def run_cp2k_charge_density(self): """ Compute the charge-density of a structure that can be later used for extracting ddec point charges. """ options = { "resources": { "num_machines": 4, "num_mpiprocs_per_machine": 12, }, "max_wallclock_seconds": 3 * 60 * 60, } inputs = { 'code' : Code.get_from_string(self.inputs.cp2k_codename.value), 'structure' : from_cif_to_structuredata(self.ctx.processed_structure), 'parameters' : self.inputs.cp2k_parameters, '_options' : options, '_label' : "run_chargedensity_cp2k", } # Create the calculation process and launch it process = Cp2kCalculation.process() future = submit(process, **inputs) self.report("pk: {} | Running cp2k to compute the charge-density") self.ctx.cp2k_pid=future.pid return ToContext(cp2k=Outputs(future))
def generate_scf_input_params(structure, codename, pseudo_family): # The inputs inputs = PwCalculation.process().get_inputs_template() # The structure inputs.structure = structure inputs.code = Code.get_from_string(codename.value) inputs._options.resources = {"num_machines": 1} inputs._options.max_wallclock_seconds = 30 * 60 # Kpoints KpointsData = DataFactory("array.kpoints") kpoints = KpointsData() kpoints_mesh = 2 kpoints.set_kpoints_mesh([kpoints_mesh, kpoints_mesh, kpoints_mesh]) inputs.kpoints = kpoints # Calculation parameters parameters_dict = { "CONTROL": {"calculation": "scf", "tstress": True, # Important that this stays to get stress "tprnfor": True,}, "SYSTEM": {"ecutwfc": 30., "ecutrho": 200.,}, "ELECTRONS": {"conv_thr": 1.e-6,} } ParameterData = DataFactory("parameter") inputs.parameters = ParameterData(dict=parameters_dict) # Pseudopotentials inputs.pseudo = get_pseudos(structure, str(pseudo_family)) return inputs
def run_block_zeopp(self): """ This is the main function that will perform a raspa calculation for the current pressure """ NetworkParameters = DataFactory('zeopp.parameters') # Create the input dictionary sigma = self.inputs.probe_molecule.get_dict()['sigma'] params = { 'ha':True, 'block': [sigma, 200], } inputs = { 'code' : Code.get_from_string(self.inputs.zeopp_codename.value), 'structure' : self.ctx.processed_structure, 'parameters' : NetworkParameters(dict=params), '_options' : self.inputs._options, '_label' : "run_block_zeopp", } # Create the calculation process and launch it process = ZeoppCalculation.process() future = submit(process, **inputs) self.report("pk: {} | Running zeo++ block volume calculation".format(future.pid)) self.ctx.block_pk = future.pid return ToContext(zeopp=Outputs(future))
def run_loading_raspa(self): """ This is the main function that will perform a raspa calculation for the current pressure """ pressure = self.ctx.pressures[self.ctx.p] self.ctx.raspa_parameters['GeneralSettings']['ExternalPressure'] = pressure if self.ctx.prev_pk is not None: self.ctx.raspa_parameters['GeneralSettings']['RestartFile'] = True self.ctx.raspa_parameters['GeneralSettings']['RestartFilePk'] = self.ctx.prev_pk # Create the input dictionary inputs = { 'code' : Code.get_from_string(self.inputs.raspa_codename.value), 'structure' : self.ctx.processed_structure, 'parameters' : ParameterData(dict=self.ctx.raspa_parameters), '_options' : self.inputs._options, '_label' : "run_loading_raspa", } # 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, pressure/1e5)) self.ctx.p += 1 self.ctx.prev_pk = future.pid return ToContext(raspa=Outputs(future))
def run(structure_pk, code, atomic_files, group, partition, ranks_per_node, ranks_kp, ranks_diag, kmesh): # load code from label@computer c = Code.get_from_string(code) if not atomic_files: if c.get_input_plugin_name() == 'quantumespresso.pw': atomic_files = 'SSSP_acc_PBE' if c.get_input_plugin_name() == 'exciting.exciting': atomic_files = 'high_quality_lapw_species' # create k-point mesh k = List() k.extend(kmesh) for spk in structure_pk: # load structure from PK structure = load_node(spk) # create stress tensor workflow stress_tensor = Stress_Tensor() stress_tensor.run(structure=structure, code=c, atomic_files=Str(atomic_files), group=Str(group), kmesh=k, partition=Str(partition), ranks_per_node=Int(ranks_per_node), ranks_kp=Int(ranks_kp), ranks_diag=Int(ranks_diag))
def run_henry_raspa(self): """ This is the main function that will perform a raspa calculation for the current pressure """ raspa_parameters = self.inputs.raspa_parameters.get_dict() raspa_parameters['GeneralSettings'].pop('ExternalPressure') for i, comp in enumerate(raspa_parameters['Component']): name = comp['MoleculeName'] raspa_parameters['Component'][0] = { "MoleculeName" : name, "MoleculeDefinition" : "TraPPE", "WidomProbability" : 1.0, "CreateNumberOfMolecules" : 0, } # Create the input dictionary inputs = { 'code' : Code.get_from_string(self.inputs.raspa_codename.value), 'structure' : self.ctx.processed_structure, 'parameters' : ParameterData(dict=raspa_parameters), '_options' : self.inputs._options, '_label' : "run_henry_raspa", } # Create the calculation process and launch it process = RaspaCalculation.process() future = submit(process, **inputs) self.report("pk: {} | Running raspa for the Henry coefficients".format(future.pid)) return
def main(): DifferenceCalculation = CalculationFactory('wait.wait') builder = DifferenceCalculation.get_builder() builder.code = Code.get_from_string('wait') builder.options = {'resources': {'num_machines': 1}, 'withmpi': False} node = submit(builder) print(node.pk)
def generate_scf_input_params(structure, codename, pseudo, element): # The inputs inputs = PwCalculation.process().get_inputs_template() # The structure inputs.structure = structure inputs.code = Code.get_from_string(codename) # calc.label = "PW test" # calc.description = "My first AiiDA calculation of Silicon with Quantum ESPRESSO" inputs._options.resources = {"num_machines": 1} inputs._options.max_wallclock_seconds = 23*30*60 queue="compute" if queue is not None: inputs._options.queue_name=queue # Kpoints KpointsData = DataFactory("array.kpoints") kpoints = KpointsData() # kpoints_mesh = 2 kp=[0,0,0] f=open('/home/bosonie/AIMS/LDARESULTS/NonRelBirchLDAref', 'r') for line in f: a=line.split() if a[0]==element: kp[0]=int(a[1]) kp[1]=int(a[3]) kp[2]=int(a[5]) vol=a[7] kpoints.set_kpoints_mesh([1,1,1])#[kp[0], kp[1], kp[2]]) inputs.kpoints = kpoints # Calculation parameters parameters_dict = { "CONTROL": {"calculation": "scf", "tstress": True, # Important that this stays to get stress "tprnfor": True, "disk_io": "none"}, "SYSTEM": {"ecutwfc": 100., "ecutrho": 200., "smearing": "gauss", "degauss": 0.000734986}, "ELECTRONS": {"conv_thr": 1.e-6} } ParameterData = DataFactory("parameter") inputs.parameters = ParameterData(dict=parameters_dict) pseudos = {} pseudos[element] = pseudo inputs.pseudo = pseudos return inputs
def run_si_scf(codename, pseudo_family): JobCalc = PwCalculation.process() inputs = JobCalc.get_inputs_template() inputs.code = Code.get_from_string(codename) # calc.label = "PW test" # calc.description = "My first AiiDA calculation of Silicon with Quantum ESPRESSO" inputs._options.resources = {"num_machines": 1} inputs._options.max_wallclock_seconds = 30 * 60 # The structure alat = 5.4 the_cell = [[alat / 2., alat / 2., 0], [alat / 2., 0, alat / 2.], [0, alat / 2., alat / 2.]] StructureData = DataFactory("structure") structure = StructureData(cell=the_cell) structure.append_atom(position=(0., 0., 0.), symbols="Si") structure.append_atom(position=(alat / 4., alat / 4., alat / 4.), symbols="Si") inputs.structure = structure # Kpoints KpointsData = DataFactory("array.kpoints") kpoints = KpointsData() kpoints_mesh = 2 kpoints.set_kpoints_mesh([kpoints_mesh, kpoints_mesh, kpoints_mesh]) inputs.kpoints = kpoints # Calculation parameters parameters_dict = { "CONTROL": { "calculation": "scf", "tstress": True, "tprnfor": True, }, "SYSTEM": { "ecutwfc": 30., "ecutrho": 200., }, "ELECTRONS": { "conv_thr": 1.e-6, } } ParameterData = DataFactory("parameter") inputs.parameters = ParameterData(dict=parameters_dict) # Pseudopotentials inputs.pseudo = get_pseudos(structure, pseudo_family) # calc.set_extra("element", "Si") # calc.submit() asyncd(JobCalc, **inputs)
def generate_pw_input_params(structure, codename, pseudo_family,parameters, calculation_set, kpoints,gamma,settings,parent_folder): """Generate PW input._* from given params """ inputs = {} inputs['structure'] = structure inputs['code'] = Code.get_from_string(codename.value) calculation_set = calculation_set.get_dict() inputs['options'] = ParameterData(dict=calculation_set) if parent_folder: inputs['parent_folder'] = parent_folder inputs['kpoints']=kpoints inputs['parameters'] = parameters inputs['pseudo_family'] = pseudo_family inputs['settings'] = settings return inputs
def generate_ApeCalculation(codename, element, s, p, d, f): inp = ApeCalculation.process().get_inputs_template() inp.code = Code.get_from_string(codename) inp._options.computer = Computer.get('localhost') inp._options.resources = {"num_machines": 1} check = False for ele in ELEMENTS: if element == ele.symbol: nc = int(ele.number) check = True print check, nc if not check: sys.exit("element is not valid") corpar = 1 if nc <= 2: corpar = 0 parameters = ParameterData( dict={ 'Title': '{}'.format(element), 'CalculationMode': 'ae + pp', 'Verbose': '40', 'WaveEquation': 'schrodinger', 'XCFunctional': 'lda_x + lda_c_pz', 'NuclearCharge': '{}'.format(nc), 'PPCalculationTolerance': '1.e-6', 'PPOutputFileFormat': 'upf + siesta', 'CoreCorrection': '{}'.format(corpar), 'EigenSolverTolerance': '1.e-8', 'ODEIntTolerance': '1.e-12' }) orbitals, PPComponents = get_orb_and_PPcomp(nc, s, p, d, f) inp.parameters = parameters inp.orbitals = orbitals inp.PPComponents = PPComponents inp._label = "{0} {1} {2} {3}".format(s, p, d, f) inp._description = "{} pseudo generation with cut of radii in label".format( element) return inp
def generate_scf_input_params(structure, codename, pseudo_family): # The inputs inputs = PwCalculation.get_builder() # The structure inputs.structure = structure inputs.code = Code.get_from_string(codename) # calc.label = "PW test" # calc.description = "My first AiiDA calculation of Silicon with Quantum ESPRESSO" inputs.options.resources = {"num_machines": 1} inputs.options.max_wallclock_seconds = 30 * 60 # Kpoints KpointsData = DataFactory("array.kpoints") kpoints = KpointsData() kpoints_mesh = 2 kpoints.set_kpoints_mesh([kpoints_mesh, kpoints_mesh, kpoints_mesh]) inputs.kpoints = kpoints # Calculation parameters parameters_dict = { "CONTROL": { "calculation": "scf", "tstress": True, # Important that this stays to get stress "tprnfor": True, }, "SYSTEM": { "ecutwfc": 30., "ecutrho": 200., }, "ELECTRONS": { "conv_thr": 1.e-6, } } ParameterData = DataFactory("parameter") inputs.parameters = ParameterData(dict=parameters_dict) # Pseudopotentials inputs.pseudo = validate_and_prepare_pseudos_inputs( structure, pseudo_family=pseudo_family) return inputs
def code_rename(self, *args): import argparse from aiida.common.exceptions import NotExistent from aiida.orm.code import Code parser = argparse.ArgumentParser( prog=self.get_full_command_name(), description='Rename a code (change its label).') # The default states are those that are shown if no option is given parser.add_argument('old_name', help="The old name of the code") parser.add_argument('new_name', help="The new name of the code") parsed_args = parser.parse_args(args) new_name = parsed_args.new_name old_name = parsed_args.old_name try: code = Code.get_from_string(old_name) except NotExistent: print "ERROR! A code with name {} could not be found".format( old_name) sys.exit(1) suffix = '@{}'.format(code.get_computer().name) if new_name.endswith(suffix): new_name = new_name[:-len(suffix)] if '@' in new_name: print >> sys.stderr, "ERROR! Do not put '@' symbols in the code name" sys.exit(1) retrieved_old_name = '{}@{}'.format(code.label, code.get_computer().name) # CHANGE HERE code.label = new_name retrieved_new_name = '{}@{}'.format(code.label, code.get_computer().name) print "Renamed code with ID={} from '{}' to '{}'".format( code.pk, retrieved_old_name, retrieved_new_name)
def run_ddec_point_charges(self): """ Compute ddec point charges from precomputed charge-density. """ cp2k_calc = load_node(self.ctx.cp2k_pid) options = self.inputs._options #options['prepend_text'] = "export OMP_NUM_THREADS=12" inputs = { 'code' : Code.get_from_string(self.inputs.ddec_codename.value), 'parameters' : self.inputs.ddec_parameters, 'electronic_calc_folder' : cp2k_calc.out.remote_folder, '_options' : options, '_label' : "run_pointcharges_ddec", } # Create the calculation process and launch it process = DdecCalculation.process() future = submit(process, **inputs) self.report("pk: {} | Running ddec to compute point charges based on the charge-density") self.ctx.ddec_pid=future.pid return ToContext(ddec=Outputs(future))
def get_pw_calculation(wf_params, only_initialization=False, parent_calc=None, parent_remote_folder=None): """ Returns a stored calculation """ # default max number of seconds for a calculation with only_initialization=True # (should be largely sufficient) default_max_seconds_only_init = 1800 from aiida.orm.code import Code calculation = wf_params['input']['relaxation_scheme'] if only_initialization: wf_params['calculation_set'] = update_nested_dict( wf_params.get('calculation_set',{}), {'max_wallclock_seconds': default_max_seconds_only_init, 'resources': {'num_machines': 1}}) if parent_calc is None: code = Code.get_from_string(wf_params["codename"]) calc = code.new_calc() calc.use_structure(wf_params["structure"]) calc.use_pseudos_from_family(wf_params["pseudo_family"]) if parent_remote_folder is None: pw_parameters = get_pwparameterdata_from_wfparams(wf_params, calculation=calculation) else: # restart from a remote folder (typically, with charge density) pw_parameters = get_pwparameterdata_from_wfparams(wf_params, restart_mode='restart', calculation=calculation) calc._set_parent_remotedata(parent_remote_folder) else: if calculation in ['bands']: calc = parent_calc.create_restart(force_restart=True,use_output_structure=True) else: calc = parent_calc.create_restart(force_restart=True) pw_parameters = get_pwparameterdata_from_wfparams(wf_params, restart_mode='restart', calculation=calculation) if 'vdw_table' in wf_params: calc.use_vdw_table(wf_params['vdw_table']) calc.use_parameters(pw_parameters) calc.use_kpoints(wf_params['kpoints']) calc = set_the_set(calc,wf_params.get('calculation_set',{})) # set the settings if present try: settings_dict = wf_params['settings'] except KeyError: try: settings_dict = parent_calc.inp.settings.get_dict() if calc.inp.parameters.get_dict()['CONTROL']['calculation'] == 'bands': # for bands calculation we take out the npools specification # from the parent settings as the number of kpoints will # be different cmdline = settings_dict.get('cmdline',[]) the_cmdline = take_out_npools_from_cmdline(cmdline) if the_cmdline: settings_dict['cmdline'] = the_cmdline except AttributeError: settings_dict = {} if calc.inp.parameters.get_dict()['CONTROL']['calculation'] == 'bands': settings_dict['also_bands'] = True if only_initialization: settings_dict['ONLY_INITIALIZATION'] = only_initialization _ = settings_dict.pop('also_bands',None) if settings_dict: settings = ParameterData(dict=settings_dict) calc.use_settings(settings) calc.store_all() return calc
def deposit(what, type, author_name=None, author_email=None, url=None, title=None, username=None, password=False, user_email=None, code_label=default_options['code'], computer_name=None, replace=None, message=None, **kwargs): """ Launches a :py:class:`aiida.orm.implementation.general.calculation.job.AbstractJobCalculation` to deposit data node to \*COD-type database. :return: launched :py:class:`aiida.orm.implementation.general.calculation.job.AbstractJobCalculation` instance. :raises ValueError: if any of the required parameters are not given. """ from aiida.common.setup import get_property parameters = {} if not what: raise ValueError("Node to be deposited is not supplied") if not type: raise ValueError("Deposition type is not supplied. Should be " "one of the following: 'published', " "'prepublication' or 'personal'") if not username: username = get_property('tcod.depositor_username') if not username: raise ValueError("Depositor username is not supplied") if not password: parameters['password'] = get_property('tcod.depositor_password') if not parameters['password']: raise ValueError("Depositor password is not supplied") if not user_email: user_email = get_property('tcod.depositor_email') if not user_email: raise ValueError("Depositor email is not supplied") parameters['deposition-type'] = type parameters['username'] = username parameters['user_email'] = user_email if type == 'published': pass elif type in ['prepublication', 'personal']: if not author_name: author_name = get_property('tcod.depositor_author_name') if not author_name: raise ValueError("Author name is not supplied") if not author_email: author_email = get_property('tcod.depositor_author_email') if not author_email: raise ValueError("Author email is not supplied") if not title: raise ValueError("Publication title is not supplied") else: raise ValueError("Unknown deposition type '{}' -- should be " "one of the following: 'published', " "'prepublication' or 'personal'".format(type)) if replace: if str(int(replace)) != replace or int(replace) < 10000000 \ or int(replace) > 99999999: raise ValueError("ID of the replaced structure ({}) does not " "seem to be valid TCOD ID: must be in " "range [10000000,99999999]".format(replace)) elif message: raise ValueError("Message is given while the structure is not " "redeposited -- log message is relevant to " "redeposition only") kwargs['additional_tags'] = {} if title: kwargs['additional_tags']['_publ_section_title'] = title if author_name: kwargs['additional_tags']['_publ_author_name'] = author_name if replace: kwargs['additional_tags']['_tcod_database_code'] = replace kwargs['datablock_names'] = [replace] cif = export_cifnode(what, store=True, **kwargs) from aiida.orm.code import Code from aiida.orm.computer import Computer from aiida.orm.data.parameter import ParameterData from aiida.common.exceptions import NotExistent code = Code.get_from_string(code_label) computer = None if computer_name: computer = Computer.get(computer_name) calc = code.new_calc(computer=computer) calc.set_resources({'num_machines': 1, 'num_mpiprocs_per_machine': 1}) if password: import getpass parameters['password'] = getpass.getpass("Password: ") if author_name: parameters['author_name'] = author_name if author_email: parameters['author_email'] = author_email if url: parameters['url'] = url if replace: parameters['replace'] = True if message: parameters['log-message'] = str(message) pd = ParameterData(dict=parameters) calc.use_cif(cif) calc.use_parameters(pd) calc.store_all() calc.submit() return calc
def siesta_develop(): sd = {} from aiida.orm.code import Code sd["code"] = Code.get_from_string('siesta@develop') return sd
def inner(inputs, code_string): from aiida.orm.code import Code inputs.code = Code.get_from_string(code_string)
def generate_yambo_input_params(precodename, yambocodename, parent_folder, parameters, calculation_set, settings): inputs = YamboCalculation.process().get_inputs_template() inputs.preprocessing_code = Code.get_from_string(precodename.value) inputs.code = Code.get_from_string(yambocodename.value) calculation_set = calculation_set.get_dict() resource = calculation_set.pop('resources', {}) if resource: inputs._options.resources = resource inputs._options.max_wallclock_seconds = calculation_set.pop( 'max_wallclock_seconds', 86400) max_memory_kb = calculation_set.pop('max_memory_kb', None) if max_memory_kb: inputs._options.max_memory_kb = max_memory_kb queue_name = calculation_set.pop('queue_name', None) if queue_name: inputs._options.queue_name = queue_name custom_scheduler_commands = calculation_set.pop( 'custom_scheduler_commands', None) if custom_scheduler_commands: inputs._options.custom_scheduler_commands = custom_scheduler_commands environment_variables = calculation_set.pop("environment_variables", None) if environment_variables: inputs._options.environment_variables = environment_variables label = calculation_set.pop('label', None) if label: inputs._label = label inputs.parent_folder = parent_folder inputs.settings = settings # Get defaults: edit_parameters = parameters.get_dict() try: calc = parent_folder.get_inputs_dict(link_type=LinkType.CREATE)['remote_folder'].inp.parent_calc_folder.get_inputs_dict()\ ['remote_folder'].inp.parent_calc_folder.get_inputs_dict()['remote_folder'] except AttributeError: calc = None is_pw = False if isinstance(calc, PwCalculation): is_pw = True nelec = calc.out.output_parameters.get_dict()['number_of_electrons'] nocc = None if calc.out.output_parameters.get_dict()['lsda']== True or\ calc.out.output_parameters.get_dict()['non_colinear_calculation'] == True: nocc = nelec / 2 else: nocc = nelec / 2 bndsrnxp = gbndrnge = nocc ngsblxpp = int(calc.out.output_parameters.get_dict()['wfc_cutoff'] * 0.073498645 / 4 * 0.25) # ev to ry then 1/4 #ngsblxpp = 2 nkpts = calc.out.output_parameters.get_dict()['number_of_k_points'] if not resource: resource = { "num_mpiprocs_per_machine": 8, "num_machines": 1 } # safe trivial defaults tot_mpi = resource[u'num_mpiprocs_per_machine'] * resource[ u'num_machines'] if 'FFTGvecs' not in edit_parameters.keys(): edit_parameters['FFTGvecs'] = 2 edit_parameters['FFTGvecs_units'] = 'Ry' if 'BndsRnXp' not in edit_parameters.keys(): edit_parameters['BndsRnXp'] = (bndsrnxp / 2, bndsrnxp / 2 + 1) if 'GbndRnge' not in edit_parameters.keys(): edit_parameters['GbndRnge'] = (1.0, gbndrnge / 2) if 'NGsBlkXp' not in edit_parameters.keys(): edit_parameters['NGsBlkXp'] = ngsblxpp edit_parameters['NGsBlkXp_units'] = 'RL' if 'QPkrange' not in edit_parameters.keys(): edit_parameters['QPkrange'] = [(1, 1, int(nocc), int(nocc) + 1) ] # To revisit if 'SE_CPU' not in edit_parameters.keys(): b, qp = split_incom(tot_mpi) edit_parameters['SE_CPU'] = "1 {qp} {b}".format(qp=qp, b=b) edit_parameters['SE_ROLEs'] = "q qp b" if 'X_all_q_CPU' not in edit_parameters.keys(): c, v = split_incom(tot_mpi) edit_parameters['X_all_q_CPU'] = "1 1 {c} {v}".format(c=c, v=v) edit_parameters['X_all_q_ROLEs'] = "q k c v" inputs.parameters = ParameterData(dict=edit_parameters) return inputs
def inner(builder, code_string): from aiida.orm.code import Code builder.code = Code.get_from_string(code_string)