TB2J 0.9.9rc4__tar.gz → 0.9.9rc6__tar.gz

{tb2j-0.9.9rc4 → tb2j-0.9.9rc6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: TB2J
-Version: 0.9.9rc4
+Version: 0.9.9rc6
 Summary: TB2J: First principle to Heisenberg exchange J using tight-binding Green function method
 Author: Xu He
 Author-email: mailhexu@gmail.com

{tb2j-0.9.9rc4 → tb2j-0.9.9rc6}/TB2J/MAE.py

@@ -137,9 +137,9 @@ class MAEGreen(MAE):
         efermi = occ.efermi(evals)
         print(f"{efermi=}")
         self.G = TBGreen(model, kmesh, efermi=efermi, gamma=gamma, **kwargs)
-        self.emin = -12
+        self.emin = -52
         self.emax = 0
-        self.nz = 50
+        self.nz = 100
         self._prepare_elist()
 
     def _prepare_elist(self, method="legendre"):
@@ -186,7 +186,7 @@ class MAEGreen(MAE):
         for ie, e in enumerate(tqdm.tqdm(self.contour.path)):
             dE_angle = self.get_perturbed(e, thetas, phis)
             es += np.imag(dE_angle * self.contour.weights[ie])
-        return -es / np.pi
+        return -es / np.pi / 2
 
 
 def get_model_energy(model, kmesh, gamma=True):

{tb2j-0.9.9rc4 → tb2j-0.9.9rc6}/TB2J/MAEGreen.py

@@ -3,10 +3,11 @@ from pathlib import Path
 import numpy as np
 import tqdm
 from HamiltonIO.abacus.abacus_wrapper import AbacusSplitSOCParser
-from HamiltonIO.model.occupations import Occupations
+from HamiltonIO.model.occupations import GaussOccupations
 from typing_extensions import DefaultDict
 
 from TB2J.exchange import ExchangeNCL
+from TB2J.external import p_map
 
 # from HamiltonIO.model.rotate_spin import rotate_Matrix_from_z_to_axis, rotate_Matrix_from_z_to_sperical
 # from TB2J.abacus.abacus_wrapper import AbacusWrapper, AbacusParser
@@ -16,7 +17,7 @@ from TB2J.mathutils.rotate_spin import (
 
 
 def get_occupation(evals, kweights, nel, width=0.1):
-    occ = Occupations(nel=nel, width=width, wk=kweights, nspin=2)
+    occ = GaussOccupations(nel=nel, width=width, wk=kweights, nspin=2)
     return occ.occupy(evals)
 
 
@@ -78,6 +79,17 @@ class MAEGreen(ExchangeNCL):
 
     def get_perturbed(self, e, thetas, phis):
         self.tbmodel.set_so_strength(0.0)
+        maxsoc = self.tbmodel.get_max_Hsoc_abs()
+        maxH0 = self.tbmodel.get_max_H0_spin_abs()
+        if maxsoc > maxH0 * 0.01:
+            print(f"""Warning: The SOC of the Hamiltonian has a maximum of {maxsoc} eV,
+                  comparing to the maximum of {maxH0} eV of the spin part of the Hamiltonian.
+                  The SOC is too strong, the perturbation theory may not be valid.""")
+
+        print(f"""Warning: The SOC of the Hamiltonian has a maximum of {maxsoc} eV,
+                  comparing to the maximum of {maxH0} eV of the spin part of the Hamiltonian.
+                  The SOC is too strong, the perturbation theory may not be valid.""")
+
         G0K = self.G.get_Gk_all(e)
         Hsoc_k = self.tbmodel.get_Hk_soc(self.G.kpts)
         na = len(thetas)
@@ -97,6 +109,7 @@ class MAEGreen(ExchangeNCL):
                 dG2 = GdH * GdH.T
                 dG2sum = np.sum(dG2)
                 # print(f"dG2sum-sum: {dG2sum}")
+                dG2sum = np.sum(dG2diag)
 
                 # dG2sum = np.trace(GdH @ GdH)
                 # print(f"dG2sum-Tr: {dG2sum}")
@@ -142,15 +155,33 @@ class MAEGreen(ExchangeNCL):
         if with_eigen:
             self.es2 = self.get_band_energy_vs_angles_from_eigen(thetas, phis)
 
-        for ie, e in enumerate(tqdm.tqdm(self.contour.path)):
-            dE_angle, dE_angle_atom, dE_angle_atom_orb = self.get_perturbed(
-                e, thetas, phis
-            )
-            self.es += dE_angle * self.contour.weights[ie]
-            self.es_atom += dE_angle_atom * self.contour.weights[ie]
+        # for ie, e in enumerate(tqdm.tqdm(self.contour.path)):
+        #    dE_angle, dE_angle_atom, dE_angle_atom_orb = self.get_perturbed(
+        #        e, thetas, phis
+        #    )
+        #    self.es += dE_angle * self.contour.weights[ie]
+        #    self.es_atom += dE_angle_atom * self.contour.weights[ie]
+        #    for key, value in dE_angle_atom_orb.items():
+        #        self.es_atom_orb[key] += (
+        #            dE_angle_atom_orb[key] * self.contour.weights[ie]
+        #        )
+
+        # rewrite the for loop above to use p_map
+        def func(e):
+            return self.get_perturbed(e, thetas, phis)
+
+        if self.nproc > 1:
+            results = p_map(func, self.contour.path, num_cpus=self.nproc)
+        else:
+            npole = len(self.contour.path)
+            results = map(func, tqdm.tqdm(self.contour.path, total=npole))
+        for i, result in enumerate(results):
+            dE_angle, dE_angle_atom, dE_angle_atom_orb = result
+            self.es += dE_angle * self.contour.weights[i]
+            self.es_atom += dE_angle_atom * self.contour.weights[i]
             for key, value in dE_angle_atom_orb.items():
                 self.es_atom_orb[key] += (
-                    dE_angle_atom_orb[key] * self.contour.weights[ie]
+                    dE_angle_atom_orb[key] * self.contour.weights[i]
                 )
 
         self.es = -np.imag(self.es) / (2 * np.pi)
@@ -158,7 +189,7 @@ class MAEGreen(ExchangeNCL):
         for key, value in self.es_atom_orb.items():
             self.es_atom_orb[key] = -np.imag(value) / (2 * np.pi)
 
-    def output(self, output_path="TB2J_anisotropy", with_eigen=False):
+    def output(self, output_path="TB2J_anisotropy", with_eigen=True):
         Path(output_path).mkdir(exist_ok=True)
         fname = f"{output_path}/MAE.dat"
         fname_orb = f"{output_path}/MAE_orb.dat"
@@ -242,6 +273,7 @@ def abacus_get_MAE(
     magnetic_elements=None,
     nel=None,
     width=0.1,
+    with_eigen=False,
     **kwargs,
 ):
     """Get MAE from Abacus with magnetic force theorem. Two calculations are needed. First we do an calculation with SOC but the soc_lambda is set to 0. Save the density. The next calculatin we start with the density from the first calculation and set the SOC prefactor to 1. With the information from the two calcualtions, we can get the band energy with magnetic moments in the direction, specified in two list, thetas, and phis."""
@@ -262,4 +294,4 @@ def abacus_get_MAE(
         magnetic_elements=magnetic_elements,
         **kwargs,
     )
-    mae.run(output_path=output_path)
+    mae.run(output_path=output_path, with_eigen=with_eigen)

{tb2j-0.9.9rc4 → tb2j-0.9.9rc6}/TB2J/contour.py

@@ -1,5 +1,6 @@
 import numpy as np
 from scipy.special import roots_legendre
+
 from TB2J.utils import simpson_nonuniform_weight
 
 
@@ -15,6 +16,21 @@ class Contour:
             self._weights = simpson_nonuniform_weight(self.path)
         return self._weights
 
+    def integrate_func(self, func):
+        """
+        integrate f along the path
+        """
+        return np.dot(func(self.path), self.weights)
+
+    def integrate_values(self, values):
+        """
+        integrate f along the path
+        """
+        ret = 0
+        for i in range(len(values)):
+            ret += values[i] * self.weights[i]
+        return ret
+
     def build_path_semicircle(self, npoints, endpoint=True):
         R = (self.emax - self.emin) / 2.0
         R0 = (self.emin + self.emax) / 2.0

{tb2j-0.9.9rc4 → tb2j-0.9.9rc6}/TB2J/exchange.py

@@ -10,29 +10,24 @@ from TB2J.exchange_params import ExchangeParams
 from TB2J.external import p_map
 from TB2J.green import TBGreen
 from TB2J.io_exchange import SpinIO
+from TB2J.mycfr import CFR
 from TB2J.orbmap import map_orbs_matrix
 from TB2J.pauli import pauli_block_all, pauli_block_sigma_norm
 from TB2J.utils import (
     kmesh_to_R,
-    simpson_nonuniform,
     symbol_number,
-    trapezoidal_nonuniform,
 )
 
 
 class Exchange(ExchangeParams):
-    def __init__(
-        self,
-        tbmodels,
-        atoms,
-        **params: ExchangeParams,
-    ):
+    def __init__(self, tbmodels, atoms, **params):
         self.atoms = atoms
         super().__init__(**params)
         self._prepare_kmesh(self._kmesh)
         self._prepare_Rlist()
         self.set_tbmodels(tbmodels)
         self._adjust_emin()
+        # self._prepare_elist(method="CFR")
         self._prepare_elist(method="legendre")
         self._prepare_basis()
         self._prepare_orb_dict()
@@ -50,8 +45,9 @@ class Exchange(ExchangeParams):
         os.makedirs(self.orbpath, exist_ok=True)
 
     def _adjust_emin(self):
-        # self.emin = self.G.find_energy_ingap(rbound=self.efermi - 10.0) - self.efermi
-        self.emin = -22.0
+        self.emin = self.G.find_energy_ingap(rbound=self.efermi - 15.0) - self.efermi
+        # self.emin = self.G.find_energy_ingap(rbound=self.efermi - 15.0) - self.efermi
+        # self.emin = -42.0
         print(f"A gap is found at {self.emin}, set emin to it.")
 
     def set_tbmodels(self, tbmodels):
@@ -62,25 +58,28 @@ class Exchange(ExchangeParams):
         # del self.G.tbmodel
         pass
 
-    def _prepare_kmesh(self, kmesh):
+    def _prepare_kmesh(self, kmesh, ibz=False):
         for k in kmesh:
             self.kmesh = list(map(lambda x: x // 2 * 2 + 1, kmesh))
 
-    def _prepare_elist(self, method="legendre"):
+    def _prepare_elist(self, method="CFR"):
         """
         prepare list of energy for integration.
         The path has three segments:
          emin --1-> emin + 1j*height --2-> emax+1j*height --3-> emax
         """
-        self.contour = Contour(self.emin, self.emax)
         # if method.lower() == "rectangle":
         #    self.contour.build_path_rectangle(
         #        height=self.height, nz1=self.nz1, nz2=self.nz2, nz3=self.nz3
         #    )
         if method.lower() == "semicircle":
+            self.contour = Contour(self.emin, self.emax)
             self.contour.build_path_semicircle(npoints=self.nz, endpoint=True)
         elif method.lower() == "legendre":
+            self.contour = Contour(self.emin, self.emax)
             self.contour.build_path_legendre(npoints=self.nz, endpoint=True)
+        elif method.lower() == "cfr":
+            self.contour = CFR(nz=self.nz, T=600)
         else:
             raise ValueError(f"The path cannot be of type {method}.")
 
@@ -119,6 +118,7 @@ class Exchange(ExchangeParams):
                 else:
                     try:
                         atom_sym, orb_sym = base[:2]
+                        iatom = sdict[atom_sym]
                     except Exception:
                         iatom = base.iatom
                         atom_sym = base.iatom
@@ -150,7 +150,7 @@ class Exchange(ExchangeParams):
                 )
         if not self._is_collinear:
             for iatom, orb in self.orb_dict.items():
-                print(f"iatom: {iatom}, orb: {orb}")
+                # print(f"iatom: {iatom}, orb: {orb}")
                 nsorb = len(self.orb_dict[iatom])
                 if nsorb % 2 != 0 and False:
                     raise ValueError(
@@ -173,10 +173,9 @@ or badly localized. Please check the Wannier centers in the Wannier90 output fil
         self.mmats = {}
         self.orbital_names = {}
         self.norb_reduced = {}
-        print(f"self.backend_name: {self.backend_name}")
         if self.backend_name.upper() in ["SIESTA", "ABACUS", "LCAOHAMILTONIAN"]:
-            print(f"magntic_elements: {self.magnetic_elements}")
-            print(f"include_orbs: {self.include_orbs}")
+            # print(f"magntic_elements: {self.magnetic_elements}")
+            # print(f"include_orbs: {self.include_orbs}")
             syms = self.atoms.get_chemical_symbols()
             for iatom, orbs in self.labels.items():
                 if (self.include_orbs is not None) and syms[iatom] in self.include_orbs:
@@ -186,7 +185,7 @@ or badly localized. Please check the Wannier centers in the Wannier90 output fil
                         include_only=self.include_orbs[syms[iatom]],
                     )
                 else:
-                    print(f"orbs: {orbs}")
+                    # print(f"orbs: {orbs}")
                     mmat, reduced_orbs = map_orbs_matrix(
                         orbs, spinor=not (self._is_collinear), include_only=None
                     )
@@ -271,10 +270,10 @@ class ExchangeNCL(Exchange):
         """
         self.tbmodel = tbmodels
         self.backend_name = self.tbmodel.name
-        print(self.kmesh)
         self.G = TBGreen(
             tbmodel=self.tbmodel,
             kmesh=self.kmesh,
+            ibz=self.ibz,
             gamma=True,
             efermi=self.efermi,
             use_cache=self._use_cache,
@@ -567,20 +566,24 @@ class ExchangeNCL(Exchange):
         AijRs: a list of AijR,
         wherer AijR: array of ((nR, n, n, 4,4), dtype=complex)
         """
-        if method == "trapezoidal":
-            integrate = trapezoidal_nonuniform
-        elif method == "simpson":
-            integrate = simpson_nonuniform
+        # if method == "trapezoidal":
+        #    integrate = trapezoidal_nonuniform
+        # elif method == "simpson":
+        #    integrate = simpson_nonuniform
+        #
 
         # self.rho = integrate(self.contour.path, rhoRs)
         for iR, R in enumerate(self.R_ijatom_dict):
             for iatom, jatom in self.R_ijatom_dict[R]:
                 f = AijRs[(R, iatom, jatom)]
-                self.A_ijR[(R, iatom, jatom)] = integrate(self.contour.path, f)
+                # self.A_ijR[(R, iatom, jatom)] = integrate(self.contour.path, f)
+                self.A_ijR[(R, iatom, jatom)] = self.contour.integrate_values(f)
+
                 if self.orb_decomposition:
-                    self.A_ijR_orb[(R, iatom, jatom)] = integrate(
-                        self.contour.path, AijRs_orb[(R, iatom, jatom)]
-                    )
+                    # self.A_ijR_orb[(R, iatom, jatom)] = integrate(
+                    #    self.contour.path, AijRs_orb[(R, iatom, jatom)]
+                    # )
+                    self.contour.integrate_values(AijRs_orb[(R, iatom, jatom)])
 
     def get_quantities_per_e(self, e):
         Gk_all = self.G.get_Gk_all(e)

{tb2j-0.9.9rc4 → tb2j-0.9.9rc6}/TB2J/exchangeCL2.py

@@ -1,15 +1,18 @@
 """
 Exchange from Green's function
 """
+
 import os
 from collections import defaultdict
+
 import numpy as np
-from TB2J.green import TBGreen
-from TB2J.io_exchange import SpinIO
 from tqdm import tqdm
+
 from TB2J.external import p_map
+from TB2J.green import TBGreen
+from TB2J.io_exchange import SpinIO
+
 from .exchange import ExchangeCL
-from .utils import simpson_nonuniform, trapezoidal_nonuniform
 
 
 class ExchangeCL2(ExchangeCL):
@@ -221,17 +224,23 @@ class ExchangeCL2(ExchangeCL):
         #    shutil.rmtree(path)
 
     def integrate(self, method="simpson"):
-        if method == "trapezoidal":
-            integrate = trapezoidal_nonuniform
-        elif method == "simpson":
-            integrate = simpson_nonuniform
+        # if method == "trapezoidal":
+        #    integrate = trapezoidal_nonuniform
+        # elif method == "simpson":
+        #    integrate = simpson_nonuniform
         for R, ijpairs in self.R_ijatom_dict.items():
             for iatom, jatom in ijpairs:
-                self.Jorb[(R, iatom, jatom)] = integrate(
-                    self.contour.path, self.Jorb_list[(R, iatom, jatom)]
+                # self.Jorb[(R, iatom, jatom)] = integrate(
+                #    self.contour.path, self.Jorb_list[(R, iatom, jatom)]
+                # )
+                # self.JJ[(R, iatom, jatom)] = integrate(
+                #    self.contour.path, self.JJ_list[(R, iatom, jatom)]
+                # )
+                self.Jorb[(R, iatom, jatom)] = self.contour.integrate_values(
+                    self.Jorb_list[(R, iatom, jatom)]
                 )
-                self.JJ[(R, iatom, jatom)] = integrate(
-                    self.contour.path, self.JJ_list[(R, iatom, jatom)]
+                self.JJ[(R, iatom, jatom)] = self.contour.integrate_values(
+                    self.JJ_list[(R, iatom, jatom)]
                 )
 
     def get_quantities_per_e(self, e):

{tb2j-0.9.9rc4 → tb2j-0.9.9rc6}/TB2J/exchange_params.py

@@ -31,6 +31,7 @@ class ExchangeParams:
     output_path: str = "TB2J_results"
     mae_angles = None
     orth = False
+    ibz = False
 
     def __init__(
         self,
@@ -53,6 +54,7 @@ class ExchangeParams:
         exclude_orbs=[],
         mae_angles=None,
         orth=False,
+        ibz=False,
     ):
         self.efermi = efermi
         self.basis = basis
@@ -76,6 +78,7 @@ class ExchangeParams:
         self.output_path = output_path
         self.mae_angles = mae_angles
         self.orth = orth
+        self.ibz = ibz
 
     def set_params(self, **kwargs):
         for key, val in kwargs.items():
@@ -92,8 +95,6 @@ class ExchangeParams:
             include_orbs = {}
         if isinstance(magnetic_elements, str):
             magnetic_elements = [magnetic_elements]
-        print(f"magnetic_elements: {magnetic_elements}")
-        print(f"include_orbs: {include_orbs}")
         for element in magnetic_elements:
             if "_" in element:
                 elem = element.split("_")[0]
@@ -102,8 +103,6 @@ class ExchangeParams:
             else:
                 include_orbs[element] = None
 
-        print(f"magnetic_elements: {magnetic_elements}")
-        print(f"include_orbs: {include_orbs}")
         magnetic_elements = list(include_orbs.keys())
         return magnetic_elements, include_orbs
 
@@ -116,6 +115,14 @@ def add_exchange_args_to_parser(parser: argparse.ArgumentParser):
         type=str,
         nargs="*",
     )
+
+    parser.add_argument(
+        "--spinor",
+        help="whether the Wannier functions are spinor. Default: False",
+        action="store_true",
+        default=False,
+    )
+
     parser.add_argument(
         "--rcut",
         help="cutoff of spin pair distance. The default is to calculate all commensurate R point to the k mesh.",
@@ -214,6 +221,14 @@ def add_exchange_args_to_parser(parser: argparse.ArgumentParser):
         action="store_true",
         default=False,
     )
+
+    parser.add_argument(
+        "--ibz",
+        help=" use irreducible k-points in the Brillouin zone. (Note: only for computing total MAE).",
+        action="store_true",
+        default=False,
+    )
+
     return parser
 
 

{tb2j-0.9.9rc4 → tb2j-0.9.9rc6}/TB2J/green.py

@@ -7,17 +7,28 @@ from collections import defaultdict
 from shutil import rmtree
 
 import numpy as np
-from HamiltonIO.model.occupations import Occupations
+from HamiltonIO.model.occupations import GaussOccupations
 from HamiltonIO.model.occupations import myfermi as fermi
 from pathos.multiprocessing import ProcessPool
 
-from TB2J.kpoints import monkhorst_pack
+from TB2J.kpoints import ir_kpts, monkhorst_pack
 
 # from TB2J.mathutils.fermi import fermi
 
 MAX_EXP_ARGUMENT = np.log(sys.float_info.max)
 
 
+def eigen_to_G2(H, S, efermi, energy):
+    """calculate green's function from eigenvalue/eigenvector for energy(e-ef): G(e-ef).
+    :param H: Hamiltonian matrix in eigenbasis
+    :param S: Overlap matrix in eigenbasis
+    :param efermi: fermi energy
+    :param energy: energy level e - efermi
+    """
+    # G = ((E+Ef) S - H)^-1
+    return np.linalg.inv((energy + efermi) * S - H)
+
+
 def eigen_to_G(evals, evecs, efermi, energy):
     """calculate green's function from eigenvalue/eigenvector for energy(e-ef): G(e-ef).
     :param evals:  eigen values
@@ -40,7 +51,7 @@ def eigen_to_G(evals, evecs, efermi, energy):
     )
 
 
-def find_energy_ingap(evals, rbound, gap=4.0):
+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.
@@ -59,9 +70,11 @@ class TBGreen:
         self,
         tbmodel,
         kmesh=None,  # [ikpt, 3]
+        ibz=False,  # if True, will interpolate the Green's function at Ir-kpoints
         efermi=None,  # efermi
         gamma=False,
         kpts=None,
+        kweights=None,
         k_sym=False,
         use_cache=False,
         cache_path=None,
@@ -81,20 +94,64 @@ class TBGreen:
         self.cache_path = cache_path
         if use_cache:
             self._prepare_cache()
-        if kpts is not None:
-            self.kpts = kpts
-        elif kmesh is not None:
-            self.kpts = monkhorst_pack(kmesh, gamma_center=gamma)
-        else:
-            self.kpts = tbmodel.get_kpts()
-        self.nkpts = len(self.kpts)
-        self.kweights = np.array([1.0 / self.nkpts] * self.nkpts)
+        self.prepare_kpts(
+            kmesh=kmesh,
+            ibz=ibz,
+            gamma=gamma,
+            kpts=kpts,
+            kweights=kweights,
+            tbmodel=tbmodel,
+        )
+
         self.norb = tbmodel.norb
         self.nbasis = tbmodel.nbasis
         self.k_sym = k_sym
         self.nproc = nproc
         self._prepare_eigen()
 
+    def prepare_kpts(
+        self, kmesh=None, gamma=True, ibz=False, kpts=None, kweights=None, tbmodel=None
+    ):
+        """
+        Prepare the k-points for the calculation.
+
+        Parameters:
+        - kmesh (tuple): The k-mesh used to generate k-points.
+        - gamma (bool): Whether to include the gamma point in the k-points.
+        - ibz (bool): Whether to use the irreducible Brillouin zone.
+        - kpts (list): List of user-defined k-points.
+        - kweights (list): List of weights for each k-point.
+
+        Returns:
+        None
+        """
+        if kpts is not None:
+            self.kpts = kpts
+            self.nkpts = len(self.kpts)
+            self.kweights = kweights
+        elif kmesh is not None:
+            if ibz:
+                self.kpts, self.kweights = ir_kpts(
+                    atoms=tbmodel.atoms,
+                    mp_grid=kmesh,
+                    ir=True,
+                    is_time_reversal=False,
+                )
+                self.nkpts = len(self.kpts)
+                print(f"Using IBZ of kmesh of {kmesh}")
+                print(f"Number of kpts: {self.nkpts}")
+                for kpt, weight in zip(self.kpts, self.kweights):
+                    # format the kpt and weight, use 5 digits
+                    print(f"{kpt[0]:8.5f} {kpt[1]:8.5f} {kpt[2]:8.5f} {weight:8.5f}")
+            else:
+                self.kpts = monkhorst_pack(kmesh, gamma_center=gamma)
+                self.nkpts = len(self.kpts)
+                self.kweights = np.array([1.0 / self.nkpts] * self.nkpts)
+        else:
+            self.kpts = tbmodel.get_kpts()
+            self.nkpts = len(self.kpts)
+            self.kweights = np.array([1.0 / self.nkpts] * self.nkpts)
+
     def _reduce_eigens(self, evals, evecs, emin, emax):
         ts = np.logical_and(evals >= emin, evals < emax)
         ts = np.any(ts, axis=0)
@@ -106,7 +163,7 @@ class TBGreen:
         istart, iend = ts[0], ts[-1] + 1
         return evals[:, istart:iend], evecs[:, :, istart:iend]
 
-    def find_energy_ingap(self, rbound, gap=4.0):
+    def find_energy_ingap(self, rbound, gap=2.0):
         return find_energy_ingap(self.evals, rbound, gap)
 
     def _prepare_cache(self):
@@ -165,7 +222,14 @@ class TBGreen:
         if self.efermi is None:
             print("Calculating Fermi energy from eigenvalues")
             print(f"Number of electrons: {self.tbmodel.nel} ")
-            occ = Occupations(
+
+            # occ = Occupations(
+            #    nel=self.tbmodel.nel, width=0.1, wk=self.kweights, nspin=2
+            # )
+            # self.efermi = occ.efermi(copy.deepcopy(self.evals))
+            # print(f"Fermi energy found: {self.efermi}")
+
+            occ = GaussOccupations(
                 nel=self.tbmodel.nel, width=0.1, wk=self.kweights, nspin=2
             )
             self.efermi = occ.efermi(copy.deepcopy(self.evals))
@@ -360,7 +424,6 @@ class TBGreen:
             for iR, R in enumerate(Rpts):
                 phase = np.exp(self.k2Rfactor * np.dot(R, kpt))
                 GR[R] += Gkw * (phase * self.kweights[ik])
-
                 dHRdx = dHdx.get_hamR(R)
                 dGRdx[R] += Gkw @ dHRdx @ Gk
                 # dGRdx[R] += Gk.dot(dHRdx).dot(Gkp)

{tb2j-0.9.9rc4 → tb2j-0.9.9rc6}/TB2J/interfaces/siesta_interface.py

@@ -74,6 +74,7 @@ def gen_exchange_siesta(fdf_fname, read_H_soc=False, **kwargs):
         output_path="TB2J_results",
         orb_decomposition=False,
         orth=False,
+        ibz=False,
         description="",
     )
     exargs.update(kwargs)
@@ -162,7 +163,7 @@ Warning: The DMI component parallel to the spin orientation, the Jani which has
             # thetas = [0, np.pi / 2, np.pi, 3 * np.pi / 2]
             # phis = [0, 0, 0, 0]
             # MAE.set_angles(thetas=thetas, phis=phis)
-            MAE.run(output_path=f"{output_path}_anisotropy")
+            MAE.run(output_path=f"{output_path}_anisotropy", with_eigen=True)
             print(
                 f"MAE calculation finished. The results are in {output_path} directory."
             )