aiida-vasp/aiida-vasp

A plugin to AiiDA for running simulations with VASP

AiiDA VASP plugin

Release
Build
Stats

This is a plugin to AiiDA to run calculations with the ab-initio program VASP.

Please have a look at the AiiDA-VASP documentation for instructions on how to install and use the plugin.

Installing the plugin

1. If you are already using AiiDA, simply activate the virtual environment associated with it, here assumed to be located in ~/env/aiida-vasp:

   $ source ~/env/aiida-vasp/bin/activate

2. Otherwise, set up a new virtual environment:

   $ python -m venv ~/env/aiida-vasp

3. And then enable the newly installed virtual environment:

   $ source ~/env/aiida-vasp/bin/activate

4. Install the AiiDA-VASP plugin (and AiiDA if that is not already installed):

   $ (aiida-vasp) pip install aiida-vasp

If you need to install the compatibility release of AiiDA-VASP which works with AiiDA 1.6.4 you should instead install the plugin using pip install aiida-vasp=2.2, but this is not recommended and only mentioned for legacy support. For the legacy version you also most likely have to run reentry scan -r aiida after installing the plugin.

This will automatically install the AiiDA python package(s) as well as any other dependencies of the plugin and register all the plugin classes with AiiDA.

Please consider that AiiDA have prerequisite that needs to be installed and ensured working. The steps above will not take care of this for you. Please consult AiiDA prerequisites and follow the instructions therein.

Support

The development, maintenance and use of this plugin is considered a community effort. In order to facilitate for the community to contribute, we have established a space on Matrix that users can use to communicate. We encourage users to help each other. In addition, the development team is present in the space and users are free to ask. First consult the documentation of both AiiDA-VASP documentation and AiiDA documentation and also consider that the developers are not paid for this work. Please respect potential lead times in getting answers and be polite.

aiida-vasp's Issues

Request: Add pymatgen parser to setup.json

Hi there!

Would it be a problem to add the pymatgen parser entry to the setup.json? This way the parser is properly installed with the plugin and I have to modify anything from the code to use it.

Thanks.

https://github.com/DropD/aiida-vasp/blob/15a68a08fa0dfd329558ce19410a275aa2ba4caa/setup.json#L28

Base Workchain: Consider additional VASP step for parallelization params

It might be helpful to run a dummy calculation and then parse the correct parallelization parameters from the output.

There is an example of a similar process in the quantumespresso workchains

Put documentation on readthedocs

pmg-parser: add settings to suppress band structure / dos output nodes & parsing

Add rudimentary unit tests for VaspCalculation

add dos parsing to pymatgen parser

POSCAR generated incorrectly in fix-50

In fix-50 branch the POSCAR file is not generated correctly.
I experienced the issue running the simple Si example in examples directory:

ERROR: the triple product of the basis vectors is negative exchange two basis vectors

It works Ok in development branch.

pmg-parser: add born charges and epsilon

INCAR parsing: num * num is not parsed

lines like

MAGMOM = 0. * 600

are parsed into {'magmom': 0}.

Continuing the effort to make vasp parameter input nodes queryable, this should be parsed into a python value. However, actually converting it to [0.] * 6 is very space inefficient and may slow down querying.

A first approach should be to parse into something like

{'list': [0.], 'repetitions': 600}

And then adjust io.incar._incarify to parse dictionaries as repeated arrays back into '0. * 600' form.

Create a VaspImmmigrantCalculation analog to PwImmigrantCalculation (in aiida-quantumespresso)

Requirements:

• parser: INCAR -> ParameterData
• parser: POSCAR -> StructureData
• parser: POTCAR -> PotcarData, PotcarFileData
• parser: KPOINTS -> KpointsData

test and improve INCAR io

poscar written by vasp calcs can be malformed

See #34 for more info

Requirements for pre-commit hooks in 'dev' extra

The requirements for running the pre-commit hooks (I think yapf, prospector and pre-commit, but there might be more) should be a dev extra.

merge all vasp calculations into one

Suggestion: change results node name to ouput_parameters

If an ouput_parameters node is generated the contents can be easily accessed using verdi:

verdi calculation res pk_number

I can be a good idea to rename the results node name to get better integration with aiida

https://github.com/DropD/aiida-vasp/blob/317a9ce56d7c5a346f7332b51f9d05908fb0991b/aiida_vasp/parsers/vasp.py#L64

Redesign Potcar data nodes

Problem with current system

Currently licenced information is stored in PawData nodes which are also used as input nodes to VaspCalculations. This leads to a proveniency graph link from licenced data to every calculation. This in turn makes it illegal to share exported aiida-vasp calculations with non-license holders.

Tentative solution:

Split into two data classes. One holds the file and hash, one serves as a facade and only holds the hash. For both the hash must be unique, so that without having a link in the proveniency graph, we can find one from the other.

It is also possible to store multiple POTCAR files in a compressed archive (using ArchiveData).

The facade then serves as input to calculations, while whenever the file must be read or written, the full node is found via querying for the file hash.

