TB2J 0.9.9rc4__py3-none-any.whl → 0.9.9rc6__py3-none-any.whl

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/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/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/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/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/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/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/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."
             )

TB2J/kpoints.py

@@ -1,4 +1,7 @@
+from collections import Counter
+
 import numpy as np
+import spglib
 
 
 def monkhorst_pack(size, gamma_center=False):
@@ -12,5 +15,87 @@ def monkhorst_pack(size, gamma_center=False):
     mkpts = (kpts + 0.5) / size - 0.5
     if gamma_center:
         mkpts += shift
-
     return mkpts
+
+
+def get_ir_kpts(atoms, mesh):
+    """
+    Gamma-centered IR kpoints. mesh : [nk1,nk2,nk3].
+    """
+    lattice = atoms.get_cell()
+    positions = atoms.get_scaled_positions()
+    numbers = atoms.get_atomic_numbers()
+
+    cell = (lattice, positions, numbers)
+    mapping, grid = spglib.get_ir_reciprocal_mesh(mesh, cell, is_shift=[0, 0, 0])
+    return grid[np.unique(mapping)] / np.array(mesh, dtype=float)
+
+
+def ir_kpts(
+    atoms, mp_grid, is_shift=[0, 0, 0], verbose=True, ir=True, is_time_reversal=False
+):
+    """
+    generate kpoints for structure
+    Parameters:
+    ------------------
+    atoms: ase.Atoms
+      structure
+    mp_grid: [nk1,nk2,nk3]
+    is_shift: shift of k points. default is Gamma centered.
+    ir: bool
+    Irreducible or not.
+    """
+    cell = (atoms.get_cell(), atoms.get_scaled_positions(), atoms.get_atomic_numbers())
+    # print(spglib.get_spacegroup(cell, symprec=1e-5))
+    mesh = mp_grid
+    # Gamma centre mesh
+    mapping, grid = spglib.get_ir_reciprocal_mesh(
+        mesh, cell, is_shift=is_shift, is_time_reversal=is_time_reversal, symprec=1e-4
+    )
+    if not ir:
+        return (np.array(grid).astype(float) + np.asarray(is_shift) / 2.0) / mesh, [
+            1.0 / len(mapping)
+        ] * len(mapping)
+    # All k-points and mapping to ir-grid points
+    # for i, (ir_gp_id, gp) in enumerate(zip(mapping, grid)):
+    #    print("%3d ->%3d %s" % (i, ir_gp_id, gp.astype(float) / mesh))
+    cnt = Counter(mapping)
+    ids = list(cnt.keys())
+    weight = list(cnt.values())
+    weight = np.array(weight) * 1.0 / sum(weight)
+    ird_kpts = [
+        (grid[id].astype(float) + np.asarray(is_shift) / 2.0) / mesh for id in ids
+    ]
+
+    # Irreducible k-points
+    # print("Number of ir-kpoints: %d" % len(np.unique(mapping)))
+    # print(grid[np.unique(mapping)] / np.array(mesh, dtype=float))
+
+    new_ir_kpts = []
+    new_weight = []
+    for ik, k in enumerate(ird_kpts):
+        # add k and -k to ird_kpts if -k is not in ird_kpts
+        if not any([np.allclose(-1.0 * k, kpt) for kpt in new_ir_kpts]):
+            new_ir_kpts.append(k)
+            new_ir_kpts.append(-1.0 * k)
+            new_weight.append(weight[ik] / 2)
+            new_weight.append(weight[ik] / 2)
+        else:
+            new_ir_kpts.append(k)
+            new_weight.append(weight[ik])
+    # return ird_kpts, weight
+    return np.array(new_ir_kpts), np.array(new_weight)
+
+
+def test_ir_kpts():
+    from ase.build import bulk
+
+    atoms = bulk("Si")
+    mesh = [14, 14, 14]
+    kpts = get_ir_kpts(atoms, mesh)
+    print(kpts)
+    print(len(kpts))
+
+
+if __name__ == "__main__":
+    test_ir_kpts()

TB2J/mycfr.py

