def run_pm(self): """ It runs a Ev calculation in PorousMaterials. """ pm_input = self.exposed_inputs(PorousMaterialsCalculation, 'porousmaterials') pm_input['structure'] = {} pm_input['structure'][self.ctx.label] = self.inputs.structure pm_input['acc_voronoi_nodes'] = {} pm_input['metadata']['label'] = 'Voronoi Energy Calculation' pm_input['metadata']['call_link_label'] = 'run_pm' if all(self.ctx.should_run_comp) and all(self.ctx.should_run_pld): for key in self.ctx.components.keys(): zeopp_label = "zeopp_{}".format(key) voro_label = "{}_{}".format(self.ctx.label, key) pm_input['acc_voronoi_nodes'][voro_label] = self.ctx[ zeopp_label].outputs.voro_accessible pm_input["parameters"] = modify_pm_parameters( self.inputs.porousmaterials.parameters, Str('ev_vdw_kh_multicomp_pld_template')) if all(self.ctx.should_run_comp) and not all(self.ctx.should_run_pld): for key in self.inputs.components.keys(): zeopp_label = "zeopp_{}".format(key) voro_label = "{}_{}".format(self.ctx.label, key) pm_input['acc_voronoi_nodes'][voro_label] = self.ctx[ zeopp_label].outputs.voro_accessible pm_input["parameters"] = modify_pm_parameters( self.inputs.porousmaterials.parameters, Str('ev_vdw_kh_multicomp_template')) if not all(self.ctx.should_run_comp) and all(self.ctx.should_run_pld): voro_label = "{}_{}".format(self.ctx.label, 'PLD') pm_input['acc_voronoi_nodes'][voro_label] = self.ctx[ "zeopp_PLD"].outputs.voro_accessible pm_input["parameters"] = modify_pm_parameters( self.inputs.porousmaterials.parameters, Str('ev_vdw_kh_pld_template')) pm_ev = self.submit(PorousMaterialsCalculation, **pm_input) # pylint: disable=invalid-name self.report("pk: <{}> | Running Voronoi Energy Calculation".format( pm_ev.pk)) return ToContext(pm_ev=pm_ev)
def submit(self, _=None): assert self.input_structure is not None builder = WorkflowFactory('quantumespresso.pw.bands').get_builder() builder.scf.pw.code = self.code_group.selected_code builder.scf.pw.parameters = load_default_parameters() builder.scf.pw.metadata.options = self.options builder.scf.kpoints_distance = Float(0.8) builder.scf.pseudo_family = Str(self.pseudo_family_selection.value) builder.bands.pw.code = self.code_group.selected_code builder.bands.pw.parameters = load_default_parameters() builder.bands.pw.metadata.options = self.options builder.bands.pseudo_family = Str(self.pseudo_family_selection.value) builder.structure = self.input_structure self.process = submit(builder)
def define(cls, spec): super().define(spec) spec.input('value', default=lambda: Str('A')) spec.input('n', default=lambda: Int(3)) spec.outputs.dynamic = True spec.outline( cls.step1, if_(cls.is_a)(cls.step2).elif_(cls.is_b)(cls.step3).else_(cls.step4), # pylint: disable=no-member cls.step5, while_(cls.larger_then_n)(cls.step6,), )
def define(cls, spec): super().define(spec) spec.input( 'test', valid_type=Str, serializer=lambda x: Str(ObjectLoader().identify_object(x)), ) spec.input('reference', valid_type=Str) spec.outline(cls.do_test)
def example_multistage_al(cp2k_code): """Example usage: verdi run thistest.py cp2k@localhost""" print("Testing CP2K multistage workchain on Al (RKS, needs smearing)...") print( "EXPECTED: the OT (settings_0) will converge to a negative bandgap, then we switch to SMEARING (settings_1)" ) thisdir = os.path.dirname(os.path.abspath(__file__)) structure = StructureData( ase=ase.io.read(os.path.join(thisdir, '../data/Al.cif'))) # testing user change of parameters and protocol parameters = Dict( dict={'FORCE_EVAL': { 'DFT': { 'MGRID': { 'CUTOFF': 250, } } }}) protocol_mod = Dict( dict={ 'initial_magnetization': { 'Al': 0 }, 'settings_0': { 'FORCE_EVAL': { 'DFT': { 'SCF': { 'OUTER_SCF': { 'MAX_SCF': 5, } } } } } }) # Construct process builder builder = Cp2kMultistageWorkChain.get_builder() builder.structure = structure builder.protocol_tag = Str('test') builder.starting_settings_idx = Int(0) builder.protocol_modify = protocol_mod builder.cp2k_base.cp2k.parameters = parameters builder.cp2k_base.cp2k.code = cp2k_code builder.cp2k_base.cp2k.metadata.options.resources = { "num_machines": 1, "num_mpiprocs_per_machine": 1, } builder.cp2k_base.cp2k.metadata.options.max_wallclock_seconds = 1 * 3 * 60 run(builder)
def define(cls, spec): super().define(spec) spec.input('value', default=lambda: Str('A')) spec.input('n', default=lambda: Int(3)) spec.outputs.dynamic = True 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().define(spec) spec.input( 'test', valid_type=Str, serializer=lambda x: Str(ObjectLoader().identify_object(x)) ) spec.outline(cls.echo) spec.outputs.dynamic = True
def finalize(self): """ Return the output after the optimization procedure has finished. """ self.report('Finalizing optimization procedure.') with self.optimizer() as opt: optimal_process_output = opt.result_value optimal_process_output.store() self.out('optimal_process_output', optimal_process_output) result_index = opt.result_index optimal_process = self.ctx[self.eval_key(result_index)] self.out('optimal_process_uuid', Str(optimal_process.uuid).store())
def main(codelabel): """Example usage: verdi run thistest.py cp2k@localhost""" print("Testing CP2K multistage workchain on Al (RKS, needs smearing)...") print("EXPECTED: the OT (settings_0) will converge to a negative bandgap, then we switch to SMEARING (settings_1)") code = Code.get_from_string(codelabel) thisdir = os.path.dirname(os.path.abspath(__file__)) structure = StructureData(ase=ase.io.read(os.path.join(thisdir, '../data/Al.cif'))) # testing user change of parameters and protocol parameters = Dict(dict={'FORCE_EVAL': {'DFT': {'MGRID': {'CUTOFF': 250,}}}}) protocol_mod = Dict(dict={ 'initial_magnetization': { 'Al': 0 }, 'settings_0': { 'FORCE_EVAL': { 'DFT': { 'SCF': { 'OUTER_SCF': { 'MAX_SCF': 5, } } } } } }) options = { "resources": { "num_machines": 1, "num_mpiprocs_per_machine": 1, }, "max_wallclock_seconds": 1 * 3 * 60, } inputs = { 'structure': structure, 'protocol_tag': Str('test'), 'starting_settings_idx': Int(0), 'protocol_modify': protocol_mod, 'cp2k_base': { 'cp2k': { 'parameters': parameters, 'code': code, 'metadata': { 'options': options, } } } } run(Cp2kMultistageWorkChain, **inputs)
def main(code_string, incar, kmesh, structure, potential_family, potential_mapping, options): """Main method to setup the calculation.""" # First, we need to fetch the AiiDA datatypes which will # house the inputs to our calculation dict_data = DataFactory('dict') kpoints_data = DataFactory('array.kpoints') # Then, we set the workchain you would like to call workchain = WorkflowFactory('vasp.master') # And finally, we declare the options, settings and input containers settings = AttributeDict() inputs = AttributeDict() # Organize settings settings.parser_settings = { 'output_params': ['total_energies', 'maximum_force'] } # Set inputs for the following WorkChain execution # Set code inputs.code = Code.get_from_string(code_string) # Set structure inputs.structure = structure # Set k-points grid density kpoints = kpoints_data() kpoints.set_kpoints_mesh(kmesh) inputs.kpoints = kpoints # Set parameters inputs.parameters = dict_data(dict=incar) # Set potentials and their mapping inputs.potential_family = Str(potential_family) inputs.potential_mapping = dict_data(dict=potential_mapping) # Set options inputs.options = dict_data(dict=options) # Set settings inputs.settings = dict_data(dict=settings) # Set workchain related inputs, in this case, give more explicit output to repor inputs.verbose = Bool(True) # Master, convergence and relaxation related parameters that is passed to the master, # convergence and relaxation workchain, respectively # Turn of relaxation relax = AttributeDict() relax.perform = Bool(False) inputs.relax = relax # Extract electronic band structure inputs.extract_bands = Bool(True) # Submit the requested workchain with the supplied inputs submit(workchain, **inputs)
def run_multistage_h2om(cp2k_code): """Example usage: verdi run thistest.py cp2k@localhost""" print( "Testing CP2K multistage workchain on 2xH2O- (UKS, no need for smearing)..." ) print("This is checking:") print(" > unit cell resizing") print(" > protocol modification") print(" > cp2k calc modification") atoms = ase.build.molecule('H2O') atoms.center(vacuum=2.0) structure = StructureData(ase=atoms) protocol_mod = Dict(dict={ 'settings_0': { 'FORCE_EVAL': { 'DFT': { 'MGRID': { 'CUTOFF': 300, } } } } }) parameters = Dict(dict={ 'FORCE_EVAL': { 'DFT': { 'UKS': True, 'MULTIPLICITY': 3, 'CHARGE': -2, } } }) # Construct process builder builder = Cp2kMultistageWorkChain.get_builder() builder.structure = structure builder.min_cell_size = Float(4.1) builder.protocol_tag = Str('test') builder.protocol_modify = protocol_mod builder.cp2k_base.cp2k.parameters = parameters builder.cp2k_base.cp2k.code = cp2k_code builder.cp2k_base.cp2k.metadata.options.resources = { "num_machines": 1, "num_mpiprocs_per_machine": 1, } builder.cp2k_base.cp2k.metadata.options.max_wallclock_seconds = 1 * 3 * 60 run(builder)
def define(cls, spec): super(ParseCalculation, cls).define(spec) spec.input('wannier_folder', valid_type=FolderData, help="Folder containing the Wannier90 output data.") spec.exit_code(300, 'ERROR_OUTPUT_MODEL_FILE', message='The output model HDF5 file was not found.') spec.input('pos_kind', valid_type=Str, default=lambda: Str('wannier'), help='Determines how the orbital positions are parsed.')
def TI_sim(job_work_dir): task_abs_dir_list = glob.glob(os.path.join(job_work_dir.value, './task*')) task_dir_list = [ os.path.relpath(ii, start=job_work_dir.value) for ii in task_abs_dir_list ] submission = get_empty_submission(job_work_dir.value) task_list = [ Task(command='lmp_serial -i in.lammps', task_work_path=ii) for ii in task_dir_list ] submission.register_task_list(task_list=task_list) submission.run_submission() return Str(job_work_dir.value)
def define(cls, spec): super(FormchkCalculation, cls).define(spec) spec.input('parent_calc_folder', valid_type=RemoteData, required=True, help='the folder of a containing the .chk') spec.input('chk_name', valid_type=Str, required=False, default=lambda: Str(cls._DEFAULT_INPUT_FILE), help="name of the checkpoint file") # Turn mpi off by default spec.input('metadata.options.withmpi', valid_type=bool, default=False)
def run_wf(pwscf_code, pw2wannier90_code, wannier_code): """Run a simple workflow running Quantum ESPRESSO+wannier90 for GaAs.""" static_inputs = get_static_inputs() pseudo_family_name = get_or_create_pseudo_family() # Run the workflow run( MinimalW90WorkChain, pw_code=pwscf_code, #load_code('pw-6.4-release@localhost'), pseudo_family=Str( pseudo_family_name), #Str('SSSP_efficiency_pseudos'), wannier_code=wannier_code, #load_code('wannier90-3-desktop@localhost'), pw2wannier90_code= pw2wannier90_code, #load_code('pw2wannier90-6.4-release@localhost'), **static_inputs)
def parse(self): """Parse log file of premod.""" # Check if retrieved folder is present. try: output_folder = self.premod_calc.retrieved except exceptions.NotExistent: return self.exit_codes.ERROR_NO_RETRIEVED_FOLDER # Try to load the log file. try: with output_folder.open('PreModRun.log', 'r') as handle: result = self._parse_log(handle) except (OSError, IOError): return self.exit_codes.ERROR_READING_LOG_FILE if result is None: return self.exit_codes.ERROR_INVALID_LOG_OUTPUT return {'log': Str(result)}
def define(cls, spec): super(STMWorkChain, cls).define(spec) spec.input("cp2k_code", valid_type=Code) spec.input("structure", valid_type=StructureData) spec.input("wfn_file_path", valid_type=Str, default=lambda:Str("")) spec.input("dft_params", valid_type=Dict) spec.input("stm_code", valid_type=Code) spec.input("stm_params", valid_type=Dict) spec.outline( cls.run_scf_diag, cls.run_stm, cls.finalize, ) spec.outputs.dynamic = True
def main(raspa_code_label, zeopp_code_label): """Prepare inputs and submit the Isotherm workchain. Usage: verdi run run_IsothermMultiTempWorkChain_HKUST-1.py raspa@localhost zeopp@localhost""" builder = IsothermWorkChain.get_builder() builder.metadata.label = "test" builder.raspa_base.raspa.code = Code.get_from_string(raspa_code_label) builder.zeopp.code = Code.get_from_string(zeopp_code_label) options = { "resources": { "num_machines": 1, "tot_num_mpiprocs": 1, }, "max_wallclock_seconds": 1 * 60 * 60, "withmpi": False, } builder.raspa_base.raspa.metadata.options = options builder.zeopp.metadata.options = options builder.structure = CifData(file=os.path.abspath('data/TCC1RS.cif'), label="TCC1RS") builder.molecule = Str('co2') builder.parameters = Dict( dict={ 'forcefield': 'UFF', # Default: UFF 'temperature_list': [ 400, 500 ], # (K) ******* NOTE: list for multi temperature ********* 'zeopp_volpo_samples': 1000, # Default: 1e5 *NOTE: default is good for standard real-case! 'zeopp_block_samples': 10, # Default: 100 'raspa_widom_cycles': 100, # Default: 1e5 'raspa_gcmc_init_cycles': 10, # Default: 1e3 'raspa_gcmc_prod_cycles': 100, # Default: 1e4 'pressure_min': 0.001, # Default: 0.001 (bar) 'pressure_max': 3, # Default: 10 (bar) }) run(builder)
def main(code_string, incar, kmesh, structures, potential_family, potential_mapping, options): """Main method to setup the calculation.""" # First, we need to fetch the AiiDA datatypes which will # house the inputs to our calculation dict_data = DataFactory('dict') kpoints_data = DataFactory('array.kpoints') # Then, we set the workchain you would like to call workchain = EosWorkChain # And finally, we declare the options, settings and input containers settings = AttributeDict() inputs = AttributeDict() # organize settings settings.parser_settings = { 'output_params': ['total_energies', 'maximum_force'] } # set inputs for the following WorkChain execution # set code inputs.code = Code.get_from_string(code_string) # set structures inputs.structures = structures # set k-points grid density kpoints = kpoints_data() kpoints.set_kpoints_mesh(kmesh) inputs.kpoints = kpoints # set parameters inputs.parameters = dict_data(dict=incar) # set potentials and their mapping inputs.potential_family = Str(potential_family) inputs.potential_mapping = dict_data(dict=potential_mapping) # set options inputs.options = dict_data(dict=options) # set settings inputs.settings = dict_data(dict=settings) # set workchain related inputs, in this case, give more explicit output to report inputs.verbose = Bool(True) # submit the requested workchain with the supplied inputs submit(workchain, **inputs)
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 test_isotherm_mg_mof74(raspa_code, zeopp_code, mg_mof74_cifdata): """Test Isotherm workchain on MOF 74.""" builder = IsothermWorkChain.get_builder() builder.raspa_base.raspa.code = raspa_code builder.zeopp.code = zeopp_code options = { "resources": { "num_machines": 1, "tot_num_mpiprocs": 1, }, "max_wallclock_seconds": 1 * 60 * 60, "withmpi": False, } builder.raspa_base.raspa.metadata.options = options builder.zeopp.metadata.options = options builder.structure = mg_mof74_cifdata builder.molecule = Str('co2') builder.parameters = Dict( dict={ 'ff_framework': 'UFF', # Default: UFF 'temperature': 400, # (K) Note: higher temperature will have less adsorbate and it is faster 'zeopp_volpo_samples': 1000, # Default: 1e5 *NOTE: default is good for standard real-case! 'zeopp_block_samples': 10, # Default: 100 'raspa_widom_cycles': 100, # Default: 1e5 'raspa_gcmc_init_cycles': 10, # Default: 1e3 'raspa_gcmc_prod_cycles': 100, # Default: 1e4 'pressure_min': 0.001, # Default: 0.001 (bar) 'pressure_max': 3, # Default: 10 (bar) }) results = run(builder) params = results['output_parameters'].get_dict() assert params['Estimated_saturation_loading'] == pytest.approx( 13.49433, 0.1), params
def define(cls, spec): super(SiestaSTMWorkChain, cls).define(spec) spec.input('code', valid_type=Code) spec.input('stm_code', valid_type=Code) spec.input('structure', valid_type=StructureData) spec.input('protocol', valid_type=Str, default=Str('standard')) spec.input('height', valid_type=Float) spec.input('e1', valid_type=Float) spec.input('e2', valid_type=Float) spec.outline( cls.setup_protocol, cls.setup_structure, cls.setup_kpoints, cls.setup_pseudo_potentials, cls.setup_parameters, cls.setup_basis, cls.run_relax, # This should be optional cls. run_scf_and_ldos, # We could run this directly, a combined scf+ldos cls.run_stm, cls.run_results, ) spec.output('stm_array', valid_type=ArrayData) # These will be inherited from the Base workchain output #spec.output('output_structure', # valid_type=StructureData, # required=False) # This could be 'output_parameters', also inherited from the Base workchain, representing # the summary of energies, etc. coming out of the last SiestaCalculation run. # but its relevance is limited for a "stm" workflow. Left here for now for debugging. #spec.output('output_parameters', valid_type=Dict) spec.exit_code(140, 'ERROR_PROTOCOL_NOT_FOUND', message='The protocol specified is not known') spec.exit_code( 160, 'ERROR_RELAXED_STRUCTURE_NOT_AVAILABLE', message='Failed to get the output structure from the relaxation run' )
def main(raspa_code_label, zeopp_code_label): """Prepare inputs and submit the Isotherm workchain. Usage: verdi run run_IsothermWorkChain_COF-1.py raspa@localhost network@localhost""" builder = IsothermWorkChain.get_builder() builder.metadata.label = "test" builder.raspa_base.raspa.code = Code.get_from_string(raspa_code_label) builder.zeopp.code = Code.get_from_string(zeopp_code_label) options = { "resources": { "num_machines": 1, "tot_num_mpiprocs": 1, }, "max_wallclock_seconds": 1 * 60 * 60, "withmpi": False, } builder.raspa_base.raspa.metadata.options = options builder.zeopp.metadata.options = options builder.structure = CifData(file=os.path.abspath('data/COF-1.cif'), label="COF-1") builder.molecule = Str('co2') builder.parameters = Dict( dict={ 'ff_framework': 'UFF', # Default: UFF 'temperature': 400, # (K) Note: higher temperature will have less adsorbate and it is faster 'zeopp_volpo_samples': 1000, # Default: 1e5 *NOTE: default is good for standard real-case! 'zeopp_block_samples': 10, # Default: 100 'raspa_widom_cycles': 100, # Default: 1e5 'raspa_gcmc_init_cycles': 10, # Default: 1e3 'raspa_gcmc_prod_cycles': 100, # Default: 1e4 'pressure_min': 0.001, # Default: 0.001 (bar) 'pressure_max': 3, # Default: 10 (bar) }) run(builder)
def run_isotherms(self): """Run Isotherm work chain for CO2 and N2.""" inputs = self.exposed_inputs(IsothermWorkChain) self.report( "Run Isotherm work chain for CO2 and N2, in CifData<{}> (label: {} )" .format(self.inputs.structure.pk, self.inputs.structure.label)) for mol in ['co2', 'n2']: dict_merge( inputs, { 'metadata': { 'call_link_label': 'run_isotherm_for_{}'.format(mol), }, 'molecule': Str(mol), 'parameters': self.inputs.parameters }) running = self.submit(IsothermWorkChain, **inputs) self.to_context(**{'isotherm_{}'.format(mol): running})
def main(codelabel): """Example usage: verdi run thistest.py cp2k@localhost""" print("Testing CP2K multistage workchain on H2O") print(">>> Making it fail because of an unphysical Multiplicity") code = Code.get_from_string(codelabel) atoms = ase.build.molecule('H2O') atoms.center(vacuum=2.0) structure = StructureData(ase=atoms) options = { "resources": { "num_machines": 1, "num_mpiprocs_per_machine": 1, }, "max_wallclock_seconds": 1 * 3 * 60, } parameters = Dict(dict={'FORCE_EVAL': { 'DFT': { 'UKS': True, 'MULTIPLICITY': 666, } }}) inputs = { 'structure': structure, 'protocol_tag': Str('test'), 'cp2k_base': { 'max_iterations': Int(1), 'cp2k': { 'parameters': parameters, 'code': code, 'metadata': { 'options': options, } } } } run(Cp2kMultistageWorkChain, **inputs)
def main(cp2k_code_label): """Example usage: verdi run thistest.py cp2k@localhost""" cp2k_code = Code.get_from_string(cp2k_code_label) print("Testing CP2K BindingEnergy work chain for CO2 in Zn-MOF-74 ...") print("[NOTE: this test will run on 4 cpus and take ca. 10 minutes]") thisdir = os.path.dirname(os.path.abspath(__file__)) # Construct process builder builder = BindingEnergyWorkChain.get_builder() builder.structure = StructureData(ase=ase.io.read(os.path.join(thisdir, 'data/Zn-MOF-74.cif'))) builder.molecule = StructureData(ase=ase.io.read(os.path.join(thisdir, 'data/CO2_in_Zn-MOF-74.cif'))) builder.protocol_tag = Str('test') builder.cp2k_base.cp2k.parameters = Dict(dict={ # Lowering CP2K default setting for a faster test calculation 'FORCE_EVAL': { 'DFT': { 'SCF': { 'EPS_SCF': 1.0E-4, 'OUTER_SCF': { 'EPS_SCF': 1.0E-4, }, }, }, }, 'MOTION': { 'GEO_OPT': { 'MAX_ITER': 5 } }, }) builder.cp2k_base.cp2k.code = cp2k_code builder.cp2k_base.cp2k.metadata.options.resources = { "num_machines": 1, "num_mpiprocs_per_machine": 4, } builder.cp2k_base.cp2k.metadata.options.max_wallclock_seconds = 1 * 5 * 60 run(builder)
def HTI_start(start_info, NVT_end_info): work_base_abs_dir = start_info['work_base_abs_dir'] dag_work_dir = start_info['dag_work_dir'] if_liquid = start_info['if_liquid'] conf_lmp = NVT_end_info['out_lmp'] job_work_dir = Str(os.path.join(dag_work_dir, 'HTI_sim', 'new_job')) if os.path.isfile( os.path.join(dag_work_dir, 'HTI_sim', 'new_job', 'result.json')): return job_work_dir if if_liquid: with open(os.path.join(work_base_abs_dir, 'hti.liquid.json')) as j: hti_jdata = json.load(j) else: with open(os.path.join(work_base_abs_dir, 'hti.json')) as j: hti_jdata = json.load(j) task_jdata = hti_jdata.copy() # task_jdata['equi_conf'] = "../NVT_sim/new_job/out.lmp" # task_jdata['equi_conf'] = os.path.join(start_info['dag_work_dir'], 'NVT_sim', 'new_job', 'out.lmp') if conf_lmp is not None: task_jdata['equi_conf'] = conf_lmp else: task_jdata['equi_conf'] = start_info['conf_lmp'] task_jdata['temp'] = start_info['target_temp'] task_jdata['pres'] = start_info['target_pres'] cwd = os.getcwd() os.chdir(work_base_abs_dir) if if_liquid: hti_liq.make_tasks(iter_name=job_work_dir.value, jdata=task_jdata) else: hti.make_tasks(iter_name=job_work_dir.value, jdata=task_jdata, ref='einstein', switch='three-step') os.chdir(cwd) return job_work_dir
def run_multistage_h2o_singlepoint(cp2k_code): """Example usage: verdi run thistest.py cp2k@localhost""" print("Testing CP2K multistage workchain on H2O") print(">>> Using 'singlepoint' tag, with no output structure") atoms = ase.build.molecule('H2O') atoms.center(vacuum=2.0) structure = StructureData(ase=atoms) # Construct process builder builder = Cp2kMultistageWorkChain.get_builder() builder.structure = structure builder.protocol_tag = Str('singlepoint') builder.cp2k_base.cp2k.code = cp2k_code builder.cp2k_base.cp2k.metadata.options.resources = { "num_machines": 1, "num_mpiprocs_per_machine": 1, } builder.cp2k_base.cp2k.metadata.options.max_wallclock_seconds = 1 * 3 * 60 run(builder)
def NPT_start(start_info): work_base_abs_dir = start_info['work_base_abs_dir'] dag_work_dir = start_info['dag_work_dir'] job_work_dir = Str(os.path.join(dag_work_dir, 'NPT_sim', 'new_job')) result_json_file = os.path.join(job_work_dir.value, 'result.json') if os.path.isfile(result_json_file): return job_work_dir with open(os.path.join(work_base_abs_dir, 'npt.json')) as f: npt_jdata = json.load(f) task_jdata = npt_jdata.copy() task_jdata['equi_conf'] = start_info['conf_lmp'] task_jdata['temp'] = start_info['target_temp'] task_jdata['pres'] = start_info['target_pres'] task_jdata['ens'] = start_info['ens'] print(task_jdata) cwd = os.getcwd() os.chdir(work_base_abs_dir) equi.make_task(job_work_dir.value, task_jdata) os.chdir(cwd) return job_work_dir
def extract_dos_data_from_folder(self, folder, last_calc): """ Get DOS data and parse files. """ # initialize in case dos data is not extracted dosXyDatas = None # get list of files in directory (needed since SandboxFolder does not have `list_object_names` method) # also extract absolute path of folder (needed by parse_impdosfiles since calcfunction does not work with SandboxFolder as input) if isinstance(folder, SandboxFolder): folder_abspath = folder.abspath filelist = os.listdir(folder_abspath) else: filelist = folder.list_object_names() with folder.open(filelist[0]) as tmpfile: folder_abspath = tmpfile.name.replace(filelist[0], '') # check if out_ldos* files are there and parse dos files if 'out_ldos.interpol.atom=01_spin1.dat' in filelist: # extract EF and number of atoms from kkrflex_writeout calculation kkrflex_writeout = load_node(self.ctx.pk_flexcalc) parent_calc_kkr_converged = kkrflex_writeout.inputs.parent_folder.get_incoming( node_class=CalcJobNode).first().node ef = parent_calc_kkr_converged.outputs.output_parameters.get_dict( ).get('fermi_energy') last_calc_output_params = last_calc.outputs.output_parameters natom = last_calc_output_params.get_dict().get( 'number_of_atoms_in_unit_cell') # parse dosfiles using nspin, EF and Natom inputs dosXyDatas = parse_impdosfiles(Str(folder_abspath), Int(natom), Int(self.ctx.nspin), Float(ef)) dos_extracted = True else: dos_extracted = False dosXyDatas = None return dos_extracted, dosXyDatas