def test_kpointlist(self):
"""Test KpointList."""
lattice = self.lattice
frac_coords = [0, 0, 0, 1 / 2, 1 / 2, 1 / 2, 1 / 3, 1 / 3, 1 / 3]
weights = [0.1, 0.2, 0.7]
klist = KpointList(lattice, frac_coords, weights=weights)
self.serialize_with_pickle(klist, protocols=[-1])
self.assertMSONable(klist, test_if_subclass=False)
assert klist.sum_weights() == 1
assert len(klist) == 3
for i, kpoint in enumerate(klist):
assert kpoint in klist
assert klist.count(kpoint) == 1
assert klist.find(kpoint) == i
# Changing the weight of the Kpoint object should change the weights of klist.
for kpoint in klist:
kpoint.set_weight(1.0)
assert np.all(klist.weights == 1.0)
# Test find_closest
iclose, kclose, dist = klist.find_closest([0, 0, 0])
assert iclose == 0 and dist == 0.
iclose, kclose, dist = klist.find_closest(
Kpoint([0.001, 0.002, 0.003], klist.reciprocal_lattice))
assert iclose == 0
self.assert_almost_equal(dist, 0.001984943324127921)
frac_coords = [0, 0, 0, 1 / 2, 1 / 3, 1 / 3]
other_klist = KpointList(lattice, frac_coords)
# Test __add__
add_klist = klist + other_klist
for k in itertools.chain(klist, other_klist):
assert k in add_klist
assert add_klist.count([0, 0, 0]) == 2
# Remove duplicated k-points.
add_klist = add_klist.remove_duplicated()
self.assertTrue(add_klist.count([0, 0, 0]) == 1)
self.assertTrue(len(add_klist) == 4)
self.assertTrue(add_klist == add_klist.remove_duplicated())
def __init__(self, filepath):
super(Fold2BlochNcfile, self).__init__(filepath)
self.reader = ElectronsReader(filepath)
# Initialize the electron bands from file.
# Spectral weights are dimensioned with `nss`
# Fortran arrays.
# nctkarr_t("reduced_coordinates_of_unfolded_kpoints", "dp", "number_of_reduced_dimensions, nk_unfolded")
# nctkarr_t("unfolded_eigenvalues", "dp", "max_number_of_states, nk_unfolded, number_of_spins")
# nctkarr_t("spectral_weights", "dp", "max_number_of_states, nk_unfolded, nsppol_times_nspinor")
self._ebands = self.reader.read_ebands()
self.nss = max(self.nsppol, self.nspinor)
self.fold_matrix = self.reader.read_value("fold_matrix")
# Compute direct lattice of the primitive cell from fold_matrix.
if is_diagonal(self.fold_matrix):
folds = np.diagonal(self.fold_matrix)
self.pc_lattice = Lattice(
(self.structure.lattice.matrix.T * (1.0 / folds)).T.copy())
else:
raise NotImplementedError("non diagonal fold_matrix: %s" %
str(self.fold_matrix))
# Read fold2bloch output data.
self.uf_kfrac_coords = self.reader.read_value(
"reduced_coordinates_of_unfolded_kpoints")
self.uf_kpoints = KpointList(self.pc_lattice.reciprocal_lattice,
self.uf_kfrac_coords)
self.uf_nkpt = len(self.uf_kpoints)
def __init__(self, filepath):
super(ScrReader, self).__init__(filepath)
# Read and store important quantities.
self.structure = self.read_structure()
qred_coords = self.read_value("qpoints_dielectric_function")
self.qpoints = KpointList(self.structure.reciprocal_lattice,
qred_coords)
self.wpts = self.read_value("frequencies_dielectric_function",
cmode="c")
def test_kpointlist(self):
"""Test KpointList."""
lattice = self.lattice
frac_coords = [0, 0, 0, 1/2, 1/2, 1/2, 1/3, 1/3, 1/3]
weights = [0.1, 0.2, 0.7]
klist = KpointList(lattice, frac_coords, weights=weights)
self.assertTrue(klist.sum_weights() == 1)
self.assertTrue(len(klist) == 3)
for i, kpoint in enumerate(klist):
self.assertTrue(kpoint in klist)
self.assertTrue(klist.count(kpoint) == 1)
self.assertTrue(klist.find(kpoint) == i)
# Changing the weight of the Kpoint object should change the weights of klist.
for kpoint in klist: kpoint.set_weight(1.0)
self.assertTrue(np.all(klist.weights == 1.0))
frac_coords = [0, 0, 0, 1/2, 1/3, 1/3]
other_klist = KpointList(lattice, frac_coords)
# Test __add__
add_klist = klist + other_klist
for k in itertools.chain(klist, other_klist):
self.assertTrue(k in add_klist)
self.assertTrue(add_klist.count([0,0,0]) == 2)
# Remove duplicated k-points.
add_klist = add_klist.remove_duplicated()
self.assertTrue(add_klist.count([0,0,0]) == 1)
self.assertTrue(len(add_klist) == 4)
self.assertTrue(add_klist == add_klist.remove_duplicated())
def from_file(cls, filepath):
"""Create the object from a netCDF file."""
with PHBST_Reader(filepath) as r:
structure = r.read_structure()
# Build the list of q-points
qpoints = KpointList(structure.reciprocal_lattice,
frac_coords=r.read_qredcoords(),
weights=r.read_qweights(),
names=None)
return cls(structure=structure,
qpoints=qpoints,
phfreqs=r.read_phfreqs(),
phdispl_cart=r.read_phdispl_cart())
def __init__(self, filepath):
super(DdbFile, self).__init__(filepath)
self._header = self._parse_header()
self._structure = Structure.from_abivars(**self.header)
# Add Spacegroup (needed in guessed_ngkpt)
# FIXME: has_timerev is always True
spgid, has_timerev, h = 0, True, self.header
self._structure.set_spacegroup(SpaceGroup(spgid, h.symrel, h.tnons, h.symafm, has_timerev))
frac_coords = self._read_qpoints()
self._qpoints = KpointList(self.structure.reciprocal_lattice, frac_coords, weights=None, names=None)
# Guess q-mesh
self._guessed_ngqpt = self._guess_ngqpt()
def __init__(self, filepath):
super(ScrReader, self).__init__(filepath)
# Read and store important quantities.
self.structure = self.read_structure()
qfrac_coords = self.read_value("qpoints_dielectric_function")
self.kpoints = KpointList(self.structure.reciprocal_lattice,
qfrac_coords)
self.wpoints = self.read_value("frequencies_dielectric_function",
cmode="c")
self.ng = self.read_dimvalue(
"number_of_coefficients_dielectric_function")
# Find number of real/imaginary frequencies.
self.nw = len(self.wpoints)
self.nrew = self.nw
self.nimw = 0
for i, w in enumerate(self.wpoints):
if np.iscomplex(w):
self.nrew = i
break
self.nimw = self.nw - self.nrew
if self.nimw and not np.all(np.iscomplex(
self.wpoints[self.nrew + 1:])):
raise ValueError(
"wpoints should contained real points packed in the first positions\n"
"followed by imaginary points but got: %s" % str(self.wpoints))
# Define self.netcdf_name from the data available on file.
nfound = 0
netcdf_names = [
"polarizability", "dielectric_function",
"inverse_dielectric_function"
]
for tryname in netcdf_names:
if tryname in self.rootgrp.variables:
self.netcdf_name = tryname
nfound += 1
if nfound == 0:
raise RuntimeError("Cannot find `%s` in netcdf file" %
str(netcdf_names))
if nfound > 1:
raise RuntimeError(
"Find multiple netcdf arrays (%s) in netcdf file!" %
str(netcdf_names))
def qpoints(self):
"""List of q-points (ndarray)."""
# Read the fractional coordinates and convert them to KpointList.
return KpointList(self.structure.reciprocal_lattice,
frac_coords=self.read_value("qpoints"))
def qpoints(self):
return KpointList(self.structure.reciprocal_lattice,
frac_coords=self.reader.read_value("qpts"))
def test_kpointlist(self):
"""Test KpointList."""
lattice = self.lattice
frac_coords = [0, 0, 0, 1 / 2, 1 / 2, 1 / 2, 1 / 3, 1 / 3, 1 / 3]
weights = [0.1, 0.2, 0.7]
klist = KpointList(lattice, frac_coords, weights=weights)
repr(klist)
str(klist)
self.serialize_with_pickle(klist, protocols=[-1])
self.assertMSONable(klist, test_if_subclass=False)
self.assert_equal(klist.frac_coords.flatten(), frac_coords)
self.assert_equal(klist.get_cart_coords(),
np.reshape([k.cart_coords for k in klist], (-1, 3)))
assert klist.sum_weights() == 1
assert len(klist) == 3
for i, kpoint in enumerate(klist):
assert kpoint in klist
assert klist.count(kpoint) == 1
assert klist.find(kpoint) == i
# Changing the weight of the Kpoint object should change the weights of klist.
for kpoint in klist:
kpoint.set_weight(1.0)
assert np.all(klist.weights == 1.0)
# Test find_closest
iclose, kclose, dist = klist.find_closest([0, 0, 0])
assert iclose == 0 and dist == 0.
iclose, kclose, dist = klist.find_closest(
Kpoint([0.001, 0.002, 0.003], klist.reciprocal_lattice))
assert iclose == 0
self.assert_almost_equal(dist, 0.001984943324127921)
# Compute mapping k_index --> (k + q)_index, g0
k2kqg = klist.get_k2kqg_map((0, 0, 0))
assert all(ikq == ik for ik, (ikq, g0) in k2kqg.items())
k2kqg = klist.get_k2kqg_map((1 / 2, 1 / 2, 1 / 2))
assert len(k2kqg) == 2
assert k2kqg[0][0] == 1 and np.all(k2kqg[0][1] == 0)
assert k2kqg[1][0] == 0 and np.all(k2kqg[1][1] == 1)
frac_coords = [0, 0, 0, 1 / 2, 1 / 3, 1 / 3]
other_klist = KpointList(lattice, frac_coords)
# Test __add__
add_klist = klist + other_klist
for k in itertools.chain(klist, other_klist):
assert k in add_klist
assert add_klist.count([0, 0, 0]) == 2
# Remove duplicated k-points.
add_klist = add_klist.remove_duplicated()
assert add_klist.count([0, 0, 0]) == 1
assert len(add_klist) == 4
assert add_klist == add_klist.remove_duplicated()
def __init__(self, path):
self.ks_bands = ElectronBands.from_file(path)
self.nsppol = self.ks_bands.nsppol
super(SigresReader, self).__init__(path)
try:
self.nomega_r = self.read_dimvalue("nomega_r")
except self.Error:
self.nomega_r = 0
#self.nomega_i = self.read_dim("nomega_i")
# Save important quantities needed to simplify the API.
self.structure = self.read_structure()
self.gwcalctyp = self.read_value("gwcalctyp")
self.usepawu = self.read_value("usepawu")
# 1) The K-points of the homogeneous mesh.
self.ibz = self.ks_bands.kpoints
# 2) The K-points where QPState corrections have been calculated.
gwred_coords = self.read_redc_gwkpoints()
self.gwkpoints = KpointList(self.structure.reciprocal_lattice, gwred_coords)
# minbnd[nkptgw,nsppol] gives the minimum band index computed
# Note conversion between Fortran and python convention.
self.gwbstart_sk = self.read_value("minbnd") - 1
self.gwbstop_sk = self.read_value("maxbnd")
# min and Max band index for GW corrections.
self.min_gwbstart = np.min(self.gwbstart_sk)
self.max_gwbstart = np.max(self.gwbstart_sk)
self.min_gwbstop = np.min(self.gwbstop_sk)
self.max_gwbstop = np.max(self.gwbstop_sk)
self._egw = self.read_value("egw", cmode="c")
# Read and save important matrix elements.
# All these arrays are dimensioned
# vxcme(b1gw:b2gw,nkibz,nsppol*nsig_ab))
self._vxcme = self.read_value("vxcme")
self._sigxme = self.read_value("sigxme")
self._hhartree = self.read_value("hhartree", cmode="c")
self._vUme = self.read_value("vUme")
#if self.usepawu == 0: self._vUme.fill(0.0)
# Complex arrays
self._sigcmee0 = self.read_value("sigcmee0", cmode="c")
self._ze0 = self.read_value("ze0", cmode="c")
# Frequencies for the spectral function.
if self.has_spfunc:
self._omega_r = self.read_value("omega_r")
self._sigcme = self.read_value("sigcme", cmode="c")
self._sigxcme = self.read_value("sigxcme", cmode="c")
# Self-consistent case
self._en_qp_diago = self.read_value("en_qp_diago")
# <KS|QPState>
self._eigvec_qp = self.read_value("eigvec_qp", cmode="c")
