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 _legacy_get_explicit_kpoints_path(structure, **kwargs):
"""
Call the get_explicit_kpoints_path of the legacy implementation
:param structure: a StructureData node
:param float kpoint_distance: parameter controlling the distance between kpoints. Distance is
given in crystal coordinates, i.e. the distance is computed in the space of b1, b2, b3.
The distance set will be the closest possible to this value, compatible with the requirement
of putting equispaced points between two special points (since extrema are included).
:param bool cartesian: if set to true, reads the coordinates eventually passed in value as cartesian coordinates
:param float epsilon_length: threshold on lengths comparison, used to get the bravais lattice info
:param float epsilon_angle: threshold on angles comparison, used to get the bravais lattice info
"""
args_recognized = [
'value', 'kpoint_distance', 'cartesian', 'epsilon_length',
'epsilon_angle'
]
args_unknown = set(kwargs).difference(args_recognized)
if args_unknown:
raise ValueError("unknown arguments {}".format(args_unknown))
point_coords, path, bravais_info, explicit_kpoints, labels = legacy.get_explicit_kpoints_path(
cell=structure.cell, pbc=structure.pbc, **kwargs)
kpoints = KpointsData()
kpoints.set_cell(structure.cell)
kpoints.set_kpoints(explicit_kpoints)
kpoints.labels = labels
parameters = {
'bravais_info': bravais_info,
'point_coords': point_coords,
'path': path,
}
return {
'parameters': ParameterData(dict=parameters),
'explicit_kpoints': 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:
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),
)
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:
vibra_code = Code.get_from_string(args.vibra_codename)
except NotExistent as exception:
print "Execution failed: could not retrieve the code '{}'".format(
args.stm_codename)
print "Exception report: {}".format(exception)
return
protocol = Str(args.protocol)
# Structure. Bulk silicon
SuperCell_1 = 1
SuperCell_2 = 1
SuperCell_3 = 1
scnumbers = np.array([SuperCell_1, SuperCell_2, SuperCell_3])
scarray = ArrayData()
scarray.set_array('sca', scnumbers)
alat = 5.43 # Angstrom. Not passed to the fdf file (only for internal use)
cell = [[
0.,
alat / 2,
alat / 2,
], [
alat / 2,
0.,
alat / 2,
], [
alat / 2,
alat / 2,
0.,
]]
pf = alat * 0.125
na = 2
x0 = [[pf, pf, pf], [-pf, -pf, -pf]]
s1 = StructureData(cell=cell)
for i in range(na):
s1.append_atom(position=(x0[i][0], x0[i][1], x0[i][2]), symbols=['Si'])
bandskpoints = KpointsData()
kpp = [(1, 1., 1., 1.), (15, 0., 0.5, 0.5), (25, 0., 0., 0.),
(20, 0.5, 0.5, 0.5), (20, 0., 0.5, 0.5), (15, 0.25, 0.5, 0.75),
(20, 0.5, 0.5, 0.5)]
lpp = [[0, '\Gamma'], [1, 'X'], [2, '\Gamma'], [3, 'L'], [4, 'X'],
[5, 'W'], [6, 'L']]
bandskpoints.set_cell(s1.cell, s1.pbc)
bandskpoints.set_kpoints(kpp, labels=lpp)
if args.structure > 0:
structure = load_node(args.structure)
else:
structure = s1
run(SiestaVibraWorkChain,
code=code,
vibra_code=vibra_code,
scarray=scarray,
structure=structure,
protocol=protocol,
bandskpoints=bandskpoints)
