def run_ph(self):
"""
Run a PhCalculation either starting from a previous PwCalculation or restarting from a
previous PhCalculation run in this workchain
"""
self.ctx.iteration += 1
# Create local copy of general inputs stored in the context and adapt for next calculation
inputs = dict(self.ctx.inputs)
if isinstance(self.ctx.restart_calc, PhCalculation):
inputs['parameters']['INPUTPH']['recover'] = True
elif isinstance(self.ctx.restart_calc, PwCalculation):
pass
else:
ctype = type(self.ctx.restart_calc)
self.abort_nowait(
"The type '{}' of the parent calculation is invalid".format(
ctype))
inputs['parent_folder'] = self.ctx.restart_calc.out.remote_folder
inputs['parameters'] = ParameterData(dict=inputs['parameters'])
inputs['settings'] = ParameterData(dict=inputs['settings'])
process = PhCalculation.process()
running = submit(process, **inputs)
self.report('launching PhCalculation<{}> iteration #{}'.format(
running.pid, self.ctx.iteration))
return ToContext(calculations=append_(running))
def run_atoms(self):
"""
Run a separate HpBaseWorkChain for each of the defined Hubbard atoms
"""
workchain = self.ctx.initialization
if not workchain.is_finished_ok:
self.report(
'initialization workchain<{}> failed with finish status {}, aborting...'
.format(workchain.pk, workchain.finish_status))
return self.ERROR_CHILD_WORKCHAIN_FAILED
output_params = workchain.out.output_parameters.get_dict()
hubbard_sites = output_params['hubbard_sites']
for site_index, site_kind in hubbard_sites.iteritems():
do_only_key = 'do_one_only({})'.format(site_index)
inputs = AttributeDict(self.exposed_inputs(HpBaseWorkChain))
inputs.parameters = inputs.parameters.get_dict()
inputs.parameters['INPUTHP'][do_only_key] = True
inputs.parameters = ParameterData(dict=inputs.parameters)
running = self.submit(HpBaseWorkChain, **inputs)
self.report(
'launching HpBaseWorkChain<{}> for atomic site {} of kind {}'.
format(running.pk, site_index, site_kind))
self.to_context(workchains=append_(running))
def run_calculation(self):
"""Run a new calculation, taking the input dictionary from the context at self.ctx.inputs."""
self.ctx.iteration += 1
try:
unwrapped_inputs = self.ctx.inputs
except AttributeError:
raise ValueError(
'no calculation input dictionary was defined in self.ctx.inputs'
)
inputs = prepare_process_inputs(unwrapped_inputs)
process = self._calculation_class.process()
running = self.submit(process, **inputs)
if hasattr(running, 'pid'):
self.report('launching {}<{}> iteration #{}'.format(
self._calculation_class.__name__, running.pid,
self.ctx.iteration))
else:
self.report('launching {}<{}> iteration #{}'.format(
self._calculation_class.__name__, running.pk,
self.ctx.iteration))
return ToContext(calculations=append_(running))
def run_scf_smearing(self):
"""
Run a simple PwCalculation with smeared occupations
"""
inputs = copy(self.ctx.inputs)
inputs.parameters = deepcopy(inputs.parameters)
inputs.parameters['CONTROL']['calculation'] = 'scf'
inputs.parameters['SYSTEM']['occupations'] = 'smearing'
inputs.parameters['SYSTEM']['smearing'] = inputs.parameters[
'SYSTEM'].get('smearing', self.defaults.smearing_method)
inputs.parameters['SYSTEM']['degauss'] = inputs.parameters[
'SYSTEM'].get('degauss', self.defaults.smearing_degauss)
inputs.parameters['SYSTEM']['u_projection_type'] = inputs.parameters[
'SYSTEM'].get('u_projection_type',
self.defaults.u_projection_type_scf)
inputs.parameters['ELECTRONS']['conv_thr'] = inputs.parameters[
'ELECTRONS'].get('conv_thr', self.defaults.conv_thr_preconverge)
inputs.parameters = ParameterData(dict=inputs.parameters)
running = self.submit(PwBaseWorkChain, **inputs)
self.report(
'launching PwBaseWorkChain<{}> with smeared occupations'.format(
running.pk))
return ToContext(workchains_scf=append_(running))
def run_relax(self):
"""
Run the PwRelaxWorkChain to run a relax PwCalculation
"""
inputs = copy(self.ctx.inputs)
inputs.parameters = deepcopy(inputs.parameters)
u_projection_type_relax = inputs.parameters['SYSTEM'].get(
'u_projection_type', self.defaults.u_projection_type_relax)
if u_projection_type_relax != self.defaults.u_projection_type_relax:
self.report(
"warning: you specified 'u_projection_type = {}' in the input parameters, but this will crash "
"pw.x, changing it to '{}'".format(
u_projection_type_relax,
self.defaults.u_projection_type_relax))
inputs.parameters['SYSTEM'][
'u_projection_type'] = self.defaults.u_projection_type_relax
inputs.parameters = ParameterData(dict=inputs.parameters)
running = self.submit(PwRelaxWorkChain, **inputs)
self.report('launching PwRelaxWorkChain<{}> iteration #{}'.format(
running.pk, self.ctx.iteration))
return ToContext(workchains_relax=append_(running))
def do_submit(self):
if self.should_submit():
self.report('Submitting nested workchain.')
return ToContext(
workchain=append_(self.submit(
NestedWorkChain,
inp=self.inputs.inp - 1
))
)
def run_relax(self):
"""Run the BaseVaspWf for the relaxation."""
self.ctx.inputs.structure = self.ctx.current_structure
inputs = prepare_process_inputs(self.ctx.inputs)
running = self.submit(VaspBaseWf, **inputs)
self.ctx.iteration += 1
self.report('launching VaspBaseWf{}'.format(running))
return ToContext(workchains=append_(running))
def run_final(self):
"""
Perform the final HpCalculation to collect the various components of the chi matrices
"""
inputs = AttributeDict(self.exposed_inputs(HpBaseWorkChain))
inputs.parameters = inputs.parameters.get_dict()
inputs.parameters['INPUTHP']['collect_chi'] = True
inputs.parameters = ParameterData(dict=inputs.parameters)
inputs.parent_folder = self.ctx.merged_retrieved
inputs.pop('parent_calculation', None)
running = self.submit(HpBaseWorkChain, **inputs)
self.report('launching HpBaseWorkChain<{}> to collect matrices'.format(
running.pk))
self.to_context(workchains=append_(running))
def run_calculation(self):
"""
Run a new calculation, taking the input dictionary from the context at self.ctx.inputs
"""
self.ctx.iteration += 1
try:
unwrapped_inputs = self.ctx.inputs
except AttributeError:
raise ValueError('no calculation input dictionary was defined in self.ctx.inputs')
inputs = self._prepare_process_inputs(self._calculation_class, unwrapped_inputs)
calculation = self.submit(self._calculation_class, **inputs)
self.report('launching {}<{}> iteration #{}'.format(self.ctx.calc_name, calculation.pk, self.ctx.iteration))
return ToContext(calculations=append_(calculation))
def run_hp(self):
"""
Run the HpWorkChain restarting from the last completed scf calculation
"""
self.ctx.iteration += 1
workchain = self.ctx.workchains_scf[-1]
parent_calculation = workchain.out.output_parameters.get_inputs(
node_type=PwCalculation)[0]
inputs = self.exposed_inputs(HpWorkChain, namespace='hp')
inputs['parent_calculation'] = parent_calculation
running = self.submit(HpWorkChain, **inputs)
self.report('launching HpWorkChain<{}> iteration #{}'.format(
running.pk, self.ctx.iteration))
return ToContext(workchains_hp=append_(running))
def run_scf_fixed_magnetic(self):
"""
Run a simple PwCalculation with fixed occupations restarting from the previous calculation
with smeared occupations, based on which the number of bands and total magnetization are fixed
"""
inputs = copy(self.ctx.inputs)
inputs.parameters = deepcopy(inputs.parameters)
previous_workchain = self.ctx.workchains_scf[-1]
previous_parameters = previous_workchain.out.output_parameters
inputs.parameters['CONTROL']['calculation'] = 'scf'
inputs.parameters['CONTROL']['restart_mode'] = 'restart'
inputs.parameters['SYSTEM']['occupations'] = 'fixed'
inputs.parameters['SYSTEM'].pop('degauss', None)
inputs.parameters['SYSTEM'].pop('smearing', None)
inputs.parameters['SYSTEM'].pop('starting_magnetization', None)
inputs.parameters['SYSTEM']['nbnd'] = previous_parameters.get_dict(
)['number_of_bands']
inputs.parameters['SYSTEM'][
'tot_magnetization'] = previous_parameters.get_dict(
)['total_magnetization']
inputs.parameters['SYSTEM']['u_projection_type'] = inputs.parameters[
'SYSTEM'].get('u_projection_type',
self.defaults.u_projection_type_scf)
inputs.parameters['ELECTRONS']['conv_thr'] = inputs.parameters[
'ELECTRONS'].get('conv_thr', self.defaults.conv_thr_strictfinal)
inputs.parameters = ParameterData(dict=inputs.parameters)
running = self.submit(PwBaseWorkChain, **inputs)
self.report(
'launching PwBaseWorkChain<{}> with fixed occupations, bands and total magnetization'
.format(running.pk))
return ToContext(workchains_scf=append_(running))
def run_relax(self):
"""
Run the PwBaseWorkChain to run a relax PwCalculation
"""
self.ctx.iteration += 1
inputs = AttributeDict(
self.exposed_inputs(PwBaseWorkChain, namespace='base'))
inputs.structure = self.ctx.current_structure
inputs.parameters = inputs.parameters.get_dict()
inputs.parameters.setdefault('CONTROL', {})
inputs.parameters['CONTROL'][
'calculation'] = self.inputs.relaxation_scheme.value
# Do not clean workdirs of sub workchains, because then we won't be able to restart from them
inputs.pop('clean_workdir', None)
inputs = prepare_process_inputs(PwBaseWorkChain, inputs)
running = self.submit(PwBaseWorkChain, **inputs)
self.report('launching PwBaseWorkChain<{}>'.format(running.pk))
return ToContext(workchains=append_(running))
from aiida.orm.data.int import Int
from aiida.work.workchain import WorkChain, ToContext, append_
class SomeWorkChain(WorkChain):
@classmethod
def define(cls, spec):
super(SomeWorkChain, cls).define(spec)
spec.outline(
cls.submit_workchains,
cls.inspect_workchains,
)
def submit_workchains(self)
for i in range(3):
future = self.submit(SomeWorkChain)
self.to_context(workchains=append_(future))
def inspect_workchains(self)
for workchain in self.ctx.workchains:
assert workchain.is_finished_ok
def run(self):
inputs = {'inp': self.inputs.inp}
running = submit(SubWorkChain, **inputs)
self.report('launching SubWorkChain<{}>'.format(running.pid))
return ToContext(workchains=append_(running))
