TB2J 0.9.3rc0__tar.gz → 0.9.9rc2__tar.gz

{tb2j-0.9.3rc0 → tb2j-0.9.9rc2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: TB2J
-Version: 0.9.3rc0
+Version: 0.9.9rc2
 Summary: TB2J: First principle to Heisenberg exchange J using tight-binding Green function method
 Author: Xu He
 Author-email: mailhexu@gmail.com
@@ -14,14 +14,15 @@ Classifier: Topic :: Scientific/Engineering :: Physics
 Classifier: License :: OSI Approved :: BSD License
 Requires-Python: >=3.6
 License-File: LICENSE
-Requires-Dist: numpy>1.16.5
+Requires-Dist: numpy<2.0
 Requires-Dist: scipy
 Requires-Dist: matplotlib
 Requires-Dist: ase>=3.19
 Requires-Dist: tqdm
 Requires-Dist: pathos
 Requires-Dist: packaging>=20.0
+Requires-Dist: HamiltonIO>=0.1.8
 Requires-Dist: pre-commit
-Requires-Dist: HamiltonIO>=0.1.4
+Requires-Dist: sympair>0.1.0
 
 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. 

{tb2j-0.9.3rc0 → tb2j-0.9.9rc2}/TB2J/MAE.py

@@ -1,19 +1,26 @@
+from pathlib import Path
+
+import matplotlib.pyplot as plt
 import numpy as np
-from TB2J.abacus.abacus_wrapper import AbacusWrapper, AbacusParser
-from TB2J.mathutils.rotate_spin import rotate_Matrix_from_z_to_axis
+import tqdm
+
+# from TB2J.abacus.abacus_wrapper import AbacusSplitSOCParser
+from HamiltonIO.abacus.abacus_wrapper import AbacusSplitSOCParser
+from HamiltonIO.model.occupations import Occupations
+from HamiltonIO.siesta import SislParser
+from scipy.linalg import eigh
+
+from TB2J.contour import Contour
+from TB2J.green import TBGreen
+
+# from HamiltonIO.model.rotate_spin import rotate_Matrix_from_z_to_axis, rotate_Matrix_from_z_to_sperical
 from TB2J.kpoints import monkhorst_pack
-from TB2J.mathutils.fermi import fermi
 from TB2J.mathutils.kR_convert import R_to_k
-from scipy.linalg import eigh
-from copy import deepcopy
-from scipy.spatial.transform import Rotation
-import matplotlib.pyplot as plt
-from pathlib import Path
-from TB2J.mathutils.rotate_spin import spherical_to_cartesian
-from HamiltonIO.model.occupations import Occupations
-from TB2J.abacus.abacus_wrapper import AbacusSplitSOCParser
-from HamiltonIO.siesta import SislWrapper
-import tqdm
+
+# from TB2J.abacus.abacus_wrapper import AbacusWrapper, AbacusParser
+from TB2J.mathutils.rotate_spin import (
+    rotate_spinor_matrix,
+)
 
 
 def get_occupation(evals, kweights, nel, width=0.1):
@@ -28,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):
@@ -75,7 +95,10 @@ class MAE:
         # e,rho = self.model.get_band_energy(dm=True)
         # self.calc_ref()
         # thetas = np.linspace(*angle_range, npoints)
-        for i, (theta, phi) in tqdm.tqdm(enumerate(zip(thetas, phis))):
+        nangles = len(thetas)
+        for i in tqdm.trange(nangles):
+            theta = thetas[i]
+            phi = phis[i]
             self.model.set_Hsoc_rotation_angle([theta, phi])
             e = self.get_band_energy()
             es.append(e)
@@ -83,41 +106,138 @@ class MAE:
         return es
 
 