@@ -0,0 +1,114 @@
+# -*- coding: utf-8 -*-
+# File: mycfr.py
+# Time: 2017/12/10 19:29:43
+"""
+Continued fraction representation.
+"""
+
+import numpy as np
+from scipy.linalg import eig
+
+kb = 8.61733e-5  # Boltzmann constant in eV
+
+
+class CFR:
+    """
+    Integration with the continued fraction representation.
+    """
+
+    def __init__(self, nz=50, T=60):
+        self.nz = nz
+        self.T = 600
+        self.beta = 1 / (kb * self.T)
+        self.Rinf = 1e10
+        if nz <= 0:
+            raise ValueError("nz should be larger than 0.")
+        else:
+            self.prepare_poles()
+
+    def prepare_poles(self):
+        ##b_mat = [1 / (2.0 * np.sqrt((2 * (j + 1) - 1) * (2 * (j + 1) + 1)) / (kb * self.#T)) for j in range(0, self.nz- 1)]
+        jmat = np.arange(0, self.nz - 1)
+        b_mat = 1 / (2.0 * np.sqrt((2 * (jmat + 1) - 1) * (2 * (jmat + 1) + 1)))
+        b_mat = np.diag(b_mat, -1) + np.diag(b_mat, 1)
+        self.poles, residules = eig(b_mat)
+
+        residules = 0.25 * np.abs(residules[0, :]) ** 2 / self.poles**2
+        # residules = 0.25 * np.diag(residules) ** 2 / self.poles**2
+
+        # self.weights = np.where(
+        #        #np.real(self.poles) > 0, 4.0j / self.beta * residules, 0.0
+        #        #np.real(self.poles) > 0, 2.0j / self.beta * residules, 2.0j / self.beta * residules
+        #    np.real(self.poles) > 0, 2.0j / self.beta * residules, 0.0
+        # )
+
+        # self.path = 1j / self.poles * kb * self.T
+
+        self.path = []
+        self.weights = []
+        for p, r in zip(self.poles, residules):
+            if p > 0:
+                self.path.append(1j / p * kb * self.T)
+                w = 2.0j / self.beta * r
+                self.weights.append(w)
+                self.path.append(-1j / p * kb * self.T)
+                self.weights.append(w)
+
+        self.path = np.array(self.path)
+        self.weights = np.array(self.weights)
+
+        # from J. Phys. Soc. Jpn. 88, 114706 (2019)
+        # A_mat =  -1/2 *np.diag(1, -1) + np.diag(1, 1)
+        # B_mat = np.diag([2*i-1 for i in range(1, self.nz)])
+        # eigp, eigv = eig(A_mat, B_mat)
+        # zp = 1j / eigp * kb * self.T
+        # Rp = 0.25 * np.diag(eigv)**2 * zp **2
+
+        # add a point to the poles: 1e10j
+        self.path = np.concatenate((self.path, [self.Rinf * 1j]))
+        # self.path = np.concatenate((self.path, [0.0]))
+        self.npoles = len(self.poles)
+
+        # add weights for the point 1e10j
+        # self.weights = np.concatenate((self.weights, [-self.Rinf]))
+        self.weights = np.concatenate((self.weights, [00.0]))
+        # zeros moment is 1j * R * test_gf(1j * R), but the real part of it will be taken. In contrast to the other part, where the imaginary part is taken.
+
+    def integrate_values(self, gf_vals, imag=False):
+        ret = 0
+        for i in range(self.npoles + 1):
+            ret += self.weights[i] * gf_vals[i]
+        ret *= (
+            -np.pi / 2
+        )  # This is to be compatible with the integration of contour, where /-np.pi is used after the integration. And the factor of 2 is because the Fermi function here is 2-fold degenerate.
+        if imag:
+            return np.imag(ret)
+        return ret
+
+    def integrate_func(self, gf, ef=0):
+        """
+        Integration with the continued fraction representation.
+
+        :param gf: Green's function
+        :param ef: Fermi energy
+        :return: integration result
+        """
+        path = self.path
+        gf_vals = gf(path, ef=ef)
+        return self.integrate_values(gf_vals)
+
+
+def test_cfr():
+    cfr = CFR(nz=100)
+
+    def test_gf(z, ef=0.1):
+        return 1 / (z - 3 + ef)
+
+    r = cfr.integrate_func(test_gf, ef=2)
+    r = -np.imag(r) / np.pi * 2
+    print(r)
+    return r
+
+
+if __name__ == "__main__":
+    test_cfr()

