TB2J 0.9.12.9__py3-none-any.whl → 0.9.12.22__py3-none-any.whl

TB2J/green.py

@@ -56,13 +56,26 @@ def find_energy_ingap(evals, rbound, gap=2.0):
     find a energy inside a gap below rbound (right bound),
     return the energy gap top - 0.5.
     """
+    # print("Finding energy in gap...")
+    # print(f"Right bound: {rbound}, min gap size: {gap}")
     m0 = np.sort(evals.flatten())
-    m = m0[m0 < rbound]
+    # print(f"Min eigenvalue: {m0[0]}, Max eigenvalue: {m0[-1]}")
+    m = m0[m0 <= rbound]
+    # append the next state above rbound to m
+    if len(m0) > len(m):
+        m = np.append(m, m0[len(m)])
+    # print(f"Number of states below right bound: {len(m)}")
+    # print(f"Max eigenvalue below right bound: {m[-1]}")
     ind = np.where(np.diff(m) > gap)[0]
+    # print(f"Number of gaps found: {len(ind)}")
+    # print("ind[-1]: ", ind[-1] if len(ind) > 0 else "N/A")
+    emin = 0.0
     if len(ind) == 0:
-        return m0[0] - 0.5
+        emin = m0[0] - 0.5
     else:
-        return m[ind[-1] + 1] - 0.5
+        emin = m[ind[-1] + 1] - 0.5
+    # print("emin:", emin)
+    return emin
 
 
 class TBGreen:
@@ -79,12 +92,23 @@ class TBGreen:
         use_cache=False,
         cache_path=None,
         nproc=1,
+        initial_emin=-25,
+        smearing_width=0.01,
     ):
         """
         :param tbmodel: A tight binding model
         :param kmesh: size of monkhorst pack. e.g [6,6,6]
         :param efermi: fermi energy.
+        :param gamma: whether to include gamma point in monkhorst pack
+        :param kpts: user defined kpoints
+        :param kweights: weights for user defined kpoints
+        :param k_sym: whether the kpoints are symmetrized
+        :param use_cache: whether to use cache to store wavefunctions
+        :param cache_path: path to store cache
+        :param nproc: number of processes to use
+        :param emin: minimum energy relative to fermi level to consider
         """
+        self.initial_emin = initial_emin
         self.tbmodel = tbmodel
         self.is_orthogonal = tbmodel.is_orthogonal
         self.R2kfactor = tbmodel.R2kfactor
@@ -107,6 +131,7 @@ class TBGreen:
         self.nbasis = tbmodel.nbasis
         self.k_sym = k_sym
         self.nproc = nproc
+        self.fermi_width = float(smearing_width)
         self._prepare_eigen()
 
     def prepare_kpts(
@@ -235,9 +260,21 @@ class TBGreen:
             self.efermi = occ.efermi(copy.deepcopy(self.evals))
             print(f"Fermi energy found: {self.efermi}")
 
-        # self.evals, self.evecs = self._reduce_eigens(
-        #    self.evals, self.evecs, emin=self.efermi - 15.0, emax=self.efermi + 10.1
-        # )
+        self.adjusted_emin = (
+            find_energy_ingap(
+                self.evals, rbound=self.efermi + self.initial_emin, gap=2.0
+            )
+            - self.efermi
+        )
+        # print(f"Adjusted emin relative to Fermi level: {self.adjusted_emin}")
+        self.evals, self.evecs = self._reduce_eigens(
+            self.evals,
+            self.evecs,
+            emin=self.efermi + self.adjusted_emin,
+            emax=self.efermi + 5.1,
+            # emin=self.efermi -10,
+            # emax=self.efermi + 10,
+        )
         if self._use_cache:
             evecs = self.evecs
             self.evecs_shape = self.evecs.shape
@@ -309,14 +346,24 @@ class TBGreen:
                 evecs_k = self.get_evecs(ik)
                 # chekc if any of the evecs element is nan
                 rho += (
-                    (evecs_k * fermi(self.evals[ik], self.efermi, nspin=2))
+                    (
+                        evecs_k
+                        * fermi(
+                            self.evals[ik], self.efermi, width=self.fermi_width, nspin=2
+                        )
+                    )
                     @ evecs_k.T.conj()
                     * self.kweights[ik]
                 )
         else:
             for ik, _ in enumerate(self.kpts):
                 rho += (
-                    (self.get_evecs(ik) * fermi(self.evals[ik], self.efermi, nspin=2))
+                    (
+                        self.get_evecs(ik)
+                        * fermi(
+                            self.evals[ik], self.efermi, width=self.fermi_width, nspin=2
+                        )
+                    )
                     @ self.get_evecs(ik).T.conj()
                     @ self.get_Sk(ik)
                     * self.kweights[ik]
@@ -332,7 +379,7 @@ class TBGreen:
             rhok = np.einsum(
                 "ib,b, bj-> ij",
                 evec,
-                fermi(self.evals[ik], self.efermi, nspin=2),
+                fermi(self.evals[ik], self.efermi, width=self.fermi_width, nspin=2),
                 evec.conj().T,
             )
             for iR, R in enumerate(Rlist):
@@ -376,38 +423,28 @@ class TBGreen:
             Gk_all[ik] = self.get_Gk(ik, energy)
         return Gk_all
 
-    def get_GR(self, Rpts, energy, get_rho=False, Gk_all=None):
+    def compute_GR(self, Rpts, kpts, Gks):
+        Rvecs = np.array(Rpts)
+        phase = np.exp(self.k2Rfactor * np.einsum("ni,mi->nm", Rvecs, kpts))
+        phase *= self.kweights[None]
+        GR = np.einsum("kij,rk->rij", Gks, phase, optimize="optimal")
+        return GR
+
+    def get_GR(self, Rpts, energy, Gk_all=None):
         """calculate real space Green's function for one energy, all R points.
         G(R, epsilon) = G(k, epsilon) exp(-2\pi i R.dot. k)
         :param Rpts: R points
