Module with Node sub classes for data structures.
aiida.orm.nodes.data.
ArrayData
Bases: aiida.orm.nodes.data.data.Data
aiida.orm.nodes.data.data.Data
Store a set of arrays on disk (rather than on the database) in an efficient way using numpy.save() (therefore, this class requires numpy to be installed).
Each array is stored within the Node folder as a different .npy file.
Before storing, no caching is done: if you perform a get_array() call, the array will be re-read from disk. If instead the ArrayData node has already been stored, the array is cached in memory after the first read, and the cached array is used thereafter. If too much RAM memory is used, you can clear the cache with the clear_internal_cache() method.
get_array()
clear_internal_cache()
__abstractmethods__
__module__
_abc_impl
_arraynames_from_files
Return a list of all arrays stored in the node, listing the files (and not relying on the properties).
_arraynames_from_properties
Return a list of all arrays stored in the node, listing the attributes starting with the correct prefix.
_cached_arrays
_logger
_plugin_type_string
_query_type_string
_validate
Check if the list of .npy files stored inside the node and the list of properties match. Just a name check, no check on the size since this would require to reload all arrays and this may take time and memory.
array_prefix
clear_internal_cache
Clear the internal memory cache where the arrays are stored after being read from disk (used in order to reduce at minimum the readings from disk). This function is useful if you want to keep the node in memory, but you do not want to waste memory to cache the arrays in RAM.
delete_array
Delete an array from the node. Can only be called before storing.
name – The name of the array to delete from the node.
get_array
Return an array stored in the node
name – The name of the array to return.
get_arraynames
New in version 0.7: Renamed from arraynames
get_iterarrays
Iterator that returns tuples (name, array) for each array stored in the node.
New in version 1.0: Renamed from iterarrays
get_shape
Return the shape of an array (read from the value cached in the properties for efficiency reasons).
name – The name of the array.
initialize
Initialize internal variables for the backend node
This needs to be called explicitly in each specific subclass implementation of the init.
set_array
Store a new numpy array inside the node. Possibly overwrite the array if it already existed.
Internally, it stores a name.npy file in numpy format.
array – The numpy array to store.
BandsData
Bases: aiida.orm.nodes.data.array.kpoints.KpointsData
aiida.orm.nodes.data.array.kpoints.KpointsData
Class to handle bands data
_get_band_segments
Return the band segments.
_get_bandplot_data
Get data to plot a band structure
cartesian – if True, distances (for the x-axis) are computed in cartesian coordinates, otherwise they are computed in reciprocal coordinates. cartesian=True will fail if no cell has been set.
prettify_format – by default, strings are not prettified. If you want to prettify them, pass a valid prettify_format string (see valid options in the docstring of :py:func:prettify_labels).
join_symbols – by default, strings are not joined. If you pass a string, this is used to join strings that are much closer than a given threshold. The most typical string is the pipe symbol: |.
|
get_segments – if True, also computes the band split into segments
y_origin – if present, shift bands so to set the value specified at y=0
y=0
a plot_info dictiorary, whose keys are x (array of distances for the x axis of the plot); y (array of bands), labels (list of tuples in the format (float x value of the label, label string), band_type_idx (array containing an index for each band: if there is only one spin, then it’s an array of zeros, of length equal to the number of bands at each point; if there are two spins, then it’s an array of zeros or ones depending on the type of spin; the length is always equalt to the total number of bands per kpoint).
x
y
labels
band_type_idx
_get_mpl_body_template
paths – paths of k-points
_matplotlib_get_dict
Prepare the data to send to the python-matplotlib plotting script.
comments – if True, print comments (if it makes sense for the given format)
plot_info – a dictionary
setnumber_offset – an offset to be applied to all set numbers (i.e. s0 is replaced by s[offset], s1 by s[offset+1], etc.)
color_number – the color number for lines, symbols, error bars and filling (should be less than the parameter MAX_NUM_AGR_COLORS defined below)
title – the title
legend – the legend (applied only to the first of the set)
legend2 – the legend for second-type spins (applied only to the first of the set)
y_max_lim – the maximum on the y axis (if None, put the maximum of the bands)
y_min_lim – the minimum on the y axis (if None, put the minimum of the bands)
y_origin – the new origin of the y axis -> all bands are replaced by bands-y_origin
prettify_format – if None, use the default prettify format. Otherwise specify a string with the prettifier to use.
kwargs – additional customization variables; only a subset is accepted, see internal variable ‘valid_additional_keywords
_prepare_agr
Prepare an xmgrace agr file.
color_number2 – the color number for lines, symbols, error bars and filling for the second-type spins (should be less than the parameter MAX_NUM_AGR_COLORS defined below)
legend – the legend (applied only to the first set)
y_max_lim – the maximum on the y axis (if None, put the maximum of the bands); applied after shifting the origin by y_origin
y_origin
y_min_lim – the minimum on the y axis (if None, put the minimum of the bands); applied after shifting the origin by y_origin
_prepare_agr_batch
Prepare two files, data and batch, to be plot with xmgrace as: xmgrace -batch file.dat
main_file_name – if the user asks to write the main content on a file, this contains the filename. This should be used to infer a good filename for the additional files. In this case, we remove the extension, and add ‘_data.dat’
_prepare_dat_blocks
Format suitable for gnuplot using blocks. Columns with x and y (path and band energy). Several blocks, separated by two empty lines, one per energy band.
_prepare_dat_multicolumn
Write an N x M matrix. First column is the distance between kpoints, The other columns are the bands. Header contains number of kpoints and the number of bands (commented).
_prepare_gnuplot
Prepare an gnuplot script to plot the bands, with the .dat file returned as an independent file.
title – if specified, add a title to the plot
_prepare_json
Prepare a json file in a format compatible with the AiiDA band visualizer
_prepare_mpl_pdf
Prepare a python script using matplotlib to plot the bands, with the JSON returned as an independent file.
For the possible parameters, see documentation of _matplotlib_get_dict()
_matplotlib_get_dict()
_prepare_mpl_png
_prepare_mpl_singlefile
Prepare a python script using matplotlib to plot the bands
_prepare_mpl_withjson
_set_pbc
validate the pbc, then store them
_validate_bands_occupations
Validate the list of bands and of occupations before storage. Kpoints must be set in advance. Bands and occupations must be convertible into arrays of Nkpoints x Nbands floats or Nspins x Nkpoints x Nbands; Nkpoints must correspond to the number of kpoints.
array_labels
Get the labels associated with the band arrays
get_bands
Returns an array (nkpoints x num_bands or nspins x nkpoints x num_bands) of energies. :param also_occupations: if True, returns also the occupations array. Default = False
set_bands
Set an array of band energies of dimension (nkpoints x nbands). Kpoints must be set in advance. Can contain floats or None. :param bands: a list of nkpoints lists of nbands bands, or a 2D array of shape (nkpoints x nbands), with band energies for each kpoint :param units: optional, energy units :param occupations: optional, a 2D list or array of floats of same shape as bands, with the occupation associated to each band
set_kpointsdata
Load the kpoints from a kpoint object. :param kpointsdata: an instance of KpointsData class
show_mpl
Call a show() command for the band structure using matplotlib. This uses internally the ‘mpl_singlefile’ format, with empty main_file_name.
Other kwargs are passed to self._exportcontent.
units
Units in which the data in bands were stored. A string
BaseType
Data sub class to be used as a base for data containers that represent base python data types.
__eq__
Fallback equality comparison by uuid (can be overwritten by specific types)
__hash__
__init__
backend_entity (aiida.orm.implementation.entities.BackendEntity) – the backend model supporting this entity
aiida.orm.implementation.entities.BackendEntity
__ne__
Return self!=value.
__str__
Return str(self).
new
value
Bool
Bases: aiida.orm.nodes.data.base.BaseType
aiida.orm.nodes.data.base.BaseType
Data sub class to represent a boolean value.
__bool__
__int__
_type
alias of builtins.bool
builtins.bool
CifData
Bases: aiida.orm.nodes.data.singlefile.SinglefileData
aiida.orm.nodes.data.singlefile.SinglefileData
Wrapper for Crystallographic Interchange File (CIF)
Note
the file (physical) is held as the authoritative source of information, so all conversions are done through the physical file: when setting ase or values, a physical CIF file is generated first, the values are updated from the physical CIF file.
ase
values
_PARSE_POLICIES
_PARSE_POLICY_DEFAULT
_SCAN_TYPES
_SCAN_TYPE_DEFAULT
_SET_INCOMPATIBILITIES
Construct a new instance and set the contents to that of the file.
file – an absolute filepath or filelike object for CIF. Hint: Pass io.BytesIO(b”my string”) to construct the SinglefileData directly from a string.
filename – specify filename to use (defaults to name of provided file).
ase – ASE Atoms object to construct the CifData instance from.
values – PyCifRW CifFile object to construct the CifData instance from.
source –
scan_type – scan type string for parsing with PyCIFRW (‘standard’ or ‘flex’). See CifFile.ReadCif
parse_policy – ‘eager’ (parse CIF file on set_file) or ‘lazy’ (defer parsing until needed)
_ase
_get_object_ase
Converts CifData to ase.Atoms
an ase.Atoms object
_get_object_pycifrw
Converts CifData to PyCIFRW.CifFile
a PyCIFRW.CifFile object
_prepare_cif
Return CIF string of CifData object.
If parsed values are present, a CIF string is created and written to file. If no parsed values are present, the CIF string is read from file.
Validates MD5 hash of CIF file.
_values
ASE object, representing the CIF.
requires ASE module.
from_md5
Return a list of all CIF files that match a given MD5 hash.
the hash has to be stored in a _md5 attribute, otherwise the CIF file will not be found.
_md5
generate_md5
Computes and returns MD5 hash of the CIF file.
get_ase
Returns ASE object, representing the CIF. This function differs from the property ase by the possibility to pass the keyworded arguments (kwargs) to ase.io.cif.read_cif().
get_formulae
Return chemical formulae specified in CIF file.
Note: This does not compute the formula, it only reads it from the appropriate tag. Use refine_inline to compute formulae.
get_or_create
Pass the same parameter of the init; if a file with the same md5 is found, that CifData is returned.
filename – an absolute filename on disk
use_first – if False (default), raise an exception if more than one CIF file is found. If it is True, instead, use the first available CIF file.
store_cif (bool) – If false, the CifData objects are not stored in the database. default=True.
where cif is the CifData object, and create is either True if the object was created, or False if the object was retrieved from the DB.
get_spacegroup_numbers
Get the spacegroup international number.
get_structure
Creates aiida.orm.nodes.data.structure.StructureData.
aiida.orm.nodes.data.structure.StructureData
New in version 1.0: Renamed from _get_aiida_structure
converter – specify the converter. Default ‘pymatgen’.
store – if True, intermediate calculation gets stored in the AiiDA database for record. Default False.
primitive_cell – if True, primitive cell is returned, conventional cell if False. Default False.
occupancy_tolerance – If total occupancy of a site is between 1 and occupancy_tolerance, the occupancies will be scaled down to 1. (pymatgen only)
site_tolerance – This tolerance is used to determine if two sites are sitting in the same position, in which case they will be combined to a single disordered site. Defaults to 1e-4. (pymatgen only)
aiida.orm.nodes.data.structure.StructureData node.
has_atomic_sites
Returns whether there are any atomic sites defined in the cif data. That is to say, it will check all the values for the _atom_site_fract_* tags and if they are all equal to ? that means there are no relevant atomic sites defined and the function will return False. In all other cases the function will return True
False when at least one atomic site fractional coordinate is not equal to ? and True otherwise
has_attached_hydrogens
Check if there are hydrogens without coordinates, specified as attached to the atoms of the structure.
True if there are attached hydrogens, False otherwise.
has_partial_occupancies
Return if the cif data contains partial occupancies
A partial occupancy is defined as site with an occupancy that differs from unity, within a precision of 1E-6
True if there are partial occupancies, False otherwise
has_undefined_atomic_sites
Return whether the cif data contains any undefined atomic sites.
An undefined atomic site is defined as a site where at least one of the fractional coordinates specified in the _atom_site_fract_* tags, cannot be successfully interpreted as a float. If the cif data contains any site that matches this description, or it does not contain any atomic site tags at all, the cif data is said to have undefined atomic sites.
boolean, True if no atomic sites are defined or if any of the defined sites contain undefined positions and False otherwise
has_unknown_species
Returns whether the cif contains atomic species that are not recognized by AiiDA.
The known species are taken from the elements dictionary in aiida.common.constants, with the exception of the “unknown” placeholder element with symbol ‘X’, as this could not be used to construct a real structure. If any of the formula of the cif data contain species that are not in that elements dictionary, the function will return True and False in all other cases. If there is no formulae to be found, it will return None
True when there are unknown species in any of the formulae, False if not, None if no formula found
parse
Parses CIF file and sets attributes.
scan_type – See set_scan_type
read_cif
A wrapper method that simulates the behavior of the old function ase.io.cif.read_cif by using the new generic ase.io.read function.
Somewhere from 3.12 to 3.17 the tag concept was bundled with each Atom object. When reading a CIF file, this is incremented and signifies the atomic species, even though the CIF file do not have specific tags embedded. On reading CIF files we thus force the ASE tag to zero for all Atom elements.
set_ase
Set the contents of the CifData starting from an ASE atoms object
aseatoms – the ASE atoms object
set_file
Set the file.
If the source is set and the MD5 checksum of new file is different from the source, the source has to be deleted.
file – filepath or filelike object of the CIF file to store. Hint: Pass io.BytesIO(b”my string”) to construct the file directly from a string.
set_parse_policy
Set the parse policy.
parse_policy – Either ‘eager’ (parse CIF file on set_file) or ‘lazy’ (defer parsing until needed)
set_scan_type
Set the scan_type for PyCifRW.
The ‘flex’ scan_type of PyCifRW is faster for large CIF files but does not yet support the CIF2 format as of 02/2018. See the CifFile.ReadCif function
scan_type – Either ‘standard’ or ‘flex’ (see _scan_types)
set_values
Set internal representation to values.
Warning: This also writes a new CIF file.
values – PyCifRW CifFile object
requires PyCifRW module.
store
Store the node.
PyCifRW structure, representing the CIF datablocks.
Code
A code entity. It can either be ‘local’, or ‘remote’.
Local code: it is a collection of files/dirs (added using the add_path() method), where one file is flagged as executable (using the set_local_executable() method).
Remote code: it is a pair (remotecomputer, remotepath_of_executable) set using the set_remote_computer_exec() method.
For both codes, one can set some code to be executed right before or right after the execution of the code, using the set_preexec_code() and set_postexec_code() methods (e.g., the set_preexec_code() can be used to load specific modules required for the code to be run).
HIDDEN_KEY
_set_local
Set the code as a ‘local’ code, meaning that all the files belonging to the code will be copied to the cluster, and the file set with set_exec_filename will be run.
It also deletes the flags related to the local case (if any)
_set_remote
Set the code as a ‘remote’ code, meaning that the code itself has no files attached, but only a location on a remote computer (with an absolute path of the executable on the remote computer).
Perform validation of the Data object.
validation of data source checks license and requires attribution to be provided in field ‘description’ of source in the case of any CC-BY* license. If such requirement is too strict, one can remove/comment it out.
can_run_on
Return True if this code can run on the given computer, False otherwise.
Local codes can run on any machine; remote codes can run only on the machine on which they reside.
TODO: add filters to mask the remote machines on which a local code can run.
full_label
Get full label of this code.
Returns label of the form <code-label>@<computer-name>.
get
Get a Computer object with given identifier string, that can either be the numeric ID (pk), or the label (and computername) (if unique).
pk – the numeric ID (pk) for code
label – the code label identifying the code to load
machinename – the machine name where code is setup
aiida.common.NotExistent – if no code identified by the given string is found
aiida.common.MultipleObjectsError – if the string cannot identify uniquely a code
aiida.common.InputValidationError – if neither a pk nor a label was passed in
get_append_text
Return the postexec_code, or an empty string if no post-exec code was defined.
get_builder
Create and return a new ProcessBuilder for the CalcJob class of the plugin configured for this code.
The configured calculation plugin class is defined by the get_input_plugin_name method.
it also sets the builder.code value.
builder.code
a ProcessBuilder instance with the code input already populated with ourselves
aiida.common.EntryPointError – if the specified plugin does not exist.
ValueError – if no default plugin was specified.
get_code_helper
get_computer_label
Get label of this code’s computer.
get_computer_name
Deprecated since version 1.4.0: Will be removed in v2.0.0, use the self.get_computer_label() method instead.
get_description
Return a string description of this Code instance.
string description of this Code instance
get_execname
Return the executable string to be put in the script. For local codes, it is ./LOCAL_EXECUTABLE_NAME For remote codes, it is the absolute path to the executable.
get_from_string
Get a Computer object with given identifier string in the format label@machinename. See the note below for details on the string detection algorithm.
the (leftmost) ‘@’ symbol is always used to split code and computername. Therefore do not use ‘@’ in the code name if you want to use this function (‘@’ in the computer name are instead valid).
code_string – the code string identifying the code to load
aiida.common.InputValidationError – if code_string is not of string type
get_full_text_info
Return a list of lists with a human-readable detailed information on this code.
Deprecated since version 1.4.0: Will be removed in v2.0.0.
list of lists where each entry consists of two elements: a key and a value
get_input_plugin_name
Return the name of the default input plugin (or None if no input plugin was set.
get_local_executable
get_prepend_text
Return the code that will be put in the scheduler script before the execution, or an empty string if no pre-exec code was defined.
get_remote_computer
get_remote_exec_path
hidden
Determines whether the Code is hidden or not
hide
Hide the code (prevents from showing it in the verdi code list)
is_local
Return True if the code is ‘local’, False if it is ‘remote’ (see also documentation of the set_local and set_remote functions).
label
Return the node label.
the label
list_for_plugin
Return a list of valid code strings for a given plugin.
plugin – The string of the plugin.
labels – if True, return a list of code names, otherwise return the code PKs (integers).
a list of string, with the code names if labels is True, otherwise a list of integers with the code PKs.
relabel
Relabel this code.
new_label – new code label
raise_error – Set to False in order to return a list of errors instead of raising them.
Deprecated since version 1.2.0: Will remove raise_error in v2.0.0. Use try/except instead.
reveal
Reveal the code (allows to show it in the verdi code list) By default, it is revealed
set_append_text
Pass a string of code that will be put in the scheduler script after the execution of the code.
set_files
Given a list of filenames (or a single filename string), add it to the path (all at level zero, i.e. without folders). Therefore, be careful for files with the same name!
decide whether to check if the Code must be a local executable to be able to call this function.
set_input_plugin_name
Set the name of the default input plugin, to be used for the automatic generation of a new calculation.
set_local_executable
Set the filename of the local executable. Implicitly set the code as local.
set_prepend_text
Pass a string of code that will be put in the scheduler script before the execution of the code.
set_remote_computer_exec
Set the code as remote, and pass the computer on which it resides and the absolute path on that computer.
remote_computer_exec – a tuple (computer, remote_exec_path), where computer is a aiida.orm.Computer and remote_exec_path is the absolute path of the main executable on remote computer.
Data
Bases: aiida.orm.nodes.node.Node
aiida.orm.nodes.node.Node
The base class for all Data nodes.
AiiDA Data classes are subclasses of Node and must support multiple inheritance.
Architecture note: Calculation plugins are responsible for converting raw output data from simulation codes to Data nodes. Data nodes are responsible for validating their content (see _validate method).
__copy__
Copying a Data node is not supported, use copy.deepcopy or call Data.clone().
__deepcopy__
Create a clone of the Data node by pipiong through to the clone method and return the result.
an unstored clone of this Data node
_export_format_replacements
_exportcontent
Converts a Data node to one (or multiple) files.
Note: Export plugins should return utf8-encoded bytes, which can be directly dumped to file.
fileformat (str) – the extension, uniquely specifying the file format.
main_file_name (str) – (empty by default) Can be used by plugin to infer sensible names for additional files, if necessary. E.g. if the main file is ‘../myplot.gnu’, the plugin may decide to store the dat file under ‘../myplot_data.dat’.
kwargs – other parameters are passed down to the plugin
a tuple of length 2. The first element is the content of the otuput file. The second is a dictionary (possibly empty) in the format {filename: filecontent} for any additional file that should be produced.
(bytes, dict)
_get_converters
Get all implemented converter formats. The convention is to find all _get_object_… methods. Returns a list of strings.
_get_exporters
Get all implemented export formats. The convention is to find all _prepare_… methods. Returns a dictionary of method_name: method_function
_get_importers
Get all implemented import formats. The convention is to find all _parse_… methods. Returns a list of strings.
_source_attributes
_storable
_unstorable_message
clone
Create a clone of the Data node.
convert
Convert the AiiDA StructureData into another python object
object_format – Specify the output format
creator
Return the creator of this node or None if it does not exist.
the creating node or None
export
Save a Data object to a file.
fname – string with file name. Can be an absolute or relative path.
fileformat – kind of format to use for the export. If not present, it will try to use the extension of the file name.
overwrite – if set to True, overwrites file found at path. Default=False
kwargs – additional parameters to be passed to the _exportcontent method
the list of files created
get_export_formats
Get the list of valid export format strings
a list of valid formats
importfile
Populate a Data object from a file.
importstring
Converts a Data object to other text format.
fileformat – a string (the extension) to describe the file format.
a string with the structure description.
set_source
Sets the dictionary describing the source of Data object.
source
Gets the dictionary describing the source of Data object. Possible fields:
db_name: name of the source database.
db_uri: URI of the source database.
uri: URI of the object’s source. Should be a permanent link.
id: object’s source identifier in the source database.
version: version of the object’s source.
extras: a dictionary with other fields for source description.
source_md5: MD5 checksum of object’s source.
description: human-readable free form description of the object’s source.
license: a string with a type of license.
some limitations for setting the data source exist, see _validate method.
dictionary describing the source of Data object.
Dict
Data sub class to represent a dictionary.
The dictionary contents of a Dict node are stored in the database as attributes. The dictionary can be initialized through the dict argument in the constructor. After construction, values can be retrieved and updated through the item getters and setters, respectively:
node[‘key’] = ‘value’
Alternatively, the dict property returns an instance of the AttributeManager that can be used to get and set values through attribute notation:
node.dict.key = ‘value’
Note that trying to set dictionary values directly on the node, e.g. node.key = value, will not work as intended. It will merely set the key attribute on the node instance, but will not be stored in the database. As soon as the node goes out of scope, the value will be lost.
It is also relevant to note here the difference in something being an “attribute of a node” (in the sense that it is stored in the “attribute” column of the database when the node is stored) and something being an “attribute of a python object” (in the sense of being able to modify and access it as if it was a property of the variable, e.g. node.key = value). This is true of all types of nodes, but it becomes more relevant for Dict nodes where one is constantly manipulating these attributes.
Finally, all dictionary mutations will be forbidden once the node is stored.
__getitem__
Store a dictionary as a Node instance.
Usual rules for attribute names apply, in particular, keys cannot start with an underscore, or a ValueError will be raised.
Initial attributes can be changed, deleted or added as long as the node is not stored.
dict – the dictionary to set
__setitem__
dict
Return an instance of AttributeManager that transforms the dictionary into an attribute dict.
this will allow one to do node.dict.key as well as node.dict[key].
an instance of the AttributeResultManager.
get_dict
Return a dictionary with the parameters currently set.
dictionary
keys
Iterator of valid keys stored in the Dict object.
iterator over the keys of the current dictionary
set_dict
Replace the current dictionary with another one.
dictionary – dictionary to set
update_dict
Update the current dictionary with the keys provided in the dictionary.
works exactly as dict.update() where new keys are simply added and existing keys are overwritten.
dictionary – a dictionary with the keys to substitute
Float
Bases: aiida.orm.nodes.data.numeric.NumericType
aiida.orm.nodes.data.numeric.NumericType
Data sub class to represent a float value.
alias of builtins.float
builtins.float
FolderData
Data sub class to represent a folder on a file system.
Construct a new FolderData to which any files and folders can be added.
Use the tree keyword to simply wrap a directory:
folder = FolderData(tree=’/absolute/path/to/directory’)
Alternatively, one can construct the node first and then use the various repository methods to add objects:
folder = FolderData() folder.put_object_from_tree(‘/absolute/path/to/directory’) folder.put_object_from_filepath(‘/absolute/path/to/file.txt’) folder.put_object_from_filelike(filelike_object)
tree (str) – absolute path to a folder to wrap
Int
Data sub class to represent an integer value.
alias of builtins.int
builtins.int
KpointsData
Bases: aiida.orm.nodes.data.array.array.ArrayData
aiida.orm.nodes.data.array.array.ArrayData
Class to handle array of kpoints in the Brillouin zone. Provide methods to generate either user-defined k-points or path of k-points along symmetry lines. Internally, all k-points are defined in terms of crystal (fractional) coordinates. Cell and lattice vector coordinates are in Angstroms, reciprocal lattice vectors in Angstrom^-1 . :note: The methods setting and using the Bravais lattice info assume the PRIMITIVE unit cell is provided in input to the set_cell or set_cell_from_structure methods.
_change_reference
Change reference system, from cartesian to crystal coordinates (units of b1,b2,b3) or viceversa. :param kpoints: a list of (3) point coordinates :return kpoints: a list of (3) point coordinates in the new reference
_dimension
Dimensionality of the structure, found from its pbc (i.e. 1 if it’s a 1D structure, 2 if its 2D, 3 if it’s 3D …). :return dimensionality: 0, 1, 2 or 3 :note: will return 3 if pbc has not been set beforehand
_set_cell
Validate if ‘value’ is a allowed crystal unit cell :param value: something compatible with a 3x3 tuple of floats
_set_labels
set label names. Must pass in input a list like: [[0,'X'],[34,'L'],... ]
[[0,'X'],[34,'L'],... ]
_validate_kpoints_weights
Validate the list of kpoints and of weights before storage. Kpoints and weights must be convertible respectively to an array of N x dimension and N floats
cell
The crystal unit cell. Rows are the crystal vectors in Angstroms. :return: a 3x3 numpy.array
Returns a string with infos retrieved from kpoints node’s properties. :param node: :return: retstr
get_kpoints
Return the list of kpoints
also_weights – if True, returns also the list of weights. Default = False
cartesian – if True, returns points in cartesian coordinates, otherwise, returns in crystal coordinates. Default = False.
get_kpoints_mesh
Get the mesh of kpoints.
print_list – default=False. If True, prints the mesh of kpoints as a list
AttributeError – if no mesh has been set
(if print_list=False) a list of 3 integers and a list of three floats 0<x<1, representing the mesh and the offset of kpoints
(if print_list = True) an explicit list of kpoints coordinates, similar to what returned by get_kpoints()
Labels associated with the list of kpoints. List of tuples with kpoint index and kpoint name: [(0,'G'),(13,'M'),...]
[(0,'G'),(13,'M'),...]
pbc
The periodic boundary conditions along the vectors a1,a2,a3.
a tuple of three booleans, each one tells if there are periodic boundary conditions for the i-th real-space direction (i=1,2,3)
reciprocal_cell
Compute reciprocal cell from the internally set cell.
reciprocal cell in units of 1/Angstrom with cell vectors stored as rows. Use e.g. reciprocal_cell[0] to access the first reciprocal cell vector.
set_cell
Set a cell to be used for symmetry analysis. To set a cell from an AiiDA structure, use “set_cell_from_structure”.
cell – 3x3 matrix of cell vectors. Orientation: each row represent a lattice vector. Units are Angstroms.
pbc – list of 3 booleans, True if in the nth crystal direction the structure is periodic. Default = [True,True,True]
set_cell_from_structure
Set a cell to be used for symmetry analysis from an AiiDA structure. Inherits both the cell and the pbc’s. To set manually a cell, use “set_cell”
structuredata – an instance of StructureData
set_kpoints
Set the list of kpoints. If a mesh has already been stored, raise a ModificationNotAllowed
kpoints –
a list of kpoints, each kpoint being a list of one, two or three coordinates, depending on self.pbc: if structure is 1D (only one True in self.pbc) one allows singletons or scalars for each k-point, if it’s 2D it can be a length-2 list, and in all cases it can be a length-3 list. Examples:
[[0.,0.,0.],[0.1,0.1,0.1],…] for 1D, 2D or 3D [[0.,0.],[0.1,0.1,],…] for 1D or 2D [[0.],[0.1],…] for 1D [0., 0.1, …] for 1D (list of scalars)
[[0.,0.,0.],[0.1,0.1,0.1],…] for 1D, 2D or 3D
[[0.,0.],[0.1,0.1,],…] for 1D or 2D
[[0.],[0.1],…] for 1D
[0., 0.1, …] for 1D (list of scalars)
For 0D (all pbc are False), the list can be any of the above or empty - then only Gamma point is set. The value of k for the non-periodic dimension(s) is set by fill_values
cartesian – if True, the coordinates given in input are treated as in cartesian units. If False, the coordinates are crystal, i.e. in units of b1,b2,b3. Default = False
labels – optional, the list of labels to be set for some of the kpoints. See labels for more info
weights – optional, a list of floats with the weight associated to the kpoint list
fill_values – scalar to be set to all non-periodic dimensions (indicated by False in self.pbc), or list of values for each of the non-periodic dimensions.
set_kpoints_mesh
Set KpointsData to represent a uniformily spaced mesh of kpoints in the Brillouin zone. This excludes the possibility of set/get kpoints
mesh – a list of three integers, representing the size of the kpoint mesh along b1,b2,b3.
offset – (optional) a list of three floats between 0 and 1. [0.,0.,0.] is Gamma centered mesh [0.5,0.5,0.5] is half shifted [1.,1.,1.] by periodicity should be equivalent to [0.,0.,0.] Default = [0.,0.,0.].
set_kpoints_mesh_from_density
Set a kpoints mesh using a kpoints density, expressed as the maximum distance between adjacent points along a reciprocal axis
distance – distance (in 1/Angstrom) between adjacent kpoints, i.e. the number of kpoints along each reciprocal axis i is \(|b_i|/distance\) where \(|b_i|\) is the norm of the reciprocal cell vector.
offset – (optional) a list of three floats between 0 and 1. [0.,0.,0.] is Gamma centered mesh [0.5,0.5,0.5] is half shifted Default = [0.,0.,0.].
force_parity – (optional) if True, force each integer in the mesh to be even (except for the non-periodic directions).
a cell should be defined first.
the number of kpoints along non-periodic axes is always 1.
List
Bases: aiida.orm.nodes.data.data.Data, collections.abc.MutableSequence
collections.abc.MutableSequence
Data sub class to represent a list.
_LIST_KEY
__delitem__
__len__
_using_list_reference
This function tells the class if we are using a list reference. This means that calls to self.get_list return a reference rather than a copy of the underlying list and therefore self.set_list need not be called. This knwoledge is essential to make sure this class is performant.
Currently the implementation assumes that if the node needs to be stored then it is using the attributes cache which is a reference.
True if using self.get_list returns a reference to the underlying sequence. False otherwise.
bool
append
S.append(value) – append value to the end of the sequence
count
Return number of occurrences of value.
extend
S.extend(iterable) – extend sequence by appending elements from the iterable
get_list
Return the contents of this node.
a list
index
Return first index of value..
insert
S.insert(index, value) – insert value before index
pop
Remove and return item at index (default last).
remove
S.remove(value) – remove first occurrence of value. Raise ValueError if the value is not present.
reverse
S.reverse() – reverse IN PLACE
set_list
Set the contents of this node.
data – the list to set
sort
NumericType
Sub class of Data to store numbers, overloading common operators (+, *, …).
+
*
__add__
Decorator wrapper.
__div__
__float__
__floordiv__
__ge__
__gt__
__le__
__lt__
__mod__
__mul__
__pow__
__radd__
__rdiv__
__rfloordiv__
__rmod__
__rmul__
__rsub__
__rtruediv__
__sub__
__truediv__
OrbitalData
Used for storing collections of orbitals, as well as providing methods for accessing them internally.
clear_orbitals
Remove all orbitals that were added to the class Cannot work if OrbitalData has been already stored
get_orbitals
Returns all orbitals by default. If a site is provided, returns all orbitals cooresponding to the location of that site, additional arguments may be provided, which act as filters on the retrieved orbitals.
site – if provided, returns all orbitals with position of site
attributes than can filter the set of returned orbitals
a list of orbitals
set_orbitals
Sets the orbitals into the database. Uses the orbital’s inherent set_orbital_dict method to generate a orbital dict string.
orbital – an orbital or list of orbitals to be set
ProjectionData
Bases: aiida.orm.nodes.data.orbital.OrbitalData, aiida.orm.nodes.data.array.array.ArrayData
aiida.orm.nodes.data.orbital.OrbitalData
A class to handle arrays of projected wavefunction data. That is projections of a orbitals, usually an atomic-hydrogen orbital, onto a given bloch wavefunction, the bloch wavefunction being indexed by s, n, and k. E.g. the elements are the projections described as < orbital | Bloch wavefunction (s,n,k) >
_check_projections_bands
Checks to make sure that a reference bandsdata is already set, and that projection_array is of the same shape of the bands data
projwfc_arrays – nk x nb x nwfc array, to be checked against bands
AttributeError if energy is not already set
AttributeError if input_array is not of same shape as dos_energy
_find_orbitals_and_indices
Finds all the orbitals and their indicies associated with kwargs essential for retrieving the other indexed array parameters
kwargs – kwargs that can call orbitals as in get_orbitals()
retrieve_indexes, list of indicicies of orbitals corresponding to the kwargs
all_orbitals, list of orbitals to which the indexes correspond
_from_index_to_arrayname
Used internally to determine the array names.
get_pdos
Retrieves all the pdos arrays corresponding to the input kwargs
kwargs – inputs describing the orbitals associated with the pdos arrays
a list of tuples containing the orbital, energy array and pdos array associated with all orbitals that correspond to kwargs
get_projections
a list of tuples containing the orbital, and projection arrays associated with all orbitals that correspond to kwargs
get_reference_bandsdata
Returns the reference BandsData, using the set uuid via set_reference_bandsdata
a BandsData instance
AttributeError – if the bandsdata has not been set yet
exceptions.NotExistent – if the bandsdata uuid did not retrieve bandsdata
This method is inherited from OrbitalData, but is blocked here. If used will raise a NotImplementedError
set_projectiondata
Stores the projwfc_array using the projwfc_label, after validating both.
list_of_orbitals – list of orbitals, of class orbital data. They should be the ones up on which the projection array corresponds with.
list_of_projections – list of arrays of projections of a atomic wavefunctions onto bloch wavefunctions. Since the projection is for every bloch wavefunction which can be specified by its spin (if used), band, and kpoint the dimensions must be nspin x nbands x nkpoints for the projwfc array. Or nbands x nkpoints if spin is not used.
energy_axis – list of energy axis for the list_of_pdos
list_of_pdos – a list of projected density of states for the atomic wavefunctions, units in states/eV
tags – A list of tags, not supported currently.
bands_check – if false, skips checks of whether the bands has been already set, and whether the sizes match. For use in parsers, where the BandsData has not yet been stored and therefore get_reference_bandsdata cannot be called
set_reference_bandsdata
Sets a reference bandsdata, creates a uuid link between this data object and a bandsdata object, must be set before any projection arrays
value – a BandsData instance, a uuid or a pk
exceptions.NotExistent if there was no BandsData associated with uuid or pk
RemoteData
Store a link to a file or folder on a remote machine.
Remember to pass a computer!
_clean
Remove all content of the remote folder on the remote computer
get_authinfo
Get label of this node’s computer.
Deprecated since version 1.4.0: Will be removed in v2.0.0, use the self.computer.label property instead.
get_remote_path
getfile
Connects to the remote folder and retrieves the content of a file.
relpath – The relative path of the file on the remote to retrieve.
destpath – The absolute path of where to store the file on the local machine.
is_empty
Check if remote folder is empty
listdir
Connects to the remote folder and lists the directory content.
relpath – If ‘relpath’ is specified, lists the content of the given subfolder.
a flat list of file/directory names (as strings).
listdir_withattributes
a list of dictionaries, where the documentation is in :py:class:Transport.listdir_withattributes.
set_remote_path
RemoteStashData
Data plugin that models an archived folder on a remote computer.
A stashed folder is essentially an instance of RemoteData that has been archived. Archiving in this context can simply mean copying the content of the folder to another location on the same or another filesystem as long as it is on the same machine. In addition, the folder may have been compressed into a single file for efficiency or even written to tape. The stash_mode attribute will distinguish how the folder was stashed which will allow the implementation to also unstash it and transform it back into a RemoteData such that it can be used as an input for new CalcJobs.
stash_mode
CalcJobs
This class is a non-storable base class that merely registers the stash_mode attribute. Only its subclasses, that actually implement a certain stash mode, can be instantiated and therefore stored. The reason for this design is that because the behavior of the class can change significantly based on the mode employed to stash the files and implementing all these variants in the same class will lead to an unintuitive interface where certain properties or methods of the class will only be available or function properly based on the stash_mode.
Construct a new instance
stash_mode – the stashing mode with which the data was stashed on the remote.
Return the mode with which the data was stashed on the remote.
the stash mode.
RemoteStashFolderData
Bases: aiida.orm.nodes.data.remote.stash.base.RemoteStashData
aiida.orm.nodes.data.remote.stash.base.RemoteStashData
Data plugin that models a folder with files of a completed calculation job that has been stashed through a copy.
This data plugin can and should be used to stash files if and only if the stash mode is StashMode.COPY.
target_basepath – the target basepath.
source_list – the list of source files.
source_list
Return the list of source files that were stashed.
the list of source files.
target_basepath
Return the target basepath.
the target basepath.
SinglefileData
Data class that can be used to store a single file in its repository.
DEFAULT_FILENAME
file – an absolute filepath or filelike object whose contents to copy. Hint: Pass io.BytesIO(b”my string”) to construct the SinglefileData directly from a string.
Ensure that there is one object stored in the repository, whose key matches value set for filename attr.
filename
Return the name of the file stored.
the filename under which the file is stored in the repository
get_content
Return the content of the single file stored for this data node.
the content of the file as a string
open
Return an open file handle to the content of this data node.
Deprecated since version 1.4.0: Keyword key is deprecated and will be removed in v2.0.0. Use path instead.
Deprecated since version 1.4.0: Starting from v2.0.0 this will raise if not used in a context manager.
path – the relative path of the object within the repository.
key – optional key within the repository, by default is the filename set in the attributes
mode – the mode with which to open the file handle (default: read mode)
a file handle
Store the content of the file in the node’s repository, deleting any other existing objects.
file – an absolute filepath or filelike object whose contents to copy Hint: Pass io.BytesIO(b”my string”) to construct the file directly from a string.
Str
Data sub class to represent a string value.
alias of builtins.str
builtins.str
StructureData
This class contains the information about a given structure, i.e. a collection of sites together with a cell, the boundary conditions (whether they are periodic or not) and other related useful information.
_adjust_default_cell
If the structure was imported from an xyz file, it lacks a defined cell, and the default cell is taken ([[1,0,0], [0,1,0], [0,0,1]]), leading to an unphysical definition of the structure. This method will adjust the cell
_dimensionality_label
Converts StructureData to ase.Atoms
_get_object_phonopyatoms
Converts StructureData to PhonopyAtoms
a PhonopyAtoms object
_get_object_pymatgen
Converts StructureData to pymatgen object
a pymatgen Structure for structures with periodic boundary conditions (in three dimensions) and Molecule otherwise
Requires the pymatgen module (version >= 3.0.13, usage of earlier versions may cause errors).
_get_object_pymatgen_molecule
Converts StructureData to pymatgen Molecule object
a pymatgen Molecule object corresponding to this StructureData object.
Requires the pymatgen module (version >= 3.0.13, usage of earlier versions may cause errors)
_get_object_pymatgen_structure
Converts StructureData to pymatgen Structure object :param add_spin: True to add the spins to the pymatgen structure. Default is False (no spin added).
The spins are set according to the following rule:
if the kind name ends with 1 -> spin=+1
if the kind name ends with 2 -> spin=-1
a pymatgen Structure object corresponding to this StructureData object
ValueError – if periodic boundary conditions does not hold in at least one dimension of real space; if there are partial occupancies together with spins (defined by kind names ending with ‘1’ or ‘2’).
_internal_kind_tags
_parse_xyz
Read the structure from a string of format XYZ.
_prepare_chemdoodle
Write the given structure to a string of format required by ChemDoodle.
Write the given structure to a string of format CIF.
_prepare_xsf
Write the given structure to a string of format XSF (for XCrySDen).
_prepare_xyz
Write the given structure to a string of format XYZ.
_set_incompatibilities
Performs some standard validation tests.
append_atom
Append an atom to the Structure, taking care of creating the corresponding kind.
ase – the ase Atom object from which we want to create a new atom (if present, this must be the only parameter)
position – the position of the atom (three numbers in angstrom)
symbols – passed to the constructor of the Kind object.
weights – passed to the constructor of the Kind object.
name – passed to the constructor of the Kind object. See also the note below.
Note on the ‘name’ parameter (that is, the name of the kind):
if specified, no checks are done on existing species. Simply, a new kind with that name is created. If there is a name clash, a check is done: if the kinds are identical, no error is issued; otherwise, an error is issued because you are trying to store two different kinds with the same name.
if not specified, the name is automatically generated. Before adding the kind, a check is done. If other species with the same properties already exist, no new kinds are created, but the site is added to the existing (identical) kind. (Actually, the first kind that is encountered). Otherwise, the name is made unique first, by adding to the string containing the list of chemical symbols a number starting from 1, until an unique name is found
checks of equality of species are done using the compare_with() method.
compare_with()
append_kind
Append a kind to the StructureData. It makes a copy of the kind.
kind – the site to append, must be a Kind object.
append_site
Append a site to the StructureData. It makes a copy of the site.
site – the site to append. It must be a Site object.
Returns the cell shape.
a 3x3 list of lists.
cell_angles
Get the angles between the cell lattice vectors in degrees.
cell_lengths
Get the lengths of cell lattice vectors in angstroms.
clear_kinds
Removes all kinds for the StructureData object.
Also clear all sites!
clear_sites
Removes all sites for the StructureData object.
Get the ASE object. Requires to be able to import ase.
an ASE object corresponding to this StructureData object.
If any site is an alloy or has vacancies, a ValueError is raised (from the site.get_ase() routine).
get_cell_volume
Returns the cell volume in Angstrom^3.
a float.
get_cif
Creates aiida.orm.nodes.data.cif.CifData.
aiida.orm.nodes.data.cif.CifData
New in version 1.0: Renamed from _get_cif
converter – specify the converter. Default ‘ase’.
store – If True, intermediate calculation gets stored in the AiiDA database for record. Default False.
aiida.orm.nodes.data.cif.CifData node.
get_composition
Returns the chemical composition of this structure as a dictionary, where each key is the kind symbol (e.g. H, Li, Ba), and each value is the number of occurences of that element in this structure. For BaZrO3 it would return {‘Ba’:1, ‘Zr’:1, ‘O’:3}. No reduction with smallest common divisor!
a dictionary with the composition
Returns a string with infos retrieved from StructureData node’s properties
self – the StructureData node
retsrt: the description string
get_dimensionality
This function checks the dimensionality of the structure and calculates its length/surface/volume :return: returns the dimensionality and length/surface/volume
get_formula
Return a string with the chemical formula.
mode –
a string to specify how to generate the formula, can assume one of the following values:
’hill’ (default): count the number of atoms of each species, then use Hill notation, i.e. alphabetical order with C and H first if one or several C atom(s) is (are) present, e.g. ['C','H','H','H','O','C','H','H','H'] will return 'C2H6O' ['S','O','O','H','O','H','O'] will return 'H2O4S' From E. A. Hill, J. Am. Chem. Soc., 22 (8), pp 478–494 (1900)
['C','H','H','H','O','C','H','H','H']
'C2H6O'
['S','O','O','H','O','H','O']
'H2O4S'
’hill_compact’: same as hill but the number of atoms for each species is divided by the greatest common divisor of all of them, e.g. ['C','H','H','H','O','C','H','H','H','O','O','O'] will return 'CH3O2'
['C','H','H','H','O','C','H','H','H','O','O','O']
'CH3O2'
’reduce’: group repeated symbols e.g. ['Ba', 'Ti', 'O', 'O', 'O', 'Ba', 'Ti', 'O', 'O', 'O', 'Ba', 'Ti', 'Ti', 'O', 'O', 'O'] will return 'BaTiO3BaTiO3BaTi2O3'
['Ba', 'Ti', 'O', 'O', 'O', 'Ba', 'Ti', 'O', 'O', 'O', 'Ba', 'Ti', 'Ti', 'O', 'O', 'O']
'BaTiO3BaTiO3BaTi2O3'
’group’: will try to group as much as possible parts of the formula e.g. ['Ba', 'Ti', 'O', 'O', 'O', 'Ba', 'Ti', 'O', 'O', 'O', 'Ba', 'Ti', 'Ti', 'O', 'O', 'O'] will return '(BaTiO3)2BaTi2O3'
'(BaTiO3)2BaTi2O3'
’count’: same as hill (i.e. one just counts the number of atoms of each species) without the re-ordering (take the order of the atomic sites), e.g. ['Ba', 'Ti', 'O', 'O', 'O','Ba', 'Ti', 'O', 'O', 'O'] will return 'Ba2Ti2O6'
['Ba', 'Ti', 'O', 'O', 'O','Ba', 'Ti', 'O', 'O', 'O']
'Ba2Ti2O6'
’count_compact’: same as count but the number of atoms for each species is divided by the greatest common divisor of all of them, e.g. ['Ba', 'Ti', 'O', 'O', 'O','Ba', 'Ti', 'O', 'O', 'O'] will return 'BaTiO3'
'BaTiO3'
separator – a string used to concatenate symbols. Default empty.
a string with the formula
in modes reduce, group, count and count_compact, the initial order in which the atoms were appended by the user is used to group and/or order the symbols in the formula
get_kind
Return the kind object associated with the given kind name.
kind_name – String, the name of the kind you want to get
The Kind object associated with the given kind_name, if a Kind with the given name is present in the structure.
ValueError if the kind_name is not present.
get_kind_names
Return a list of kind names (in the same order of the self.kinds property, but return the names rather than Kind objects)
self.kinds
This is NOT necessarily a list of chemical symbols! Use get_symbols_set for chemical symbols
a list of strings.
get_pymatgen
Get pymatgen object. Returns Structure for structures with periodic boundary conditions (in three dimensions) and Molecule otherwise. :param add_spin: True to add the spins to the pymatgen structure. Default is False (no spin added).
get_pymatgen_molecule
Get the pymatgen Molecule object.
get_pymatgen_structure
Get the pymatgen Structure object. :param add_spin: True to add the spins to the pymatgen structure. Default is False (no spin added).
a pymatgen Structure object corresponding to this StructureData object.
ValueError – if periodic boundary conditions do not hold in at least one dimension of real space.
get_site_kindnames
Return a list with length equal to the number of sites of this structure, where each element of the list is the kind name of the corresponding site.
This is NOT necessarily a list of chemical symbols! Use [ self.get_kind(s.kind_name).get_symbols_string() for s in self.sites] for chemical symbols
[ self.get_kind(s.kind_name).get_symbols_string() for s in self.sites]
a list of strings
get_symbols_set
Return a set containing the names of all elements involved in this structure (i.e., for it joins the list of symbols for each kind k in the structure).
a set of strings of element names.
has_vacancies
Return whether the structure has vacancies in the structure.
a boolean, True if at least one kind has a vacancy
is_alloy
Return whether the structure contains any alloy kinds.
a boolean, True if at least one kind is an alloy
kinds
Returns a list of kinds.
Get the periodic boundary conditions.
reset_cell
Reset the cell of a structure not yet stored to a new value.
new_cell – list specifying the cell vectors
ModificationNotAllowed: if object is already stored
reset_sites_positions
Replace all the Site positions attached to the Structure
new_positions – list of (3D) positions for every sites.
conserve_particle – if True, allows the possibility of removing a site. currently not implemented.
aiida.common.ModificationNotAllowed – if object is stored already
ValueError – if positions are invalid
it is assumed that the order of the new_positions is given in the same order of the one it’s substituting, i.e. the kind of the site will not be checked.
Load the structure from a ASE object
Set the cell.
set_cell_angles
set_cell_lengths
set_pbc
Set the periodic boundary conditions.
set_pymatgen
Load the structure from a pymatgen object.
set_pymatgen_molecule
Load the structure from a pymatgen Molecule object.
margin – the margin to be added in all directions of the bounding box of the molecule.
set_pymatgen_structure
Load the structure from a pymatgen Structure object.
periodic boundary conditions are set to True in all three directions.
Requires the pymatgen module (version >= 3.3.5, usage of earlier versions may cause errors).
ValueError – if there are partial occupancies together with spins.
sites
Returns a list of sites.
TrajectoryData
Stores a trajectory (a sequence of crystal structures with timestamps, and possibly with velocities).
_internal_validate
Internal function to validate the type and shape of the arrays. See the documentation of py:meth:.set_trajectory for a description of the valid shape and type of the parameters.
_parse_xyz_pos
Load positions from a XYZ file.
The steps and symbols must be set manually before calling this import function as a consistency measure. Even though the symbols and steps could be extracted from the XYZ file, the data present in the XYZ file may or may not be correct and the same logic would have to be present in the XYZ-velocities function. It was therefore decided not to implement it at all but require it to be set explicitly.
Usage:
from aiida.orm.nodes.data.array.trajectory import TrajectoryData t = TrajectoryData() # get sites and number of timesteps t.set_array('steps', arange(ntimesteps)) t.set_array('symbols', array([site.kind for site in s.sites])) t.importfile('some-calc/AIIDA-PROJECT-pos-1.xyz', 'xyz_pos')
_parse_xyz_vel
Load velocities from a XYZ file.
The steps and symbols must be set manually before calling this import function as a consistency measure. See also comment for _parse_xyz_pos()
_parse_xyz_pos()
Write the given trajectory to a string of format CIF.
Write the given trajectory to a string of format XSF (for XCrySDen).
Verify that the required arrays are present and that their type and dimension are correct.
get_cells
Return the array of cells, if it has already been set.
KeyError – if the trajectory has not been set yet.
Creates aiida.orm.nodes.data.cif.CifData
get_index_from_stepid
Given a value for the stepid (i.e., a value among those of the steps array), return the array index of that stepid, that can be used in other methods such as get_step_data() or get_step_structure().
steps
get_step_data()
get_step_structure()
New in version 0.7: Renamed from get_step_index
Note that this function returns the first index found (i.e. if multiple steps are present with the same value, only the index of the first one is returned).
ValueError – if no step with the given value is found.
get_positions
Return the array of positions, if it has already been set.
get_step_data
Return a tuple with all information concerning the stepid with given index (0 is the first step, 1 the second step and so on). If you know only the step value, use the get_index_from_stepid() method to get the corresponding index.
get_index_from_stepid()
If no velocities were specified, None is returned as the last element.
A tuple in the format (stepid, time, cell, symbols, positions, velocities), where stepid is an integer, time is a float, cell is a \(3 \times 3\) matrix, symbols is an array of length n, positions is a \(n \times 3\) array, and velocities is either None or a \(n \times 3\) array
(stepid, time, cell, symbols, positions, velocities)
stepid
time
symbols
n
None
index – The index of the step that you want to retrieve, from 0 to self.numsteps - 1.
self.numsteps - 1
IndexError – if you require an index beyond the limits.
KeyError – if you did not store the trajectory yet.
get_step_structure
Return an AiiDA aiida.orm.nodes.data.structure.StructureData node (not stored yet!) with the coordinates of the given step, identified by its index. If you know only the step value, use the get_index_from_stepid() method to get the corresponding index.
The periodic boundary conditions are always set to True.
New in version 0.7: Renamed from step_to_structure
index – The index of the step that you want to retrieve, from 0 to self.numsteps- 1.
self.numsteps- 1
custom_kinds – (Optional) If passed must be a list of aiida.orm.nodes.data.structure.Kind objects. There must be one kind object for each different string in the symbols array, with kind.name set to this string. If this parameter is omitted, the automatic kind generation of AiiDA aiida.orm.nodes.data.structure.StructureData nodes is used, meaning that the strings in the symbols array must be valid chemical symbols.
aiida.orm.nodes.data.structure.Kind
kind.name
get_stepids
Return the array of steps, if it has already been set.
New in version 0.7: Renamed from get_steps
get_times
Return the array of times (in ps), if it has already been set.
get_velocities
Return the array of velocities, if it has already been set.
This function (differently from all other get_* functions, will not raise an exception if the velocities are not set, but rather return None (both if no trajectory was not set yet, and if it the trajectory was set but no velocities were specified).
get_*
numsites
Return the number of stored sites, or zero if nothing has been stored yet.
numsteps
Return the number of stored steps, or zero if nothing has been stored yet.
set_structurelist
Create trajectory from the list of aiida.orm.nodes.data.structure.StructureData instances.
structurelist – a list of aiida.orm.nodes.data.structure.StructureData instances.
ValueError – if symbol lists of supplied structures are different
set_trajectory
Store the whole trajectory, after checking that types and dimensions are correct.
Parameters stepids, cells and velocities are optional variables. If nothing is passed for cells or velocities nothing will be stored. However, if no input is given for stepids a consecutive sequence [0,1,2,…,len(positions)-1] will be assumed.
stepids
cells
velocities
symbols – string list with dimension n, where n is the number of atoms (i.e., sites) in the structure. The same list is used for each step. Normally, the string should be a valid chemical symbol, but actually any unique string works and can be used as the name of the atomic kind (see also the get_step_structure() method).
positions – float array with dimension \(s \times n \times 3\), where s is the length of the stepids array and n is the length of the symbols array. Units are angstrom. In particular, positions[i,j,k] is the k-th component of the j-th atom (or site) in the structure at the time step with index i (identified by step number step[i] and with timestamp times[i]).
s
positions[i,j,k]
k
j
i
step[i]
times[i]
stepids – integer array with dimension s, where s is the number of steps. Typically represents an internal counter within the code. For instance, if you want to store a trajectory with one step every 10, starting from step 65, the array will be [65,75,85,...]. No checks are done on duplicate elements or on the ordering, but anyway this array should be sorted in ascending order, without duplicate elements. (If not specified, stepids will be set to numpy.arange(s) by default) It is internally stored as an array named ‘steps’.
[65,75,85,...]
numpy.arange(s)
cells – if specified float array with dimension \(s \times 3 \times 3\), where s is the length of the stepids array. Units are angstrom. In particular, cells[i,j,k] is the k-th component of the j-th cell vector at the time step with index i (identified by step number stepid[i] and with timestamp times[i]).
cells[i,j,k]
stepid[i]
times – if specified, float array with dimension s, where s is the length of the stepids array. Contains the timestamp of each step in picoseconds (ps).
velocities – if specified, must be a float array with the same dimensions of the positions array. The array contains the velocities in the atoms.
positions
show_mpl_heatmap
Show a heatmap of the trajectory with matplotlib.
show_mpl_pos
Shows the positions as a function of time, separate for XYZ coordinates
stepsize (int) – The stepsize for the trajectory, set higher than 1 to reduce number of points
mintime (int) – Time to start from
maxtime (int) – Maximum time
elements (list) – A list of atomic symbols that should be displayed. If not specified, all atoms are displayed.
indices (list) – A list of indices of that atoms that can be displayed. If not specified, all atoms of the correct species are displayed.
dont_block (bool) – If True, interpreter is not blocked when figure is displayed.
Return the array of symbols, if it has already been set.
UpfData
Data sub class to represent a pseudopotential single file in UPF format.
Create UpfData instance from pseudopotential file.
file – filepath or filelike object of the UPF potential file to store. Hint: Pass io.BytesIO(b”my string”) to construct directly from a string.
source – Dictionary with information on source of the potential (see “.source” property).
Returns UPF PP in json format.
_prepare_upf
Return UPF content.
Validate the UPF potential file stored for this node.
element
Return the element of the UPF pseudopotential.
the element
Return a list of all UpfData that match the given md5 hash.
assumes hash of stored UpfData nodes is stored in the md5 attribute
md5 – the file hash
list of existing UpfData nodes that have the same md5 hash
Get the UpfData with the same md5 of the given file, or create it if it does not yet exist.
filepath – an absolute filepath on disk
use_first – if False (default), raise an exception if more than one potential is found. If it is True, instead, use the first available pseudopotential.
store_upf – boolean, if false, the UpfData if created will not be stored.
tuple of UpfData and boolean indicating whether it was created.
get_upf_family_names
Get the list of all upf family names to which the pseudo belongs.
get_upf_group
Return the UPF family group with the given label.
group_label – the family group label
the Group with the given label, if it exists
get_upf_groups
Return all names of groups of type UpfFamily, possibly with some filters.
filter_elements – A string or a list of strings. If present, returns only the groups that contains one UPF for every element present in the list. The default is None, meaning that all families are returned.
user – if None (default), return the groups for all users. If defined, it should be either a User instance or the user email.
list of Group entities of type UPF.
md5sum
Return the md5 checksum of the UPF pseudopotential file.
the md5 checksum
Store the file in the repository and parse it to set the element and md5 attributes.
file – filepath or filelike object of the UPF potential file to store. Hint: Pass io.BytesIO(b”my string”) to construct the file directly from a string.
Store the node, reparsing the file so that the md5 and the element are correctly reset.
XyData
A subclass designed to handle arrays that have an “XY” relationship to each other. That is there is one array, the X array, and there are several Y arrays, which can be considered functions of X.
_arrayandname_validator
Validates that the array is an numpy.ndarray and that the name is of type str. Raises InputValidationError if this not the case.
get_x
Tries to retrieve the x array and x name raises a NotExistent exception if no x array has been set yet. :return x_name: the name set for the x_array :return x_array: the x array set earlier :return x_units: the x units set earlier
get_y
Tries to retrieve the y arrays and the y names, raises a NotExistent exception if they have not been set yet, or cannot be retrieved :return y_names: list of strings naming the y_arrays :return y_arrays: list of y_arrays :return y_units: list of strings giving the units for the y_arrays
set_x
Sets the array and the name for the x values.
x_array – A numpy.ndarray, containing only floats
x_name – a string for the x array name
x_units – the units of x
set_y
Set array(s) for the y part of the dataset. Also checks if the x_array has already been set, and that, the shape of the y_arrays agree with the x_array. :param y_arrays: A list of y_arrays, numpy.ndarray :param y_names: A list of strings giving the names of the y_arrays :param y_units: A list of strings giving the units of the y_arrays
to_aiida_type
Turns basic Python types (str, int, float, bool) into the corresponding AiiDA types.
aiida.orm.nodes.data.base.
aiida.orm.nodes.data.bool.
Tools for handling Crystallographic Information Files (CIF)
aiida.orm.nodes.data.cif.
cif_from_ase
Construct a CIF datablock from the ASE structure. The code is taken from https://wiki.fysik.dtu.dk/ase/epydoc/ase.io.cif-pysrc.html#write_cif, as the original ASE code contains a bug in printing the Hermann-Mauguin symmetry space group symbol.
ase – ASE “images”
array of CIF datablocks
has_pycifrw
True if the PyCifRW module can be imported, False otherwise.
parse_formula
Parses the Hill formulae. Does not need spaces as separators. Works also for partial occupancies and for chemical groups enclosed in round/square/curly brackets. Elements are counted and a dictionary is returned. e.g. ‘C[NH2]3NO3’ –> {‘C’: 1, ‘N’: 4, ‘H’: 6, ‘O’: 3}
pycifrw_from_cif
Constructs PyCifRW’s CifFile from an array of CIF datablocks.
datablocks – an array of CIF datablocks
loops – optional dict of lists of CIF tag loops.
names – optional list of datablock names
CifFile
Data plugin represeting an executable code to be wrapped and called through a CalcJob plugin.
aiida.orm.nodes.data.code.
Module with Node sub class Data to be used as a base class for data structures.
aiida.orm.nodes.data.data.
aiida.orm.nodes.data.dict.
aiida.orm.nodes.data.float.
aiida.orm.nodes.data.folder.
aiida.orm.nodes.data.int.
aiida.orm.nodes.data.list.
Module for defintion of base Data sub class for numeric based data types.
aiida.orm.nodes.data.numeric.
Data plugin to model an atomic orbital.
aiida.orm.nodes.data.orbital.
aiida.orm.nodes.data.singlefile.
aiida.orm.nodes.data.str.
This module defines the classes for structures and all related functions to operate on them.
aiida.orm.nodes.data.structure.
Kind
Bases: object
object
This class contains the information about the species (kinds) of the system.
It can be a single atom, or an alloy, or even contain vacancies.
__dict__
Create a site. One can either pass:
raw – the raw python dictionary that will be converted to a Kind object.
ase – an ase Atom object
kind – a Kind object (to get a copy)
Or alternatively the following parameters:
symbols – a single string for the symbol of this site, or a list of symbol strings
weights – (optional) the weights for each atomic species of this site. If only a single symbol is provided, then this value is optional and the weight is set to 1.
mass – (optional) the mass for this site in atomic mass units. If not provided, the mass is set by the self.reset_mass() function.
name – a string that uniquely identifies the kind, and that is used to identify the sites.
__repr__
Return repr(self).
__weakref__
list of weak references to the object (if defined)
compare_with
Compare with another Kind object to check if they are different.
This does NOT check the ‘type’ attribute. Instead, it compares (with reasonable thresholds, where applicable): the mass, and the list of symbols and of weights. Moreover, it compares the _internal_tag, if defined (at the moment, defined automatically only when importing the Kind from ASE, if the atom has a non-zero tag). Note that the _internal_tag is only used while the class is loaded, but is not persisted on the database.
_internal_tag
A tuple with two elements. The first one is True if the two sites are ‘equivalent’ (same mass, symbols and weights), False otherwise. The second element of the tuple is a string, which is either None (if the first element was True), or contains a ‘human-readable’ description of the first difference encountered between the two sites.
get_raw
Return the raw version of the site, mapped to a suitable dictionary. This is the format that is actually used to store each kind of the structure in the DB.
a python dictionary with the kind.
get_symbols_string
Return a string that tries to match as good as possible the symbols of this kind. If there is only one symbol (no alloy) with 100% occupancy, just returns the symbol name. Otherwise, groups the full string in curly brackets, and try to write also the composition (with 2 precision only).
If there is a vacancy (sum of weights<1), we indicate it with the X symbol followed by 1-sum(weights) (still with 2 digits precision, so it can be 0.00)
Note the difference with respect to the symbols and the symbol properties!
Return whether the Kind contains vacancies, i.e. when the sum of the weights is less than one.
the property uses the internal variable _SUM_THRESHOLD as a threshold.
boolean, True if the sum of the weights is less than one, False otherwise
Return whether the Kind is an alloy, i.e. contains more than one element
boolean, True if the kind has more than one element, False otherwise.
mass
The mass of this species kind.
a float
name
Return the name of this kind. The name of a kind is used to identify the species of a site.
a string
reset_mass
Reset the mass to the automatic calculated value.
The mass can be set manually; by default, if not provided, it is the mass of the constituent atoms, weighted with their weight (after the weight has been normalized to one to take correctly into account vacancies).
This function uses the internal _symbols and _weights values and thus assumes that the values are validated.
It sets the mass to None if the sum of weights is zero.
set_automatic_kind_name
Set the type to a string obtained with the symbols appended one after the other, without spaces, in alphabetical order; if the site has a vacancy, a X is appended at the end too.
set_symbols_and_weights
Set the chemical symbols and the weights for the site.
Note that the kind name remains unchanged.
symbol
If the kind has only one symbol, return it; otherwise, raise a ValueError.
List of symbols for this site. If the site is a single atom, pass a list of one element only, or simply the string for that atom. For alloys, a list of elements.
Note that if you change the list of symbols, the kind name remains unchanged.
weights
Weights for this species kind. Refer also to :func:validate_symbols_tuple for the validation rules on the weights.
Site
This class contains the information about a given site of the system.
Create a site.
kind_name – a string that identifies the kind (species) of this site. This has to be found in the list of kinds of the StructureData object. Validation will be done at the StructureData level.
position – the absolute position (three floats) in angstrom
Return a ase.Atom object for this site.
kinds – the list of kinds from the StructureData object.
Return the raw version of the site, mapped to a suitable dictionary. This is the format that is actually used to store each site of the structure in the DB.
a python dictionary with the site.
kind_name
Return the kind name of this site (a string).
The type of a site is used to decide whether two sites are identical (same mass, symbols, weights, …) or not.
position
Return the position of this site in absolute coordinates, in angstrom.
Module of Data sub class to represent a pseudopotential single file in UPF format and related utilities.
aiida.orm.nodes.data.upf.