bandu 1.1.1__tar.gz → 1.3.0__tar.gz

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

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

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

{bandu-1.1.1 → bandu-1.3.0}/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,x,y))
+            wfk.wfk_coeffs = wfk.wfk_coeffs.reshape((x,y,z))
             wfk = wfk.XSFFormat()
             wfk.WriteXSF(xsf_file=file_name)

{bandu-1.1.1 → bandu-1.3.0}/src/bandu/isosurface_class.py

@@ -42,6 +42,10 @@ class Isosurface():
         Default 0.05, this scales inversely with kpoint grid size (larger grids require smaller radius)
     sym_ops : np.ndarray
         Array of symmetry operations for generating points in Brillouin Zone
+    grid_stretch : float
+        Value that stretches grid that is used to interpolate bands
+        If portions of Brillouin Zone are cropped off, increase this value
+        Default is 0.15
 
     Methods
     -------
@@ -51,7 +55,8 @@ class Isosurface():
     def __init__(
         self, points:np.ndarray=np.zeros(1), values:np.ndarray=np.zeros(1), rec_latt:np.ndarray=np.zeros(1), 
         wfk_name:str='', grid_steps:tuple=(50,50,50), fermi_energy:float=0.0, energy_level:float=0.0, 
-        width:float=0.005, radius:float=0.05, nbands:list[int]=[], sym_ops:np.ndarray=np.zeros(1), _debug:bool=False
+        width:float=0.005, radius:float=0.05, nbands:list[int]=[], sym_ops:np.ndarray=np.zeros(1), 
+        grid_stretch:float=0.15
     )->None:
         # define attributes
         self.points=points
@@ -64,9 +69,9 @@ class Isosurface():
         self.radius=radius
         self.nbands=nbands
         self.sym_ops=sym_ops
-        self._debug=_debug
+        self.grid_stretch=grid_stretch
         # check if enough information is provided to class to construct isosurfaces
-        if self.points.all() == np.zeros(1) and self.values.all() == np.zeros(1):
+        if self.points.shape == (1,) and self.values.shape == (1,):
             if wfk_name == '':
                 raise ValueError((
                     'Either the points and the values attributes must be defined or the wfk_name attribute '
@@ -126,8 +131,18 @@ class Isosurface():
         dimy = self.grid_steps[1]
         dimz = self.grid_steps[2]
         grid = pv.ImageData()
-        grid.origin = (xmin-0.035, ymin-0.035, zmin-0.035)
-        grid.spacing = (2*(xmax+0.05)/dimx, 2*(ymax+0.05)/dimy, 2*(zmax+0.05)/dimz)
+        stretch_factor = self.grid_stretch
+        dim_stretch = [2*stretch_factor/dim for dim in self.grid_steps]
+        grid.origin = (
+            xmin - 0.5*stretch_factor, 
+            ymin - 0.5*stretch_factor,
+            zmin - 0.5*stretch_factor
+        )
+        grid.spacing = (
+            2*xmax/dimx + dim_stretch[0], 
+            2*ymax/dimy + dim_stretch[1], 
+            2*zmax/dimz + dim_stretch[2]
+        )
         grid.dimensions = (dimx, dimy, dimz)
         return grid
     #-----------------------------------------------------------------------------------------------------------------#
@@ -185,22 +200,18 @@ class Isosurface():
         nkpt = wfk.nkpt
         self.fermi_energy = wfk.fermi
         self.rec_latt = wc.WFK(lattice=wfk.real_lattice).Real2Reciprocal()
-        if self._debug:
-            eigs = np.zeros((nkpt,10))
-            band_num = [1,2,3,4,5]
-        else:
-            for wfk_obj in wfk.ReadEigenvalues():
-                eigs.append(wfk_obj.eigenvalues)
-            eigs = np.array(eigs).reshape((nkpt,nbands))
-            # look through eigenvalues to find which bands to contour
-            min_val = self.fermi_energy + self.energy_level - self.width/2
-            max_val = self.fermi_energy + self.energy_level + self.width/2
-            band_num = []
-            for i in range(nbands):
-                for eigval in eigs[:,i]:
-                    if min_val <= eigval <= max_val:
-                        band_num.append(i)
-                        break            
+        for wfk_obj in wfk.ReadEigenvalues():
+            eigs.append(wfk_obj.eigenvalues)
+        eigs = np.array(eigs).reshape((nkpt,nbands))
+        # look through eigenvalues to find which bands to contour
+        min_val = self.fermi_energy + self.energy_level - self.width/2
+        max_val = self.fermi_energy + self.energy_level + self.width/2
+        band_num = []
+        for i in range(nbands):
+            for eigval in eigs[:,i]:
+                if min_val <= eigval <= max_val:
+                    band_num.append(i)
+                    break            
         # return kpoints and bands of interest
         bands = np.take(eigs, band_num, axis=1)
         shifts = brlzn.BZ(self.rec_latt).GetShifts(kpoints)
@@ -222,8 +233,4 @@ class Isosurface():
         kpoints = np.delete(all_kpts, 0, axis=0)
         bands = np.delete(all_eigs, 0, axis=0)
         kpoints = np.matmul(kpoints, self.rec_latt)
-        if self._debug:
-            print(kpoints.shape)
-            print(bands.shape)
-            raise SystemExit()
         return kpoints, bands, band_num, ir_kpts

{bandu-1.1.1 → bandu-1.3.0}/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.ngfftx, self.ngffty), 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, kx, ky] = self.wfk_coeffs[band_index][k]
+                gridded_wfk[kx, ky, kz] = self.wfk_coeffs[band_index][k]
             else:
-                gridded_wfk[kz, kx, ky] = 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.ngfftx,self.ngffty):
+        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.ngfftx}, {self.ngffty})'
+                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:
@@ -192,7 +192,7 @@ class WFK():
         # Fourier transform reciprocal grid to real space grid
         real_coeffs = fftn(self.wfk_coeffs, norm='ortho')
         new_WFK = copy(self)
-        new_WFK.wfk_coeffs = np.array(real_coeffs).reshape((self.ngfftz, self.ngfftx, self.ngffty))
+        new_WFK.wfk_coeffs = np.array(real_coeffs).reshape((self.ngfftx, self.ngffty, self.ngfftz))
         return new_WFK
     #-----------------------------------------------------------------------------------------------------------------#
     # method transforming real space wfks to reciprocal space
@@ -206,7 +206,7 @@ class WFK():
         # Fourier transform real space grid to reciprocal space grid
         reciprocal_coeffs = ifftn(self.wfk_coeffs, norm='ortho')
         new_WFK = copy(self)
-        new_WFK.wfk_coeffs = reciprocal_coeffs
+        new_WFK.wfk_coeffs = np.array(reciprocal_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.ngfftx, self.ngffty):
+        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.ngfftx}, {self.ngffty}),
+                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.ngfftx, self.ngffty)), axis=0)
-        grid_wfk = np.append(grid_wfk, np.zeros((self.ngfftz+1, 1, self.ngffty)), axis=1)
-        grid_wfk = np.append(grid_wfk, np.zeros((self.ngfftz+1, self.ngfftx+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][x][y] = grid_wfk[z][0][y]
+                        grid_wfk[x,y,z] = grid_wfk[0,y,z]
                     if y == self.ngffty:
-                        grid_wfk[z][x][y] = grid_wfk[z][x][0]
+                        grid_wfk[x,y,z] = grid_wfk[x,0,z]
                     if z == self.ngfftz:
-                        grid_wfk[z][x][y] = 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][x][y] = 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][x][y] = grid_wfk[0][0][y]
+                        grid_wfk[x,y,z] = grid_wfk[0,y,0]
                     if z == self.ngfftz and y == self.ngffty:
-                        grid_wfk[z][x][y] = grid_wfk[0][x][0]
+                        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][x][y] = 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.ngfftx):
-                for y in range(self.ngffty):
+            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,x,y] = 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.ngfftx-1, self.ngffty-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)
@@ -539,18 +539,18 @@ class WFK():
             print(f'{self.lattice[2,0]} {self.lattice[2,1]} {self.lattice[2,2]}', file=xsf)
             count = 0
             for z in range(self.ngfftz):
-                for x in range(self.ngfftx):
-                    for y in range(self.ngffty):
+                for y in range(self.ngffty):
+                    for x in range(self.ngfftx):
                         count += 1
                         if _component:
-                            print(self.wfk_coeffs[z,x,y].real, file=xsf, end=' ')
+                            print(self.wfk_coeffs[x,y,z].real, file=xsf, end=' ')
                         else:
-                            print(self.wfk_coeffs[z,x,y].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.1.1 → bandu-1.3.0/src/bandu.egg-info}/PKG-INFO

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