TB2J 0.9.5rc0__py3-none-any.whl → 0.9.6rc0__py3-none-any.whl

TB2J/MAE.py

@@ -1,20 +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.abacus.abacus_wrapper import AbacusSplitSOCParser
-from HamiltonIO.siesta import SislParser, SiestaHamiltonian
-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):
@@ -87,39 +93,116 @@ 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:5.3f}, {psi:5.3f}, {e:10.9f}\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
+):
     """ """
-    model= SislParser(fdf_fname=fdf_fname, read_H_soc=True).get_model()
-    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