aiida-core

core.rabbitmq

core.zeromq

core.arithmetic.add

`CalcJob` implementation to add two numbers using bash for testing and demonstration purposes.

core.stash

Utility to stash files from a remote folder. An example of how the input should look like: .. code-block:: python inputs = { 'metadata': { 'computer': load_computer(label="localhost"), 'options': { 'resources': {'num_machines': 1}, 'stash': { 'stash_mode': StashMode.COPY.value, 'target_base': '/scratch/my_stashing/', 'source_list': ['aiida.in', '_aiidasubmit.sh'], }, }, }, 'source_node': node_1, } Ideally one could use the same computer as the one of the `source_node`. However if you cannot access the stash storage from the same computer anymore but you have access to it from another computer, you can can specify the computer in `metadata.computer`. Only in case of `StashMode.SUBMIT_CUSTOM_CODE` mode, the `code` input is required. And the stashing is done by submitting a script to the computer specified in `metadata.computer`. For example: .. code-block:: python inputs = { 'metadata': { 'computer': load_computer(label="localhost"), 'options': { 'resources': {'num_machines': 1}, 'stash': { 'stash_mode': StashMode.SUBMIT_CUSTOM_CODE.value, 'target_base': '/scratch/my_stashing/', 'source_list': ['aiida.in', '_aiidasubmit.sh'], }, }, }, 'source_node': <RemoteData_NODE>, 'code': <MY_CODE> }

core.templatereplacer

Simple stub of a plugin that can be used to replace some text in a given template. Can be used for many different codes, or as a starting point to develop a new plugin. This simple plugin takes two node inputs, both of type Dict, with the labels 'parameters' and 'template' You can also add other SinglefileData nodes as input, that will be copied according to what is written in 'template' (see below). * parameters: a set of parameters that will be used for substitution. * template: can contain the following parameters: * input_file_template: a string with substitutions to be managed with the format() function of python, i.e. if you want to substitute a variable called 'varname', you write {varname} in the text. See http://www.python.org/dev/peps/pep-3101/ for more details. The replaced file will be the input file. * input_file_name: a string with the file name for the input. If it is not provided, no file will be created. * output_file_name: a string with the file name for the output. If it is not provided, no redirection will be done and the output will go in the scheduler output file. * cmdline_params: a list of strings, to be passed as command line parameters. Each one is substituted with the same rule of input_file_template. Optional * input_through_stdin: if True, the input file name is passed via stdin. Default is False if missing. * files_to_copy: if defined, a list of tuple pairs, with format ('link_name', 'dest_rel_path'); for each tuple, an input link to this calculation is looked for, with link labeled 'link_label', and with file type 'Singlefile', and the content is copied to a remote file named 'dest_rel_path' Errors are raised in the input links are non-existent, or of the wrong type, or if there are unused input files. * retrieve_temporary_files: a list of relative filepaths, that if defined, will be retrieved and temporarily stored in an unstored FolderData node that will be available during the Parser.parser_with_retrieved call under the key specified by the Parser.retrieved_temporary_folder key

core.transfer

Utility to copy files from different FolderData and RemoteData nodes into a single place. The final destination for these files can be either the local repository (by creating a new FolderData node to store them) or in the remote computer (by leaving the files in a new remote folder saved in a RemoteData node). Only files from the local computer and from remote folders in the same external computer can be moved at the same time with a single instance of this CalcJob. The user needs to provide three inputs: * ``instructions``: a dict node specifying which files to copy from which nodes. * ``source_nodes``: a dict of nodes, each with a unique identifier label as its key. * ``metadata.computer``: the computer that contains the remote files and will contain the final RemoteData node. The ``instructions`` dict must have the ``retrieve_files`` flag. The CalcJob will create a new folder in the remote machine (``RemoteData``) and put all the files there and will either: (1) leave them there (``retrieve_files = False``) or ... (2) retrieve all the files and store them locally in a ``FolderData`` (``retrieve_files = True``) The `instructions` dict must also contain at least one list with specifications of which files to copy and from where. All these lists take tuples of 3 that have the following format: .. code-block:: python ( source_node_key, path_to_file_in_source, path_to_file_in_target) where the ``source_node_key`` has to be the respective one used when providing the node in the ``source_nodes`` input nodes dictionary. The two main lists to include are ``local_files`` (for files to be taken from FolderData nodes) and ``remote_files`` (for files to be taken from RemoteData nodes). Alternatively, files inside of RemoteData nodes can instead be put in the ``symlink_files`` list: the only difference is that files from the first list will be fully copied in the target RemoteData folder, whereas for the files in second list only a symlink to the original file will be created there. This will only affect the content of the final RemoteData target folder, but in both cases the full file will be copied back in the local target FolderData (if ``retrieve_files = True``).

core.unstash

Utility to unstash files from a remote folder. An example of how the input should look like: .. code-block:: python inputs = { 'metadata': { 'computer': Computer.collection.get(label="localhost"), 'options': { 'resources': {'num_machines': 1}, 'unstash': { 'unstash_target_mode': UnstashTargetMode.NewNode.value, 'source_list': ['aiida.in', '_aiidasubmit.sh'], # also accepts ['*'] }, }, }, 'source_node': <RemoteStashData>, 'code': <MY_CODE> # only in case of `type(source_node)==RemoteStashCustomData` }

core.arithmetic.add

core.always_kill

core.local

core.ssh

core.array

core.bands

core.cif

core.dict

core.remote

core.singlefile

core.structure

core.trajectory

core.upf

core.array

core.array.bands

core.array.kpoints

core.array.projection

core.array.trajectory

core.array.xy

core.base

core.bool

core.cif

core.code

core.code.abstract

core.code.containerized

core.code.installed

core.code.portable

core.dict

core.enum

core.float

core.folder

core.int

core.jsonable

core.list

core.numeric

core.orbital

core.remote

core.remote.stash

core.remote.stash.compress

core.remote.stash.custom

core.remote.stash.folder

core.singlefile

core.str

core.structure

core.upf

core

core.auto

core.import

core.upf

data

process

process.calculation

process.calculation.calcfunction

process.calculation.calcjob

process.workflow

process.workflow.workchain

process.workflow.workfunction

core.auth_info

core.comment

core.computer

core.data

core.entity

core.group

core.log

core.node

core.user

core.arithmetic.add

core.templatereplacer

core.direct

core.lsf

core.pbspro

core.sge

core.slurm

core.torque

core.psql_dos

core.sqlite_dos

core.sqlite_temp

core.sqlite_zip

core.orbital

core.realhydrogen

core.cod

core.icsd

core.materialsproject

core.mpds

core.mpod

core.nninc

core.oqmd

core.pcod

core.tcod

core.local

core.ssh

core.ssh_async

core.arithmetic.add_multiply

Add two numbers and multiply it with a third.

core.arithmetic.multiply_add

WorkChain to multiply two numbers and add a third, for testing and demonstration purposes.

runaiida

verdi