def main(code_string, incar, kmesh, structure, potential_family,
potential_mapping, options):
"""Main method to setup the calculation."""
# We set the workchain you would like to call
workchain = WorkflowFactory('vasp.relax')
# And finally, we declare the options, settings and input containers
settings = AttributeDict()
inputs = AttributeDict()
# Organize settings
settings.parser_settings = {}
# Set inputs for the following WorkChain execution
# Set code
inputs.code = Code.get_from_string(code_string)
# Set structure
inputs.structure = structure
# Set k-points grid density
kpoints = DataFactory('array.kpoints')()
kpoints.set_kpoints_mesh(kmesh)
inputs.kpoints = kpoints
# Set parameters
inputs.parameters = DataFactory('dict')(dict=incar)
# Set potentials and their mapping
inputs.potential_family = DataFactory('str')(potential_family)
inputs.potential_mapping = DataFactory('dict')(dict=potential_mapping)
# Set options
inputs.options = DataFactory('dict')(dict=options)
# Set settings
inputs.settings = DataFactory('dict')(dict=settings)
# Set workchain related inputs, in this case, give more explicit output to report
inputs.verbose = DataFactory('bool')(True)
# Relaxation related parameters that is passed to the relax workchain
relax = AttributeDict()
# Turn on relaxation
relax.perform = DataFactory('bool')(True)
# Select relaxation algorithm
relax.algo = DataFactory('str')('cg')
# Set force cutoff limit (EDIFFG, but no sign needed)
relax.force_cutoff = DataFactory('float')(0.01)
# Turn on relaxation of positions (strictly not needed as the default is on)
# The three next parameters correspond to the well known ISIF=3 setting
relax.positions = DataFactory('bool')(True)
# Turn on relaxation of the cell shape (defaults to False)
relax.shape = DataFactory('bool')(True)
# Turn on relaxation of the volume (defaults to False)
relax.volume = DataFactory('bool')(True)
# Set maximum number of ionic steps
relax.steps = DataFactory('int')(100)
# Set the relaxation parameters on the inputs
inputs.relax = relax
# Submit the requested workchain with the supplied inputs
submit(workchain, **inputs)
def vasp_kpoints(request, fresh_aiida_env):
"""Fixture: (kpoints object, resulting KPOINTS)."""
from aiida.plugins import DataFactory
if request.param == 'mesh':
kpoints = DataFactory('array.kpoints')()
kpoints.set_kpoints_mesh([2, 2, 2])
ref_kpoints = _ref_kp_mesh()
elif request.param == 'list':
kpoints = DataFactory('array.kpoints')()
kpoints.set_kpoints([[0., 0., 0.], [0., 0., .5]], weights=[1., 1.])
ref_kpoints = _ref_kp_list()
return kpoints, ref_kpoints
def _parse_kpoints(hdf5_handle):
type_tag = hdf5_handle['type_tag'].value
kpoints = DataFactory('array.kpoints')()
if 'kpoints_mesh' in type_tag:
kpoints.set_kpoints_mesh(
hdf5_handle['mesh'].value, hdf5_handle['offset'].value
)
elif 'kpoints_explicit' in type_tag:
kpoints.set_kpoints(hdf5_handle['kpoints'].value)
else:
raise NotImplementedError(
"Unrecognized type_tag '{}' encountered when parsing k-points data."
.format(type_tag)
)
return kpoints
def test_eigenvals(
configure_with_daemon, # pylint: disable=unused-argument
sample,
get_tbmodels_process_builder
):
"""
Test that the eigenvals calculation creates a bands output.
"""
from aiida.plugins import DataFactory
from aiida.engine import run
builder = get_tbmodels_process_builder('tbmodels.eigenvals')
builder.tb_model = DataFactory('singlefile')(file=sample('model.hdf5'))
k_mesh = DataFactory('array.kpoints')()
k_mesh.set_kpoints_mesh([4, 4, 4], offset=[0, 0, 0])
builder.kpoints = k_mesh
output = run(builder)
assert isinstance(output['bands'], DataFactory('array.bands'))
def get_builder(self,
structure,
calc_engines,
protocol,
relaxation_type,
threshold_forces=None,
threshold_stress=None,
previous_workchain=None,
**kwargs):
"""Return a process builder for the corresponding workchain class with inputs set according to the protocol.
:param structure: the structure to be relaxed
:param calc_engines: ...
:param protocol: the protocol to use when determining the workchain inputs
:param relaxation_type: the type of relaxation to perform, instance of `RelaxType`
:param threshold_forces: target threshold for the forces in eV/Å.
:param threshold_stress: target threshold for the stress in eV/Å^3.
:param kwargs: any inputs that are specific to the plugin.
:return: a `aiida.engine.processes.ProcessBuilder` instance ready to be submitted.
"""
# pylint: disable=too-many-locals
super().get_builder(structure, calc_engines, protocol, relaxation_type,
threshold_forces, threshold_stress,
previous_workchain, **kwargs)
# Get the protocol that we want to use
if protocol is None:
protocol = self._default_protocol
protocol = self.get_protocol(protocol)
# Set the builder
builder = self.process_class.get_builder()
# Set code
builder.code = Code.get_from_string(calc_engines['relax']['code'])
# Set structure
builder.structure = structure
# Set options
builder.options = DataFactory('dict')(
dict=calc_engines['relax']['options'])
# Set settings
# Make sure we add forces and stress for the VASP parser
settings = AttributeDict()
settings.update(
{'parser_settings': {
'add_forces': True,
'add_stress': True
}})
builder.settings = DataFactory('dict')(dict=settings)
# Set workchain related inputs, in this case, give more explicit output to report
builder.verbose = DataFactory('bool')(True)
# Set parameters
builder.parameters = DataFactory('dict')(dict=protocol['parameters'])
# Set potentials and their mapping
builder.potential_family = DataFactory('str')(
protocol['potential_family'])
builder.potential_mapping = DataFactory('dict')(
dict=self._potential_mapping[protocol['potential_mapping']])
# Set the kpoint grid from the density in the protocol
kpoints = DataFactory('array.kpoints')()
kpoints.set_kpoints_mesh([1, 1, 1])
kpoints.set_cell_from_structure(structure)
rec_cell = kpoints.reciprocal_cell
kpoints.set_kpoints_mesh(
fetch_k_grid(rec_cell, protocol['kpoint_distance']))
builder.kpoints = kpoints
# Here we set the protocols fast, moderate and precise. These currently have no formal meaning.
# After a while these will be set in the VASP workchain entrypoints using the convergence workchain etc.
# However, for now we rely on defaults plane wave cutoffs and a set k-point density for the chosen protocol.
relax = AttributeDict()
relax.perform = DataFactory('bool')(True)
relax.algo = DataFactory('str')(protocol['relax']['algo'])
if relaxation_type == RelaxType.ATOMS:
relax.positions = DataFactory('bool')(True)
relax.shape = DataFactory('bool')(False)
relax.volume = DataFactory('bool')(False)
elif relaxation_type == RelaxType.CELL:
relax.positions = DataFactory('bool')(False)
relax.shape = DataFactory('bool')(True)
relax.volume = DataFactory('bool')(True)
elif relaxation_type == RelaxType.ATOMS_CELL:
relax.positions = DataFactory('bool')(True)
relax.shape = DataFactory('bool')(True)
relax.volume = DataFactory('bool')(True)
else:
raise ValueError('relaxation type `{}` is not supported'.format(
relaxation_type.value))
if threshold_forces is not None:
threshold = threshold_forces
else:
threshold = protocol['relax']['threshold_forces']
relax.force_cutoff = DataFactory('float')(threshold)
if threshold_stress is not None:
raise ValueError(
'Using a stress threshold is not directly available in VASP during relaxation.'
)
builder.relax = relax
return builder
