Working with other codes#

This section will show how to use aiida-vasp to work with other codes.

Atomic Simulation Environment (ASE)#

ASE can be used to setup input structure or analyse the outputs. The AiiDA core package already contains routines for converting ase.Atoms between aiida.orm.StructureData

from aiida import orm
structure = orm.StructureData(ase=ase_atoms)
atoms = structure.get_ase()

In addition, ASE can be very useful for visualizing the structures in a notebook environment.

from ase.visualize import view
view(structure_node.get_ase())

Hint

You may want to construct a view function in your ipython start file (~/.ipython/profile_default/startup/ase_view.py) to make it easier to visualize structures with automatic conversion.

try:
    import pymatgen
    import ase
except ImportError:
    pass
else:
    from pymatgen.io.ase import AseAtomsAdaptor
    from pymatgen.core import Structure
    from ase.visualize import view as aview

    def view(atoms, *args, **kwargs):
        """
        Allow viewing pymatgen.core.Structure using ase
        """
        if isinstance(atoms, (list, tuple)):
            if isinstance(atoms[0], Structure):
                atoms = [AseAtomsAdaptor.get_atoms(s) for s in atoms]
        elif isinstance(atoms, Structure):
            atoms = AseAtomsAdaptor.get_atoms(atoms)
        elif hasattr(atoms, 'get_ase'):   # check if a aiida.orm.StructureData
            atoms = atoms.get_ase()
        return aview(atoms, *args, **kwargs)

Pymatgen#

Structure conversion#

Similarly, pymatgen can be used to convert pymatgen.core.Structure to aiida.orm.StructureData and vice versa.

from aiida import orm
structure_node = orm.StructureData(pymatgen=pymatgen_structure)
pymatgen_structure = structure_node.get_pymatgen()

Then pymatgen’s analysis and visualization tools can be used as usual.

VASP IO with pymatgen#

Pymatgen also has its own classes for working with VASP calculations. These objects are not directly supported as inputs to VASP calculation in AiiDA-VASP. However, it is possible to load these objects from a finished VaspCalculation or VaspWorkChain and use them in subsequent analysis.

from aiida_vasp.utils.pmg import PymatgenAdapter

vasp_calc = load_node('<uuid>')
adapt = PymatgenAdapter(vasp_calc)
vasprun = adapt.vasprun  # Retrieve the pymatgen Vasprun object

This is possible by AiiDA-VASP preserves the original calculation output files in the storage. Behind the scene, the calculation folder is reconstructed inside a temporary directory.

Since exporting the raw files can be slow, cache has been implemented so it is possible to get objects without re-exporting the files every time a property is accessed. The caches stores the output of the as_dict of the corresponding python objects as the extras of the calculation node. Some object, cannot be reconstructed due to the limitations in pymatgen, but they can still be accessed as dictionaries with the property name suffixed with _dict.

from aiida_vasp.utils.pmg import PymatgenAdapter

vasp_calc = load_node('<uuid>')
# Using with block triggers the cache to be flushed into the storage
with PymatgenAdapter(vasp_calc) as adapt:
    vasprun = adapt.vasprun  # Retrieve the pymatgen Vasprun object

vdict = PymatgenAdapter(vasp_calc).vasprun_dict  # Access the vasprun as a dictionary - this will not export the files again

vasprun PymatgenAdapter(vasp_calc).vasprun  # This WILL re-export the files to the disk and parse using pymatgen again

Uploading pseduopotentials from a pymatgen installation#

If you have a pymatgen installation with VASP POTCARs configured (following this guide), you can use the verdi data vasp.potcar upload-from-pymatgen command to upload them to the AiiDA database. As in the normal upload, the family name must be specified. Pymatgen distinguishes different POTCAR sets as different functionals, so the functional must also be specified. The PBE.54 family mentioned in the documentation refers to the potpaw.54 POTCAR set, which is the PBE_54 functional as in pymatgen.

Note

Pymatgen defaults to the PBE POTCAR set (functional) which is quite OLD had been superseded by multiple updated sets . Certain POTCARs in this set can be problematic (such as the W_pv, which is removed in PBE_54). One should avoid using this set unless direct comparison of raw energies with the Materials Project is required.

