def converge_scf(self):
"""
start scf-cycle from Fleur calculation
"""
# run a convergence worklfow
# Comment: Here we wait, because of run,
# maybe using a future and submit instead might be better
#print 'ctx, before scf {} {}'.format(ctx, [a for a in self.ctx])
inputs = self.get_inputs_scf(self.ctx)
if self.ctx.last_calc2:
#print 'inputs for convergnce2: {}'.format(inputs)
res = run(fleur_scf_wc,
wf_parameters=inputs['wf_parameters'],
fleurinp=inputs['fleurinp'],
fleur=inputs['fleur'])
#inputs)#
#wf_parameters=wf_para,
#structure=s,
#calc_parameters=parameters,
#inpgen = code,
#fleur=code2)#, computer=computer)
else:
res = run(fleur_scf_wc,
wf_parameters=inputs['wf_parameters'],
structure=inputs['structure'],
calc_parameters=inputs['calc_parameters'],
inpgen=inputs['inpgen'],
fleur=inputs['fleur']) #inputs)#
#print 'ctx, after scf {} {}'.format(ctx, [a for a in self.ctx])
#print 'output of convergence: {}'.format(res)
self.ctx.last_calc2 = res #.get('remote_folder', None)
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, 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.run 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.pid))
else:
run(PwBandStructureWorkChain, **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 main():
inputs = {'a': Float(3.14), 'b': Int(4), 'c': Int(6)}
results = run(SumWorkChain, **inputs)
print 'Result of SumWorkChain: {}'.format(results)
results = run(ProductWorkChain, **inputs)
print 'Result of ProductWorkChain: {}'.format(results)
results = run(SumProductWorkChain, **inputs)
print 'Result of SumProductWorkChain: {}'.format(results)
def execute(args):
"""
The main execution of the script, which will run some preliminary checks on the command
line arguments before passing them to the workchain and running it
"""
try:
code = Code.get_from_string(args.codename)
except NotExistent as exception:
print "Execution failed: could not retrieve the code '{}'".format(args.codename)
print "Exception report: {}".format(exception)
return
try:
parent_calc = load_node(args.parent_calc)
except NotExistent as exception:
print "Execution failed: failed to load the node for the given parent calculation '{}'".format(args.parent_calc)
print "Exception report: {}".format(exception)
return
if not isinstance(parent_calc, PwCalculation):
print "The provided parent calculation {} is not of type PwCalculation, aborting...".format(args.parent_calc)
return
qpoints = KpointsData()
qpoints.set_kpoints_mesh(args.qpoints)
parameters = {
'INPUTPH': {
'tr2_ph': 1e-10,
}
}
settings = {}
options = {
'resources': {
'num_machines': 1
},
'max_wallclock_seconds': args.max_wallclock_seconds,
}
run(
PhBaseWorkChain,
code=code,
parent_calc=parent_calc,
qpoints=qpoints,
parameters=ParameterData(dict=parameters),
settings=ParameterData(dict=settings),
options=ParameterData(dict=options),
max_iterations=Int(args.max_iterations)
)
def test_changed_seedname(create_gaas_calc, configure_with_daemon,
assert_finished):
from aiida.work.run import run
process, inputs = create_gaas_calc(seedname='wannier90')
output, pid = run(process, _return_pid=True, **inputs)
assert all(key in output for key in ['retrieved', 'output_parameters'])
assert_finished(pid)
def run_eos(element="Si",
code='qe-pw-6.2.1@localhost',
pseudo_family='GBRV_lda'):
return run(EquationOfStates,
element=Str(element),
code=Str(code),
pseudo_family=Str(pseudo_family))
def test_filter_symmetries(configure_with_daemon, filter_symmetries_inputs):
from aiida.work.run import run
builder = filter_symmetries_inputs
output = run(builder)
assert 'symmetries' in output
def test_same_input_node(self):
class Wf(WorkChain):
@classmethod
def define(cls, spec):
super(Wf, cls).define(spec)
spec.input('a', valid_type=Int)
spec.input('b', valid_type=Int)
# Try defining an invalid outline
spec.outline(cls.check_a_b)
def check_a_b(self):
assert 'a' in self.inputs
assert 'b' in self.inputs
x = Int(1)
run(Wf, a=x, b=x)
def test_caching(create_gaas_calc, configure_with_daemon, assert_finished):
from aiida.work.run import run
from aiida.orm import load_node
from aiida.common.hashing import make_hash
try:
from aiida.common import caching
except ImportError:
pytest.skip("The used version of aiida-core does not support caching.")
process, inputs = create_gaas_calc()
output, pid = run(process, _return_pid=True, **inputs)
output2, pid2 = run(process, _use_cache=True, _return_pid=True, **inputs)
assert '_aiida_cached_from' in load_node(pid2).extras()
assert all(key in output for key in ['retrieved', 'output_parameters'])
assert all(key in output2 for key in ['retrieved', 'output_parameters'])
assert_finished(pid)
assert_finished(pid2)
def test_changed_seedname_no_settings(create_gaas_calc, configure_with_daemon,
assert_state):
from aiida.work.run import run
from aiida.common.datastructures import calc_states
process, inputs = create_gaas_calc(seedname='wannier90')
del inputs.settings
output, pid = run(process, _return_pid=True, **inputs)
assert_state(pid, calc_states.SUBMISSIONFAILED)
def test_empty_settings(create_gaas_calc, configure_with_daemon, assert_state):
from aiida.work.run import run
from aiida.orm import DataFactory
from aiida.common.datastructures import calc_states
process, inputs = create_gaas_calc()
inputs.settings = DataFactory('parameter')()
output, pid = run(process, _return_pid=True, **inputs)
assert_state(pid, calc_states.FINISHED)
def test_plot(configure_with_daemon, plot_process_inputs):
from aiida.work.run import run
from aiida.orm import DataFactory
process, inputs = plot_process_inputs
output = run(process, _use_cache=False, **inputs)
assert 'plot' in output
assert isinstance(output['plot'], DataFactory('singlefile'))
def execute(args):
"""
The main execution of the script, which will run some preliminary checks on the command
line arguments before passing them to the workchain and running it
"""
try:
code = Code.get_from_string(args.codename)
except NotExistent as exception:
print "Execution failed: could not retrieve the code '{}'".format(args.codename)
print "Exception report: {}".format(exception)
return
try:
structure = load_node(args.structure)
except NotExistent as exception:
print "Execution failed: failed to load the node for the given structure pk '{}'".format(args.structure)
print "Exception report: {}".format(exception)
return
if not isinstance(structure, StructureData):
print "The provided pk {} for the structure does not correspond to StructureData, aborting...".format(args.parent_calc)
return
kpoints = KpointsData()
kpoints.set_kpoints_mesh(args.kpoints)
parameters = load_property_json('parameters.json')
basis = load_property_json('basis.json')
settings = load_property_json('settings.json')
options = load_property_json('options.json')
options['max_wallclock_seconds'] = args.max_wallclock_seconds
run(
SiestaWorkChain,
code=code,
structure=structure,
pseudo_family=Str(args.pseudo_family),
kpoints=kpoints,
parameters=ParameterData(dict=parameters),
settings=ParameterData(dict=settings),
options=ParameterData(dict=options),
basis=ParameterData(dict=basis),
max_iterations=Int(args.max_iterations),
)
def run_eos(structure,
element="Si",
code='qe-pw-6.2.1@localhost',
pseudo_family='GBRV_lda'):
return run(PressureConvergence,
structure=structure,
code=Str(code),
pseudo_family=Str(pseudo_family),
volume_tolerance=Float(0.1))
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 launch(code, structure, pseudo_family, kpoints, max_num_machines,
max_wallclock_seconds, daemon, mode):
"""
Run a PwCalculation for a given input structure
"""
from aiida.orm import load_node
from aiida.orm.data.parameter import ParameterData
from aiida.orm.data.upf import get_pseudos_from_structure
from aiida.orm.utils import CalculationFactory
from aiida.work.run import run, submit
from aiida_quantumespresso.utils.resources import get_default_options
PwCalculation = CalculationFactory('quantumespresso.pw')
parameters = {
'CONTROL': {
'calculation': mode,
},
'SYSTEM': {
'ecutwfc': 30.,
'ecutrho': 240.,
},
}
inputs = {
'code': code,
'structure': structure,
'pseudo': get_pseudos_from_structure(structure, pseudo_family),
'kpoints': kpoints,
'parameters': ParameterData(dict=parameters),
'settings': ParameterData(dict={}),
'_options': get_default_options(max_num_machines,
max_wallclock_seconds),
}
process = PwCalculation.process()
if daemon:
calculation = submit(process, **inputs)
click.echo('Submitted {}<{}> to the daemon'.format(
PwCalculation.__name__, calculation.pid))
else:
click.echo('Running a PwCalculation in the {} mode... '.format(mode))
results, pk = run(process, _return_pid=True, **inputs)
calculation = load_node(pk)
click.echo('PwCalculation<{}> terminated with state: {}'.format(
pk, calculation.get_state()))
click.echo('\n{link:25s} {node}'.format(link='Output link',
node='Node pk and type'))
click.echo('{s}'.format(s='-' * 60))
for link, node in sorted(calculation.get_outputs(also_labels=True)):
click.echo('{:25s} <{}> {}'.format(link, node.pk,
node.__class__.__name__))
def test_vasp2w90(
configure_with_daemon, # pylint: disable=unused-argument
sample,
get_gaas_process_inputs, # pylint: disable=redefined-outer-name
assert_finished):
"""Vasp2w90 unit test"""
from aiida.work.run import run
from aiida.orm import DataFactory
from aiida.orm.data.base import List
process, inputs = get_gaas_process_inputs(
calculation_string='vasp.vasp2w90',
parameters={
'ncore': 1,
'isym': -1,
'icharg': 11,
'lwave': False
})
charge_density = DataFactory('vasp.chargedensity')()
charge_density.set_file(sample('GaAs/CHGCAR'))
inputs.charge_density = charge_density
wannier_input_parameters = dict(
dis_num_iter=1000,
num_bands=24,
num_iter=0,
num_wann=14,
spinors=True,
)
inputs.wannier_parameters = DataFactory('parameter')(
dict=wannier_input_parameters)
wannier_projections = List()
wannier_projections.extend(['Ga : s; px; py; pz', 'As : px; py; pz'])
inputs.wannier_projections = wannier_projections
output, pid = run(process, _return_pid=True, **inputs)
assert all(key in output for key in [
'retrieved', 'kpoints', 'wannier_parameters', 'wannier_kpoints',
'wannier_projections'
])
# check that the input parameters are preserved
wannier_output_parameters = output['wannier_parameters'].get_dict()
for key, value in wannier_input_parameters.items():
assert key in wannier_output_parameters
out_value = eval(
wannier_output_parameters[key].strip('.').capitalize()) # pylint: disable=eval-used
assert value == out_value
# check that the projections block is preserved
assert wannier_projections.get_attr(
'list') == output['wannier_projections'].get_attr('list')
assert_finished(pid)
def registry_tester():
# Call a wf
result, pid = run(nested_tester, _return_pid=True)
assert pid == result['pid']
assert pid == result['node_pk']
# Call a Process
StackTester.run()
return {
'pid': Int(ProcessStack.get_active_process_id()),
'node_pk': Int(ProcessStack.get_active_process_calc_node().pk)
}
def test_calculation_input(self):
@workfunction
def simple_wf():
return {'a': Int(6), 'b': Int(7)}
outputs, pid = run(simple_wf, _return_pid=True)
calc = load_node(pid)
dp = DummyProcess.new_instance(inputs={'calc': calc})
dp.run_until_complete()
input_calc = dp.calc.get_inputs_dict()['calc']
self.assertTrue(isinstance(input_calc, FrozenDict))
self.assertEqual(input_calc['a'], outputs['a'])
def test_seal(self):
rinfo = run(DummyProcess, _return_pid=True)[1]
self.assertTrue(load_node(pk=rinfo).is_sealed)
storedir = tempfile.mkdtemp()
storage = Persistence.create_from_basedir(storedir)
rinfo = submit(DummyProcess, _jobs_store=storage)
n = load_node(pk=rinfo.pid)
self.assertFalse(n.is_sealed)
dp = DummyProcess.create_from(storage.load_checkpoint(rinfo.pid))
dp.run_until_complete()
self.assertTrue(n.is_sealed)
shutil.rmtree(storedir)
def test_tocontext_async_workchain(self):
class MainWorkChain(WorkChain):
@classmethod
def define(cls, spec):
super(MainWorkChain, cls).define(spec)
spec.outline(cls.run, cls.check)
spec.dynamic_output()
def run(self):
return ToContext(subwc=async (SubWorkChain))
def check(self):
assert self.ctx.subwc.out.value == Int(5)
class SubWorkChain(WorkChain):
@classmethod
def define(cls, spec):
super(SubWorkChain, cls).define(spec)
spec.outline(cls.run)
def run(self):
self.out("value", Int(5))
run(MainWorkChain)
def test_vasp(configure_with_daemon, get_gaas_process_inputs, assert_finished): # pylint: disable=unused-argument,redefined-outer-name
"""Vasp calculation integration test"""
from aiida.work.run import run
from aiida.orm import DataFactory
process, inputs = get_gaas_process_inputs(calculation_string='vasp.vasp',
parameters={'ncore': 4})
inputs.settings = DataFactory('parameter')(dict={
'ADDITIONAL_RETRIEVE_LIST': ['CHGCAR']
})
output, pid = run(process, _return_pid=True, **inputs)
assert_finished(pid)
assert all(filename in output['retrieved'].get_folder_list() for filename
in ['OUTCAR', 'EIGENVAL', 'DOSCAR', 'CHGCAR', 'vasprun.xml'])
def test_duplicate_exclude_bands(create_gaas_calc, configure_with_daemon,
assert_state):
from aiida.work.run import run
from aiida.orm import DataFactory
from aiida.common.datastructures import calc_states
process, inputs = create_gaas_calc(projections_dict={
'kind_name': 'As',
'ang_mtm_name': 's'
})
inputs.parameters = DataFactory('parameter')(
dict=dict(num_wann=1,
num_iter=12,
wvfn_formatted=True,
exclude_bands=[1] * 2 + [2, 3]))
output, pid = run(process, _return_pid=True, **inputs)
assert all(key in output for key in ['retrieved', 'output_parameters'])
assert_state(pid, calc_states.FAILED)
def test_run_workchain(self):
"""Test running the WorkChain"""
from aiida.work.run import run
from aiida.orm.data.cif import CifData
from aiida_phtools.workflows.dmatrix import DistanceMatrixWorkChain
structure = CifData(file=os.path.join(pt.TEST_DIR, 'HKUST-1.cif'),
parse_policy='lazy')
outputs = run(
DistanceMatrixWorkChain,
structure=structure,
zeopp_code=self.zeopp_code,
pore_surface_code=self.pore_surface_code,
distance_matrix_code=self.distance_matrix_code,
rips_code=self.rips_code,
)
print(outputs)
def setUpClass(cls):
"""
Create a simple workchain and run it.
"""
super(TestVerdiWorkCommands, cls).setUpClass()
from aiida.work.run import run
from aiida.work.workchain import WorkChain
TEST_STRING = 'Test report.'
cls.test_string = TEST_STRING
class Wf(WorkChain):
@classmethod
def define(cls, spec):
super(Wf, cls).define(spec)
spec.outline(cls.create_logs)
def create_logs(self):
self.report(TEST_STRING)
_, cls.workchain_pid = run(Wf, _return_pid=True)
def test_vasp2w90(
configure_with_daemon, # pylint: disable=unused-argument
sample,
get_gaas_process_inputs, # pylint: disable=redefined-outer-name
assert_finished):
"""Vasp2W90 unit test"""
from aiida.work.run import run
from aiida.orm import DataFactory
from aiida.orm.data.base import List
process, inputs = get_gaas_process_inputs(
calculation_string='vasp.vasp2w90',
parameters={
'ncore': 1,
'isym': -1,
'icharg': 11,
'lwave': False
})
charge_density = DataFactory('vasp.chargedensity')()
charge_density.set_file(sample('GaAs/CHGCAR'))
inputs.charge_density = charge_density
wannier_parameters = DataFactory('parameter')(dict=dict(
dis_num_iter=1000,
num_bands=24,
num_iter=0,
num_wann=14,
spinors=True,
))
inputs.wannier_parameters = wannier_parameters
wannier_projections = List()
wannier_projections.extend(['Ga : s; px; py; pz', 'As : px; py; pz'])
inputs.wannier_projections = wannier_projections
output, pid = run(process, _return_pid=True, **inputs)
assert all(key in output for key in [
'retrieved', 'kpoints', 'wannier_parameters', 'wannier_kpoints',
'wannier_projections'
])
assert_finished(pid)
def run_wf():
# print "Workfunction node identifiers: {}".format(ProcessRegistry().current_calc_node)
wcalc_uuid = ProcessRegistry().current_calc_node.uuid
print "Workfunction node: {}".format(wcalc_uuid)
#Instantiate a JobCalc process and create basic structure
JobCalc = SiestaCalculation.process()
s0 = create_structure()
calcs = {}
for label, factor in zip(labels, scale_facs):
s = rescale(s0, Float(factor))
inputs = geninputs(s)
print "Running a scf for Si with scale factor {}".format(factor)
result = run(JobCalc, **inputs)
calcs[label] = get_info(result, s)
eos = []
for label in labels:
eos.append(calcs[label])
retdict = {'result': ParameterData(dict={'eos_data': eos})}
return retdict
def setUpClass(cls, *args, **kwargs):
"""
Create a simple workchain and run it.
"""
super(TestVerdiWorkCommands, cls).setUpClass()
from aiida.work.run import run
from aiida.work.workchain import WorkChain
TEST_STRING = 'Test report.'
cls.test_string = TEST_STRING
# pylint: disable=abstract-method
class Wf(WorkChain):
@classmethod
def define(cls, spec):
super(Wf, cls).define(spec)
spec.outline(cls.create_logs)
def create_logs(self):
self.report(TEST_STRING)
# Note: Method 'get_exec_engine' is abstract in class 'Process'
# but is not overridden.
_, cls.workchain_pid = run(Wf, _return_pid=True)
