def sub_create_bands_data(cls, user=None):
from aiida.orm.data.array.kpoints import KpointsData
from aiida.orm import JobCalculation
from aiida.orm.data.structure import StructureData
from aiida.common.links import LinkType
from aiida.orm.data.array.bands import BandsData
import numpy
s = StructureData(cell=((2., 0., 0.), (0., 2., 0.), (0., 0., 2.)))
s.append_atom(position=(0., 0., 0.),
symbols=['Ba', 'Ti'],
weights=(1., 0.),
name='mytype')
if user is not None:
s.dbnode.user = user._dbuser
s.store()
c = JobCalculation(computer=cls.computer,
resources={
'num_machines': 1,
'num_mpiprocs_per_machine': 1
})
if user is not None:
c.dbnode.user = user._dbuser
c.store()
c.add_link_from(s, "S1", LinkType.INPUT)
c._set_state(calc_states.RETRIEVING)
# define a cell
alat = 4.
cell = numpy.array([
[alat, 0., 0.],
[0., alat, 0.],
[0., 0., alat],
])
k = KpointsData()
k.set_cell(cell)
k.set_kpoints_path()
if user is not None:
k.dbnode.user = user._dbuser
k.store()
b = BandsData()
b.set_kpointsdata(k)
input_bands = numpy.array(
[numpy.ones(4) * i for i in range(k.get_kpoints().shape[0])])
b.set_bands(input_bands, units='eV')
if user is not None:
b.dbnode.user = user._dbuser
b.store()
b.add_link_from(c, link_type=LinkType.CREATE)
return b
def connect_structure_bands(structure):
alat = 4.
cell = np.array([
[alat, 0., 0.],
[0., alat, 0.],
[0., 0., alat],
])
k = KpointsData()
k.set_cell(cell)
k.set_kpoints_path([('G', 'M', 2)])
b = BandsData()
b.set_kpointsdata(k)
b.set_bands([[1.0, 2.0], [3.0, 4.0]])
k.store()
b.store()
return b
def run_bands(self):
"""
Run the SiestaBaseWorkChain in scf+bands mode on the primitive cell of the relaxed input structure
"""
self.report('Running bands calculation')
try:
structure = self.ctx.workchain_relax.out.output_structure
except:
self.abort_nowait('failed to get the output structure from the relaxation run')
return
self.ctx.structure_relaxed_primitive = structure
inputs = dict(self.ctx.inputs)
kpoints_mesh = KpointsData()
kpoints_mesh.set_cell_from_structure(self.ctx.structure_relaxed_primitive)
kpoints_mesh.set_kpoints_mesh_from_density(
distance=self.ctx.protocol['kpoints_mesh_density'],
offset=self.ctx.protocol['kpoints_mesh_offset'])
bandskpoints = KpointsData()
bandskpoints.set_cell(structure.cell, structure.pbc)
bandskpoints.set_kpoints_path(kpoint_distance = 0.05)
self.ctx.kpoints_path = bandskpoints
# Final input preparation, wrapping dictionaries in ParameterData nodes
inputs['bandskpoints'] = self.ctx.kpoints_path
inputs['kpoints'] = kpoints_mesh
inputs['structure'] = self.ctx.structure_relaxed_primitive
inputs['parameters'] = ParameterData(dict=inputs['parameters'])
inputs['basis'] = ParameterData(dict=inputs['basis'])
inputs['settings'] = ParameterData(dict=inputs['settings'])
running = submit(SiestaBaseWorkChain, **inputs)
self.report('launching SiestaBaseWorkChain<{}> in scf+bands mode'.format(running.pid))
return ToContext(workchain_bands=running)
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),
)
