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 get_structure(original_structure, new_volume):
"""
Given a structure and a new volume, rescale the structure to the new volume
"""
initial_volume = original_structure.get_cell_volume()
scale_factor = (new_volume/initial_volume)**(1./3.)
scaled_structure = rescale(original_structure, Float(scale_factor))
return scaled_structure
def get_structure(original_structure, new_volume):
"""
Given a structure and a new volume, rescale the structure to the new volume
"""
initial_volume = original_structure.get_cell_volume()
scale_factor = (new_volume / initial_volume)**(1. / 3.)
scaled_structure = rescale(original_structure, Float(scale_factor))
return scaled_structure
def get_structure(structure, step_data=None):
"""Return a scaled version of the given structure, where the new volume is determined by the given step data."""
initial_volume = structure.get_cell_volume()
if step_data is None:
new_volume = initial_volume + 4. # In Å^3
else:
# Minimum of a parabola
new_volume = -step_data.dict.b / 2. / step_data.dict.a
scale_factor = (new_volume / initial_volume)**(1. / 3.)
scaled_structure = rescale(structure, Float(scale_factor))
return scaled_structure
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)
