TB2J 0.9.6rc0__tar.gz → 0.9.8rc0__tar.gz

{tb2j-0.9.6rc0 → tb2j-0.9.8rc0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: TB2J
-Version: 0.9.6rc0
+Version: 0.9.8rc0
 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.6rc0 → tb2j-0.9.8rc0}/TB2J/MAE.py

@@ -35,12 +35,25 @@ def get_density_matrix(evals=None, evecs=None, kweights=None, nel=None, width=0.
 
 
 class MAE:
-    def __init__(self, model, kmesh, gamma=True, width=0.1, nel=None):
+    def __init__(
+        self,
+        model,
+        kmesh=None,
+        gamma=True,
+        kpts=None,
+        kweights=None,
+        width=0.1,
+        nel=None,
+    ):
         self.model = model
         if nel is not None:
             self.model.nel = nel
-        self.kpts = monkhorst_pack(kmesh, gamma_center=gamma)
-        self.kweights = np.ones(len(self.kpts), dtype=float) / len(self.kpts)
+        if kpts is None:
+            self.kpts = monkhorst_pack(kmesh, gamma_center=gamma)
+            self.kweights = np.ones(len(self.kpts), dtype=float) / len(self.kpts)
+        else:
+            self.kpts = kpts
+            self.kweights = kweights
         self.width = width
 
     def get_band_energy(self):
@@ -94,8 +107,27 @@ class MAE:
 
 
 class MAEGreen(MAE):
-    def __init__(self, model, kmesh, gamma=True, nel=None, width=0.1, **kwargs):
-        super().__init__(model, kmesh, gamma=gamma, nel=nel, width=width)
+    def __init__(
+        self,
+        model,
+        kmesh=None,
+        gamma=True,
+        kpts=None,
+        kweights=None,
+        nel=None,
+        width=0.1,
+        **kwargs,
+    ):
+        self.model = model
+        if nel is not None:
+            self.model.nel = nel
+        if kpts is None:
+            self.kpts = monkhorst_pack(kmesh, gamma_center=gamma)
+            self.kweights = np.ones(len(self.kpts), dtype=float) / len(self.kpts)
+        else:
+            self.kpts = kpts
+            self.kweights = kweights
+        self.width = width
         model.set_so_strength(0.0)
         evals, evecs = model.solve_all(self.kpts)
         occ = Occupations(
@@ -103,8 +135,9 @@ class MAEGreen(MAE):
         )
         # occ.occupy(evals)
         efermi = occ.efermi(evals)
+        print(f"{efermi=}")
         self.G = TBGreen(model, kmesh, efermi=efermi, gamma=gamma, **kwargs)
-        self.emin = -18
+        self.emin = -12
         self.emax = 0
         self.nz = 50
         self._prepare_elist()
@@ -143,7 +176,8 @@ class MAEGreen(MAE):
             for i, dHk in enumerate(Hsoc_k):
                 dHi = rotate_spinor_matrix(dHk, theta, phi)
                 GdH = G0K[i] @ dHi
-                dE += np.trace(GdH @ G0K[i].T.conj() @ dHi) * self.kweights[i]
+                # dE += np.trace(GdH @ G0K[i].T.conj() @ dHi) * self.kweights[i]
+                dE += np.trace(GdH @ GdH) * self.kweights[i]
             dE_ang.append(dE)
         return np.array(dE_ang)
 

tb2j-0.9.8rc0/TB2J/MAEGreen.py

@@ -0,0 +1,84 @@
+from pathlib import Path
+
+import numpy as np
+import tqdm
+
+# from TB2J.abacus.abacus_wrapper import AbacusSplitSOCParser
+from TB2J.exchange import ExchangeNCL
+
+# 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
+from TB2J.mathutils.rotate_spin import (
+    rotate_spinor_matrix,
+)
+
+
+class MAEGreen(ExchangeNCL):
+    def __init__(self, angles=None, **kwargs):
+        super().__init__(**kwargs)
+        self.es = None
+        self.natoms = len(self.atoms)
+        if angles is None or angles == "axis":
+            self.set_angles_axis()
+        elif angles == "scan":
+            self.set_angles_scan()
+
+    def set_angles_axis(self):
+        """theta and phi are defined as the x, y, z, axis."""
+        self.thetas = [0, np.pi / 2, np.pi / 2, np.pi / 2]
+        self.phis = [0, 0, np.pi / 2, np.pi / 4]
+
+    def set_angles_scan(self, step=15):
+        self.thetas = []
+        self.phis = []
+        for i in range(0, 181, step):
+            for j in range(0, 181, step):
+                self.thetas.append(i * np.pi / 180)
+                self.phis.append(j * np.pi / 180)
+
+    def get_perturbed(self, e, thetas, phis):
+        self.tbmodel.set_so_strength(0.0)
+        G0K = self.G.get_Gk_all(e)
+        Hsoc_k = self.tbmodel.get_Hk_soc(self.G.kpts)
+        na = len(thetas)
+        dE_angle = np.zeros(na, dtype=complex)
+        dE_angle_atoms = np.zeros((na, self.natoms), dtype=complex)
+        for iangle, (theta, phi) in enumerate(zip(thetas, phis)):
+            for ik, dHk in enumerate(Hsoc_k):
+                dHi = rotate_spinor_matrix(dHk, theta, phi)
+                GdH = G0K[ik] @ dHi
+                # dE += np.trace(GdH @ G0K[i].T.conj() @ dHi) * self.kweights[i]
+                # diagonal of second order perturbation.
+                dG2diag = np.diag(GdH @ GdH)
+                # dG2diag = np.diag(GdH @G0K[i].T.conj() @ dHi)
+                dE_angle[iangle] += np.sum(dG2diag) * self.G.kweights[ik]
+                for iatom in range(self.natoms):
+                    dE_atom = np.sum(dG2diag[self.iorb(iatom)]) * self.G.kweights[ik]
+                    dE_angle_atoms[iangle, iatom] += dE_atom
+        return dE_angle, dE_angle_atoms
+
+    def get_band_energy_vs_angles(self, thetas, phis):
+        nangles = len(thetas)
+        self.es = np.zeros(nangles, dtype=float)
+        self.es_atoms = np.zeros((nangles, self.natoms), dtype=float)
+        for ie, e in enumerate(tqdm.tqdm(self.contour.path)):
+            dE_angle, dE_angle_atoms = self.get_perturbed(e, thetas, phis)
+            self.es -= np.imag(dE_angle * self.contour.weights[ie]) / np.pi
+            self.es_atoms -= np.imag(dE_angle_atoms * self.contour.weights[ie]) / np.pi
+
+    def output(self, output_path="TB2J_anisotropy"):
+        Path(output_path).mkdir(exist_ok=True)
+        fname = f"{output_path}/MAE.dat"
+        with open(fname, "w") as f:
+            f.write("# theta phi MAE, MAEatom1, atom2, ...\n")
+            for i, (theta, phi, e, es) in enumerate(
+                zip(self.thetas, self.phis, self.es, self.es_atoms)
+            ):
+                f.write(f"{theta:.5f} {phi:.5f} {e:.8f} ")
+                for ea in es:
+                    f.write(f"{ea:.8f} ")
+                f.write("\n")
+
+    def run(self, output_path="TB2J_anisotropy"):
+        self.get_band_energy_vs_angles(self.thetas, self.phis)
+        self.output(output_path=output_path)

{tb2j-0.9.6rc0 → tb2j-0.9.8rc0}/TB2J/exchange.py

@@ -11,7 +11,7 @@ from TB2J.external import p_map
 from TB2J.green import TBGreen
 from TB2J.io_exchange import SpinIO
 from TB2J.orbmap import map_orbs_matrix
-from TB2J.pauli import pauli_block_all, pauli_block_sigma_norm, pauli_mat
+from TB2J.pauli import pauli_block_all, pauli_block_sigma_norm
 from TB2J.utils import (
     kmesh_to_R,
     simpson_nonuniform,
@@ -39,10 +39,7 @@ class Exchange(ExchangeParams):
         self._prepare_distance()
 
         # whether to calculate J and DMI with NJt method.
-        self.calc_NJt = True
         # self._prepare_NijR()
-        self.Ddict_NJT = None
-        self.Jdict_NJT = None
         self._is_collinear = True
         self.has_elistc = False
         self._clean_tbmodels()
@@ -60,8 +57,9 @@ class Exchange(ExchangeParams):
         pass
 
     def _clean_tbmodels(self):
-        del self.tbmodel
-        del self.G.tbmodel
+        # del self.tbmodel
+        # del self.G.tbmodel
+        pass
 
     def _prepare_kmesh(self, kmesh):
         for k in kmesh:
@@ -262,9 +260,11 @@ class ExchangeNCL(Exchange):
         """
         self.tbmodel = tbmodels
         self.backend_name = self.tbmodel.name
+        print(self.kmesh)
         self.G = TBGreen(
             tbmodel=self.tbmodel,
             kmesh=self.kmesh,
+            gamma=True,
             efermi=self.efermi,
             use_cache=self._use_cache,
             nproc=self.nproc,
@@ -551,53 +551,6 @@ class ExchangeNCL(Exchange):
         self.rho_dict = rho
         return self.rho_dict
 
-    def calculate_DMI_NJT(self):
-        """
-        calculate exchange and DMI with the
-        This did not work and should be removed.
-        """
-        Ddict_NJT = {}
-        Jdict_NJT = {}
-        for R in self.short_Rlist:
-            N = self.N[tuple(-np.array(R))]  # density matrix
-            t = self.tbmodel.get_hamR(R)  # hopping parameter
-            for iatom in self.ind_mag_atoms:
-                orbi = self.iorb(iatom)
-                ni = len(orbi)
-                for jatom in self.ind_mag_atoms:
-                    orbj = self.iorb(jatom)
-                    nj = len(orbj)
-                    Nji = N[np.ix_(orbj, orbi)]
-                    tij = t[np.ix_(orbi, orbj)]
-                    D = np.zeros(3, dtype=float)
-                    J = np.zeros(3, dtype=float)
-                    for dim in range(3):
-                        # S_i = pauli_mat(ni, dim +
-                        #                1)  #*self.rho[np.ix_(orbi, orbi)]
-                        # S_j = pauli_mat(nj, dim +
-                        #                1)  #*self.rho[np.ix_(orbj, orbj)]
-                        # TODO: Note that rho is complex, not the imaginary part
-                        S_i = pauli_mat(ni, dim + 1) * self.rho[np.ix_(orbi, orbi)]
-                        S_j = pauli_mat(nj, dim + 1) * self.rho[np.ix_(orbj, orbj)]
-
-                        # [S, t]+  = Si tij + tij Sj, where
-                        # Si and Sj are the spin operator
-                        # Here we do not have L operator, so J-> S
-                        Jt = np.matmul(S_i, tij) + np.matmul(tij, S_j)
-
-                        Jtminus = np.matmul(S_i, tij) - np.matmul(tij, S_j)
-                        # D = -1/2 Tr Nji [J, tij]
-                        # Trace over spin and orb
-                        D[dim] = -0.5 * np.imag(np.trace(np.matmul(Nji, Jt)))
-                        J[dim] = -0.5 * np.imag(np.trace(np.matmul(Nji, Jtminus)))
-                    ispin = self.ispin(iatom)
-                    jspin = self.ispin(jatom)
-                    Ddict_NJT[(R, ispin, jspin)] = D
-                    Jdict_NJT[(R, ispin, jspin)] = J
-        self.Jdict_NJT = Jdict_NJT
-        self.Ddict_NJT = Ddict_NJT
-        return Ddict_NJT
-
     def integrate(self, AijRs, AijRs_orb=None, method="simpson"):
         """
         AijRs: a list of AijR,
@@ -620,37 +573,14 @@ class ExchangeNCL(Exchange):
 
     def get_quantities_per_e(self, e):
         Gk_all = self.G.get_Gk_all(e)
-        mae = self.get_mae_kspace(Gk_all)
+        # mae = self.get_mae_kspace(Gk_all)
+        mae = None
         # TODO: get the MAE from Gk_all
         GR = self.G.get_GR(self.short_Rlist, energy=e, get_rho=False, Gk_all=Gk_all)
         # TODO: define the quantities for one energy.
         AijR, AijR_orb = self.get_all_A(GR)
         return dict(AijR=AijR, AijR_orb=AijR_orb, mae=mae)
 
-    def get_mae_kspace(self, Gk_all):
-        """
-        get the MAE from Gk_all
-        TODO: This is only a place holder.
-        """
-        return None
-
-    #    mae_e = np.zeros(len(self.mae_angles), dtype=complex)
-    #    # rotate the Hso_k to angles
-    #    for ik, k in enumerate(self.G.kpoints):
-    #        Hso_k = self.model.get_Hso_k(k)
-    #        Gk = Gk_all[ik]
-    #        for i_angle, angle in enumerate(self.mae_angles):
-    #            # TODO: implementa rotate_H
-    #            Hso_k_rot = rotate_H(Hso_k, angle)
-    #            mae_e[i_angle] = Gk @ Hso_k @ Gk @ Hso_k
-    #    return mae_e
-
-    def get_mae_rspace(self, GR):
-        """
-        get the MAE from GR
-        """
-        raise NotImplementedError("Not yet implemented.")
-
     def save_AijR(self, AijRs, fname):
         result = dict(path=self.contour.path, AijRs=AijRs)
         with open(fname, "wb") as myfile:
@@ -739,8 +669,6 @@ class ExchangeNCL(Exchange):
             Jani_dict=self.Jani,
             DMI_orb=self.DMI_orb,
             Jani_orb=self.Jani_orb,
-            NJT_Jdict=self.Jdict_NJT,
-            NJT_ddict=self.Ddict_NJT,
             biquadratic_Jdict=self.B,
             debug_dict=self.debug_dict,
             description=self.description,
@@ -779,8 +707,6 @@ class ExchangeCL(ExchangeNCL):
             distance_dict=self.distance_dict,
             exchange_Jdict=self.exchange_Jdict,
             dmi_ddict=None,
-            NJT_Jdict=None,
-            NJT_ddict=None,
             biquadratic_Jdict=self.B,
             description=self.description,
         )

{tb2j-0.9.6rc0 → tb2j-0.9.8rc0}/TB2J/green.py

@@ -166,7 +166,7 @@ class TBGreen:
             print("Calculating Fermi energy from eigenvalues")
             print(f"Number of electrons: {self.tbmodel.nel} ")
             occ = Occupations(
-                nel=self.tbmodel.nel, width=0.05, wk=self.kweights, nspin=2
+                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}")

{tb2j-0.9.6rc0 → tb2j-0.9.8rc0}/TB2J/interfaces/siesta_interface.py

@@ -4,6 +4,7 @@ import numpy as np
 
 from TB2J.exchange import ExchangeNCL
 from TB2J.exchangeCL2 import ExchangeCL2
+from TB2J.MAEGreen import MAEGreen
 
 try:
     from HamiltonIO.siesta import SislParser
@@ -12,28 +13,70 @@ except ImportError:
         "Cannot import SislWrapper from HamiltonIO.siesta. Please install HamiltonIO first."
     )
 