Coming from pymatgen based workflows#

If you are coming from using pymatgen for setting up VASP input files, the BuilderUpdater interface would feel very familiar, which uses the same approach of using a preset of input parameters.

Consider the following code using pymatgen to set up a VASP calculation:

from pymatgen.core import Structure
from pymatgen.io.vasp.sets import MITRelaxSet

incar_dict = { 'EDIFFG': -1e-2, 'IVDW': 11, 'ISYM':2,'NSW':1500, 'ENCUT':520}
structure = Structure.from_file("Al_empty.cif")
inputset = MITRelaxSet(structure = structure,user_incar_settings=incar_dict,
                       user_kpoints_settings={'length':25})
inputset.write_input(output_dir='./DFT_calc',include_cif=True)

Which loads the Al_empty.cif file, sets up a MITRelaxSet with some user defined settings, and writes the input files to the DFT_calc directory.

To achieve a similar (but not equivalent) effect with aiida-vasp:

from aiida import orm
from pymatgen.core import Structure
from aiida_vasp.workchains.v2 import VaspBuilderUpdater

structure = Structure.from_file("Al_empty.cif")
overrides = { 'ediffg': -1e-2, 'ivdw': 11, 'isym':2,'nsw':1500, 'encut':520}
upd = VaspBuilderUpdater(inputset='MITRelaxSet').apply_preset(orm.StructureData(pymatgen=structure), code='vasp-6.4.2@localhost', overrides=overrides)
upd.set_resources(num_machines=1, tot_num_mpiprocs=16)
upd.set_options(max_wallclock_seconds=3600)
upd.set_kspacing(0.05)
upd.submit()

There are a few differences to note:

  1. The VaspBuilderUpdater class is used to set up the input parameters with presets, here we used the MITRelaxSet inputset preset which is based on the pymatgen’s MITRelaxSet.

  2. The apply_preset method takes an orm.StructureData as input, which is converted from a pymatgen Structure. This input structure is stored in the database as a StructureData node.

  3. The kpoints are configured with a spacing of 0.05 (*2pi), rather than being implicitly set by the VASP code itself. When using AiidA, it is preferable to store explicit kpoints (grid) in the database as KpointsData nodes.

  4. In addition to the calculation input, one needs to define resources requested from the computing cluster’s scheduler. This is because the submit method submits all calculation data to the daemon which takes care the rests, rather than having the user manually transfer the data to the remote machine, submit the job, and then retrieve the results. In fact, what gets submitted is a workflow which may apply automatic restarts and error corrections if needed.

There are also a few other input set such as MPRelaxSet and one can have their own input set files defined in the ~/.aiida-vasp/ folder. This folder will be searched first when looking for input sets.

The VaspBuilderUpdater also takes an argument of the preset name which gives a higher level of control over how the calculation should be configured. The preset includes which input set should be used, what overrides should be applied as well as how they should be adapted for different types of workflow as well as for different Code/Computers. For example, different NCORE may be applied when running VASP on different machines. In practice, we recommend uses to define their own preset rather than creating/modifying the input sets directly.

Since AiiDA can store the structure files as StructureData nodes, it is possible to first read files and then use a single structure as inputs to multiple subsequent calculations, rather than creating new but identical StructureData nodes each time that a calculation is submitted.

Note

We recommend using VaspRelaxUpdater rather than VaspBuilderUpdater for setting up VASP geometry optimisation calculations, as the former offers more checks and control for the optimisation process.

Sumo#

Sumo is a code for plotting electronic band structures and DOS. It can be used with calculations done by aiida-vasp. There are two ways to use sumo with this package:

  1. You can export the calculation with verdi data vasp.tools export <node> <folder> and then use sumo’s command line interface to plot. This approach works best for DOS plots and for band structure calculations the exported KPOINTS files currently does not have band labels.

  2. Use the vasp.utils.sumo module to plot the band structure from a band structure workflow with the get_sumo_dos_plotter and get_sumo_bands_plotter functions.

On this page
Edit on GitHub
Show Source