def parse_win(self):
"""Create the wannier90 .win file and kpoints output nodes."""
win = self.get_file('wannier90.win')
if not win:
return False, None, None, None
win_result = WinParser(win).result
# remove kpoints block from parameters
kpoints = win_result.pop('kpoints', None)
success, kpoints_node = self.convert_kpoints(kpoints)
# remove structure (cannot be given in parameters)
win_result.pop('unit_cell_cart', None)
win_result.pop('atoms_cart', None)
projections = win_result.pop('projections', None)
if projections is None:
proj_node = None
else:
proj_node = List()
proj_node.extend(projections)
param_node = DataFactory('parameter')(dict=win_result)
return success, kpoints_node, param_node, proj_node
def test_full_nio_afm(new_database):
from aiida.orm import DataFactory
from aiida_crystal17.workflows.cry_main_immigrant import migrate_as_main
# from aiida.common.datastructures import calc_states
work_dir = TEST_DIR
inpath = os.path.join("input_files", 'nio_sto3g_afm.crystal.d12')
outpath = os.path.join("output_files", 'nio_sto3g_afm.crystal.out')
node = migrate_as_main(
work_dir,
inpath,
outpath,
input_links={
'structure': {
"struct_setup": DataFactory('parameter')()
}
})
print(list(node.attrs()))
assert node.is_stored
assert set(node.get_inputs_dict().keys()) == set(
['basis_Ni', 'basis_O', 'parameters', 'structure', 'settings'])
struct = node.inp.structure
assert "struct_setup" in struct.get_inputs_dict()[
'structure'].get_inputs_dict()
print(node.get_outputs_dict())
assert set(node.get_outputs_dict().keys()).issuperset(
['output_parameters', 'retrieved'])
assert '_aiida_cached_from' not in node.extras()
def inner(projections_dict={'kind_name': 'As', 'ang_mtm_name': 'sp3'}):
from aiida.orm import DataFactory, CalculationFactory
from aiida_wannier90.orbitals import generate_projections
res = dict()
a = 5.367 * pymatgen.core.units.bohr_to_ang
structure_pmg = pymatgen.Structure(lattice=[[-a, 0, a], [0, a, a],
[-a, a, 0]],
species=['Ga', 'As'],
coords=[[0] * 3, [0.25] * 3])
structure = DataFactory('structure')()
structure.set_pymatgen_structure(structure_pmg)
res['structure'] = structure
res['projections'] = generate_projections(projections_dict,
structure=structure)
KpointsData = DataFactory('array.kpoints')
kpoints = KpointsData()
kpoints.set_kpoints_mesh([2, 2, 2])
res['kpoints'] = kpoints
kpoint_path_tmp = KpointsData()
kpoint_path_tmp.set_cell_from_structure(structure)
kpoint_path_tmp.set_kpoints_path()
point_coords, path = kpoint_path_tmp.get_special_points()
kpoint_path = DataFactory('parameter')(dict={
'path': path,
'point_coords': point_coords,
})
res['kpoint_path'] = kpoint_path
res['parameters'] = DataFactory('parameter')(
dict=dict(num_wann=4, num_iter=12, wvfn_formatted=True))
return res
# -*- coding: utf-8 -*-
from __future__ import division
import aiida.common
from aiida.common import aiidalogger
from aiida.orm.workflow import Workflow
from aiida.orm import Code, Computer
from aiida.orm import CalculationFactory, DataFactory
from aiida.orm.utils import load_node
__copyright__ = u"Copyright (c), This file is part of the AiiDA platform. For further information please visit http://www.aiida.net/. All rights reserved."
__license__ = "MIT license, see LICENSE.txt file."
__version__ = "0.7.0"
__authors__ = "The AiiDA team."
LapwbasisData = DataFactory('lapwbasis')
ParameterData = DataFactory('parameter')
KpointsData = DataFactory('array.kpoints')
StructureData = DataFactory('structure')
logger = aiidalogger.getChild('WorkflowStressTensor')
## ===============================================
## Workflow_LAPW_Stress_Tensor_Lagrange
## ===============================================
class Workflow_LAPW_stress_tensor_Lagrange(Workflow):
def __init__(self, **kwargs):
super(Workflow_LAPW_stress_tensor_Lagrange, self).__init__(**kwargs)
"""AiiDA - Workflow to get bandstructure of a material using VASP"""
from aiida.common import aiidalogger
from aiida.orm.workflow import Workflow
from aiida.orm import DataFactory
from aiida_vasp.calcs.maker import VaspMaker
LOGGER = aiidalogger.getChild('Bandstructure')
PARAMETER_CLS = DataFactory('parameter')
class Bandstructure(Workflow):
"""
AiiDA workflow to get bandstructure of a material using VASP.
Necessary steps are:
* selfconsistent run with few kpoints
* nonselfconsistent run with more kpoints and CHGCAR from
selfconsistent run
"""
def get_calc_maker(self):
"""Return an VaspMaker instance."""
from aiida.orm import Code
params = self.get_parameters()
maker = VaspMaker(structure=params['structure'])
maker.add_parameters(icharg=0,
istart=0,
lorbit=11,
lsorbit=True,
sigma=0.05,
ismear=0,
from distutils.spawn import find_executable
from tempfile import NamedTemporaryFile
from subprocess import Popen, PIPE, STDOUT
from pymatgen import Structure, Lattice
from pymatgen.io.cif import CifWriter
import numpy as np
from sys import path
from aiida.orm import Str, Bool, Int, Float
from aiida.orm import DataFactory
from aiida.work.workchain import WorkChain, if_, while_, return_
path.insert(0, 'GLOSIM2')
from libmatch.soap import get_soap
from libmatch.utils import ase2qp, get_spkit, get_spkitMax
StructureData = DataFactory('structure')
class SOAP(WorkChain):
@classmethod
def define(cls, spec):
super(SOAP, cls).define(spec)
spec.input('aiida_structure', valid_type=StructureData)
spec.input('spkit_max', valid_type=ParameterData)
spec.input('aononymize', valid_type=Bool, default=Bool(True))
spec.input('scale', valid_type=Bool, default=Bool(True))
spec.input('scale_per', valid_type=Str, default=Str('site'))
spec.input('soapargs', valid_type=ParameterData, required=False)
spec.outline(
cls.get_quippy_atoms,
def datify(type_or_str):
if isinstance(type_or_str, str):
return DataFactory(type_or_str)
return type_or_str
quasiparticle = False
from aiida import load_dbenv
from aiida.orm import Code, DataFactory
from aiida.orm.calculation.inline import make_inline
from aiida.orm.workflow import Workflow
if quasiparticle:
from aiida.workflows.wf_quasiparticle import WorkflowQuasiparticle as WorkflowPhonon
else:
from aiida.workflows.wf_phonon import WorkflowPhonon
from aiida.orm import load_workflow
StructureData = DataFactory('structure')
ParameterData = DataFactory('parameter')
ArrayData = DataFactory('array')
@make_inline
def calculate_qha_inline(**kwargs):
from phonopy import PhonopyQHA
from phonopy.structure.atoms import Atoms as PhonopyAtoms
import numpy as np
# structures = kwargs.pop('structures')
# optimized_data = kwargs.pop('optimized_data')
# thermodyamic_properties = kwargs.pop('thermodyamic_properties')
# This file is used to generate inputs for the 3 different supported codes: VASP, QE and LAMMPS. This is implemented
# in 3 functions: generate_vasp_params(), generate_qe_params() and generate_lammps_params().
# generate_inputs() function at the end of the file decides which function to use according to the plugin
from aiida.orm import Code, CalculationFactory, DataFactory
from aiida.common.exceptions import InputValidationError
KpointsData = DataFactory("array.kpoints")
ParameterData = DataFactory('parameter')
StructureData = DataFactory('structure')
# Function obtained from aiida's quantumespresso plugin. Copied here for convenience
def get_pseudos_qe(structure, family_name):
"""
Set the pseudo to use for all atomic kinds, picking pseudos from the
family with name family_name.
:note: The structure must already be set.
:param family_name: the name of the group containing the pseudos
"""
from collections import defaultdict
from aiida.orm.data.upf import get_pseudos_from_structure
# A dict {kind_name: pseudo_object}
kind_pseudo_dict = get_pseudos_from_structure(structure, family_name)
# We have to group the species by pseudo, I use the pseudo PK
# pseudo_dict will just map PK->pseudo_object
pseudo_dict = {}
import json
from aiida.orm.calculation.job import JobCalculation
from aiida.common.utils import classproperty
from aiida.common.exceptions import (InputValidationError, ValidationError)
from aiida.common.datastructures import (CalcInfo, CodeInfo)
from aiida.orm import DataFactory
MultiplyParameters = DataFactory('template.factors')
class MultiplyCalculation(JobCalculation):
'''AiiDA calculation plugin for simple "multiplication"
Simple AiiDA plugin for wrapping a code that adds two numbers.
'''
def _init_internal_params(self):
# reuse base class function
super(MultiplyCalculation, self)._init_internal_params()
self._INPUT_FILE_NAME = 'in.json'
self._OUTPUT_FILE_NAME = 'out.json'
# template.product entry point defined in setup.json
self._default_parser = 'template.product'
@classproperty
def _use_methods(cls):
"""Add use_* methods for calculations.
Code below enables the usage
my_calculation.use_parameters(my_parameters)
class VaspMaker(object):
"""
Simplifies creating a Scf, Nscf or AmnCalculation from scratch interactively or as a copy or continuation of a previous calculation.
Further simplifies creating certain often used types of calculations.
Most of the required information can be given as keyword arguments to
the constructor or set via properties later on.
The input information is stored in the instance and the calculation
is only built in the :py:meth:`new` method. This also makes it possible
to create a set of similar calculations in an interactive setting very
quickly.
:param structure: A StructureData node or a
(relative) path to either a .cif file or a POSCAR file. Defaults to
a new empty structure node recieved from calc_cls.
:type structure: str or StructureData
:keyword calc_cls: the class that VaspMaker will use when creating
Calculation nodes.
defaults to 'vasp.vasp'.
if a string is given, it will be passed to aiida's CalculationFactory
:type calc_cls: str or vasp.BasicCalculation subclass
:keyword continue_from: A vasp calculation node with charge_density and
wavefunction output links. VaspMaker will create calculations that
start with those as inputs.
:type continue_from: vasp calculation node
:keyword copy_from: A vasp calculation. It's inputs will be used as
defaults for the created calculations.
:type copy_from: vasp calculation node
:keyword charge_density: chargedensity node from a previously run
calculation
:type charge_density: ChargedensityData
:keyword wavefunctions: wavefunctions node from a previously run
calculation
:type wavefunctions: WavefunData
:keyword array.KpointsData kpoints: kpoints node to use for input
:keyword str paw_family: The name of a PAW family stored in the db
:keyword str paw_map: A dictionary mapping element symbols -> PAW symbols
:keyword str label: value for the calculation label
:keyword str computer: computer name, defaults to code's if code is given
:keyword str code: code name, if any Calculations are given, defaults to their code
:keyword str resources: defaults to copy_from.get_resources() or None
:keyword str queue: defaults to queue from given calculation, if any, or None
.. py:method:: new()
:returns: an instance of :py:attr:`calc_cls`, initialized with the data held by the VaspMaker
.. py:method:: add_parameters(**kwargs)
Adds keys to the parameters (INCAR keywords), if parameters is already
stored, makes a copy.
Does not overwrite previously set keywords.
.. py:method:: rewrite_parameters(**kwargs)
Same as :py:meth:`add_parameters`, but also overwrites keywords.
.. py:attribute:: structure
Used to initialize the created calculations as well as other nodes
(like kpoints).
When changed, can trigger changes in other data nodes.
.. py:attribute:: calc_cls
Vasp calculation class to be used in :py:meth:`new`
.. py:attribute:: computer
.. py:attribute:: code
.. py:attribute:: queue
.. py:attribute:: parameters
A readonly shortcut to the contents of the parameters node
.. py:attribute:: kpoints
The kpoints node to be used, may be copied to have py:func:set_cell
called.
.. py:attribute:: wavefunction
.. py:attribute:: charge_density
.. py:attribute:: elements
Chemical symbols of the elements contained in py:attr:structure
"""
def __init__(self, *args, **kwargs):
self._recipe = None
self._parameters = None
self._queue = None
self._computer = None
self._code = None
self._wannier_data = None
self._charge_density = None
self._wavefunctions = None
self._wannier_parameters = None
self._kpoints = None
self._structure = None
self._init_defaults(*args, **kwargs)
self._calcname = kwargs.get('calc_cls')
if 'continue_from' in kwargs:
self._init_from(kwargs['continue_from'])
if 'copy_from' in kwargs:
self._copy_from(kwargs['copy_from'])
def _init_defaults(self, *args, **kwargs): # pylint: disable=unused-argument
"""Set default values"""
calcname = kwargs.get('calc_cls', 'vasp.vasp')
if isinstance(calcname, (str, unicode)):
self.calc_cls = CalculationFactory(calcname)
else:
self.calc_cls = calcname
self.label = kwargs.get('label', 'unlabeled')
self._computer = kwargs.get('computer')
self._code = kwargs.get('code')
self._parameters = kwargs.get('parameters',
self.calc_cls.new_parameters())
self._set_default_structure(kwargs.get('structure'))
self._paw_fam = kwargs.get('paw_family', 'PBE')
self._paw_def = kwargs.get('paw_map')
self._paws = {}
self._set_default_paws()
self._kpoints = kwargs.get('kpoints', self.calc_cls.new_kpoints())
self.kpoints = self._kpoints
self._charge_density = kwargs.get('charge_density', None)
self._wavefunctions = kwargs.get('wavefunctions', None)
self._wannier_parameters = kwargs.get('wannier_parameters', None)
self._wannier_data = kwargs.get('wannier_data', None)
self._recipe = None
self._queue = kwargs.get('queue')
self._resources = kwargs.get('resources', {})
def _copy_from(self, calc):
"""Copy data links from another calculation"""
ins = calc.get_inputs_dict()
if not self._calcname:
self.calc_cls = calc.__class__
self.label = calc.label + '_copy'
self._computer = calc.get_computer()
self._code = calc.get_code()
self._parameters = ins.get('parameters')
self._structure = ins.get('structure')
self._paws = {}
for paw in [i for i in ins.iteritems() if 'paw' in i[0]]:
self._paws[paw[0].replace('paw_', '')] = paw[1]
self._kpoints = ins.get('kpoints')
self._charge_density = ins.get('charge_density')
self._wavefunctions = ins.get('wavefunctions')
self._wannier_parameters = ins.get('wannier_parameters')
self._wannier_data = ins.get('wannier_data')
self._queue = calc.get_queue_name()
self._resources = calc.get_resources()
def _set_default_structure(self, structure):
"""Set a structure depending on what was given, empty if nothing was given"""
if not structure:
self._structure = self.calc_cls.new_structure()
elif isinstance(structure, (str, unicode)):
structure = os.path.abspath(os.path.expanduser(structure))
if os.path.splitext(structure)[1] == '.cif':
self._structure = DataFactory('cif').get_or_create(
structure)[0]
elif os.path.basename(structure) == 'POSCAR':
from ase.io.vasp import read_vasp
atoms = read_vasp(os.path.abspath(structure))
self._structure = self.calc_cls.new_structure()
self._structure.set_ase(atoms)
else:
self._structure = structure
def _init_from(self, prev):
"""Initialize from an already run calculation"""
out = prev.get_outputs_dict()
self._copy_from(prev)
if 'structure' in out:
self.structure = prev.out.structure
self.rewrite_parameters(istart=1, icharg=11)
self.wavefunctions = prev.out.wavefunctions
self.charge_density = prev.out.charge_density
self._wannier_parameters = out.get('wannier_parameters',
self._wannier_parameters)
self._wannier_data = out.get('wannier_data', self.wannier_data)
def new(self):
"""Create a new, unstored Calculation node from previously set properties."""
calc = self.calc_cls()
calc.use_code(self._code)
calc.use_structure(self._structure)
for k in self.elements:
calc.use_paw(self._paws[k], kind=k)
calc.use_parameters(self._parameters)
calc.use_kpoints(self._kpoints)
calc.set_computer(self._computer)
calc.set_queue_name(self._queue)
if self._charge_density:
calc.use_charge_density(self._charge_density)
if self._wavefunctions:
calc.use_wavefunctions(self._wavefunctions)
if self._wannier_parameters:
calc.use_wannier_parameters(self._wannier_parameters)
if self._wannier_data:
calc.use_wannier_data(self._wannier_data)
calc.label = self.label
calc.set_resources(self._resources)
return calc
@property
def structure(self):
return self._structure
@structure.setter
def structure(self, val):
self._set_default_structure(val)
self._set_default_paws()
if self._kpoints.pk:
self._kpoints = self._kpoints.copy()
self._kpoints.set_cell(self._structure.get_ase().get_cell())
@property
def parameters(self):
return self._parameters.get_dict()
@property
def kpoints(self):
return self._kpoints
@kpoints.setter
def kpoints(self, kpoints):
self._kpoints = kpoints
self._kpoints.set_cell(self._structure.get_ase().get_cell())
def set_kpoints_path(self, value=None, weights=None, **kwargs):
"""
Calls kpoints' set_kpoints_path method with value, automatically adds weights.
Copies the kpoints node if it's already stored.
"""
if self._kpoints.is_stored:
self.kpoints = self.calc_cls.new_kpoints()
self._kpoints.set_kpoints_path(value=value, **kwargs)
if not weights:
kp_list = self._kpoints.get_kpoints()
weights = [1. for _ in kp_list]
self._kpoints.set_kpoints(kp_list, weights=weights)
def set_kpoints_mesh(self, *args, **kwargs):
"""Passes arguments on to kpoints.set_kpoints_mesh, copies if it was already stored."""
if self._kpoints.pk:
self.kpoints = self.calc_cls.new_kpoints()
self._kpoints.set_kpoints_mesh(*args, **kwargs)
def set_kpoints_list(self, kpoints, weights=None, **kwargs):
"""Passes arguments on to kpoints.set_kpoints, copies if it was already stored."""
import numpy as np
if self._kpoints.pk:
self.kpoints = self.calc_cls.new_kpoints()
if not weights:
weights = np.ones(len(kpoints), dtype=float)
self._kpoints.set_kpoints(kpoints, weights=weights, **kwargs)
@property
def wavefunctions(self):
return self._wavefunctions
@wavefunctions.setter
def wavefunctions(self, val):
self._wavefunctions = val
self.add_parameters(istart=1)
@property
def charge_density(self):
return self._charge_density
@charge_density.setter
def charge_density(self, val):
self._charge_density = val
self.add_parameters(icharg=11)
@property
def wannier_parameters(self):
return self._wannier_parameters
@wannier_parameters.setter
def wannier_parameters(self, val):
self._wannier_parameters = val
if 'lwannier90' not in self.parameters:
self.add_parameters(lwannier90=True)
@property
def wannier_data(self):
return self._wannier_data
@wannier_data.setter
def wannier_data(self, val):
self._wannier_data = val
@property
def code(self):
return self._code
@code.setter
def code(self, val):
self._code = val
self._computer = val.get_computer()
@property
def computer(self):
return self._computer
@computer.setter
def computer(self, val):
self._computer = val
@property
def queue(self):
return self._queue
@queue.setter
def queue(self, val):
self._queue = val
@property
def resources(self):
return self._resources
@resources.setter
def resources(self, val):
if isinstance(val, dict):
self._resources.update(val)
else:
self._resources['num_machines'] = val[0]
self._resources['num_mpiprocs_per_machine'] = val[1]
def add_parameters(self, **kwargs):
"""Add additional parameters to the generated calculation, does not override existing parameters."""
if self._parameters.pk:
self._parameters = self._parameters.copy()
for key, value in kwargs.iteritems():
if key not in self.parameters:
self._parameters.update_dict({key: value})
def rewrite_parameters(self, **kwargs):
if self._parameters_conflict(kwargs):
if self._parameters.pk:
self._parameters = self._parameters.copy()
self._parameters.update_dict(kwargs)
def _parameters_conflict(self, parameters):
conflict = False
for key, value in parameters.iteritems():
conflict |= (self.parameters.get(key) != value)
return conflict
def _set_default_paws(self):
"""Set default POTCAR potentials from the given mapping."""
for key in self.elements:
if key not in self._paws:
if self._paw_def is None:
raise ValueError(
"The 'paw_map' keyword is required. Pre-defined potential "
"mappings are defined in 'aiida.tools.codespecific.vasp.default_paws'."
)
try:
paw = self.calc_cls.Paw.load_paw(
family=self._paw_fam, symbol=self._paw_def[key])[0]
except KeyError:
raise ValueError(
"The given 'paw_map' does not contain a mapping for element '{}'"
.format(key))
self._paws[key] = paw
@property
def elements(self):
return ordered_unique_list(
self._structure.get_ase().get_chemical_symbols())
@staticmethod
def compare_pk(node_a, node_b):
"""Compare two nodes by primary key"""
if node_a.pk < node_b.pk:
return -1
elif node_a.pk > node_b.pk:
return 1
return 0
def verify_parameters(self):
"""
Verify input parameters
:return: (bool, string) success, message
"""
if not self._structure:
raise ValueError('need structure,')
magmom = self.parameters.get('magmom', [])
lsorb = self.parameters.get('lsorbit', False)
lnonc = self.parameters.get('lnoncollinear', False)
parameters_ok = True
msg = 'Everything ok'
nmag = len(magmom)
nsit = self.n_ions
if lsorb:
if lnonc:
if magmom and not nmag == 3 * nsit:
parameters_ok = False
msg = 'magmom has wrong dimension'
else:
if magmom and not nmag == nsit:
parameters_ok = False
msg = 'magmom has wrong dimension'
else:
if magmom and not nmag == nsit:
parameters_ok = False
msg = 'magmom has wrong dimension'
return parameters_ok, msg
def check_magmom(self):
"""Check that the magnetic moment given in parameters matches the one of the structure"""
magnetic_moment = self.parameters.get('magmom', [])
structure_mm = self._structure.get_ase().get_initial_magnetic_moments()
lsf = 3 if self.noncol else 1
nio = self.n_ions
structure_mm_dim = nio * lsf
magnetic_moment_dim = len(magnetic_moment)
if magnetic_moment and structure_mm:
return structure_mm_dim == magnetic_moment_dim
return True
def set_magmom_1(self, val):
magmom = [val]
magmom *= self.n_ions
magmom *= self.noncol and 3 or 1
self.rewrite_parameters(magmom=magmom)
@property
def nbands(self):
return self.n_ions * 3 * (self.noncol and 3 or 1)
@property
def n_ions(self):
return self.structure.get_ase().get_number_of_atoms()
@property
def n_elec(self):
"""Get the number of electrons based on the chemical symbols."""
res = 0
for k in self._structure.get_ase().get_chemical_symbols():
res += self._paws[k].valence
return res
@property
def noncol(self):
lsorb = self.parameters.get('lsorbit', False)
lnonc = self.parameters.get('lnoncollinear', False)
return lsorb or lnonc
@property
def icharg(self):
return self.parameters.get('icharg', 'default')
@icharg.setter
def icharg(self, value):
if value not in [0, 1, 2, 4, 10, 11, 12]:
raise ValueError('invalid ICHARG value for vasp 5.3.5')
else:
self.parameters['icharg'] = value
@property
def recipe(self):
return self._recipe
@recipe.setter
def recipe(self, val):
if self._recipe and self._recipe != val:
raise ValueError('recipe is already set to something else')
self._init_recipe(val)
self._recipe = val
def _init_recipe(self, recipe):
if recipe == 'test_sc':
self._init_recipe_test_sc()
else:
raise ValueError('recipe not recognized')
def _init_recipe_test_sc(self):
self.add_parameters(
gga='PE',
gga_compat=False,
ismear=0,
lorbit=11,
lsorbit=True,
sigma=0.05,
)
from aiida.orm import load_node
from aiida.orm.code import Code
from aiida.orm.data.base import Bool, Str
from aiida.work import workfunction as wf
from aiida.work.run import run, submit
from aiida.work.workchain import WorkChain, ToContext, if_, while_, Outputs
# subworkflows
from workflows.charges import DdecChargesWorkChain
from aiida_raspa.workflows import RaspaConvergeWorkChain
# calculations
ZeoppCalculation = CalculationFactory('zeopp.network')
# data objects
ArrayData = DataFactory('array')
CifData = DataFactory('cif')
NetworkParameters = DataFactory('zeopp.parameters')
ParameterData = DataFactory('parameter')
RemoteData = DataFactory('remote')
StructureData = DataFactory('structure')
@wf
def from_cif_to_structuredata(cif):
"""Helper function that converts CifData object into StructureData"""
a = cif.get_ase()
return StructureData(ase=a)
class Isotherm(WorkChain):
#!/usr/bin/env runaiida
# -*- coding: utf-8 -*-
import sys
import os
from aiida.orm import DataFactory, CalculationFactory
from aiida.common.example_helpers import test_and_get_code
from aiida.orm.data.base import List
from aiida.orm import Code
from aiida.orm import DataFactory
import pymatgen
from aiida.work.run import submit
from aiida_yambo.calculations.gw import YamboCalculation
from aiida_quantumespresso.calculations.pw import PwCalculation
from aiida.orm.data.upf import UpfData, get_pseudos_from_structure
ParameterData = DataFactory('parameter')
parameters = ParameterData(
dict={
'CONTROL': {
'calculation': 'nscf',
'restart_mode': 'from_scratch',
'wf_collect': True,
'verbosity': 'high',
},
'SYSTEM': {
'ecutwfc': 80.,
'nbnd': 50,
'force_symmorphic': True,
},
'ELECTRONS': {
def _get_bands(self):
"""
Create a bands and a kpoints node from values in eigenvalue.
:returns: bsnode, kpout
* bsnode: BandsData containing eigenvalues from EIGENVAL
and occupations from vasprun.xml
* kpout: KpointsData containing kpoints from EIGENVAL,
both bsnode as well as kpnode come with cell unset
"""
eig = self.get_file('EIGENVAL')
if not eig:
return {'bands': None, 'kpoints': None}
_, kpoints, bands = EigParser.parse_eigenval(eig)
bsnode = DataFactory('array.bands')()
kpout = DataFactory('array.kpoints')()
# Take the output structure if available.
structure = None
if 'structure' in self._output_nodes:
structure = self._output_nodes['structure']
if structure is None:
structure = self._calc.inp.structure
bsnode.set_cell(structure.get_ase().get_cell())
kpout.set_cell(structure.get_ase().get_cell())
if self._calc.inp.kpoints.get_attrs().get('array|kpoints'):
bsnode.set_kpointsdata(self._calc.inp.kpoints)
if self._calc.inp.kpoints.labels:
bsnode.labels = self._calc.inp.kpoints.labels
else:
bsnode.set_kpoints(kpoints[:, :3],
weights=kpoints[:, 3],
cartesian=False)
bsnode.set_bands(bands,
occupations=self._parsers['vasprun.xml'].occupations)
kpout.set_kpoints(kpoints[:, :3],
weights=kpoints[:, 3],
cartesian=False)
return {'bands': bsnode, 'kpoints': kpout}
from __future__ import print_function
from aiida.orm import CalculationFactory, DataFactory
from aiida.orm.code import Code
from aiida.work import workfunction as wf
from aiida.work.run import submit
from aiida.work.workchain import WorkChain, ToContext, Outputs
from aiida_cp2k.workflows import Cp2kDftBaseWorkChain
from copy import deepcopy
# calculations
DdecCalculation = CalculationFactory('ddec')
# data objects
CifData = DataFactory('cif')
ParameterData = DataFactory('parameter')
RemoteData = DataFactory('remote')
StructureData = DataFactory('structure')
def dict_merge(dct, merge_dct):
""" Taken from https://gist.github.com/angstwad/bf22d1822c38a92ec0a9
Recursive dict merge. Inspired by :meth:``dict.update()``, instead of
updating only top-level keys, dict_merge recurses down into dicts nested
to an arbitrary depth, updating keys. The ``merge_dct`` is merged into
``dct``.
:param dct: dict onto which the merge is executed
:param merge_dct: dct merged into dct
:return: None
"""
import collections
#!/usr/bin/env python
"""
This test runs the fleur_convergence workflow for path 2
"""
#TODO: overall tests, should create the nodes they use in the db.
from aiida import load_dbenv, is_dbenv_loaded
if not is_dbenv_loaded():
load_dbenv()
from aiida.orm import Code, DataFactory
from aiida.orm import load_node
#from aiida.work.run import async, run
from aiida_fleur.workflows.scf import fleur_scf_wc
StructureData = DataFactory('structure')
ParameterData = DataFactory('parameter')
KpointsData = DataFactory('array.kpoints')
#FleurinpData = DataFactory('fleurinp.fleurinp')
FleurinpData = DataFactory('fleur.fleurinp')
###############################
# Set your values here
codename = 'inpgen_iff@local_iff' #'inpgen_mac_30_11_2016@local_mac'
codename2 = 'fleur_iff@local_iff' #'fleur_mac_v0_27@local_mac'
###############################
code = Code.get_from_string(codename)
code2 = Code.get_from_string(codename2)
wf_para = ParameterData(
dict={
from aiida.work.workfunction import workfunction
from aiida.orm import Code, CalculationFactory, load_node, DataFactory, WorkflowFactory
from aiida.work.run import run, submit
from aiida.orm.data.base import Str, Float, Bool, Int
from aiida.work.workchain import _If, _While
import numpy as np
from aiida_phonopy.common.generate_inputs import generate_inputs
# Should be improved by some kind of WorkChainFactory
# For now all workchains should be copied to aiida/workflows
# from aiida.workflows.wc_optimize import OptimizeStructure
ForceConstantsData = DataFactory('phonopy.force_constants')
ForceSetsData = DataFactory('phonopy.force_sets')
BandStructureData = DataFactory('phonopy.band_structure')
PhononDosData = DataFactory('phonopy.phonon_dos')
NacData = DataFactory('phonopy.nac')
ParameterData = DataFactory('parameter')
ArrayData = DataFactory('array')
StructureData = DataFactory('structure')
OptimizeStructure = WorkflowFactory('phonopy.optimize')
__testing__ = False
@workfunction
__authors__ = "The AiiDA team."
import sys
import os
from aiida.common.example_helpers import test_and_get_code
from aiida.orm import DataFactory
from aiida.common.exceptions import NotExistent
# If set to True, will ask AiiDA to run in serial mode (i.e., AiiDA will not
# invoke the mpirun command in the submission script)
run_in_serial_mode = False
################################################################
UpfData = DataFactory('upf')
ParameterData = DataFactory('parameter')
KpointsData = DataFactory('array.kpoints')
StructureData = DataFactory('structure')
try:
dontsend = sys.argv[1]
if dontsend == "--dont-send":
submit_test = True
elif dontsend == "--send":
submit_test = False
else:
raise IndexError
except IndexError:
print >> sys.stderr, ("The first parameter can only be either "
"--send or --dont-send")
sys.exit(1)
# -*- coding: utf-8 -*-
from __future__ import print_function
from __future__ import absolute_import
from aiida.common.example_helpers import test_and_get_code
from aiida.orm import DataFactory, CalculationFactory
from aiida.work.run import submit
from aiida.orm import load_node
# Data classes
CifData = DataFactory('cif')
ParameterData = DataFactory('parameter')
RaspaCalculation = CalculationFactory('raspa')
# Raspa input parameters
parameters = ParameterData(dict={
"GeneralSettings": {
"SimulationType" : "MonteCarlo",
"NumberOfCycles" : 1000,
"NumberOfInitializationCycles" : 1000,
"PrintEvery" : 100,
"CutOff" : 12.0, # (Angstroms)
"Forcefield" : "UFF-TraPPE",
"ChargeMethod" : "None",
"UnitCells" : "<int> <int> <int>",
"ExternalTemperature" : <float (K)>,
"ExternalPressure" : <float (Pa)>,
},
def generate_calculation_vasp(self,
structure,
parameters,
type='optimize',
pressure=0.0):
# import pymatgen as mg
from pymatgen.io import vasp as vaspio
ParameterData = DataFactory('parameter')
code = Code.get_from_string(parameters['code'])
# Set calculation
calc = code.new_calc(max_wallclock_seconds=3600,
resources=parameters['resources'])
calc.set_withmpi(True)
calc.label = 'VASP'
# POSCAR
calc.use_structure(structure)
# INCAR
incar = parameters['parameters']
if type == 'optimize':
vasp_input_optimize = dict(incar)
vasp_input_optimize.update({
'PREC': 'Accurate',
'ISTART': 0,
'IBRION': 2,
'ISIF': 3,
'NSW': 100,
'LWAVE': '.FALSE.',
'LCHARG': '.FALSE.',
'EDIFF': 1e-08,
'EDIFFG': -1e-08,
'ADDGRID': '.TRUE.',
'LREAL': '.FALSE.',
'PSTRESS': pressure
}) # unit: kb -> kB
incar = vasp_input_optimize
if type == 'optimize_constant_volume':
vasp_input_optimize = dict(incar)
vasp_input_optimize.update({
'PREC': 'Accurate',
'ISTART': 0,
'IBRION': 2,
'ISIF': 4,
'NSW': 100,
'LWAVE': '.FALSE.',
'LCHARG': '.FALSE.',
'EDIFF': 1e-08,
'EDIFFG': -1e-08,
'ADDGRID': '.TRUE.',
'LREAL': '.FALSE.'
})
incar = vasp_input_optimize
if type == 'forces':
vasp_input_forces = dict(incar)
vasp_input_forces.update({
'PREC': 'Accurate',
'ISYM': 0,
'ISTART': 0,
'IBRION': -1,
'NSW': 1,
'LWAVE': '.FALSE.',
'LCHARG': '.FALSE.',
'EDIFF': 1e-08,
'ADDGRID': '.TRUE.',
'LREAL': '.FALSE.'
})
incar = vasp_input_forces
if type == 'born_charges':
vasp_input_epsilon = dict(incar)
vasp_input_epsilon.update({
'PREC': 'Accurate',
'LEPSILON': '.TRUE.',
'ISTART': 0,
'IBRION': 1,
'NSW': 0,
'LWAVE': '.FALSE.',
'LCHARG': '.FALSE.',
'EDIFF': 1e-08,
'ADDGRID': '.TRUE.',
'LREAL': '.FALSE.'
})
incar = vasp_input_epsilon
# KPOINTS
kpoints = parameters['kpoints']
if 'kpoints_per_atom' in kpoints:
kpoints = vaspio.Kpoints.automatic_density(
structure.get_pymatgen_structure(),
kpoints['kpoints_per_atom'])
# num_kpoints = np.product(kpoints.kpts)
# if num_kpoints < 4:
# incar['ISMEAR'] = 0
# incar['SIGMA'] = 0.05
else:
if not 'style' in kpoints:
kpoints['style'] = 'Monkhorst'
# supported_modes = Enum(("Gamma", "Monkhorst", "Automatic", "Line_mode", "Cartesian", "Reciprocal"))
kpoints = vaspio.Kpoints(comment='aiida generated',
style=kpoints['style'],
kpts=(kpoints['points'], ),
kpts_shift=kpoints['shift'])
calc.use_kpoints(ParameterData(dict=kpoints.as_dict()))
# update incar (just in case something changed with kpoints)
incar = vaspio.Incar(incar)
calc.use_incar(ParameterData(dict=incar.as_dict()))
# POTCAR
pseudo = parameters['pseudo']
potcar = vaspio.Potcar(symbols=pseudo['symbols'],
functional=pseudo['functional'])
calc.use_potcar(ParameterData(dict=potcar.as_dict()))
# Parser settings
settings = {'PARSER_INSTRUCTIONS': []}
pinstr = settings['PARSER_INSTRUCTIONS']
pinstr.append({
'instr': 'array_data_parser',
'type': 'data',
'params': {}
})
pinstr.append({
'instr': 'output_parameters',
'type': 'data',
'params': {}
})
# additional files to return
settings.setdefault('ADDITIONAL_RETRIEVE_LIST', [
'vasprun.xml',
])
calc.use_settings(ParameterData(dict=settings))
calc.store_all()
return calc
