def run_eos_wf(codename, pseudo_family, element): print "Workfunction node identifiers: {}".format(Process.current().calc) s0 = create_diamond_fcc(Str(element)) calcs = {} for label, factor in zip(labels, scale_facs): s = rescale(s0, Float(factor)) inputs = generate_scf_input_params(s, str(codename), Str(pseudo_family)) print "Running a scf for {} with scale factor {}".format( element, factor) result = run(PwCalculation, **inputs) print "RESULT: {}".format(result) calcs[label] = get_info(result) eos = [] for label in labels: eos.append(calcs[label]) # Return information to plot the EOS ParameterData = DataFactory('parameter') retdict = { 'initial_structure': s0, 'result': ParameterData(dict={'eos_data': eos}) } return retdict
def run_eos_wf(codename, pseudo_family, element): print "Workfunction node pk: {}".format(registry.current_calc_node) #Instantiate a JobCalc process and create basic structure JobCalc = PwCalculation.process() s0 = create_diamond_fcc(Str(element)) eos=[] scale_facs = (0.98, 0.99, 1.0, 1.02, 1.04) for factor in scale_facs: s = rescale(s0,Float(factor)) inputs = generate_scf_input_params( s, str(codename), str(pseudo_family)) print "Running a scf for {} with scale factor {}".format( element, factor) calc_results = run(JobCalc,**inputs) eos.append(get_info(calc_results)) #Return information to plot the EOS ParameterData = DataFactory("parameter") return {'initial_structure': s0,'result': ParameterData(dict={'eos_data': eos})}
def run_pw(self): print "Workchain node identifiers: {}".format(self.calc) #Instantiate a JobCalc process and create basic structure JobCalc = PwCalculation.process() self.ctx.s0 = create_diamond_fcc(Str(self.inputs.element)) self.ctx.eos_names = [] calcs = {} for label, factor in zip(labels, scale_facs): s = rescale(self.ctx.s0, Float(factor)) inputs = generate_scf_input_params(s, str(self.inputs.code), self.inputs.pseudo_family) print "Running a scf for {} with scale factor {}".format( self.inputs.element, factor) future = submit(JobCalc, **inputs) calcs[label] = future # Ask the workflow to continue when the results are ready and store them # in the context return ToContext(**calcs)
def run_eos_wf(code, pseudo_family, element): """Run an equation of state of a bulk crystal structure for the given element.""" # This will print the pk of the work function print('Running run_eos_wf<{}>'.format(Process.current().pid)) scale_factors = (0.96, 0.98, 1.0, 1.02, 1.04) labels = ['c1', 'c2', 'c3', 'c4', 'c5'] calculations = {} # Create an initial bulk crystal structure for the given element, using the calculation function defined earlier initial_structure = create_diamond_fcc(element) # Loop over the label and scale_factor pairs for label, factor in list(zip(labels, scale_factors)): # Generated the scaled structure from the initial structure structure = rescale(initial_structure, Float(factor)) # Generate the inputs for the `PwCalculation` inputs = generate_scf_input_params(structure, code, pseudo_family) # Launch a `PwCalculation` for each scaled structure print('Running a scf for {} with scale factor {}'.format( element, factor)) calculations[label] = run(PwCalculation, **inputs) # Bundle the individual results from each `PwCalculation` in a single dictionary node. # Note: since we are 'creating' new data from existing data, we *have* to go through a `calcfunction`, otherwise # the provenance would be lost! inputs = { label: result['output_parameters'] for label, result in calculations.items() } eos = create_eos_dictionary(**inputs) # Finally, return the results of this work function result = {'initial_structure': initial_structure, 'eos': eos} return result
def run_eos(self): """Run calculations for equation of state.""" # Create basic structure and attach it as an output initial_structure = create_diamond_fcc(self.inputs.element) self.out('initial_structure', initial_structure) calculations = {} for label, factor in zip(labels, scale_facs): structure = rescale(initial_structure, Float(factor)) inputs = generate_scf_input_params(structure, self.inputs.code, self.inputs.pseudo_family) self.report( 'Running an SCF calculation for {} with scale factor {}'. format(self.inputs.element, factor)) future = self.submit(PwCalculation, **inputs) calculations[label] = future # Ask the workflow to continue when the results are ready and store them in the context return ToContext(**calculations)
def run_pw(self, ctx): PwProcess = PwCalculation.process() ctx.s0 = create_diamond_fcc(Str(self.inputs.element)) ctx.eos_names = [] calcs = {} for label, factor in zip(labels, scale_facs): s = rescale(ctx.s0,Float(factor)) inputs = generate_scf_input_params( s, str(self.inputs.code), str(self.inputs.pseudo_family)) print "Running a scf for {} with scale factor {}".format( self.inputs.element, factor) # Launch the code future = self.submit(PwProcess, inputs) # Store the future calcs[label] = future # Ask the workflow to continue when the results are ready and store them # in the context return ResultToContext(**calcs)
def report(self, ctx): """ Output final quantities """ from aiida.orm import DataFactory self.out("steps", DataFactory('parameter')(dict={ 'steps': ctx.steps, 'step0': ctx.step0})) self.out("structure", ctx.last_structure) if __name__ == "__main__": import argparse parser = argparse.ArgumentParser(description='Energy calculation example.') parser.add_argument('--pseudo', type=str, dest='pseudo', required=True, help='The pseudopotential family') parser.add_argument('--code', type=str, dest='code', required=True, help='The codename to use') structure = create_diamond_fcc(element=Str('Si')) print "Initial structure:", structure args = parser.parse_args() wf_results = run(PressureConvergence, structure=structure, code=Str(args.code), pseudo_family=Str(args.pseudo), volume_tolerance=Float(0.1)) print "Workflow results:" print wf_results
r0_out = self.ctx.r0.get_outputs_dict() r1_out = self.ctx.r1.get_outputs_dict() return abs(r1_out['output_parameters'].dict.volume - r0_out['output_parameters'].dict.volume ) > self.inputs.volume_tolerance def finish(self): """ Output final quantities """ from aiida.orm import DataFactory self.out( "steps", DataFactory('parameter')(dict={ 'steps': self.ctx.steps, 'step0': self.ctx.step0 })) self.out("structure", self.ctx.last_structure) if __name__ == "__main__": structure = create_diamond_fcc(element=Str('Si')) wf_results = run_eos(structure=structure) print "Initial structure:", structure print "Workflow results:" print "Final energies and fit parameters are stored in the ParameterData {}".format( wf_results['steps'].pk) print "The optimized structure is stored in StructureData with pk {}".format( wf_results['structure'].pk)