def report_wf(self):
"""
"""
self.report('Final step.')
from aiida.orm import DataFactory
try:
pw = self.ctx.pw_wf_res.out.pw.get_dict()
except Exception:
pw = {}
gw = self.ctx.yambo_res.out.gw.get_dict()
#gw.update(pw)
self.out("yambo_remote_folder",
self.ctx.yambo_res.out.yambo_remote_folder)
self.out("scf_remote_folder", self.ctx.pw_wf_res.out.scf_remote_folder)
self.out("nscf_remote_folder",
self.ctx.pw_wf_res.out.nscf_remote_folder)
if self.ctx.bands_groupname is not None:
g_bands, _ = Group.get_or_create(name=self.ctx.bands_groupname)
g_bands.add_nodes(self.ctx.yambo_res)
self.report("Yambo calc (pk: {}) added to the group {}".format(
yambo_res.pk, self.ctx.bands_groupname))
else:
self.report("Yambo calc done (pk: {} ".format(gw))
self.out("gw", DataFactory('parameter')(dict=gw))
self.out("pw", DataFactory('parameter')(dict=pw))
self.report("workflow complete")
def get_data():
"""
Return some ParameterData
"""
from aiida.orm.utils import DataFactory
data = DataFactory('parameter')(dict={'data': 'test'})
data.store()
return data
def report_wf(self):
"""
Output final quantities
"""
extra = {}
nscf_pk = False
scf_pk = False
parameters = None
from aiida.orm import DataFactory
if 'nscf_pk' in self.ctx.r1.out.gw.get_dict():
nscf_pk = self.ctx.r1.out.gw.get_dict()['nscf_pk']
self.out("nscf_remote_folder", self.ctx.r1.out.nscf_remote_folder)
if 'scf_pk' in self.ctx.r1.out.gw.get_dict():
scf_pk = self.ctx.r1.out.gw.get_dict()['scf_pk']
self.out("scf_remote_folder", self.ctx.r1.out.scf_remote_folder)
if 'yambo_pk' in self.ctx.r1.out.gw.get_dict():
parameters = load_node(self.ctx.r1.out.gw.get_dict()
['yambo_pk']).inp.parameters.get_dict()
self.out("yambo_remote_folder",
self.ctx.r1.out.yambo_remote_folder)
self.out(
"convergence",
DataFactory('parameter')(
dict={
"parameters": parameters,
"yambo_pk": self.ctx.r1.out.gw.get_dict()['yambo_pk'],
"convergence_space": self.ctx.conv_elem,
"energy_widths": self.ctx.en_diffs,
"nscf_pk": nscf_pk,
"scf_pk": scf_pk,
}))
self.report("completed 1-D convergence workflow")
def report(self):
"""
Output final quantities
"""
from aiida.orm import DataFactory
self.out("steps", DataFactory('parameter')(dict={
'steps': self.ctx.steps,
'step0': self.ctx.step0}))
self.out("structure", self.ctx.last_structure)
def test_statistics_default_class(self):
"""
Test if the statistics query works properly.
I try to implement it in a way that does not depend on the past state.
"""
from aiida.orm import Node, DataFactory, Calculation
from collections import defaultdict
from aiida.backends.general.abstractqueries import AbstractQueryManager
def store_and_add(n, statistics):
n.store()
statistics['total'] += 1
statistics['types'][n._plugin_type_string] += 1
statistics['ctime_by_day'][n.ctime.strftime('%Y-%m-%d')] += 1
class QueryManagerDefault(AbstractQueryManager):
pass
qmanager_default = QueryManagerDefault()
current_db_statistics = qmanager_default.get_creation_statistics()
types = defaultdict(int)
types.update(current_db_statistics['types'])
ctime_by_day = defaultdict(int)
ctime_by_day.update(current_db_statistics['ctime_by_day'])
expected_db_statistics = {
'total': current_db_statistics['total'],
'types': types,
'ctime_by_day': ctime_by_day
}
ParameterData = DataFactory('parameter')
store_and_add(Node(), expected_db_statistics)
store_and_add(ParameterData(), expected_db_statistics)
store_and_add(ParameterData(), expected_db_statistics)
store_and_add(Calculation(), expected_db_statistics)
new_db_statistics = qmanager_default.get_creation_statistics()
# I only check a few fields
new_db_statistics = {
k: v
for k, v in new_db_statistics.iteritems()
if k in expected_db_statistics
}
expected_db_statistics = {
k: dict(v) if isinstance(v, defaultdict) else v
for k, v in expected_db_statistics.iteritems()
}
self.assertEquals(new_db_statistics, expected_db_statistics)
def generate_scf_input_params(structure, codename, pseudo_family):
# The inputs
inputs = PwCalculation.process().get_inputs_template()
# The structure
inputs.structure = structure
inputs.code = Code.get_from_string(codename.value)
inputs._options.resources = {"num_machines": 1}
inputs._options.max_wallclock_seconds = 30 * 60
# Kpoints
KpointsData = DataFactory("array.kpoints")
kpoints = KpointsData()
kpoints_mesh = 2
kpoints.set_kpoints_mesh([kpoints_mesh, kpoints_mesh, kpoints_mesh])
inputs.kpoints = kpoints
# Calculation parameters
parameters_dict = {
"CONTROL": {
"calculation": "scf",
"tstress": True, # Important that this stays to get stress
"tprnfor": True,
},
"SYSTEM": {
"ecutwfc": 30.,
"ecutrho": 200.,
},
"ELECTRONS": {
"conv_thr": 1.e-6,
}
}
ParameterData = DataFactory("parameter")
inputs.parameters = ParameterData(dict=parameters_dict)
# Pseudopotentials
inputs.pseudo = get_pseudos(structure, str(pseudo_family))
return inputs
def report_wf(self):
"""Output final quantities"""
from aiida.orm import DataFactory
self.out(
"result",
DataFactory('parameter')(
dict={
"kpoints": self.ctx.step0_res.out.convergence.get_dict(),
"fft": self.ctx.step1_res.out.convergence.get_dict(),
"bands": self.ctx.step2_res.out.convergence.get_dict(),
"cutoff": self.ctx.step3_res.out.convergence.get_dict(),
"ordered_step_output": self.ctx.ordered_outputs
}))
def rescale(structure, scale):
"""
Workfunction to rescale a structure
:param structure: An AiiDA structure to rescale
:param scale: The scale factor
:return: The rescaled structure
"""
the_ase = structure.get_ase()
new_ase = the_ase.copy()
new_ase.set_cell(the_ase.get_cell() * float(scale), scale_atoms=True)
new_structure = DataFactory('structure')(ase=new_ase)
return new_structure
def step_1(self, recheck=False):
self.report("converging FFTGvecs")
extra = {}
if self.inputs.parent_scf_folder:
extra['parent_scf_folder'] = self.inputs.parent_scf_folder
if self.inputs.structure:
extra['structure'] = self.inputs.structure
if self.ctx.last_step == 'step_2_1':
extra['parameters'] = ParameterData(
dict=self.ctx.step2_res.out.convergence.get_dict()
['parameters'])
if self.ctx.last_step == 'step_0_1' and self.ctx.step_0_done == True:
extra['parameters'] = ParameterData(
dict=self.ctx.step0_res.out.convergence.get_dict()
['parameters'])
convergence_parameters = DataFactory('parameter')(
dict={
'variable_to_converge': 'FFT_cutoff',
'conv_tol': 0.1,
'start_value': 4,
'step': 2,
'max_value': 60
})
p2y_result = submit(
YamboConvergenceWorkflow,
pwcode=self.inputs.pwcode,
precode=self.inputs.precode,
yambocode=self.inputs.yambocode,
calculation_set=self.inputs.calculation_set,
calculation_set_pw=self.inputs.calculation_set_pw,
parent_nscf_folder=load_node(self.ctx.nscf_calc).out.remote_folder,
pseudo=self.inputs.pseudo,
convergence_parameters=convergence_parameters,
#converge_parameters= converge_parameters,
#parameters = self.ctx.step2_res["convergence"].get_dict()['parameters'],
#threshold = Float(0.01),starting_points = starting_points,
**extra)
self.report("submitted 1-D FFT convergence workflow")
reslt = {}
if not recheck:
reslt['step1_1_res'] = p2y_result
self.ctx.last_step = 'step_1_1'
self.ctx.first_runs1 = False
self.ctx.step_1_done = True
else:
reslt['step1_2_res'] = p2y_result
self.ctx.last_step = 'step_1_2'
self.step1_res_ = p2y_result
def report_wf(self):
"""
Output final quantities
return information that may be used to figure out
the status of the calculation.
"""
from aiida.orm import DataFactory
success = load_node(self.ctx.yambo_pks[-1]).get_state() == 'FINISHED'
self.out(
"gw",
DataFactory('parameter')(dict={
"yambo_pk": self.ctx.yambo_pks[-1],
"success": success
}))
self.out("yambo_remote_folder",
load_node(self.ctx.yambo_pks[-1]).out.remote_folder)
self.report("workflow completed ")
def report_wf(self):
"""
Output final quantities
return information that may be used to figure out
the status of the calculation.
"""
self.report("Workflow Complete : scf {} nscf {} success {}".format(
self.ctx.scf_pk, self.ctx.nscf_pk, self.ctx.success))
from aiida.orm import DataFactory
res = {}
if self.ctx.scf_pk:
res['scf_pk'] = self.ctx.scf_pk
if self.ctx.nscf_pk:
res['nscf_pk'] = self.ctx.nscf_pk
res['success'] = self.ctx.success
self.out("pw", DataFactory('parameter')(dict=res))
self.out("scf_remote_folder",
load_node(self.ctx.scf_pk).out.remote_folder)
self.out("nscf_remote_folder",
load_node(self.ctx.nscf_pk).out.remote_folder)
def step_0(self, recheck=False):
self.report("Working on K-point convergence ")
extra = {}
if self.inputs.parent_scf_folder:
extra['parent_scf_folder'] = self.inputs.parent_scf_folder
if self.inputs.structure:
extra['structure'] = self.inputs.structure
if self.ctx.last_step == 'step_1_1':
extra['parameters'] = self.ctx.step1_res.out.convergence.get_dict(
)['parameters']
self.report("converging K-points ")
convergence_parameters = DataFactory('parameter')(
dict={
'variable_to_converge': 'kpoints',
'conv_tol': 0.1,
'start_value': .9,
'step': .1,
'max_value': 0.017
})
p2y_result = submit(YamboConvergenceWorkflow,
pwcode=self.inputs.pwcode,
precode=self.inputs.precode,
yambocode=self.inputs.yambocode,
calculation_set=self.inputs.calculation_set,
calculation_set_pw=self.inputs.calculation_set_pw,
pseudo=self.inputs.pseudo,
convergence_parameters=convergence_parameters,
**extra)
self.report("Submitted the K-point convergence step ")
reslt = {}
if not recheck:
reslt['step0_1_res'] = p2y_result
self.ctx.last_step = 'step_0_1'
self.ctx.step_0_done = True
else:
reslt['step0_2_res'] = p2y_result
self.ctx.last_step = 'step_0_2'
self.step0_res_ = p2y_result
self.ctx.first_run = False
def report_wf(self):
"""Output final quantities
this reports the parameters used in the converged calculation, the pk of that calculation,
a listing of the space sampled for convergence and the gaps computed at those points
in the convergence space.
"""
extra = {}
nscf_pk = False
scf_pk = False
parameters = None
from aiida.orm import DataFactory
if 'pw' in self.ctx.zero_calc.out:
if 'nscf_pk' in self.ctx.zero_calc.out.pw.get_dict():
nscf_pk = self.ctx.zero_calc.out.pw.get_dict()['nscf_pk']
self.out("nscf_remote_folder",
self.ctx.zero_calc.out.nscf_remote_folder)
if 'scf_pk' in self.ctx.zero_calc.out.pw.get_dict():
scf_pk = self.ctx.zero_calc.out.pw.get_dict()['scf_pk']
self.out("scf_remote_folder",
self.ctx.zero_calc.out.scf_remote_folder)
if 'yambo_pk' in self.ctx.zero_calc.out.gw.get_dict():
parameters = load_node(self.ctx.zero_calc.out.gw.get_dict()
['yambo_pk']).inp.parameters.get_dict()
self.out("yambo_remote_folder",
self.ctx.zero_calc.out.yambo_remote_folder)
self.out(
"convergence",
DataFactory('parameter')
(dict={
"parameters": parameters,
"yambo_pk": self.ctx.zero_calc.out.gw.get_dict()['yambo_pk'],
"convergence_space": self.ctx.conv_elem,
"energy_widths": self.ctx.en_diffs,
"nscf_pk": nscf_pk,
"scf_pk": scf_pk,
}))
self.report("completed 1-D convergence workflow")
def update_parameters(self, paging):
params = self.ctx.parameters.get_dict()
for field in self.ctx.conv_elem.keys():
starting_point = self.ctx.start_value +\
self.ctx.step * self.ctx.loop_length* self.ctx.iteration
if starting_point < 0:
self.report(
"*** ERROR: updating in the negative direction, please check: starting_point {}"
.format(starting_point))
self.report("*** ERROR: self.ctx.start_value {}".format(
self.ctx.start_value))
self.report("*** ERROR: self.ctx.step {}".format(
self.ctx.step))
self.report("*** ERROR: self.ctx.loop_length {}".format(
self.ctx.loop_length))
self.report("*** ERROR: self.ctx.iteration {}".format(
self.ctx.iteration))
params[field] = update_parameter_field(field, starting_point,
self.ctx.step * paging)
self.ctx.conv_elem[field].append(params[field])
self.report(" extended convergence points: {}".format(
self.ctx.conv_elem))
self.ctx.parameters = DataFactory('parameter')(dict=params)
# -*- coding: utf-8 -*-
"""Raspa input plugin."""
from __future__ import absolute_import
from aiida.common.datastructures import CalcInfo, CodeInfo
from aiida.common.exceptions import InputValidationError
from aiida.common.utils import classproperty
from aiida.orm.calculation.job import JobCalculation
from aiida.orm.utils import DataFactory
from six.moves import map
from six.moves import range
from ase.io import read, write
from shutil import copyfile
# data objects
CifData = DataFactory('cif')
FolderData = DataFactory('folder')
ParameterData = DataFactory('parameter')
RemoteData = DataFactory('remote')
SinglefileData = DataFactory('singlefile')
class RaspaCalculation(JobCalculation):
"""This is a RaspaCalculation, subclass of JobCalculation,
to prepare input for an RaspaCalculation.
For information on RASPA, refer to: https://github.com/numat/RASPA2.
"""
# --------------------------------------------------------------------------
def _init_internal_params(self):
"""
Set parameters of instance
def init_parameters(self, paging):
"""This function initializes the settings and parameters needed for a convergence calculations.
This function will store all needed parameters each in a self.ctx variable, and generate from
defaults optional parameters that are not provieded. It uses functions from `yambo_utils` to
generates the defaults. This function is only called once, after which the only update parameter
is called.
"""
convergence_parameters_dict = self.inputs.convergence_parameters.get_dict(
)
if 'calculation_set_pw' not in self.inputs.keys():
self.inputs.calculation_set_pw = DataFactory('parameter')(
dict=self.inputs.calculation_set.get_dict())
if 'calculation_set_p2y' not in self.inputs.keys():
main_set = self.inputs.calculation_set.get_dict()
main_set['resources'] = {
"num_machines": 1,
"num_mpiprocs_per_machine": 1
}
self.ctx.calculation_set_p2y = DataFactory('parameter')(
dict=main_set)
else:
self.ctx.calculation_set_p2y = self.inputs.calculation_set_p2y
if 'parameters' not in self.inputs.keys():
self.ctx.parameters = set_default_qp_param()
else:
self.ctx.parameters = self.inputs.parameters
if 'parent_scf_folder' in self.inputs.keys():
self.report("parent_scf folder was set")
parent_calc = self.inputs.parent_scf_folder.get_inputs_dict(
link_type=LinkType.CREATE)['remote_folder']
if isinstance(parent_calc, PwCalculation):
if parent_calc.get_state() == 'FINISHED':
if 'settings_pw' not in self.inputs.keys():
self.ctx.settings_pw = parent_calc.inp.settings
if 'structure' not in self.inputs.keys():
self.inputs.structure = parent_calc.inp.structure
if 'pseudo' not in self.inputs.keys():
raise InputValidationError("Pseudo should be provided")
if parent_calc.get_inputs_dict(
link_type=LinkType.CREATE)['parameters'].get_dict(
)['CONTROL']['calculation'] == 'scf':
if 'parameters_pw' not in self.inputs.keys():
self.ctx.parameters_pw = parent_calc.inp.parameters
else:
if 'parameters_pw_nscf' not in self.inputs.keys():
self.ctx.parameters_pw_nscf = parent_calc.inp.parameters
self.report("parent_scf_folder defined params {}".format(
self.ctx.parameters_pw.get_dict()))
if isinstance(parent_calc, YamboCalculation):
if parent_calc.get_state() == 'FINISHED':
if 'parameters' not in self.inputs.keys():
self.report(
"setting default parameters, parent was yambocalc "
)
self.ctx.parameters = set_default_qp_param()
if 'kpoints' == self.ctx.variable_to_converge:
if 'settings_pw' not in self.inputs.keys():
self.ctx.settings_pw = default_pw_settings()
if 'parameters_pw' not in self.inputs.keys():
self.ctx.parameters_pw = set_default_pw_param()
if 'parameters_pw_nscf' not in self.inputs.keys():
self.ctx.parameters_pw_nscf = set_default_pw_param(
nscf=True)
else:
if 'kpoints' == self.ctx.variable_to_converge:
self.report(
" initializing in a kpoints convergence calculation")
if 'settings_pw' not in self.inputs.keys():
self.ctx.settings_pw = default_pw_settings()
if 'parameters_pw' not in self.inputs.keys():
self.report(
" parameters_pw were not found setting them to default pw params"
)
self.ctx.parameters_pw = set_default_pw_param()
if 'parameters_pw_nscf' not in self.inputs.keys():
self.report(
" parameters_pw_nscf were not found setting them to default pw params"
)
self.ctx.parameters_pw_nscf = set_default_pw_param(
nscf=True)
if 'kpoints' != self.ctx.variable_to_converge:
if 'settings_pw' not in self.inputs.keys():
self.ctx.settings_pw = default_pw_settings()
if 'parameters' not in self.inputs.keys():
self.ctx.parameters = set_default_qp_param()
if 'structure' not in self.inputs.keys():
raise InputValidationError(
"Structure should be provided if parent PW SCF folder is not given when converging kpoints"
)
if 'pseudo' not in self.inputs.keys():
raise InputValidationError(
"Pseudo should be provided if parent PW calculation is not given when converging kpoints"
)
if 'pwcode' not in self.inputs.keys():
raise InputValidationError(
"PW code should be provided when converging kpoints")
if 'kpoints'!=self.ctx.variable_to_converge and\
'parent_nscf_folder' not in self.inputs.keys():
raise InputValidationError(
"Parent nscf folder should be provided when not converging kpoints"
)
if 'parent_nscf_folder' in self.inputs.keys():
parent_calc = load_node(
self.inputs.parent_nscf_folder.get_inputs_dict()
['remote_folder'].pk)
if isinstance(parent_calc, PwCalculation):
if parent_calc.get_inputs_dict()['parameters'].get_dict()['CONTROL']['calculation'] == 'nscf'\
and parent_calc.get_state()== 'FINISHED'\
and 'QPkrange' not in self.ctx.parameters.get_dict().keys():
self.ctx.parameters = default_qpkrange(
parent_calc.pk, self.ctx.parameters)
self.report(
"QPkrange not in self.ctx.parameters.get_dict keys ")
if 'settings_pw' in self.inputs.keys():
self.ctx.settings_pw = self.inputs.settings_pw
params = self.ctx.parameters.get_dict()
if 'kpoints' != self.ctx.variable_to_converge:
for field in self.ctx.conv_elem.keys():
self.report(
"self.ctx.start_value {} self.ctx.step {} self.ctx.loop_length {} self.ctx.iteration {}"
.format(self.ctx.start_value, self.ctx.step,
self.ctx.loop_length, self.ctx.iteration))
starting_point = self.ctx.start_value +\
self.ctx.step * self.ctx.loop_length * self.ctx.iteration
new_ind_var = update_parameter_field(field, starting_point,
self.ctx.step * paging)
if len(self.ctx.conv_elem[field]) == 1:
if self.ctx.conv_elem[field][0] == new_ind_var:
pass
else:
params[field] = new_ind_var
self.ctx.conv_elem[field].append(params[field])
self.report("initialized {} ".format(params[field]))
else:
params[field] = new_ind_var
self.ctx.conv_elem[field].append(params[field])
self.report("initialized {} ".format(params[field]))
self.ctx.parameters = DataFactory('parameter')(dict=params)
self.report('Initialization step completed.')
def step_2(self, recheck=False):
"""This calls the YamboConvergenceWorkflow as a subworkflow, converging the Bands.
We converge the Bands, using the converged kpoints from a preceeding kpoints,
converged FFT from a preceeding FFT convergence.
This is a 1-D convergence performed by a subworkflow.
"""
self.report("Working on Bands Convergence ")
nelec = load_node(self.ctx.nscf_calc).out.output_parameters.get_dict(
)['number_of_electrons']
nbands = load_node(self.ctx.nscf_calc).out.output_parameters.get_dict(
)['number_of_bands']
self.ctx.MAX_B_VAL = self.ctx.convergence_settings.dict.max_bands # int(nelec*8)
band_cutoff = self.ctx.convergence_settings.dict.start_bands # min(nelec,nbands)
extra = {}
if 'restart_options_pw' in self.inputs.keys():
extra['restart_options_pw'] = self.inputs.restart_options_pw
if 'restart_options_gw' in self.inputs.keys():
extra['restart_options_gw'] = self.inputs.restart_options_gw
if 'settings_pw_nscf' in self.inputs.keys():
extra['settings_pw_nscf'] = self.inputs.settings_pw_nscf
if 'settings_pw' in self.inputs.keys():
extra['settings_pw'] = self.inputs.settings_pw
if 'settings_p2y' in self.inputs.keys():
extra['settings_pw_p2y'] = self.inputs.settings_p2y
if 'calculation_set_pw_nscf' in self.inputs.keys():
extra[
'calculation_set_pw_nscf'] = self.inputs.calculation_set_pw_nscf
if 'parent_scf_folder' in self.inputs.keys():
extra['parent_scf_folder'] = self.inputs.parent_scf_folder
if 'parent_nscf_folder' in self.inputs.keys():
extra['parent_nscf_folder'] = self.inputs.parent_nscf_folder
if 'structure' in self.inputs.keys():
extra['structure'] = self.inputs.structure
if self.ctx.last_step == 'step_3_1':
if self.ctx.step3_res.out.convergence.get_dict()['parameters'][
'NGsBlkXp'] == self.ctx.convergence_settings.dict.start_w_cutoff: # 1 == default
self.report(
" converged cutt-off are similar to the default used in a previous band convergence, consistency achieved"
)
self.ctx.step_2_done = True
self.ctx.bands_n_cutoff_consistent = True
return
#band_cutoff = int(self.ctx.last_used_band *0.7)
extra['parameters'] = ParameterData(
dict=self.ctx.step3_res.out.convergence.get_dict()
['parameters'])
self.report(
"updated the bands convergence parameters with cut-off from cutoff convergence step"
)
if self.ctx.last_step == 'step_3_2':
# CRUNCH TIME: use values from step3_2
if self.ctx.step3_res.out.convergence.get_dict(
)['parameters']['NGsBlkXp'] <= self.ctx.last_used_cutoff: #
# we are done, and consistent:
self.report(
" converged cutt-off are similar to those used in a previous bands convergence, consistency achieved"
)
self.ctx.step_2_done = True
self.ctx.bands_n_cutoff_consistent = True
return
self.report(
"passing parameters from converged cut-off, this can be repeated untill the two parameters are consistent "
)
#band_cutoff = self.ctx.last_used_band ## BUG?
#band_cutoff = int( self.ctx.last_used_band*0.7)
extra['parameters'] = ParameterData(
dict=self.ctx.step3_res.out.convergence.get_dict()
['parameters'])
self.report(
"updated the bands convegence parameters with cut-off from cutoff convergence"
)
if self.ctx.last_step != 'step_1_1' and self.ctx.last_step != 'step_1_2': # last iteration was W_cutoff not FFT
self.ctx.last_used_cutoff = self.ctx.step3_res.out.convergence.get_dict(
)['parameters']['NGsBlkXp']
self.report("Cut-off in last W-Cutoff convergence: {}".format(
self.ctx.last_used_cutoff))
if self.ctx.last_step == 'step_1_1':
params = self.ctx.step1_res.out.convergence.get_dict(
)['parameters']
extra['parameters'] = ParameterData(dict=params)
convergence_parameters = DataFactory('parameter')(
dict={
'variable_to_converge': 'bands',
'conv_tol': float(self.inputs.threshold),
'start_value': band_cutoff,
'step': 10, #band_cutoff
'max_value': self.ctx.MAX_B_VAL
}) # self.ctx.MAX_B_VAL
self.report("converging BndsRnXp, GbndRnge")
p2y_result = submit(
YamboConvergenceWorkflow,
pwcode=self.inputs.pwcode,
precode=self.inputs.precode,
yambocode=self.inputs.yambocode,
calculation_set=self.inputs.calculation_set,
calculation_set_pw=self.inputs.calculation_set_pw,
parent_nscf_folder=load_node(self.ctx.nscf_calc).out.remote_folder,
pseudo=self.inputs.pseudo,
convergence_parameters=convergence_parameters,
#converge_parameters= converge_parameters,
#threshold = Float(0.01),starting_points = starting_points,
**extra)
self.report("submitted 1-D bands convergence workflow")
reslt = {}
if not recheck:
step2_1_res = p2y_result
self.ctx.last_step = 'step_2_1'
self.ctx.first_runs2 = False
else:
self.step2_2_res = p2y_result
self.ctx.last_step = 'step_2_2'
self.ctx.step_2_done = True
self.ctx.step2_res_ = p2y_result
def step_0(self, recheck=False):
"""This calls the YamboConvergenceWorkflow as a subworkflow, converging the K-points.
We converge the k-points by performing SCF and {NSCF+GW} at different mesh sizes untill convergence.
This is a 1-D convergence performed by a subworkflow.
"""
self.report("Working on K-point convergence ")
extra = {}
if 'restart_options_pw' in self.inputs.keys():
extra['restart_options_pw'] = self.inputs.restart_options_pw
if 'restart_options_gw' in self.inputs.keys():
extra['restart_options_gw'] = self.inputs.restart_options_gw
if 'settings_pw_nscf' in self.inputs.keys():
extra['settings_pw_nscf'] = self.inputs.settings_pw_nscf
if 'settings_pw' in self.inputs.keys():
extra['settings_pw'] = self.inputs.settings_pw
if 'settings_p2y' in self.inputs.keys():
extra['settings_pw_p2y'] = self.inputs.settings_p2y
if 'calculation_set_pw_nscf' in self.inputs.keys():
extra[
'calculation_set_pw_nscf'] = self.inputs.calculation_set_pw_nscf
if 'parent_scf_folder' in self.inputs.keys():
extra['parent_scf_folder'] = self.inputs.parent_scf_folder
if 'parent_nscf_folder' in self.inputs.keys():
extra['parent_nscf_folder'] = self.inputs.parent_nscf_folder
if 'structure' in self.inputs.keys():
extra['structure'] = self.inputs.structure
if self.ctx.last_step == 'step_1_1':
extra['parameters'] = self.ctx.step1_res.out.convergence.get_dict(
)['parameters']
if 'parameters' in self.inputs.keys():
extra['parameters'] = self.inputs.parameters
if 'parameters_pw' in self.inputs.keys():
extra['parameters_pw'] = self.inputs.parameters_pw
if 'parameters_pw_nscf' in self.inputs.keys():
extra['parameters_pw_nscf'] = self.inputs.parameters_pw_nscf
self.report("converging K-points ")
convergence_parameters = DataFactory('parameter')(
dict={
'variable_to_converge': 'kpoints',
'conv_tol': float(self.inputs.threshold),
'start_value':
self.ctx.convergence_settings.dict.kpoint_starting_distance,
'step': .1, # IGNORE STEP
'max_value':
self.ctx.convergence_settings.dict.kpoint_min_distance
}) # 0.34 , 0.0250508117676
p2y_result = submit(YamboConvergenceWorkflow,
pwcode=self.inputs.pwcode,
precode=self.inputs.precode,
yambocode=self.inputs.yambocode,
calculation_set=self.inputs.calculation_set,
calculation_set_pw=self.inputs.calculation_set_pw,
pseudo=self.inputs.pseudo,
convergence_parameters=convergence_parameters,
**extra)
self.report("Submitted the K-point convergence step ")
reslt = {}
if not recheck:
reslt['step0_1_res'] = p2y_result
self.ctx.last_step = 'step_0_1'
self.ctx.step_0_done = True
else:
reslt['step0_2_res'] = p2y_result
self.ctx.last_step = 'step_0_2'
self.ctx.step0_res_ = p2y_result
self.ctx.first_run = False
def yambo_should_restart(self):
"""This function encodes the logic to restart calculations from failures
This function supports detecting failed/incomplete yambo runs, taking corrective
action and resubmitting automatically. These classes of errors are taken care of:
1. Memory probelms
2. Parallelism problems
3. Some input inconsistency problems (too low number of bands)
4. Queue time exhaustion.
The calculation is restarted upto a maximum number of 4 retries
"""
self.report("Checking if yambo restart is needed")
if self.ctx.restart >= self.ctx.max_restarts:
self.report(
"I will not restart: maximum restarts reached: {}".format(
self.ctx.max_restarts))
return False
self.report(
"I can restart (# {}), max restarts ({}) not reached yet".format(
self.ctx.restart, self.ctx.max_restarts))
calc = load_node(self.ctx.yambo_pks[-1])
if self.ctx.last == 'INITIALISE':
return True
if calc.get_state() == calc_states.SUBMISSIONFAILED:
self.report(
"I will not resubmit calc pk: {}, submission failed: {}, check the log or you settings "
.format(calc.pk, calc.get_state()))
return False
max_input_seconds = self.ctx.calculation_set.get_dict(
)['max_wallclock_seconds']
last_time = 30 # seconds default value:
try:
last_time = calc.get_outputs_dict()['output_parameters'].get_dict(
)['last_time']
except Exception:
pass # Likely no logs were produced
if calc.get_state() == calc_states.FAILED and (
float(max_input_seconds) -
float(last_time)) / float(max_input_seconds) * 100.0 < 1:
max_input_seconds = int(max_input_seconds * 1.3) # 30% increase
calculation_set = self.ctx.calculation_set.get_dict()
calculation_set['max_wallclock_seconds'] = max_input_seconds
self.ctx.calculation_set = DataFactory('parameter')(
dict=calculation_set)
self.report(
"Failed calculation, likely queue time exhaustion, restarting with new max_input_seconds = {}"
.format(max_input_seconds))
return True
if calc.get_state(
) != calc_states.PARSINGFAILED and calc.get_state != calc_states.FINISHED: # special case for parallelization needed
output_p = {}
if 'output_parameters' in calc.get_outputs_dict(
): # calc.get_outputs_dict()['output_parameters'].get_dict().keys()
output_p = calc.get_outputs_dict(
)['output_parameters'].get_dict()
if 'para_error' in output_p.keys():
if output_p[
'para_error'] == True: # Change parallelism or add missing parallelism inputs
self.report(" parallelism error detected")
params = self.ctx.parameters.get_dict()
X_all_q_CPU = params.pop('X_all_q_CPU', '')
X_all_q_ROLEs = params.pop('X_all_q_ROLEs', '')
SE_CPU = params.pop('SE_CPU', '')
SE_ROLEs = params.pop('SE_ROLEs', '')
calculation_set = self.ctx.calculation_set.get_dict()
params[
'X_all_q_CPU'], calculation_set = reduce_parallelism(
'X_all_q_CPU', X_all_q_ROLEs, X_all_q_CPU,
calculation_set)
params['SE_CPU'], calculation_set = reduce_parallelism(
'SE_CPU', SE_ROLEs, SE_CPU, calculation_set)
params["X_all_q_ROLEs"] = X_all_q_ROLEs
params["SE_ROLEs"] = SE_ROLEs
self.ctx.calculation_set = DataFactory('parameter')(
dict=calculation_set)
self.ctx.parameters = DataFactory('parameter')(dict=params)
self.report(
"Calculation {} failed from a parallelism problem: {}".
format(calc.pk, output_p['errors']))
self.report("Old parallelism {}= {} , {} = {} ".format(
X_all_q_ROLEs, X_all_q_CPU, SE_ROLEs, SE_CPU))
self.report("New parallelism {}={} , {} = {}".format(
X_all_q_ROLEs, params['X_all_q_CPU'], SE_ROLEs,
params['SE_CPU']))
return True
if 'unphysical_input' in output_p.keys():
if output_p['unphysical_input'] == True:
# this handles this type of error: "[ERROR][NetCDF] NetCDF: NC_UNLIMITED in the wrong index"
# we should reset the bands to a larger value, it may be too small.
# this is a probable cause, and it may not be the real problem, but often is the cause.
self.report(
"the calculation failed due to a problematic input, defaulting to increasing bands"
)
params = self.ctx.parameters.get_dict()
bandX = params.pop('BndsRnXp', None)
bandG = params.pop('GbndRnge', None)
if bandX:
bandX = (bandX[0], int(bandX[0] * 1.5)) #
params['BndsRnXp'] = bandX
if bandG:
bandG = (bandG[0], int(bandG[0] * 1.5)) #
params['GbndRnge'] = bandG
self.ctx.parameters = DataFactory('parameter')(dict=params)
return True
if 'errors' in output_p.keys() and calc.get_state(
) == calc_states.FAILED:
if len(calc.get_outputs_dict()['output_parameters'].get_dict()
['errors']) < 1:
# No errors, We check for memory issues, indirectly
if 'last_memory_time' in calc.get_outputs_dict(
)['output_parameters'].get_dict().keys():
# check if the last alloc happened close to the end:
last_mem_time = calc.get_outputs_dict(
)['output_parameters'].get_dict()['last_memory_time']
if abs(last_time - last_mem_time
) < 3: # 3 seconds selected arbitrarily,
# this is (based on a simple heuristic guess, a memory related problem)
# change the parallelization to account for this before continuing, warn user too.
params = self.ctx.parameters.get_dict()
X_all_q_CPU = params.pop('X_all_q_CPU', '')
X_all_q_ROLEs = params.pop('X_all_q_ROLEs', '')
SE_CPU = params.pop('SE_CPU', '')
SE_ROLEs = params.pop('SE_ROLEs', '')
calculation_set = self.ctx.calculation_set.get_dict(
)
params[
'X_all_q_CPU'], calculation_set = reduce_parallelism(
'X_all_q_CPU', X_all_q_ROLEs, X_all_q_CPU,
calculation_set)
params[
'SE_CPU'], calculation_set = reduce_parallelism(
'SE_CPU', SE_ROLEs, SE_CPU,
calculation_set)
params["X_all_q_ROLEs"] = X_all_q_ROLEs
params["SE_ROLEs"] = SE_ROLEs
self.ctx.calculation_set = DataFactory(
'parameter')(dict=calculation_set)
self.ctx.parameters = DataFactory('parameter')(
dict=params)
self.report(
"Calculation {} failed likely from memory issues"
)
self.report(
"Old parallelism {}= {} , {} = {} ".format(
X_all_q_ROLEs, X_all_q_CPU, SE_ROLEs,
SE_CPU))
self.report(
"New parallelism selected {}={}, {} = {} ".
format(X_all_q_ROLEs, params['X_all_q_CPU'],
SE_ROLEs, params['SE_CPU']))
return True
else:
pass
if calc.get_state() == calc_states.SUBMISSIONFAILED\
or calc.get_state() == calc_states.FAILED\
or 'output_parameters' not in calc.get_outputs_dict():
self.report(
"Calculation {} failed or did not genrerate outputs for unknow reason, restarting with no changes"
.format(calc.pk))
return True
return False
def step_3(self, recheck=False):
self.report("Working on W-cutoff ")
w_cutoff = 1
extra = {}
if self.inputs.parent_scf_folder:
extra['parent_scf_folder'] = self.inputs.parent_scf_folder
if self.inputs.structure:
extra['structure'] = self.inputs.structure
if self.ctx.last_step == 'step_2_2':
if self.ctx.last_used_band <= self.ctx.step2_res.out.convergence.get_dict(
)['parameters']['BndsRnXp'][-1]:
self.report(
"bands input is similar to that used in a previous cut-off convergence, consistency achieved"
)
self.ctx.step_3_done = True
self.ctx.bands_n_cutoff_consistent = True
return
self.report("passing parameters from re-converged bands ")
extra['parameters'] = ParameterData(
dict=self.ctx.step2_res.out.convergence.get_dict()
['parameters'])
#w_cutoff = self.ctx.last_used_cutoff # start from last used value. ## BUG?
w_cutoff = int(self.ctx.last_used_cutoff * 0.7)
if self.ctx.last_step == 'step_2_1':
self.report("passing parameters from converged bands ")
# use cut-off from 2_1
extra['parameters'] = ParameterData(
dict=self.ctx.step2_res.out.convergence.get_dict()
['parameters'])
#self.ctx.last_used_band = self.ctx.step2_res.out.convergence.get_dict()['parameters']['BndsRnXp'][-1]
self.ctx.last_used_band = self.ctx.step2_res.out.convergence.get_dict(
)['parameters']['BndsRnXp'][-1]
self.report("Bands in last bands convergence: {}".format(
self.ctx.last_used_band))
convergence_parameters = DataFactory('parameter')(
dict={
'variable_to_converge': 'W_cutoff',
'conv_tol': 0.1,
'start_value': w_cutoff,
'step': 1,
'max_value': 20
})
self.report("converging 1-D W-off")
p2y_result = submit(
YamboConvergenceWorkflow,
pwcode=self.inputs.pwcode,
precode=self.inputs.precode,
yambocode=self.inputs.yambocode,
calculation_set=self.inputs.calculation_set,
calculation_set_pw=self.inputs.calculation_set_pw,
parent_nscf_folder=load_node(self.ctx.nscf_calc).out.remote_folder,
pseudo=self.inputs.pseudo,
convergence_parameters=convergence_parameters,
#converge_parameters= converge_parameters,
#parameters = self.ctx.step2_res["convergence"].get_dict()['parameters'],
#threshold = Float(0.01),starting_points = starting_points,
**extra)
self.report("Submitted W-cut off Workflow ")
reslt = {}
if not recheck:
reslt['step3_1_res'] = p2y_result
self.ctx.last_step = 'step_3_1'
self.ctx.first_runs3 = False
else:
reslt['step3_2_res'] = p2y_result
self.ctx.last_step = 'step_3_2'
self.ctx.step_3_done = True
# if this differs from that of step3_1_res
self.step3_res_ = p2y_result
def step_2(self, recheck=False):
self.report("Working on Bands Convergence ")
nelec = load_node(self.ctx.nscf_calc).out.output_parameters.get_dict(
)['number_of_electrons']
band_cutoff = int(nelec / 2)
extra = {}
if self.inputs.parent_scf_folder:
extra['parent_scf_folder'] = self.inputs.parent_scf_folder
if self.inputs.structure:
extra['structure'] = self.inputs.structure
if self.ctx.last_step == 'step_3_1':
if self.ctx.step3_res.out.convergence.get_dict(
)['parameters']['NGsBlkXp'] == 1: # 1 == default,
self.report(
" converged cutt-off are similar to the default used in a previous band convergence, consistency achieved"
)
self.ctx.step_2_done = True
self.ctx.bands_n_cutoff_consistent = True
return
#band_cutoff = self.ctx.last_used_band ## BUG?
band_cutoff = int(self.ctx.last_used_band * 0.7)
extra['parameters'] = ParameterData(
dict=self.ctx.step3_res.out.convergence.get_dict()
['parameters'])
self.report(
"updated the bands convegence parameters with cut-off from cutoff convergence step"
)
if self.ctx.last_step == 'step_3_2':
# CRUNCH TIME: use values from step3_2
if self.ctx.step3_res.out.convergence.get_dict(
)['parameters']['NGsBlkXp'] <= self.ctx.last_used_cutoff: #
# we are done, and consistent:
self.report(
" converged cutt-off are similar to those used in a previous bands convergence, consistency achieved"
)
self.ctx.step_2_done = True
self.ctx.bands_n_cutoff_consistent = True
return
self.report(
"passing parameters from converged cut-off, this can be repeated untill the two parameters are consistent "
)
#band_cutoff = self.ctx.last_used_band ## BUG?
band_cutoff = int(self.ctx.last_used_band * 0.7)
extra['parameters'] = ParameterData(
dict=self.ctx.step3_res.out.convergence.get_dict()
['parameters'])
self.report(
"updated the bands convegence parameters with cut-off from cutoff convergence"
)
if self.ctx.last_step != 'step_1_1' and self.ctx.last_step != 'step_1_2': # last iteration was W_cutoff not FFT
self.ctx.last_used_cutoff = self.ctx.step3_res.out.convergence.get_dict(
)['parameters']['NGsBlkXp']
self.report("Cut-off in last W-Cutoff convergence: {}".format(
self.ctx.last_used_cutoff))
if self.ctx.last_step == 'step_1_1':
params = self.ctx.step1_res.out.convergence.get_dict(
)['parameters']
params['FFTGvecs'] = 2 #
params['NGsBlkXp'] = 2 #
extra['parameters'] = ParameterData(dict=params)
convergence_parameters = DataFactory('parameter')(
dict={
'variable_to_converge': 'bands',
'conv_tol': 0.1,
'start_value': band_cutoff,
'step': 1,
'max_value': nelec - 2
})
self.report("converging BndsRnXp, GbndRnge")
p2y_result = submit(
YamboConvergenceWorkflow,
pwcode=self.inputs.pwcode,
precode=self.inputs.precode,
yambocode=self.inputs.yambocode,
calculation_set=self.inputs.calculation_set,
calculation_set_pw=self.inputs.calculation_set_pw,
parent_nscf_folder=load_node(self.ctx.nscf_calc).out.remote_folder,
pseudo=self.inputs.pseudo,
convergence_parameters=convergence_parameters,
#converge_parameters= converge_parameters,
#threshold = Float(0.01),starting_points = starting_points,
**extra)
self.report("submitted 1-D bands convergence workflow")
reslt = {}
if not recheck:
step2_1_res = p2y_result
self.ctx.last_step = 'step_2_1'
self.ctx.first_runs2 = False
else:
self.step2_2_res = p2y_result
self.ctx.last_step = 'step_2_2'
self.ctx.step_2_done = True
self.step2_res_ = p2y_result
from __future__ import absolute_import
from __future__ import print_function
import os
import click
from aiida.common.example_helpers import test_and_get_code # noqa
from aiida.orm.utils import DataFactory
from aiida.orm import load_node
from aiida.work.run import submit
from aiida_raspa.workflows import RaspaConvergeWorkChain
# data objects
CifData = DataFactory('cif')
ParameterData = DataFactory('parameter')
SinglefileData = DataFactory('singlefile')
@click.command('cli')
@click.argument('codelabel')
@click.option(
'--block_pockets', '-b', required=True, type=int, help='Block pockets')
def main(codelabel, block_pockets):
code = test_and_get_code(codelabel, expected_code_type='raspa')
options_dict = {
"resources": {
"num_machines": 1,
"num_mpiprocs_per_machine": 1,
},
"max_wallclock_seconds": 3 * 60 * 60,
}
load_dbenv()
import json
import os, sys
from aiida_yambo.workflows.yambowf import YamboWorkflow
try:
from aiida.orm.data.base import Float, Str, NumericType, BaseType, Bool, List
from aiida.work.run import run, submit
except ImportError:
from aiida.workflows2.db_types import Float, Str, NumericType, SimpleData, Bool
from aiida.workflows2.db_types import SimpleData as BaseType
from aiida.orm.data.simple import SimpleData as SimpleData_
from aiida.workflows2.run import run
from aiida.orm.utils import DataFactory
ParameterData = DataFactory("parameter")
StructureData = DataFactory('structure')
KpointsData = DataFactory('array.kpoints')
def read_from_pw_inp(filename="../GS/nscf.in"):
from aiida_quantumespresso.tools import pwinputparser
pwinputfile = pwinputparser.PwInputFile(os.path.abspath(filename))
struc = pwinputfile.get_structuredata()
pw_params = pwinputfile.namelists # CONTROL, SYSTEM, ELECTRONS,...
control = pw_params['CONTROL']
system = pw_params['SYSTEM']
del control['pseudo_dir']
del control['outdir']
del control['prefix']
pw_params['CONTROL'] = control
del system['ibrav']
if not is_dbenv_loaded():
load_dbenv()
from aiida.common.exceptions import InputValidationError, ValidationError, WorkflowInputValidationError
from aiida.orm import load_node
from aiida.orm.data.upf import get_pseudos_from_structure
from collections import defaultdict
from aiida.orm.utils import DataFactory, CalculationFactory
from aiida.orm.code import Code
from aiida.orm.data.structure import StructureData
from aiida.common.links import LinkType
from aiida_quantumespresso.calculations.pw import PwCalculation
from aiida_yambo.calculations.gw import YamboCalculation
ParameterData = DataFactory("parameter")
def generate_yambo_input_params(precodename, yambocodename, parent_folder,
parameters, calculation_set, settings):
inputs = YamboCalculation.process().get_inputs_template()
inputs.preprocessing_code = Code.get_from_string(precodename.value)
inputs.code = Code.get_from_string(yambocodename.value)
calculation_set = calculation_set.get_dict()
resource = calculation_set.pop('resources', {})
if resource:
inputs._options.resources = resource
inputs._options.max_wallclock_seconds = calculation_set.pop(
'max_wallclock_seconds', 86400)
max_memory_kb = calculation_set.pop('max_memory_kb', None)
if max_memory_kb:
if not is_dbenv_loaded():
load_dbenv()
from aiida_yambo.workflows.yamboconvergence import YamboConvergenceWorkflow
try:
from aiida.orm.data.base import Float, Str, NumericType, BaseType, List
from aiida.work.run import run, submit
except ImportError:
from aiida.workflows2.db_types import Float, Str, NumericType, SimpleData, Bool
from aiida.workflows2.db_types import SimpleData as BaseType
from aiida.orm.data.simple import SimpleData as SimpleData_
from aiida.workflows2.run import run
from aiida.orm.utils import DataFactory
ParameterData = DataFactory("parameter")
yambo_parameters = {
'ppa': True,
'gw0': True,
'HF_and_locXC': True,
'em1d': True,
'DIP_Threads': 0,
'BndsRnXp': (1, 16),
'NGsBlkXp': 1,
'NGsBlkXp_units': 'RL',
'PPAPntXp': 20,
'PPAPntXp_units': 'eV',
'GbndRnge': (1, 16),
'GDamping': 0.1,
'GDamping_units': 'eV',
def step_3(self, recheck=False):
"""This calls the YamboConvergenceWorkflow as a subworkflow, converging the G-cutoff.
We converge the G-cutoff, using the converged kpoints from a preceeding kpoints,
converged FFT from a preceeding FFT convergence and converged Bands from preceeding bands convergence
This is a 1-D convergence performed by a subworkflow.
"""
nbands = load_node(self.ctx.nscf_calc).out.output_parameters.get_dict(
)['number_of_bands']
self.report("Working on W-cutoff ")
w_cutoff = self.ctx.convergence_settings.dict.start_w_cutoff #2
extra = {}
if 'restart_options_pw' in self.inputs.keys():
extra['restart_options_pw'] = self.inputs.restart_options_pw
if 'restart_options_gw' in self.inputs.keys():
extra['restart_options_gw'] = self.inputs.restart_options_gw
if 'settings_pw_nscf' in self.inputs.keys():
extra['settings_pw_nscf'] = self.inputs.settings_pw_nscf
if 'settings_pw' in self.inputs.keys():
extra['settings_pw'] = self.inputs.settings_pw
if 'settings_p2y' in self.inputs.keys():
extra['settings_pw_p2y'] = self.inputs.settings_p2y
if 'calculation_set_pw_nscf' in self.inputs.keys():
extra[
'calculation_set_pw_nscf'] = self.inputs.calculation_set_pw_nscf
if 'parent_scf_folder' in self.inputs.keys():
extra['parent_scf_folder'] = self.inputs.parent_scf_folder
if 'parent_nscf_folder' in self.inputs.keys():
extra['parent_nscf_folder'] = self.inputs.parent_nscf_folder
if 'structure' in self.inputs.keys():
extra['structure'] = self.inputs.structure
if self.ctx.last_step == 'step_2_2':
if self.ctx.last_used_band <= self.ctx.step2_res.out.convergence.get_dict(
)['parameters']['BndsRnXp'][-1]:
self.report(
"bands input is similar to that used in a previous cut-off convergence, consistency achieved"
)
self.ctx.step_3_done = True
self.ctx.bands_n_cutoff_consistent = True
return
self.report("passing parameters from re-converged bands ")
extra['parameters'] = ParameterData(
dict=self.ctx.step2_res.out.convergence.get_dict()
['parameters'])
#w_cutoff = self.ctx.last_used_cutoff # start from last used value. ## BUG?
#w_cutoff = int(self.ctx.last_used_cutoff*0.7)
w_cutoff = int(self.ctx.step3_res.out.convergence.get_dict()
['parameters']['NGsBlkXp'])
if self.ctx.last_step == 'step_2_1':
self.report("passing parameters from converged bands ")
# use cut-off from 2_1
extra['parameters'] = ParameterData(
dict=self.ctx.step2_res.out.convergence.get_dict()
['parameters'])
#self.ctx.last_used_band = self.ctx.step2_res.out.convergence.get_dict()['parameters']['BndsRnXp'][-1]
self.ctx.last_used_band = self.ctx.step2_res.out.convergence.get_dict(
)['parameters']['BndsRnXp'][-1]
self.report("Bands in last bands convergence: {}".format(
self.ctx.last_used_band))
convergence_parameters = DataFactory('parameter')(
dict={
'variable_to_converge': 'W_cutoff',
'conv_tol': float(self.inputs.threshold),
'start_value': w_cutoff,
'step': 1, # w_cutoff
'max_value': self.ctx.convergence_settings.dict.max_w_cutoff
}) #self.ctx.MAX_B_VAL
self.report("converging 1-D W-off")
p2y_result = submit(YamboConvergenceWorkflow,
pwcode=self.inputs.pwcode,
precode=self.inputs.precode,
yambocode=self.inputs.yambocode,
calculation_set=self.inputs.calculation_set,
calculation_set_pw=self.inputs.calculation_set_pw,
parent_nscf_folder=load_node(
self.ctx.nscf_calc).out.remote_folder,
pseudo=self.inputs.pseudo,
convergence_parameters=convergence_parameters,
**extra)
self.report("Submitted W-cut off Workflow ")
reslt = {}
if not recheck:
reslt['step3_1_res'] = p2y_result
self.ctx.last_step = 'step_3_1'
self.ctx.first_runs3 = False
else:
reslt['step3_2_res'] = p2y_result
self.ctx.last_step = 'step_3_2'
self.ctx.step_3_done = True
# if this differs from that of step3_1_res
self.ctx.step3_res_ = p2y_result
from aiida.backends.utils import load_dbenv, is_dbenv_loaded
if not is_dbenv_loaded():
load_dbenv()
from aiida_yambo.workflows.gwconvergence import YamboFullConvergenceWorkflow
from aiida.orm.data.base import Float, Str, NumericType, BaseType, List
from aiida.work.run import run, submit
from aiida.orm.utils import DataFactory
ParameterData = DataFactory("parameter")
StructureData = DataFactory('structure')
from ase.spacegroup import crystal
a = 5.388
cell = crystal('Si', [(0, 0, 0)],
spacegroup=227,
cellpar=[a, a, a, 90, 90, 90],
primitive_cell=True)
struc = StructureData(ase=cell)
struc.store()
calculation_set_yambo = {
'resources': {
"num_machines": 1,
"num_mpiprocs_per_machine": 8
},
'max_wallclock_seconds': 60 * 60 * 6,
'max_memory_kb': 1 * 80 *
1000000, #REMOVE 'custom_scheduler_commands': u"#PBS -A Pra14_3622\n",
"queue_name": "s3par8c",
'environment_variables': {
def start_workflow(self):
self.ctx.pw_wf_res = DataFactory('parameter')(dict={})
self.ctx.yambo_res = DataFactory('parameter')(dict={})
self.ctx.last_step_pw_wf = None
self.ctx.last_step_kind = None
self.ctx.can_cont = 0
self.ctx.yambo_pks = []
self.ctx.pw_pks = []
self.ctx.done = False
if 'parent_folder' in self.inputs.keys():
parent_calc = self.inputs.parent_folder.get_inputs_dict(
link_type=LinkType.CREATE)['remote_folder']
if isinstance(parent_calc, YamboCalculation):
self.ctx.last_step_kind = 'yambo'
self.ctx.yambo_res = DataFactory('parameter')(dict={
"out": {
"gw": {
"yambo_pk": parent_calc.pk,
"success": True
}
}
})
self.report(
"Yambo calculation (pk {}) found in input, I will start from there."
.format(parent_calc.pk))
elif isinstance(parent_calc, PwCalculation):
self.ctx.last_step_kind = 'pw'
self.ctx.pw_wf_res = None
self.report(
"PW calculation (pk {}) found in input, I will start from there."
.format(parent_calc.pk))
else:
self.ctx.pw_wf_res = None
self.report(
"No PW or Yambo calculation found in input, I will start from scratch."
)
if 'previous_yambo_workchain' in self.inputs.keys():
self.report(
'WARNING: previous_yambo_workchain option should be used in DEBUG mode only!'
)
wf_outs = load_node(int(str(self.inputs.previous_yambo_workchain)))
self.ctx.pw_wf_res = wf_outs # has both gw and pw outputs in one
self.ctx.yambo_res = wf_outs
if 'scf_remote_folder' in wf_outs.get_outputs_dict().keys():
scf_calc = wf_outs.out.scf_remote_folder.get_inputs_dict(
link_type=LinkType.CREATE)['remote_folder']
if scf_calc.get_state() != u'FINISHED':
self.ctx.last_step_kind = 'pw'
del self.ctx['pw_wf_res']
if 'nscf_remote_folder' in wf_outs.get_outputs_dict().keys():
nscf_calc = wf_outs.out.scf_remote_folder.get_inputs_dict(
link_type=LinkType.CREATE)['remote_folder']
if nscf_calc.get_state() != u'FINISHED':
self.ctx.last_step_kind = 'pw'
del self.ctx['pw_wf_res']
if 'yambo_remote_folder' in wf_outs.get_outputs_dict().keys():
parent_calc = wf_outs.out.yambo_remote_folder.get_inputs_dict(
link_type=LinkType.CREATE)['remote_folder']
print(parent_calc.inp.settings.get_dict())
init_calc = parent_calc.inp.settings.get_dict().pop(
'INITIALISE', False)
if init_calc and parent_calc.get_state(
) == u'FINISHED': # Finished P2Y
self.ctx.last_step_kind = 'yambo_p2y'
elif init_calc == False and parent_calc.get_state(
) != u'FINISHED': # Unfinished QP
self.ctx.last_step_kind = 'yambo'
elif init_calc == False and parent_calc.get_state(
) == u'FINISHED': # Finished QP?
self.ctx.last_step_kind = 'yambo'
else: # unifinished P2Y?
self.ctx.last_step_kind = 'pw'
self.report("DEBUG: workchain {} loaded".format(
self.ctx.yambo_res))
try:
self.ctx.bands_groupname = self.inputs.bands_groupname
self.report("GW bands will be added to the group {}".format(
self.inputs.bands_groupname))
except AttributeError:
self.ctx.bands_groupname = None
self.ctx.parameters_yambo = self.inputs.parameters_yambo
self.report(" workflow initilization step completed.")
from aiida.orm.code import Code
from aiida.orm.utils import CalculationFactory, DataFactory
from aiida.work.workchain import WorkChain, ToContext, Outputs, while_
from aiida.work.run import submit
from .dftutilities import default_options, empty_pd
from copy import deepcopy
# data objects
StructureData = DataFactory('structure')
ParameterData = DataFactory('parameter')
RemoteData = DataFactory('remote')
# workchains
from aiida_cp2k.workflows import Cp2kDftBaseWorkChain
from aiida_cp2k.workflows import Cp2kGeoOptWorkChain
from aiida_cp2k.workflows import Cp2kCellOptWorkChain
from aiida_cp2k.workflows import Cp2kMdWorkChain
class Cp2kRobustGeoOptWorkChain(WorkChain):
"""Robust workflow that tries to optimize geometry combining molecular dynamics, cell optimization, and standard
geometry optimization. It is under development!"""
@classmethod
def define(cls, spec):
super(Cp2kRobustGeoOptWorkChain, cls).define(spec)
# specify the inputs of the workchain
spec.input('code', valid_type=Code)
spec.input('structure', valid_type=StructureData)
spec.input('parameters', valid_type=ParameterData, default=empty_pd)
spec.input('_options',
if not is_dbenv_loaded():
load_dbenv()
from aiida_yambo.workflows.yamboconvergence import YamboConvergenceWorkflow
try:
from aiida.orm.data.base import Float, Str, NumericType, BaseType, List
from aiida.work.run import run, submit
except ImportError:
from aiida.workflows2.db_types import Float, Str, NumericType, SimpleData, Bool
from aiida.workflows2.db_types import SimpleData as BaseType
from aiida.orm.data.simple import SimpleData as SimpleData_
from aiida.workflows2.run import run
from aiida.orm.utils import DataFactory
ParameterData = DataFactory("parameter")
StructureData = DataFactory('structure')
cell = [
[4.2262023163, 0.0000000000, 0.0000000000],
[0.0000000000, 4.2262023163, 0.0000000000],
[0.0000000000, 0.0000000000, 2.7009939524],
]
struc = StructureData(cell=cell)
struc.append_atom(position=(1.2610450495, 1.2610450495, 0.0000000000),
symbols='O')
struc.append_atom(position=(0.8520622471, 3.3741400691, 1.3504969762),
symbols='O')
struc.append_atom(position=(2.9651572668, 2.9651572668, 0.0000000000),
symbols='O')