For reading / writing the files pymatgen will be used

Why not links to file paths?

• file system links outside the repository break when exported data is imported on another machine. This makes manual intervention necessery everytime someone wishes to rerun an experiment from someone else
• files are mutable

Why not a environment variable like pymatgen?

• This requires a defined format for storing POTCAR files
• Reusing the one of pymatgen is possible but is an unneccessary dependency and requires even non-pymatgen users to configure pymatgen

Suggestion: Importing compressed PAW pseudopotentials

Maybe a good Idea to be able to import POSCAR files from PAW directory
directly in compressed form as they are distributed

Experiment with alternative storage format for POTCAR files

Try out the following ideas:

• PotcarFileStore: one node that stores all the files in one compressed archive.
• Storing only a setting with a path to where the files are stored (in original or pymatgen format)

Both of these require

• A user setting to choose between methods
• Changes to PotcarData.find_file_node()

Create a pymatgen based VaspCalculation parser

• unittests for BaseParser
• write very basic PymatgenParser with tests: kpoints and structure output nodes
• test PymatgenParser with broken xml -> #35
• add forces output node & tests
• add energies output node & tests
• add bandstructure output node & tests
• add DOS outupt node & tests
• add born charges, epsilon & tests

run unit tests in ci phase

add rudimentary pymatgen-parser with tests

Using example data from phonondb:

• test output kpoints
• test output structure

Request: energy and forces parsing

Hi,

I would like to use AiiDA to make phonon calculations.
Therefore I need this plugin to parse at least total energy and atomic forces to be able to test it.
I suggest to use the same quantumespresso scheme:
Energy in output_parameters node (ParametersData) and forces in output_array node (ArrayData).
Also to parse stress tensor would be nice.

I think it is important to keep the output structure as close as possible among all the plugins.
Then, developing workflows that work using many codes is much easier.

Thanks,

Keep a changelog

• read http://keepachangelog.com/en/1.0.0/
• Start keeping a Changelog.
• Automatically publish the Changelog

installation

I think that something has changed:
the installation looks for aiida-core/aiida/djsite/db/subtests while now it is aiida-core/aiida/backends/djsite. It seems that there is a backend more.

Empty res return (default parser output node names are outdated)

Seems res returns empty after finishing one of the examples:

(envaiida)[efl@efl examples]$ python run_vasp.py simple VASP computer
(envaiida)[efl@efl examples]$ verdi calculation list -a
# Last daemon state_updater check: 0h:00m:12s ago (at 09:53:18 on 2017-12-19)
PK Creation State Sched. state Computer Type
---- ---------- ---------------- -------------- ---------- ---------
427 4m ago WITHSCHEDULER QUEUED cluster2 vasp.vasp
432 2m ago FINISHED DONE cluster1 vasp.vasp
442 55s ago FINISHED DONE cluster1 vasp.vasp
(envaiida)[efl@efl examples]$ verdi calculation res 442
{}
(envaiida)[efl@efl examples]$
(envaiida)[efl@efl examples]$ verdi data bands list
ID formula ctime label
435 Si 19 Dec 2017
445 Si 19 Dec 2017
(envaiida)[efl@efl examples]$ verdi data structure list
ID formula label
431 Si
441 Si
(envaiida)[efl@efl examples]$ verdi data structure export --format xyz 441
1
Lattice="2.7 2.7 0.0 2.7 2.7 0.0 2.7 2.7 0.0" pbc="True True True"
Si 1.3500000000 1.3500000000 1.3500000000

Data is certainly there, at least partially. Happy to contribute.

Add unit tests where it makes sense

• VaspCalculation
• Vasp2W90Calculation
• VaspParser
• Vasp2W90Parser
• IO parsers / writers
• vasprun parser
• incar parser + writer
• kpoints parser + writer
• poscar parser + writer
• potcar parser + writer
• eigenval parser
• doscar parser
• utilities
• calculation builder

Check if badly ordered StructureData is translated into POSCAR correctly

POSCAR does not allow for example [Ti, O, Ti, O], instead the species have to be together as i [Ti, Ti, O, O].

replace current integration tests with CI-compatible ones

fixtures at: https://github.com/DropD/aiida_core/blob/plugin-fixtures/aiida/utils/fixtures.py

Revise logic for recognising static, relaxation, md, and cell shape relaxation in the vasprun parser

https://github.com/DropD/aiida-vasp/blob/437d0c40536938de4ecf991ec491b0b3d1db85d1/aiida_vasp/parsers/vasp.py#L148

Currently the unit cell is been taken from the output structure if is_md == true ( which is equivalent to IBRION !in [-1, 1, 2]). Whether or not the cell changes during a calculation is however determined by the value of ISIF and actually requires IBRION in [1, 2, 3]. If ISIF < 3 only the positions of the atoms are allowed to change. If ISIF >= 3 the cell shape or volume can change depending on the exact value of ISIF. The possible values for IBRION are:

