def launch(code, structure, pseudo_family, daemon, protocol):
"""
Run the PwBandStructureWorkChain for a given input structure
to compute the band structure for the relaxed structure
"""
from aiida.orm.data.base import Str
from aiida.orm.utils import WorkflowFactory
from aiida.work.launch import run, submit
PwBandStructureWorkChain = WorkflowFactory(
'quantumespresso.pw.band_structure')
inputs = {
'code': code,
'structure': structure,
'pseudo_family': Str(pseudo_family),
'protocol': Str(protocol),
}
if daemon:
workchain = submit(PwBandStructureWorkChain, **inputs)
click.echo('Submitted {}<{}> to the daemon'.format(
PwBandStructureWorkChain.__name__, workchain.pk))
else:
run(PwBandStructureWorkChain, **inputs)
def launch(code, calculation, kpoints, max_num_machines, max_wallclock_seconds,
daemon, clean_workdir):
"""
Run the PhBaseWorkChain for a previously completed PwCalculation
"""
from aiida.orm.data.base import Bool
from aiida.orm.data.parameter import ParameterData
from aiida.orm.utils import WorkflowFactory
from aiida.work.launch import run, submit
from aiida_quantumespresso.utils.resources import get_default_options
PhBaseWorkChain = WorkflowFactory('quantumespresso.ph.base')
parameters = {'INPUTPH': {}}
options = get_default_options(max_num_machines, max_wallclock_seconds)
inputs = {
'code': code,
'qpoints': kpoints,
'parent_folder': calculation.out.remote_folder,
'parameters': ParameterData(dict=parameters),
'options': ParameterData(dict=options),
}
if clean_workdir:
inputs['clean_workdir'] = Bool(True)
if daemon:
workchain = submit(PhBaseWorkChain, **inputs)
click.echo('Submitted {}<{}> to the daemon'.format(
PhBaseWorkChain.__name__, workchain.pk))
else:
run(PhBaseWorkChain, **inputs)
def launch(
code, parent_calc, kpoints, max_num_machines, max_wallclock_seconds, daemon):
"""
Run the MatdynBaseWorkChain for a previously completed Q2rCalculation
"""
from aiida.orm.data.parameter import ParameterData
from aiida.orm.utils import CalculationFactory, WorkflowFactory
from aiida.work.run import run, submit
from aiida_quantumespresso.utils.resources import get_default_options
MatdynBaseWorkChain = WorkflowFactory('quantumespresso.matdyn.base')
options = get_default_options(max_num_machines, max_wallclock_seconds)
inputs = {
'code': code,
'kpoints': kpoints,
'parent_folder': parent_calc.out.force_constants,
'options': ParameterData(dict=options),
}
if daemon:
workchain = submit(MatdynBaseWorkChain, **inputs)
click.echo('Submitted {}<{}> to the daemon'.format(MatdynBaseWorkChain.__name__, workchain.pid))
else:
run(MatdynBaseWorkChain, **inputs)
def launch(code, structure, pseudo_family, kpoints, max_num_machines,
max_wallclock_seconds, daemon, automatic_parallelization,
clean_workdir, final_scf, group):
"""
Run the PwRelaxWorkChain for a given input structure
"""
from aiida.orm.data.base import Bool, Str
from aiida.orm.data.parameter import ParameterData
from aiida.orm.utils import WorkflowFactory
from aiida.work.run import run, submit
from aiida_quantumespresso.utils.resources import get_default_options
PwRelaxWorkChain = WorkflowFactory('quantumespresso.pw.relax')
parameters = {
'SYSTEM': {
'ecutwfc': 30.,
'ecutrho': 240.,
},
}
inputs = {
'code': code,
'structure': structure,
'pseudo_family': Str(pseudo_family),
'kpoints': kpoints,
'parameters': ParameterData(dict=parameters),
}
if automatic_parallelization:
parallelization = {
'max_num_machines': max_num_machines,
'target_time_seconds': 0.5 * max_wallclock_seconds,
'max_wallclock_seconds': max_wallclock_seconds
}
inputs['automatic_parallelization'] = ParameterData(
dict=parallelization)
else:
options = get_default_options(max_num_machines, max_wallclock_seconds)
inputs['options'] = ParameterData(dict=options)
if clean_workdir:
inputs['clean_workdir'] = Bool(True)
if final_scf:
inputs['final_scf'] = Bool(True)
if group:
inputs['group'] = Str(group)
if daemon:
workchain = submit(PwRelaxWorkChain, **inputs)
click.echo('Submitted {}<{}> to the daemon'.format(
PwRelaxWorkChain.__name__, workchain.pid))
else:
run(PwRelaxWorkChain, **inputs)
def launch(code, calculation, kpoints, max_num_machines, max_wallclock_seconds,
daemon, parallelize_atoms):
"""
Run the HpWorkChain for a completed Hubbard PwCalculation
"""
from aiida.orm.data.base import Bool
from aiida.orm.data.parameter import ParameterData
from aiida.orm.utils import WorkflowFactory
from aiida.work.launch import run, submit
from aiida_quantumespresso.utils.resources import get_default_options
HpWorkChain = WorkflowFactory('quantumespresso.hp.main')
parameters = {'INPUTHP': {}}
inputs = {
'code':
code,
'parent_calculation':
calculation,
'qpoints':
kpoints,
'parameters':
ParameterData(dict=parameters),
'options':
ParameterData(
dict=get_default_options(max_num_machines, max_wallclock_seconds)),
'clean_workdir':
Bool(clean_workdir),
'parallelize_atoms':
Bool(parallelize_atoms),
}
if daemon:
workchain = submit(HpWorkChain, **inputs)
click.echo('Submitted {}<{}> to the daemon'.format(
HpWorkChain.__name__, workchain.pk))
else:
run(HpWorkChain, **inputs)
# -*- coding: utf-8 -*-
from aiida.common.extendeddicts import AttributeDict
from aiida.orm.calculation import JobCalculation
from aiida.orm.data.base import Bool, Float, Int, Str
from aiida.orm.data.structure import StructureData
from aiida.orm.group import Group
from aiida.orm.utils import CalculationFactory, WorkflowFactory
from aiida.work.workchain import WorkChain, ToContext, if_, while_, append_
from aiida_quantumespresso.utils.mapping import prepare_process_inputs
PwCalculation = CalculationFactory('quantumespresso.pw')
PwBaseWorkChain = WorkflowFactory('quantumespresso.pw.base')
class PwRelaxWorkChain(WorkChain):
"""Workchain to relax a structure using Quantum ESPRESSO pw.x"""
@classmethod
def define(cls, spec):
super(PwRelaxWorkChain, cls).define(spec)
spec.expose_inputs(PwBaseWorkChain,
namespace='base',
exclude=('structure', 'clean_workdir'))
spec.input('structure', valid_type=StructureData)
spec.input('final_scf', valid_type=Bool, default=Bool(False))
spec.input('group', valid_type=Str, required=False)
spec.input('relaxation_scheme',
valid_type=Str,
default=Str('vc-relax'))
spec.input('meta_convergence', valid_type=Bool, default=Bool(True))
spec.input('max_meta_convergence_iterations',
valid_type=Int,
def launch(code_pw, code_hp, structure, pseudo_family, kpoints, qpoints,
ecutwfc, ecutrho, hubbard_u, starting_magnetization,
automatic_parallelization, clean_workdir, max_num_machines,
max_wallclock_seconds, daemon, meta_convergence, is_insulator,
parallelize_atoms):
"""
Run the SelfConsistentHubbardWorkChain for a given input structure
"""
from aiida.orm.data.base import Bool, Str
from aiida.orm.data.parameter import ParameterData
from aiida.orm.utils import WorkflowFactory
from aiida.work.launch import run, submit
from aiida_quantumespresso.utils.resources import get_default_options
SelfConsistentHubbardWorkChain = WorkflowFactory(
'quantumespresso.hp.hubbard')
parameters = {
'SYSTEM': {
'ecutwfc': ecutwfc,
'ecutrho': ecutrho,
'lda_plus_u': True,
},
}
parameters_hp = {'INPUTHP': {}}
options = get_default_options(max_num_machines, max_wallclock_seconds)
structure_kinds = structure.get_kind_names()
hubbard_u_kinds = [kind for kind, value in hubbard_u]
hubbard_u = {kind: value for kind, value in hubbard_u}
if not set(hubbard_u_kinds).issubset(structure_kinds):
raise click.BadParameter(
'the kinds in the specified starting Hubbard U values {} is not a strict subset of the kinds in the structure {}'
.format(hubbard_u_kinds, structure_kinds),
param_hint='hubbard_u')
if starting_magnetization:
parameters['SYSTEM']['nspin'] = 2
for kind, magnetization in starting_magnetization:
if kind not in structure_kinds:
raise click.BadParameter(
'the provided structure does not contain the kind {}'.
format(kind),
param_hint='starting_magnetization')
parameters['SYSTEM'].setdefault('starting_magnetization',
{})[kind] = magnetization
inputs = {
'structure': structure,
'hubbard_u': ParameterData(dict=hubbard_u),
'meta_convergence': Bool(meta_convergence),
'is_insulator': Bool(is_insulator),
'scf': {
'code': code_pw,
'pseudo_family': Str(pseudo_family),
'kpoints': kpoints,
'parameters': ParameterData(dict=parameters),
'options': ParameterData(dict=options)
},
'hp': {
'code': code_hp,
'qpoints': qpoints,
'parameters': ParameterData(dict=parameters_hp),
'options': ParameterData(dict=options),
'parallelize_atoms': Bool(parallelize_atoms),
}
}
if daemon:
workchain = submit(SelfConsistentHubbardWorkChain, **inputs)
click.echo('Submitted {}<{}> to the daemon'.format(
SelfConsistentHubbardWorkChain.__name__, workchain.pk))
else:
run(SelfConsistentHubbardWorkChain, **inputs)
def launch(code, structure, pseudo_family, kpoints, max_num_machines,
max_wallclock_seconds, daemon, ecutwfc, ecutrho, hubbard_u,
hubbard_v, hubbard_file_pk, starting_magnetization, smearing,
automatic_parallelization, clean_workdir):
"""
Run the PwBaseWorkChain for a given input structure
"""
from aiida.orm.data.base import Bool, Str
from aiida.orm.data.parameter import ParameterData
from aiida.orm.utils import WorkflowFactory
from aiida.work.launch import run, submit
from aiida_quantumespresso.utils.resources import get_default_options, get_automatic_parallelization_options
PwBaseWorkChain = WorkflowFactory('quantumespresso.pw.base')
parameters = {
'SYSTEM': {
'ecutwfc': ecutwfc,
'ecutrho': ecutrho,
},
}
try:
hubbard_file = validate.validate_hubbard_parameters(
structure, parameters, hubbard_u, hubbard_v, hubbard_file_pk)
except ValueError as exception:
raise click.BadParameter(exception.message)
try:
validate.validate_starting_magnetization(structure, parameters,
starting_magnetization)
except ValueError as exception:
raise click.BadParameter(exception.message)
try:
validate.validate_smearing(parameters, smearing)
except ValueError as exception:
raise click.BadParameter(exception.message)
inputs = {
'code': code,
'structure': structure,
'pseudo_family': Str(pseudo_family),
'kpoints': kpoints,
'parameters': ParameterData(dict=parameters),
}
if automatic_parallelization:
automatic_parallelization = get_automatic_parallelization_options(
max_num_machines, max_wallclock_seconds)
inputs['automatic_parallelization'] = ParameterData(
dict=automatic_parallelization)
else:
options = get_default_options(max_num_machines, max_wallclock_seconds)
inputs['options'] = ParameterData(dict=options)
if clean_workdir:
inputs['clean_workdir'] = Bool(True)
if daemon:
workchain = submit(PwBaseWorkChain, **inputs)
click.echo('Submitted {}<{}> to the daemon'.format(
PwBaseWorkChain.__name__, workchain.pk))
else:
run(PwBaseWorkChain, **inputs)
from aiida.common.extendeddicts import AttributeDict
from aiida.orm import Code
from aiida.orm.data.base import Str, Float, Bool
from aiida.orm.data.parameter import ParameterData
from aiida.orm.data.structure import StructureData
from aiida.orm.data.array.bands import BandsData
from aiida.orm.data.array.kpoints import KpointsData
from aiida.orm.data.singlefile import SinglefileData
from aiida.orm.group import Group
from aiida.orm.utils import WorkflowFactory
from aiida.work.run import submit
from aiida.work.workchain import WorkChain, ToContext, if_
from aiida.work.workfunction import workfunction
from aiida_quantumespresso.utils.mapping import prepare_process_inputs
PwBaseWorkChain = WorkflowFactory('quantumespresso.pw.base')
PwRelaxWorkChain = WorkflowFactory('quantumespresso.pw.relax')
class PwBandsWorkChain(WorkChain):
"""
Workchain to launch a Quantum Espresso pw.x to calculate a bandstructure for a given
structure. The structure will first be relaxed followed by a band structure calculation
"""
@classmethod
def define(cls, spec):
super(PwBandsWorkChain, cls).define(spec)
spec.input('code', valid_type=Code)
spec.input('structure', valid_type=StructureData)
spec.input('pseudo_family', valid_type=Str)
spec.input('kpoints_distance', valid_type=Float, default=Float(0.2))
# -*- coding: utf-8 -*-
from aiida.orm import Code
from aiida.orm.data.base import Str, Float, Bool
from aiida.orm.data.parameter import ParameterData
from aiida.orm.data.structure import StructureData
from aiida.orm.data.array.bands import BandsData
from aiida.orm.data.array.kpoints import KpointsData
from aiida.orm.utils import WorkflowFactory
from aiida.work.workchain import WorkChain, ToContext
PwBandsWorkChain = WorkflowFactory('quantumespresso.pw.bands')
class PwBandStructureWorkChain(WorkChain):
"""
Workchain to relax and compute the band structure for a given input structure
using Quantum ESPRESSO's pw.x
"""
ERROR_INVALID_INPUT_UNRECOGNIZED_KIND = 1
@classmethod
def define(cls, spec):
super(PwBandStructureWorkChain, cls).define(spec)
spec.input('code', valid_type=Code)
spec.input('structure', valid_type=StructureData)
spec.input('pseudo_family', valid_type=Str)
spec.input('protocol', valid_type=Str, default=Str('standard'))
spec.outline(
cls.setup_protocol,
