bandu 1.0.0__py3-none-any.whl → 1.1.1__py3-none-any.whl

bandu/abinit_reader.py

@@ -193,9 +193,23 @@ class Abinit7WFK():
         print('WFK header read')
         wfk.close()
     #-----------------------------------------------------------------------------------------------------------------#
+    # check for time reversal symmetry
+    def _CheckTimeRev(
+        self
+    ):
+        # if system is centrosymmetric, do not double reciprocal symmetry operations
+        if True in [np.array_equal(-np.identity(3),mat) for mat in self.symrel]:
+            self.time_reversal = False
+        else:
+            self.time_reversal = True
+            print((
+            'Noncentrosymmetric system identified, assuming time reversal symmetry\n'
+            'To change this, set "check_time_rev" keyword to False when calling ReadWFK() or ReadEigenvalues()'
+            ))
+    #-----------------------------------------------------------------------------------------------------------------#
     # method to read entire body of abinit version 7 wavefunction file
     def ReadWFK(
-        self, energy_level=np.nan, width=np.nan
+        self, energy_level=np.nan, width=np.nan, check_time_rev:bool=True
     )->Generator[wc.WFK, None, None]:
         '''
         Method that constructs WFK objects from ABINIT v7 WFK file
@@ -212,6 +226,12 @@ class Abinit7WFK():
         Total range is equal to width, so look width/2 above and below energy_level
         If not defined but energy_level is defined, default is 0.005 Hartree
         '''
+        # check for time reversal symmetry
+        if check_time_rev:
+            self._CheckTimeRev()
+        else:
+            self.time_reversal = False
+        # read wfk file
         wfk = open(self.filename, 'rb')
         skip = True
         if energy_level is np.nan:
@@ -322,16 +342,23 @@ class Abinit7WFK():
             typat=self.typat,
             znucltypat=self.znucltypat,
             fermi_energy=self.fermi,
-            non_symm_vecs=np.array(self.tnons)
+            non_symm_vecs=np.array(self.tnons),
+            time_reversal=self.time_reversal
         )
     #-----------------------------------------------------------------------------------------------------------------#
     # method to read only eigenvalues from body of abinit version 7 wavefunction file
     def ReadEigenvalues(
-        self
+        self, check_time_rev:bool=True
     )->Generator[wc.WFK, None, None]:
         '''
         Method that constructs WFK objects from ABINIT v7 WFK file.
         '''
+        # check for time reversal symmetry
+        if check_time_rev:
+            self._CheckTimeRev()
+        else:
+            self.time_reversal = False
+        # read wfk
         wfk = open(self.filename, 'rb')
         #-----------#
         # skip header
@@ -378,7 +405,8 @@ class Abinit7WFK():
                     typat=self.typat,
                     znucltypat=self.znucltypat,
                     fermi_energy=self.fermi,
-                    non_symm_vecs=np.array(self.tnons)
+                    non_symm_vecs=np.array(self.tnons),
+                    time_reversal=self.time_reversal
                 )
         print('WFK body read')
         wfk.close()
@@ -648,9 +676,23 @@ class Abinit10WFK():
         print('WFK header read')
         wfk.close()
     #-----------------------------------------------------------------------------------------------------------------#
+    # check for time reversal symmetry
+    def _CheckTimeRev(
+        self
+    ):
+        # if system is centrosymmetric, do not double reciprocal symmetry operations
+        if True in [np.array_equal(-np.identity(3),mat) for mat in self.symrel]:
+            self.time_reversal = False
+        else:
+            self.time_reversal = True
+            print((
+            'Noncentrosymmetric system identified, assuming time reversal symmetry\n'
+            'To change this, set "check_time_rev" keyword to False when calling ReadWFK() or ReadEigenvalues()'
+            ))
+    #-----------------------------------------------------------------------------------------------------------------#
     # method to read entire body of abinit version 7 wavefunction file
     def ReadWFK(
-        self, energy_level=np.nan, width=np.nan
+        self, energy_level=np.nan, width=np.nan, check_time_rev:bool=True
     )->Generator[wc.WFK, None, None]:
         '''
         Method that constructs WFK objects from ABINIT v10 WFK file.
@@ -667,6 +709,12 @@ class Abinit10WFK():
         Total range is equal to width, so look width/2 above and below energy_level
         If not defined but energy_level is defined, default is 0.005 Hartree
         '''
