def test_tick(self):
registry = ProcessRegistry()
rinfo = submit(ProcessEventsTester, _jobs_store=self.storage)
# Tick the engine a number of times or until there is no more work
i = 0
while daemon.tick_workflow_engine(self.storage,
print_exceptions=False):
self.assertLess(i, 10, "Engine not done after 10 ticks")
i += 1
self.assertTrue(registry.has_finished(rinfo.pid))
def test_create_fail(self):
registry = ProcessRegistry()
dp_rinfo = submit(DummyProcess, _jobs_store=self.storage)
fail_rinfo = submit(FailCreateFromSavedStateProcess,
_jobs_store=self.storage)
# Tick the engine a number of times or until there is no more work
i = 0
while daemon.tick_workflow_engine(self.storage,
print_exceptions=False):
self.assertLess(i, 10, "Engine not done after 10 ticks")
i += 1
self.assertTrue(registry.has_finished(dp_rinfo.pid))
self.assertTrue(registry.has_finished(fail_rinfo.pid))
def start_up(self):
"""
init context and some parameters
"""
#print('started delta workflow version {}'.format(self._workflowversion))
#print("Workchain node identifiers: {}".format(ProcessRegistry().current_calc_node))
self.report('started delta workflow version {} with idenifier: {}'
''.format(self._workflowversion, ProcessRegistry().current_calc_node))
# init
self.ctx.calcs_to_run = []
# input check
# check if right codes
wf_dict = self.inputs.wf_parameters.get_dict()
self.ctx.inputs_eos = {
'fleur': self.inputs.fleur,
'inpgen': self.inputs.inpgen,
'wf_parameters':
{'points' : wf_dict.get('points', 5),
'step' : wf_dict.get('step', 0.02),
'guess' : 1.0,
'resources' : wf_dict.get('resources', {"num_machines": 1}),
'walltime_sec': wf_dict.get('walltime_sec', 3600),
'queue_name' : wf_dict.get('queue_name', ''),
'serial' : wf_dict.get('serial', False)
}}
self.ctx.wc_eos_para = ParameterData(dict=self.ctx.inputs_eos.get('wf_parameters'))
self.get_calcs_from_groups()
self.ctx.successful = True
self.ctx.warnings = []
self.ctx.labels = []
def start(self):
'''
check parameters, what condictions? complete?
check input nodes
'''
### input check ### ? or done automaticly, how optional?
# check if fleuinp corresponds to fleur_calc
print('started bands workflow version {}'.format(self._workflowversion))
print("Workchain node identifiers: {}"
"".format(ProcessRegistry().current_calc_node))
self.ctx.fleurinp1 = ""
self.ctx.last_calc = None
self.ctx.successful = False
self.ctx.warnings = []
wf_dict = self.inputs.wf_parameters.get_dict()
# if MPI in code name, execute parallel
self.ctx.serial = wf_dict.get('serial', False)
# set values, or defaults
self.ctx.max_number_runs = wf_dict.get('fleur_runmax', 4)
self.ctx.resources = wf_dict.get('resources', {"num_machines": 1})
self.ctx.walltime_sec = wf_dict.get('walltime_sec', 10*30)
self.ctx.queue = wf_dict.get('queue_name', None)
def start(self):
"""
init context and some parameters
"""
print('started convergence workflow version {}'.format(
self._workflowversion))
print("Workchain node identifiers: {}".format(
ProcessRegistry().current_calc_node))
# init
self.ctx.last_calc = None
self.ctx.loop_count = 0
self.ctx.calcs = []
self.ctx.successful = False
self.ctx.distance = []
self.ctx.total_energy = []
self.energydiff = 10000
self.ctx.warnings = []
self.ctx.errors = []
self.ctx.fleurinp = None
wf_dict = self.inputs.wf_parameters.get_dict()
if wf_dict == {}:
wf_dict = self._wf_default
# if MPI in code name, execute parallel
self.ctx.serial = wf_dict.get('serial', False) #True
# set values, or defaults
self.ctx.max_number_runs = wf_dict.get('fleur_runmax', 4)
self.ctx.resources = wf_dict.get('resources', {"num_machines": 1})
self.ctx.walltime_sec = wf_dict.get('walltime_sec', 60 * 60)
self.ctx.queue = wf_dict.get('queue_name', '')
def start(self):
"""
check parameters, what condictions? complete?
check input nodes
"""
self.report('started eos workflow version {}'.format(self._workflowversion))
self.report("Workchain node identifiers: {}".format(ProcessRegistry().current_calc_node))
#print('started eos workflow version {}'.format(self._workflowversion))
#print("Workchain node identifiers: {}".format(ProcessRegistry().current_calc_node))
### input check ### ? or done automaticly, how optional?
self.ctx.last_calc2 = None
self.ctx.calcs = []
self.ctx.calcs_future = []
self.ctx.structures = []
self.ctx.temp_calc = None
self.ctx.structurs_uuids = []
self.ctx.scalelist = []
self.ctx.volume = []
self.ctx.volume_peratom = []
self.ctx.org_volume = -1# avoid div 0
self.ctx.labels = []
self.ctx.successful = True#False
# TODO get all succesfull from convergence, if all True this
wf_dict = self.inputs.wf_parameters.get_dict()
# set values, or defaults, default: always converge charge density,
# crit < 0.00002, max 4 fleur runs
self.ctx.points = wf_dict.get('points', 9)
self.ctx.step = wf_dict.get('step', 0.002)
self.ctx.guess = wf_dict.get('guess', 1.00)
self.ctx.serial = wf_dict.get('serial', False)#True
self.ctx.custom_scheduler_commands = wf_dict.get('custom_scheduler_commands', '')
self.ctx.max_number_runs = wf_dict.get('fleur_runmax', 4)
inputs = self.inputs
if 'inpgen' in inputs:
try:
test_and_get_codenode(inputs.inpgen, 'fleur.inpgen', use_exceptions=True)
except ValueError:
error = ("The code you provided for inpgen of FLEUR does not "
"use the plugin fleur.inpgen")
#self.control_end_wc(error)
print(error)
self.abort(error)
if 'fleur' in inputs:
try:
test_and_get_codenode(inputs.fleur, 'fleur.fleur', use_exceptions=True)
except ValueError:
error = ("The code you provided for FLEUR does not "
"use the plugin fleur.fleur")
#self.control_end_wc(error)
#print(error)
self.abort(error)
def init(self):
print "Workchain node identifiers: {}".format(
ProcessRegistry().current_calc_node)
print "Run Ape with guess radii, just to get nodes and picks"
apein = generate_ApeCalculation('apelocal', self.inputs.element, 2, 2,
2, 2)
self.ctx.Vo2, self.ctx.Bo2, self.ctx.Bp2 = get_reference(
self.inputs.element)
future = submit(ApeCalculation.process(), **apein)
return ToContext(result=future)
def start(self):
'''
check parameters, what condictions? complete?
check input nodes
'''
### input check ### ? or done automaticly, how optional?
# check if fleuinp corresponds to fleur_calc
print('started bands workflow version {}'.format(self._workflowversion))
print("Workchain node identifiers: {}"
"".format(ProcessRegistry().current_calc_node))
def run_wf():
print "Workfunction node identifiers: {}".format(ProcessRegistry().current_calc_node)
#Instantiate a JobCalc process and create basic structure
JobCalc = SiestaCalculation.process()
s0 = create_structure()
calcs = {}
for label, factor in zip(labels, scale_facs):
s = rescale(s0,Float(factor))
inputs = geninputs(s)
print "Running a scf for Si with scale factor {}".format(factor)
# result = run(JobCalc,**inputs)
result = async(JobCalc,**inputs)
def start(self):
"""
check parameters, what condictions? complete?
check input nodes
"""
self.report(
'started fleur_optimize_parameter workflow version {}'.format(
self._workflowversion))
self.report("Workchain node identifiers: {}".format(
ProcessRegistry().current_calc_node))
### input check ###
# initialize contexts
self.ctx.successful = True
# Check on inputnodes
inputs = self.inputs
# wf_parameters:
wf_dict = inputs.wf_parameters.get_dict()
# set values, or DEFAULTS
self.ctx.serial = wf_dict.get('serial', False)
self.ctx.custom_scheduler_commands = wf_dict.get(
'custom_scheduler_commands', '')
self.ctx.max_number_runs = wf_dict.get('fleur_runmax', 4)
# codes
if 'inpgen' in inputs:
try:
test_and_get_codenode(inputs.inpgen,
'fleur.inpgen',
use_exceptions=True)
except ValueError:
error = ("The code you provided for inpgen of FLEUR does not "
"use the plugin fleur.inpgen")
self.control_end_wc(error)
self.abort(error)
if 'fleur' in inputs:
try:
test_and_get_codenode(inputs.fleur,
'fleur.fleur',
use_exceptions=True)
except ValueError:
error = ("The code you provided for FLEUR does not "
"use the plugin fleur.fleur")
self.control_end_wc(error)
self.abort(error)
def start(self):
"""
init context and some parameters
"""
self.report('INFO: started convergence workflow version {}\n'
'INFO: Workchain node identifiers: {}'
''.format(self._workflowversion,
ProcessRegistry().current_calc_node))
####### init #######
# internal para /control para
self.ctx.last_calc = None
self.ctx.loop_count = 0
self.ctx.calcs = []
self.ctx.abort = False
# input para
wf_dict = self.inputs.wf_parameters.get_dict()
if wf_dict == {}:
wf_dict = self._wf_default
self.ctx.serial = wf_dict.get('serial', False)
# set values, or defaults
self.ctx.max_number_runs = wf_dict.get('fleur_runmax', 4)
self.ctx.resources = wf_dict.get('resources', {"num_machines": 1})
self.ctx.walltime_sec = wf_dict.get('walltime_sec', 60 * 60)
self.ctx.queue = wf_dict.get('queue_name', '')
self.ctx.custom_scheduler_commands = wf_dict.get(
'custom_scheduler_commands', '')
self.ctx.description_wf = self.inputs.get('_description',
'') + '|fleur_scf_wc|'
self.ctx.label_wf = self.inputs.get('_label', 'fleur_scf_wc')
# return para/vars
self.ctx.successful = True
self.ctx.distance = []
self.ctx.total_energy = []
self.ctx.energydiff = 10000
self.ctx.warnings = []
self.ctx.errors = []
self.ctx.fleurinp = None
self.ctx.formula = ''
def start(self):
'''
check parameters, what condictions? complete?
check input nodes
'''
### input check ### ? or done automaticly, how optional?
# check if fleuinp corresponds to fleur_calc
print('started dos workflow version {}'.format(self._workflowversion))
print("Workchain node identifiers: {}"
"".format(ProcessRegistry().current_calc_node))
self.ctx.fleurinp1 = ""
self.ctx.last_calc = None
self.ctx.successful = False
self.ctx.warnings = []
wf_dict = self.inputs.wf_parameters.get_dict()
# if MPI in code name, execute parallel
self.ctx.serial = wf_dict.get('serial', False)
# set values, or defaults
self.ctx.max_number_runs = wf_dict.get('fleur_runmax', 4)
self.ctx.resources = wf_dict.get('resources', {"num_machines": 1})
self.ctx.walltime_sec = wf_dict.get('walltime_sec', 10 * 60)
self.ctx.queue = wf_dict.get('queue_name', None)
inputs = self.inputs
if 'fleur' in inputs:
try:
test_and_get_codenode(inputs.fleur,
'fleur.fleur',
use_exceptions=True)
except ValueError:
error = ("The code you provided for FLEUR does not "
"use the plugin fleur.fleur")
#self.control_end_wc(error)
print(error)
self.abort()
def run_pw(self):
print "Workchain node identifiers: {}".format(
ProcessRegistry().current_calc_node)
#Instantiate a JobCalc process and create basic structure
JobCalc = PwCalculation.process()
self.ctx.s0 = structure_init(Str(self.inputs.element))
self.ctx.eos_names = []
calcs = {}
for label, factor in zip(labels, scale_facs):
s = rescale(self.ctx.s0, Float(factor))
inputs = generate_scf_input_params(s, str(self.inputs.code),
self.inputs.pseudo,
str(self.inputs.element))
print "Running a scf for {} with scale factor {}".format(
self.inputs.element, factor)
future = submit(JobCalc, **inputs)
calcs[label] = Outputs(future)
# Ask the workflow to continue when the results are ready and store them
# in the context
return ToContext(**calcs) #Here it waits
def run_wf():
# print "Workfunction node identifiers: {}".format(ProcessRegistry().current_calc_node)
wcalc_uuid = ProcessRegistry().current_calc_node.uuid
print "Workfunction node: {}".format(wcalc_uuid)
#Instantiate a JobCalc process and create basic structure
JobCalc = SiestaCalculation.process()
s0 = create_structure()
calcs = {}
for label, factor in zip(labels, scale_facs):
s = rescale(s0, Float(factor))
inputs = geninputs(s)
print "Running a scf for Si with scale factor {}".format(factor)
result = run(JobCalc, **inputs)
calcs[label] = get_info(result, s)
eos = []
for label in labels:
eos.append(calcs[label])
retdict = {'result': ParameterData(dict={'eos_data': eos})}
return retdict
def start(self):
"""
check parameters, what condictions? complete?
check input nodes
"""
print('started eos workflow version {}'.format(self._workflowversion))
print("Workchain node identifiers: {}".format(
ProcessRegistry().current_calc_node))
### input check ### ? or done automaticly, how optional?
self.ctx.last_calc2 = None
self.ctx.calcs = []
self.ctx.structures = []
self.ctx.structurs_uuids = []
self.ctx.scalelist = []
self.ctx.volume = []
self.ctx.successful = True #False # TODO get all succesfull from convergence, if all True this
wf_dict = self.inputs.wf_parameters.get_dict()
self.ctx.points = wf_dict.get('points', 2) #9
self.ctx.step = wf_dict.get('step', 0.002)
self.ctx.guess = wf_dict.get('guess', 1.00)
# set values, or defaults, default: always converge charge density, crit < 0.00002, max 4 fleur runs
self.ctx.max_number_runs = wf_dict.get('fleur_runmax', 4)
def check_input(self):
"""
Init same context and check what input is given if it makes sence
"""
### input check ### ? or done automaticly, how optional?
msg = ("INFO: Started inital_state_CLS workflow version {} "
"Workchain node identifiers: {}"
"".format(self._workflowversion,
ProcessRegistry().current_calc_node))
self.report(msg)
# init
self.ctx.last_calc = None
self.ctx.eximated_jobs = 0
self.ctx.run_jobs = 0
self.ctx.calcs_res = []
self.ctx.labels = []
self.ctx.ref_labels = []
self.ctx.calcs_torun = []
self.ctx.ref_calcs_torun = []
self.ctx.ref_calcs_res = []
self.ctx.struc_to_relax = []
self.ctx.successful = False
self.ctx.warnings = []
self.ctx.errors = []
self.ctx.ref = {}
self.ctx.calculate_formation_energy = True
#Style: {atomtype : listof all corelevel, atomtype_coresetup... }
#ie: { 'W-1' : [shift_1s, ... shift 7/2 4f],
# 'W-1_coreconfig' : ['1s','2s',...],
# 'W-2' : [...], 'Be-1': [], ...} #all in eV!
self.ctx.CLS = {}
self.ctx.cl_energies = {} # same style as CLS only energy <-> shift
self.ctx.ref_cl_energies = {}
#Style: {'Compound' : energy, 'ref_x' : energy , ...}
#i.e {'Be12W' : 0.0, 'Be' : 0.104*htr_eV , 'W' : 0.12*htr_eV} # all in eV!
self.ctx.fermi_energies = {}
self.ctx.bandgaps = {}
self.ctx.atomtypes = {}
# set values, or defaults for Wf_para
wf_dict = self.inputs.wf_parameters.get_dict()
default = self._default_wf_para
self.ctx.serial = wf_dict.get('serial', default.get('serial'))
self.ctx.same_para = wf_dict.get('same_para', default.get('same_para'))
self.ctx.scf_para = wf_dict.get('scf_para', default.get('scf_para'))
self.ctx.relax = wf_dict.get('relax', default.get('relax'))
self.ctx.relax_mode = wf_dict.get('relax_mode',
default.get('relax_mode'))
self.ctx.relax_para = wf_dict.get('relax_para',
default.get('dos_para'))
self.ctx.resources = wf_dict.get('resources', default.get('resources'))
self.ctx.walltime_sec = wf_dict.get('walltime_sec',
default.get('walltime_sec'))
self.ctx.queue = wf_dict.get('queue_name', default.get('queue_name'))
self.ctx.custom_scheduler_commands = wf_dict.get(
'custom_scheduler_commands', '')
# check if inputs given make sense # TODO sort this out in common wc
inputs = self.inputs
if 'fleurinp' in inputs:
#TODO make a check if an extracted structure exists, since get_structuredata is wf
structure = inputs.fleurinp.get_structuredata(inputs.fleurinp)
self.ctx.elements = list(structure.get_composition().keys())
self.ctx.calcs_torun.append(inputs.get('fleurinp'))
#print('here1')
if 'structure' in inputs:
warning = 'WARNING: Ignoring Structure input, because Fleurinp was given'
self.ctx.warnings.append(warning)
self.report(warning)
if 'calc_parameters' in inputs:
warning = 'WARNING: Ignoring parameter input, because Fleurinp was given'
self.ctx.warnings.append(warning)
self.report(warning)
elif 'structure' in inputs:
self.ctx.elements = list(inputs.structure.get_composition().keys())
#self.ctx.elements = list(s.get_symbols_set())
if 'inpgen' not in inputs:
error = 'ERROR: StructureData was provided, but no inpgen code was provided'
self.ctx.errors.append(error)
self.abort_nowait(error)
if 'calc_parameters' in inputs:
self.ctx.calcs_torun.append(
[inputs.get('structure'),
inputs.get('calc_parameters')])
#print('here2')
else:
self.ctx.calcs_torun.append(inputs.get('structure'))
#print('here3')
else:
error = 'ERROR: No StructureData nor FleurinpData was provided'
#print(error)
self.ctx.errors.append(error)
self.abort_nowait(error)
self.report('INFO: elements in structure: {}'.format(
self.ctx.elements))
########################################################################### # Copyright (c), The AiiDA team. All rights reserved. # # This file is part of the AiiDA code. # # # # The code is hosted on GitHub at https://github.com/aiidateam/aiida_core # # For further information on the license, see the LICENSE.txt file # # For further information please visit http://www.aiida.net # ########################################################################### from plum.engine.serial import SerialEngine import plum.class_loader from plum.engine.parallel import MultithreadedEngine import plum.in_memory_database import plum.knowledge_provider import plum.knowledge_base from aiida.work.class_loader import ClassLoader from aiida.work.process_registry import ProcessRegistry _kb = plum.knowledge_base.KnowledgeBase() #_kb.add_provider( # plum.in_memory_database.InMemoryDatabase( # retain_inputs=False, retain_outputs=False)) _kb.add_provider(ProcessRegistry()) plum.knowledge_provider.set_global_provider(_kb) # Have globals that can be used by all of AiiDA class_loader = plum.class_loader.ClassLoader(ClassLoader()) registry = _kb parallel_engine = MultithreadedEngine() serial_engine = SerialEngine()
def start(self):
"""
init context and some parameters
"""
self.report('INFO: started VoroStart workflow version {}\n'
'INFO: Workchain node identifiers: {}'
''.format(self._workflowversion,
ProcessRegistry().current_calc_node))
####### init #######
# internal para /control para
self.ctx.abort = False
# input para
wf_dict = self.inputs.wf_parameters.get_dict()
#TODO: check for completeness
if wf_dict == {}:
wf_dict = self._wf_default
self.report('INFO: using default wf parameter')
# set values, or defaults
self.ctx.use_mpi = wf_dict.get('use_mpi', self._wf_default['use_mpi'])
self.ctx.resources = wf_dict.get('resources',
self._wf_default['resources'])
self.ctx.walltime_sec = wf_dict.get('walltime_sec',
self._wf_default['walltime_sec'])
self.ctx.queue = wf_dict.get('queue_name',
self._wf_default['queue_name'])
self.ctx.custom_scheduler_commands = wf_dict.get(
'custom_scheduler_commands',
self._wf_default['custom_scheduler_commands'])
self.ctx.dos_params_dict = wf_dict.get('dos_params',
self._wf_default['dos_params'])
self.ctx.description_wf = self.inputs.get('_description',
self._wf_description)
self.ctx.label_wf = self.inputs.get('_label', self._wf_label)
# iterative rerunning parameters
self.ctx.iter = 0
self.ctx.Nrerun = wf_dict.get('num_rerun',
self._wf_default['num_rerun'])
# initialize checking booleans
self.ctx.is_starting_iter = True
self.ctx.doscheck_ok = False
self.ctx.voro_ok = False
self.ctx.check_dos = wf_dict.get('check_dos',
self._wf_default['check_dos'])
self.ctx.dos_check_fail_reason = None
# some physical parameters that are reused
self.ctx.r_cls = wf_dict.get('r_cls', self._wf_default['r_cls'])
self.ctx.nclsmin = wf_dict.get('natom_in_cls_min',
self._wf_default['natom_in_cls_min'])
self.ctx.fac_clsincrease = wf_dict.get(
'fac_cls_increase', self._wf_default['fac_cls_increase'])
self.ctx.efermi = None
# difference in eV to emin (e_fermi) if emin (emax) are larger (smaller) than emin (e_fermi)
self.ctx.delta_e = wf_dict.get('delta_e_min',
self._wf_default['delta_e_min'])
# threshold for dos comparison (comparison of dos at emin)
self.ctx.threshold_dos_zero = wf_dict.get(
'threshold_dos_zero', self._wf_default['threshold_dos_zero'])
self.ctx.min_dist_core_states = wf_dict.get(
'delta_e_min_core_states',
self._wf_default['delta_e_min_core_states'])
#TODO add missing info
# print the inputs
self.report(
'INFO: use the following parameter:\n'
'use_mpi: {}\n'
'Resources: {}\n'
'Walltime (s): {}\n'
'queue name: {}\n'
'scheduler command: {}\n'
'description: {}\n'
'label: {}\n'
'dos_params: {}\n'
'Max. number of voronoi reruns: {}\n'
'factor cluster increase: {}\n'
'default cluster radius (in alat): {}\n'
'min. number of atoms in screening cls: {}\n'
'min. dist in DOS contour to emin/emax: {} eV\n'
'threshold where DOS is zero: {} states/eV\n'
'minimal distance of highest core state from EMIN: {} Ry\n'.format(
self.ctx.use_mpi, self.ctx.resources, self.ctx.walltime_sec,
self.ctx.queue, self.ctx.custom_scheduler_commands,
self.ctx.description_wf, self.ctx.label_wf,
self.ctx.dos_params_dict, self.ctx.Nrerun,
self.ctx.fac_clsincrease, self.ctx.r_cls, self.ctx.nclsmin,
self.ctx.delta_e, self.ctx.threshold_dos_zero,
self.ctx.min_dist_core_states))
# return para/vars
self.ctx.successful = True
self.ctx.errors = []
self.ctx.formula = ''
# get kkr and voronoi codes from input
try:
test_and_get_codenode(self.inputs.kkr,
'kkr.kkr',
use_exceptions=True)
except ValueError:
error = ("The code you provided for kkr does not "
"use the plugin kkr.kkr")
self.ctx.errors.append(error)
self.control_end_wc(error)
try:
test_and_get_codenode(self.inputs.voronoi,
'kkr.voro',
use_exceptions=True)
except ValueError:
error = ("The code you provided for voronoi does not "
"use the plugin kkr.voro")
self.ctx.errors.append(error)
self.control_end_wc(error)
def start(self):
"""
init context and some parameters
"""
self.report('INFO: started KKR dos workflow version {}\n'
'INFO: Workchain node identifiers: {}'
''.format(self._workflowversion,
ProcessRegistry().current_calc_node))
####### init #######
# internal para /control para
self.ctx.abort = False
# input para
wf_dict = self.inputs.wf_parameters.get_dict()
#TODO: check for completeness
if wf_dict == {}:
wf_dict = self._wf_default
self.report('INFO: using default wf parameter')
# set values, or defaults
self.ctx.use_mpi = wf_dict.get('use_mpi', self._wf_default['use_mpi'])
self.ctx.resources = wf_dict.get('resources',
self._wf_default['resources'])
self.ctx.walltime_sec = wf_dict.get('walltime_sec',
self._wf_default['walltime_sec'])
self.ctx.queue = wf_dict.get('queue_name',
self._wf_default['queue_name'])
self.ctx.custom_scheduler_commands = wf_dict.get(
'custom_scheduler_commands',
self._wf_default['custom_scheduler_commands'])
self.ctx.dos_params_dict = wf_dict.get('dos_params',
self._wf_default['dos_params'])
self.ctx.dos_kkrparams = None # is set in set_params_dos
self.ctx.description_wf = self.inputs.get('_description',
self._wf_description)
self.ctx.label_wf = self.inputs.get('_label', self._wf_label)
self.report('INFO: use the following parameter:\n'
'use_mpi: {}\n'
'Resources: {}\n'
'Walltime (s): {}\n'
'queue name: {}\n'
'scheduler command: {}\n'
'description: {}\n'
'label: {}\n'
'dos_params: {}\n'.format(
self.ctx.use_mpi, self.ctx.resources,
self.ctx.walltime_sec, self.ctx.queue,
self.ctx.custom_scheduler_commands,
self.ctx.description_wf, self.ctx.label_wf,
self.ctx.dos_params_dict))
# return para/vars
self.ctx.successful = True
self.ctx.errors = []
self.ctx.formula = ''
def start(self):
"""
check parameters, what condictions? complete?
check input nodes
"""
self.report('started simple eos workflow version {}'.format(
self._workflowversion))
self.report("Workchain node identifiers: {}".format(
ProcessRegistry().current_calc_node))
### input check ###
# initialize contexts
self.ctx.last_calc2 = None
self.ctx.calcs = []
self.ctx.calcs_future = []
self.ctx.structures = []
self.ctx.temp_calc = None
self.ctx.structurs_uuids = []
self.ctx.scalelist = []
self.ctx.volume = []
self.ctx.volume_peratom = []
self.ctx.org_volume = -1 # avoid div 0
self.ctx.labels = []
self.ctx.successful = True
# Check on inputnodes
inputs = self.inputs
# wf_parameters:
wf_dict = inputs.wf_parameters.get_dict()
# set values, or DEFAULTS
self.ctx.points = wf_dict.get('points', 9)
self.ctx.step = wf_dict.get('step', 0.002)
self.ctx.guess = wf_dict.get('guess', 1.00)
self.ctx.serial = wf_dict.get('serial', False)
self.ctx.custom_scheduler_commands = wf_dict.get(
'custom_scheduler_commands', '')
self.ctx.max_number_runs = wf_dict.get('fleur_runmax', 4)
# codes
if 'inpgen' in inputs:
try:
test_and_get_codenode(inputs.inpgen,
'fleur.inpgen',
use_exceptions=True)
except ValueError:
error = ("The code you provided for inpgen of FLEUR does not "
"use the plugin fleur.inpgen")
self.control_end_wc(error)
self.abort(error)
if 'fleur' in inputs:
try:
test_and_get_codenode(inputs.fleur,
'fleur.fleur',
use_exceptions=True)
except ValueError:
error = ("The code you provided for FLEUR does not "
"use the plugin fleur.fleur")
self.control_end_wc(error)
self.abort(error)