TB2J/orbmap.py

@@ -28,14 +28,14 @@ def map_orbs_matrix(orblist, spinor=False, include_only=None):
 
     norb = len(orblist)
 
-    print("orblist: ", orblist)
+    # print("orblist: ", orblist)
     ss = [split_orb_name(orb) for orb in orblist]
     orbdict = dict(zip(ss, range(norb)))
 
     reduced_orbdict = defaultdict(lambda: [])
 
-    print(f"Orbital dictionary: {orbdict}")
-    print("include_only: ", include_only)
+    # print(f"Orbital dictionary: {orbdict}")
+    # print("include_only: ", include_only)
 
     if include_only is None:
         for key, val in orbdict.items():
@@ -46,7 +46,7 @@ def map_orbs_matrix(orblist, spinor=False, include_only=None):
                 # [:2] for 3d, 4d, 5d, etc. and [:1] for s, p, d, etc
                 reduced_orbdict[key[0]].append(val)
 
-    print(f"reduced_orbdict: {reduced_orbdict}")
+    # print(f"reduced_orbdict: {reduced_orbdict}")
     reduced_orbs = tuple(reduced_orbdict.keys())
     ngroup = len(reduced_orbdict)
     mmat = np.zeros((norb, ngroup), dtype=int)

TB2J/symmetrize_J.py

@@ -4,6 +4,7 @@ from pathlib import Path
 import numpy as np
 from sympair import SymmetryPairFinder
 
+from TB2J.io_exchange import SpinIO
 from TB2J.versioninfo import print_license
 
 
@@ -35,6 +36,7 @@ class TB2JSymmetrizer:
         self.pgdict = finder.get_symmetry_pair_group_dict()
         self.exc = exc
         self.new_exc = copy.deepcopy(exc)
+        self.Jonly = Jonly
 
     def print_license(self):
         print_license()
@@ -44,8 +46,8 @@ class TB2JSymmetrizer:
         Symmetrize the exchange parameters J.
         """
         symJdict = {}
-        Jdict = self.exc.exchange_Jdict
-        ngroup = self.pgdict
+        # Jdict = self.exc.exchange_Jdict
+        # ngroup = self.pgdict
         for pairgroup in self.pgdict.groups:
             ijRs = pairgroup.get_all_ijR()
             ijRs_spin = [self.exc.ijR_index_atom_to_spin(*ijR) for ijR in ijRs]
@@ -56,9 +58,12 @@ class TB2JSymmetrizer:
         self.new_exc.exchange_Jdict = symJdict
         if self.Jonly:
             self.new_exc.has_dmi = False
-            self.new_exc.dmi_dict = {}
-            self.new_exc.has_uniaxial_anistropy = False
-            self.new_exc.k1_dict = {}
+            self.new_exc.dmi_ddict = None
+            self.new_exc.has_bilinear = False
+            self.new_exc.Jani_dict = None
+            self.has_uniaxial_anisotropy = False
+            self.k1 = None
+            self.k1dir = None
 
     def output(self, path="TB2J_symmetrized"):
         if path is None:
@@ -89,7 +94,7 @@ def symmetrize_J(
     """
     if exc is None:
         exc = SpinIO.load_pickle(path=path, fname=fname)
-    symmetrizer = TB2JSymmetrizer(exc, symprec=symprec)
+    symmetrizer = TB2JSymmetrizer(exc, symprec=symprec, Jonly=Jonly)
     symmetrizer.run(path=output_path)
 
 
@@ -130,7 +135,12 @@ def symmetrize_J_cli():
     if args.inpath is None:
         parser.print_help()
         raise ValueError("Please provide the input path to the exchange.")
-    symmetrize_J(path=args.inpath, output_path=args.outpath, symprec=args.symprec)
+    symmetrize_J(
+        path=args.inpath,
+        output_path=args.outpath,
+        symprec=args.symprec,
+        Jonly=args.Jonly,
+    )
 
 
 if __name__ == "__main__":

