def __init__(self, path):
"""Initialize the object from a filename."""
super(WFK_Reader, self).__init__(path)
self.structure = self.read_structure()
self.kpoints = kpoints_factory(path)
self.nfft1 = self.read_dimvalue("number_of_grid_points_vector1")
self.nfft2 = self.read_dimvalue("number_of_grid_points_vector2")
self.nfft3 = self.read_dimvalue("number_of_grid_points_vector3")
self.cplex_ug = self.read_dimvalue("real_or_complex_coefficients")
self.nspinor = self.read_dimvalue("number_of_spinor_components")
self.nsppol = self.read_dimvalue("number_of_spins")
self.nspden = self.read_dimvalue("number_of_components")
self.ecut = self.read_value("kinetic_energy_cutoff")
self.nband_sk = self.read_value("number_of_states")
self.istwfk = self.read_value("istwfk")
self.npwarr = self.read_value("number_of_coefficients")
# Gvectors
self._kg = self.read_value("reduced_coordinates_of_plane_waves")
# Wavefunctions (complex array)
# TODO use variables to avoid storing the full block.
if self.cplex_ug == 2:
self.set_of_ug = self.read_value("coefficients_of_wavefunctions", cmode="c")
else:
raise NotImplementedError("")
def sppgroup():
filename = "/Users/gmatteo/Coding/Abinit/bzr_archives/733/gmatteo-private/gcc47/tests/Silicon/o_GSR"
#from abipy.core import Structure, SpaceGroup
#wfk = WFK_File(get_reference_file("si_WFK-etsf.nc"))
#wfk = WFK_File(get_reference_file("si_WFK-etsf.nc"))
#structure = wfk.get_structure()
#ibz = wfk.kpoints
structure = Structure.from_file(filename)
spg = structure.spacegroup
print(spg)
ibz = kpoints_factory(filename)
print(type(ibz))
print("mpdivs", ibz.mpdivs)
bands = ElectronBands.from_file(filename)
from abipy.core.kpoints import map_mesh2ibz, Kmesh
kmap = map_mesh2ibz(structure, ibz.mpdivs, ibz.shifts, ibz)
sys.exit(1)
#kmesh = Kmesh(structure,ibz.mpdivs, ibz.shifts, ibz)
#print(kmesh.bzmap)
band = 3
branch = bands.eigens[0, :, band]
kx, ky, plane = kmesh.plane_cut(branch)
#print(plane)
#plot_array(plane)
#plt.contour(plane)
#from mayavi import mlab
#mlab.surf(kx,ky,plane)
#mlab.show()
from abipy.tools.plotting_utils import plot_array
from mpl_toolkits.mplot3d import axes3d
from matplotlib import cm
fig = plt.figure()
ax = fig.gca(projection='3d')
surf = ax.plot_surface(kx, ky, plane, alpha=0.3)
min_eig = plane.min()
#min_eig -= abs(min_eig) * 0.1
off_x = -1
off_y = len(ky) + 1
cset = ax.contourf(kx, ky, plane, zdir='z', offset=min_eig, cmap=cm.jet)
#cset = ax.contourf(kx, ky, plane, zdir='x', offset=off_x, cmap=cm.coolwarm)
#cset = ax.contourf(kx, ky, plane, zdir='y', offset=off_y, cmap=cm.coolwarm)
#fig.colorbar(surf, shrink=0.5, aspect=5)
plt.show()
def check_kinfo():
from abipy.core.kpoints import KpointsInfo, kpoints_factory
file = get_reference_file("si_nscf_WFK-etsf.nc")
#kinfo = KpointsInfo.from_file(file)
#print(kinfo)
#print(kinfo.is_sampling)
kpoints = kpoints_factory(file)
print(kpoints)
def __init__(self, path):
super(DIPME_Reader, self).__init__(path)
# Read important dimensions and variables.
frac_coords = self.read_value("kpoints_reduced_coordinates")
self.kibz = kpoints_factory(self)
# Minimum and maximum band index as function of [s,k]
self.minb_ks = self.read_value("minb")
self.maxb_ks = self.read_value("maxb")
# Dipole matrix elements
self.dipme_skvc = self.read_value("dipme", cmode="c")
def __init__(self, filepath):
"""
Initialized the object from a Netcdf file.
"""
super(WFK_File, self).__init__(filepath)
# Initialize the structure from file.
self.structure = Structure.from_file(filepath)
# Initialize the band energies.
self.bands = ElectronBands.from_file(filepath)
self.kpoints = kpoints_factory(filepath)
self.nkpt = len(self.kpoints)
with WFK_Reader(filepath) as reader:
assert reader.has_pwbasis_set
assert reader.cplex_ug == 2
self.npwarr = reader.npwarr
self.nband_sk = reader.nband_sk
self.nspinor = reader.nspinor
self.nsppol = reader.nsppol
self.nspden = reader.nspden
# FFT mesh (augmented divisions reported in the WFK file)
self.fft_mesh = Mesh3D(reader.fft_divs, self.structure.lattice_vectors())
# Build G-spheres for each k-point
gspheres = len(self.kpoints) * [None]
ecut = reader.ecut
for k, kpoint in enumerate(self.kpoints):
gvec_k, istwfk = reader.read_gvec_istwfk(k)
gspheres[k] = GSphere(ecut, self.structure.reciprocal_lattice, kpoint, gvec_k, istwfk=istwfk)
self._gspheres = tuple(gspheres)
# Save reference to the reader.
self.reader = reader
def __init__(self, path):
self.ks_bands = ElectronBands.from_file(path)
self.nsppol = self.ks_bands.nsppol
super(SIGRES_Reader, 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.kpoints = kpoints_factory(self)
# 2) The K-points where QPState corrections have been calculated.
gwred_coords = self.read_redc_gwkpoints()
self.gwkpoints = askpoints(gwred_coords, self.structure.reciprocal_lattice)
# 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_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")
