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 define(cls, spec):
"""
Defines the outline of the workflow.
"""
# Take input of the workflow or use defaults defined above
super(kkr_maginit_wc, cls).define(spec)
spec.input("wf_parameters",
valid_type=ParameterData,
required=False,
default=ParameterData(dict=cls._wf_default))
spec.input("remote_data", valid_type=RemoteData, required=False)
spec.input("kkr", valid_type=Code, required=True)
# Here the structure of the workflow is defined
spec.outline(
# initialize workflow
cls.start,
# check input consistency (needs to be NSPIN=2)
if_(cls.validate_input)(
# set input parameter for initial magnetization
cls.update_inp_node,
# run Nmax number of simple mixing to initialize moment
cls.run_kkr,
# check calculation output
cls.inspect_kkr,
# reset parameters to continue calculation
cls.reset_inp_node),
cls.return_results)
def define(cls, spec):
super(fleur_convergence, cls).define(spec)
spec.input("wf_parameters",
valid_type=ParameterData,
required=False,
default=ParameterData(
dict={
'fleur_runmax': 4,
'density_criterion': 0.00002,
'energy_criterion': 0.002,
'converge_density': True,
'converge_energy': False,
'reuse': True
}))
spec.input("structure", valid_type=StructureData, required=False)
spec.input("calc_parameters", valid_type=ParameterData, required=False)
#spec.input("settings", valid_type=ParameterData, required=False)
spec.input("fleurinp", valid_type=FleurInpData, required=False)
spec.input("remote_data", valid_type=RemoteData, required=False)
spec.input("inpgen", valid_type=Code, required=False)
spec.input("fleur", valid_type=Code, required=True)
spec.outline(cls.start,
if_(cls.validate_input)(cls.run_fleurinpgen),
cls.run_fleur, cls.get_res,
while_(cls.condition)(cls.run_fleur,
cls.get_res), cls.return_results)
def define(cls, spec):
"""
Defines the outline of the workflow.
"""
# Take input of the workflow or use defaults defined above
super(kkr_startpot_wc, cls).define(spec)
spec.input("wf_parameters",
valid_type=ParameterData,
required=False,
default=ParameterData(dict=cls._wf_default))
spec.input("structure", valid_type=StructureData, required=True)
spec.input("kkr", valid_type=Code, required=True)
spec.input("voronoi", valid_type=Code, required=True)
spec.input("calc_parameters", valid_type=ParameterData, required=False)
# Here the structure of the workflow is defined
spec.outline(
# initialize workflow and check inputs
cls.start,
# check if another iteration is done (in case of either voro_ok, doscheck_ok is False)
while_(cls.do_iteration_check)(
# run voronoi calculation
cls.run_voronoi,
# check voronoi output (also sets ctx.voro_ok)
if_(cls.check_voronoi)(
# create starting DOS using dos sub-workflow
cls.get_dos,
# perform some checks and set ctx.doscheck_ok accordingly
cls.check_dos)),
# collect results and return
cls.return_results)
def define(cls, spec):
super(PwBaseWorkChain, cls).define(spec)
spec.input('code', valid_type=Code)
spec.input('structure', valid_type=StructureData)
spec.input('kpoints', valid_type=KpointsData)
spec.input('parameters', valid_type=ParameterData)
spec.input_group('pseudos', required=False)
spec.input('pseudo_family', valid_type=Str, required=False)
spec.input('parent_folder', valid_type=RemoteData, required=False)
spec.input('vdw_table', valid_type=SinglefileData, required=False)
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.outline(
cls.setup,
cls.validate_inputs,
if_(cls.should_run_init)(
cls.validate_init_inputs,
cls.run_init,
cls.inspect_init,
),
while_(cls.should_run_calculation)(
cls.prepare_calculation,
cls.run_calculation,
cls.inspect_calculation,
),
cls.results,
)
spec.output('output_array', valid_type=ArrayData, required=False)
spec.output('output_band', valid_type=BandsData, required=False)
spec.output('output_structure', valid_type=StructureData, required=False)
spec.output('output_parameters', valid_type=ParameterData)
spec.output('remote_folder', valid_type=RemoteData)
spec.output('retrieved', valid_type=FolderData)
def define(cls, spec):
super(ChangeStoichiometryWorkChain, cls).define(spec)
spec.input('structure', valid_type=StructureData, required=True)
spec.input('species', valid_type=Str, required=True)
spec.input('delta_N', valid_type=Float, required=True)
spec.input('distribution', valid_type=Str, default=Str('equal_scale'))
spec.input('delta_weight_equal', valid_type=Float, default=Float(0.01))
spec.input('error_tol_occ', valid_type=Float, default=Float(1e-4))
spec.outline(
cls.check_inputs,
if_(cls.distribution_is_equal_scale)(
cls.change_stoichiometry_equal_scale,
).elif_(cls.distribution_is_aufbau)(
cls.change_stoichiometry_aufbau,
).else_(
cls.no_distribution,
),
cls.set_output
)
spec.output('structure_changed', valid_type=StructureData)
spec.exit_code(1, 'ERROR_INPUT', 'Unreasonable input parameters.')
spec.exit_code(2, 'ERROR_MISSING_DISTRIBUTION', 'No valid distibution for stoichiometry change provided.')
spec.exit_code(3, 'ERROR_PROCESS', 'Could not generate requested structure: Unreasonable occupancies.')
spec.exit_code(4, 'ERROR_ATOMS_LEFT', 'Requested change in stoichiometry exceeds amount available in cell.')
def define(cls, spec):
super(VolpoKh, cls).define(spec)
# structure
spec.input('structure', valid_type=CifData)
# 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", valid_type=ParameterData)
spec.input("_raspa_options", valid_type=dict, default=None, required=False)
spec.input("_raspa_usecharges", valid_type=bool, default=False, required=False)
# workflow
spec.outline(
cls.run_zeopp, #computes volpo and blocks
if_(cls.should_run_widom)( #run Widom only if porous
cls.init_raspa_widom, #initialize raspa calculation
cls.run_raspa_widom, #run raspa calculation
),
cls.return_results,
)
spec.dynamic_output()
def define(cls, spec):
"""
Defines the outline of the workflow.
"""
# Take input of the workflow or use defaults defined above
super(kkr_dos_wc, cls).define(spec)
spec.input("wf_parameters",
valid_type=ParameterData,
required=False,
default=ParameterData(dict=cls._wf_default))
spec.input("remote_data", valid_type=RemoteData, required=True)
spec.input("kkr", valid_type=Code, required=True)
# Here the structure of the workflow is defined
spec.outline(
# initialize workflow
cls.start,
# validate input
if_(cls.validate_input)(
# set DOS contour in parameter node
cls.set_params_dos,
# calculate DOS and interpolate result
cls.get_dos),
# collect results and store DOS output as ArrayData node (dos, lmdos, dos.interpolate, ...)
cls.return_results)
def define(cls, spec):
"""Define inputs, logic and outputs of ZeoppGeometryWorkChain"""
super(ZeoppBlockPocketsWorkChain, cls).define(spec)
# Define the inputs, specifying the type we expect
spec.input("probe_radius", valid_type=Float, required=True)
spec.input("structure", valid_type=CifData, required=True)
spec.input("zeopp_code", valid_type=Code, required=True)
spec.input("_options",
valid_type=dict,
required=False,
default=options)
# Define the outputs, specifying the type we expect
spec.output("block", valid_type=SinglefileData, required=False)
spec.output("output_parameters",
valid_type=ParameterData,
required=True)
# Define workflow logic
spec.outline(
cls.run_geom_zeopp,
if_(cls.should_run_block_zeopp)(cls.run_block_zeopp, ),
cls.return_result,
)
def define(cls, spec):
super(fleur_initial_cls_wc, cls).define(spec)
spec.input("wf_parameters",
valid_type=ParameterData,
required=False,
default=ParameterData(
dict={
'references': {},
'relax': True,
'relax_mode': 'Fleur',
'relax_para': 'default',
'scf_para': 'default',
'same_para': True,
'resources': {
"num_machines": 1
},
'walltime_sec': 10 * 60,
'queue_name': None,
'serial': True,
'custom_scheduler_commands': ''
}))
#TODO_default_wf_para out of here#
spec.input("fleurinp", valid_type=FleurinpData, required=False)
spec.input("fleur", valid_type=Code, required=True)
spec.input("inpgen", valid_type=Code, required=False)
spec.input("structure", valid_type=StructureData, required=False)
spec.input("calc_parameters", valid_type=ParameterData, required=False)
spec.outline(cls.check_input, cls.get_references, cls.run_fleur_scfs,
if_(cls.relaxation_needed)(cls.relax),
cls.find_parameters, cls.run_scfs_ref, cls.return_results)
spec.dynamic_output()
def define(cls, spec):
super(corelevel, cls).define(spec)
spec.input("wf_parameters", valid_type=ParameterData, required=False,
default=ParameterData(dict={
'method' : 'initial',
'atoms' : 'all',
'references' : 'calculate',
'calculate_doses' : False,
'relax' : True,
'relax_mode': 'QE Fleur',
'relax_para' : 'default',
'scf_para' : 'default',
'dos_para' : 'default'}))
spec.input("fleurinp", valid_type=FleurinpData, required=True)
spec.input("fleur", valid_type=Code, required=True)
spec.input("structure", valid_type=StructureData, required=False)
spec.input("calc_parameters", valid_type=ParameterData, required=False)
spec.outline(
cls.check_input,
if_(cls.initalstate)(
cls.calculate_inital
)
cls.create_new_fleurinp,
cls.run_fleur,
cls.run_scfs
cls.collect_results
cls.return_results
)
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 define(cls, spec):
super(IfTest, cls).define(spec)
spec.outline(
if_(cls.condition)(
cls.step1,
cls.step2
)
)
def define(cls, spec):
super(WcWithReturn, cls).define(spec)
spec.outline(
cls.s1,
if_(cls.isA)(
return_
),
cls.after
)
def define(cls, spec):
super(OutlineWorkChain, cls).define(spec)
spec.input('a', valid_type=Int)
spec.outline(
cls.setup,
while_(cls.not_finished)(if_(cls.if_multiple_of_three_and_five)(
cls.report_fizz_buzz).elif_(cls.if_multiple_of_five)(
cls.report_buzz).elif_(cls.if_multiple_of_three)(
cls.report_fizz).else_(cls.report_number),
cls.decrement))
def define(cls, spec):
super(SOAP, cls).define(spec)
spec.input('aiida_structure', valid_type=StructureData)
spec.input('spkit_max', valid_type=ParameterData)
spec.input('aononymize', valid_type=Bool, default=Bool(True))
spec.input('scale', valid_type=Bool, default=Bool(True))
spec.input('scale_per', valid_type=Str, default=Str('site'))
spec.input('soapargs', valid_type=ParameterData, required=False)
spec.outline(
cls.get_quippy_atoms,
if_(cls.check_anonymize)(
cls.anonymize_structure,
)
if_(cls.check_scale)(
cls.scale_volume,
)
cls.get_soap_fingerprint
)
spec.output('soap', valid_type=Dict)
def define(cls, spec):
super(Wf, cls).define(spec)
spec.input("value")
spec.input("n")
spec.dynamic_output()
spec.outline(
cls.s1,
if_(cls.isA)(cls.s2).elif_(cls.isB)(cls.s3).else_(cls.s4),
cls.s5,
while_(cls.ltN)(cls.s6),
)
def define(cls, spec):
super(WorkChain, cls).define(spec)
spec.input('structure', valid_type=StructureData)
spec.input('parameters', valid_type=ParameterData)
spec.input('verbose', valid_type=Bool, default=Bool(False))
spec.outline(cls.validate_inputs,
if_(cls.abc_not_defined)(cls.determine_factors),
cls.replicate)
spec.output('structure', valid_type=StructureData)
def define(cls, spec):
super(fleur_corehole_wc, cls).define(spec)
spec.input("wf_parameters",
valid_type=ParameterData,
required=False,
default=ParameterData(
dict={
'method': 'initial',
'atoms': 'all',
'references': 'calculate',
'relax': False,
'relax_mode': 'Fleur',
'relax_para': 'default',
'scf_para': 'default',
}))
spec.input("fleurinp", valid_type=FleurinpData, required=True)
spec.input("fleur", valid_type=Code, required=True)
spec.input("structure", valid_type=StructureData, required=False)
spec.input("calc_parameters", valid_type=ParameterData, required=False)
spec.outline(cls.check_input,
if_(cls.relaxation_needed)(cls.relax),
if_(cls.supercell_needed)(cls.create_supercell),
cls.create_new_fleurinp, cls.create_coreholes,
cls.run_scfs, cls.collect_results, cls.return_results)
def define(cls, spec):
"""
Defines the outline of the workflow.
"""
# Take input of the workflow or use defaults defined above
super(kkr_check_para_wc, cls).define(spec)
spec.input("wf_parameters",
valid_type=ParameterData,
required=False,
default=ParameterData(dict=cls._wf_default))
spec.input("remote_data", valid_type=RemoteData, required=False)
spec.input("kkr", valid_type=Code, required=True)
# Here the structure of the workflow is defined
spec.outline(
cls.start,
if_(cls.validate_input)(cls.run_voronoi,
cls.get_dos), cls.run_kkr, cls.inspect_kkr,
while_(cls.condition)(cls.run_kkr, cls.inspect_kkr, cls.get_res),
cls.return_results)
def define(cls, spec):
super(PwBandsWorkChain, cls).define(spec)
spec.expose_inputs(PwRelaxWorkChain,
namespace='relax',
exclude=('structure', 'clean_workdir'))
spec.expose_inputs(PwBaseWorkChain,
namespace='scf',
exclude=('structure', 'clean_workdir', 'kpoints'))
spec.expose_inputs(PwBaseWorkChain,
namespace='bands',
exclude=('structure', 'clean_workdir'))
spec.input('structure', valid_type=StructureData)
spec.input('clean_workdir', valid_type=Bool, default=Bool(False))
spec.input('group', valid_type=Str, required=False)
spec.outline(
cls.setup,
if_(cls.should_do_relax)(
cls.run_relax,
cls.inspect_relax,
),
cls.run_seekpath,
cls.run_scf,
cls.inspect_scf,
cls.run_bands,
cls.inspect_bands,
cls.results,
)
spec.exit_code(401,
'ERROR_SUB_PROCESS_FAILED_RELAX',
message='the PwRelaxWorkChain sub process failed')
spec.exit_code(402,
'ERROR_SUB_PROCESS_FAILED_SCF',
message='the scf PwBasexWorkChain sub process failed')
spec.exit_code(403,
'ERROR_SUB_PROCESS_FAILED_BANDS',
message='the bands PwBasexWorkChain sub process failed')
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 define(cls, spec):
super(fleur_scf_wc, cls).define(spec)
spec.input("wf_parameters",
valid_type=ParameterData,
required=False,
default=ParameterData(
dict={
'fleur_runmax': 4,
'density_criterion': 0.00002,
'energy_criterion': 0.002,
'converge_density': True,
'converge_energy': False,
'reuse': True,
'resources': {
"num_machines": 1
},
'walltime_sec': 60 * 60,
'queue_name': '',
'serial': False,
'inpxml_changes': [],
'custom_scheduler_commands': ''
}))
spec.input("structure", valid_type=StructureData, required=False)
spec.input("calc_parameters", valid_type=ParameterData, required=False)
spec.input("settings", valid_type=ParameterData, required=False)
spec.input("fleurinp", valid_type=FleurInpData, required=False)
spec.input("remote_data", valid_type=RemoteData, required=False)
spec.input("inpgen", valid_type=Code, required=False)
spec.input("fleur", valid_type=Code, required=True)
spec.outline(
cls.start,
if_(cls.validate_input)(cls.run_fleurinpgen),
cls.run_fleur, # are these first runs needed TODO
cls.inspect_fleur, # are these first runs needed
cls.get_res, # are these first runs needed
while_(cls.condition)(cls.run_fleur, cls.inspect_fleur,
cls.get_res),
cls.return_results)
def define(cls, spec):
super(PwRelaxWorkChain, cls).define(spec)
spec.expose_inputs(PwBaseWorkChain,
namespace='base',
exclude=('structure', 'clean_workdir'))
spec.input('structure', valid_type=StructureData)
spec.input('final_scf', valid_type=Bool, default=Bool(False))
spec.input('group', valid_type=Str, required=False)
spec.input('relaxation_scheme',
valid_type=Str,
default=Str('vc-relax'))
spec.input('meta_convergence', valid_type=Bool, default=Bool(True))
spec.input('max_meta_convergence_iterations',
valid_type=Int,
default=Int(5))
spec.input('volume_convergence', valid_type=Float, default=Float(0.01))
spec.input('clean_workdir', valid_type=Bool, default=Bool(False))
spec.outline(
cls.setup,
while_(cls.should_run_relax)(
cls.run_relax,
cls.inspect_relax,
),
if_(cls.should_run_final_scf)(
cls.run_final_scf,
cls.inspect_final_scf,
),
cls.results,
)
spec.exit_code(401,
'ERROR_SUB_PROCESS_FAILED_RELAX',
message='the relax PwBaseWorkChain sub process failed')
spec.exit_code(
402,
'ERROR_SUB_PROCESS_FAILED_FINAL_SCF',
message='the final scf PwBaseWorkChain sub process failed')
spec.expose_outputs(PwBaseWorkChain)
def define(cls, spec):
super(Isotherm, cls).define(spec)
# structure, adsorbant, pressures
spec.input('structure', valid_type=CifData)
spec.input("probe_molecule", valid_type=ParameterData)
spec.input("pressures", valid_type=ArrayData)
spec.input("min_cell_size", valid_type=Float)
# cp2k
spec.input('cp2k_code', valid_type=Code)
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)
# zeopp
spec.input('zeopp_code', valid_type=Code)
spec.input("_zeopp_options",
valid_type=dict,
default=None,
required=False)
# raspa
spec.input("raspa_code", valid_type=Code)
spec.input("raspa_parameters", valid_type=ParameterData)
spec.input("_raspa_options",
valid_type=dict,
default=None,
required=False)
# settings
spec.input("_interactive",
valid_type=bool,
default=False,
required=False)
spec.input("_usecharges",
valid_type=bool,
default=False,
required=False)
spec.input('_guess_multiplicity', valid_type=bool, default=False)
# workflow
spec.outline(
cls.
init, #read pressures, switch on cif charges if _usecharges=True
cls.
run_geo_opt, #robust 4 stesps cellopt, first expands the uc according to min_cell_size
cls.parse_geo_opt,
if_(cls.should_use_charges)
( #if charges are needed, wfn > (E_DENSITY & core_el) > DDEC charges
cls.run_point_charges,
cls.parse_point_charges,
),
cls.
run_geom_zeopp, #computes sa, vol, povol, res, e chan. Block pore?
cls.init_raspa_calc, #assign HeliumVoidFraction=POAV and UnitCells
cls.
run_henry_raspa, #NumberOfInitializationCycles=0, remove ExternalPressure, WidomProbability=1
while_(cls.should_run_loading_raspa)(
cls.
run_loading_raspa, #for each P, recover the last snapshoot of the previous and run GCMC
cls.parse_loading_raspa,
),
cls.return_results,
)
# TODO: once the workflow is ready, explicitely specify the outputs
spec.dynamic_output()
def define(cls, spec):
super(WorkChain, cls).define(spec)
# spec.input('parameters', valid_type=ParameterData)
spec.input('use_cache', valid_type=Bool, default=Bool(True))
spec.input('seed', valid_type=Int, required=False)
spec.input('verbose', valid_type=Bool, default=Bool(False))
spec.input_namespace('structures',
valid_type=StructureData,
dynamic=True)
spec.input_namespace('structures.forces',
valid_type=ArrayData,
dynamic=True,
required=False)
spec.input_namespace('structures.energy',
valid_type=Float,
dynamic=True,
required=False)
# spec.input_namespace('structures.stress', valid_type=ParameterData, dynamic=True, required=False)
spec.input_namespace('fitter')
spec.input('fitter.code', valid_type=Code)
spec.input('fitter.parameters', valid_type=ParameterData)
spec.input('fitter.options', valid_type=ParameterData)
spec.input('fitter.force_field', valid_type=ParameterData)
spec.input_namespace('structure', required=False)
spec.input_namespace('structure.replicate',
dynamic=True,
required=False)
spec.input_namespace('structure.partial', dynamic=True, required=False)
spec.input_namespace('structure.shake', dynamic=True, required=False)
spec.input_namespace('force', dynamic=True, required=False)
spec.input('force.code', valid_type=Code, required=False)
spec.input('force.settings', valid_type=ParameterData, required=False)
spec.input('force.parameters',
valid_type=ParameterData,
required=False)
spec.input('force.pseudo_family', valid_type=String, required=False)
spec.input('force.kpoints', valid_type=KpointsData, required=False)
# spec.input('force_field', valid_type=PotentialData)
spec.outline(
cls.validate_inputs,
if_(cls.do_replicate)(cls.execute_replicate, cls.handle_replicate),
if_(cls.do_partial)(cls.execute_partial, cls.handle_partial),
if_(cls.do_shake)(cls.execute_shake, cls.handle_shake),
if_(cls.do_forces)(cls.execute_forces, cls.handle_forces), cls.fit,
cls.process, cls.finalize)
# ,
# while_(cls.converging)(
# cls.fit,
# cls.process
# ),
# cls.finalize
spec.output('seed', valid_type=Int)
def define(cls, spec):
super(Isotherm, cls).define(spec)
# structure, adsorbant, pressures
spec.input('structure', valid_type=CifData)
spec.input("probe_molecule", valid_type=ParameterData)
spec.input("pressures", valid_type=ArrayData)
spec.input("min_cell_size", valid_type=Float)
# cp2k
spec.input('cp2k_code', valid_type=Code)
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)
# zeopp
spec.input('zeopp_code', valid_type=Code)
spec.input("_zeopp_options",
valid_type=dict,
default=None,
required=False)
# raspa
spec.input("raspa_code", valid_type=Code)
spec.input("raspa_parameters", valid_type=ParameterData)
spec.input("_raspa_options",
valid_type=dict,
default=None,
required=False)
# settings
spec.input("_interactive",
valid_type=bool,
default=False,
required=False)
spec.input("_usecharges",
valid_type=bool,
default=False,
required=False)
spec.input('_guess_multiplicity', valid_type=bool, default=False)
# workflow
spec.outline(
cls.init,
cls.run_geo_opt,
cls.parse_geo_opt,
if_(cls.should_use_charges)(
cls.run_point_charges,
cls.parse_point_charges,
),
cls.run_geom_zeopp,
cls.parse_geom_zeopp,
cls.run_henry_raspa,
while_(cls.should_run_loading_raspa)(
cls.run_loading_raspa,
cls.parse_loading_raspa,
),
cls.return_results,
)
# TODO: once the workflow is ready, explicitely specify the outputs
spec.dynamic_output()
def define(cls, spec):
"""
This is the most important method of a Workchain, that defines the
inputs that it takes, the logic of the execution and the outputs
that are generated in the process
"""
super(Isotherm, cls).define(spec)
# First we define the inputs, specifying the type we expect
options = {
"resources": {
"num_machines": 1,
"tot_num_mpiprocs": 1,
"num_mpiprocs_per_machine": 1,
},
"max_wallclock_seconds": 30 * 60,
"withmpi": False,
}
spec.input("probe_molecule", valid_type=ParameterData, required=True)
spec.input("cp2k_parameters", valid_type=ParameterData, required=True)
spec.input("ddec_parameters", valid_type=ParameterData, required=True)
spec.input("raspa_parameters", valid_type=ParameterData, required=True)
spec.input("pressures", valid_type=ArrayData, required=True)
spec.input("structure", valid_type=CifData, required=True)
spec.input("cp2k_codename", valid_type=Str, required=True)
spec.input("ddec_codename", valid_type=Str, required=True)
spec.input("zeopp_codename", valid_type=Str, required=True)
spec.input("raspa_codename", valid_type=Str, required=True)
spec.input("_options", valid_type=dict, required=False, default=options)
spec.input("_interactive", valid_type=bool, required=False, default=False)
spec.input("_usecharges", valid_type=bool, required=False, default=True)
# The outline describes the business logic that defines
# which steps are executed in what order and based on
# what conditions. Each `cls.method` is implemented below
spec.outline(
cls.init,
if_(cls.should_use_charges)(
cls.run_cp2k_charge_density,
cls.run_ddec_point_charges,
cls.parse_ddec_point_charges,
),
cls.run_geom_zeopp,
cls.parse_geom_zeopp,
if_(cls.should_run_block_zeopp)(
cls.run_block_zeopp,
cls.parse_block_zeopp,
),
cls.run_henry_raspa,
while_(cls.should_run_loading_raspa)(
cls.run_loading_raspa,
cls.parse_loading_raspa,
),
cls.return_result,
)
# Here we define the output the Workchain will generate and
# return. Dynamic output allows a variety of AiiDA data nodes
# to be returned
spec.dynamic_output()
def define(cls, spec):
super(PwBaseWorkChain, cls).define(spec)
spec.input('code', valid_type=Code)
spec.input('structure', valid_type=StructureData)
spec.input('kpoints', valid_type=KpointsData, required=False)
spec.input('kpoints_distance', valid_type=Float, required=False)
spec.input('kpoints_force_parity', valid_type=Bool, required=False)
spec.input('parameters', valid_type=ParameterData)
spec.input_namespace('pseudos', required=False)
spec.input('pseudo_family', valid_type=Str, required=False)
spec.input('parent_folder', valid_type=RemoteData, required=False)
spec.input('vdw_table', valid_type=SinglefileData, required=False)
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.outline(
cls.setup,
cls.validate_inputs,
if_(cls.should_run_init)(
cls.validate_init_inputs,
cls.run_init,
cls.inspect_init,
),
while_(cls.should_run_calculation)(
cls.prepare_calculation,
cls.run_calculation,
cls.inspect_calculation,
),
cls.results,
)
spec.exit_code(
301,
'ERROR_INVALID_INPUT_PSEUDO_POTENTIALS',
message=
"the explicitly passed 'pseudos' or 'pseudo_family' input could not be used to get the necessary potentials"
)
spec.exit_code(
302,
'ERROR_INVALID_INPUT_KPOINTS',
message=
"neither the 'kpoints' nor the 'kpoints_distance' input was specified"
)
spec.exit_code(
303,
'ERROR_INVALID_INPUT_RESOURCES',
message=
"neither the 'options' nor 'automatic_parallelization' input was specified"
)
spec.exit_code(
304,
'ERROR_INVALID_INPUT_RESOURCES_UNDERSPECIFIED',
message=
"the 'options' do not specify both 'num_machines' and 'max_wallclock_seconds'"
)
spec.exit_code(
310,
'ERROR_INVALID_INPUT_AUTOMATIC_PARALLELIZATION_MISSING_KEY',
message=
"required key for 'automatic_parallelization' was not specified")
spec.exit_code(
311,
'ERROR_INVALID_INPUT_AUTOMATIC_PARALLELIZATION_UNRECOGNIZED_KEY',
message=
"unrecognized keys were specified for 'automatic_parallelization'")
spec.exit_code(401,
'ERROR_INITIALIZATION_CALCULATION_FAILED',
message='the initialization calculation failed')
spec.exit_code(
402,
'ERROR_CALCULATION_INVALID_INPUT_FILE',
message=
'the calculation failed because it had an invalid input file')
spec.output('output_array', valid_type=ArrayData, required=False)
spec.output('output_band', valid_type=BandsData, required=False)
spec.output('output_structure',
valid_type=StructureData,
required=False)
spec.output('output_parameters', valid_type=ParameterData)
spec.output('remote_folder', valid_type=RemoteData)
def define(cls, spec):
"""
This is the most important method of a Workchain, that defines the
inputs that it takes, the logic of the execution and the outputs
that are generated in the process
"""
super(Isotherm, cls).define(spec)
# structure, adsorbant, pressures
spec.input('structure', valid_type=CifData)
spec.input("probe_molecule", valid_type=ParameterData)
spec.input("pressures", valid_type=ArrayData)
# cp2k
spec.input('cp2k_code', valid_type=Code)
spec.input("cp2k_options",
valid_type=ParameterData,
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=ParameterData,
default=None,
required=False)
# zeopp
spec.input('zeopp_code', valid_type=Code)
spec.input("zeopp_options",
valid_type=ParameterData,
default=None,
required=False)
# raspa
spec.input("raspa_code", valid_type=Code)
spec.input("raspa_parameters", valid_type=ParameterData)
spec.input("raspa_options",
valid_type=ParameterData,
default=None,
required=False)
# settings
spec.input("_interactive",
valid_type=bool,
default=False,
required=False)
spec.input("_usecharges",
valid_type=bool,
default=False,
required=False)
# workflow
spec.outline(
cls.init,
if_(cls.should_use_charges)(
cls.run_point_charges,
cls.parse_point_charges,
),
cls.run_geom_zeopp,
cls.parse_geom_zeopp,
cls.run_henry_raspa,
while_(cls.should_run_loading_raspa)(
cls.run_loading_raspa,
cls.parse_loading_raspa,
),
cls.return_results,
)
# TODO: once the workflow is ready, explicitely specify the outputs
spec.dynamic_output()
def define(cls, spec):
super(VolpoKhIsothermWorkChain, cls).define(spec)
# structure
spec.input('structure', valid_type=CifData)
# zeopp main
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 main
spec.input("raspa_code", valid_type=Code)
spec.input("raspa_parameters", valid_type=ParameterData)
spec.input("_raspa_options",
valid_type=dict,
default=None,
required=False)
spec.input("_raspa_usecharges",
valid_type=bool,
default=False,
required=False)
spec.input("raspa_minKh",
valid_type=Float,
default=Float(1e-10),
required=False)
spec.input("raspa_molsatdens", valid_type=Float
) #density of the liquid phase of the molecule in mol/m3
# advanced settings (TODO: add and discuss)
spec.input("zeopp_block_samples_A3",
valid_type=Int,
default=Int(100),
required=False
) #100 samples / Ang^3: accurate for all the structures
spec.input(
"zeopp_volpo_samples_UC",
valid_type=Int,
default=Int(100000),
required=False
) #100k samples, may need more for structures bigger than 30x30x30
spec.input("raspa_verbosity",
valid_type=Int,
default=Int(10),
required=False)
spec.input("raspa_widom_cycle_mult",
valid_type=Int,
default=Int(10),
required=False)
spec.input("raspa_gcmc_press_precision",
valid_type=Float,
default=Float(0.1),
required=False)
spec.input("raspa_gcmc_press_maxstep",
valid_type=Float,
default=Float(5e5),
required=False)
spec.input("raspa_gcmc_press_max",
valid_type=Float,
default=Float(30e5),
required=False)
# workflow
spec.outline(
cls.run_zeopp, #computes volpo and blocks
if_(cls.should_run_widom)( #run Widom only if porous
cls.init_raspa_widom, #initialize raspa widom calculation
cls.run_raspa_widom, #run raspa widom calculation
if_(cls.should_run_gcmc)
( #make decision (e.g., Kh high enough)
cls.init_raspa_gcmc, #initializate setting for GCMC
while_(
cls.should_run_another_gcmc)( #new pressure to compute
cls.run_raspa_gcmc, #run raspa GCMC calculation
cls.parse_raspa_gcmc, #parse the result @ T,P
),
),
),
cls.return_results,
)
spec.dynamic_output()