+        # check for time reversal symmetry
+        if check_time_rev:
+            self._CheckTimeRev()
+        else:
+            self.time_reversal = False
+        # read wfk
         wfk = open(self.filename, 'rb')
         skip = True
         if energy_level is np.nan:
@@ -798,16 +846,23 @@ class Abinit10WFK():
             typat=self.typat,
             znucltypat=self.znucltypat,
             fermi_energy=self.fermi,
-            non_symm_vecs=np.array(self.tnons)
+            non_symm_vecs=np.array(self.tnons),
+            time_reversal=self.time_reversal
         )
     #-----------------------------------------------------------------------------------------------------------------#
     # method to read only eigenvalues from body of abinit version 10 wavefunction file
     def ReadEigenvalues(
-        self
+        self, check_time_rev:bool=True
     )->Generator[wc.WFK, None, None]:
         '''
         Method that constructs WFK objects from ABINIT v10 WFK file.
         '''
+        # check for time reversal symmetry
+        if check_time_rev:
+            self._CheckTimeRev()
+        else:
+            self.time_reversal = False
+        # read wfk
         wfk = open(self.filename, 'rb')
         #-----------#
         # skip header
@@ -874,7 +929,8 @@ class Abinit10WFK():
                     typat=self.typat,
                     znucltypat=self.znucltypat,
                     fermi_energy=self.fermi,
-                    non_symm_vecs=np.array(self.tnons)
+                    non_symm_vecs=np.array(self.tnons),
+                    time_reversal=self.time_reversal
                 )
         print('WFK body read')
         wfk.close()
@@ -907,7 +963,11 @@ 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'][:]
-        self.znucltypat:list = [int(self.zion[i-1]) for i in self.typat]
+        _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.bands = [self.nband]
 #---------------------------------------------------------------------------------------------------------------------#
 #------------------------------------------------------ METHODS ------------------------------------------------------#
@@ -919,31 +979,52 @@ class AbinitNetCDF():
         from netCDF4 import Dataset
         return Dataset(self.filename,format='NETCDF4')
     #-----------------------------------------------------------------------------------------------------------------#
+    # check for time reversal symmetry
+    def _CheckTimeRev(
+        self
+    ):
+        # if system is centrosymmetric, do not double reciprocal symmetry operations
+        if True in [np.array_equal(-np.identity(3),mat) for mat in self.symrel]:
+            self.time_reversal = False
+        else:
+            self.time_reversal = True
+            print((
+            'Noncentrosymmetric system identified, assuming time reversal symmetry\n'
+            'To change this, set "check_time_rev" keyword to False when calling ReadWFK() or ReadEigenvalues()'
+            ))
+    #-----------------------------------------------------------------------------------------------------------------#
     # fetch wavefunction coefficients from netcdf dataset
     def ReadWFK(
-        self, energy_level:float=np.nan, width:float=np.nan
+        self, energy_level:float=np.nan, width:float=np.nan, check_time_rev:bool=True
     )->Generator[wc.WFK, None, None]:
+        # check for time reversal symmetry
+        if check_time_rev:
+            self._CheckTimeRev()
+        else:
+            self.time_reversal = False
         eigs:np.ndarray = self.dataset.variables['eigenvalues'][:][0]
         pw_inds:np.ndarray = self.dataset.variables['reduced_coordinates_of_plane_waves'][:]
         # restructure wavefunction coefficients
-        coeffs:np.ndarray = self.dataset.variables['coefficients_of_wavefunctions'][:][0]
-        for i, kpt in enumerate(coeffs):
-            print(f'Reading kpoint {i+1} of {self.nkpt}', end='\r')
+        for kpt in range(self.nkpt):
+            print(f'Reading kpoint {kpt+1} of {self.nkpt}', end='\r')
             kpt_coeffs = []
             # format plane wave indices
-            kpt_pw_inds = pw_inds[i]
+            kpt_pw_inds = pw_inds[kpt]
             kpt_pw_inds = kpt_pw_inds[~kpt_pw_inds.mask]
             kpt_pw_inds = kpt_pw_inds.reshape((-1,3))
-            for band in kpt:
+            kpt_pw_inds = np.ma.getdata(kpt_pw_inds)
+            coeffs = self.dataset.variables['coefficients_of_wavefunctions'][0,kpt]
+            for band in coeffs:
                 band = band[0]
                 band = band[~band.mask]
                 band = band.reshape((-1,2))