TB2J/versioninfo.py

@@ -1,6 +1,7 @@
-import TB2J
 from datetime import datetime
 
+import TB2J
+
 
 def print_license():
     print(

{TB2J-0.9.9rc4.dist-info → TB2J-0.9.9rc6.dist-info}/METADATA

@@ -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.dist-info → TB2J-0.9.9rc6.dist-info}/RECORD

@@ -1,46 +1,47 @@
 TB2J/Jdownfolder.py,sha256=Rmg6KfQ-Lkhei5daTJ2POzr0XL-R1WM-rzUnDcfoDhc,9595
 TB2J/Jtensor.py,sha256=t6OsqrSlYW6Im4H7ykVAW8Al_pFXN4C5yj2UEsV6r7g,3181
-TB2J/MAE.py,sha256=9VwwLpUALaaVwn4LTnhSISJMT7MDym247sSKT5Rum0o,10989
-TB2J/MAEGreen.py,sha256=eXzQDue54YJOHpL5OgoOutlqN69PQjoVz-Oqy2-TWOA,10731
+TB2J/MAE.py,sha256=fM8U-Dgp9HcQOEeC_kyZV1oVrygBvcux9BraUXVouvY,10994
+TB2J/MAEGreen.py,sha256=MoLoE5fLpbp1knAP_oU-egHr0jnpTQpqD9FgoVtDkgk,12322
 TB2J/Oiju.py,sha256=cNGv8N5uH_swGq7cnAt2OyiDfqtjLlLrwseGu0E4iaM,3383
 TB2J/Oiju_epc.py,sha256=oytM3NYW7nWmklrGgNlqwIpI_JYv_hb7ZnR4o9nYNog,6809
 TB2J/__init__.py,sha256=hcEWkag_UvLm1ZSbjsgcTWkGVlR3Bwmzg1QYAwsvf-g,24
 TB2J/anisotropy.py,sha256=zz4ID6_Yjf5gxPJt1psc6liNKhTG8X5AtHdpq0dCEzM,22616
 TB2J/basis.py,sha256=DFo6_QUwjBwisP6zGxvoO0lpGTMDPAOkiL9giNCjOjA,1558
 TB2J/citation.py,sha256=gcQeyJZaT1Qrtsl8Y3s4neOH3-vvgmIcCvXeV2o3vj0,2891
-TB2J/contour.py,sha256=4wFZSPV81WwuUrvn1MENMnP-cW5ICDy8azOdTO8HJdw,2877
+TB2J/contour.py,sha256=zLHQZZ3hhgLkLFPATCraLOJyLJKLC0fba_L_5sRz23o,3246
 TB2J/density_matrix.py,sha256=D5k8Oe21OCiLVORNYbo4TZOFG0slrQSbj91kJ3TMFjs,1514
 TB2J/epc.py,sha256=zLbtqZJhDr8DnnGN6YENcXwrMb3Qxu6KB08mLy9Pw20,3474
-TB2J/exchange.py,sha256=TEX8xagcn2DIbygC7C39LD7nvpYp996GcOcLFBBun4U,25830
-TB2J/exchangeCL2.py,sha256=vJgVBpvtTE2K7Xf7hGQNc3C87VvVXTa689Qd5827ItE,11165
-TB2J/exchange_params.py,sha256=hKz78yxU1RTXntmGArY94jfNrYJn-C4irHn0RfBXu0k,6908
+TB2J/exchange.py,sha256=1kkrrQvmoOaPgT_rKG7wgLy31rWpbFGNYXai1ysd58M,26221
+TB2J/exchangeCL2.py,sha256=P7bklMXVYX_tn9DbjEPqeTir1SeZyfPBIP1fhWUzLmY,11419
+TB2J/exchange_params.py,sha256=AcGYYky27DXSF3yDZWVjksr_3rt6im6qeIzpOwvqssk,7141
 TB2J/exchange_pert.py,sha256=jmFMtQbYa_uczM4VAeS6TijkIHRFIqEzZJswzE9Wfuo,8523
 TB2J/exchange_qspace.py,sha256=ZL68qBGFUaQ9BsSPsJaaoWOr9RssPiqX34R_9I3nk_8,8436
 TB2J/gpaw_wrapper.py,sha256=aJ--9Dtyq7jOP1Hkh-Sh1nWcfXm6zKcljOCO0DNCAr0,6890
