def define(cls, spec):
super(PwBandsWorkChain, cls).define(spec)
spec.input('code', valid_type=Code)
spec.input('structure', valid_type=StructureData)
spec.input('pseudo_family', valid_type=Str)
spec.input('kpoints_distance', valid_type=Float, default=Float(0.2))
spec.input('kpoints_distance_bands',
valid_type=Float,
default=Float(0.2))
spec.input('kpoints', valid_type=KpointsData, required=False)
spec.input('vdw_table', valid_type=SinglefileData, required=False)
spec.input('parameters', valid_type=ParameterData)
spec.input('settings', valid_type=ParameterData, required=False)
spec.input('options', valid_type=ParameterData, required=False)
spec.input('automatic_parallelization',
valid_type=ParameterData,
required=False)
spec.input('group', valid_type=Str, required=False)
spec.input_group('relax', required=False)
spec.outline(
cls.setup,
cls.validate_inputs,
if_(cls.should_do_relax)(cls.run_relax, ),
cls.run_seekpath,
cls.run_scf,
cls.run_bands,
cls.results,
)
spec.output('primitive_structure', valid_type=StructureData)
spec.output('seekpath_parameters', valid_type=ParameterData)
spec.output('scf_parameters', valid_type=ParameterData)
spec.output('band_parameters', valid_type=ParameterData)
spec.output('band_structure', valid_type=BandsData)
def test_add(self):
a = Float(4)
b = Float(5)
# Check adding two db Floats
res = a + b
self.assertIsInstance(res, NumericType)
self.assertEqual(res, 9.0)
# Check adding db Float and native (both ways)
res = a + 5.0
self.assertIsInstance(res, NumericType)
self.assertEqual(res, 9.0)
res = 5.0 + a
self.assertIsInstance(res, NumericType)
self.assertEqual(res, 9.0)
# Inplace
a = Float(4)
a += b
self.assertEqual(a, 9.0)
a = Float(4)
a += 5
self.assertEqual(a, 9.0)
def define(cls, spec):
super(OptimizeStructure, cls).define(spec)
spec.input("structure", valid_type=StructureData)
spec.input("es_settings", valid_type=ParameterData)
# Optional
spec.input("pressure",
valid_type=Float,
required=False,
default=Float(0.0))
spec.input("tolerance_forces",
valid_type=Float,
required=False,
default=Float(1e-5))
spec.input("tolerance_stress",
valid_type=Float,
required=False,
default=Float(1e-2))
spec.input("max_iterations",
valid_type=Int,
required=False,
default=Int(10))
spec.input("standarize_cell",
valid_type=Bool,
required=False,
default=Bool(True))
spec.outline(cls.optimize_cycle,
_While(cls.not_converged)(cls.optimize_cycle),
cls.get_data)
def test_create(self):
a = Float()
# Check that initial value is zero
self.assertEqual(a.value, 0.0)
f = Float(6.0)
self.assertEqual(f.value, 6.)
self.assertEqual(f, Float(6.0))
i = Int()
self.assertEqual(i.value, 0)
i = Int(6)
self.assertEqual(i.value, 6)
self.assertEqual(f, i)
b = Bool()
self.assertEqual(b.value, False)
b = Bool(False)
self.assertEqual(b.value, False)
self.assertEqual(b.value, get_false_node())
b = Bool(True)
self.assertEqual(b.value, True)
self.assertEqual(b.value, get_true_node())
s = Str()
self.assertEqual(s.value, "")
s = Str('Hello')
self.assertEqual(s.value, 'Hello')
def test_mul(self):
a = Float(4)
b = Float(5)
# Check adding two db Floats
res = a * b
self.assertIsInstance(res, NumericType)
self.assertEqual(res, 20.0)
# Check adding db Float and native (both ways)
res = a * 5.0
self.assertIsInstance(res, NumericType)
self.assertEqual(res, 20)
res = 5.0 * a
self.assertIsInstance(res, NumericType)
self.assertEqual(res, 20.0)
# Inplace
a = Float(4)
a *= b
self.assertEqual(a, 20)
a = Float(4)
a *= 5
self.assertEqual(a, 20)
def run_bands(self):
"""
Run the PwBandsWorkChain to compute the band structure
"""
inputs = dict(self.ctx.inputs)
options = inputs['options']
settings = inputs['settings']
parameters = inputs['parameters']
# Final input preparation, wrapping dictionaries in ParameterData nodes
inputs['kpoints_mesh'] = self.ctx.kpoints_mesh
inputs['parameters'] = ParameterData(dict=parameters)
inputs['settings'] = ParameterData(dict=settings)
inputs['options'] = ParameterData(dict=options)
inputs['relax'] = {
'kpoints_distance': Float(self.ctx.protocol['kpoints_mesh_density']),
'parameters': ParameterData(dict=parameters),
'settings': ParameterData(dict=settings),
'options': ParameterData(dict=options),
'meta_convergence': Bool(False),
'relaxation_scheme': Str('vc-relax'),
'volume_convergence': Float(0.01)
}
running = self.submit(PwBandsWorkChain, **inputs)
self.report('launching PwBandsWorkChain<{}>'.format(running.pk))
return ToContext(workchain_bands=running)
def define(cls, spec):
super(GCMCMD2, cls).define(spec)
# structure, adsorbant, pressures
spec.input('structure', valid_type=CifData)
spec.input("pressure", valid_type=Float, required=True)
spec.input("number_runs", valid_type=Float, default=Float(1))
spec.input("number_cycles_lower", valid_type=Float, default=Float(1))
spec.input("number_cycles_upper",
valid_type=Float,
default=Float(100000))
# zeopp
spec.input('zeopp_code', valid_type=Code)
spec.input("_zeopp_options",
valid_type=dict,
default=None,
required=False)
spec.input("zeopp_probe_radius", valid_type=Float)
spec.input("zeopp_atomic_radii",
valid_type=SinglefileData,
default=None,
required=False)
# raspa
spec.input("raspa_code", valid_type=Code)
spec.input("raspa_parameters_gcmc", valid_type=ParameterData)
spec.input("raspa_parameters_md", valid_type=ParameterData)
spec.input("raspa_parameters_gcmc_0", valid_type=ParameterData)
spec.input("_raspa_options",
valid_type=dict,
default=None,
required=False)
# settings
spec.input("_usecharges",
valid_type=bool,
default=True,
required=False)
# workflow
spec.outline(
cls.init,
cls.run_zeopp, # computes volpo and block pockets
cls.init_raspa_calc, # assign HeliumVoidFraction=POAV
cls.run_first_gcmc, # first GCMC is longer and with intialization
cls.
parse_loading_raspa, # then move to loop in which one cycles between MD and MC
while_(cls.should_run_loading_raspa)(
cls.run_md,
cls.parse_loading_raspa,
cls.
run_loading_raspa, # for each run, recover the last snapshot of the previous and run GCMC
cls.parse_loading_raspa,
),
cls.return_results,
)
spec.dynamic_output()
def define(cls, spec):
spec.input("structure", valid_type=StructureData)
spec.input("start", valid_type=NumericType, default=Float(0.96))
spec.input("delta", valid_type=NumericType, default=Float(0.02))
spec.input("end", valid_type=NumericType, default=Float(1.04))
spec.input("code", valid_type=Str)
spec.input("pseudo_family", valid_type=Str)
spec.outline(cls.run_pw, cls.print_eos)
def define(cls, spec):
super(GruneisenPhonopy, cls).define(spec)
spec.input("structure", valid_type=StructureData)
spec.input("ph_settings", valid_type=ParameterData)
spec.input("es_settings", valid_type=ParameterData)
# Optional arguments
spec.input("pressure", valid_type=Float, required=False, default=Float(0.0)) # in kB
spec.input("stress_displacement", valid_type=Float, required=False, default=Float(2.0)) # in kB
spec.input("use_nac", valid_type=Bool, required=False, default=Bool(False))
spec.outline(cls.create_unit_cell_expansions, cls.calculate_gruneisen)
def submit_jobs(self):
print("structure PK: %i" % self.inputs.structure.pk)
grp, created = Group.get_or_create(name=self.inputs.group)
grp.add_nodes([self.calc])
print("stress tensor PK: %i" % self.calc.pk)
# get calculation class
C = CalculationFactory(self.inputs.code.get_input_plugin_name())
Proc = C.process()
num_points = 5
# volume scales from 0.94 to 1.06, alat scales as pow(1/3)
scales = numpy.linspace(0.94**(1 / 3.0), 1.06**(1 / 3.0),
num_points).tolist()
calcs = {}
for scale in scales:
print("scale = %f" % scale)
# scaled structure
new_structure = scaled_structure(self.inputs.structure,
Float(scale))
# basic parameters of the calculation
params = calculation_helpers.create_calculation_parameters(
self.inputs.code, str(self.inputs.partition),
int(self.inputs.ranks_per_node), int(self.inputs.ranks_kp),
int(self.inputs.ranks_diag))
inputs = Proc.get_inputs_template()
inputs.code = self.inputs.code
inputs._options.resources = params['calculation_resources']
inputs._options.max_wallclock_seconds = 20 * 60
inputs._options.custom_scheduler_commands = params[
'custom_scheduler_commands']
inputs._options.environment_variables = params[
'environment_variables']
inputs._options.mpirun_extra_params = params['mpirun_extra_params']
inputs.structure = new_structure
inputs.kpoints = KpointsData()
inputs.kpoints.set_kpoints_mesh(self.inputs.kmesh,
offset=(0.0, 0.0, 0.0))
inputs.parameters = params['calculation_parameters']
inputs.settings = params['calculation_settings']
if self.inputs.code.get_input_plugin_name(
) == 'quantumespresso.pw':
inputs.pseudo = get_pseudos(new_structure,
self.inputs.atomic_files)
if self.inputs.code.get_input_plugin_name() == 'exciting.exciting':
inputs.lapwbasis = get_lapwbasis(new_structure,
self.inputs.atomic_files)
future = submit(Proc, **inputs)
def test_identifier_sub_classes(self):
"""
The sub_classes keyword argument should allow to narrow the scope of the query based on the orm class
"""
node_bool = Bool(True).store()
node_float = Float(0.0).store()
node_int = Int(1).store()
param_type_normal = NodeParamType()
param_type_scoped = NodeParamType(sub_classes=('aiida.data:bool',
'aiida.data:float'))
# For the base NodeParamType all node types should be matched
self.assertEquals(
param_type_normal.convert(str(node_bool.pk), None, None).uuid,
node_bool.uuid)
self.assertEquals(
param_type_normal.convert(str(node_float.pk), None, None).uuid,
node_float.uuid)
self.assertEquals(
param_type_normal.convert(str(node_int.pk), None, None).uuid,
node_int.uuid)
# The scoped NodeParamType should only match Bool and Float
self.assertEquals(
param_type_scoped.convert(str(node_bool.pk), None, None).uuid,
node_bool.uuid)
self.assertEquals(
param_type_scoped.convert(str(node_float.pk), None, None).uuid,
node_float.uuid)
# The Int should not be found and raise
with self.assertRaises(click.BadParameter):
param_type_scoped.convert(str(node_int.pk), None,
None).uuid, node_int.uuid
def define(cls, spec):
super(SelfConsistentHubbardWorkChain, cls).define(spec)
spec.input('structure', valid_type=StructureData)
spec.input('hubbard_u', valid_type=ParameterData)
spec.input('tolerance', valid_type=Float, default=Float(0.1))
spec.input('max_iterations', valid_type=Int, default=Int(5))
spec.input('is_insulator', valid_type=Bool, required=False)
spec.input('meta_convergence', valid_type=Bool, default=Bool(False))
spec.expose_inputs(PwBaseWorkChain,
namespace='scf',
exclude=('structure'))
spec.expose_inputs(HpWorkChain,
namespace='hp',
exclude=('parent_calculation'))
spec.outline(
cls.setup,
cls.validate_inputs,
if_(cls.should_run_recon)(
cls.run_recon,
cls.inspect_recon,
),
while_(cls.should_run_iteration)(
if_(cls.should_run_relax)(
cls.run_relax,
cls.inspect_relax,
),
if_(cls.is_metal)(cls.run_scf_smearing).elif_(cls.is_magnetic)(
cls.run_scf_smearing,
cls.run_scf_fixed_magnetic).else_(cls.run_scf_fixed),
cls.run_hp,
cls.inspect_hp,
),
cls.run_results,
)
def run_eos_wf(codename, pseudo_family, element):
print "Workfunction node identifiers: {}".format(Process.current().calc)
s0 = create_diamond_fcc(Str(element))
calcs = {}
for label, factor in zip(labels, scale_facs):
s = rescale(s0, Float(factor))
inputs = generate_scf_input_params(s, str(codename),
Str(pseudo_family))
print "Running a scf for {} with scale factor {}".format(
element, factor)
result = run(PwCalculation, **inputs)
print "RESULT: {}".format(result)
calcs[label] = get_info(result)
eos = []
for label in labels:
eos.append(calcs[label])
# Return information to plot the EOS
ParameterData = DataFactory('parameter')
retdict = {
'initial_structure': s0,
'result': ParameterData(dict={'eos_data': eos})
}
return retdict
def calc_energies(codename, pseudo_family):
print("Calculating energies, my pk is '{}'".format(
ProcessStack.get_active_process_id()))
futures = {}
for element, scale in [("Si", 5.41)]:
structure = create_diamond_fcc(Str(element), Float(1.))
structure = rescale(structure, Float(scale))
print("Running {} scf calculation.".format(element))
futures[element] = async(run_scf, structure, codename, pseudo_family)
print("Waiting for calculations to finish.")
outs = {element: Float(future.result()['output_parameters'].dict.energy)
for element, future in futures.iteritems()}
print("Calculations finished.")
return outs
def _run_loading_raspa(self):
"""Perform raspa calculation at given pressure.
Most of the runtime will be spent in this function.
"""
# Create the input dictionary
inputs = {
'code':
self.inputs.raspa_code,
'structure':
self.inputs.structure,
'parameters':
update_raspa_parameters(self.inputs.raspa_parameters,
Float(self.ctx.current_pressure)),
'block_component_0':
self.ctx.zeopp['block'],
'_options':
self.ctx.options,
}
# Create the calculation process and launch it
process = RaspaCalculation.process()
future = submit(process, **inputs)
self.report("pk: {} | Running raspa for the pressure {} [bar]".format(
future.pid, self.ctx.current_pressure / 1e5))
return ToContext(raspa=Outputs(future))
def create_unit_cell_expansions(self):
print('start Gruneisen (pk={})'.format(self.pid))
print('start create cell expansions')
# For testing
testing = False
if testing:
self.ctx._content['plus'] = load_node(13603)
self.ctx._content['origin'] = load_node(13600)
self.ctx._content['minus'] = load_node(13606)
return
calcs = {}
for expansions in {'plus': float(self.inputs.pressure) + float(self.inputs.stress_displacement),
'origin': float(self.inputs.pressure),
'minus': float(self.inputs.pressure) - float(self.inputs.stress_displacement)}.items():
future = submit(PhononPhonopy,
structure=self.inputs.structure,
ph_settings=self.inputs.ph_settings,
es_settings=self.inputs.es_settings,
pressure=Float(expansions[1]),
optimize=Bool(True),
use_nac=self.inputs.use_nac
)
calcs[expansions[0]] = future
print ('phonon workchain: {} {}'.format(expansions[0], future.pid))
return ToContext(**calcs)
def define(cls, spec):
super(Cp2kGeoOptDdecWorkChain, cls).define(spec)
# structure, adsorbant, pressures
spec.input('structure', valid_type=StructureData)
spec.input("min_cell_size", valid_type=Float, default=Float(10))
# cp2k
spec.input('cp2k_code', valid_type=Code)
spec.input('cp2k_parameters', valid_type=ParameterData, default=ParameterData(dict={}))
spec.input("_cp2k_options", valid_type=dict, default=None, required=False)
spec.input('cp2k_parent_folder', valid_type=RemoteData, default=None, required=False)
# ddec
spec.input('ddec_code', valid_type=Code)
spec.input("_ddec_options", valid_type=dict, default=None, required=False)
# settings
spec.input('_guess_multiplicity', valid_type=bool, default=False)
# workflow
spec.outline(
cls.run_geo_opt, #robust 5 stesps cellopt, first expands the uc according to min_cell_size
cls.parse_geo_opt,
cls.run_point_charges, # wfn > (E_DENSITY & core_el) > DDEC charges
cls.parse_point_charges,
cls.return_results,
)
# specify the outputs of the workchain
spec.output('output_structure', valid_type=CifData, required=False)
def get_structure(original_structure, new_volume):
"""
Given a structure and a new volume, rescale the structure to the new volume
"""
initial_volume = original_structure.get_cell_volume()
scale_factor = (new_volume / initial_volume)**(1. / 3.)
scaled_structure = rescale(original_structure, Float(scale_factor))
return scaled_structure
def run_eos(structure,
element="Si",
code='qe-pw-6.2.1@localhost',
pseudo_family='GBRV_lda'):
return run(PressureConvergence,
structure=structure,
code=Str(code),
pseudo_family=Str(pseudo_family),
volume_tolerance=Float(0.1))
def define(cls, spec):
super(ThermalPhono3py, cls).define(spec)
spec.input("structure", valid_type=StructureData)
spec.input("ph_settings", valid_type=ParameterData)
spec.input("es_settings", valid_type=ParameterData)
# Optional arguments
spec.input("optimize",
valid_type=Bool,
required=False,
default=Bool(True))
spec.input("pressure",
valid_type=Float,
required=False,
default=Float(0.0))
spec.input("use_nac",
valid_type=Bool,
required=False,
default=Bool(False))
spec.input("chunks", valid_type=Int, required=False, default=Int(100))
spec.input("step",
valid_type=Float,
required=False,
default=Float(1.0))
spec.input("initial_cutoff",
valid_type=Float,
required=False,
default=Float(2.0))
spec.input("gp_chunks", valid_type=Int, required=False, default=Int(1))
# Convergence criteria
spec.input("rtol",
valid_type=Float,
required=False,
default=Float(0.3))
spec.input("atol",
valid_type=Float,
required=False,
default=Float(0.1))
spec.outline(
cls.harmonic_calculation,
_While(cls.not_converged)(cls.get_data_sets,
cls.get_thermal_conductivity),
cls.collect_data)
def define(cls, spec):
super(PhononPhono3py, cls).define(spec)
spec.input("structure", valid_type=StructureData)
spec.input("ph_settings", valid_type=ParameterData)
spec.input("es_settings", valid_type=ParameterData)
# Optional arguments
spec.input("optimize", valid_type=Bool, required=False, default=Bool(True))
spec.input("pressure", valid_type=Float, required=False, default=Float(0.0))
spec.input("use_nac", valid_type=Bool, required=False, default=Bool(False)) # false by default
spec.input("calculate_fc", valid_type=Bool, required=False, default=Bool(False)) # false by default
spec.input("chunks", valid_type=Int, required=False, default=Int(100))
spec.input("cutoff", valid_type=Float, required=False, default=Float(0))
spec.input("recover", required=False, default=Bool(False)) # temporal patch
spec.input("data_sets", required=False, default=Bool(False))
spec.outline(_If(cls.use_optimize)(cls.optimize),
# cls.create_displacement_calculations,
_While(cls.continue_submitting)(cls.create_displacement_calculations_chunk),
cls.collect_data,
_If(cls.calculate_fc)(cls.calculate_force_constants))
def eos(structure, codename, pseudo_family):
Proc = PwCalculation.process()
results = {}
for s in (0.98, 0.99, 1.0, 1.02, 1.04):
rescaled = rescale(structure, Float(s))
inputs = generate_scf_input_params(rescaled, codename, pseudo_family)
outputs = run(Proc, **inputs)
res = outputs['output_parameters'].dict
results[str(s)] = res
return results
def main():
inputs = {'a': Float(3.14), 'b': Int(4), 'c': Int(6)}
results = run(SumWorkChain, **inputs)
print 'Result of SumWorkChain: {}'.format(results)
results = run(ProductWorkChain, **inputs)
print 'Result of ProductWorkChain: {}'.format(results)
results = run(SumProductWorkChain, **inputs)
print 'Result of SumProductWorkChain: {}'.format(results)
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 launch(code, structure, pseudo_family, kpoints, max_num_machines,
max_wallclock_seconds, daemon, automatic_parallelization):
"""
Run the PwBandsWorkChain for a given input structure
"""
from aiida.orm.data.base import Bool, Float, Str
from aiida.orm.data.parameter import ParameterData
from aiida.orm.utils import WorkflowFactory
from aiida.work.run import run, submit
from aiida_quantumespresso.utils.resources import get_default_options
PwBandsWorkChain = WorkflowFactory('quantumespresso.pw.bands')
parameters = {
'SYSTEM': {
'ecutwfc': 30.,
'ecutrho': 240.,
},
}
relax_inputs = {
'kpoints_distance': Float(0.2),
'parameters': ParameterData(dict=parameters),
}
inputs = {
'code': code,
'structure': structure,
'pseudo_family': Str(pseudo_family),
'kpoints': kpoints,
'parameters': ParameterData(dict=parameters),
'relax': relax_inputs,
}
if automatic_parallelization:
parallelization = {
'max_num_machines': max_num_machines,
'target_time_seconds': 0.5 * max_wallclock_seconds,
'max_wallclock_seconds': max_wallclock_seconds
}
inputs['automatic_parallelization'] = ParameterData(
dict=parallelization)
else:
options = get_default_options(max_num_machines, max_wallclock_seconds)
inputs['options'] = ParameterData(dict=options)
if daemon:
workchain = submit(PwBandsWorkChain, **inputs)
click.echo('Submitted {}<{}> to the daemon'.format(
PwBandsWorkChain.__name__, workchain.pid))
else:
run(PwBandsWorkChain, **inputs)
def main():
a = Float(3.14)
b = Int(4)
c = Int(6)
results = sum(a, b)
print 'Result of sum: {}'.format(results)
results = product(a, b)
print 'Result of product: {}'.format(results)
results = sumproduct(a, b, c)
print 'Result of sumproduct: {}'.format(results)
def to_db_type(value):
if isinstance(value, Data):
return value
elif isinstance(value, bool):
return Bool(value)
elif isinstance(value, (int, long)):
return Int(value)
elif isinstance(value, float):
return Float(value)
elif isinstance(value, basestring):
return Str(value)
else:
raise ValueError("Cannot convert value to database type")
def test_operator(self):
a = Float(2.2)
b = Int(3)
for op in [
operator.add, operator.mul, operator.pow, operator.lt,
operator.le, operator.gt, operator.ge, operator.iadd,
operator.imul
]:
for x, y in [(a, b), (b, a)]:
c = op(x, y)
c_val = op(x.value, y.value)
self.assertEqual(c._type, type(c_val))
self.assertEqual(c, op(x.value, y.value))
def define(cls, spec):
super(DFTGeoOptWorkChain, cls).define(spec)
spec.input("cp2k_code", valid_type=Code)
spec.input("structure", valid_type=StructureData)
spec.input("max_force", valid_type=Float, default=Float(0.001))
spec.input("vdw_switch", valid_type=Bool, default=Bool(False))
spec.input("mgrid_cutoff", valid_type=Int, default=Int(600))
spec.input("fixed_atoms", valid_type=Str, default=Str(''))
spec.outline(
cls.run_geopt,
while_(cls.not_converged)(cls.run_geopt_again),
)
spec.dynamic_output()
def get_gruneisen_prediction(self):
print('start qha (pk={})'.format(self.pid))
if __testing__:
self.ctx._content['gruneisen'] = load_node(19945)
return
future = submit(GruneisenPhonopy,
structure=self.inputs.structure,
ph_settings=self.inputs.ph_settings,
es_settings=self.inputs.es_settings,
pressure=Float(0.0),
use_nac=self.inputs.use_nac)
print('gruneisen workchain: {}'.format(future.pid))
return ToContext(gruneisen=future)