-        :param energy:
-        :returns:  real space green's function for one energy for a list of R.
-        :rtype:  dictionary, the keys are tuple of R, values are matrices of nbasis*nbasis
+        :param energy: energy value
+        :param Gk_all: optional pre-computed Gk for all k-points
+        :returns: real space green's function for one energy for a list of R.
+        :rtype: numpy array of shape (len(Rpts), nbasis, nbasis)
         """
-        Rpts = [tuple(R) for R in Rpts]
-        GR = defaultdict(lambda: 0.0j)
-        rhoR = defaultdict(lambda: 0.0j)
-        for ik, kpt in enumerate(self.kpts):
-            if Gk_all is None:
-                Gk = self.get_Gk(ik, energy)
-            else:
-                Gk = Gk_all[ik]
-            if get_rho:
-                if self.is_orthogonal:
-                    rhok = Gk
-                else:
-                    rhok = self.get_Sk(ik) @ Gk
-            for iR, R in enumerate(Rpts):
-                phase = np.exp(self.k2Rfactor * np.dot(R, kpt))
-                tmp = Gk * (phase * self.kweights[ik])
-                GR[R] += tmp
-                # change this if need full rho
-                if get_rho and R == (0, 0, 0):
-                    rhoR[R] += rhok * (phase * self.kweights[ik])
-        if get_rho:
-            return GR, rhoR
+        if Gk_all is None:
+            Gks = self.get_Gk_all(energy)
         else:
-            return GR
+            Gks = Gk_all
+
+        return self.compute_GR(Rpts, self.kpts, Gks)
 
     def get_GR_and_dGRdx1(self, Rpts, energy, dHdx):
         """

TB2J/interfaces/abacus/gen_exchange_abacus.py

@@ -91,11 +91,12 @@ data directory: {outpath}
             Rcut=Rcut,
             nproc=nproc,
             use_cache=use_cache,
+            output_path=output_path,
             orb_decomposition=orb_decomposition,
             index_magnetic_atoms=index_magnetic_atoms,
             description=description,
         )
-        exchange.run()
+        exchange.run(path=output_path)
         print("\n")
         print("All calculation finsihed. The results are in TB2J_results directory.")
 

TB2J/interfaces/wannier90_interface.py

@@ -1,8 +1,8 @@
 import os
 
 from ase.io import read
+from HamiltonIO.wannier import WannierHam
 
-from TB2J.myTB import MyTB
 from TB2J.utils import auto_assign_basis_name
 from TB2J.wannier import parse_atoms
 
@@ -62,11 +62,11 @@ class WannierManager(Manager):
 
     def prepare_model_colinear(self, path, prefix_up, prefix_dn, atoms, output_path):
         print("Reading Wannier90 hamiltonian: spin up.")
-        tbmodel_up = MyTB.read_from_wannier_dir(
+        tbmodel_up = WannierHam.read_from_wannier_dir(
             path=path, prefix=prefix_up, atoms=atoms, nls=False
         )
         print("Reading Wannier90 hamiltonian: spin down.")
-        tbmodel_dn = MyTB.read_from_wannier_dir(
+        tbmodel_dn = WannierHam.read_from_wannier_dir(
             path=path, prefix=prefix_dn, atoms=atoms, nls=False
         )
         basis, _ = auto_assign_basis_name(
@@ -82,7 +82,7 @@ class WannierManager(Manager):
         groupby = groupby.lower().strip()
         if groupby not in ["spin", "orbital"]:
             raise ValueError("groupby can only be spin or orbital.")
-        tbmodel = MyTB.read_from_wannier_dir(
+        tbmodel = WannierHam.read_from_wannier_dir(
             path=path, prefix=prefix_SOC, atoms=atoms, groupby=groupby, nls=True
         )
         basis, _ = auto_assign_basis_name(

TB2J/io_exchange/__init__.py

@@ -1,3 +1,21 @@
+from .edit import (
+    load,
+    save,
+    set_anisotropy,
+    symmetrize_exchange,
+    toggle_DMI,
+    toggle_exchange,
+    toggle_Jani,
+)
 from .io_exchange import SpinIO
 
-__all__ = ["SpinIO"]
+__all__ = [
+    "SpinIO",
+    "load",
+    "save",
+    "set_anisotropy",
+    "toggle_DMI",
+    "toggle_Jani",
+    "toggle_exchange",
+    "symmetrize_exchange",
+]