bandu 1.3.5__py3-none-any.whl → 1.3.7__py3-none-any.whl

bandu/xsf_reader.py

@@ -1,91 +1,92 @@
-import numpy as np
-
-atom_labels = {1:'H', 2:'He', 3:'Li', 4:'Be', 5:'B', 6:'C', 7:'N', 8:'O', 9:'F', 10:'Ne', 11:'Na', 12:'Mg', 13:'Al', 
-               14:'Si', 15:'P', 16:'S', 17:'Cl', 18:'Ar', 19:'K', 20:'Ca', 21:'Sc', 22:'Ti', 23:'V', 24:'Cr', 25:'Mn',
-               26:'Fe', 27:'Co', 28:'Ni', 29:'Cu', 30:'Zn', 31:'Ga', 32:'Ge', 33:'As', 34:'Se', 35:'Br', 36:'Kr', 
-               37:'Rb', 38:'Sr', 39:'Y', 40:'Zr', 41:'Nb', 42:'Mo', 43:'Tc', 44:'Ru', 45:'Rh', 46:'Pd', 47:'Ag', 
-               48:'Cd', 49:'In', 50:'Sn', 51:'Sb', 52:'Te', 53:'I', 54:'Xe', 55:'Cs', 56:'Ba', 57:'La', 58:'Ce', 
-               59:'Pr', 60:'Nd', 61:'Pm', 62:'Sm', 63:'Eu', 64:'Gd', 65:'Tb', 66:'Dy', 67:'Ho', 68:'Er', 69:'Tm', 
-               70:'Yb', 71:'Lu', 72:'Hf', 73:'Ta', 74:'W', 75:'Re', 76:'Os', 77:'Ir', 78:'Pt', 79:'Au', 80:'Hg', 
-               81:'Tl', 82:'Pb', 83:'Bi', 84:'Po', 85:'At', 86:'Rn', 87:'Fr', 88:'Ra', 89:'Ac', 90:'Th', 91:'Pa', 
-               92:'U'}
-
-class XSF():
-    def __init__(
-            self, 
-            xsf_file:str='WFK.xsf',
-            datagrid:str='BEGIN_DATAGRID_3D_principal_orbital_component'
-        )->None:
-        '''
-        Class for reading in XSF files
-
-        Parameters
-        ----------
-        xsf_file : str
-            Path to XSF file
-        datagrid : str
-            Name of datagrid to be read in\n
-            Default is "BEGIN_DATAGRID_3D_principal_orbital_component"
-        '''
-    # if xsf file is supplied, read in parameters
-        self.xsf_file = xsf_file
-        with open(xsf_file, 'r') as xsf:
-            self.xsf_lines = xsf.readlines()
-        self.lattice = np.zeros((3,3))
-        for i, line in enumerate(self.xsf_lines):
-            # get lattice vectors from XSF file
-            if line.strip() == 'PRIMVEC':
-                self.lattice[0,:] = [float(val) for val in self.xsf_lines[i+1].strip().split(' ') if val != '']
-                self.lattice[1,:] = [float(val) for val in self.xsf_lines[i+2].strip().split(' ') if val != '']
-                self.lattice[2,:] = [float(val) for val in self.xsf_lines[i+3].strip().split(' ') if val != '']
-            # get number of atoms and atomic symbols
-            # get atomic coordinates from XSF file
-            if line.strip() == 'PRIMCOORD':
-                self.natoms = int(self.xsf_lines[i+1].strip().split(' ')[0])
-                self.coords = np.zeros((self.natoms, 3))
-                self.elements = []
-                for atom in range(self.natoms):
-                    coord = self.xsf_lines[i+atom+2].strip().split(' ')
-                    coord = [float(val) for val in coord if val != '']
-                    element = atom_labels[int(coord[0])]
-                    self.elements.append(element)
-                    del coord[0]
-                    self.coords[atom,:] = coord
-            # once density block is reached, get ngfft spacing and end init
-            if line.strip() == datagrid:
-                ngfft_spacing = self.xsf_lines[i+1].strip().split(' ')
-                ngfft_spacing = [int(val) for val in ngfft_spacing if val != '']
-                self.ngfftx = ngfft_spacing[0]
-                self.ngffty = ngfft_spacing[1]
-                self.ngfftz = ngfft_spacing[2]
-                return None
-    #-----------------------------------------------------------------------------------------------------------------#
-    # method reading in BandU eigenfunction from XSF
-    def ReadGrid(
-        self
-    )->np.ndarray:
-        '''
-        Method for reading in density grid from XSF file. Returns grid as N dimensional numpy array.
-        '''
-        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() == '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 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 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.ngfftx, self.ngffty, self.ngfftz), order='F')
+import numpy as np
+
+atom_labels = {1:'H', 2:'He', 3:'Li', 4:'Be', 5:'B', 6:'C', 7:'N', 8:'O', 9:'F', 10:'Ne', 11:'Na', 12:'Mg', 13:'Al', 
+               14:'Si', 15:'P', 16:'S', 17:'Cl', 18:'Ar', 19:'K', 20:'Ca', 21:'Sc', 22:'Ti', 23:'V', 24:'Cr', 25:'Mn',
+               26:'Fe', 27:'Co', 28:'Ni', 29:'Cu', 30:'Zn', 31:'Ga', 32:'Ge', 33:'As', 34:'Se', 35:'Br', 36:'Kr', 
+               37:'Rb', 38:'Sr', 39:'Y', 40:'Zr', 41:'Nb', 42:'Mo', 43:'Tc', 44:'Ru', 45:'Rh', 46:'Pd', 47:'Ag', 
+               48:'Cd', 49:'In', 50:'Sn', 51:'Sb', 52:'Te', 53:'I', 54:'Xe', 55:'Cs', 56:'Ba', 57:'La', 58:'Ce', 
+               59:'Pr', 60:'Nd', 61:'Pm', 62:'Sm', 63:'Eu', 64:'Gd', 65:'Tb', 66:'Dy', 67:'Ho', 68:'Er', 69:'Tm', 
+               70:'Yb', 71:'Lu', 72:'Hf', 73:'Ta', 74:'W', 75:'Re', 76:'Os', 77:'Ir', 78:'Pt', 79:'Au', 80:'Hg', 
+               81:'Tl', 82:'Pb', 83:'Bi', 84:'Po', 85:'At', 86:'Rn', 87:'Fr', 88:'Ra', 89:'Ac', 90:'Th', 91:'Pa', 
+               92:'U'}
+
+class XSF():
+    def __init__(
+            self, 
+            xsf_file:str='WFK.xsf',
+            datagrid:str='BEGIN_DATAGRID_3D_principal_orbital_component'
+        )->None:
+        '''
+        Class for reading in XSF files
+
+        Parameters
+        ----------
+        xsf_file : str
+            Path to XSF file
+        datagrid : str
+            Name of datagrid to be read in\n
+            Default is "BEGIN_DATAGRID_3D_principal_orbital_component"
+        '''
+    # if xsf file is supplied, read in parameters
+        self.xsf_file = xsf_file
+        self.datagrid = datagrid
+        with open(xsf_file, 'r') as xsf:
+            self.xsf_lines = xsf.readlines()
+        self.lattice = np.zeros((3,3))
+        for i, line in enumerate(self.xsf_lines):
+            # get lattice vectors from XSF file
+            if line.strip() == 'PRIMVEC':
+                self.lattice[0,:] = [float(val) for val in self.xsf_lines[i+1].strip().split(' ') if val != '']
+                self.lattice[1,:] = [float(val) for val in self.xsf_lines[i+2].strip().split(' ') if val != '']
+                self.lattice[2,:] = [float(val) for val in self.xsf_lines[i+3].strip().split(' ') if val != '']
+            # get number of atoms and atomic symbols
+            # get atomic coordinates from XSF file
+            if line.strip() == 'PRIMCOORD':
+                self.natoms = int(self.xsf_lines[i+1].strip().split(' ')[0])
+                self.coords = np.zeros((self.natoms, 3))
+                self.elements = []
+                for atom in range(self.natoms):
+                    coord = self.xsf_lines[i+atom+2].strip().split(' ')
+                    coord = [float(val) for val in coord if val != '']
+                    element = atom_labels[int(coord[0])]
+                    self.elements.append(element)
+                    del coord[0]
+                    self.coords[atom,:] = coord
+            # once density block is reached, get ngfft spacing and end init
+            if line.strip() == self.datagrid:
+                ngfft_spacing = self.xsf_lines[i+1].strip().split(' ')
+                ngfft_spacing = [int(val) for val in ngfft_spacing if val != '']
+                self.ngfftx = ngfft_spacing[0]
+                self.ngffty = ngfft_spacing[1]
+                self.ngfftz = ngfft_spacing[2]
+                return None
+    #-----------------------------------------------------------------------------------------------------------------#
+    # method reading in BandU eigenfunction from XSF
+    def ReadGrid(
+        self
+    )->np.ndarray:
+        '''
+        Method for reading in density grid from XSF file. Returns grid as N dimensional numpy array.
+        '''
+        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() == self.datagrid:
+                # 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 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 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.ngfftx, self.ngffty, self.ngfftz), order='F')
         return density_lines

