bandu 1.2.0__tar.gz → 1.3.1__tar.gz

{bandu-1.2.0/src/bandu.egg-info → bandu-1.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bandu
-Version: 1.2.0
+Version: 1.3.1
 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.2.0 → bandu-1.3.1}/pyproject.toml

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

{bandu-1.2.0 → bandu-1.3.1}/src/bandu/bandu.py

@@ -123,7 +123,7 @@ class BandU():
             if self.grid:
                 wfk = wfk.GridWFK()
             if self.fft:
-                wfk = wfk.FFT()
+                wfk = wfk.IFFT()
             if self.norm:
                 wfk = wfk.Normalize()
             yield wfk
@@ -244,7 +244,7 @@ class BandU():
     ):
         total_states = self.found_states
         if nums is []:
-            nums = [0,total_states-1]
+            nums = [1,total_states]
         else:
             # check if list has only 2 elements
             if len(nums) != 2:
@@ -268,6 +268,6 @@ class BandU():
         for i in range(nums[0]-1, nums[1]):
             file_name = xsf_name + f'_{i+1}'
             wfk = copy(self.bandu_fxns[i])
-            wfk.wfk_coeffs = wfk.wfk_coeffs.reshape((z,y,x))
+            wfk.wfk_coeffs = wfk.wfk_coeffs.reshape((x,y,z))
             wfk = wfk.XSFFormat()
             wfk.WriteXSF(xsf_file=file_name)

{bandu-1.2.0 → bandu-1.3.1}/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.2.0 → bandu-1.3.1}/src/bandu/wfk_class.py

@@ -138,16 +138,16 @@ class WFK():
             If nothing is passed, it is assumed the coefficients of a single band are supplied.
         '''
         # initialize 3D grid
-        gridded_wfk = np.zeros((self.ngfftz, self.ngffty, self.ngfftx), dtype=complex)
+        gridded_wfk = np.zeros((self.ngfftx, self.ngffty, self.ngfftz), dtype=complex)
         # update grid with wfk coefficients
         for k, kpt in enumerate(self.pw_indices):
             kx = kpt[0]
             ky = kpt[1]
             kz = kpt[2]
             if band_index >= 0:
-                gridded_wfk[kz, ky, kx] = self.wfk_coeffs[band_index][k]
+                gridded_wfk[kx, ky, kz] = self.wfk_coeffs[band_index][k]
             else:
-                gridded_wfk[kz, ky, kx] = self.wfk_coeffs[k]
+                gridded_wfk[kx, ky, kz] = self.wfk_coeffs[k]
         new_WFK = copy(self)
         new_WFK.wfk_coeffs = gridded_wfk
         return new_WFK
@@ -166,9 +166,9 @@ class WFK():
             If nothing is passed, it is assumed the coefficients of a single band are supplied.
         '''
         # check if coefficients are gridded before undoing grid format
-        if self.wfk_coeffs.shape != (self.ngfftz,self.ngffty,self.ngfftx):
+        if self.wfk_coeffs.shape != (self.ngfftx,self.ngffty,self.ngfftz):
             raise ValueError((
-                f'Plane wave coefficients must be in 3D grid with shape ({self.ngfftz}, {self.ngffty}, {self.ngfftx})'
+                f'Plane wave coefficients must be in 3D grid with shape ({self.ngfftx}, {self.ngffty}, {self.ngfftz})'
                 ' in order to remove the gridded format'
             ))
         if band_index >= 0:
@@ -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.ngfftz, self.ngffty, self.ngfftx))
+        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.ngfftz,self.ngffty,self.ngfftx))
+        new_WFK.wfk_coeffs = np.array(real_coeffs).reshape((self.ngfftx,self.ngffty,self.ngfftz))
         return new_WFK
     #-----------------------------------------------------------------------------------------------------------------#
     # method for normalizing wfks
@@ -430,34 +430,34 @@ class WFK():
         # append zeros to ends of all axes in grid_wfk
         # zeros get replaced by values at beginning of each axis
         # this repetition is required by XSF format
-        if np.shape(self.wfk_coeffs) != (self.ngfftz, self.ngffty, self.ngfftx):
+        if np.shape(self.wfk_coeffs) != (self.ngfftx, self.ngffty, self.ngfftz):
             raise ValueError(
                 f'''Passed array is not the correct shape:
-                Expected: ({self.ngfftz}, {self.ngffty}, {self.ngfftx}),
+                Expected: ({self.ngfftx}, {self.ngffty}, {self.ngfftz}),
                 Received: {np.shape(self.wfk_coeffs)}
             ''')
         else:
             grid_wfk = self.wfk_coeffs
-        grid_wfk = np.append(grid_wfk, np.zeros((1, self.ngffty, self.ngfftx)), axis=0)
-        grid_wfk = np.append(grid_wfk, np.zeros((self.ngfftz+1, 1, self.ngfftx)), axis=1)
-        grid_wfk = np.append(grid_wfk, np.zeros((self.ngfftz+1, self.ngffty+1, 1)), axis=2)
+        grid_wfk = np.append(grid_wfk, np.zeros((1, self.ngffty, self.ngfftz)), axis=0)
+        grid_wfk = np.append(grid_wfk, np.zeros((self.ngfftx+1, 1, self.ngfftz)), axis=1)
+        grid_wfk = np.append(grid_wfk, np.zeros((self.ngfftx+1, self.ngffty+1, 1)), axis=2)
         for x in range(self.ngfftx+1):
             for y in range(self.ngffty+1):
                 for z in range(self.ngfftz+1):
                     if x == self.ngfftx:
