def run_afms(self): self.report("Running PP") afm_pp_inputs = {} afm_pp_inputs['_label'] = "afm_pp" afm_pp_inputs['code'] = self.inputs.afm_pp_code afm_pp_inputs['parameters'] = self.inputs.afm_pp_params afm_pp_inputs['parent_calc_folder'] = self.ctx.scf_diag.out.remote_folder afm_pp_inputs['atomtypes'] = SinglefileData(file="/project/apps/scanning_probe/afm/atomtypes_pp.ini") afm_pp_inputs['_options'] = { "resources": {"num_machines": 1}, "max_wallclock_seconds": 7200, } self.report("Afm pp inputs: " + str(afm_pp_inputs)) afm_pp_future = submit(AfmCalculation.process(), **afm_pp_inputs) self.to_context(afm_pp=Calc(afm_pp_future)) self.report("Running 2PP") afm_2pp_inputs = {} afm_2pp_inputs['_label'] = "afm_2pp" afm_2pp_inputs['code'] = self.inputs.afm_2pp_code afm_2pp_inputs['parameters'] = self.inputs.afm_2pp_params afm_2pp_inputs['parent_calc_folder'] = self.ctx.scf_diag.out.remote_folder afm_2pp_inputs['atomtypes'] = SinglefileData(file="/project/apps/scanning_probe/afm/atomtypes_2pp.ini") afm_2pp_inputs['_options'] = { "resources": {"num_machines": 1}, "max_wallclock_seconds": 7200, } self.report("Afm 2pp inputs: " + str(afm_2pp_inputs)) afm_2pp_future = submit(AfmCalculation.process(), **afm_2pp_inputs) self.to_context(afm_2pp=Calc(afm_2pp_future))
def test_process_with_external(new_database, new_workdir): """Test running a calculation note this does not test parsing of the output""" from aiida.orm.data.singlefile import SinglefileData # get code code = get_basic_code(new_workdir) # Prepare input parameters infile = SinglefileData( file=os.path.join(TEST_DIR, "input_files", 'mgo_sto3g_external.crystal.d12')) ingui = SinglefileData( file=os.path.join(TEST_DIR, "input_files", 'mgo_sto3g_external.crystal.gui')) # set up calculation calc = code.new_calc() # calc.label = "aiida_crystal17 test" # calc.description = "Test job submission with the aiida_crystal17 plugin" # calc.set_max_wallclock_seconds(30) calc.set_withmpi(False) calc.set_resources({"num_machines": 1, "num_mpiprocs_per_machine": 1}) calc.use_input_file(infile) calc.use_input_external(ingui) calc.store_all() # test process execution tests.test_calculation_execution( calc, check_paths=[calc._DEFAULT_OUTPUT_FILE, calc._DEFAULT_EXTERNAL_FILE])
def test_submit(self): """Test submitting a calculation""" from aiida.orm.data.singlefile import SinglefileData code = self.code # Prepare input parameters from aiida.orm import DataFactory DiffParameters = DataFactory('plumed') parameters = DiffParameters({'ignore-case': True}) file1 = SinglefileData(file=os.path.join(tests.TEST_DIR, 'file1.txt')) file2 = SinglefileData(file=os.path.join(tests.TEST_DIR, 'file2.txt')) # set up calculation calc = code.new_calc() calc.label = "aiida_plumed test" calc.description = "Test job submission with the aiida_plumed plugin" calc.set_max_wallclock_seconds(30) calc.set_withmpi(False) calc.set_resources({"num_machines": 1, "num_mpiprocs_per_machine": 1}) calc.use_parameters(parameters) calc.use_file1(file1) calc.use_file2(file2) calc.store_all() calc.submit() print("submitted calculation; calc=Calculation(uuid='{}') # ID={}"\ .format(calc.uuid,calc.dbnode.pk))
def mk_aiida_file(cls, atoms, name): tmpdir = tempfile.mkdtemp() atoms_file_name = tmpdir + "/" + name atoms.write(atoms_file_name) atoms_aiida_f = SinglefileData(file=atoms_file_name) shutil.rmtree(tmpdir) return atoms_aiida_f
def mk_coord_files(cls, atoms, first_slab_atom): mol = atoms[:first_slab_atom - 1] tmpdir = tempfile.mkdtemp() molslab_fn = tmpdir + '/mol_on_slab.xyz' mol_fn = tmpdir + '/mol.xyz' atoms.write(molslab_fn) mol.write(mol_fn) molslab_f = SinglefileData(file=molslab_fn) mol_f = SinglefileData(file=mol_fn) shutil.rmtree(tmpdir) return molslab_f, mol_f
def make_geom_file(cls, atoms, filename, spin_guess=None): # spin_guess = [[spin_up_indexes], [spin_down_indexes]] tmpdir = tempfile.mkdtemp() file_path = tmpdir + "/" + filename orig_file = BytesIO() atoms.write(orig_file, format='xyz') orig_file.seek(0) all_lines = orig_file.readlines() comment = all_lines[1] # with newline character! orig_lines = all_lines[2:] modif_lines = [] for i_line, line in enumerate(orig_lines): new_line = line lsp = line.split() if spin_guess is not None: if i_line in spin_guess[0]: new_line = lsp[0] + "1 " + " ".join(lsp[1:]) + "\n" if i_line in spin_guess[1]: new_line = lsp[0] + "2 " + " ".join(lsp[1:]) + "\n" modif_lines.append(new_line) final_str = "%d\n%s" % (len(atoms), comment) + "".join(modif_lines) with open(file_path, 'w') as f: f.write(final_str) aiida_f = SinglefileData(file=file_path) shutil.rmtree(tmpdir) return aiida_f
def test_submit(new_database, new_workdir): """Test submitting a calculation""" from aiida.orm.data.singlefile import SinglefileData from aiida.common.folders import SandboxFolder code = get_basic_code(new_workdir) # Prepare input parameters infile = SinglefileData( file=os.path.join(TEST_DIR, "input_files", 'mgo_sto3g_scf.crystal.d12')) # set up calculation calc = code.new_calc() # calc.label = "aiida_crystal17 test" # calc.description = "Test job submission with the aiida_crystal17 plugin" # calc.set_max_wallclock_seconds(30) calc.set_withmpi(False) calc.set_resources({"num_machines": 1, "num_mpiprocs_per_machine": 1}) calc.use_input_file(infile) calc.store_all() # output input files and scripts to temporary folder with SandboxFolder() as folder: subfolder, script_filename = calc.submit_test(folder=folder) print("inputs created successfully at {}".format(subfolder.abspath))
def setUp(self): """Sets up a few nodes to play around with.""" from aiida.orm.data.singlefile import SinglefileData import tempfile file_content = '''file-with-contents''' with tempfile.NamedTemporaryFile() as f: f.write(file_content) f.flush() node = SinglefileData(file=f.name) node.store() self.node = node self.file_content = file_content self.runner = CliRunner()
def build_calc_inputs(cls, structure, code, num_machines, wavefunction, remote_calc_folder, gasphase): inputs = {} if gasphase: inputs['_label'] = "ft_ene_gas" else: inputs['_label'] = "ft_ene" inputs['code'] = code inputs['file'] = {} # write the xyz structure file tmpdir = tempfile.mkdtemp() atoms = structure.get_ase() # slow slab = atoms[-1568:] mol = atoms[:-1568] molslab_fn = tmpdir + '/mol_on_slab.xyz' if gasphase: mol.write(molslab_fn) else: atoms.write(molslab_fn) molslab_f = SinglefileData(file=molslab_fn) inputs['file']['molslab_coords'] = molslab_f shutil.rmtree(tmpdir) # parameters cell_abc = "%f %f %f" % (atoms.cell[0, 0], atoms.cell[1, 1], atoms.cell[2, 2]) walltime = 86000 inp = cls.get_cp2k_input(cell_abc, wavefunction, walltime * 0.97) if remote_calc_folder is not None: inp['EXT_RESTART'] = { 'RESTART_FILE_NAME': './parent_calc/aiida-1.restart' } inputs['parent_folder'] = remote_calc_folder inputs['parameters'] = ParameterData(dict=inp) # settings settings = ParameterData(dict={'additional_retrieve_list': ['*.xyz']}) inputs['settings'] = settings # resources inputs['_options'] = { "resources": { "num_machines": num_machines }, "max_wallclock_seconds": walltime, } return inputs
def parse_with_retrieved(self, retrieved): """ Parse output data folder, store results in database. :param retrieved: a dictionary of retrieved nodes, where the key is the link name :returns: a tuple with two values ``(bool, node_list)``, where: * ``bool``: variable to tell if the parsing succeeded * ``node_list``: list of new nodes to be stored in the db (as a list of tuples ``(link_name, node)``) """ from aiida.orm.data.singlefile import SinglefileData success = False node_list = [] # Check that the retrieved folder is there try: out_folder = retrieved['retrieved'] except KeyError: self.logger.error("No retrieved folder found") return success, node_list # Check the folder content is as expected list_of_files = out_folder.get_folder_list() output_files = self._calc.inp.parameters.output_files # Note: set(A) <= set(B) checks whether A is a subset of B if set(output_files) <= set(list_of_files): pass else: self.logger.error( "Not all expected output files {} were found".format( output_files)) return success, node_list # Parse output files output_parsers = self._calc.inp.parameters.output_parsers output_links = self._calc.inp.parameters.output_links for fname, parser, link in list( zip(output_files, output_parsers, output_links)): if parser is None: parsed = SinglefileData(file=out_folder.get_abs_path(fname)) else: try: with open(out_folder.get_abs_path(fname)) as f: parsed = parser.parse_aiida(f.read()) except ValueError: self.logger.error( "Error parsing file {} with parser {}".format( fname, parser)) node_list.append((link, parsed)) success = True return success, node_list
def build_cp2k_inputs(cls, structure, cell, code, mgrid_cutoff, wfn_file_path, elpa_switch): inputs = {} inputs['_label'] = "scf_diag" inputs['code'] = code inputs['file'] = {} atoms = structure.get_ase() # slow # structure tmpdir = tempfile.mkdtemp() geom_fn = tmpdir + '/geom.xyz' atoms.write(geom_fn) geom_f = SinglefileData(file=geom_fn) shutil.rmtree(tmpdir) inputs['file']['geom_coords'] = geom_f cell_array = cell.get_array('cell') # parameters cell_abc = "%f %f %f" % (cell_array[0], cell_array[1], cell_array[2]) num_machines = 12 if len(atoms) > 500: num_machines = 27 walltime = 72000 wfn_file = "" if wfn_file_path != "": wfn_file = os.path.basename(wfn_file_path.value) inp = cls.get_cp2k_input(cell_abc, mgrid_cutoff, walltime*0.97, wfn_file, elpa_switch, atoms) inputs['parameters'] = ParameterData(dict=inp) # settings #settings = ParameterData(dict={'additional_retrieve_list': ['aiida-RESTART.wfn', 'BASIS_MOLOPT', 'aiida.inp']}) #inputs['settings'] = settings # resources inputs['_options'] = { "resources": {"num_machines": num_machines}, "max_wallclock_seconds": walltime, "append_text": ur"cp $CP2K_DATA_DIR/BASIS_MOLOPT .", } if wfn_file_path != "": inputs['_options']["prepend_text"] = ur"cp %s ." % wfn_file_path return inputs
def build_calc_inputs(cls, structure, code, max_force, mgrid_cutoff, vdw_switch, fixed_atoms, remote_calc_folder=None): inputs = {} inputs['_label'] = "slab_geo_opt" inputs['code'] = code inputs['file'] = {} # make sure we're really dealing with a gold slab atoms = structure.get_ase() # slow # structure tmpdir = tempfile.mkdtemp() mol_fn = tmpdir + '/mol.xyz' atoms.write(mol_fn) mol_f = SinglefileData(file=mol_fn) shutil.rmtree(tmpdir) inputs['file']['mol_coords'] = mol_f # parameters cell_abc = "%f %f %f" % (atoms.cell[0, 0], atoms.cell[1, 1], atoms.cell[2, 2]) num_machines = int(np.round(1. + len(atoms) / 120.)) walltime = 86000 inp = cls.get_cp2k_input(cell_abc, max_force, mgrid_cutoff, vdw_switch, fixed_atoms, walltime * 0.97) if remote_calc_folder is not None: inp['EXT_RESTART'] = { 'RESTART_FILE_NAME': './parent_calc/aiida-1.restart' } inputs['parent_folder'] = remote_calc_folder inputs['parameters'] = ParameterData(dict=inp) # settings settings = ParameterData(dict={'additional_retrieve_list': ['*.pdb']}) inputs['settings'] = settings # resources inputs['_options'] = { "resources": { "num_machines": num_machines }, "max_wallclock_seconds": walltime, } return inputs
def build_mol_cp2k_inputs(cls, structure, code, mgrid_cutoff, elpa_switch): inputs = {} inputs['_label'] = "mol_scf" inputs['code'] = code inputs['file'] = {} atoms = structure.get_ase() # slow # structure tmpdir = tempfile.mkdtemp() geom_fn = tmpdir + '/geom.xyz' atoms.write(geom_fn) geom_f = SinglefileData(file=geom_fn) shutil.rmtree(tmpdir) inputs['file']['geom_coords'] = geom_f # parameters cell_abc = "%f %f %f" % (atoms.cell[0, 0], atoms.cell[1, 1], atoms.cell[2, 2]) num_machines = 6 if len(atoms) > 150: num_machines = 12 walltime = 72000 inp = cls.get_cp2k_input(cell_abc, mgrid_cutoff, walltime * 0.97, "", elpa_switch, atoms) inputs['parameters'] = ParameterData(dict=inp) # settings #settings = ParameterData(dict={'additional_retrieve_list': ['aiida-RESTART.wfn', 'BASIS_MOLOPT', 'aiida.inp']}) #inputs['settings'] = settings # resources inputs['_options'] = { "resources": { "num_machines": num_machines }, "max_wallclock_seconds": walltime, "append_text": ur"cp $CP2K_DATA_DIR/BASIS_MOLOPT .", } return inputs
def parse_with_retrieved(self, retrieved): """ Parse outputs, store results in database. :param retrieved: a dictionary of retrieved nodes, where the key is the link name :returns: a tuple with two values ``(bool, node_list)``, where: * ``bool``: variable to tell if the parsing succeeded * ``node_list``: list of new nodes to be stored in the db (as a list of tuples ``(link_name, node)``) """ from aiida.orm.data.singlefile import SinglefileData success = False node_list = [] # Check that the retrieved folder is there try: out_folder = retrieved[self._calc._get_linkname_retrieved()] except KeyError: self.logger.error("No retrieved folder found") return success, node_list # Check the folder content is as expected list_of_files = out_folder.get_folder_list() output_files = [self._calc._OUTPUT_FILE_NAME] output_links = ['{{cookiecutter.entry_point_prefix}}'] # Note: set(A) <= set(B) checks whether A is a subset if set(output_files) <= set(list_of_files): pass else: self.logger.error( "Not all expected output files {} were found".format( output_files)) # Use something like this to loop over multiple output files for fname, link in zip(output_files, output_links): node = SinglefileData(file=out_folder.get_abs_path(fname)) node_list.append((link, node)) success = True return success, node_list
def run_ppm(self): self.report("Running PPM") inputs = {} inputs['_label'] = "hrstm_ppm" inputs['code'] = self.inputs.ppm_code inputs['parameters'] = self.inputs.ppm_params inputs['parent_calc_folder'] = self.ctx.scf_diag.out.remote_folder # TODO set atom types properly inputs['atomtypes'] = SinglefileData(file="/project/apps/scanning_probe/hrstm/atomtypes_2pp.ini") inputs['_options'] = { "resources": {"num_machines": 1}, "max_wallclock_seconds": 21600, } self.report("PPM inputs: " + str(inputs)) future = submit(AfmCalculation.process(), **inputs) return ToContext(ppm=Calc(future))
Usage: verdi run submit.py Note: This script assumes you have set up computer and code as in README.md. """ import aiida_plumed.tests as tests from aiida.orm.data.singlefile import SinglefileData import os code = tests.get_code(entry_point='plumed') # Prepare input parameters from aiida.orm import DataFactory DiffParameters = DataFactory('plumed') parameters = DiffParameters({'ignore-case': True}) file1 = SinglefileData(file=os.path.join(tests.TEST_DIR, 'file1.txt')) file2 = SinglefileData(file=os.path.join(tests.TEST_DIR, 'file2.txt')) # set up calculation calc = code.new_calc() calc.label = "aiida_plumed test" calc.description = "Test job submission with the aiida_plumed plugin" calc.set_max_wallclock_seconds(30) calc.set_withmpi(False) calc.set_resources({"num_machines": 1, "num_mpiprocs_per_machine": 1}) calc.use_parameters(parameters) calc.use_file1(file1) calc.use_file2(file2) calc.store_all()
def parse_with_retrieved(self, retrieved): """ Parse output data folder, store results in database. :param retrieved: a dictionary of retrieved nodes, where the key is the link name :returns: a tuple with two values ``(bool, node_list)``, where: * ``bool``: variable to tell if the parsing succeeded * ``node_list``: list of new nodes to be stored in the db (as a list of tuples ``(link_name, node)``) """ from aiida.orm.data.singlefile import SinglefileData success = False node_list = [] # Check that the retrieved folder is there try: out_folder = retrieved['retrieved'] except KeyError: self.logger.error("No retrieved folder found") return success, node_list # Check the folder content is as expected list_of_files = out_folder.get_folder_list() inp_params = self._calc.inp.parameters output_files = inp_params.output_files # Note: set(A) <= set(B) checks whether A is a subset of B if set(output_files) <= set(list_of_files): pass else: self.logger.error( "Not all expected output files {} were found".format( output_files)) return success, node_list # Parse output files output_parsers = inp_params.output_parsers output_links = inp_params.output_links output_parameters = ParameterData(dict={}) for fname, parser, link in list( zip(output_files, output_parsers, output_links)): if parser is None: # just add file, if no parser implemented parsed = SinglefileData(file=out_folder.get_abs_path(fname)) node_list.append((link, parsed)) else: # else parse and add keys to output_parameters try: with open(out_folder.get_abs_path(fname)) as f: # Note: We join it to the output_params #parsed = parser.parse_aiida(f.read()) parsed_dict = parser.parse(f.read()) except ValueError: self.logger.error( "Error parsing file {} with parser {}".format( fname, parser)) output_parameters.update_dict(parsed_dict) # add name of input structures as parameter output_parameters._set_attr('Input_structure_filename', self._calc.inp.structure.filename) # add input parameters for convenience # note: should be added at top-level in order to allow tab completion # of <calcnode>.res.Input_... for k in inp_params.keys(): output_parameters._set_attr('Input_{}'.format(k), inp_params.get_attr(k)) node_list.append(('output_parameters', output_parameters)) success = True return success, node_list
ANGLES H O H 55.000 104.5200 DIHEDRALS IMPROPER NONBONDED H 0.000000 -0.046000 0.224500 O 0.000000 -0.152100 1.768200 HBOND CUTHB 0.5 END""") water_pot = SinglefileData(file="/tmp/water.pot") calc.use_file(water_pot, linkname="water_pot") # structure using pdb format, because it also carries topology information atoms = ase.build.molecule('H2O') atoms.center(vacuum=10.0) atoms.write("/tmp/coords.pdb", format="proteindatabank") cell = atoms.cell coords_pdb = SinglefileData(file="/tmp/coords.pdb") calc.use_file(coords_pdb, linkname="coords_pdb") # parameters # based on cp2k/tests/Fist/regtest-1-1/water_1.inp parameters = ParameterData(dict={ 'FORCE_EVAL': { 'METHOD': 'fist',
def parse_with_retrieved(self, retrieved): """ Parse the results of retrieved nodes :param retrieved: dictionary of retrieved nodes """ is_success = True output_nodes = [] try: output_folder = retrieved[ self.calculation._get_linkname_retrieved()] except KeyError: self.logger.error('no retrieved folder found') return False, () # Verify the standard output file is present, parse it and attach as output parameters try: filepath_stdout = output_folder.get_abs_path( self.calculation.output_file_name) except OSError as exception: self.logger.error( "expected output file '{}' was not found".format(filepath)) return False, () is_success, dict_stdout = self.parse_stdout(filepath_stdout) output_nodes.append( (self.get_linkname_outparams(), ParameterData(dict=dict_stdout))) # The final chi and hubbard files are only written by a serial or post-processing calculation complete_calculation = True # We cannot use get_abs_path of the output_folder, since that will check for file existence and will throw output_path = output_folder.get_abs_path('.') filepath_chi = os.path.join(output_path, self.calculation.output_file_name_chi) filepath_hubbard = os.path.join( output_path, self.calculation.output_file_name_hubbard) filepath_hubbard_file = os.path.join( output_path, self.calculation.output_file_name_hubbard_file) for filepath in [filepath_chi, filepath_hubbard]: if not os.path.isfile(filepath): complete_calculation = False self.logger.info( "output file '{}' was not found, assuming partial calculation" .format(filepath)) if os.path.isfile(filepath_hubbard_file): output_hubbard_file = SinglefileData(file=filepath_hubbard_file) output_nodes.append( (self.get_linkname_hubbard_file(), output_hubbard_file)) if complete_calculation: dict_hubbard = self.parse_hubbard(filepath_hubbard) dict_chi = self.parse_chi(filepath_chi) output_matrices = ArrayData() output_matrices.set_array('chi0', dict_hubbard['chi0']) output_matrices.set_array('chi1', dict_hubbard['chi1']) output_matrices.set_array('chi0_inv', dict_hubbard['chi0_inv']) output_matrices.set_array('chi1_inv', dict_hubbard['chi1_inv']) output_matrices.set_array('hubbard', dict_hubbard['hubbard']) output_chi = ArrayData() output_chi.set_array('chi0', dict_chi['chi0']) output_chi.set_array('chi1', dict_chi['chi1']) output_hubbard = ParameterData(dict=dict_hubbard['hubbard_U']) output_nodes.append( (self.get_linkname_matrices(), output_matrices)) output_nodes.append((self.get_linkname_hubbard(), output_hubbard)) output_nodes.append((self.get_linkname_chi(), output_chi)) return is_success, output_nodes
def test_full_run(new_database_with_daemon, new_workdir): """Test running a calculation""" from aiida.orm.data.singlefile import SinglefileData from aiida.common.datastructures import calc_states # get code code = get_basic_code(new_workdir, configure=True) # Prepare input parameters infile = SinglefileData( file=os.path.join(TEST_DIR, "input_files", 'mgo_sto3g_scf.crystal.d12')) # set up calculation calc = code.new_calc() inputs_dict = { "input_file": infile, "code": code, "options": { "resources": { "num_machines": 1, "num_mpiprocs_per_machine": 1 }, "withmpi": False, "max_wallclock_seconds": 30 } } # , "_use_cache": Bool(False)} process = calc.process() calcnode = run_get_node(process, inputs_dict) print(calcnode) assert '_aiida_cached_from' not in calcnode.extras() assert calcnode.get_state() == calc_states.FINISHED assert set(calcnode.get_outputs_dict().keys()).issuperset([ 'output_structure', 'output_parameters', 'output_settings', 'retrieved' ]) expected_params = { 'parser_version': str(aiida_crystal17.__version__), 'ejplugins_version': str(ejplugins.__version__), 'parser_class': 'CryBasicParser', 'parser_warnings': ["no initial structure available, creating new kinds for atoms"], 'errors': [], 'warnings': [], 'energy': -2.7121814374931E+02 * 27.21138602, 'energy_units': 'eV', # hartree to eV 'calculation_type': 'restricted closed shell', 'calculation_spin': False, # 'wall_time_seconds': # 3, 'number_of_atoms': 2, 'number_of_assymetric': 2, 'scf_iterations': 7, 'volume': 18.65461527264623, } outputs = calcnode.get_outputs_dict()['output_parameters'].get_dict() # remove wall time, because it is run dependent outputs.pop('wall_time_seconds', None) assert edict.diff( outputs, expected_params, np_allclose=True) == {}
structure = StructureData(ase=atoms) n = structure.store() print 'StructureData of elemental Pd obtained from Pd.cif has pk = {}\n'.format( str(n.pk)) # Add structure of Pd atom in AiiDA group g, _ = Group.get_or_create(name='Isolated_atoms') atoms = read('{}/Pd_isolated-atom.cif'.format(mypath)) structure = StructureData(ase=atoms) n = structure.store() g.add_nodes(n) print "Added structure (pk = {}) obtained from Pd_isolated-atom.cif to AiiDA group 'Isolated_atoms'\n".format( n.pk) # Store SinglefileData with Wien2k results for the equations of states f = SinglefileData() f.set_file('{}/WIEN2k.txt'.format(mypath)) f.store() print 'SinglefileData obtained from text file WIEN2k.txt has pk = {}\n'.format( str(f.pk)) # Store KpointsData for band structure k = KpointsData() k.set_kpoints_mesh([6, 6, 6], [0.0, 0.0, 0.0]) k.store() print 'KpointsData for band structure has pk = {}\n'.format(str(k.pk)) #from aiida.orm.data.singlefile import SinglefileData #try: # g = Group.get_or_create(name='pslib.0.3.1_PBE_PAW', type_string='UpfData') #except UniquenessError:
def build_calc_inputs(cls, structure, code, max_force, calc_type, mgrid_cutoff, vdw_switch, fixed_atoms, center_switch, num_machines, remote_calc_folder): inputs = {} inputs['_label'] = "slab_geo_opt" inputs['code'] = code inputs['file'] = {} # make sure we're dealing with a metal slab # and figure out which one atoms = structure.get_ase() # slow found_metal = False for el in [29, 47, 79]: if len(np.argwhere(atoms.numbers == el)) == 0: continue first_slab_atom = np.argwhere(atoms.numbers == el)[0, 0] + 1 is_H = atoms.numbers[first_slab_atom - 1:] == 1 is_Metal = atoms.numbers[first_slab_atom - 1:] == el if np.all(np.logical_or(is_H, is_Metal)): found_metal = el break if not found_metal: raise Exception("Structure is not a proper slab.") if found_metal == 79: metal_atom = 'Au' elif found_metal == 47: metal_atom = 'Ag' elif found_metal == 29: metal_atom = 'Cu' # structure molslab_f, mol_f = cls.mk_coord_files(atoms, first_slab_atom) inputs['file']['molslab_coords'] = molslab_f inputs['file']['mol_coords'] = mol_f # Au potential pot_f = SinglefileData(file='/project/apps/surfaces/slab/Au.pot') inputs['file']['au_pot'] = pot_f # parameters cell_abc = "%f %f %f" % (atoms.cell[0, 0], atoms.cell[1, 1], atoms.cell[2, 2]) remote_computer = code.get_remote_computer() machine_cores = remote_computer.get_default_mpiprocs_per_machine() if calc_type == 'Mixed DFTB': walltime = 18000 else: walltime = 86000 inp = cls.get_cp2k_input(cell_abc, first_slab_atom, len(atoms), max_force, calc_type, mgrid_cutoff, vdw_switch, machine_cores * num_machines, fixed_atoms, walltime * 0.97, center_switch, metal_atom) if remote_calc_folder is not None: inp['EXT_RESTART'] = { 'RESTART_FILE_NAME': './parent_calc/aiida-1.restart' } inputs['parent_folder'] = remote_calc_folder inputs['parameters'] = ParameterData(dict=inp) # settings settings = ParameterData(dict={'additional_retrieve_list': ['*.pdb']}) inputs['settings'] = settings # resources inputs['_options'] = { "resources": { "num_machines": num_machines }, "max_wallclock_seconds": walltime, } return inputs
def build_calc_inputs( cls, struc_folder, cell, code, fixed_atoms, num_machines, remote_calc_folder, wfn_cp_commands, # NEB input align, endpoints, nproc_rep, nreplicas, nstepsit, rotate, spring, #list of available wfn # Calculation type specific calc_type, file_list, first_slab_atom, last_slab_atom): inputs = {} inputs['_label'] = "NEB" inputs['code'] = code inputs['file'] = {} # The files passed by the notebook for f in struc_folder.get_folder_list(): path = struc_folder.get_abs_path() + '/path/' + f inputs['file'][f] = SinglefileData(file=path) # Au potential pot_f = SinglefileData(file='/project/apps/surfaces/slab/Au.pot') inputs['file']['au_pot'] = pot_f remote_computer = code.get_remote_computer() machine_cores = remote_computer.get_default_mpiprocs_per_machine() if 'Mixed' in str(calc_type): # Then we have mol0.xyz which is not a replica itself nreplica_files = len(file_list) - 1 else: nreplica_files = len(file_list) if calc_type == 'Mixed DFTB': walltime = 18000 else: walltime = 86000 inp = cls.get_cp2k_input( cell=cell, fixed_atoms=fixed_atoms, machine_cores=machine_cores * num_machines, # NEB input align=align, endpoints=endpoints, nproc_rep=nproc_rep, nreplicas=nreplicas, nstepsit=nstepsit, rotate=rotate, spring=spring, # Calculation specific calc_type=calc_type, nreplica_files=nreplica_files, first_slab_atom=first_slab_atom, last_slab_atom=last_slab_atom, walltime=walltime * 0.97) if remote_calc_folder is not None: inputs['parent_folder'] = remote_calc_folder inputs['parameters'] = ParameterData(dict=inp) # settings settings = ParameterData( dict={'additional_retrieve_list': ['*.xyz', '*.out', '*.ener']}) inputs['settings'] = settings # resources inputs['_options'] = { "resources": { "num_machines": num_machines }, "max_wallclock_seconds": walltime, } if len(wfn_cp_commands) > 0: inputs['_options']["prepend_text"] = "" for wfn_cp_command in wfn_cp_commands: inputs['_options']["prepend_text"] += wfn_cp_command + "\n" return inputs
def build_calc_inputs(cls, structure, cell, code, colvar_target, fixed_atoms, num_machines, remote_calc_folder, replica_name, spring, spring_unit, target_unit, subsys_colvar, calc_type): inputs = {} inputs['_label'] = "replica_geo_opt" inputs['_description'] = "replica_{}_{}".format( replica_name, colvar_target) inputs['code'] = code inputs['file'] = {} # make sure we're really dealing with a gold slab atoms = structure.get_ase() # slow try: first_slab_atom = np.argwhere(atoms.numbers == 79)[0, 0] + 1 is_H = atoms.numbers[first_slab_atom - 1:] == 1 is_Au = atoms.numbers[first_slab_atom - 1:] == 79 assert np.all(np.logical_or(is_H, is_Au)) assert np.sum(is_Au) / np.sum(is_H) == 4 except AssertionError: raise Exception("Structure is not a proper slab.") # structure molslab_f, mol_f = cls.mk_coord_files(atoms, first_slab_atom) inputs['file']['molslab_coords'] = molslab_f inputs['file']['mol_coords'] = mol_f # Au potential pot_f = SinglefileData(file='/project/apps/surfaces/slab/Au.pot') inputs['file']['au_pot'] = pot_f # parameters # if no cell is given use the one from the xyz file. if cell == '' or len(str(cell)) < 3: cell_abc = "%f %f %f" % (atoms.cell[0, 0], atoms.cell[1, 1], atoms.cell[2, 2]) else: cell_abc = cell remote_computer = code.get_remote_computer() machine_cores = remote_computer.get_default_mpiprocs_per_machine() inp = cls.get_cp2k_input(cell_abc, colvar_target, fixed_atoms, spring, spring_unit, target_unit, subsys_colvar, calc_type, machine_cores * num_machines, first_slab_atom, len(atoms)) if remote_calc_folder is not None: inputs['parent_folder'] = remote_calc_folder inputs['parameters'] = ParameterData(dict=inp) # settings settings = ParameterData(dict={'additional_retrieve_list': ['*.xyz']}) inputs['settings'] = settings # resources inputs['_options'] = { "resources": { "num_machines": num_machines }, "max_wallclock_seconds": 86000, } return inputs
def build_calc_inputs(cls, code=None, parent_folder=None, structure=None, input_dict=None): inputs = {} inputs['_label'] = "phonons_opt" inputs['code'] = code inputs['file'] = {} atoms = structure.get_ase() # slow input_dict['atoms'] = atoms #basis_f = SinglefileData(file='/project/apps/surfaces/Files/RI_HFX_BASIS_all') #inputs['file']['ri_hfx_basis_all'] = basis_f molslab_f = cls.mk_aiida_file(atoms, "mol_on_slab.xyz") inputs['file']['molslab_coords'] = molslab_f first_slab_atom = None calc_type = input_dict['calc_type'] if calc_type != 'Full DFT': # Au potential pot_f = SinglefileData(file='/project/apps/surfaces/slab/Au.pot') inputs['file']['au_pot'] = pot_f tipii = find_mol.get_types(atoms, 0.1) mol_atoms = np.where(tipii == 0)[0].tolist() #mol_indexes = find_mol.molecules(mol_atoms,atoms) #print(atoms[mol_indexes]) #print(mol_indexes) first_slab_atom = len(mol_atoms) + 1 mol_f = cls.mk_aiida_file(atoms[mol_atoms], "mol.xyz") inputs['file']['mol_coords'] = mol_f if calc_type == 'Mixed DFTB': walltime = 18000 # parameters cell_ase = atoms.cell.flatten().tolist() if 'cell' in input_dict.keys(): if input_dict['cell'] == '' or input_dict['cell'] == None: input_dict['cell'] = cell_ase else: cell_abc = input_dict['cell'].split() input_dict['cell'] = np.diag(np.array( cell_abc, dtype=float)).flatten().tolist() else: input_dict['cell'] = cell_ase # remote_computer = code.get_remote_computer() # machine_cores = remote_computer.get_default_mpiprocs_per_machine() #inp = get_cp2k_input(input_dict = input_dict) input_dict['machine_cores'] = input_dict['nproc_rep'] * input_dict[ 'nreplicas'] input_dict['first_slab_atom'] = first_slab_atom input_dict['last_slab_atom'] = len(atoms) inp = Get_CP2K_Input(input_dict=input_dict).inp if 'parent_folder' in input_dict.keys(): inp['EXT_RESTART'] = { 'RESTART_FILE_NAME': './parent_calc/aiida-1.restart' } inputs['parent_folder'] = input_dict['remote_calc_folder'] inputs['parameters'] = ParameterData(dict=inp) # settings settings = ParameterData(dict={'additional_retrieve_list': ['*.mol']}) inputs['settings'] = settings # resources inputs['_options'] = { 'resources': { 'num_machines': input_dict['num_machines'] * input_dict['nreplicas'], 'num_mpiprocs_per_machine': input_dict['proc_node'], 'num_cores_per_mpiproc': input_dict['num_cores_per_mpiproc'] }, 'max_wallclock_seconds': int(input_dict['walltime']), } return inputs