These appendices consist of optional exercises, and are mentioned in earlier parts of the tutorial. Go through them only if you have time.
5. More workflow logic: while loops and conditional statements¶
In the previous sections, you have been introduced to
WorkChains, and the reason for using them over ‘standard’ work functions.
However, in the original example, the
spec.outline was quite simple, with a ‘static’ sequence of two steps.
Most often, however, you need dynamic workflows, where you need to decide at runtime whether to continue to compute or not (e.g. in a convergence loop, where you need to stop if convergence has been achieved).
To support this scenario, the
spec.outline can support logic: while loops and if/elif/else blocks.
The simplest way to explain it is to show an example:
from aiida.engine import if_, while_ spec.outline( cls.s1, if_(cls.isA)( cls.s2 ).elif_(cls.isB)( cls.s3 ).else_( cls.s4 ), cls.s5, while_(cls.condition)( cls.s6 ), )
that would roughly correspond, in a python syntax, to:
s1() if isA(): s2() elif isB(): s3() else: s4() s5() while condition(): s6()
The only constraint is that condition functions (in the example above
condition) must be class methods that returns
False depending on whether the condition is met or not.
A suggestion on how to write new workchains: use the outline to help you in designing the logic. First create the spec outline writing, almost if you were explaining it in words, what you expect the workflow to do. Then, define one by one the methods.
5.1. Pressure convergence¶
For example, we have prepared a simple workflow (using work chains, work functions and calculation functions) to optimize the lattice parameter of silicon efficiently using Newton’s algorithm on the energy derivative, i.e. the pressure .
You can download this code
The outline looks like this:
spec.outline( cls.setup, cls.put_step0_in_ctx, cls.move_next_step, while_(cls.not_converged)( cls.move_next_step, ), cls.finish )
This outline already roughly explains the algorithm: after an initialization (
setup) and putting the first step (number zero) in the ctx (
put_step0_in_ctx), a function to move to the next step is called (
This is iterated while a given convergence criterion is not met (
Finally, some reporting is done, including returning some output nodes (
If you are interested in the details of the algorithm, you can inspect the file. The main ideas are described here:
pw.x calculation for the input structure (with volume
(V)), and one for a structure where the volume is (just to get a closeby volume).
Store the results in the context as
Store in the context , and for the first calculation
This is the most important function. Calculate , and for
Also, estimate from the finite difference of the first derivative of
r1 (helper functions to achieve this are provided).
Get the , and coefficients of a parabolic fit and estimate the expected minimum of the EOS function as the minimum of the fit .
r1 in the context (i.e., get rid of the oldest point) and launch a new pw calculation at volume , that will be stored in the context replacing
In this way, at the next iteration
r1 will contain the latest two simulations.
Finally, at each step some relevant information (coefficients , and , volumes, energies, energy derivatives, …) are stored in a list called
This whole list is stored in the context because it provides quantities to be preserved between different work chain steps.
True if convergence has not been achieved yet.
Convergence is achieved if the difference in volume between the two latest simulations is smaller than a given threshold
This is the final step.
Mainly, we return the output nodes:
steps with the list of results at each step, and
structure with the final converged structure.
The results returned in
steps can be used to represent the evolution of the minimisation algorithm.
A possible way to visualize it is presented in Fig. 5.5 obtained with an initial lattice constant of alat = 5.2.