-                        grid_wfk[z][y][x] = grid_wfk[z][y][0]
+                        grid_wfk[x,y,z] = grid_wfk[0,y,z]
                     if y == self.ngffty:
-                        grid_wfk[z][y][x] = grid_wfk[z][0][x]
+                        grid_wfk[x,y,z] = grid_wfk[x,0,z]
                     if z == self.ngfftz:
-                        grid_wfk[z][y][x] = grid_wfk[0][x][y]
+                        grid_wfk[x,y,z] = grid_wfk[x,y,0]
                     if x == self.ngfftx and y == self.ngffty:
-                        grid_wfk[z][y][x] = grid_wfk[z][0][0]
+                        grid_wfk[x,y,z] = grid_wfk[0,0,z]
                     if x == self.ngfftx and z == self.ngfftz:
-                        grid_wfk[z][y][x] = grid_wfk[0][y][0]
+                        grid_wfk[x,y,z] = grid_wfk[0,y,0]
                     if z == self.ngfftz and y == self.ngffty:
-                        grid_wfk[z][y][x] = grid_wfk[0][0][x]
+                        grid_wfk[x,y,z] = grid_wfk[x,0,0]
                     if x == self.ngfftx and y == self.ngffty and z == self.ngfftz:
-                        grid_wfk[z][y][x] = grid_wfk[0][0][0]
+                        grid_wfk[x,y,z] = grid_wfk[0,0,0]
         new_WFK = copy(self)
         new_WFK.wfk_coeffs = grid_wfk
         new_WFK.ngfftx += 1
@@ -474,18 +474,18 @@ class WFK():
         '''
         grid = self.wfk_coeffs
         # to_be_del will be used to remove all extra data points added for XSF formatting
-        to_be_del = np.ones((self.ngfftz, self.ngfftx, self.ngffty), dtype=bool)
+        to_be_del = np.ones((self.ngfftx, self.ngffty, self.ngfftz), dtype=bool)
         for z in range(self.ngfftz):
-            for x in range(self.ngffty):
-                for y in range(self.ngfftx):
+            for y in range(self.ngffty):
+                for x in range(self.ngfftx):
                     # any time you reach the last density point it is a repeat of the first point
                     # remove the end points along each axis
                     if y == self.ngffty - 1 or x == self.ngfftx - 1 or z == self.ngfftz - 1:
-                        to_be_del[z,y,x] = False
+                        to_be_del[x,y,z] = False
         # remove xsf entries from array
         grid = grid[to_be_del]
         # restore grid shape
-        grid = grid.reshape((self.ngfftz-1, self.ngffty-1, self.ngfftx-1))
+        grid = grid.reshape((self.ngfftx-1, self.ngffty-1, self.ngfftz-1))
         new_WFK = copy(self)
         new_WFK.wfk_coeffs = grid
         new_WFK.ngfftx -= 1
@@ -522,16 +522,16 @@ class WFK():
             print(f'{self.natom} 1', file=xsf)
             for i, coord in enumerate(self.xred):
                 atomic_num = int(self.znucltypat[self.typat[i] - 1])
-                cart_coord = np.dot(coord, self.lattice)
+                cart_coord = np.matmul(coord, self.lattice)
                 print(f'{atomic_num} {cart_coord[0]} {cart_coord[1]} {cart_coord[2]}', file=xsf)
             print('ATOMS', file=xsf)
             for i, coord in enumerate(self.xred):
                 atomic_num = int(self.znucltypat[self.typat[i] - 1])
-                cart_coord = np.dot(coord, self.lattice)
+                cart_coord = np.matmul(coord, self.lattice)
                 print(f'{atomic_num} {cart_coord[0]} {cart_coord[1]} {cart_coord[2]}', file=xsf)
-            print('BEGIN_BLOCK_DATAGRID3D', file=xsf)
+            print('BEGIN_BLOCK_DATAGRID_3D', file=xsf)
             print('datagrids', file=xsf)
-            print('DATAGRID_3D_DENSITY', file=xsf)
+            print('BEGIN_DATAGRID_3D_principal_orbital_component', file=xsf)
             print(f'{self.ngfftx} {self.ngffty} {self.ngfftz}', file=xsf)
             print('0.0 0.0 0.0', file=xsf)
             print(f'{self.lattice[0,0]} {self.lattice[0,1]} {self.lattice[0,2]}', file=xsf)
@@ -543,14 +543,14 @@ class WFK():
                     for x in range(self.ngfftx):
                         count += 1
                         if _component:
-                            print(self.wfk_coeffs[z,y,x].real, file=xsf, end=' ')
+                            print(self.wfk_coeffs[x,y,z].real, file=xsf, end=' ')
                         else:
-                            print(self.wfk_coeffs[z,y,x].imag, file=xsf, end=' ')
+                            print(self.wfk_coeffs[x,y,z].imag, file=xsf, end=' ')
                         if count == 6:
                             count = 0
                             print('\n', file=xsf, end='')
             print('END_DATAGRID_3D', file=xsf)
-            print('END_BLOCK_DATAGRID3D', file=xsf)
+            print('END_BLOCK_DATAGRID_3D', file=xsf)
         # rerun method to write out imaginary part
         if _component:
             xsf_file = xsf_file.split('_real')[0]

{bandu-1.2.0 → bandu-1.3.1}/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.2.0 → bandu-1.3.1/src/bandu.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bandu
-Version: 1.2.0
+Version: 1.3.1
 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