-TB2J/green.py,sha256=Dz189KtGsHlANBU4TiSTZpxGEpETFZaphwyIaNp3a5E,14721
+TB2J/green.py,sha256=ySXjoV3Cj_E2C41dRfc3TkS7M4vmM6qcHXkt-_-jxsY,17071
 TB2J/greentest.py,sha256=2ISSfhor9ecSEOi_E6b4Cv26wEIQlwlzca0ru8z44_E,1603
 TB2J/io_merge.py,sha256=E1_GfAB2HGpW-ipaO2lqU9SvaslwkiLxssn4DqJpMT8,6899
-TB2J/kpoints.py,sha256=6XK2KqTncidEq3o9GuO6VEZRPNTRtWeXg9QfcV-9smI,532
+TB2J/kpoints.py,sha256=9L7tBarFBHoIhpuc9zuwA6HdnlgH834SQrPek4yRoWk,3191
 TB2J/myTB.py,sha256=ok_B4my29bOIghMSZfx0Es6G8FaXaIiLP4gPxTdSj00,17659
-TB2J/orbmap.py,sha256=g5Lhp6UkDZ7-1T9k0oO43gb2O7j2aGVKMdUeM3QdNAY,7186
+TB2J/mycfr.py,sha256=Wgj6PpA-oVuxm8Hh32FVw_vthozVBrDJhRV1hA1ku44,3752
+TB2J/orbmap.py,sha256=XLQjKMxCy2eADaM5eb2F_zG08V7lzpXJxp5uEtTeVYI,7194
 TB2J/pauli.py,sha256=ESpAhk6LG5ugzuW1YFUTqiDxcg-pQ7wNnzR2FtUnvKM,5295
 TB2J/pert.py,sha256=RaCJfewl0doht4cjAnzzGKe-uj2le4aqe0iPKFrq9fo,1192
 TB2J/plot.py,sha256=AnFIFWE2vlmj7Z6f_7-dX_O1stJN-qbuiurPj43dUCM,4104
 TB2J/rotate_atoms.py,sha256=Dwptn-wdDW4zYzjYb95yxTzuZOe9WPuLjh3d3-YcSs0,3277
 TB2J/rotate_siestaDM.py,sha256=eR97rspdrRaK9YTwQwUKfobI0S9UnEcbEZ2f5IgR7Tk,1070
 TB2J/sisl_wrapper.py,sha256=A5x1-tt8efUSPeGY5wM5m6-pJYQFXTCzQHVqD6RBa2g,14792
-TB2J/symmetrize_J.py,sha256=6ahB65d9UwbmQDvGR_4V7Cx-1Au1ElBOheYFQRlGRvk,4247
+TB2J/symmetrize_J.py,sha256=IypvLL0JxExq-cmqc4o0nLL8psE7OC9ijj9YMcsqJeA,4487
 TB2J/tensor_rotate.py,sha256=4-DfT_Mg5e40fbd74M5W0D5DqmUq-kVOOLDkkkI834A,8083
 TB2J/utest.py,sha256=z_ahi7tpHQF9WlHNQihcQ7qzfezRJQXQt28eB1X_z64,3897
 TB2J/utils.py,sha256=DHkc7BK0KUGesfoAv1OxMgIw_iZzcFXh--3ybsFSd_c,12535