+class MAEGreen(MAE):
+    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(
+            nel=self.model.nel, width=self.width, wk=self.kweights, nspin=2
+        )
+        # occ.occupy(evals)
+        efermi = occ.efermi(evals)
+        print(f"{efermi=}")
+        self.G = TBGreen(model, kmesh, efermi=efermi, gamma=gamma, **kwargs)
+        self.emin = -12
+        self.emax = 0
+        self.nz = 50
+        self._prepare_elist()
+
+    def _prepare_elist(self, method="legendre"):
+        """
+        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.build_path_semicircle(npoints=self.nz, endpoint=True)
+        elif method.lower() == "legendre":
+            self.contour.build_path_legendre(npoints=self.nz, endpoint=True)
+        else:
+            raise ValueError(f"The path cannot be of type {method}.")
+
+    def get_efermi(self):
+        evals, evecs = self.model.solve_all(self.kpts)
+        occ = Occupations(
+            nel=self.model.nel, width=self.model.width, wk=self.kweights, nspin=2
+        )
+        occ.get_efermi(evals, self.kweights)
+
+    def get_perturbed(self, e, thetas, phis):
+        G0K = self.G.get_Gk_all(e)
+        Hsoc_k = self.model.get_Hk_soc(self.kpts)
+        dE_ang = []
+        for theta, phi in zip(thetas, phis):
+            dE = 0.0
+            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 @ GdH) * self.kweights[i]
+            dE_ang.append(dE)
+        return np.array(dE_ang)
+
+    def get_band_energy_vs_angles(self, thetas, phis):
+        es = np.zeros(len(thetas))
+        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
+
+
 def get_model_energy(model, kmesh, gamma=True):
     ham = MAE(model, kmesh, gamma=gamma)
     return ham.get_band_energy()
 
 
 def abacus_get_MAE(
-    path_nosoc, path_soc, kmesh, thetas, psis, gamma=True, outfile="MAE.txt", nel=None
+    path_nosoc,
+    path_soc,
+    kmesh,
+    thetas,
+    phis,
+    gamma=True,
+    outfile="MAE.txt",
+    nel=None,
+    width=0.1,
 ):
     """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."""
     parser = AbacusSplitSOCParser(
         outpath_nosoc=path_nosoc, outpath_soc=path_soc, binary=False
     )
     model = parser.parse()
-    model.nel = 16
-    ham = MAE(model, kmesh, gamma=gamma)
-    es = ham.get_band_energy_vs_angles(thetas, psis)
+    if nel is not None:
+        model.nel = nel
+    ham = MAEGreen(model, kmesh, gamma=gamma, width=width)
+    es = ham.get_band_energy_vs_angles(thetas, phis)
     if outfile:
         with open(outfile, "w") as f:
-            f.write("#theta, psi, energy\n")
-            for theta, psi, e in zip(thetas, psis, es):
-                f.write(f"{theta}, {psi}, {e}\n")
+            f.write("#theta, phi, energy\n")
+            for theta, phi, e in zip(thetas, phis, es):
+                f.write(f"{theta:5.3f}, {phi:5.3f}, {e:10.9f}\n")
     return es
 
 
-def siesta_get_MAE(fdf_fname, kmesh, thetas, phis, gamma=True, outfile="MAE.txt"):
+def siesta_get_MAE(
+    fdf_fname, kmesh, thetas, phis, gamma=True, outfile="MAE.txt", nel=None, width=0.1
+):
     """ """
-    parser = SiestaParser(fdf_fname=fdf_fname, read_H_soc=True)
-    model = parser.parse()
-    ham = MAE(model, kmesh, gamma=gamma)
+    model = SislParser(fdf_fname=fdf_fname, read_H_soc=True).get_model()
+    if nel is not None:
+        model.nel = nel
+    ham = MAEGreen(model, kmesh, gamma=gamma, width=width)
+    # es = ham.get_band_energy_vs_angles(thetas, phis)
     es = ham.get_band_energy_vs_angles(thetas, phis)
     if outfile:
         with open(outfile, "w") as f:
             f.write("#theta, psi, energy\n")
             for theta, psi, e in zip(thetas, phis, es):
-                f.write(f"{theta}, {psi}, {e}\n")
+                # f.write(f"{theta}, {psi}, {e}\n")
+                f.write(f"{theta:5.3f}, {psi:5.3f}, {e:10.9f}\n")
     return es
 
 

tb2j-0.9.9rc2/TB2J/MAEGreen.py

@@ -0,0 +1,197 @@
+from pathlib import Path
+
+import numpy as np
+import tqdm
+from typing_extensions import DefaultDict
+
+from HamiltonIO.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=[], **kwargs):
+        super().__init__(**kwargs)
+        self.natoms = len(self.atoms)
+        nangles = len(angles[0])
+        self.es = np.zeros(nangles, dtype=complex)
+        self.es_atom = np.zeros((nangles, self.natoms), dtype=complex)
+        self.es_atom_orb = DefaultDict(lambda: 0)
+        if angles is None or angles == "axis":
+            self.set_angles_axis()
+        elif angles == "scan":
+            self.set_angles_scan()
+        else:
+            self.thetas = angles[0]
+            self.phis = angles[1]
+
+    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_atom = np.zeros((na, self.natoms), dtype=complex)
+        # dE_angle_orbitals = np.zeros((na, self.natoms, self.norb, self.norb), dtype=complex)
+        # dE_angle_orbitals = DefaultDict(lambda: 0)
+        dE_angle_atom_orb = DefaultDict(lambda: 0)
+        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)
+                #dG2 = np.einsum("ij,ji->ij", GdH,   GdH)
+                dG2 = GdH * GdH.T
+                dG2sum = np.sum(dG2)
+
+                # dG2diag = np.diag(GdH @G0K[i].T.conj() @ dHi)
+                #dE_angle[iangle] += np.trace(GdH@GdH) * self.G.kweights[ik]
+                #dE_angle[iangle] += np.trace(GdH@G0K[ik].T.conj()@dHi ) * self.G.kweights[ik]
+                dE_angle[iangle] += dG2sum * self.G.kweights[ik]
+                for iatom in range(self.natoms):
+                    iorb = self.iorb(iatom)
+                    #dG2= dG2[::2, ::2] + dG2[1::2, 1::2] + dG2[1::2, ::2] + dG2[::2, 1::2]
+                    dE_atom_orb = dG2[np.ix_(iorb, iorb)] * self.G.kweights[ik]
+                    dE_atom_orb = dE_atom_orb[::2, ::2] + dE_atom_orb[1::2, 1::2] + dE_atom_orb[1::2, ::2] + dE_atom_orb[::2, 1::2]
+                    mmat = self.mmats[iatom]
+                    dE_atom_orb =  mmat.T @ dE_atom_orb @ mmat
+
+                    dE_angle_atom_orb[(iangle, iatom)] += dE_atom_orb
+
+                    dE_atom = np.sum(dE_atom_orb)
+                    dE_angle_atom[iangle, iatom] += dE_atom
+        return dE_angle, dE_angle_atom, dE_angle_atom_orb
+
+    def get_perturbed_R(self, e, thetas, phis):
+        self.tbmodel.set_so_strength(0.0)
+        # Here only the first R vector is considered.
+        # TODO: consider all R vectors.
+        # Rlist = np.zeros((1, 3), dtype=float)
+        # G0K = self.G.get_Gk_all(e)
+        # G0R = k_to_R(self.G.kpts, Rlist, G0K, self.G.kweights)
+        # dE_angle = np.zeros(len(thetas), dtype=complex)
+        # dE_angle_atoms = np.zeros((len(thetas), self.natoms), dtype=complex)
+        pass
+
+    def get_band_energy_vs_angles(self, 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 key, value in dE_angle_atom_orb.items():
+                self.es_atom_orb[key] += dE_angle_atom_orb[key] * self.contour.weights[ie]
+
+        self.es = -np.imag(self.es) / np.pi
+        self.es_atom = -np.imag(self.es_atom) / np.pi
+        for key, value in self.es_atom_orb.items():
+            self.es_atom_orb[key] = -np.imag(value) / np.pi
+
+    def output(self, output_path="TB2J_anisotropy"):
+        Path(output_path).mkdir(exist_ok=True)
+        fname = f"{output_path}/MAE.dat"
+        fname_orb = f"{output_path}/MAE_orb.dat"
+        with open(fname, "w") as f:
+            f.write("# theta, phi, MAE(total), MAE(atom-wise) Unit: meV\n")
+            for i, (theta, phi, e, es) in enumerate(
+                zip(self.thetas, self.phis, self.es, self.es_atom)
+            ):
+                f.write(f"{theta:.5f} {phi:.5f} {e*1e3:.8f} ")
+                for ea in es:
+                    f.write(f"{ea*1e3:.8f} ")
+                f.write("\n")
+
+        with open(fname_orb, "w") as f:
+            f.write("=" * 80 + "\n")
+            f.write("Orbitals for each atom: \n")
+            f.write("=" * 80 + "\n")
+            f.write("Note: the energies are in meV\n")
+            for iatom in range(self.natoms):
+                f.write(f"Atom {iatom:03d}: ")
+                for orb in self.orbital_names[iatom]:
+                    f.write(f"{orb} ")
+                f.write("\n")
+            for i, (theta, phi, e, eatom) in enumerate(
+                zip(self.thetas, self.phis, self.es, self.es_atom)
+            ):
+                f.write("-" * 60 + "\n")
+                f.write(f"Angle {i:03d}:   theta={theta:.5f} phi={phi:.5f} \n ")
+                f.write(f"E: {e*1e3:.8f} \n")
+                for iatom, ea in enumerate(eatom):
+                    f.write(f"Atom {iatom:03d}: {ea*1e3:.8f} \n")
+                    f.write("Orbital: ")
+                    eorb = self.es_atom_orb[(i, iatom)] 
+
+                    # write numpy matrix to file
+                    f.write(
+                        np.array2string(
+                            eorb*1e3, precision=4, separator=",", suppress_small=True
+                        )
+                    )
+
+                    eorb_diff = eorb -  self.es_atom_orb[(0, iatom)]
+                    f.write("Diference to the first angle: ")
+                    f.write(
+                        np.array2string(
+                            eorb_diff*1e3, precision=4, separator=",", suppress_small=True
+                        )
+                    )
+                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)
+
+
+def abacus_get_MAE(
+    path_nosoc,
+    path_soc,
+    kmesh,
+    thetas,
+    phis,
+    gamma=True,
+    output_path="TB2J_anisotropy",
+    magnetic_elements=None,
+    nel=None,
+    width=0.1,
+    **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."""
+    parser = AbacusSplitSOCParser(
+        outpath_nosoc=path_nosoc, outpath_soc=path_soc, binary=False
+    )
+    model = parser.parse()
+    if nel is not None:
+        model.nel = nel
+    mae = MAEGreen(tbmodels=model, atoms = model.atoms, kmesh=kmesh, efermi=None,  basis=model.basis, angles=[thetas, phis], magnetic_elements=magnetic_elements, **kwargs)
+    mae.run(output_path=output_path)
+    #es = mae.get_band_energy_vs_angles(thetas, phis)
+    #if outfile:
+    #    with open(outfile, "w") as f:
+    #        f.write("#theta, phi, energy\n")
+    #        for theta, phi, e in zip(thetas, phis, es):
+    #            f.write(f"{theta:5.3f}, {phi:5.3f}, {e:10.9f}\n")
+    #return es
+
+