def validate_kpoint_mesh(callback_kwargs, ctx, param, value):
"""
Command line option validator for a kpoints mesh tuple. The value should be a tuple
of three positive integers out of which a KpointsData object will be created with
a mesh equal to the tuple.
:param callback_kwargs: an optional dictionary with arguments for internal use in the validator
:param ctx: internal context of the click.command
:param param: the click Parameter, i.e. either the Option or Argument to which the validator is hooked up
:param value: a tuple of three positive integers
:returns: a KpointsData instance
"""
from aiida.orm.data.array.kpoints import KpointsData
if any([type(i) != int
for i in value]) or any([int(i) <= 0 for i in value]):
raise click.BadParameter(
'all values of the tuple should be positive greater than zero integers'
)
try:
kpoints = KpointsData()
kpoints.set_kpoints_mesh(value)
except ValueError as exception:
raise click.BadParameter(
"failed to create a KpointsData mesh out of {}\n{}".format(
value, exception))
return kpoints
def setup_kpoints(self):
"""
Define the k-point mesh for the Siesta calculation.
"""
self.report('Running setup_kpoints')
kpoints_mesh = KpointsData()
kpmesh=self.ctx.protocol['kpoints_mesh']
kpoints_mesh.set_kpoints_mesh([kpmesh,kpmesh,kpmesh])
self.ctx.kpoints_mesh = kpoints_mesh
def _get_kpoints(self, nx, use_symmetry=True):
nx = max(1, nx)
kpoints = KpointsData()
if use_symmetry:
kpoints.set_kpoints_mesh([nx, 1, 1], offset=[0.0, 0.0, 0.0])
else:
# list kpoints explicitly
points = [[r, 0.0, 0.0] for r in np.linspace(0, 0.5, nx)]
kpoints.set_kpoints(points)
return kpoints
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 get_kpointsdata(self):
"""
Return a KpointsData object based on the data in the input file.
This uses all of the data in the input file to do the necessary unit
conversion, ect. and then creates an AiiDa KpointsData object.
**Note:** If the calculation uses only the gamma k-point (`if
self.k_points['type'] == 'gamma'`), it is necessary to also attach a
settings node to the calculation with `gamma_only = True`.
:return: KpointsData object of the kpoints in the input file
:rtype: aiida.orm.data.array.kpoints.KpointsData
:raises NotImplementedError: if the kpoints are
in a format not yet supported.
"""
from aiida.orm.data.array.kpoints import KpointsData
# Initialize the KpointsData node
kpointsdata = KpointsData()
# Get the structure using this class's method.
structuredata = self.get_structuredata()
# Set the structure information of the kpoints node.
kpointsdata.set_cell_from_structure(structuredata)
# Set the kpoints and weights, doing any necessary units conversion.
if self.k_points['type'] == 'crystal': # relative to recip latt vecs
kpointsdata.set_kpoints(self.k_points['points'],
weights=self.k_points['weights'])
elif self.k_points['type'] == 'tpiba': # cartesian; units of 2*pi/alat
alat = np.linalg.norm(structuredata.cell[0]) # alat in Angstrom
kpointsdata.set_kpoints(np.array(self.k_points['points']) *
(2. * np.pi / alat),
weights=self.k_points['weights'],
cartesian=True)
elif self.k_points['type'] == 'automatic':
kpointsdata.set_kpoints_mesh(self.k_points['points'],
offset=self.k_points['offset'])
elif self.k_points['type'] == 'gamma':
kpointsdata.set_kpoints_mesh([1, 1, 1])
else:
raise NotImplementedError(
'Support for creating KpointsData from input units of {} is'
'not yet implemented'.format(self.k_points['type']))
return kpointsdata
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 test_pw_translation(self):
from aiida.tools.dbexporters.tcod \
import translate_calculation_specific_values
# from aiida.tools.dbexporters.tcod_plugins.pw \
# import PwTcodtranslator as PWT
# from aiida.tools.dbexporters.tcod_plugins.cp \
# import CpTcodtranslator as CPT
from aiida.orm.code import Code
from aiida.orm.data.array import ArrayData
from aiida.orm.data.array.kpoints import KpointsData
from aiida.orm.data.parameter import ParameterData
import numpy
from aiida.common.pluginloader import get_plugin
PWT = get_plugin('tools.dbexporters.tcod_plugins',
'quantumespresso.pw')
CPT = get_plugin('tools.dbexporters.tcod_plugins',
'quantumespresso.cp')
code = Code()
code._set_attr('remote_exec_path', '/test')
kpoints = KpointsData()
kpoints.set_kpoints_mesh([2, 3, 4], offset=[0.25, 0.5, 0.75])
def empty_list():
return []
calc = FakeObject({
"inp": {
"parameters": ParameterData(dict={}),
"kpoints": kpoints,
"code": code
},
"out": {
"output_parameters": ParameterData(dict={})
},
"get_inputs": empty_list
})
res = translate_calculation_specific_values(calc, PWT)
self.assertEquals(
res, {
'_dft_BZ_integration_grid_X': 2,
'_dft_BZ_integration_grid_Y': 3,
'_dft_BZ_integration_grid_Z': 4,
'_dft_BZ_integration_grid_shift_X': 0.25,
'_dft_BZ_integration_grid_shift_Y': 0.5,
'_dft_BZ_integration_grid_shift_Z': 0.75,
'_dft_pseudopotential_atom_type': [],
'_dft_pseudopotential_type': [],
'_dft_pseudopotential_type_other_name': [],
'_tcod_software_package': 'Quantum ESPRESSO',
'_tcod_software_executable_path': '/test',
})
calc = FakeObject({
"inp": {
"parameters":
ParameterData(dict={
'SYSTEM': {
'ecutwfc': 40,
'occupations': 'smearing'
}
})
},
"out": {
"output_parameters":
ParameterData(dict={
'number_of_electrons': 10,
})
},
"get_inputs": empty_list
})
res = translate_calculation_specific_values(calc, PWT)
self.assertEquals(
res, {
'_dft_cell_valence_electrons': 10,
'_tcod_software_package': 'Quantum ESPRESSO',
'_dft_BZ_integration_smearing_method': 'Gaussian',
'_dft_pseudopotential_atom_type': [],
'_dft_pseudopotential_type': [],
'_dft_pseudopotential_type_other_name': [],
'_dft_kinetic_energy_cutoff_EEX': 2176.910676048,
'_dft_kinetic_energy_cutoff_charge_density': 2176.910676048,
'_dft_kinetic_energy_cutoff_wavefunctions': 544.227669012,
})
calc = FakeObject({
"inp": {
"parameters": ParameterData(dict={})
},
"out": {
"output_parameters": ParameterData(dict={
'energy_xc': 5,
})
},
"get_inputs": empty_list
})
with self.assertRaises(ValueError):
translate_calculation_specific_values(calc, PWT)
calc = FakeObject({
"inp": {
"parameters": ParameterData(dict={})
},
"out": {
"output_parameters":
ParameterData(dict={
'energy_xc': 5,
'energy_xc_units': 'meV'
})
},
"get_inputs": empty_list
})
with self.assertRaises(ValueError):
translate_calculation_specific_values(calc, PWT)
energies = {
'energy': -3701.7004199449257,
'energy_one_electron': -984.0078459766,
'energy_xc': -706.6986753641559,
'energy_ewald': -2822.6335103043157,
'energy_hartree': 811.6396117001462,
'fermi_energy': 10.25208617898623,
}
dct = energies
for key in energies.keys():
dct["{}_units".format(key)] = 'eV'
calc = FakeObject({
"inp": {
"parameters":
ParameterData(dict={'SYSTEM': {
'smearing': 'mp'
}})
},
"out": {
"output_parameters": ParameterData(dict=dct)
},
"get_inputs": empty_list
})
res = translate_calculation_specific_values(calc, PWT)
self.assertEquals(
res, {
'_tcod_total_energy': energies['energy'],
'_dft_1e_energy': energies['energy_one_electron'],
'_dft_correlation_energy': energies['energy_xc'],
'_dft_ewald_energy': energies['energy_ewald'],
'_dft_hartree_energy': energies['energy_hartree'],
'_dft_fermi_energy': energies['fermi_energy'],
'_tcod_software_package': 'Quantum ESPRESSO',
'_dft_BZ_integration_smearing_method': 'Methfessel-Paxton',
'_dft_BZ_integration_MP_order': 1,
'_dft_pseudopotential_atom_type': [],
'_dft_pseudopotential_type': [],
'_dft_pseudopotential_type_other_name': [],
})
dct = energies
dct['number_of_electrons'] = 10
for key in energies.keys():
dct["{}_units".format(key)] = 'eV'
calc = FakeObject({
"inp": {
"parameters":
ParameterData(dict={'SYSTEM': {
'smearing': 'unknown-method'
}})
},
"out": {
"output_parameters": ParameterData(dict=dct)
},
"get_inputs": empty_list
})
res = translate_calculation_specific_values(calc, CPT)
self.assertEquals(
res, {
'_dft_cell_valence_electrons': 10,
'_tcod_software_package': 'Quantum ESPRESSO'
})
ad = ArrayData()
ad.set_array("forces", numpy.array([[[1, 2, 3], [4, 5, 6]]]))
calc = FakeObject({
"inp": {
"parameters":
ParameterData(dict={'SYSTEM': {
'smearing': 'unknown-method'
}})
},
"out": {
"output_parameters": ParameterData(dict={}),
"output_array": ad
},
"get_inputs": empty_list
})
res = translate_calculation_specific_values(calc, PWT)
self.assertEquals(
res,
{
'_tcod_software_package': 'Quantum ESPRESSO',
'_dft_BZ_integration_smearing_method': 'other',
'_dft_BZ_integration_smearing_method_other': 'unknown-method',
'_dft_pseudopotential_atom_type': [],
'_dft_pseudopotential_type': [],
'_dft_pseudopotential_type_other_name': [],
## Residual forces are no longer produced, as they should
## be in the same CIF loop with coordinates -- to be
## implemented later, since it's not yet clear how.
# '_tcod_atom_site_resid_force_Cartn_x': [1,4],
# '_tcod_atom_site_resid_force_Cartn_y': [2,5],
# '_tcod_atom_site_resid_force_Cartn_z': [3,6],
})
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:
#
# Slightly distorted structure
#
alat = 5.430 # angstrom
cell = [[0.5*alat, 0.5*alat, 0.,],
[0., 0.5*alat, 0.5*alat,],
[0.5*alat, 0., 0.5*alat,],
]
# Si
# This was originally given in the "ScaledCartesian" format
#
structure = StructureData(cell=cell)
structure.append_atom(position=(0.000*alat,0.000*alat,0.000*alat),symbols=['Si'])
structure.append_atom(position=(0.250*alat,0.245*alat,0.250*alat),symbols=['Si'])
#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)
bandskpoints = KpointsData()
bandskpoints.set_cell(structure.cell, structure.pbc)
bandskpoints.set_kpoints_path(kpoint_distance = 0.05)
parameters = {
'xc-functional': 'LDA',
'xc-authors': 'CA',
'spinpolarized': False,
'meshcutoff': '150.0 Ry',
'max-scfiterations': 50,
'dm-numberpulay': 4,
'dm-mixingweight': 0.3,
'dm-tolerance': 1.e-4,
'Solution-method': 'diagon',
'electronic-temperature': '25 meV',
'md-typeofrun': 'cg',
'md-numcgsteps': 10,
'md-maxcgdispl': '0.1 Ang',
'md-maxforcetol': '0.04 eV/Ang'
}
# default basis
basis = {
'pao-energy-shift': '100 meV',
'%block pao-basis-sizes': """
Si DZP """,
}
settings = {}
options = {
'resources': {
'num_machines': 1
},
'max_wallclock_seconds': args.max_wallclock_seconds,
}
run(
SiestaBaseWorkChain,
code=code,
structure=structure,
pseudo_family=Str(args.pseudo_family),
kpoints=kpoints,
bandskpoints=bandskpoints,
parameters=ParameterData(dict=parameters),
settings=ParameterData(dict=settings),
options=ParameterData(dict=options),
basis=ParameterData(dict=basis),
max_iterations=Int(args.max_iterations),
)
alat=5.4
alat2=alat/2
alat3=alat2/2
from aiida.orm.data.array.kpoints import KpointsData
kpoints = KpointsData()
kpoints_mesh = 2
kpoints.set_kpoints_mesh([kpoints_mesh,kpoints_mesh,kpoints_mesh])
StructureData = DataFactory("structure")
the_cell = [[alat/2,alat/2,0.],[alat/2,0.,alat/2],[0.,alat/2,alat/2]]
structure = StructureData(cell=the_cell)
structure.cell
structure.append_atom(position=(alat/4.,alat/4.,alat/4.),symbols="Si")
structure.sites
from ase.lattice.spacegroup import crystal
ase_structure = crystal('Si', [(0,0,0)], spacegroup=227,
cellpar=[alat, alat, alat, 90, 90, 90],primitive_cell=True)
structure=StructureData(ase=ase_structure)
structure.store()
nameCode='pw@local-seb'
code=Code.get_from_string(nameCode)
calc=code.new_calc()
calc.label="PW test"
calc.description="First calculus on BaTiO3"
calc.set_resources({"num_machines": 1})
calc.set_max_wallclock_seconds(30*60)
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 = {
'xc-functional': 'LDA',
'xc-authors': 'CA',
'mesh-cutoff': '100.000 Ry',
'max-scfiterations': 30,
'dm-numberpulay': 4,
'dm-mixingweight': 0.1,
'dm-tolerance': 1.e-4,
'md-typeofrun': 'cg',
'md-numcgsteps': 8,
'md-maxcgdispl': '0.200 bohr',
'md-maxforcetol': '0.020 eV/Ang',
'geometry-must-converge': True,
'xml-write': True
}
# default basis
basis = {}
settings = {}
options = {
'resources': {
'num_machines': 1
},
'max_wallclock_seconds': args.max_wallclock_seconds,
}
run(
SiestaBaseWorkChain,
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 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 = {
'xc:functional': 'LDA',
'xc:authors': 'CA',
'spinpolarized': True,
'meshcutoff': '40.000 Ry',
'dm:numberpulay': 4,
'dm:mixingweight': 0.3,
'dm:tolerance': 1.e-3,
'max-scfiterations': 3,
'scf-must-converge': True,
'Solution-method': 'diagon',
'electronic-temperature': '25 meV',
'md-typeofrun': 'CG',
'md-numcgsteps': 0,
'md-maxcgdispl': '0.1 Ang',
'md-maxforcetol': '0.04 eV/Ang',
'writeforces': True,
'writecoorstep': True
}
basis = {
'pao-energy-shift': '300 meV',
'%block pao-basis-sizes': """
Si DZP """,
}
settings = {}
options = {
'resources': {
'num_machines': 1
},
'max_wallclock_seconds': args.max_wallclock_seconds,
}
run(
SiestaBaseWorkChain,
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 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
alat = 10.0 # angstrom
cell = [[alat, 0., 0.,],
[0., alat, 0.,],
[0., 0., alat,],
]
# Water molecule
# One of the H atoms is sligthy moved
s = StructureData(cell=cell)
s.append_atom(position=(0.000,0.000,0.00),symbols=['O'])
s.append_atom(position=(0.757,0.586,0.00),symbols=['H'])
s.append_atom(position=(-0.780,0.600,0.00),symbols=['H'])
structure = s
kpoints = KpointsData()
kpoints.set_kpoints_mesh(args.kpoints)
parameters = {
'meshcutoff': '80.000 Ry',
'dm:numberpulay': 4,
'dm:mixingweight': 0.2,
'dm:tolerance': 1.e-3,
'max-scfiterations': 30,
'scf-must-converge': True,
'geometry-must-converge': True,
'electronic-temperature': '25 meV',
'md-typeofrun': 'CG',
'md-numcgsteps': 6,
'md-maxcgdispl': '0.1 Ang',
'md-maxforcetol': '0.03 eV/Ang',
'xml:write': True
}
basis = {
'pao-energy-shift': '300 meV',
'pao-basis-size': 'DZP'
}
settings = {}
options = {
'resources': {
'num_machines': 1
},
'max_wallclock_seconds': args.max_wallclock_seconds,
}
run(
SiestaBaseWorkChain,
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),
)
from aiida.orm.data.array.kpoints import KpointsData
from aiida.orm.data.parameter import ParameterData
from aiida.workflows.user.base import VASPBaseWorkChain
VaspCalculation = CalculationFactory('vasp.vasp')
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),
},
'max_wallclock_seconds': 60 * 60 * 10,
})
wannier90_parameters = ParameterData(
dict={
'bands_plot': False,
'num_iter': 12,
'guiding_centres': True,
'num_wann': 4,
#'exclude_bands': exclude_bands,
# 'wannier_plot':True,
# 'wannier_plot_list':[1]
})
structure = load_node(152)
scf_kpoints = KpointsData()
scf_kpoints.set_kpoints_mesh([4, 4, 4])
nscf_kpoints = KpointsData()
nscf_kpoints.set_kpoints_mesh([4, 4, 4])
projections = List()
projections.extend(['As:s', 'As:p'])
wc = submit(
SimpleWannier90WorkChain,
pw_code=Code.get_from_string('pw_6.1@fidis'),
pw2wannier90_code=Code.get_from_string('pw2wannier90_6.1@fidis'),
wannier90_code=Code.get_from_string('wannier90_2.1@fidis'),
#orbital_projections=projections,
structure=structure,
pseudo_family=Str('SSSP_efficiency_v0.95'),
#wannier90_parameters=wannier90_parameters,
scf={
'parameters': scf_parameters,
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:
siesta_code = Code.get_from_string(args.siesta_codename)
except NotExistent as exception:
print "Execution failed: could not retrieve the code '{}'".format(
args.siesta_codename)
print "Exception report: {}".format(exception)
return
try:
gollum_code = Code.get_from_string(args.gollum_codename)
except NotExistent as exception:
print "Execution failed: could not retrieve the code '{}'".format(
args.gollum_codename)
print "Exception report: {}".format(exception)
return
protocol = Str(args.protocol)
###### Siesta structures ##############################
alat = 1.00 # Angstrom. Not passed to the fdf file
# Leads
cellle = [[
20.,
0.,
0.,
], [
0.,
20.,
0.,
], [
0.,
0.,
5.,
]]
sle = StructureData(cell=cellle)
for i in range(0, 2):
sle.append_atom(position=(0., 0., i * 2.5), symbols=['Au'])
if args.structure_em > 0:
structure_le = load_node(args.structure_le)
else:
structure_le = sle
# Extended molecule
cellem = [[
20.,
0.,
0.,
], [
0.,
20.,
0.,
], [
0.,
0.,
45.,
]]
sem = StructureData(cell=cellem)
for i in range(0, 18):
sem.append_atom(position=(0., 0., i * 2.5), symbols=['Au'])
if args.structure_em > 0:
structure_em = load_node(args.structure_em)
else:
structure_em = sem
###### Siesta k-ppoints ###############################
kpoints_le = KpointsData()
kpoints_le.set_kpoints_mesh([1, 1, 90])
kpoints_em = KpointsData()
kpoints_em.set_kpoints_mesh([1, 1, 10])
###### Gollum parameters ##############################
# The "atom" block is definied independently
pms = {
'NBlock leadp': """
2 2 -1
2 2 1 """,
'atom': """
1 2 2
0 0 10
2 2 2 """
}
parameters = ParameterData(dict=pms)
######
run(GollumSiestaWorkChain,
siesta_code=siesta_code,
gollum_code=gollum_code,
structure_le=structure_le,
structure_em=structure_em,
protocol=protocol,
kpoints_le=kpoints_le,
kpoints_em=kpoints_em,
parameters=parameters)
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 = {
'CONTROL': {
'restart_mode': 'from_scratch',
'calculation': 'scf',
'tstress': True,
},
'SYSTEM': {
'ecutwfc': 40.,
'ecutrho': 320.,
},
'ELECTRONS': {
'conv_thr': 1.e-10,
}
}
settings = {}
options = {
'resources': {
'num_machines': 1
},
'max_wallclock_seconds': args.max_wallclock_seconds,
}
run(
PwBaseWorkChain,
code=code,
structure=structure,
pseudo_family=Str(args.pseudo_family),
kpoints=kpoints,
parameters=ParameterData(dict=parameters),
settings=ParameterData(dict=settings),
options=ParameterData(dict=options),
max_iterations=Int(args.max_iterations),
)