-TB2J/versioninfo.py,sha256=wZwS9QDFRVDe7rf8JyPDDI8UGdTQiO6Pb_sWv8GAegA,337
+TB2J/versioninfo.py,sha256=atoCpy6lEcGTCC3xahrxEJjoHgoYVtL41Q_3Ryvp76I,338
 TB2J/external/__init__.py,sha256=yD_ZIMi76H49rj6GAQpiB7UlKa3TgSaMkkLHT6M-8w8,137
 TB2J/external/p_tqdm.py,sha256=ug1jy3-43r8iW7bC37xzPSIe0EjYKH_GUluGzMiQiDw,5831
 TB2J/interfaces/__init__.py,sha256=4tiLoXQ73Nlyi9L4j8jJXOYzXluVNPxQZkwfkQZEGHg,307
 TB2J/interfaces/gpaw_interface.py,sha256=GCDlJ-hRWfChvWwsgBDYSmVqO4sH9HAuGZTV9GqgN6c,1504
 TB2J/interfaces/lawaf_interface.py,sha256=PieLnmppdafOYsgeHznqOou1g9L1sam5jOm3KaObdqo,4408
 TB2J/interfaces/manager.py,sha256=PQMLEfMCT5GnDWSl2nI4JOgRPm_fysyR-6Y6l97xWcw,860
-TB2J/interfaces/siesta_interface.py,sha256=rpDDePtL4zFaS8FGHrIruPawxy78JbIZ4TUQoInIu5g,7296
+TB2J/interfaces/siesta_interface.py,sha256=C9dMmFAc8HlCGFJeHLn0nUvOJA1rhVYIFIz8udMdJjE,7332
 TB2J/interfaces/wannier90_interface.py,sha256=qzRgXUBb7t1Aiegrl_RV51BB8csdtVM0EP0Z4pjmTcs,4467
 TB2J/interfaces/abacus/__init__.py,sha256=leas71oCvM_HxrF4gnO5A_VKcJmDAgsI1BUctLU3OBw,177
 TB2J/interfaces/abacus/abacus_api.py,sha256=lNV4LNkLcKw7Zux4MQYM9wnh3eFTlcSqbf4Pb7pqhrk,7243
@@ -76,19 +77,19 @@ TB2J/spinham/supercell.py,sha256=y17uUC6r3gQb278FhxIW4CABihfLTvKFj6flyXrCPR8,122
 TB2J/wannier/__init__.py,sha256=7ojCbM84PYv1X1Tbo4NHI-d3gWmQsZB_xiYqbfxVV1E,80
 TB2J/wannier/w90_parser.py,sha256=dbd63LuKyv2DVUzqRINGsbDzEsOxsQyE8_Ear_LQIRg,4620
 TB2J/wannier/w90_tb_parser.py,sha256=qt8pnuprmPp9iIAYwPkPbmEzk6ZPgMq2xognoQp7vwc,4610