{bandu-1.3.5.dist-info → bandu-1.3.7.dist-info}/METADATA

@@ -1,192 +1,192 @@
-Metadata-Version: 2.4
-Name: bandu
-Version: 1.3.5
-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
-Project-URL: Issues, https://github.com/pcross0405/BandU/issues
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.11
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Dynamic: license-file
-
-# BandU
-------------------------------------------------------------------------------------------------------- 
-<h1><p align="center">BandU OVERVIEW</p></h1>
-
-<p align="justify">A package that performs a principal component inspired analysis on the Bloch wavefunctions of 
-periodic material to provide a real space visualization of the states that significantly contribute to the Fermi surface.
-</p>
-
-<p align="justify">These real space functions can then be projected onto the Fermi surface to provide a clear visual
-for where a nesting vector may combine two points in reciprocal space.</p>
-
-<p align="justify">This package is designed to be very straightforward in its use, offering Fermi surface and BandU function 
-visualizations in as little as 5 lines of Python script. This package can also be used to just visual the Fermi surface, without 
-BandU projections, if provided with the necessary k-point and eigenvalue data.</p>
-
--------------------------------------------------------------------------------------------------------  
-<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"
-
-2) Type "cd BandU"
-
-3) Make sure you have python's build tool up to date with  
-   "python3 -m pip install --upgrade build"
-
-4) Once up to date type  
-   "python3 -m build"
-
-5) This should create a "dist" directory with a .whl file inside
-
-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>
-
-REQUIRED FOR VISUALIZING FERMI SURFACE
-
-   - [pyvista](https://pyvista.org/)
-
-   - [numpy](https://numpy.org/)
-
-REQUIRED FOR CUSTOM COLORS
-
-   - [matplotlib](https://matplotlib.org/)
-
-WAVEFUNCTIONS THAT CAN BE READ DIRECTLY
-
-> Currently only reading directly from ABINIT 7 and 10 wavefunctions is supported.
-> Reading eigenvalues from other DFT packages will come in future updates.
-
-   - [ABINIT](https://abinit.github.io/abinit_web/)
-
----------------------------------------------------------------------------------------------------------  
-<h1><p align="center">REPORTING ISSUES</p></h1>
-
-Please report any issues [here](https://github.com/pcross0405/BandU/issues)  
-
--------------------------------------------------------------------------------------------------------------------------  
-<h1><p align="center">TUTORIAL</p></h1>
-
-An example script that can run the different functions of the BandU program is given below.
--------------------------------------------------------------------------------------------
-<pre>
-from bandu.bandu import BandU
-from bandu.abinit_reader import AbinitWFK
-from bandu.isosurface_class import Isosurface
-from bandu.plotter import Plotter
-from bandu.colors import Colors
-
-root_name = 'your file root name here' # root_name of WFK files and of XSF files
-xsf_number = 1 # XSF file number to be read in
-energy_level = 0.000 # Energy relative to the Fermi energy to be sampled
-width = 0.0005 # Search half the the width above and below the specified energy level
-wfk_path = f'path\to\WFK\file\{root_name}_o_WFK'
-xsf_path = f'path\to\XSF\file\{root_name}_bandu_{xsf_number}'
-bandu_name = f'{root_name}_bandu'
-
-def main(
-        principal_orbital_components:bool, 
-        fermi_surface:bool, 
-        fermi_surface_projection:bool,
-        load_fermi_surface:bool
-)->None:
-    # 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
-         )
-        wfk = BandU(
-            wfks = wfk_gen,
-            energy_level = energy_level,
-            width = width,
-            sym = False
-         )
-        wfk.ToXSF(
-            xsf_name = bandu_name,
-            nums = [1,10]
-         )
-    # 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,
-            width = width
-        )
-        contours.Contour() # make contours
-        plot = Plotter(
-            isosurface = contours,
-            save_file=f'{root_name}_bandu_{xsf_number}_fermi_surf.pkl'
-         ) # create plotter object
-        overlap_vals = plot.SurfaceColor(
-            wfk_path=wfk_path,
-            xsf_path=xsf_path,
-        ) # compute overlap between principal orbital component and states in Brillouin Zone
-        plot.Plot(
-            surface_vals = overlap_vals,
-            colormap = Colors().blues,
-        ) # plot contours
-    # 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(
-        principal_orbital_components=True, 
-        fermi_surface=True, 
-        fermi_surface_projection=True,
-        load_fermi_surface=True
-    )
-<pre>
+Metadata-Version: 2.4
+Name: bandu
+Version: 1.3.7
+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
+Project-URL: Issues, https://github.com/pcross0405/BandU/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# BandU
+------------------------------------------------------------------------------------------------------- 
+<h1><p align="center">BandU OVERVIEW</p></h1>
+
+<p align="justify">A package that performs a principal component inspired analysis on the Bloch wavefunctions of 
+periodic material to provide a real space visualization of the states that significantly contribute to the Fermi surface.
+</p>
+
+<p align="justify">These real space functions can then be projected onto the Fermi surface to provide a clear visual
+for where a nesting vector may combine two points in reciprocal space.</p>
+
+<p align="justify">This package is designed to be very straightforward in its use, offering Fermi surface and BandU function 
+visualizations in as little as 5 lines of Python script. This package can also be used to just visual the Fermi surface, without 
+BandU projections, if provided with the necessary k-point and eigenvalue data.</p>
+
+-------------------------------------------------------------------------------------------------------  
+<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"
+
+2) Type "cd BandU"
+
+3) Make sure you have python's build tool up to date with  
+   "python3 -m pip install --upgrade build"
+
+4) Once up to date type  
+   "python3 -m build"
+
+5) This should create a "dist" directory with a .whl file inside
+
+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>
+
+REQUIRED FOR VISUALIZING FERMI SURFACE
+
+   - [pyvista](https://pyvista.org/)
+
+   - [numpy](https://numpy.org/)
+
+REQUIRED FOR CUSTOM COLORS
+
+   - [matplotlib](https://matplotlib.org/)
+
+WAVEFUNCTIONS THAT CAN BE READ DIRECTLY
+
+> Currently only reading directly from ABINIT 7 and 10 wavefunctions is supported.
+> Reading eigenvalues from other DFT packages will come in future updates.
+
+   - [ABINIT](https://abinit.github.io/abinit_web/)
+
+---------------------------------------------------------------------------------------------------------  
+<h1><p align="center">REPORTING ISSUES</p></h1>
+
+Please report any issues [here](https://github.com/pcross0405/BandU/issues)  
+
+-------------------------------------------------------------------------------------------------------------------------  
+<h1><p align="center">TUTORIAL</p></h1>
+
+An example script that can run the different functions of the BandU program is given below.
+-------------------------------------------------------------------------------------------
+<pre>
+from bandu.bandu import BandU
+from bandu.abinit_reader import AbinitWFK
+from bandu.isosurface_class import Isosurface
+from bandu.plotter import Plotter
+from bandu.colors import Colors
+
+root_name = 'your file root name here' # root_name of WFK files and of XSF files
+xsf_number = 1 # XSF file number to be read in
+energy_level = 0.000 # Energy relative to the Fermi energy to be sampled
+width = 0.0005 # Search half the the width above and below the specified energy level
+wfk_path = f'path\to\WFK\file\{root_name}_o_WFK'
+xsf_path = f'path\to\XSF\file\{root_name}_bandu_{xsf_number}'
+bandu_name = f'{root_name}_bandu'
+
+def main(
+        principal_orbital_components:bool, 
+        fermi_surface:bool, 
+        fermi_surface_projection:bool,
+        load_fermi_surface:bool
+)->None:
+    # 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
+         )
+        wfk = BandU(
+            wfks = wfk_gen,
+            energy_level = energy_level,
+            width = width,
+            sym = False
+         )
+        wfk.ToXSF(
+            xsf_name = bandu_name,
+            nums = [1,10]
+         )
+    # 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,
+            width = width
+        )
+        contours.Contour() # make contours
+        plot = Plotter(
+            isosurface = contours,
+            save_file=f'{root_name}_bandu_{xsf_number}_fermi_surf.pkl'
+         ) # create plotter object
+        overlap_vals = plot.SurfaceColor(
+            wfk_path=wfk_path,
+            xsf_path=xsf_path,
+        ) # compute overlap between principal orbital component and states in Brillouin Zone
+        plot.Plot(
+            surface_vals = overlap_vals,
+            colormap = Colors().blues,
+        ) # plot contours
+    # 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(
+        principal_orbital_components=True, 
+        fermi_surface=True, 
+        fermi_surface_projection=True,
+        load_fermi_surface=True
+    )
+<pre>

bandu-1.3.7.dist-info/RECORD

@@ -0,0 +1,14 @@
+bandu/abinit_reader.py,sha256=frP70_tvtVLfe2qhdWLKyPXFpe3YJcBlYDEG5gI9ZNg,46462
+bandu/bandu.py,sha256=SfpYZf7VM9pmZBcBjnssDer2AqYVUkuwlsZ7g0o_H5g,14726
+bandu/brillouin_zone.py,sha256=QFXmJz-OM4XL-NuWFFP2C4lYI7-sOfHnU1rFXFK6gLI,7812
+bandu/colors.py,sha256=v1XMljrcF81z6Fth5UjL3jKh0C9nPZzUsbUeg4hSDuE,2270
+bandu/isosurface_class.py,sha256=dj1yCFGobhk0JrkGdmAA_EvYy-6ErvzsbRrwBRpmPEs,10022
+bandu/plotter.py,sha256=hWEzBwR5eN46r-l6UF4BKmXauqYMf0GPWDZHQJ6fyak,27149
+bandu/translate.py,sha256=gl-xUZezK3fnJAWaKhmksVewtfAlCc6DWSFf9FR4UCo,2180
+bandu/wfk_class.py,sha256=ZfpNRkRUwNgGpC7tf_2_g4R_D8TEGU7rMICy8ZqJdzc,25618
+bandu/xsf_reader.py,sha256=SLUQLCJ9qkdZbFKttVYP_4Xt-vjqumvcPG1xrFWOies,5009
+bandu-1.3.7.dist-info/licenses/LICENSE,sha256=WLZVs8X4n-vorZwIPyFdeQew3E5e0KG4Jfhutc2W9RA,1067
+bandu-1.3.7.dist-info/METADATA,sha256=hofiXVKFOEr_cQh6vFakbUJC7N7K5lIV4-KZw8QnNIc,8753
+bandu-1.3.7.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+bandu-1.3.7.dist-info/top_level.txt,sha256=AxbMFU3BRdjCr75K9gAdblwlBMQ3qr9-AaCC-IS8OWs,6
+bandu-1.3.7.dist-info/RECORD,,

{bandu-1.3.5.dist-info → bandu-1.3.7.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any