bandu 1.3.0__tar.gz → 1.3.2__tar.gz

{bandu-1.3.0/src/bandu.egg-info → bandu-1.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bandu
-Version: 1.3.0
+Version: 1.3.2
 Summary: The BandU program constructs a rank ordered series of crystal orbitals using principal component analysis. These principal orbital components can then be projected on the Fermi surface and visualized
 Author-email: Patrick Cross <pcross@wisc.edu>
 Project-URL: Homepage, https://github.com/pcross0405/BandU

{bandu-1.3.0 → bandu-1.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "bandu"
-version = "1.3.0"
+version = "1.3.2"
 authors = [
   { name="Patrick Cross", email="pcross@wisc.edu" },
 ]

{bandu-1.3.0 → bandu-1.3.2}/src/bandu/abinit_reader.py

@@ -963,11 +963,7 @@ class AbinitNetCDF():
         self.nband:int = int(self.dataset.dimensions['bantot'].size / self.nkpt)
         self.typat:list = self.dataset.variables['atom_species'][:].tolist()
         self.zion:np.ndarray = self.dataset.variables['atomic_numbers'][:]
-        _all_ions = [int(self.zion[i-1]) for i in self.typat]
-        self.znucltypat:list = []
-        for i in _all_ions:
-            if i not in self.znucltypat:
-                self.znucltypat.append(i)
+        self.znucltypat:list = [int(nuc) for nuc in self.zion]
         self.bands = [self.nband]
 #---------------------------------------------------------------------------------------------------------------------#
 #------------------------------------------------------ METHODS ------------------------------------------------------#

{bandu-1.3.0 → bandu-1.3.2}/src/bandu/plotter.py

@@ -338,8 +338,8 @@ class Plotter():
         self.p.app.exec_() # type: ignore
     #-----------------------------------------------------------------------------------------------------------------#
     # method to compute bandu fxn and one electron wfk overlaps
-    def _Overlaps_w_sym(
-        self, ir_wfk:wc.WFK, bandu:wc.WFK, num_bands:int
+    def _OverlapsWithSym(
+        self, ir_wfk:wc.WFK, bandu:wc.WFK
     )->np.ndarray:
         # kpoint to symmetrically generate
         kpt = ir_wfk.kpoints
@@ -348,15 +348,14 @@ class Plotter():
         dupes, unique_inds = ir_wfk._FindOrbit(sym_kpoints)
         count = sum([1 for i, _ in enumerate(unique_inds) if i not in dupes])
         # initialize array for overlap values
+        num_bands = len(self.isosurface.nbands)
         overlap_vals = np.zeros((count,num_bands), dtype=float)
-        if self._debug:
-            return overlap_vals
         # loop over bands
         for i, band in enumerate(self.isosurface.nbands):
             # generate symmetric coefficients for each band
             for j, wfk in enumerate(ir_wfk.SymWFKs(kpoint=kpt, band=band)):
                 wfk = wfk.GridWFK()
-                wfk = wfk.FFT()
+                wfk = wfk.IFFT()
                 wfk = wfk.Normalize()
                 overlap = np.sum(np.conj(bandu.wfk_coeffs)*wfk.wfk_coeffs)
                 overlap = np.square(np.abs(overlap))
@@ -364,15 +363,16 @@ class Plotter():
         return overlap_vals
     #-----------------------------------------------------------------------------------------------------------------#
     # method to compute bandu fxn and one electron wfk overlaps
-    def _Overlaps_no_sym(
-        self, ir_wfk:wc.WFK, bandu:wc.WFK, num_bands:int
+    def _OverlapsNoSym(
+        self, ir_wfk:wc.WFK, bandu:wc.WFK
     )->np.ndarray:
         # initialize array for overlap values
+        num_bands = len(self.isosurface.nbands)
         overlap_vals = np.zeros((1,num_bands), dtype=float)
         # loop over bands
         for i, band in enumerate(self.isosurface.nbands):
             wfk = ir_wfk.GridWFK(band_index=band)
-            wfk = wfk.FFT()
+            wfk = wfk.IFFT()
             wfk = wfk.Normalize()
             overlap = np.sum(np.conj(bandu.wfk_coeffs)*wfk.wfk_coeffs)
             overlap = np.square(np.abs(overlap))
@@ -430,7 +430,7 @@ class Plotter():
         # read fermi surface wavefunction
         fermi_wfk = ar.AbinitWFK(filename=wfk_path)   
         # get number of bands
-        nband = len(self.isosurface.nbands)
+        nbands = len(self.isosurface.nbands)
         # paths to real and imaginary bandu xsf files
         real_path = xsf_path + '_real.xsf'
         imag_path = xsf_path + '_imag.xsf'
@@ -440,7 +440,7 @@ class Plotter():
         print('XSF read')
         # convert xsf to wfk object
         bandu_fxn = wc.WFK(
-            wfk_coeffs=real_fxn.ReadDensity() + 1j*imag_fxn.ReadDensity(),
+            wfk_coeffs=real_fxn.ReadGrid() + 1j*imag_fxn.ReadGrid(),
             ngfftx=real_fxn.ngfftx,
             ngffty=real_fxn.ngffty,
             ngfftz=real_fxn.ngfftz
@@ -450,9 +450,9 @@ class Plotter():
         # loop through fermi surface kpoints and calc overlap with bandu fxn
         for i, kpt in enumerate(fermi_wfk.ReadWFK()):
             if sym:
-                vals = self._Overlaps_w_sym(kpt, bandu_fxn, nband)
+                vals = self._OverlapsWithSym(kpt, bandu_fxn)
             else:
-                vals = self._Overlaps_no_sym(kpt, bandu_fxn, nband)
+                vals = self._OverlapsNoSym(kpt, bandu_fxn)
             if i == 0:
                 overlaps = vals
             else:
@@ -463,8 +463,8 @@ class Plotter():
             nsym = fermi_wfk.nsym
             kpts = fermi_wfk.kpts
             all_kpts = np.zeros((1,3))
-            all_overlaps = np.zeros((1,nband))
-            new_wfk = wc.WFK(symrel=np.array(symrel), nsym=nsym, nbands=nband)
+            all_overlaps = np.zeros((1,nbands))
+            new_wfk = wc.WFK(symrel=np.array(symrel), nsym=nsym, nbands=nbands)
             for i, kpt in enumerate(kpts):
                 unique_kpts, _ = new_wfk.Symmetrize(
                     points=kpt,

{bandu-1.3.0 → bandu-1.3.2}/src/bandu/wfk_class.py

@@ -189,10 +189,10 @@ class WFK():
         Returns copy of WFK with wavefunction coefficients expressed in real space.
         Assumes existing wavefunction coefficients are expressed in reciprocal space.
         '''
-        # Fourier transform reciprocal grid to real space grid
-        real_coeffs = fftn(self.wfk_coeffs, norm='ortho')
+        # Fourier transform real grid to reciprocal grid
+        reciprocal_coeffs = fftn(self.wfk_coeffs, norm='ortho')
         new_WFK = copy(self)
-        new_WFK.wfk_coeffs = np.array(real_coeffs).reshape((self.ngfftx, self.ngffty, self.ngfftz))
+        new_WFK.wfk_coeffs = np.array(reciprocal_coeffs).reshape((self.ngfftx, self.ngffty, self.ngfftz))
         return new_WFK
     #-----------------------------------------------------------------------------------------------------------------#
     # method transforming real space wfks to reciprocal space
@@ -203,10 +203,10 @@ class WFK():
         Returns copy of WFK with wavefunction coefficients in expressed in reciprocal space.
         Assumes existing wavefunction coefficients are expressed in real space. 
         '''
-        # Fourier transform real space grid to reciprocal space grid
-        reciprocal_coeffs = ifftn(self.wfk_coeffs, norm='ortho')
+        # Fourier transform reciprocal grid to real grid
+        real_coeffs = ifftn(self.wfk_coeffs, norm='ortho')
         new_WFK = copy(self)
-        new_WFK.wfk_coeffs = np.array(reciprocal_coeffs).reshape((self.ngfftx,self.ngffty,self.ngfftz))
+        new_WFK.wfk_coeffs = np.array(real_coeffs).reshape((self.ngfftx,self.ngffty,self.ngfftz))
         return new_WFK
     #-----------------------------------------------------------------------------------------------------------------#
     # method for normalizing wfks

{bandu-1.3.0 → bandu-1.3.2}/src/bandu/xsf_reader.py

@@ -40,7 +40,7 @@ class XSF():
                     del coord[0]
                     self.coords[atom,:] = coord
             # once density block is reached, get ngfft spacing and end init
-            if line.strip() == 'DATAGRID_3D_DENSITY':
+            if line.strip() == 'BEGIN_DATAGRID_3D_principal_orbital_component':
                 ngfft_spacing = self.xsf_lines[i+1].strip().split(' ')
                 ngfft_spacing = [int(val) for val in ngfft_spacing]
                 self.ngfftx = ngfft_spacing[0]
@@ -49,7 +49,7 @@ class XSF():
                 return None
     #-----------------------------------------------------------------------------------------------------------------#
     # method reading in BandU eigenfunction from XSF
-    def ReadDensity(
+    def ReadGrid(
         self
     )->np.ndarray:
         '''
@@ -63,22 +63,22 @@ class XSF():
         density_lines:list|np.ndarray=[]
         for i, line in enumerate(self.xsf_lines):
             # get density block, this assumes density is the end most data grid in the XSF
-            if line.strip() == 'DATAGRID_3D_DENSITY':
-                # density starts 6 lines down from DATAGRID_3D_DENSITY header
+            if line.strip() == 'BEGIN_DATAGRID_3D_principal_orbital_component':
+                # density starts 6 lines down from BEGIN_DATAGRID_3D_principal_orbital_component header
                 density_lines = self.xsf_lines[i+6:]
                 # last line indicates end of data block, remove it
                 del density_lines[-1]
-                # last entry in density is a string indicating end of density, remove it
+                # last entry in datagrid has a string indicating end of grid, remove it
                 last_line = density_lines[-1].strip().split(' ')
                 last_line = [val for val in last_line if val != 'END_DATAGRID_3D']
                 # cast line back to a single string
                 last_line = ' '.join(last_line)
                 density_lines[-1] = last_line
         if density_lines is []:
-            raise LookupError('3D density data not found in XSF file')
+            raise LookupError('3D grid data not found in XSF file')
         # convert density to 3D array of floats
         density_lines = [line.strip().split(' ') for line in density_lines]
         density_lines = [val for line in density_lines for val in line if val != '']
         density_lines = np.array(density_lines, dtype=float)
-        density_lines = density_lines.reshape((self.ngfftz, self.ngfftx, self.ngffty))
+        density_lines = density_lines.reshape((self.ngfftx, self.ngffty, self.ngfftz), order='F')
         return density_lines

{bandu-1.3.0 → bandu-1.3.2/src/bandu.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bandu
-Version: 1.3.0
+Version: 1.3.2
 Summary: The BandU program constructs a rank ordered series of crystal orbitals using principal component analysis. These principal orbital components can then be projected on the Fermi surface and visualized
 Author-email: Patrick Cross <pcross@wisc.edu>
 Project-URL: Homepage, https://github.com/pcross0405/BandU