TB2J 0.9.4rc0__tar.gz → 0.9.6rc0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: TB2J
-Version: 0.9.4rc0
+Version: 0.9.6rc0
 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.7
 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.4rc0 → tb2j-0.9.6rc0}/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):
@@ -86,40 +93,117 @@ class MAE:
         return es
 
 
+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)
+        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)
+        self.G = TBGreen(model, kmesh, efermi=efermi, gamma=gamma, **kwargs)
+        self.emin = -18
+        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_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()
-    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