• -1 = static calculation with increased accuracy for the eigenvalues
• 0 = Ab-initio molecular dynamics with a timestep provided by POTIM
• 1, 2, 3 = relaxation of atom positions and/or cell shape determined by ISIF
• >3 = Calculation of Hessian matrix

This might change the logic for is_static, is_md, and is_relaxation in io/vasprun.py as well. In particular even a calculation with IBRION = 1, 2, 3 can be considered static if NSW = 0, which means no ionic steps are taken.

Precision of POSCAR file insufficient

In the current implementation (development branch) the POSCAR files are generated with 6 decimal places. I think that this is not enough for high precision calculations. At least 10 decimal places are necessary.

Additions to max_retrieve_list

All electron calculations (ALL_ELECTRON or similar in INCAR):

• AECAR0-3 (valence, core charge densities etc)

Additional optional input

It is possible to give input files containing kernels for van der vaals density function. This should be an optional input file for vasp.vasp. The name for this file is vdw_kernel.bindat.

POSCAR sorting leads to swapped atomic position in output structure

It seems the default parser is mixing up the input structure with results for the sorted structure. I can see two solutions:

• Revise the parser and put rigorous tests in place, possibly change the sorting to only group together elements and never change the order
• Reject ungrouped structures and request the user group them before using them as input (much less work).

Ungrouped structures can and should actually be supported. It is simply a question of concatenating the POTCAR files in the same ungrouped order. This can even be desirable, as different potentials might be chosen for different sites with the same element.

pmg-vasprun-parser: add output_parameters node with energy and other properties

as requested in #33 (with reference snippet), part of #46, node name described in #30

Port workflows to workchains and workfunctions

Reinstate pre-commit tests

travis.yaml should not call tox directly but instead run_ci_tests.sh

parser: add forces output node

have the pymatgen based parser create a forces output node as requested in #33.

Add unit tests for BaseParser

find a way to add functional tests (submitting to VASP, checking output) to CI

Testing workchains is possible now using a mock-up of a VASP executable. This issue remains for the long term goal of implementing a test suite which does complete end-to-end tests of submitting to a remote computer running an actual instance of VASP.

About pymatgen plugin

I'm testing the VASP pymatgen parser and I noticed that the outputs are quite different from QE plugin.
Maybe my plugin is a little outdated. Do you know if this is the structure that they will use?

If not, theses are the suggestions for pymatgen parser outputs to make it closer to QE:

node name	contains
output_trajectory	structure, forces, stress tensor, energy, etc. at each electronic step
output_structure	structure
born_charges	born_charges and dielectric tensor

output_trajectory node is convenient for MD and optimizations but I think it is OK to create it
for any calculation so the access to forces and stress is common for all types of calculations.

output_structure node: since QE seems to use this name let's follow.

born_charges node is just for my convenience since I don't know how to obtain the born charges and dielectric tensor from QE (if it's possible). I need this information to calculate the non analytical correction for phonons so if they are together in one node it is easier for my workflows.

aiida-wannier90 should be an extras requirement

the wannier90 plugin is not required for usage of VASP only calculations

Error in run_vasp.py

Seems the msg is not a method of err and it complains if this line is reached:
https://github.com/DropD/aiida-vasp/blob/317a9ce56d7c5a346f7332b51f9d05908fb0991b/examples/run_vasp.py#L19

pmg-vasprun-parser: add bandstructure output node

typo in run_vasp.py example

ISMEAR should be integer

https://github.com/DropD/aiida-vasp/blob/164f3e10931674f82f3804ba83395560d7ebf832/examples/run_vasp.py#L140

There is no up to date example

All the scripts in examples as well as test are for the old AiiDA 0.7.0 version, a new minimal example is required.

Does the current version number make sense?

As far as I understand, the version was previously just tied to the AiiDA version. Since that no longer makes sense, should we reset the version number? Or just continue from here? Since there wasn't an official (PyPI) release yet, I think both options would be ok.

add test for importing potcar from compressed tar archive

Currently only an uncompressed tar archive is tested.

Suggestion: This example is a bit to complex

I experienced some issus with VASP compilation to run this example.
I think a simpler fast example should be better as a initial test example.
A simple prototype material like Si, MgO or NaCl could be a good option with a very
minimal input like:

PREC: NORMAL
ENCUT: 200
EDIFF: 1e-08
IALGO: 38
ISMEAR: 0.0
SIGMA: 0.1

The idea to use as few external packages as possible to create the structure is good.
For an initial test only aiida provided structure object method is better.

https://github.com/DropD/aiida-vasp/blob/317a9ce56d7c5a346f7332b51f9d05908fb0991b/examples/run_vasp.py#L68

Workchains: add generic base workchain

Starting point: https://github.com/mcallsen/DeltaDFT-experiments

make vasprun parser read unfinished vasprun.xml

When VASP crashes it does not close the vasprun xml tags but sometimes information can still be obtained from it. The parser should try it's best in this case (ad probably emit a warning)