def test_keys(self):
"""
Test the edge case for tI.
"""
import seekpath
cell = [[4., 0., 0.], [0., 4., 0.], [0., 0., 4.]]
positions = [[0., 0., 0.], [0.5, 0.5, 0.5]]
atomic_numbers = [6, 6]
system = (cell, positions, atomic_numbers)
res = seekpath.get_explicit_k_path(system, recipe='hpkot')
known_keys = set([
'augmented_path', 'bravais_lattice', 'bravais_lattice_extended',
'conv_lattice', 'conv_positions', 'conv_types',
'explicit_kpoints_abs', 'explicit_kpoints_labels',
'explicit_kpoints_linearcoord', 'explicit_kpoints_rel',
'explicit_segments', 'has_inversion_symmetry',
'inverse_primitive_transformation_matrix', 'path', 'point_coords',
'primitive_lattice', 'primitive_positions',
'primitive_transformation_matrix', 'primitive_types',
'reciprocal_primitive_lattice', 'spacegroup_international',
'spacegroup_number', 'volume_original_wrt_conv',
'volume_original_wrt_prim'
])
missing_known_keys = known_keys - set(res.keys())
if missing_known_keys:
raise AssertionError("Some keys are not returned from the "
"get_explicit_k_path function: {}".format(
', '.join(missing_known_keys)))
def _bands_from_force_constants(data: ForceConstants,
q_distance: Quantity,
insert_gamma: bool = True,
frequencies_only: bool = False,
**calc_modes_kwargs
) -> Tuple[Union[QpointPhononModes,
QpointFrequencies],
XTickLabels, SplitArgs]:
structure = data.crystal.to_spglib_cell()
bandpath = seekpath.get_explicit_k_path(
structure,
reference_distance=q_distance.to('1 / angstrom').magnitude)
if insert_gamma:
_insert_gamma(bandpath)
x_tick_labels = _get_tick_labels(bandpath)
split_args = {'indices': _get_break_points(bandpath)}
print(
"Computing phonon modes: {n_modes} modes across {n_qpts} q-points"
.format(n_modes=(data.crystal.n_atoms * 3),
n_qpts=len(bandpath["explicit_kpoints_rel"])))
qpts = bandpath["explicit_kpoints_rel"]
if frequencies_only:
modes = data.calculate_qpoint_frequencies(qpts,
reduce_qpts=False,
**calc_modes_kwargs)
else:
modes = data.calculate_qpoint_phonon_modes(qpts,
reduce_qpts=False,
**calc_modes_kwargs)
return modes, x_tick_labels, split_args
def find_seekpath_data(self) -> None:
"""Get full information of seekpath band path. """
self._seekpath_data = \
seekpath.get_explicit_k_path(structure=self.cell,
symprec=self.symprec,
angle_tolerance=self.angle_tolerance,
with_time_reversal=self.time_reversal,
reference_distance=self.ref_distance)
lattice = self._seekpath_data["primitive_lattice"]
element_types = self._seekpath_data["primitive_types"]
species = [Element.from_Z(i) for i in element_types]
positions = self._seekpath_data["primitive_positions"]
self._band_primitive = Structure(lattice, species, positions)
def get_bandstructure(self, reference_distance=0.2):
import seekpath
path = seekpath.get_explicit_k_path(
self.get_cell(), reference_distance=reference_distance)
kpath = path['explicit_kpoints_rel']
explicit_labels = path['explicit_kpoints_labels']
bands = []
labels = []
for segment in path['segments']:
start_k, end_k = segment
labels.append(explicit_labels[start_k])
bands.append(kpath[start_k:end_k])
labels.append(explicit_labels[-1])
self.bands = bands
self.labels = labels
def structure_to_seekpath(structure: Structure,
time_reversal: bool = True,
ref_distance: float = BAND_REF_DIST,
recipe: str = 'hpkot',
threshold: float = 1e-7,
symprec: float = SYMMETRY_TOLERANCE,
angle_tolerance: float = ANGLE_TOL) -> dict:
"""
Return the full information for the band path of the given Structure class
object generated by seekpath.
Args:
structure (Structure):
Pymatgen Structure class object
time_reversal (bool):
If the time reversal symmetry exists
ref_distance (float):
Distance for the k-point mesh.
recipe (str):
See docstrings of seekpath.
threshold (float):
To use to verify if we are in edge case (see seekpath).
symprec (float):
Distance tolerance in cartesian coordinates Unit is compatible with
the cell.
angle_tolerance (float):
Angle tolerance used for symmetry analyzer.
Return:
Dict with some properties. See docstrings of seekpath.
"""
cell = structure_to_spglib_cell(structure)
res = seekpath.get_explicit_k_path(cell,
with_time_reversal=time_reversal,
reference_distance=ref_distance,
recipe=recipe,
threshold=threshold,
symprec=symprec,
angle_tolerance=angle_tolerance)
# If numpy.allclose is too strict in pymatgen.core.lattice __eq__,
# make almost_equal
if structure.lattice != seekpath_to_hpkot_structure(res).lattice:
logger.warning(
"Given structure is modified to be compatible with HPKOT k-path.")
return res
def _cell_change(self, change):
system = (np.array(change['new']), np.array(self.positions),
np.array(self.numbers))
res = seekpath.getpaths.get_path(system, with_time_reversal=False)
real_lattice = res["primitive_lattice"]
rec_lattice = np.array(
seekpath.hpkot.tools.get_reciprocal_cell_rows(real_lattice))
b1, b2, b3 = rec_lattice
faces_data = get_BZ(b1=b1, b2=b2, b3=b3)
response = {}
response["faces_data"] = faces_data
response["b1"] = b1.tolist()
response["b2"] = b2.tolist()
response["b3"] = b3.tolist()
## Convert to absolute
response["kpoints"] = {
k: (v[0] * b1 + v[1] * b2 + v[2] * b3).tolist()
for k, v in res["point_coords"].items()
}
response["kpoints_rel"] = {
k: [v[0], v[1], v[2]]
for k, v in res["point_coords"].items()
}
response["path"] = res["path"]
# It should use the same logic, so give the same cell as above
res_explicit = seekpath.get_explicit_k_path(system,
with_time_reversal=False)
for k in res_explicit:
if k == "segments" or k.startswith("explicit_"):
if isinstance(res_explicit[k], np.ndarray):
response[k] = res_explicit[k].tolist()
else:
response[k] = res_explicit[k]
if (np.sum(
np.abs(
np.array(res_explicit["reciprocal_primitive_lattice"]) -
np.array(res["reciprocal_primitive_lattice"]))) > 1.0e-7):
raise AssertionError("Got different reciprocal cells...")
self.jsondata = response
self.update_structure += 1
def test_keys(self): # pylint: disable=no-self-use
"""
Test the edge case for tI.
"""
import seekpath
cell = [[4.0, 0.0, 0.0], [0.0, 4.0, 0.0], [0.0, 0.0, 4.0]]
positions = [[0.0, 0.0, 0.0], [0.5, 0.5, 0.5]]
atomic_numbers = [6, 6]
system = (cell, positions, atomic_numbers)
res = seekpath.get_explicit_k_path(system, recipe="hpkot")
known_keys = set([
"augmented_path",
"bravais_lattice",
"bravais_lattice_extended",
"conv_lattice",
"conv_positions",
"conv_types",
"explicit_kpoints_abs",
"explicit_kpoints_labels",
"explicit_kpoints_linearcoord",
"explicit_kpoints_rel",
"explicit_segments",
"has_inversion_symmetry",
"inverse_primitive_transformation_matrix",
"path",
"point_coords",
"primitive_lattice",
"primitive_positions",
"primitive_transformation_matrix",
"primitive_types",
"reciprocal_primitive_lattice",
"spacegroup_international",
"spacegroup_number",
"volume_original_wrt_conv",
"volume_original_wrt_prim",
])
missing_known_keys = known_keys - set(res.keys())
if missing_known_keys:
raise AssertionError("Some keys are not returned from the "
"get_explicit_k_path function: {}".format(
", ".join(missing_known_keys)))
def automatic_linemode(self, structure,num_kpts=16):
all_kpath = seekpath.get_explicit_k_path((structure.lattice,
structure.positions,structure.atoms))
points = all_kpath['point_coords']
path = all_kpath['path']
kpoints,labels = [],[]
for p in path:
kpoints.append(points[p[0]])
kpoints.append(points[p[1]])
labels.append(p[0])
labels.append(p[1])
comment = 'Line_mode KPOINTS file, '+'num_kpts: '+str(num_kpts)
self.comment = comment
self._style = Kpoints.supported_modes.Line_mode
self.coord_type = 'Reciprocal'
self.kpts = kpoints
self.labels = labels
self.num_kpts = num_kpts
def get_json_for_visualizer(cell, relcoords, atomic_numbers):
system = (np.array(cell), np.array(relcoords), np.array(atomic_numbers))
res = seekpath.hpkot.get_path(system, with_time_reversal=False)
real_lattice = res['primitive_lattice']
#rec_lattice = np.linalg.inv(real_lattice).T # Missing 2pi!
rec_lattice = np.array(
seekpath.hpkot.tools.get_reciprocal_cell_rows(real_lattice))
b1, b2, b3 = rec_lattice
faces_data = brillouinzone.get_BZ(b1=b1, b2=b2, b3=b3)
response = {}
response['faces_data'] = faces_data
response['b1'] = b1.tolist()
response['b2'] = b2.tolist()
response['b3'] = b3.tolist()
## Convert to absolute
response['kpoints'] = {
k: (v[0] * b1 + v[1] * b2 + v[2] * b3).tolist()
for k, v in res['point_coords'].items()
}
response['path'] = res['path']
# It should use the same logic, so give the same cell as above
res_explicit = seekpath.get_explicit_k_path(system,
with_time_reversal=False)
for k in res_explicit:
if k == 'segments' or k.startswith('explicit_'):
if isinstance(res_explicit[k], np.ndarray):
response[k] = res_explicit[k].tolist()
else:
response[k] = res_explicit[k]
if np.sum(
np.abs(
np.array(res_explicit['reciprocal_primitive_lattice']) -
np.array(res['reciprocal_primitive_lattice']))) > 1.e-7:
raise AssertionError("Got different reciprocal cells...")
# Response for JS, and path_results
return response, res
def find_hpkot_primitive(structure: Structure,
symprec: float = SYMMETRY_TOLERANCE,
angle_tolerance: float = ANGLE_TOL
) -> Structure:
"""
Return a hpkot primitive unit cell.
Args:
structure (Structure):
Pymatgen Structure class object
symprec (float):
Distance tolerance in cartesian coordinates Unit is compatible with
the cell.
angle_tolerance (float):
Angle tolerance used for symmetry analyzer.
"""
cell = structure_to_spglib_cell(structure)
res = seekpath.get_explicit_k_path(structure=cell,
symprec=symprec,
angle_tolerance=angle_tolerance)
return seekpath_to_hpkot_structure(res)
def get_explicit_kpoints_path(structure, parameters):
"""
Return the kpoint path for band structure (in scaled and absolute
coordinates), given a crystal structure,
using the paths proposed in the various publications (see description
of the 'recipe' input parameter). The parameters are the same
as get get_explicit_k_path in __init__, but here all structures are
input and returned as AiiDA structures rather than tuples, and similarly
k-points-related information as a AiiDA KpointsData class.
:param structure: The AiiDA StructureData for which we want to obtain
the suggested path.
:param parameters: A dictionary whose key-value pairs are passed as
additional kwargs to the ``seekpath.get_explicit_k_path`` function.
:return: A dictionary with four nodes:
- ``explicit_kpoints``: a KpointsData with the (explicit) kpoints
(with labels set).
- ``parameters``: a Dict, whose content is
the same dictionary as returned by the ``seekpath.get_explicit_k_path`` function
(see `seekpath documentation <https://seekpath.readthedocs.io/>`_),
except that:
- ``conv_lattice``, ``conv_positions``, ``conv_types``
are removed and replaced by the ``conv_structure`` output node
- ``primitive_lattice``, ``primitive_positions``, ``primitive_types``
are removed and replaced by the `primitive_structure` output node
- ``reciprocal_primitive_lattice``, ``explicit_kpoints_abs``,
``explicit_kpoints_rel`` and ``explicit_kpoints_labels`` are removed
and replaced by the ``explicit_kpoints`` output node
- ``primitive_structure``: A StructureData with the primitive structure
- ``conv_structure``: A StructureData with the primitive structure
"""
# pylint: disable=too-many-locals
from aiida.tools.data.structure import spglib_tuple_to_structure, structure_to_spglib_tuple
structure_tuple, kind_info, kinds = structure_to_spglib_tuple(structure)
result = {}
rawdict = seekpath.get_explicit_k_path(structure=structure_tuple,
**parameters)
# Replace primitive structure with AiiDA StructureData
primitive_lattice = rawdict.pop('primitive_lattice')
primitive_positions = rawdict.pop('primitive_positions')
primitive_types = rawdict.pop('primitive_types')
primitive_tuple = (primitive_lattice, primitive_positions, primitive_types)
primitive_structure = spglib_tuple_to_structure(primitive_tuple, kind_info,
kinds)
# Replace conv structure with AiiDA StructureData
conv_lattice = rawdict.pop('conv_lattice')
conv_positions = rawdict.pop('conv_positions')
conv_types = rawdict.pop('conv_types')
conv_tuple = (conv_lattice, conv_positions, conv_types)
conv_structure = spglib_tuple_to_structure(conv_tuple, kind_info, kinds)
# Remove reciprocal_primitive_lattice, recalculated by kpoints class
rawdict.pop('reciprocal_primitive_lattice')
kpoints_abs = rawdict.pop('explicit_kpoints_abs')
kpoints_labels = rawdict.pop('explicit_kpoints_labels')
# set_kpoints expects labels like [[0,'X'],[34,'L'],...], so generate it here skipping empty labels
labels = [[idx, label] for idx, label in enumerate(kpoints_labels)
if label]
kpoints = KpointsData()
kpoints.set_cell_from_structure(primitive_structure)
kpoints.set_kpoints(kpoints_abs, cartesian=True, labels=labels)
result['parameters'] = Dict(dict=rawdict)
result['explicit_kpoints'] = kpoints
result['primitive_structure'] = primitive_structure
result['conv_structure'] = conv_structure
return result
def structure2input(structure, prefix, dk_path, dq_grid, pseudo_kind,
pseudo_dir, queue, rel):
if pseudo_kind == "sg15":
if rel:
from sg15_rel import pseudo_dict, ecutwfc_dict, ecutrho_dict, valence_dict, atomwfc_dict
else:
from sg15 import pseudo_dict, ecutwfc_dict, ecutrho_dict, valence_dict, atomwfc_dict
elif pseudo_kind == "pslibrary":
if rel:
from pslibrary_rel import pseudo_dict, ecutwfc_dict, ecutrho_dict, valence_dict, atomwfc_dict
else:
from pslibrary import pseudo_dict, ecutwfc_dict, ecutrho_dict, valence_dict, atomwfc_dict
else:
from sssp import pseudo_dict, ecutwfc_dict, ecutrho_dict, valence_dict, atomwfc_dict
#
# Band path and primitive lattice
#
frac_coord2 = numpy.array(structure.frac_coords)
for ipos in range(len(frac_coord2)):
for iaxis in range(3):
coord3 = frac_coord2[ipos, iaxis] * 6.0
if abs(round(coord3) - coord3) < 0.001:
frac_coord2[ipos, iaxis] = float(round(coord3)) / 6.0
#
skp = seekpath.get_explicit_k_path(
(structure.lattice.matrix, frac_coord2,
[pymatgen.Element(str(spc)).number for spc in structure.species]),
reference_distance=dk_path)
#
# Lattice information
#
bvec = skp["reciprocal_primitive_lattice"]
atom = [str(get_el_sp(iat)) for iat in skp["primitive_types"]]
typ = set(atom)
#
# WFC and Rho cutoff
#
ecutwfc = 0.0
ecutrho = 0.0
for ityp in typ:
if ecutwfc < ecutwfc_dict[str(ityp)]:
ecutwfc = ecutwfc_dict[str(ityp)]
if ecutrho < ecutrho_dict[str(ityp)]:
ecutrho = ecutrho_dict[str(ityp)]
#
# k and q grid
#
nq = numpy.zeros(3, numpy.int_)
for ii in range(3):
norm = numpy.sqrt(numpy.dot(bvec[ii][:], bvec[ii][:]))
nq[ii] = round(norm / dq_grid)
print(norm)
print("Coarse grid : ", nq[0], nq[1], nq[2])
#
# Band path
#
print("Band path")
for ipath in range(len(skp["path"])):
start = skp["explicit_segments"][ipath][0]
final = skp["explicit_segments"][ipath][1] - 1
print("%5d %8s %10.5f %10.5f %10.5f %8s %10.5f %10.5f %10.5f" %
(final - start + 1, skp["explicit_kpoints_labels"][start],
skp["explicit_kpoints_rel"][start][0],
skp["explicit_kpoints_rel"][start][1],
skp["explicit_kpoints_rel"][start][2],
skp["explicit_kpoints_labels"][final],
skp["explicit_kpoints_rel"][final][0],
skp["explicit_kpoints_rel"][final][1],
skp["explicit_kpoints_rel"][final][2]))
#
# Number of electrons
#
nbnd = 0
for iat in atom:
nbnd += valence_dict[iat]
if rel:
nbnd *= 2
#
# Shell scripts
#
structure2 = pymatgen.Structure(skp["primitive_lattice"],
skp["primitive_types"],
skp["primitive_positions"])
spg_analysis = SpacegroupAnalyzer(structure2)
middle = spg_analysis.get_ir_reciprocal_mesh(mesh=(nq[0] * 2, nq[1] * 2,
nq[2] * 2),
is_shift=(0, 0, 0))
dense = spg_analysis.get_ir_reciprocal_mesh(mesh=(nq[0] * 4, nq[1] * 4,
nq[2] * 4),
is_shift=(0, 0, 0))
print("Number of irreducible k : ", len(middle), len(dense))
write_sh(len(middle), len(dense), len(skp["explicit_kpoints_rel"]), atom,
prefix, atomwfc_dict, queue)
#
# rx.in, scf.in, nscf.in, band.in , nscf_w.in, nscf_r.in
#
write_pwx(prefix, skp, pseudo_dir, ecutwfc, ecutrho, pseudo_dict, nq, nbnd,
rel)
#
# ph.in, elph.in, epmat.in, phdos.in, rpa.in, scdft.in
#
write_ph(prefix, nq, ecutwfc, nbnd)
#
# bands.in, pp.in, proj.in, pw2wan.in, q2r.in
#
write_pp(prefix)
#
# band.gp, {prefix}.win, respack.in, disp.in
#
write_wannier(prefix, skp, nbnd, nq)
#
# openmx.in : Input file for openmx
#
if not os.path.isfile("openmx.in"):
write_openmx(prefix, skp, nq, rel)
# PyMatGen structure from CIF file
#
structure = pymatgen.Structure.from_file(cif_file)
structure.remove_oxidation_states()
#
# Refine 3-folded Wyckoff position
#
frac_coord2 = numpy.array(structure.frac_coords)
for ipos in range(len(frac_coord2)):
for iaxis in range(3):
coord3 = frac_coord2[ipos, iaxis] * 6.0
if abs(round(coord3) - coord3) < 0.001:
frac_coord2[ipos, iaxis] = float(round(coord3)) / 6.0
#
# Disordered structure raises AttributeError. So it is skipped.
#
try:
skp = seekpath.get_explicit_k_path(
(structure.lattice.matrix, frac_coord2, [
pymatgen.Element(str(spc)).number
for spc in structure.species
]))
structure2 = pymatgen.Structure(skp["primitive_lattice"],
skp["primitive_types"],
skp["primitive_positions"])
except AttributeError:
print("Fractional occupancy, may be disordered.")
continue
#
print(cif_file[0:len(cif_file) - 4], structure2.volume)
Colours = [(0, 0, 255), (128, 0, 255), (255, 0, 255), (255, 0, 128), (255, 0, 0), (255, 128, 0)];
#EndRegion
#Region:BandPathGeneration
structure = io.read(StructureFile)
numbers = structure.get_atomic_numbers()
inp = (structure.cell,structure.get_scaled_positions(),numbers)
BandPaths = None # Set up k-path explicitly here if not using SeeKpath
if UseSeeKpath:
explicit_data = seekpath.get_explicit_k_path(inp,reference_distance=0.1)
k_labels = (explicit_data['explicit_kpoints_labels'])
kpoint_labels = []
for label in k_labels:
label = r"$\Gamma$" if label == 'GAMMA' else label
kpoint_labels.append(label)
kpoint_positions = (explicit_data['explicit_kpoints_rel'])
BandPath = [(tuple(pos), lab) for lab,pos in zip(kpoint_labels,kpoint_positions) if lab != '']
BandPaths = [BandPath[i:j] for i, j in zip([0]+BandPathBreaks, BandPathBreaks+[None])]
if BandPaths == None:
sys.exit('You need to set up the BandPath explicitly or use seeKpath to do it for you!')
new_data = seekpath.get_path(inp)
ReciprocalLatticeVectors = new_data['reciprocal_primitive_lattice']
import seekpath
from pymatgen import Structure
import os
os.chdir('/home/ksrc5/FTJ/bfo/sto-bfo')
s = Structure.from_file('POSCAR')
skp = seekpath.get_explicit_k_path(s)
print(skp)
help=
"Turns off time reversal symmetry, if it is off and there is no centrosymmetry, additional lines are needed."
)
(options, args) = parser.parse_args()
structure = io.read(options.input_file)
numbers = structure.get_atomic_numbers()
inp = (structure.cell, structure.get_scaled_positions(), numbers)
# Turn off time reversal symmetry if necessary
if not options.time_reversal:
tr = True
else:
tr = False
explicit_data = seekpath.get_explicit_k_path(
inp, with_time_reversal=tr, reference_distance=options.resolution)
kpath = explicit_data['explicit_kpoints_rel']
weight = 0.
with open(options.output_file, 'a') as outfile:
for point in kpath:
outfile.write("%8.6f %8.6f %8.6f %5.3f\n" %
(point[0], point[1], point[2], weight))
print('Output written to {}'.format(options.output_file))
# Write new conventions cell, to ensure compliance with the kpoints
new_data = seekpath.get_path(inp)
new_cell = ase.Atoms(positions=new_data['conv_positions'],
def get_seekpath_kpoint_path(doc,
standardize=True,
explicit=True,
spacing=0.01,
threshold=1e-7,
debug=False,
symmetry_tol=None):
""" Return the conventional kpoint path of the relevant crystal system
according to the definitions by "HKPOT" in
Comp. Mat. Sci. 128, 2017:
http://dx.doi.org/10.1016/j.commatsci.2016.10.015
Parameters:
doc (dict/tuple): matador doc or spglib tuple to find kpoint path for.
Keyword arguments:
spacing (float): desired kpoint spacing
threshold (float): internal seekpath threshold
symmetry_tol (float): spglib symmetry tolerance
Returns:
dict: standardized version of input doc
list: list of kpoint positions
dict: full dictionary of all seekpath results
"""
try:
from seekpath import get_explicit_k_path, get_path
except ImportError:
raise ImportError(
"SeeK-Path dependency missing, please install it with `pip install seekpath`."
)
if symmetry_tol is None:
symmetry_tol = 1e-5
if isinstance(doc, tuple):
spg_structure = doc
else:
if standardize:
spg_structure = doc2spg(
standardize_doc_cell(doc, symprec=symmetry_tol))
else:
spg_structure = doc2spg(doc)
if explicit:
seekpath_results = get_explicit_k_path(spg_structure,
reference_distance=spacing,
with_time_reversal=True,
symprec=symmetry_tol,
threshold=threshold)
kpt_path = seekpath_results['explicit_kpoints_rel']
else:
seekpath_results = get_path(spg_structure)
kpt_path = []
primitive_doc = dict()
primitive_doc['lattice_cart'] = seekpath_results['primitive_lattice']
primitive_doc['positions_frac'] = seekpath_results['primitive_positions']
primitive_doc['atom_types'] = [
str(elements[i]) for i in seekpath_results['primitive_types']
]
primitive_doc['num_atoms'] = len(primitive_doc['atom_types'])
primitive_doc['lattice_abc'] = cart2abc(primitive_doc['lattice_cart'])
primitive_doc['cell_volume'] = cart2volume(primitive_doc['lattice_cart'])
if debug:
print('Found lattice type {}'.format(
seekpath_results['bravais_lattice_extended']))
print('Old lattice:\n', np.asarray(doc['lattice_cart']))
print('Contained {} atoms'.format(doc['num_atoms']))
print('New lattice:\n', np.asarray(primitive_doc['lattice_cart']))
print('Contains {} atoms'.format(primitive_doc['num_atoms']))
print('k-point path contains {} points.'.format(len(kpt_path)))
if 'site_occupancy' in doc:
if min(doc['site_occupancy']) < 1 - EPS:
print('Ignoring any site occupancy found in this cell.')
primitive_doc['site_occupancy'] = [
1 for atom in primitive_doc['atom_types']
]
return primitive_doc, kpt_path, seekpath_results
def __init__(self, cell, positions, numbers, face_color=True):
if type(cell) == np.ndarray:
cell = cell.tolist()
if type(positions) == np.ndarray:
positions = positions.tolist()
if type(numbers) == np.ndarray:
numbers = numbers.tolist()
super().__init__(cell=cell,
positions=positions,
numbers=numbers,
face_color=face_color)
system = (np.array(cell), np.array(positions), np.array(numbers))
res = seekpath.getpaths.get_path(system, with_time_reversal=False)
real_lattice = res["primitive_lattice"]
rec_lattice = np.array(
seekpath.hpkot.tools.get_reciprocal_cell_rows(real_lattice))
b1, b2, b3 = rec_lattice
faces_data = get_BZ(b1=b1, b2=b2, b3=b3)
response = {}
response["faces_data"] = faces_data
response["b1"] = b1.tolist()
response["b2"] = b2.tolist()
response["b3"] = b3.tolist()
## Convert to absolute
response["kpoints"] = {
k: (v[0] * b1 + v[1] * b2 + v[2] * b3).tolist()
for k, v in res["point_coords"].items()
}
response["kpoints_rel"] = {
k: [v[0], v[1], v[2]]
for k, v in res["point_coords"].items()
}
response["path"] = res["path"]
# It should use the same logic, so give the same cell as above
res_explicit = seekpath.get_explicit_k_path(system,
with_time_reversal=False)
for k in res_explicit:
if k == "segments" or k.startswith("explicit_"):
if isinstance(res_explicit[k], np.ndarray):
response[k] = res_explicit[k].tolist()
else:
response[k] = res_explicit[k]
if (np.sum(
np.abs(
np.array(res_explicit["reciprocal_primitive_lattice"]) -
np.array(res["reciprocal_primitive_lattice"]))) > 1.0e-7):
raise AssertionError("Got different reciprocal cells...")
self.jsondata = response
self.kpts = self.jsondata['explicit_kpoints_abs']
self.path_vectors = self.jsondata['path']
self.update_structure = 0
"-r",
"--resolution",
action="store",
type="float",
dest="resolution",
default=0.1,
help=
"a reference target distance between neighboring k-points in the path, in units of 1/ang."
)
(options, args) = parser.parse_args()
structure = io.read(options.input_file)
numbers = structure.get_atomic_numbers()
inp = (structure.cell, structure.get_scaled_positions(), numbers)
explicit_data = seekpath.get_explicit_k_path(
inp, reference_distance=options.resolution)
kpath = explicit_data['explicit_kpoints_rel']
weight = 0.
with open(options.output_file, 'a') as outfile:
for point in kpath:
outfile.write("%8.6f %8.6f %8.6f %5.3f\n" %
(point[0], point[1], point[2], weight))
print('Output written to {}'.format(options.output_file))
# Write new conventions cell, to ensure compliance with the kpoints
new_data = seekpath.get_path(inp)
new_cell = ase.Atoms(positions=new_data['conv_positions'],
# #----------------------------
# print("Structure information [spglib]:")
# spacegroup = spglib.get_spacegroup(inp, symprec=float(options.symprec))
# print("\tSpace group number: %s" % spacegroup.split()[1])
# print("\tSpace international symbol: %s" % spacegroup.split()[0])
# Turn off time reversal symmetry if necessary
if not options.time_reversal:
tr = True
else:
tr = False
# get K-points
explicit_data = seekpath.get_explicit_k_path(inp,
with_time_reversal=tr,
reference_distance=float(
options.resolution),
symprec=float(options.symprec))
kpath = explicit_data['explicit_kpoints_rel']
seg = np.array(explicit_data['explicit_segments'])
labels = np.array(explicit_data['explicit_kpoints_labels'])
# return symmetry
if options.verbose == True:
print("Structure information:")
print("\tPrecision for finding symmetry: %8.6f \AA" % options.symprec)
print("\tSpace group number: %s" % explicit_data['spacegroup_number'])
print("\tSpace international symbol: %s" %
explicit_data['spacegroup_international'])
print("\nTime reversal symmtery: %s" % tr)