-np.seterr(all="raise", under="ignore")
 
+def siesta_anisotropy(**kwargs):
+    pass
 
-def gen_exchange_siesta(
-    fdf_fname,
-    read_H_soc=False,
-    magnetic_elements=[],
-    include_orbs=None,
-    kmesh=[5, 5, 5],
-    emin=-12.0,
-    emax=0.0,
-    nz=100,
-    exclude_orbs=[],
-    Rcut=None,
-    ne=None,
-    nproc=1,
-    use_cache=False,
-    output_path="TB2J_results",
-    orb_decomposition=False,
-    orth=False,
-    description="",
-):
+
+def gen_exchange_siesta(fdf_fname, read_H_soc=False, **kwargs):
+    """
+    parameters:
+        fdf_fname: str
+            The fdf file for the calculation.
+        read_H_soc: bool
+            Whether to read the SOC Hamiltonian. Default is False.
+
+    parameters in **kwargs:
+        magnetic_elements: list of str
+            The magnetic elements to calculate the exchange. e.g. ["Fe", "Co", "Ni"]
+        include_orbs: dict
+            The included orbitals for each magnetic element. e.g. {"Fe": ["d"]}. Default is None.
+        kmesh: list of int
+            The k-point mesh for the calculation. e.g. [5, 5, 5]. Default is [5, 5, 5].
+        emin: float
+            The minimum energy for the calculation. Default is -12.0.
+        emax: float
+            The maximum energy for the calculation. Default is 0.0.
+        nz: int
+            The number of points for the energy mesh. Default is 100.
+        exclude_orbs: list of str
+            The excluded orbitals for the calculation. Default is [].
+        Rcut: float
+            The cutoff radius for the exchange calculation in angstrom. Default is None.
+        ne: int
+            The number of electrons for the calculation. Default is None.
+        nproc: int
+            The number of processors for the calculation. Default is 1.
+        use_cache: bool
+            Whether to use the cache for the calculation. Default is False.
+        output_path: str
+            The output path for the calculation. Default is "TB2J_results".
+        orb_decomposition: bool
+            Whether to calculate the orbital decomposition. Default is False.
+        orth: bool
+            Whether to orthogonalize the orbitals. Default is False.
+        description: str
+            The description for the calculation. Default is "".
+    """
+
+    exargs = dict(
+        magnetic_elements=[],
+        include_orbs=None,
+        kmesh=[5, 5, 5],
+        emin=-12.0,
+        emax=0.0,
+        nz=100,
+        exclude_orbs=[],
+        Rcut=None,
+        ne=None,
+        nproc=1,
+        use_cache=False,
+        output_path="TB2J_results",
+        orb_decomposition=False,
+        orth=False,
+        description="",
+    )
+    exargs.update(kwargs)
     try:
         import sisl
     except ImportError:
@@ -46,7 +89,8 @@ def gen_exchange_siesta(
             f"sisl version is {sisl.__version__}, but should be larger than 0.10.0."
         )
 
-    include_orbs = {}
+    magnetic_elements = exargs.pop("magnetic_elements")
+    include_orbs = exargs.pop("include_orbs")
     if isinstance(magnetic_elements, str):
         magnetic_elements = [magnetic_elements]
     for element in magnetic_elements:
@@ -57,13 +101,10 @@ def gen_exchange_siesta(
         else:
             include_orbs[element] = None
     magnetic_elements = list(include_orbs.keys())
+    output_path = exargs.pop("output_path")
 
-    # fdf = sisl.get_sile(fdf_fname)
-    # geom = fdf.read_geometry()
-    # H = fdf.read_hamiltonian()
-    # geom = H.geometry
     parser = SislParser(
-        fdf_fname=fdf_fname, ispin=None, read_H_soc=read_H_soc, orth=orth
+        fdf_fname=fdf_fname, ispin=None, read_H_soc=read_H_soc, orth=exargs["orth"]
     )
     if parser.spin.is_colinear:
         print("Reading Siesta hamiltonian: colinear spin.")
@@ -83,17 +124,7 @@ def gen_exchange_siesta(
             efermi=0.0,
             magnetic_elements=magnetic_elements,
             include_orbs=include_orbs,
-            kmesh=kmesh,
-            emin=emin,
-            emax=emax,
-            nz=nz,
-            exclude_orbs=exclude_orbs,
-            Rcut=Rcut,
-            ne=ne,
-            nproc=nproc,
-            use_cache=use_cache,
-            output_path=output_path,
-            description=description,
+            **exargs,
         )
         exchange.run(path=output_path)
         print("\n")
@@ -111,28 +142,17 @@ Warning: The DMI component parallel to the spin orientation, the Jani which has
  e.g. if the spins are along z, the xz, yz, zz, zx, zy components and the z component of DMI.
  If you need these component, try to do three calculations with spin along x, y, z,  or use structure with z rotated to x, y and z. And then use TB2J_merge.py to get the full set of parameters.
 \n"""
+        exargs["description"] = description
         if not model.split_soc:
             exchange = ExchangeNCL(
                 tbmodels=model,
                 atoms=model.atoms,
                 basis=basis,
                 efermi=0.0,
-                # FIXME:
-                # efermi=None,
                 magnetic_elements=magnetic_elements,
                 include_orbs=include_orbs,
-                kmesh=kmesh,
-                emin=emin,
-                emax=emax,
-                nz=nz,
-                exclude_orbs=exclude_orbs,
-                Rcut=Rcut,
-                ne=ne,
-                nproc=nproc,
-                use_cache=use_cache,
-                description=description,
                 output_path=output_path,
-                orb_decomposition=orb_decomposition,
+                **exargs,
             )
             exchange.run(path=output_path)
             print("\n")
@@ -140,6 +160,25 @@ Warning: The DMI component parallel to the spin orientation, the Jani which has
                 f"All calculation finished. The results are in {output_path} directory."
             )
         else:
+            print("Starting to calculate MAE.")
+            model.set_so_strength(0.0)
+            MAE = MAEGreen(
+                tbmodels=model,
+                atoms=model.atoms,
+                basis=basis,
+                efermi=None,
+                magnetic_elements=magnetic_elements,
+                include_orbs=include_orbs,
+                **exargs,
+            )
+            # 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")
+            print(
+                f"MAE calculation finished. The results are in {output_path} directory."
+            )
+
             angle = {"x": (np.pi / 2, 0), "y": (np.pi / 2, np.pi / 2), "z": (0, 0)}
             for key, val in angle.items():
                 # model = parser.get_model()
@@ -154,18 +193,7 @@ Warning: The DMI component parallel to the spin orientation, the Jani which has
                     efermi=None,  # set to None, compute from efermi.
                     magnetic_elements=magnetic_elements,
                     include_orbs=include_orbs,
-                    kmesh=kmesh,
-                    emin=emin,
-                    emax=emax,
-                    nz=nz,
-                    exclude_orbs=exclude_orbs,
-                    Rcut=Rcut,
-                    ne=ne,
-                    nproc=nproc,
-                    use_cache=use_cache,
-                    description=description,
-                    output_path=output_path_full,
-                    orb_decomposition=orb_decomposition,
+                    **exargs,
                 )
                 exchange.run(path=output_path_full)
                 print("\n")

{tb2j-0.9.6rc0 → tb2j-0.9.8rc0}/TB2J.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: TB2J
-Version: 0.9.6rc0
+Version: 0.9.8rc0
 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.6rc0 → tb2j-0.9.8rc0}/TB2J.egg-info/SOURCES.txt

@@ -4,6 +4,7 @@ setup.py
 TB2J/Jdownfolder.py
 TB2J/Jtensor.py
 TB2J/MAE.py
+TB2J/MAEGreen.py
 TB2J/Oiju.py
 TB2J/Oiju_epc.py
 TB2J/__init__.py

{tb2j-0.9.6rc0 → tb2j-0.9.8rc0}/setup.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 from setuptools import find_packages, setup
 
-__version__ = "0.9.6_pre"
+__version__ = "0.9.8_pre"
 
 long_description = """TB2J is a Python package aimed to compute automatically the magnetic interactions (superexchange  and Dzyaloshinskii-Moriya) between atoms of magnetic crystals from DFT Hamiltonian based on Wannier functions or Linear combination of atomic orbitals. It uses the Green's function method and take the local rigid spin rotation as a perturbation. The package can take the output from Wannier90, which is interfaced with many density functional theory codes or from codes based on localised orbitals. A minimal user input is needed, which allows for an easily integration into a high-throughput workflows. """