bandu 1.1.0__py3-none-any.whl → 1.2.0__py3-none-any.whl

bandu/bandu.py

@@ -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((z,y,x))
             wfk = wfk.XSFFormat()
             wfk.WriteXSF(xsf_file=file_name)

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/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.ngfftz, self.ngffty, self.ngfftx), 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[kz, ky, kx] = self.wfk_coeffs[band_index][k]
             else:
-                gridded_wfk[kz, kx, ky] = self.wfk_coeffs[k]
+                gridded_wfk[kz, ky, kx] = 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.ngfftz,self.ngffty,self.ngfftx):
             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.ngfftz}, {self.ngffty}, {self.ngfftx})'
                 ' 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.ngfftz, self.ngffty, self.ngfftx))
         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.ngfftz,self.ngffty,self.ngfftx))
         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.ngfftz, self.ngffty, self.ngfftx):
             raise ValueError(
                 f'''Passed array is not the correct shape:
-                Expected: ({self.ngfftz}, {self.ngfftx}, {self.ngffty}),
+                Expected: ({self.ngfftz}, {self.ngffty}, {self.ngfftx}),
                 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.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)
         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[z][y][x] = grid_wfk[z][y][0]
                     if y == self.ngffty:
-                        grid_wfk[z][x][y] = grid_wfk[z][x][0]
+                        grid_wfk[z][y][x] = grid_wfk[z][0][x]
                     if z == self.ngfftz:
-                        grid_wfk[z][x][y] = grid_wfk[0][x][y]
+                        grid_wfk[z][y][x] = grid_wfk[0][x][y]
                     if x == self.ngfftx and y == self.ngffty:
-                        grid_wfk[z][x][y] = grid_wfk[z][0][0]
+                        grid_wfk[z][y][x] = grid_wfk[z][0][0]
                     if x == self.ngfftx and z == self.ngfftz:
-                        grid_wfk[z][x][y] = grid_wfk[0][0][y]
+                        grid_wfk[z][y][x] = 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[z][y][x] = grid_wfk[0][0][x]
                     if x == self.ngfftx and y == self.ngffty and z == self.ngfftz:
-                        grid_wfk[z][x][y] = grid_wfk[0][0][0]
+                        grid_wfk[z][y][x] = grid_wfk[0][0][0]
         new_WFK = copy(self)
         new_WFK.wfk_coeffs = grid_wfk
         new_WFK.ngfftx += 1
@@ -476,16 +476,16 @@ class WFK():
         # 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)
         for z in range(self.ngfftz):
-            for x in range(self.ngfftx):
-                for y in range(self.ngffty):
+            for x in range(self.ngffty):
+                for y 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[z,y,x] = 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.ngfftz-1, self.ngffty-1, self.ngfftx-1))
         new_WFK = copy(self)
         new_WFK.wfk_coeffs = grid
         new_WFK.ngfftx -= 1
@@ -539,13 +539,13 @@ 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[z,y,x].real, file=xsf, end=' ')
                         else:
-                            print(self.wfk_coeffs[z,x,y].imag, file=xsf, end=' ')
+                            print(self.wfk_coeffs[z,y,x].imag, file=xsf, end=' ')
                         if count == 6:
                             count = 0
                             print('\n', file=xsf, end='')

{bandu-1.1.0.dist-info → bandu-1.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bandu
-Version: 1.1.0
+Version: 1.2.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
@@ -31,6 +31,8 @@ BandU projections, if provided with the necessary k-point and eigenvalue data.</
 -------------------------------------------------------------------------------------------------------  
 <h1><p align="center">INSTALLATION INSTRUCTIONS</p></h1>
 
+<h2><p align="center">THROUGH GITHUB</p></h2>
+
 1) Inside that directory type on the command line  
    "git clone https://github.com/pcross0405/BandU.git"
 
@@ -46,6 +48,10 @@ BandU projections, if provided with the necessary k-point and eigenvalue data.</
 
 6) On the command line type  
    "pip install dist/*.whl" 
+
+<h2><p align="center">THROUGH PIP</p></h2>
+
+pip install bandu
    
 -------------------------------------------------------------------------------------------------------  
 <h1><p align="center">DEPENDENCIES</p></h1>
@@ -93,9 +99,19 @@ xsf_path = f'path\to\XSF\file\{root_name}_bandu_{xsf_number}'
 bandu_name = f'{root_name}_bandu'
 
 def main(
-        Band_U:bool, Iso_Surf:bool, Load_Surf:bool
+        principal_orbital_components:bool, 
+        fermi_surface:bool, 
+        fermi_surface_projection:bool,
+        load_fermi_surface:bool
 )->None:
-    if Band_U: # create BandU principal orbital components
+    # this option will generate the principal orbital components 1 through 10
+    # to generate more or less, adjust the range of the "nums" keyword in the ToXSF() function
+    # the energy sampled can be set, relative to the Fermi energy, by changing the the "energy_level" global variable
+    # states are included in the analysis if they are within +/- 1/2*width of the set energy_level 
+    # to get fewer or more states, decrease or increase, respectively, the "width" global variable
+    # by default, the prinicipal orbital components are generated from an irreducible wedge of the Brillouin Zone
+    # to generate from the full BZ, change the "sym" attribute in the BandU class from "False" to "True"
+    if principal_orbital_components:
         wfk_gen = AbinitWFK(wfk_path).ReadWFK(
             energy_level = energy_level,
             width=width
@@ -104,13 +120,39 @@ def main(
             wfks = wfk_gen,
             energy_level = energy_level,
             width = width,
-            sym = True
+            sym = False
          )
         wfk.ToXSF(
             xsf_name = bandu_name,
             nums = [1,10]
          )
-    elif Iso_Surf: # construct energy isosurfaces and plot them
+    # this option will only generate an energy isosurface and will not project principal component overlap onto the surface
+    # the "energy_level" global variable is the energy at which the isosurface will be be generated, relative to the Fermi energy
+    # so energy_level = 0.0 will generate the Fermi surface
+    # the "width" global variable determines how many states are included in the generation of the isosurface
+    # a small width (~10 meV or ~0.5 mHa) is best here as larger widths may introduce bands that do not cross the Fermi energy
+    # the color of the surface can be changed to any string compatible with the matplotlib colors 
+    # see named colors here: https://matplotlib.org/stable/gallery/color/named_colors.html
+    # the Plot function has many other keywords to customize the visuals to the users liking, see the docstring for more
+    elif fermi_surface: 
+        contours = Isosurface(
+            wfk_name = wfk_path,
+            energy_level = energy_level,
+            width = width
+        )
+        contours.Contour() # make contours
+        plot = Plotter(
+            isosurface = contours,
+            save_file=f'{root_name}_bandu_{xsf_number}_fermi_surf.pkl'
+         ) # create plotter object
+        plot.Plot(
+            color = 'silver',
+        ) # plot contours
+    # this option will generate an energy isosurface as well as project the overlap of a principal orbital component onto the surface
+    # everything remains the same as the previous option, except now the principal orbtial component XSF file is needed 
+    # also the color of the surface is done with the Colors module by default
+    # other colors can be made with the Colors module, also any matplotlib colormap works
+    elif fermi_surface_projection: 
         contours = Isosurface(
             wfk_name = wfk_path,
             energy_level = energy_level,
@@ -129,14 +171,22 @@ def main(
             surface_vals = overlap_vals,
             colormap = Colors().blues,
         ) # plot contours
-    elif Load_Surf:
+    # this option will load a previously generated and saved fermi surface file
+    # update the "save_path" keyword to match the path and name of your save file
+    elif load_fermi_surface:
         Plotter().Load(
             save_path='{root_name}_bandu_{xsf_number}_fermi_surf.pkl',
         )
+# to run any of the options above, make sure to set that option to "True"
+# also be sure that the other options (or at least all options that come before) are set to "False"
+# the main function will only run which ever option is the first found to be "True" in top to bottom order
+# in other words, the priority follows as most to least in the order:
+# principal_orbital_components -> fermi_surface -> fermi_surface_projection -> load_fermi_surface
 if __name__ == '__main__':
     main(
-        Band_U = False,
-        Iso_Surf = False,
-        Load_Surf = False,
+        principal_orbital_components=True, 
+        fermi_surface=True, 
+        fermi_surface_projection=True,
+        load_fermi_surface=True
     )
 <pre>

bandu-1.2.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+bandu/abinit_reader.py,sha256=U4HUUTnju9MpyGtWMOedUQLln90k2F0XIv0Q0zcP05c,47704
+bandu/bandu.py,sha256=-gahVb8Eqx33RzcbYngzjDHmbMib6grRXEQE_fTgLWg,12786
+bandu/brillouin_zone.py,sha256=-SarCuvUthk5h_sFHM6KDHLns1eCWGk_v5fHngWFu08,7997
+bandu/colors.py,sha256=OcIBwVh9ieu04n1cruRgyoYslKsdfJKf-u4oWMd3CwQ,2316
+bandu/isosurface_class.py,sha256=M6XAuy89uyX3v_JX3wYd5VqAWel9JiMQ7wRBhFhhn3A,10236
+bandu/plotter.py,sha256=wSIA1TpwhioPUHpBe4_gc14e8K98fv3q0LwwD5NLboo,27725
+bandu/translate.py,sha256=YGTkwne4bdrw649OjRKBio7IBsCNVoa__rjkFZK6uRI,2217
+bandu/wfk_class.py,sha256=QchfEjqssSHbC3IcXrKNz3euFLR62WMj-ZPFd2m0mX0,26215
+bandu/xsf_reader.py,sha256=gfv7LsTofWw4PrcOeqltOREJD6RLDq8CeFSsnlfohEw,4778
+bandu-1.2.0.dist-info/licenses/LICENSE,sha256=jk_B-WYDiyH9RtxC45pO6JUtBxmfX5i240dVzv1okCg,1088
+bandu-1.2.0.dist-info/METADATA,sha256=abHRtBrAvc6Vos3f5SwcvdOilNA4pu90mEVhK3nxapU,8945
+bandu-1.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+bandu-1.2.0.dist-info/top_level.txt,sha256=AxbMFU3BRdjCr75K9gAdblwlBMQ3qr9-AaCC-IS8OWs,6
+bandu-1.2.0.dist-info/RECORD,,

bandu-1.1.0.dist-info/RECORD

@@ -1,14 +0,0 @@
-bandu/abinit_reader.py,sha256=U4HUUTnju9MpyGtWMOedUQLln90k2F0XIv0Q0zcP05c,47704
-bandu/bandu.py,sha256=EA8AsM517NrnUL6Za5q4W0NAklOCbLomvY_7v51jQ48,12786
-bandu/brillouin_zone.py,sha256=-SarCuvUthk5h_sFHM6KDHLns1eCWGk_v5fHngWFu08,7997
-bandu/colors.py,sha256=OcIBwVh9ieu04n1cruRgyoYslKsdfJKf-u4oWMd3CwQ,2316
-bandu/isosurface_class.py,sha256=o9VqcZ8b1tqkSQN6oJp7PSPkt-QNZg1V_IUbhAsFcgA,10018
-bandu/plotter.py,sha256=wSIA1TpwhioPUHpBe4_gc14e8K98fv3q0LwwD5NLboo,27725
-bandu/translate.py,sha256=YGTkwne4bdrw649OjRKBio7IBsCNVoa__rjkFZK6uRI,2217
-bandu/wfk_class.py,sha256=zsgC17OcWTLan4riaGW2ObBvFHICmZqbizClJV8hsmI,26158
-bandu/xsf_reader.py,sha256=gfv7LsTofWw4PrcOeqltOREJD6RLDq8CeFSsnlfohEw,4778
-bandu-1.1.0.dist-info/licenses/LICENSE,sha256=jk_B-WYDiyH9RtxC45pO6JUtBxmfX5i240dVzv1okCg,1088
-bandu-1.1.0.dist-info/METADATA,sha256=RiyKZil80B49SCmAxMNyzdn93TOOZWV9o_XCBRru3QM,5611
-bandu-1.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-bandu-1.1.0.dist-info/top_level.txt,sha256=AxbMFU3BRdjCr75K9gAdblwlBMQ3qr9-AaCC-IS8OWs,6
-bandu-1.1.0.dist-info/RECORD,,