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 eos(structure, codename, pseudo_family):
Proc = PwCalculation.process()
results = {}
for s in (0.98, 0.99, 1.0, 1.02, 1.04):
rescaled = rescale(structure, Float(s))
inputs = generate_scf_input_params(rescaled, codename, pseudo_family)
outputs = run(Proc, **inputs)
res = outputs['output_parameters'].dict
results[str(s)] = res
return results
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 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})}
from aiida.orm.data.structure import StructureData
from aiida.workflows2.run import run
from aiida.workflows2.fragmented_wf import FragmentedWorkfunction, \
ResultToContext, while_
from aiida.workflows2.wf import wf
from common_wf import generate_scf_input_params
from create_rescale import rescale, create_diamond_fcc
from aiida.orm.calculation.job.quantumespresso.pw import PwCalculation
GPa_to_eV_over_ang3 = 1./160.21766208
# Set up the factories
ParameterData = DataFactory("parameter")
KpointsData = DataFactory("array.kpoints")
PwProcess = PwCalculation.process()
def get_first_deriv(stress):
"""
Return the energy first derivative from the stress
"""
from numpy import trace
# Get the pressure (GPa)
p = trace(stress)/3.
# Pressure is -dE/dV; moreover p in kbar, we need to convert
# it to eV/angstrom^3 to be consisten
dE = -p * GPa_to_eV_over_ang3
return dE
def get_volume_energy_and_derivative(output_parameters):
# Set up kpoint
kpoints = KpointsData()
kpoints_mesh = 2
kpoints.set_kpoints_mesh([kpoints_mesh, kpoints_mesh, kpoints_mesh])
# to retrieve the bands
# (the object settings is optional)
settings_dict = {'also_bands': True}
settings = ParameterData(dict=settings_dict)
# calc.label = "Test QE pw.x"
# calc.description = "Test calculation with the Quantum ESPRESSO pw.x code"
# Valid only for Slurm and PBS (using default values for the
# number_cpus_per_machine), change for SGE-like schedulers
JobCalc = PwCalculation.process()
# Inputs
inputs = JobCalc.get_inputs_template()
inputs.structure = s
inputs.parameters = parameters
inputs.kpoints = kpoints
inputs.code = test_and_get_code(codename,
expected_code_type='quantumespresso.pw')
# Calculation options
options = inputs._options
options.max_wallclock_seconds = 30 * 60 # 30 min
options.resources = {"num_machines": 1, "num_mpiprocs_per_machine": 8}
options.custom_scheduler_commands = u"#SBATCH --account=ch3"
if run_in_serial_mode:
from aiida.orm.code import Code
from aiida.orm.data.structure import StructureData
from aiida.workflows2.run import run, asyncd
from aiida.workflows2.fragmented_wf import (FragmentedWorkfunction,
ResultToContext)
from common import generate_scf_input_params
from examples.workflows2.diamond_fcc import rescale
from aiida.orm.calculation.job.quantumespresso.pw import PwCalculation
# Set up the factories
ParameterData = DataFactory("parameter")
KpointsData = DataFactory("array.kpoints")
PwProcess = PwCalculation.process()
class EquationOfStates(FragmentedWorkfunction):
@classmethod
def _define(cls, spec):
spec.input("structure", valid_type=StructureData)
spec.input("start", valid_type=NumericType, default=Float(0.96))
spec.input("delta", valid_type=NumericType, default=Float(0.02))
spec.input("end", valid_type=NumericType, default=Float(1.04))
spec.input("code", valid_type=SimpleData)
spec.input("pseudo_family", valid_type=SimpleData)
spec.outline(
cls.run_pw,
cls.plot_eos
)
def run_scf(structure, codename, pseudo_family):
JobCalc = PwCalculation.process()
inputs = generate_scf_input_params(structure, codename, pseudo_family)
return run(JobCalc, **inputs)
# This file is part of the AiiDA code. #
# #
# The code is hosted on GitHub at https://github.com/aiidateam/aiida_core #
# For further information on the license, see the LICENSE.txt file #
# For further information please visit http://www.aiida.net #
###########################################################################
from aiida.work.workchain import WorkChain, while_, ToContext, Outputs
from aiida.orm.data.float import Float
from aiida.orm.data.str import Str
from aiida.orm.utils import DataFactory
from aiida.work.workfunctions import workfunction as wf
from aiida.work.launch import run, submit
from aiida.orm.calculation.job.quantumespresso.pw import PwCalculation
Proc = PwCalculation.process()
def generate_scf_input_params(**kwargs):
pass
@wf
def rescale(structure, scale):
the_ase = structure.get_ase()
new_ase = the_ase.copy()
new_ase.set_cell(the_ase.get_cell() * float(scale), scale_atoms=True)
new_structure = DataFactory('structure')(ase=new_ase)
return new_structure