+                band = np.ma.getdata(band)
                 kpt_coeffs.append(band[:,0] + 1j*band[:,1])
             yield wc.WFK(
-                eigenvalues=eigs[i,:], 
+                eigenvalues=eigs[kpt,:], 
                 wfk_coeffs=np.array(kpt_coeffs),
                 pw_indices=kpt_pw_inds,
-                kpoints=self.kpts[i],
+                kpoints=self.kpts[kpt],
                 nkpt=self.nkpt,
                 nbands=self.nband,
                 ngfftx=self.ngfftx,
@@ -957,13 +1038,19 @@ class AbinitNetCDF():
                 typat=self.typat,
                 znucltypat=self.znucltypat,
                 fermi_energy=self.fermi,
-                non_symm_vecs=self.tnons
+                non_symm_vecs=self.tnons,
+                time_reversal=self.time_reversal
             )
     #-----------------------------------------------------------------------------------------------------------------#
     # fetch eigenvalues from netcdf dataset
     def ReadEigenvalues(
-        self, energy_level:float=np.nan, width:float=np.nan
+        self, energy_level:float=np.nan, width:float=np.nan, check_time_rev:bool=True
     )->Generator[wc.WFK, None, None]:
+        # check for time reversal symmetry
+        if check_time_rev:
+            self._CheckTimeRev()
+        else:
+            self.time_reversal = False
         eigs:np.ndarray = self.dataset.variables['eigenvalues'][:][0]
         for i, kpt in enumerate(self.kpts):
             print(f'Reading kpoint {i+1} of {self.nkpt}', end='\r')
@@ -983,7 +1070,8 @@ class AbinitNetCDF():
                 typat=self.typat,
                 znucltypat=self.znucltypat,
                 fermi_energy=self.fermi,
-                non_symm_vecs=self.tnons
+                non_symm_vecs=self.tnons,
+                time_reversal=self.time_reversal
             )        
 
 #---------------------------------------------------------------------------------------------------------------------#

bandu/bandu.py

@@ -51,7 +51,6 @@ class BandU():
         self.low_mem:bool=low_mem
         self.found_states:int=0
         self.bandu_fxns:list[wc.WFK]=[]
-        self.duped_states:int=0
         self.plot=plot
         # find all states within width
         self._FindStates(energy_level, width, wfks)
@@ -62,7 +61,7 @@ class BandU():
         if plot:
             self._PlotEigs(principal_vals)
         # normalize bandu functions
-        for i in range(self.found_states + self.duped_states):
+        for i in range(self.found_states):
             self.bandu_fxns[i] = self.bandu_fxns[i].Normalize()
         # compute ratios
         omega_vals, omega_check = self._CheckOmega()
@@ -169,7 +168,7 @@ class BandU():
     def _PrincipalComponents(
         self
     )->np.ndarray:
-        total_states = self.found_states + self.duped_states
+        total_states = self.found_states
         # organize wfk coefficients 
         x = self.bandu_fxns[0].ngfftx
         y = self.bandu_fxns[0].ngffty
@@ -196,7 +195,7 @@ class BandU():
     def _CheckOmega(
         self
     )->tuple[np.ndarray, np.ndarray]:
-        total_states = self.found_states + self.duped_states
+        total_states = self.found_states
         omega_vals = np.zeros((total_states, 3), dtype=float)
         vals = np.linspace(start=-0.01, stop=0.01, num=3)
         for i, val in enumerate(vals):
@@ -209,7 +208,7 @@ class BandU():
         omega_diff1 = (omega_vals[:,1] - omega_vals[:,0])
         omega_diff2 = (omega_vals[:,2] - omega_vals[:,1])
         omega_check = np.sign(omega_diff1) + np.sign(omega_diff2)