-TB2J-0.9.9rc4.data/scripts/TB2J_downfold.py,sha256=i4BVqnpDdgrX_amookVWeLGefGBn-qeAutWiwuY9SfQ,2099
-TB2J-0.9.9rc4.data/scripts/TB2J_eigen.py,sha256=Qs9v2hnMm2Tpfoa4h53muUKty2dZjwx8948MBoQooNg,1128
-TB2J-0.9.9rc4.data/scripts/TB2J_magnon.py,sha256=q7UwAmorRcFNk4tfE7gl_ny05l6p7pbD9Wm_LkIpKEw,3101
-TB2J-0.9.9rc4.data/scripts/TB2J_magnon_dos.py,sha256=TMXQvD2dIbO5FZ4tUMmxJgCgH2O2hDAPUNfEKO4z-x4,110
-TB2J-0.9.9rc4.data/scripts/TB2J_merge.py,sha256=y834SF4rIRn1L1ptkhczvavQpC-8Px6DTmDOOSaq_DE,1854
-TB2J-0.9.9rc4.data/scripts/TB2J_rotate.py,sha256=zgiDFuYZNmzKK0rwDmTaYD2OpRlmKA_VGeBx83w2Xwc,873
-TB2J-0.9.9rc4.data/scripts/TB2J_rotateDM.py,sha256=kCvF7gotuqAX1VnJ06cwfVm7RrhrdtiV5v7d9P2Pn_E,567
-TB2J-0.9.9rc4.data/scripts/abacus2J.py,sha256=0HLXoJhAkiZ-ZM1cs26lncccxE8-TzC8JiDTba1h1uM,4163
-TB2J-0.9.9rc4.data/scripts/siesta2J.py,sha256=gp31LioqpPkDmMY0y_5gXIjOBPNnf080P37pRo0yjw8,4886
-TB2J-0.9.9rc4.data/scripts/wann2J.py,sha256=pTFDf6h72I_LN_NX5UivyCoJPgwvyAyHW175nSAJvLo,2987
-TB2J-0.9.9rc4.dist-info/LICENSE,sha256=CbZI-jyRTjiqIcWa244cRSHJdjjtUNqGR4HeJkgEwJw,1332
-TB2J-0.9.9rc4.dist-info/METADATA,sha256=PHff7nqo8ab-J2HQ8BSg5QuHXgV4c2CsPceDxa6f5Qk,1482
-TB2J-0.9.9rc4.dist-info/WHEEL,sha256=cVxcB9AmuTcXqmwrtPhNK88dr7IR_b6qagTj0UvIEbY,91
-TB2J-0.9.9rc4.dist-info/entry_points.txt,sha256=Hdz1WC9waUzyFVmowKnbbZ6j-J4adHh_Ko6JpxGYAtE,131
-TB2J-0.9.9rc4.dist-info/top_level.txt,sha256=whYa5ByLYhl5XnTPBHSWr-IGD6VWmr5Ql2bye2qwV_s,5
-TB2J-0.9.9rc4.dist-info/RECORD,,
+TB2J-0.9.9rc6.data/scripts/TB2J_downfold.py,sha256=i4BVqnpDdgrX_amookVWeLGefGBn-qeAutWiwuY9SfQ,2099
+TB2J-0.9.9rc6.data/scripts/TB2J_eigen.py,sha256=Qs9v2hnMm2Tpfoa4h53muUKty2dZjwx8948MBoQooNg,1128
+TB2J-0.9.9rc6.data/scripts/TB2J_magnon.py,sha256=q7UwAmorRcFNk4tfE7gl_ny05l6p7pbD9Wm_LkIpKEw,3101
+TB2J-0.9.9rc6.data/scripts/TB2J_magnon_dos.py,sha256=TMXQvD2dIbO5FZ4tUMmxJgCgH2O2hDAPUNfEKO4z-x4,110
+TB2J-0.9.9rc6.data/scripts/TB2J_merge.py,sha256=y834SF4rIRn1L1ptkhczvavQpC-8Px6DTmDOOSaq_DE,1854
+TB2J-0.9.9rc6.data/scripts/TB2J_rotate.py,sha256=zgiDFuYZNmzKK0rwDmTaYD2OpRlmKA_VGeBx83w2Xwc,873
+TB2J-0.9.9rc6.data/scripts/TB2J_rotateDM.py,sha256=kCvF7gotuqAX1VnJ06cwfVm7RrhrdtiV5v7d9P2Pn_E,567
+TB2J-0.9.9rc6.data/scripts/abacus2J.py,sha256=0HLXoJhAkiZ-ZM1cs26lncccxE8-TzC8JiDTba1h1uM,4163
+TB2J-0.9.9rc6.data/scripts/siesta2J.py,sha256=gp31LioqpPkDmMY0y_5gXIjOBPNnf080P37pRo0yjw8,4886
+TB2J-0.9.9rc6.data/scripts/wann2J.py,sha256=pTFDf6h72I_LN_NX5UivyCoJPgwvyAyHW175nSAJvLo,2987
+TB2J-0.9.9rc6.dist-info/LICENSE,sha256=CbZI-jyRTjiqIcWa244cRSHJdjjtUNqGR4HeJkgEwJw,1332
+TB2J-0.9.9rc6.dist-info/METADATA,sha256=liNOEG_iKPUW6hOrcu08SqCBqzeEd3RxGRt3_YxBh2M,1482
+TB2J-0.9.9rc6.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+TB2J-0.9.9rc6.dist-info/entry_points.txt,sha256=Hdz1WC9waUzyFVmowKnbbZ6j-J4adHh_Ko6JpxGYAtE,131
+TB2J-0.9.9rc6.dist-info/top_level.txt,sha256=whYa5ByLYhl5XnTPBHSWr-IGD6VWmr5Ql2bye2qwV_s,5
+TB2J-0.9.9rc6.dist-info/RECORD,,

{TB2J-0.9.9rc4.dist-info → TB2J-0.9.9rc6.dist-info}/WHEEL

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