aiida.engine.processes.workchains package¶
Module for the WorkChain process and related utilities.
-
aiida.engine.processes.workchains.
ToContext
¶ alias of
builtins.dict
-
aiida.engine.processes.workchains.
assign_
(target)[source]¶ Convenience function that will construct an Awaitable for a given class instance with the context action set to ASSIGN. When the awaitable target is completed it will be assigned to the context for a key that is to be defined later
- Parameters
target – an instance of a Process or Awaitable
- Returns
the awaitable
- Return type
-
aiida.engine.processes.workchains.
append_
(target)[source]¶ Convenience function that will construct an Awaitable for a given class instance with the context action set to APPEND. When the awaitable target is completed it will be appended to a list in the context for a key that is to be defined later
- Parameters
target – an instance of a Process or Awaitable
- Returns
the awaitable
- Return type
-
class
aiida.engine.processes.workchains.
BaseRestartWorkChain
(*args, **kwargs)[source]¶ Bases:
aiida.engine.processes.workchains.workchain.WorkChain
Base restart work chain.
This work chain serves as the starting point for more complex work chains that will be designed to run a sub process that might need multiple restarts to come to a successful end. These restarts may be necessary because a single process run is not sufficient to achieve a fully converged result, or certain errors maybe encountered which are recoverable.
This work chain implements the most basic functionality to achieve this goal. It will launch the sub process, restarting until it is completed successfully or the maximum number of iterations is reached. It can recover from errors through error handlers that can be registered to the class through the register_process_handler decorator.
The idea is to sub class this work chain and leverage the generic error handling that is implemented in the few outline methods. The minimally required outline would look something like the following:
cls.setup while_(cls.should_run_process)( cls.run_process, cls.inspect_process, )
Each of these methods can of course be overriden but they should be general enough to fit most process cycles. The run_process method will take the inputs for the process from the context under the key inputs. The user should, therefore, make sure that before the run_process method is called, that the to be used inputs are stored under self.ctx.inputs. One can update the inputs based on the results from a prior process by calling an outline method just before the run_process step, for example:
cls.setup while_(cls.should_run_process)( cls.prepare_inputs, cls.run_process, cls.inspect_process, )
Where in the prepare_calculation method, the inputs dictionary at self.ctx.inputs is updated before the next process will be run with those inputs.
The _process_class attribute should be set to the Process class that should be run in the loop.
-
_BaseRestartWorkChain__handlers
= ()¶
-
_Process__called
= True¶
-
__abstractmethods__
= frozenset({})¶
-
__module__
= 'aiida.engine.processes.workchains.restart'¶
-
_abc_impl
= <_abc_data object>¶
-
_handler_entry_point
= None¶
-
_handlers
= ()¶
-
_process_class
= None¶
-
_spec
= <aiida.engine.processes.workchains.workchain.WorkChainSpec object>¶
-
_verbose
= False¶
-
_wrap_bare_dict_inputs
(port_namespace, inputs)[source]¶ Wrap bare dictionaries in inputs in a Dict node if dictated by the corresponding inputs portnamespace.
- Parameters
port_namespace – a PortNamespace
inputs – a dictionary of inputs intended for submission of the process
- Returns
an attribute dictionary with all bare dictionaries wrapped in Dict if dictated by the port namespace
-
inspect_process
()[source]¶ Analyse the results of the previous process and call the handlers when necessary.
If the process is excepted or killed, the work chain will abort. Otherwise any attached handlers will be called in order of their specified priority. If the process was failed and no handler returns a report indicating that the error was handled, it is considered an unhandled process failure and the process is relaunched. If this happens twice in a row, the work chain is aborted. In the case that at least one handler returned a report the following matrix determines the logic that is followed:
Process Handler Handler Action result report? exit code —————————————– Success yes == 0 Restart Success yes != 0 Abort Failed yes == 0 Restart Failed yes != 0 Abort
If no handler returned a report and the process finished successfully, the work chain’s work is considered done and it will move on to the next step that directly follows the while conditional, if there is one defined in the outline.
-
on_terminated
()[source]¶ Clean the working directories of all child calculation jobs if clean_workdir=True in the inputs.
-
classmethod
register_handler
(name, handler)[source]¶ Register a new handler to this class.
- Parameters
name – the name under which to register the handler
handler – a method with the signature self, node.
-
results
()[source]¶ Attach the outputs specified in the output specification from the last completed process.
-
run_process
()[source]¶ Run the next process, taking the input dictionary from the context at self.ctx.inputs.
-
-
class
aiida.engine.processes.workchains.
ProcessHandler
(method, priority, exit_codes)¶ Bases:
tuple
-
__getnewargs__
()¶ Return self as a plain tuple. Used by copy and pickle.
-
__module__
= 'aiida.engine.processes.workchains.utils'¶
-
static
__new__
(_cls, method=None, priority=0, exit_codes=None)¶ Create new instance of ProcessHandler(method, priority, exit_codes)
-
__repr__
()¶ Return a nicely formatted representation string
-
__slots__
= ()¶
-
_asdict
()¶ Return a new OrderedDict which maps field names to their values.
-
_fields
= ('method', 'priority', 'exit_codes')¶
-
_fields_defaults
= {}¶
-
classmethod
_make
(iterable)¶ Make a new ProcessHandler object from a sequence or iterable
-
_replace
(**kwds)¶ Return a new ProcessHandler object replacing specified fields with new values
-
property
exit_codes
¶ Alias for field number 2
-
property
method
¶ Alias for field number 0
-
property
priority
¶ Alias for field number 1
-
-
class
aiida.engine.processes.workchains.
ProcessHandlerReport
(do_break, exit_code)¶ Bases:
tuple
-
__getnewargs__
()¶ Return self as a plain tuple. Used by copy and pickle.
-
__module__
= 'aiida.engine.processes.workchains.utils'¶
-
static
__new__
(_cls, do_break=False, exit_code=ExitCode(status=0, message=None, invalidates_cache=False))¶ Create new instance of ProcessHandlerReport(do_break, exit_code)
-
__repr__
()¶ Return a nicely formatted representation string
-
__slots__
= ()¶
-
_asdict
()¶ Return a new OrderedDict which maps field names to their values.
-
_fields
= ('do_break', 'exit_code')¶
-
_fields_defaults
= {}¶
-
classmethod
_make
(iterable)¶ Make a new ProcessHandlerReport object from a sequence or iterable
-
_replace
(**kwds)¶ Return a new ProcessHandlerReport object replacing specified fields with new values
-
property
do_break
¶ Alias for field number 0
-
property
exit_code
¶ Alias for field number 1
-
-
aiida.engine.processes.workchains.
register_process_handler
(cls, *, priority=None, exit_codes=None)[source]¶ Decorator to register a function as a handler for a
BaseRestartWorkChain
.The function expects two arguments, a work chain class and a priortity. The decorator will add the function as a class method to the work chain class and add an
ProcessHandler
tuple to the __handlers private attribute of the work chain. During the inspect_process outline method, the work chain will retrieve all the registered handlers through the_handlers()
property and loop over them sorted with respect to their priority in reverse. If the work chain class defines the_verbose
attribute and is set to True, a report message will be fired when the process handler is executed.Requirements on the function signature of process handling functions. The function to which the decorator is applied needs to take two arguments:
self: This is the instance of the work chain itself
node: This is the process node that finished and is to be investigated
The function body typically consists of a conditional that will check for a particular problem that might have occurred for the sub process. If a particular problem is handled, the process handler should return an instance of the
aiida.engine.ProcessHandlerReport
tuple. If no other process handlers should be considered, the set do_break attribute should be set to True. If the work chain is to be aborted entirely, the exit_code of the report can be set to an ExitCode instance with a non-zero status.- Parameters
cls – the work chain class to register the process handler with
priority – optional integer that defines the order in which registered handlers will be called during the handling of a finished process. Higher priorities will be handled first.
exit_codes – single or list of ExitCode instances. If defined, the handler will return None if the exit code set on the node does not appear in the exit_codes. This is useful to have a handler called only when the process failed with a specific exit code.
-
class
aiida.engine.processes.workchains.
WorkChain
(inputs=None, logger=None, runner=None, enable_persistence=True)[source]¶ Bases:
aiida.engine.processes.process.Process
The WorkChain class is the principle component to implement workflows in AiiDA.
-
_CONTEXT
= 'CONTEXT'¶
-
_Process__called
= True¶
-
_STEPPER_STATE
= 'stepper_state'¶
-
__abstractmethods__
= frozenset({})¶
-
__init__
(inputs=None, logger=None, runner=None, enable_persistence=True)[source]¶ Construct a WorkChain instance.
Construct the instance only if it is a sub class of WorkChain, otherwise raise InvalidOperation.
- Parameters
inputs (dict) – work chain inputs
logger (
logging.Logger
) – aiida loggerrunner – work chain runner
enable_persistence (bool) – whether to persist this work chain
- Type
-
__module__
= 'aiida.engine.processes.workchains.workchain'¶
-
_abc_impl
= <_abc_data object>¶
-
_auto_persist
= {'_CREATION_TIME', '_awaitables', '_enable_persistence', '_future', '_parent_pid', '_paused', '_pid', '_pre_paused_status', '_status'}¶
-
_do_step
()[source]¶ Execute the next step in the outline and return the result.
If the stepper returns a non-finished status and the return value is of type ToContext, the contents of the ToContext container will be turned into awaitables if necessary. If any awaitables were created, the process will enter in the Wait state, otherwise it will go to Continue. When the stepper returns that it is done, the stepper result will be converted to None and returned, unless it is an integer or instance of ExitCode.
-
_node_class
¶ alias of
aiida.orm.nodes.process.workflow.workchain.WorkChainNode
-
_spec
= <aiida.engine.processes.workchains.workchain.WorkChainSpec object>¶
-
_spec_class
¶ alias of
WorkChainSpec
-
_store_nodes
(data)[source]¶ Recurse through a data structure and store any unstored nodes that are found along the way
- Parameters
data – a data structure potentially containing unstored nodes
-
_update_process_status
()[source]¶ Set the process status with a message accounting the current sub processes that we are waiting for.
-
action_awaitables
()[source]¶ Handle the awaitables that are currently registered with the work chain
Depending on the class type of the awaitable’s target a different callback function will be bound with the awaitable and the runner will be asked to call it when the target is completed
-
property
ctx
¶ Get context.
- Return type
-
insert_awaitable
(awaitable)[source]¶ Insert an awaitable that should be terminated before before continuing to the next step.
- Parameters
awaitable (
aiida.engine.processes.workchains.awaitable.Awaitable
) – the thing to await
-
load_instance_state
(saved_state, load_context)[source]¶ Load instance state.
- Parameters
saved_state – saved instance state
load_context (
plumpy.persistence.LoadSaveContext
) –
-
on_exiting
()[source]¶ Ensure that any unstored nodes in the context are stored, before the state is exited
After the state is exited the next state will be entered and if persistence is enabled, a checkpoint will be saved. If the context contains unstored nodes, the serialization necessary for checkpointing will fail.
-
on_process_finished
(awaitable, pk)[source]¶ Callback function called by the runner when the process instance identified by pk is completed.
The awaitable will be effectuated on the context of the work chain and removed from the internal list. If all awaitables have been dealt with, the work chain process is resumed.
- Parameters
awaitable – an Awaitable instance
pk (int) – the pk of the awaitable’s target
-
remove_awaitable
(awaitable)[source]¶ Remove an awaitable.
Precondition: must be an awaitable that was previously inserted.
- Parameters
awaitable – the awaitable to remove
-
-
aiida.engine.processes.workchains.
if_
(condition)[source]¶ A conditional that can be used in a workchain outline.
Use as:
if_(cls.conditional)( cls.step1, cls.step2 )
Each step can, of course, also be any valid workchain step e.g. conditional.
- Parameters
condition – The workchain method that will return True or False
-
aiida.engine.processes.workchains.
while_
(condition)[source]¶ A while loop that can be used in a workchain outline.
Use as:
while_(cls.conditional)( cls.step1, cls.step2 )
Each step can, of course, also be any valid workchain step e.g. conditional.
- Parameters
condition – The workchain method that will return True or False
Submodules¶
Enums and function for the awaitables of Processes.
-
class
aiida.engine.processes.workchains.awaitable.
Awaitable
(**kwargs)[source]¶ Bases:
plumpy.utils.AttributesDict
An attribute dictionary that represents an action that a Process could be waiting for to finish.
-
__module__
= 'aiida.engine.processes.workchains.awaitable'¶
-
-
class
aiida.engine.processes.workchains.awaitable.
AwaitableTarget
[source]¶ Bases:
enum.Enum
Enum that describes the class of the target a given awaitable.
-
PROCESS
= 'process'¶
-
__module__
= 'aiida.engine.processes.workchains.awaitable'¶
-
-
class
aiida.engine.processes.workchains.awaitable.
AwaitableAction
[source]¶ Bases:
enum.Enum
Enum that describes the action to be taken for a given awaitable.
-
APPEND
= 'append'¶
-
ASSIGN
= 'assign'¶
-
__module__
= 'aiida.engine.processes.workchains.awaitable'¶
-
-
aiida.engine.processes.workchains.awaitable.
construct_awaitable
(target)[source]¶ Construct an instance of the Awaitable class that will contain the information related to the action to be taken with respect to the context once the awaitable object is completed.
The awaitable is a simple dictionary with the following keys
pk: the pk of the node that is being waited on
action: the context action to be performed upon completion
outputs: a boolean that toggles whether the node itself
Currently the only awaitable classes are ProcessNode and Workflow The only awaitable actions are the Assign and Append operators
Convenience functions to add awaitables to the Context of a WorkChain.
-
aiida.engine.processes.workchains.context.
ToContext
¶ alias of
builtins.dict
-
aiida.engine.processes.workchains.context.
assign_
(target)[source]¶ Convenience function that will construct an Awaitable for a given class instance with the context action set to ASSIGN. When the awaitable target is completed it will be assigned to the context for a key that is to be defined later
- Parameters
target – an instance of a Process or Awaitable
- Returns
the awaitable
- Return type
-
aiida.engine.processes.workchains.context.
append_
(target)[source]¶ Convenience function that will construct an Awaitable for a given class instance with the context action set to APPEND. When the awaitable target is completed it will be appended to a list in the context for a key that is to be defined later
- Parameters
target – an instance of a Process or Awaitable
- Returns
the awaitable
- Return type
Base implementation of WorkChain class that implements a simple automated restart mechanism for sub processes.
-
class
aiida.engine.processes.workchains.restart.
BaseRestartWorkChain
(*args, **kwargs)[source]¶ Bases:
aiida.engine.processes.workchains.workchain.WorkChain
Base restart work chain.
This work chain serves as the starting point for more complex work chains that will be designed to run a sub process that might need multiple restarts to come to a successful end. These restarts may be necessary because a single process run is not sufficient to achieve a fully converged result, or certain errors maybe encountered which are recoverable.
This work chain implements the most basic functionality to achieve this goal. It will launch the sub process, restarting until it is completed successfully or the maximum number of iterations is reached. It can recover from errors through error handlers that can be registered to the class through the register_process_handler decorator.
The idea is to sub class this work chain and leverage the generic error handling that is implemented in the few outline methods. The minimally required outline would look something like the following:
cls.setup while_(cls.should_run_process)( cls.run_process, cls.inspect_process, )
Each of these methods can of course be overriden but they should be general enough to fit most process cycles. The run_process method will take the inputs for the process from the context under the key inputs. The user should, therefore, make sure that before the run_process method is called, that the to be used inputs are stored under self.ctx.inputs. One can update the inputs based on the results from a prior process by calling an outline method just before the run_process step, for example:
cls.setup while_(cls.should_run_process)( cls.prepare_inputs, cls.run_process, cls.inspect_process, )
Where in the prepare_calculation method, the inputs dictionary at self.ctx.inputs is updated before the next process will be run with those inputs.
The _process_class attribute should be set to the Process class that should be run in the loop.
-
_BaseRestartWorkChain__handlers
= ()¶
-
_Process__called
= True¶
-
__abstractmethods__
= frozenset({})¶
-
__module__
= 'aiida.engine.processes.workchains.restart'¶
-
_abc_impl
= <_abc_data object>¶
-
_handler_entry_point
= None¶
-
_handlers
= ()¶
-
_process_class
= None¶
-
_spec
= <aiida.engine.processes.workchains.workchain.WorkChainSpec object>¶
-
_verbose
= False¶
-
_wrap_bare_dict_inputs
(port_namespace, inputs)[source]¶ Wrap bare dictionaries in inputs in a Dict node if dictated by the corresponding inputs portnamespace.
- Parameters
port_namespace – a PortNamespace
inputs – a dictionary of inputs intended for submission of the process
- Returns
an attribute dictionary with all bare dictionaries wrapped in Dict if dictated by the port namespace
-
inspect_process
()[source]¶ Analyse the results of the previous process and call the handlers when necessary.
If the process is excepted or killed, the work chain will abort. Otherwise any attached handlers will be called in order of their specified priority. If the process was failed and no handler returns a report indicating that the error was handled, it is considered an unhandled process failure and the process is relaunched. If this happens twice in a row, the work chain is aborted. In the case that at least one handler returned a report the following matrix determines the logic that is followed:
Process Handler Handler Action result report? exit code —————————————– Success yes == 0 Restart Success yes != 0 Abort Failed yes == 0 Restart Failed yes != 0 Abort
If no handler returned a report and the process finished successfully, the work chain’s work is considered done and it will move on to the next step that directly follows the while conditional, if there is one defined in the outline.
-
on_terminated
()[source]¶ Clean the working directories of all child calculation jobs if clean_workdir=True in the inputs.
-
classmethod
register_handler
(name, handler)[source]¶ Register a new handler to this class.
- Parameters
name – the name under which to register the handler
handler – a method with the signature self, node.
-
results
()[source]¶ Attach the outputs specified in the output specification from the last completed process.
-
run_process
()[source]¶ Run the next process, taking the input dictionary from the context at self.ctx.inputs.
-
Utilities for WorkChain implementations.
-
class
aiida.engine.processes.workchains.utils.
ProcessHandler
(method, priority, exit_codes)¶ Bases:
tuple
-
__getnewargs__
()¶ Return self as a plain tuple. Used by copy and pickle.
-
__module__
= 'aiida.engine.processes.workchains.utils'¶
-
static
__new__
(_cls, method=None, priority=0, exit_codes=None)¶ Create new instance of ProcessHandler(method, priority, exit_codes)
-
__repr__
()¶ Return a nicely formatted representation string
-
__slots__
= ()¶
-
_asdict
()¶ Return a new OrderedDict which maps field names to their values.
-
_fields
= ('method', 'priority', 'exit_codes')¶
-
_fields_defaults
= {}¶
-
classmethod
_make
(iterable)¶ Make a new ProcessHandler object from a sequence or iterable
-
_replace
(**kwds)¶ Return a new ProcessHandler object replacing specified fields with new values
-
property
exit_codes
¶ Alias for field number 2
-
property
method
¶ Alias for field number 0
-
property
priority
¶ Alias for field number 1
-
-
class
aiida.engine.processes.workchains.utils.
ProcessHandlerReport
(do_break, exit_code)¶ Bases:
tuple
-
__getnewargs__
()¶ Return self as a plain tuple. Used by copy and pickle.
-
__module__
= 'aiida.engine.processes.workchains.utils'¶
-
static
__new__
(_cls, do_break=False, exit_code=ExitCode(status=0, message=None, invalidates_cache=False))¶ Create new instance of ProcessHandlerReport(do_break, exit_code)
-
__repr__
()¶ Return a nicely formatted representation string
-
__slots__
= ()¶
-
_asdict
()¶ Return a new OrderedDict which maps field names to their values.
-
_fields
= ('do_break', 'exit_code')¶
-
_fields_defaults
= {}¶
-
classmethod
_make
(iterable)¶ Make a new ProcessHandlerReport object from a sequence or iterable
-
_replace
(**kwds)¶ Return a new ProcessHandlerReport object replacing specified fields with new values
-
property
do_break
¶ Alias for field number 0
-
property
exit_code
¶ Alias for field number 1
-
-
aiida.engine.processes.workchains.utils.
register_process_handler
(cls, *, priority=None, exit_codes=None)[source]¶ Decorator to register a function as a handler for a
BaseRestartWorkChain
.The function expects two arguments, a work chain class and a priortity. The decorator will add the function as a class method to the work chain class and add an
ProcessHandler
tuple to the __handlers private attribute of the work chain. During the inspect_process outline method, the work chain will retrieve all the registered handlers through the_handlers()
property and loop over them sorted with respect to their priority in reverse. If the work chain class defines the_verbose
attribute and is set to True, a report message will be fired when the process handler is executed.Requirements on the function signature of process handling functions. The function to which the decorator is applied needs to take two arguments:
self: This is the instance of the work chain itself
node: This is the process node that finished and is to be investigated
The function body typically consists of a conditional that will check for a particular problem that might have occurred for the sub process. If a particular problem is handled, the process handler should return an instance of the
aiida.engine.ProcessHandlerReport
tuple. If no other process handlers should be considered, the set do_break attribute should be set to True. If the work chain is to be aborted entirely, the exit_code of the report can be set to an ExitCode instance with a non-zero status.- Parameters
cls – the work chain class to register the process handler with
priority – optional integer that defines the order in which registered handlers will be called during the handling of a finished process. Higher priorities will be handled first.
exit_codes – single or list of ExitCode instances. If defined, the handler will return None if the exit code set on the node does not appear in the exit_codes. This is useful to have a handler called only when the process failed with a specific exit code.
Components for the WorkChain concept of the workflow engine.
-
class
aiida.engine.processes.workchains.workchain.
WorkChain
(inputs=None, logger=None, runner=None, enable_persistence=True)[source]¶ Bases:
aiida.engine.processes.process.Process
The WorkChain class is the principle component to implement workflows in AiiDA.
-
_CONTEXT
= 'CONTEXT'¶
-
_Process__called
= True¶
-
_STEPPER_STATE
= 'stepper_state'¶
-
__abstractmethods__
= frozenset({})¶
-
__init__
(inputs=None, logger=None, runner=None, enable_persistence=True)[source]¶ Construct a WorkChain instance.
Construct the instance only if it is a sub class of WorkChain, otherwise raise InvalidOperation.
- Parameters
inputs (dict) – work chain inputs
logger (
logging.Logger
) – aiida loggerrunner – work chain runner
enable_persistence (bool) – whether to persist this work chain
- Type
-
__module__
= 'aiida.engine.processes.workchains.workchain'¶
-
_abc_impl
= <_abc_data object>¶
-
_auto_persist
= {'_CREATION_TIME', '_awaitables', '_enable_persistence', '_future', '_parent_pid', '_paused', '_pid', '_pre_paused_status', '_status'}¶
-
_do_step
()[source]¶ Execute the next step in the outline and return the result.
If the stepper returns a non-finished status and the return value is of type ToContext, the contents of the ToContext container will be turned into awaitables if necessary. If any awaitables were created, the process will enter in the Wait state, otherwise it will go to Continue. When the stepper returns that it is done, the stepper result will be converted to None and returned, unless it is an integer or instance of ExitCode.
-
_node_class
¶ alias of
aiida.orm.nodes.process.workflow.workchain.WorkChainNode
-
_spec
= <aiida.engine.processes.workchains.workchain.WorkChainSpec object>¶
-
_spec_class
¶ alias of
WorkChainSpec
-
_store_nodes
(data)[source]¶ Recurse through a data structure and store any unstored nodes that are found along the way
- Parameters
data – a data structure potentially containing unstored nodes
-
_update_process_status
()[source]¶ Set the process status with a message accounting the current sub processes that we are waiting for.
-
action_awaitables
()[source]¶ Handle the awaitables that are currently registered with the work chain
Depending on the class type of the awaitable’s target a different callback function will be bound with the awaitable and the runner will be asked to call it when the target is completed
-
property
ctx
¶ Get context.
- Return type
-
insert_awaitable
(awaitable)[source]¶ Insert an awaitable that should be terminated before before continuing to the next step.
- Parameters
awaitable (
aiida.engine.processes.workchains.awaitable.Awaitable
) – the thing to await
-
load_instance_state
(saved_state, load_context)[source]¶ Load instance state.
- Parameters
saved_state – saved instance state
load_context (
plumpy.persistence.LoadSaveContext
) –
-
on_exiting
()[source]¶ Ensure that any unstored nodes in the context are stored, before the state is exited
After the state is exited the next state will be entered and if persistence is enabled, a checkpoint will be saved. If the context contains unstored nodes, the serialization necessary for checkpointing will fail.
-
on_process_finished
(awaitable, pk)[source]¶ Callback function called by the runner when the process instance identified by pk is completed.
The awaitable will be effectuated on the context of the work chain and removed from the internal list. If all awaitables have been dealt with, the work chain process is resumed.
- Parameters
awaitable – an Awaitable instance
pk (int) – the pk of the awaitable’s target
-
remove_awaitable
(awaitable)[source]¶ Remove an awaitable.
Precondition: must be an awaitable that was previously inserted.
- Parameters
awaitable – the awaitable to remove
-
-
aiida.engine.processes.workchains.workchain.
if_
(condition)[source]¶ A conditional that can be used in a workchain outline.
Use as:
if_(cls.conditional)( cls.step1, cls.step2 )
Each step can, of course, also be any valid workchain step e.g. conditional.
- Parameters
condition – The workchain method that will return True or False
-
aiida.engine.processes.workchains.workchain.
while_
(condition)[source]¶ A while loop that can be used in a workchain outline.
Use as:
while_(cls.conditional)( cls.step1, cls.step2 )
Each step can, of course, also be any valid workchain step e.g. conditional.
- Parameters
condition – The workchain method that will return True or False