def generate_inputs(process_class: engine.Process,
protocol: Dict,
code: orm.Code,
structure: StructureData,
override: Dict[str, Any] = None) -> Dict[str, Any]:
"""Generate the input parameters for the given workchain type for a given code and structure.
The override argument can be used to pass a dictionary with values for specific inputs that should override the
defaults. This dictionary should have the same nested structure as the final input dictionary would have for the
workchain submission.
:param process_class: process class, either calculation or workchain,
i.e. ``AbinitCalculation`` or ``AbinitBaseWorkChain``
:param protocol: the protocol based on which to choose input parameters
:param code: the code or code name to use
:param magnetism: the type of magnetisation to be used
:param initial_mag: value for the initial magnetisation along the z axis.
:param soc: whether or not to use spin-orbit coupling
:param structure: the structure
:param override: a dictionary to override specific inputs
:return: input dictionary
"""
# pylint: disable=too-many-arguments,unused-argument
from aiida.common.lang import type_check
AbinitCalculation = plugins.CalculationFactory('abinit') # pylint: disable=invalid-name
AbinitBaseWorkChain = plugins.WorkflowFactory('abinit.base') # pylint: disable=invalid-name
type_check(structure, orm.StructureData)
if not isinstance(code, orm.Code):
try:
code = orm.load_code(code)
except (exceptions.MultipleObjectsError,
exceptions.NotExistent) as exception:
raise ValueError('could not load the code {}: {}'.format(
code, exception))
if process_class == AbinitCalculation:
protocol = protocol['abinit']
dictionary = generate_inputs_calculation(protocol, code, structure,
override)
elif process_class == AbinitBaseWorkChain:
protocol = protocol['base']
dictionary = generate_inputs_base(protocol, code, structure, override)
else:
raise NotImplementedError(
'process class {} is not supported'.format(process_class))
return dictionary
def generate_inputs(process_class: engine.Process,
protocol: Dict,
code: orm.Code,
structure: orm.StructureData,
override: Dict[str, Any] = None) -> Dict[str, Any]:
"""Generate the input parameters for the given workchain type for a given code, structure and pseudo family.
The override argument can be used to pass a dictionary with values for specific inputs that should override the
defaults. This dictionary should have the same nested structure as the final input dictionary would have for the
workchain submission. For example if one wanted to generate the inputs for a PwBandsWorkChain and override the
ecutwfc parameter for the PwBaseWorkChain of the PwRelaxWorkChains, one would have to pass:
override = {'relax': {'base': {'ecutwfc': 400}}}
:param process_class: process class, either calculation or workchain, i.e. ``PwCalculation`` or ``PwBaseWorkChain``
:param protocol: the protocol based on which to choose input parameters
:param code: the code or code name to use
:param structure: the structure
:param override: a dictionary to override specific inputs
:return: input dictionary
"""
# pylint: disable=too-many-arguments,unused-argument
from aiida.common.lang import type_check
family_name = protocol['relax']['base']['pseudos_family']
if isinstance(family_name, orm.Str):
family_name = family_name.value
try:
otfg_family = OTFGGroup.objects.get(label=family_name)
except exceptions.NotExistent:
raise ValueError(
'protocol `{}` requires the `{}` `pseudos family` but could not be found.'
.format(protocol['name'],
protocol['relax']['base']['pseudos_family']))
CastepCalculation = plugins.CalculationFactory('castep.castep') # pylint: disable=invalid-name
CastepBaseWorkChain = plugins.WorkflowFactory('castep.base') # pylint: disable=invalid-name
CastepRelaxWorkChain = plugins.WorkflowFactory('castep.relax') # pylint: disable=invalid-name
type_check(structure, orm.StructureData)
if not isinstance(code, orm.Code):
try:
code = orm.load_code(code)
except (exceptions.MultipleObjectsError,
exceptions.NotExistent) as exception:
raise ValueError('could not load the code {}: {}'.format(
code, exception))
if process_class == CastepCalculation:
protocol = protocol['relax']['base']['calc']
dictionary = generate_inputs_calculation(protocol, code, structure,
otfg_family, override)
elif process_class == CastepBaseWorkChain:
protocol = protocol['relax']['base']
dictionary = generate_inputs_base(protocol, code, structure,
otfg_family, override)
elif process_class == CastepRelaxWorkChain:
protocol = protocol['relax']
dictionary = generate_inputs_relax(protocol, code, structure,
otfg_family, override)
else:
raise NotImplementedError(
'process class {} is not supported'.format(process_class))
return dictionary
def __init__(self, code_name, *args, **kwargs):
"""Pass also a code name, that should be a code associated to an `arithmetic.add` plugin."""
super().__init__(*args, **kwargs)
self._code = orm.load_code(code_name)
self._process_class = plugins.CalculationFactory('arithmetic.add')
def clean_workchain_calcs(workchain):
"""Clean all remote directories of a workchain's descendant calculations."""
cleaned_calcs = []
for called_descendant in workchain.called_descendants:
if isinstance(called_descendant, orm.CalcJobNode):
if clean_calcjob_remote(called_descendant):
cleaned_calcs.append(called_descendant.pk)
return cleaned_calcs
PwBaseWorkChain = plugins.WorkflowFactory('quantumespresso.pw.base')
DosCalculation = plugins.CalculationFactory('quantumespresso.dos')
ProjwfcCalculation = plugins.CalculationFactory('quantumespresso.projwfc')
class PdosWorkChain(ProtocolMixin, WorkChain):
"""A WorkChain to compute Total & Partial Density of States of a structure, using Quantum Espresso."""
@classmethod
def define(cls, spec):
# yapf: disable
"""Define the process specification."""
super().define(spec)
spec.input('structure', valid_type=orm.StructureData, help='The input structure.')
spec.input(
'serial_clean',
valid_type=orm.Bool,
serializer=to_aiida_type,
from aiida import orm, plugins, engine
builder = plugins.CalculationFactory("quantumespresso.pw").get_builder()
builder.code = orm.Code.get(label="qe-direct")
builder.structure = orm.load_node("5eb94d2d-2f58-4769-9f74-80c223791077")
builder.kpoints = orm.load_node("a63f51e4-4a86-4271-bb30-ad69c1e1a7e2")
builder.parameters = orm.load_node("ea01fb5e-9098-481c-b46e-57cfa60a77cc")
upf_family = orm.Group.get(label="SSSP/1.1/PBE/efficiency",
type_string="sssp.family")
builder.pseudos = upf_family.get_pseudos(builder.structure)
builder.metadata.options.withmpi = True
builder.metadata.options.resources = {"num_machines": 1, "tot_num_mpiprocs": 2}
builder.metadata.options.max_wallclock_seconds = 1800
calc = engine.submit(builder)
print("pk=", calc.pk)