-        return omega_vals, omega_check
+        return omega_vals[:,1], omega_check
     #-----------------------------------------------------------------------------------------------------------------#
     # plot eigenvalues from PCA
     def _PlotEigs(
@@ -243,7 +242,7 @@ class BandU():
     def ToXSF(
         self, nums:list[int]=[], xsf_name:str='Principal_orbital_component'
     ):
-        total_states = self.found_states + self.duped_states
+        total_states = self.found_states
         if nums is []:
             nums = [0,total_states-1]
         else:

bandu/plotter.py

@@ -462,9 +462,20 @@ class Plotter():
             symrel = fermi_wfk.symrel
             nsym = fermi_wfk.nsym
             kpts = fermi_wfk.kpts
-            permute_overlaps = wc.WFK(symrel=np.array(symrel), nsym=nsym, nbands=nband)
-            new_pts, overlaps = permute_overlaps.Symmetrize(points=np.array(kpts), values=overlaps, reciprocal=True)
-            self.isosurface.points = new_pts
+            all_kpts = np.zeros((1,3))
+            all_overlaps = np.zeros((1,nband))
+            new_wfk = wc.WFK(symrel=np.array(symrel), nsym=nsym, nbands=nband)
+            for i, kpt in enumerate(kpts):
+                unique_kpts, _ = new_wfk.Symmetrize(
+                    points=kpt,
+                    reciprocal=True
+                )
+                all_kpts = np.concatenate((all_kpts, unique_kpts), axis=0)
+                new_overlaps = np.repeat(overlaps[i,:].reshape((1,-1)), unique_kpts.shape[0], axis=0)
+                all_overlaps = np.concatenate((all_overlaps, new_overlaps), axis=0)
+            kpts = np.delete(all_kpts, 0, axis=0)
+            overlaps = np.delete(all_overlaps, 0, axis=0)
+            self.isosurface.points = np.matmul(kpts, self.isosurface.rec_latt)
         # interpolate overlap values for smooth coloration
         scalars = []
         for i in range(overlaps.shape[1]):

bandu/wfk_class.py

@@ -376,8 +376,6 @@ class WFK():
             Choose which band to pull coefficients from (indexed starting from zero).
             Default assumes coefficients from a single band are provided (-1).
         '''
-        # first check for time reversal symmetry
-        self._CheckTimeRevSym()
         # find symmetric kpoints
         kpoint = kpoint.reshape((1,3))
         sym_kpoints, _ = self.Symmetrize(kpoint, unique=False, reciprocal=True)

{bandu-1.0.0.dist-info → bandu-1.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bandu
-Version: 1.0.0
+Version: 1.1.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
@@ -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.1.1.dist-info/RECORD

@@ -0,0 +1,14 @@
+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.1.dist-info/licenses/LICENSE,sha256=jk_B-WYDiyH9RtxC45pO6JUtBxmfX5i240dVzv1okCg,1088
+bandu-1.1.1.dist-info/METADATA,sha256=hLKKV7kP7l0lo6CKnUvHxHXH1_MozcRGG7ck98O1NDw,8945
+bandu-1.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+bandu-1.1.1.dist-info/top_level.txt,sha256=AxbMFU3BRdjCr75K9gAdblwlBMQ3qr9-AaCC-IS8OWs,6
+bandu-1.1.1.dist-info/RECORD,,

bandu-1.0.0.dist-info/RECORD

@@ -1,14 +0,0 @@
-bandu/abinit_reader.py,sha256=T_GjUi4MOUqhr41wMg5bAgP6tqbhwf0TduC9CLKSTOI,43836
-bandu/bandu.py,sha256=RmaJDdbMEechutwUKoOQSuUBYjIP8RUCx5ElqRekwkE,12894
-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=Ae0fCSwsbxWlmJ1vnK22pbxt_igjffNuR4a9J587Kzw,27169
-bandu/translate.py,sha256=YGTkwne4bdrw649OjRKBio7IBsCNVoa__rjkFZK6uRI,2217
-bandu/wfk_class.py,sha256=Bbyf8OKocEQde3mda-sd2F-l9Pd9hrvPMSESycv9wto,26241
-bandu/xsf_reader.py,sha256=gfv7LsTofWw4PrcOeqltOREJD6RLDq8CeFSsnlfohEw,4778
-bandu-1.0.0.dist-info/licenses/LICENSE,sha256=jk_B-WYDiyH9RtxC45pO6JUtBxmfX5i240dVzv1okCg,1088
-bandu-1.0.0.dist-info/METADATA,sha256=Cy1aP_MxQnm3piKcy0729_i5Y4ITNv_52cQaRbSHIOg,5611
-bandu-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-bandu-1.0.0.dist-info/top_level.txt,sha256=AxbMFU3BRdjCr75K9gAdblwlBMQ3qr9-AaCC-IS8OWs,6
-bandu-1.0.0.dist-info/RECORD,,