def run_zeopp(self):
self.report("Running workchain for structure {}".format(
self.inputs.structure.filename))
label = "zeopp"
inputs = {}
inputs['_label'] = label
inputs['_description'] = "Sampling accessible pore surface with zeo++"
inputs['code'] = self.inputs.zeopp_code
inputs['structure'] = self.inputs.structure
NetworkParameters = DataFactory('zeopp.parameters')
network_dict = {
'cssr': True,
'ha': True,
'vsa': [1.8, 1.8, 1000],
'sa': [1.8, 1.8, 1000],
}
inputs['parameters'] = NetworkParameters(dict=network_dict)
inputs['_options'] = self.default_options
NetworkCalculation = CalculationFactory('zeopp.network')
future = submit(NetworkCalculation.process(), **inputs)
self.report(
"pk: {} | Submitted zeo++ calculation for structure {}".format(
future.pid, self.inputs.structure.filename))
return ToContext(**{label: Outputs(future)})
def generate_lammps_params(structure, settings, type=None, pressure=0.0):
"""
Generate the input paramemeters needed to run a calculation for LAMMPS
:param structure: StructureData object
:param settings: ParametersData object containing a dictionary with the LAMMPS parameters
:return: Calculation process object, input dictionary
"""
try:
code = settings.dict.code[type]
except:
code = settings.dict.code
plugin = Code.get_from_string(code).get_attr('input_plugin')
LammpsCalculation = CalculationFactory(plugin)
inputs = LammpsCalculation.process().get_inputs_template()
inputs.code = Code.get_from_string(code)
# machine
inputs._options.resources = settings.dict.machine['resources']
inputs._options.max_wallclock_seconds = settings.dict.machine[
'max_wallclock_seconds']
inputs.structure = structure
inputs.potential = ParameterData(dict=settings.dict.potential)
# if code.get_input_plugin_name() == 'lammps.optimize':
if type == 'optimize':
print('optimize inside')
lammps_parameters = dict(settings.dict.parameters)
lammps_parameters.update({'pressure': pressure}) # pressure kb
inputs.parameters = ParameterData(dict=lammps_parameters)
return LammpsCalculation.process(), inputs
def run_ddec_point_charges(self):
"""Compute ddec point charges from precomputed charge-density."""
charge_density = self.ctx.charge_density_calc['remote_folder']
#options['prepend_text'] = "export OMP_NUM_THREADS=12"
inputs = {
'code' : self.inputs.ddec_code,
'parameters' : self.inputs.ddec_parameters,
'charge_density_folder' : charge_density,
'_options' : self.inputs.ddec_options.get_dict(),
'_label' : "run_pointcharges_ddec",
}
# Create the calculation process and launch it
DdecCalculation = CalculationFactory('ddec')
process = DdecCalculation.process()
future = submit(process, **inputs)
self.report("pk: {} | Running ddec to compute point charges based on the charge-density")
return ToContext(ddec_calc=Outputs(future))
def run_pore_surface(self):
zeopp_out = self.ctx.zeopp
label = "pore_surface"
inputs = {}
inputs['_label'] = label
inputs[
'_description'] = "Subsampling pore surface & formation of supercell"
inputs['code'] = self.inputs.pore_surface_code
inputs['parameters'] = get_pore_surface_parameters(
zeopp_out['output_parameters'])
inputs['surface_sample'] = zeopp_out['surface_sample_vsa']
inputs['structure'] = zeopp_out['structure_cssr']
inputs['_options'] = self.default_options
PoreSurfaceCalculation = CalculationFactory('phtools.surface')
future = submit(PoreSurfaceCalculation.process(), **inputs)
self.report("pk: {} | Submitted pore_surface for structure {}".format(
future.pid, inputs['structure']))
return ToContext(**{label: Outputs(future)})
def test_process_type_with_entry_point(self):
"""
For a process with a registered entry point, the process_type will be its formatted entry point string
"""
from aiida.orm import CalculationFactory, Code
code = Code()
code.set_remote_computer_exec((self.computer, '/bin/true'))
code.store()
parameters = ParameterData(dict={})
template = ParameterData(dict={})
options = {
'resources': {
'num_machines': 1,
'tot_num_mpiprocs': 1
},
'max_wallclock_seconds': 1,
}
inputs = {
'code': code,
'parameters': parameters,
'template': template,
'options': options,
}
entry_point = 'simpleplugins.templatereplacer'
calculation = CalculationFactory(entry_point)
job_process = calculation.process()
process = job_process(inputs=inputs)
expected_process_type = 'aiida.calculations:{}'.format(entry_point)
self.assertEqual(process.calc.process_type, expected_process_type)
# Verify that load_process_class on the calculation node returns the original entry point class
recovered_process = process.calc.load_process_class()
self.assertEqual(recovered_process, calculation)
def run_rips_complex(self):
distance_matrix_out = self.ctx.distance_matrix
label = "rips_complex"
inputs = {}
inputs['_label'] = label
inputs[
'_description'] = "Computing the distance matrix for surface point cloud"
inputs['code'] = self.inputs.rips_code
#inputs['distance_matrix'] = distance_matrix_out['distance_matrix']
inputs['remote_folder'] = distance_matrix_out['remote_folder']
Parameters = DataFactory('gudhi.rdm')
inputs['parameters'] = Parameters(dict={'max-edge-length': 4.2})
inputs['_options'] = self.default_options
RipsDistanceMatrixCalculation = CalculationFactory('gudhi.rdm')
future = submit(RipsDistanceMatrixCalculation.process(), **inputs)
self.report(
"pk: {} | Submitted rips calculation for structure {}".format(
future.pid, self.inputs.structure.filename))
return ToContext(**{label: Outputs(future)})
def run_distance_matrix(self):
pore_surface_out = self.ctx.pore_surface
label = "distance_matrix"
inputs = {}
inputs['_label'] = label
inputs[
'_description'] = "Computing the distance matrix for surface point cloud"
inputs['code'] = self.inputs.distance_matrix_code
inputs['surface_sample'] = pore_surface_out['surface_sample']
inputs['cell'] = pore_surface_out['cell']
inputs['_options'] = self.default_options
self.out("pore_surface", pore_surface_out['surface_sample'])
DistanceMatrixCalculation = CalculationFactory('phtools.dmatrix')
future = submit(DistanceMatrixCalculation.process(), **inputs)
self.report(
"pk: {} | Submitted distance_matrix for structure {}".format(
future.pid, self.inputs.structure.filename))
return ToContext(**{label: Outputs(future)})
"MoleculeName" : "methane",
"MoleculeDefinition" : "TraPPE",
"MolFraction" : 1.0,
"TranslationProbability" : 1.0,
"RotationProbability" : 1.0,
"ReinsertionProbability" : 1.0,
"SwapProbability" : 1.0,
"CreateNumberOfMolecules" : 0,
}],
})
# Calculation resources
options = {
"resources": {
"num_machines": 1, # run on 1 node
"tot_num_mpiprocs": 1, # use 1 process
"num_mpiprocs_per_machine": 1,
},
"max_wallclock_seconds": 1 * 60 * 60, # 1h walltime
"max_memory_kb": 2000000, # 2GB memory
"queue_name": "molsim", # slurm partition to use
"withmpi": False, # we run in serial mode
}
submit(RaspaCalculation.process(),
code=test_and_get_code("raspa@bazis", expected_code_type='raspa'),
structure=load_node("<uuid>"),
parameters=parameters,
_options=options
)
def generate_qe_params(structure, settings, pressure=0.0, type=None):
"""
Generate the input parameters needed to run a calculation for PW (Quantum Espresso)
:param structure: StructureData object containing the crystal structure
:param machine: ParametersData object containing a dictionary with the computational resources information
:param settings: ParametersData object containing a dictionary with the INCAR parameters
:return: Calculation process object, input dictionary
"""
try:
code = settings.dict.code[type]
except:
code = settings.dict.code
plugin = Code.get_from_string(code).get_attr('input_plugin')
PwCalculation = CalculationFactory(plugin)
inputs = PwCalculation.process().get_inputs_template()
# code
inputs.code = Code.get_from_string(code)
# structure
inputs.structure = structure
# machine
inputs._options.resources = settings.dict.machine['resources']
inputs._options.max_wallclock_seconds = settings.dict.machine[
'max_wallclock_seconds']
# Parameters
parameters = dict(settings.dict.parameters)
parameters['CONTROL'] = {'calculation': 'scf'}
if type == 'optimize':
parameters['CONTROL'].update({
'calculation': 'vc-relax',
'tstress': True,
'tprnfor': True,
'etot_conv_thr': 1.e-8,
'forc_conv_thr': 1.e-8
})
parameters['CELL'] = {
'press': pressure,
'press_conv_thr': 1.e-3,
'cell_dynamics': 'bfgs', # Quasi-Newton algorithm
# 'cell_dofree': 'all'
} # Degrees of movement
parameters['IONS'] = {'ion_dynamics': 'bfgs', 'ion_nstepe': 10}
if type == 'forces':
parameters['CONTROL'].update({
'tstress': True,
'tprnfor': True,
'etot_conv_thr': 1.e-8,
'forc_conv_thr': 1.e-8
})
if type == 'born_charges': # in development (not really usable)
parameters['CONTROL'].update({
'tstress': True,
'tprnfor': True,
'etot_conv_thr': 1.e-8,
'forc_conv_thr': 1.e-8
})
#parameters['INPUTPH'] = {'epsil': True,
# 'zeu': True} # Degrees of movement
inputs.parameters = ParameterData(dict=parameters)
# Kpoints
kpoints = KpointsData()
kpoints.set_cell_from_structure(structure)
kpoints.set_kpoints_mesh_from_density(settings.dict.kpoints_density)
inputs.kpoints = kpoints
inputs.pseudo = get_pseudos_qe(structure, settings.dict.pseudos_family)
return PwCalculation.process(), inputs
def generate_vasp_params(structure, settings, type=None, pressure=0.0):
"""
Generate the input paramemeters needed to run a calculation for VASP
:param structure: StructureData object containing the crystal structure
:param settings: ParametersData object containing a dictionary with the INCAR parameters
:return: Calculation process object, input dictionary
"""
try:
code = settings.dict.code[type]
except:
code = settings.dict.code
plugin = Code.get_from_string(code).get_attr('input_plugin')
VaspCalculation = CalculationFactory(plugin)
inputs = VaspCalculation.process().get_inputs_template()
# code
inputs.code = Code.get_from_string(code)
# structure
inputs.structure = structure
# machine
inputs._options.resources = settings.dict.machine['resources']
inputs._options.max_wallclock_seconds = settings.dict.machine[
'max_wallclock_seconds']
# inputs._options._parser_name = 'vasp.pymatgen'
# Use for all the set functions in calculation.
# inputs._options = dict(inputs._options)
# inputs._options['_parser_name'] = 'vasp.pymatgen'
# INCAR (parameters)
incar = dict(settings.dict.parameters)
if type == 'optimize':
incar.update({
'PREC': 'Accurate',
'ISTART': 0,
'IBRION': 2,
'ISIF': 3,
'LWAVE': '.FALSE.',
'LCHARG': '.FALSE.',
'EDIFF': -1e-08,
'EDIFFG': -1e-08,
'ADDGRID': '.TRUE.',
'LREAL': '.FALSE.',
'PSTRESS': pressure
}) # unit: kb -> kB
if not 'NSW' in incar:
incar.update({'NSW': 100})
elif type == 'optimize_constant_volume':
incar.update({
'PREC': 'Accurate',
'ISTART': 0,
'IBRION': 2,
'ISIF': 4,
'NSW': 100,
'LWAVE': '.FALSE.',
'LCHARG': '.FALSE.',
'EDIFF': 1e-08,
'EDIFFG': -1e-08,
'ADDGRID': '.TRUE.',
'LREAL': '.FALSE.'
})
elif type == 'forces':
incar.update({
'PREC': 'Accurate',
'ISYM': 0,
'ISTART': 0,
'IBRION': -1,
'NSW': 1,
'LWAVE': '.FALSE.',
'LCHARG': '.FALSE.',
'EDIFF': 1e-08,
'ADDGRID': '.TRUE.',
'LREAL': '.FALSE.'
})
elif type == 'born_charges':
incar.update({
'PREC': 'Accurate',
'LEPSILON': '.TRUE.',
'ISTART': 0,
'IBRION': 1,
'NSW': 0,
'LWAVE': '.FALSE.',
'LCHARG': '.FALSE.',
'EDIFF': 1e-08,
'ADDGRID': '.TRUE.',
'LREAL': '.FALSE.'
})
inputs.parameters = ParameterData(dict=incar)
# POTCAR (pseudo potentials)
inputs.paw = get_pseudos_vasp(structure,
settings.dict.pseudos_family,
folder_path=settings.dict.family_folder)
# KPOINTS
kpoints = KpointsData()
kpoints.set_cell_from_structure(structure)
if 'kpoints_density' in settings.get_dict():
kpoints.set_kpoints_mesh_from_density(settings.dict.kpoints_density)
elif 'kpoints_mesh' in settings.get_dict():
if 'kpoints_offset' in settings.get_dict():
kpoints_offset = settings.dict.kpoints_offset
else:
kpoints_offset = [0.0, 0.0, 0.0]
kpoints.set_kpoints_mesh(settings.dict.kpoints_mesh,
offset=kpoints_offset)
else:
raise InputValidationError(
'no kpoint definition in input. Define either kpoints_density or kpoints_mesh'
)
inputs.kpoints = kpoints
return VaspCalculation.process(), inputs
def test_bands(siesta_develop):
"""Test workfunction runs and outputs results in serial mode."""
from aiida.orm import Code, DataFactory, CalculationFactory
from aiida.orm.data.base import Float, Str
SiestaCalculation = CalculationFactory('siesta.siesta')
PsfData = DataFactory('siesta.psf')
StructureData = DataFactory('structure')
ParameterData = DataFactory('parameter')
KpointsData = DataFactory('array.kpoints')
codename = 'siesta@develop'
code = Code.get_from_string(codename)
inputs = SiestaCalculation.process().get_inputs_template()
inputs.code = code
inputs._options.resources = {
"num_machines": 1,
"num_mpiprocs_per_machine": 1,
}
inputs._options.max_wallclock_seconds = 30 * 60
# Define MgO structure
alat = 4.117 # MgO lattice constant, Angstroms
cell = create_FCC_structure(alat) # Creating MgO FCC-cell
structure = StructureData(cell=cell) # Creating structure from cell
# Placing basis atoms
structure.append_atom(position=(0.000 * alat, 0.000 * alat, 0.000 * alat),
symbols=['Mg'])
structure.append_atom(position=(0.500 * alat, 0.500 * alat, 0.500 * alat),
symbols=['O'])
inputs.structure = structure
# Pseudopotentials
# from aiida_siesta.data.psf import get_pseudos_from_structure
# inputs.pseudo = get_pseudos_from_structure(structure, "test_psf_family")
raw_pseudos = [
("Mg.psf", 'Mg'),
("O.psf", 'O'),
]
pseudo_dict = {}
for fname, kind in raw_pseudos:
absname = os.path.realpath(
os.path.join(os.path.dirname(__file__), '..', 'pseudos', fname))
pseudo, created = PsfData.get_or_create(absname, use_first=True)
if created:
print "Created the pseudo for {}".format(kind)
else:
print "Using the pseudo for {} from DB: {}".format(kind, pseudo.pk)
# Attach pseudo node to the calculation
pseudo_dict[kind] = pseudo
inputs.pseudo = pseudo_dict
# K-points mesh
kpoints_mesh = KpointsData()
kpoints_mesh.set_kpoints_mesh([6, 6, 6], [0.5, 0.5, 0.5])
inputs.kpoints = kpoints_mesh
# Bands' k-points
bandskpoints = KpointsData()
bandskpoints.set_cell(structure.cell, structure.pbc)
bandskpoints.set_kpoints_path([
('K', 'G', 39),
('G', 'X', 37),
('X', 'W', 19),
('W', 'L', 27),
('L', 'G', 32),
])
inputs.bandskpoints = bandskpoints
# Calculation parameters
parameters = ParameterData(
dict={
'xc-functional': 'LDA',
'xc-authors': 'CA',
'spin-polarized': False,
'meshcutoff': '200 Ry',
'max-scfiterations': 50,
'xml-write': True,
})
inputs.parameters = parameters
# Create and run Siesta calculation process
from aiida.work.run import run
JobCalc = SiestaCalculation.process()
result = run(JobCalc, **inputs)
assert result['bands_array'] is not None
def generate_phonopy_params(structure,
ph_settings,
force_sets=None,
force_constants=None,
nac_data=None,
bands=None):
"""
Generate inputs parameters needed to do a remote phonopy calculation
:param structure: StructureData Object that constains the crystal structure unit cell
:param ph_settings: ParametersData object containing a dictionary with the phonopy input data
:param force_sets: ForceSetssData object containing the atomic forces and displacement information
:return: Calculation process object, input dictionary
"""
try:
code = Code.get_from_string(ph_settings.dict.code['fc2'])
except:
code = Code.get_from_string(ph_settings.dict.code)
plugin = code.get_attr('input_plugin')
PhonopyCalculation = CalculationFactory(plugin)
# The inputs
inputs = PhonopyCalculation.process().get_inputs_template()
# code
inputs.code = code
# structure
inputs.structure = structure
# parameters
inputs.parameters = ph_settings
# resources
inputs._options.resources = ph_settings.dict.machine['resources']
inputs._options.max_wallclock_seconds = ph_settings.dict.machine[
'max_wallclock_seconds']
# data_sets
inputs.data_sets = force_sets
# data_sets
if force_sets is not None:
inputs.data_sets = force_sets
# force constants
if force_constants is not None:
inputs.force_constants = force_constants
# non-analytical corrections
if nac_data is not None:
inputs.nac_data = nac_data
# bands
if bands is not None:
inputs.bands = bands
if force_constants is None and force_sets is None:
Exception('Either force sets or force constants must be set!')
return PhonopyCalculation.process(), inputs
class TestProcessBuilder(AiidaTestCase):
def setUp(self):
super(TestProcessBuilder, self).setUp()
self.assertIsNone(Process.current())
self.calculation_class = CalculationFactory(
'simpleplugins.templatereplacer')
self.process_class = self.calculation_class.process()
self.builder = self.process_class.get_builder()
def tearDown(self):
super(TestProcessBuilder, self).tearDown()
self.assertIsNone(Process.current())
def test_process_builder_attributes(self):
"""
Check that the builder has all the input ports of the process class as attributes
"""
for name, port in self.process_class.spec().inputs.iteritems():
self.assertTrue(hasattr(self.builder, name))
def test_process_builder_set_attributes(self):
"""
Verify that setting attributes in builder works
"""
label = 'Test label'
description = 'Test description'
self.builder.label = label
self.builder.description = description
self.assertEquals(self.builder.label, label)
self.assertEquals(self.builder.description, description)
def test_workchain(self):
"""
Verify that the attributes of the TestWorkChain can be set but defaults are not there
"""
builder = TestWorkChain.get_builder()
builder.a = Int(2)
builder.b = Float(2.3)
builder.c.d = Bool(True)
self.assertEquals(builder, {
'a': Int(2),
'b': Float(2.3),
'c': {
'd': Bool(True)
}
})
def test_invalid_setattr_raises(self):
"""
Verify that __setattr__ cannot be called on a terminal Port
"""
builder = TestWorkChain.get_builder()
with self.assertRaises(AttributeError):
builder.a.b = 3
def test_dynamic_getters_value(self):
"""
Verify that getters will return the actual value
"""
builder = TestWorkChain.get_builder()
builder.a = Int(2)
builder.b = Float(2.3)
builder.c.d = Bool(True)
# Verify that the correct type is returned by the getter
self.assertTrue(isinstance(builder.a, Int))
self.assertTrue(isinstance(builder.b, Float))
self.assertTrue(isinstance(builder.c.d, Bool))
# Verify that the correct value is returned by the getter
self.assertEquals(builder.a, Int(2))
self.assertEquals(builder.b, Float(2.3))
self.assertEquals(builder.c.d, Bool(True))
def test_dynamic_getters_doc_string(self):
"""
Verify that getters have the correct docstring
"""
builder = TestWorkChain.get_builder()
self.assertEquals(builder.__class__.a.__doc__,
str(TestWorkChain.spec().inputs['a']))
self.assertEquals(builder.__class__.b.__doc__,
str(TestWorkChain.spec().inputs['b']))
self.assertEquals(builder.__class__.c.__doc__,
str(TestWorkChain.spec().inputs['c']))
self.assertEquals(builder.c.__class__.d.__doc__,
str(TestWorkChain.spec().inputs['c']['d']))
def test_code_get_builder(self):
"""
Test that the get_builder method of Code returns a builder
where the code is already set.
"""
from aiida.orm import Code
code1 = Code()
# This also sets the code as a remote code
code1.set_remote_computer_exec((self.computer, '/bin/true'))
code1.label = 'test_code1'
code1.set_input_plugin_name('simpleplugins.templatereplacer')
code1.store()
# Check that I can get a builder
builder = code1.get_builder()
self.assertEquals(builder.code.pk, code1.pk)
# Check that I can set the parameters
builder.parameters = ParameterData(dict={})
# Check that it complains for an unknown input
with self.assertRaises(AttributeError):
builder.unknown_parameter = 3
# Check that it complains if the type is not the correct one
# (for the simpleplugins.templatereplacer, it should be a
# ParameterData)
with self.assertRaises(ValueError):
builder.parameters = Int(3)
def get_vasp_proc():
vasp_cls = CalculationFactory('vasp.vasp')
if builder_interface(vasp_cls):
return vasp_cls
return vasp_cls.process()
def generate_phono3py_params(structure,
parameters,
force_sets,
nac_data=None,
fc2=None,
fc3=None,
grid_point=None,
grid_data=None):
"""
Generate inputs parameters needed to do a remote phonopy calculation
:param structure: StructureData Object that constains the crystal structure unit cell
:param parameters: ParametersData object containing a dictionary with the phonopy input data
:param force_sets: ForceSetsData object containing the atomic forces and displacement information
:param nac_data: NacData object containing the dielectric tensor and Born effective charges info
:param fc2: ForceConstantsData object containing the 2nd order force constants
:param fc3: ForceConstantsData object containing the 3rd order force constants
:param grid_point: List containing the grid points to calculate (in distributed calculation)
:return: Calculation process object, input dictionary
"""
try:
code = Code.get_from_string(parameters.dict.code['fc3'])
except:
code = Code.get_from_string(parameters.dict.code)
plugin = code.get_attr('input_plugin')
PhonopyCalculation = CalculationFactory(plugin)
# The inputs
inputs = PhonopyCalculation.process().get_inputs_template()
# code
inputs.code = code
# structure
inputs.structure = structure
# Parameters
if grid_point is not None:
parameters_dic = parameters.get_dict()
parameters_dic.update({'grid_point': np.array(grid_point).tolist()})
parameters = ParameterData(dict=parameters_dic)
if grid_data is not None:
inputs.grid_data = grid_data
inputs.parameters = parameters
# resources
inputs._options.resources = parameters.dict.machine['resources']
inputs._options.max_wallclock_seconds = parameters.dict.machine[
'max_wallclock_seconds']
# data_sets & force constants
if force_sets is not None:
inputs.data_sets = force_sets
if fc2 is not None:
inputs.force_constants = fc2
if fc3 is not None:
inputs.force_constants_3 = fc3
# non-analytical corrections
if nac_data is not None:
inputs.nac_data = nac_data
return PhonopyCalculation.process(), inputs
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))
# 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
options = {
'resources': {
'num_machines': 1,
'tot_num_mpiprocs': 1,
},
'max_wallclock_seconds': 1800,
}
kpoints = KpointsData()
kpoints.set_kpoints_mesh([1, 1, 1])
inputs = {
'code': Code.get_from_string('VASP.5.4.4@Raichu'),
'structure': load_node(888),
'kpoints': kpoints,
'parameters': ParameterData(dict={}),
'settings': ParameterData(dict={}),
'pseudo_family': Str('vasp-pbe'),
'options' : ParameterData( dict = {
'max_wallclock_seconds' : 3600,
'max_memory_kb': 10000000,
'resources' : { 'num_machines': 1
},
}),
'max_iterations' : Int(1),
}
process = VaspCalculation.process()
# running = run(process, **inputs)
running = run(VASPBaseWorkchain, **inputs)
