def s2(self): assert self.ctx.r1['_return'] == A assert self.ctx.r2['_return'] == B # Try overwriting r1 return ToContext(r1=Outputs(async(b)))
def run_eos(self): """ Run the equation of states for all delta structures with their parameters """ eos_results = {} inputs = self.get_inputs_eos() for struc, para in self.ctx.calcs_to_run[10:33]:#[10:33] print para formula = struc.get_formula() label = '|delta_wc|eos|{}'.format(formula) description = '|delta| fleur_eos_wc on {}'.format(formula) if para: eos_future = submit(fleur_eos_wc, wf_parameters=inputs['wc_eos_para'], structure=struc, calc_parameters=para, inpgen=inputs['inpgen'], fleur=inputs['fleur'], _label=label, _description=description) #fleur_eos_wc.run(# else: # TODO: run eos_wc_simple eos_future = submit(fleur_eos_wc, wf_parameters=inputs['wc_eos_para'], structure=struc, inpgen=inputs['inpgen'], fleur=inputs['fleur'], _label=label, _description=description) #fleur_eos_wc.run(#a self.report('launching fleur_eos_wc<{}> on structure {} with parameter {}' ''.format(eos_future.pid, struc.pk, para.pk)) label = formula self.ctx.labels.append(label) eos_results[label] = eos_future return ToContext(**eos_results) ''' #async to limit through put eos_results = {} inputs = self.get_inputs_eos() for struc, para in self.ctx.calcs_to_run[:4]: print para formula = struc.get_formula() label = '|delta_wc|eos|{}'.format(formula) description = '|delta| fleur_eos_wc on {}'.format(formula) if para: eos_future = asy(fleur_eos_wc, wf_parameters=inputs['wc_eos_para'], structure=struc, calc_parameters=para, inpgen=inputs['inpgen'], fleur=inputs['fleur'], _label=label, _description=description) #fleur_eos_wc.run(# else: eos_future = asy(fleur_eos_wc, wf_parameters=inputs['wc_eos_para'], structure=struc, inpgen=inputs['inpgen'], fleur=inputs['fleur'], _label=label, _description=description) #fleur_eos_wc.run(#a self.report('launching fleur_eos_wc<{}> on structure {} with parameter {}' ''.format(eos_future.pid, struc.pk, para.pk)) label = formula self.ctx.labels.append(label) eos_results[label] = eos_future return ToContext(**eos_results) ''' '''
def s1(self): return ToContext(r1=Outputs(async(a)), r2=Outputs(async(b)))
def run_voronoi(self): """ run voronoi calculation with parameters from input """ # incerement iteration counter self.ctx.iter += 1 # increase some parameters if self.ctx.iter > 1: # check if cluster size is actually the reason for failure if self.ctx.dos_check_fail_reason not in [ 'EMIN too high', 'core state in contour', 'core state too close' ]: self.ctx.r_cls = self.ctx.r_cls * self.ctx.fac_clsincrease structure = self.inputs.structure self.ctx.formula = structure.get_formula() label = 'voronoi calculation step {}'.format(self.ctx.iter) description = '{} vornoi on {}'.format(self.ctx.description_wf, self.ctx.formula) voronoicode = self.inputs.voronoi # get valid KKR parameters if self.ctx.iter > 1: # take value from last run to continue params = self.ctx.last_params first_iter = False else: # used input or defaults in first iteration first_iter = True if 'calc_parameters' in self.inputs: params = self.inputs.calc_parameters else: kkrparams_default = kkrparams() para_version = self._kkr_default_params[1] for key, val in self._kkr_default_params[0].iteritems(): kkrparams_default.set_value(key, val, silent=True) # create ParameterData node params = ParameterData(dict=kkrparams_default.get_dict()) params.label = 'Defaults for KKR parameter node' params.description = 'defaults as defined in kkrparams of version {}'.format( para_version) # set last_params accordingly (used below for provenance tracking) self.ctx.last_params = params # check if RCLUSTZ is set and use setting from wf_parameters instead (calls update_params_wf to keep track of provenance) updated_params = False update_list = [] kkr_para = kkrparams() for key, val in params.get_dict().iteritems(): kkr_para.set_value(key, val, silent=True) set_vals = kkr_para.get_set_values() set_vals = [keyvalpair[0] for keyvalpair in set_vals] if 'RCLUSTZ' in set_vals: rcls_input = params.get_dict()['RCLUSTZ'] # set r_cls by default or from input in first iteration if self.ctx.r_cls < rcls_input and first_iter: self.ctx.r_cls = rcls_input updated_params = True update_list.append('RCLUSTZ') elif self.ctx.r_cls > rcls_input: # change rcls with iterations updated_params = True update_list.append('RCLUSTZ') else: updated_params = True update_list.append('RCLUSTZ') # in case of dos check verify that RMAX, GMAX are set and use setting from wf_parameters otherwise if 'RMAX' in set_vals: update_list.append('RMAX') rmax_input = params.get_dict()['RMAX'] elif self.ctx.check_dos: # add only if doscheck is done updated_params = True update_list.append('RMAX') rmax_input = kkrparams.get_KKRcalc_parameter_defaults()[0].get( 'RMAX') if 'GMAX' in set_vals: update_list.append('GMAX') gmax_input = params.get_dict()['GMAX'] elif self.ctx.check_dos: # add only if doscheck is done updated_params = True update_list.append('GMAX') gmax_input = kkrparams.get_KKRcalc_parameter_defaults()[0].get( 'GMAX') # check if emin should be changed: skip_voro = False if self.ctx.iter > 1: if (self.ctx.dos_check_fail_reason == 'EMIN too high' or self.ctx.dos_check_fail_reason == 'core state too close'): # decrease emin by self.ctx.delta_e emin_old = self.ctx.dos_params_dict['emin'] eV2Ry = 1. / get_Ry2eV() emin_new = emin_old - self.ctx.delta_e * eV2Ry self.ctx.dos_params_dict['emin'] = emin_new updated_params = True update_list.append('EMIN') skip_voro = True # store updated nodes (also used via last_params in kkr_scf_wc) if updated_params: # set values that are updated if 'RCLUSTZ' in update_list: kkr_para.set_value('RCLUSTZ', self.ctx.r_cls) self.report("INFO: setting RCLUSTZ to {}".format( self.ctx.r_cls)) if 'EMIN' in update_list: kkr_para.set_value('EMIN', emin_new) self.report("INFO: setting EMIN to {}".format(emin_new)) if 'RMAX' in update_list: kkr_para.set_value('RMAX', rmax_input) self.report( "INFO: setting RMAX to {} (needed for DOS check with KKRcode)" .format(rmax_input)) if 'GMAX' in update_list: kkr_para.set_value('GMAX', gmax_input) self.report( "INFO: setting GMAX to {} (needed for DOS check with KKRcode)" .format(gmax_input)) updatenode = ParameterData(dict=kkr_para.get_dict()) updatenode.description = 'changed values: {}'.format(update_list) if first_iter: updatenode.label = 'initial params from wf input' # used workfunction for provenance tracking if parameters have been changed params = update_params_wf(self.ctx.last_params, updatenode) self.ctx.last_params = params else: updatenode.label = 'updated params: {}'.format(update_list) # also keep track of last voronoi output if that has been used voro_out = self.ctx.voro_calc.out.output_parameters params = update_voro_input(self.ctx.last_params, updatenode, voro_out) self.ctx.last_params = params # run voronoi step if not skip_voro: options = { "max_wallclock_seconds": self.ctx.walltime_sec, "resources": self.ctx.resources, "queue_name": self.ctx.queue } VoronoiProcess, inputs = get_inputs_voronoi(voronoicode, structure, options, label, description, params=params) self.report('INFO: run voronoi step {}'.format(self.ctx.iter)) future = submit(VoronoiProcess, **inputs) # return remote_voro (passed to dos calculation as input) return ToContext(voro_calc=future) else: self.report( "INFO: skipping voronoi calculation (do DOS run with different emin only)" )
def run_calculation(self): """Run scf calculation.""" # Create the calculation process and launch it running = submit(Cp2kDftBaseWorkChain, **self.ctx.inputs) self.report("pk: {} | Running cp2k CELL_OPT".format(running.pid)) return ToContext(cp2k=Outputs(running))
def start(self): return ToContext(res=Outputs(legacy_workflow(wf.pk)))
def create_displacement_calculations(self): self.report('create displacements') if 'optimized' in self.ctx: self.ctx.final_structure = self.ctx.optimized.out.optimized_structure self.out('optimized_data', self.ctx.optimized.out.optimized_structure_data) else: self.ctx.final_structure = self.inputs.structure self.ctx.primitive_structure = get_primitive( self.ctx.final_structure, self.inputs.ph_settings)['primitive_structure'] supercells = create_supercells_with_displacements_using_phonopy( self.ctx.final_structure, self.inputs.ph_settings) self.ctx.data_sets = supercells.pop('data_sets') self.ctx.number_of_displacements = len(supercells) calcs = {} # Load data from nodes if __testing__: from aiida.orm import load_node nodes = [96661, 96664] # VASP labels = ['structure_1', 'structure_0'] for pk, label in zip(nodes, labels): future = load_node(pk) self.ctx._content[label] = future #self.ctx._content['single_point'] = load_node(96667) return # Forces for label, supercell in supercells.iteritems(): JobCalculation, calculation_input = generate_inputs( supercell, # self.inputs.machine, self.inputs.es_settings, # pressure=self.input.pressure, type='forces') calculation_input._label = label future = submit(JobCalculation, **calculation_input) self.report('{} pk = {}'.format(label, future.pid)) calcs[label] = future # Born charges if bool(self.inputs.use_nac): self.report('calculate born charges') JobCalculation, calculation_input = generate_inputs( self.ctx.primitive_structure, self.inputs.es_settings, # pressure=self.input.pressure, type='born_charges') future = submit(JobCalculation, **calculation_input) print('single_point: {}'.format(future.pid)) calcs['single_point'] = future return ToContext(**calcs)
def start(self): return ToContext(wf=legacy_workflow(wf.pk))
def run(self): return ToContext(subwc=async (SubWorkChain))
def run_fleur(self): """ run a FLEUR calculation """ self.change_fleurinp() fleurin = self.ctx.fleurinp ''' if 'settings' in self.inputs: settings = self.input.settings else: settings = ParameterData(dict={'files_to_retrieve' : [], 'files_not_to_retrieve': [], 'files_copy_remotely': [], 'files_not_copy_remotely': [], 'commandline_options': ["-wtime", "{}".format(self.ctx.walltime_sec)], 'blaha' : ['bla']}) ''' if self.ctx['last_calc']: # will this fail if fleur before failed? try needed? remote = self.ctx['last_calc'].out.remote_folder elif 'remote_data' in self.inputs: remote = self.inputs.remote_data else: remote = None label = ' ' description = ' ' if self.ctx.formula: label = 'scf: fleur run {}'.format(self.ctx.loop_count + 1) description = '{} fleur run {} on {}'.format( self.ctx.description_wf, self.ctx.loop_count + 1, self.ctx.formula) else: label = 'scf: fleur run {}'.format(self.ctx.loop_count + 1) description = '{} fleur run {}, fleurinp given'.format( self.ctx.description_wf, self.ctx.loop_count + 1) code = self.inputs.fleur options = { "max_wallclock_seconds": self.ctx.walltime_sec, "resources": self.ctx.resources, "queue_name": self.ctx.queue } #, if self.ctx.custom_scheduler_commands: options[ "custom_scheduler_commands"] = self.ctx.custom_scheduler_commands inputs = get_inputs_fleur(code, remote, fleurin, options, label, description, serial=self.ctx.serial) future = submit(FleurProcess, **inputs) self.ctx.loop_count = self.ctx.loop_count + 1 self.report('INFO: run FLEUR number: {}'.format(self.ctx.loop_count)) self.ctx.calcs.append(future) return ToContext(last_calc=future)
def run(self): inputs = {'inp': self.inputs.inp} running = submit(SubWorkChain, **inputs) self.report('launching SubWorkChain<{}>'.format(running.pid)) return ToContext(workchains=append_(running))
from aiida.orm.data.int import Int from aiida.work.workchain import WorkChain, ToContext class SomeWorkChain(WorkChain): @classmethod def define(cls, spec): super(SomeWorkChain, cls).define(spec) spec.outline( cls.submit_workchain, cls.inspect_workchain, ) def submit_workchain(self) future = self.submit(SomeWorkChain) return ToContext(workchain=future) def inspect_workchain(self) assert self.ctx.workchain.is_finished_ok