TB2J 0.9.0.1__tar.gz → 0.9.1rc0__tar.gz

{TB2J-0.9.0.1 → tb2j-0.9.1rc0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: TB2J
-Version: 0.9.0.1
+Version: 0.9.1rc0
 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.1rc0/TB2J/abacus/MAE.py

@@ -0,0 +1,320 @@
+import numpy as np
+from TB2J.abacus.abacus_wrapper import AbacusWrapper, AbacusParser
+from TB2J.mathutils.rotate_spin import rotate_Matrix_from_z_to_axis
+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.abacus.occupations import Occupations
+
+# TODO List:
+# - [x] Add the class AbacusSplitSOCWrapper
+# - [x] Add the function to rotate the XC part
+# - [x] Compute the band energy at arbitrary angle
+
+
+def get_occupation(evals, kweights, nel, width=0.1):
+    occ = Occupations(nel=nel, width=width, wk=kweights, nspin=2)
+    return occ.occupy(evals)
+
+
+def get_density_matrix(evals=None, evecs=None, kweights=None, nel=None, width=0.1):
+    occ = get_occupation(evals, kweights, nel, width=width)
+    rho = np.einsum("kib, kb, kjb -> kij", evecs, occ, evecs.conj())
+    return rho
+
+
+def spherical_to_cartesian(theta, phi, normalize=True):
+    """
+    Convert spherical coordinates to cartesian
+    """
+    x = np.sin(theta) * np.cos(phi)
+    y = np.sin(theta) * np.sin(phi)
+    z = np.cos(theta)
+    vec = np.array([x, y, z])
+    if normalize:
+        vec = vec / np.linalg.norm(vec)
+    return vec
+
+
+class AbacusSplitSOCWrapper(AbacusWrapper):
+    """
+    Abacus wrapper with Hamiltonian split to SOC and non-SOC parts
+    """
+
+    def __init__(self, *args, **kwargs):
+        HR_soc = kwargs.pop("HR_soc", None)
+        # nbasis = HR_soc.shape[1]
+        # kwargs["nbasis"] = nbasis
+        super().__init__(*args, **kwargs)
+        self._HR_copy = deepcopy(self._HR)
+        self.HR_soc = HR_soc
+        self.soc_lambda = 1.0
+        self.nel = 16
+        self.width = 0.1
+
+    @property
+    def HR(self):
+        return self._HR + self.HR_soc * self.soc_lambda
+
+    def rotate_HR_xc(self, axis):
+        """
+        Rotate SOC part of Hamiltonian
+        """
+        for iR, R in enumerate(self.Rlist):
+            self._HR[iR] = rotate_Matrix_from_z_to_axis(self._HR_copy[iR], axis)
+
+    def rotate_Hk_xc(self, axis):
+        """
+        Rotate SOC part of Hamiltonian
+        """
+        for ik in range(len(self._Hk)):
+            self._Hk[ik] = rotate_Matrix_from_z_to_axis(self._Hk_copy[ik], axis)
+
+    def get_density_matrix(self, kpts, kweights=None):
+        rho = np.zeros((len(kpts), self.nbasis, self.nbasis), dtype=complex)
+        evals, evecs = self.solve_all(kpts)
+        occ = get_occupation(evals, kweights, self.nel, width=self.width)
+        rho = np.einsum(
+            "kib, kb, kjb -> kij", evecs, occ, evecs.conj()
+        )  # should multiply S to the the real DM.
+        return rho
+
+    def rotate_DM(self, rho, axis):
+        """
+        Rotate the density matrix
+        """
+        for ik in range(len(rho)):
+            rho[ik] = rotate_Matrix_from_z_to_axis(rho[ik], axis)
+        return rho
+
+
+class RotateHam:
+    def __init__(self, model, kmesh, gamma=True):
+        self.model = model
+        self.kpts = monkhorst_pack(kmesh, gamma_center=gamma)
+        self.kweights = np.ones(len(self.kpts), dtype=float) / len(self.kpts)
+
+    def get_band_energy2(self):
+        for ik, kpt in enumerate(self.kpts):
+            Hk, Sk = self.model.gen_ham(kpt)
+            evals, evecs = eigh(Hk, Sk)
+            rho = np.einsum(
+                "ib, b, jb -> ij",
+                evecs,
+                fermi(evals, self.model.efermi, width=0.05),
+                evecs.conj(),
+            )
+            eband1 = np.sum(evals * fermi(evals, self.model.efermi, width=0.05))
+            eband2 = np.trace(Hk @ rho)
+            print(eband1, eband2)
+
+    def get_band_energy(self, dm=False):
+        evals, evecs = self.model.solve_all(self.kpts)
+        occ = get_occupation(
+            evals, self.kweights, self.model.nel, width=self.model.width
+        )
+        eband = np.sum(evals * occ * self.kweights[:, np.newaxis])
+        # * fermi(evals, self.model.efermi, width=0.05)
+        if dm:
+            density_matrix = self.model.get_density_matrix(evecs)
+            return eband, density_matrix
+        else:
+            return eband
+
+    def calc_ref(self):
+        # calculate the Hk_ref, Sk_ref, Hk_soc_ref, and rho_ref
+        self.Sk_ref = R_to_k(self.kpts, self.model.Rlist, self.model.SR)
+        self.Hk_xc_ref = R_to_k(self.kpts, self.model.Rlist, self.model._HR_copy)
+        self.Hk_soc_ref = R_to_k(self.kpts, self.model.Rlist, self.model.HR_soc)
+        self.rho_ref = np.zeros(
+            (len(self.kpts), self.model.nbasis, self.model.nbasis), dtype=complex
+        )
+
+        evals = np.zeros((len(self.kpts), self.model.nbasis), dtype=float)
+        evecs = np.zeros(
+            (len(self.kpts), self.model.nbasis, self.model.nbasis), dtype=complex
+        )
+
+        for ik, kpt in enumerate(self.kpts):
+            # evals, evecs = eigh(self.Hk_xc_ref[ik]+self.Hk_soc_ref[ik], self.Sk_ref[ik])
+            evals[ik], evecs[ik] = eigh(self.Hk_xc_ref[ik], self.Sk_ref[ik])
+        occ = get_occupation(
+            evals, self.kweights, self.model.nel, width=self.model.width
+        )
+        # occ = fermi(evals, self.model.efermi, width=self.model.width)
+        self.rho_ref = np.einsum("kib, kb, kjb -> kij", evecs, occ, evecs.conj())
+
+    def get_band_energy_from_rho(self, axis):
+        """
+        This is wrong!! Should use second order perturbation theory to get the band energy instead.
+        """
+        eband = 0.0
+        for ik, k in enumerate(self.kpts):
+            rho = rotate_Matrix_from_z_to_axis(self.rho_ref[ik], axis)
+            Hk_xc = rotate_Matrix_from_z_to_axis(self.Hk_xc_ref[ik], axis)
+            Hk_soc = self.Hk_soc_ref[ik]
+            Htot = Hk_xc + Hk_soc * self.model.soc_lambda
+            # Sk = self.Sk_ref[ik]
+            # evals, evecs = eigh(Htot, Sk)
+            # rho2= np.einsum("ib, b, jb -> ij", evecs, fermi(evals, self.model.efermi, width=0.05), evecs.conj())
+            if ik == 0 and False:
+                pass
+                # print(f"{evecs[:4,0:4].real=}")
+                # print(f"{evals[:4]=}")
+                # print(f"{Hk_xc[:4,0:4].real=}")
+                # print(f"{Htot[:4,0:4].real=}")
+                # print(f"{Sk[:4,0:4].real=}")
+                # print(f"{rho[:4,0:4].real=}")
+                # print(f"{rho2[:4,0:4].real=}")
+            # eband1 = np.sum(evals * fermi(evals, self.model.efermi, width=0.05))
+            # eband2 = np.trace(Htot @ rho2).real
+            # eband3 = np.trace(Htot @ rho).real
+            # print(eband1, eband2, eband3)
+            e_soc = np.trace(Hk_soc @ rho) * self.kweights[ik] * self.model.soc_lambda
+            eband += e_soc
+        return eband
+
+    def get_band_energy_vs_angles(
+        self,
+        thetas,
+        psis,
+    ):
+        es = []
+        # es2 = []
+        # e,rho = self.model.get_band_energy(dm=True)
+        # self.calc_ref()
+        # thetas = np.linspace(*angle_range, npoints)
+        for i, theta, phi in enumerate(zip(thetas, psis)):
+            axis = spherical_to_cartesian(theta, phi)
+            self.model.rotate_HR_xc(axis)
+            # self.get_band_energy2()
+            e = self.get_band_energy()
+            es.append(e)
+            # es2.append(e2)
+        return es
+
+
+def get_model_energy(model, kmesh, gamma=True):
+    ham = RotateHam(model, kmesh, gamma=gamma)
+    return ham.get_band_energy()
+
+
+class AbacusSplitSOCParser:
+    """
+    Abacus parser with Hamiltonian split to SOC and non-SOC parts
+    """
+
+    def __init__(self, outpath_nosoc=None, outpath_soc=None, binary=False):
+        self.outpath_nosoc = outpath_nosoc
+        self.outpath_soc = outpath_soc
+        self.binary = binary
+        self.parser_nosoc = AbacusParser(outpath=outpath_nosoc, binary=binary)
+        self.parser_soc = AbacusParser(outpath=outpath_soc, binary=binary)
+        spin1 = self.parser_nosoc.read_spin()
+        spin2 = self.parser_soc.read_spin()
+        if spin1 != "noncollinear" or spin2 != "noncollinear":
+            raise ValueError("Spin should be noncollinear")
+
+    def parse(self):
+        nbasis, Rlist, HR, SR = self.parser_nosoc.Read_HSR_noncollinear()
+        nbasis2, Rlist2, HR2, SR2 = self.parser_soc.Read_HSR_noncollinear()
+        # print(HR[0])
+        HR_soc = HR2 - HR
+        model = AbacusSplitSOCWrapper(HR, SR, Rlist, nbasis, nspin=2, HR_soc=HR_soc)
+        model.efermi = self.parser_soc.efermi
+        model.basis = self.parser_nosoc.basis
+        model.atoms = self.parser_nosoc.atoms
+        return model
+
+
+def abacus_get_MAE(
+    path_nosoc, path_soc, kmesh, thetas, psis, gamma=True, outfile="MAE.txt"
+):
+    """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 = RotateHam(model, kmesh, gamma=gamma)
+    es = []
+    for theta, psi in zip(thetas, psis):
+        axis = spherical_to_cartesian(theta, psi)
+        model.rotate_HR_xc(axis)
+        e = ham.get_band_energy()
+        es.append(ham.get_band_energy())
+    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")
+    return es
+
+
+def test_AbacusSplitSOCWrapper():
+    # path = Path("~/projects/2D_Fe").expanduser()
+    path = Path("~/projects/TB2Jflows/examples/2D_Fe/Fe_z").expanduser()
+    outpath_nosoc = f"{path}/soc0/OUT.ABACUS"
+    outpath_soc = f"{path}/soc1/OUT.ABACUS"
+    parser = AbacusSplitSOCParser(
+        outpath_nosoc=outpath_nosoc, outpath_soc=outpath_soc, binary=False
+    )
+    model = parser.parse()
+    kmesh = [6, 6, 1]
+
+    r = RotateHam(model, kmesh)
+    # thetas, es = r.get_band_energy_vs_theta(angle_range=(0, np.pi*2), rotation_axis="z", initial_direction=(1,0,0),  npoints=21)
+    thetas, es, es2 = r.get_band_energy_vs_theta(
+        angle_range=(0, np.pi * 2),
+        rotation_axis="y",
+        initial_direction=(0, 0, 1),
+        npoints=11,
+    )
+    # print the table of thetas and es, es2
+    print("theta, e, e2")
+    for theta, e, e2 in zip(thetas, es, es2):
+        print(f"{theta=}, {e=}, {e2=}")
+
+    plt.plot(thetas / np.pi, es - es[0], marker="o")
+    plt.plot(thetas / np.pi, es2 - es2[0], marker=".")
+    plt.savefig("E_along_z_x_z.png")
+    plt.show()
+
+
+def abacus_get_MAE_cli():
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        description="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.add_argument("path_nosoc", type=str, help="Path to the  calculation with ")
+    parser.add_argument("path_soc", type=str, help="Path to the SOC calculation")
+    parser.add_argument("thetas", type=float, nargs="+", help="Thetas")
+    parser.add_argument("psis", type=float, nargs="+", help="Phis")
+    parser.add_argument("kmesh", type=int, nargs=3, help="K-mesh")
+    parser.add_argument(
+        "--gamma", action="store_true", help="Use Gamma centered kpoints"
+    )
+    parser.add_argument(
+        "--outfile",
+        type=str,
+        help="The angles and the energey will be saved in this file.",
+    )
+    args = parser.parse_args()
+    abacus_get_MAE(
+        args.path_nosoc,
+        args.path_soc,
+        args.kmesh,
+        args.thetas,
+        args.psis,
+        gamma=args.gamma,
+        outfile=args.outfile,
+    )
+
+
+if __name__ == "__main__":
+    abacus_get_MAE_cli()

{TB2J-0.9.0.1 → tb2j-0.9.1rc0}/TB2J/abacus/abacus_wrapper.py

@@ -16,10 +16,10 @@ from TB2J.abacus.stru_api import read_abacus, read_abacus_out
 
 class AbacusWrapper(AbstractTB):
     def __init__(self, HR, SR, Rlist, nbasis, nspin=1):
-        self.R2kfactor = -2j * np.pi
+        self.R2kfactor = 2j * np.pi
         self.is_orthogonal = False
         self._name = "ABACUS"
-        self.HR = HR
+        self._HR = HR
         self.SR = SR
         self.Rlist = Rlist
         self.nbasis = nbasis
@@ -27,6 +27,14 @@ class AbacusWrapper(AbstractTB):
         self.norb = nbasis * nspin
         self._build_Rdict()
 
+    @property
+    def HR(self):
+        return self._HR
+
+    @HR.setter
+    def set_HR(self, HR):
+        self._HR = HR
+
     def _build_Rdict(self):
         if hasattr(self, "Rdict"):
             pass
@@ -62,6 +70,8 @@ class AbacusWrapper(AbstractTB):
                 S = self.SR[iR] * phase
                 # Sk += S + S.conjugate().T
                 Sk += S
+                # Hk = (Hk + Hk.conj().T)/2
+                # Sk = (Sk + Sk.conj().T)/2
         elif convention == 1:
             # TODO: implement the first convention (the r convention)
             raise NotImplementedError("convention 1 is not implemented yet.")
@@ -74,6 +84,14 @@ class AbacusWrapper(AbstractTB):
         Hk, Sk = self.gen_ham(k, convention=convention)
         return eigh(Hk, Sk)
 
+    def solve_all(self, kpts, convention=2):
+        nk = len(kpts)
+        evals = np.zeros((nk, self.nbasis), dtype=float)
+        evecs = np.zeros((nk, self.nbasis, self.nbasis), dtype=complex)
+        for ik, k in enumerate(kpts):
+            evals[ik], evecs[ik] = self.solve(k, convention=convention)
+        return evals, evecs
+
     def HSE_k(self, kpt, convention=2):
         H, S = self.gen_ham(tuple(kpt), convention=convention)
         evals, evecs = eigh(H, S)

tb2j-0.9.1rc0/TB2J/abacus/occupations.py

@@ -0,0 +1,278 @@
+"""
+This file is stolen from the hotbit programm, with some modification.
+"""
+
+import numpy as np
+from scipy.optimize import brentq
+import sys
+
+from ase.dft.dos import DOS
+from scipy import integrate
+
+# import numba
+
+# from numba import float64, int32
+
+MAX_EXP_ARGUMENT = np.log(sys.float_info.max)
+
+# @numba.vectorize(nopython=True)
+# def myfermi(e, mu, width, nspin):
+#    x = (e - mu) / width
+#    if x < -10:
+#        ret = 2.0 / nspin
+#    elif x > 10:
+#        ret = 0.0
+#    else:
+#        ret = 2.0 / nspin / (math.exp(x) + 1)
+#    return ret
+
+
+def myfermi(e, mu, width, nspin):
+    x = (e - mu) / width
+    return np.where(x < 10, 2.0 / (nspin * (np.exp(x) + 1.0)), 0.0)
+
+
+class Occupations(object):
+    def __init__(self, nel, width, wk, nspin=1):
+        """
+        Initialize parameters for occupations.
+        :param nel: Number of electrons
+        :param width: Fermi-broadening
+        :param wk: k-point weights. eg. If only gamma, [1.0]
+        :param nspin(optional): number of spin, if spin=1 multiplicity=2 else, multiplicity=1.
+        """
+        self.nel = nel
+        self.width = width
+        self.wk = wk
+        self.nk = len(wk)
+        self.nspin = nspin
+
+    def get_mu(self):
+        """Return the Fermi-level (or chemical potential)."""
+        return self.mu
+
+    def fermi(self, mu):
+        """
+        Occupy states with given chemical potential.
+        Occupations are 0...2; without k-point weights
+        """
+        return myfermi(self.e, mu, self.width, self.nspin)
+
+    def root_function(self, mu):
+        """This function is exactly zero when mu is right."""
+        f = self.fermi(mu)
+        return np.einsum("i, ij->", self.wk, f) - self.nel
+
+    def occupy(self, e, xtol=1e-11):
+        """
+        Calculate occupation numbers with given Fermi-broadening.
+
+        @param e: e[ind_k,ind_orb] energy of k-point, state a
+            Note added by hexu:  With spin=2,e[k,a,sigma], it also work. only the *2 should be removed.
+        @param wk: wk[:] weights for k-points
+        @param width: The Fermi-broadening
+
+        Returns: fermi[ind_k, ind_orb]
+        """
+        self.e = e
+        eflat = e.flatten()
+        ind = np.argsort(eflat)
+        e_sorted = eflat[ind]
+        if self.nspin == 1:
+            m = 2
+        elif self.nspin == 2:
+            m = 1
+        n_sorted = (self.wk[:, None, None] * np.ones_like(e) * m).flatten()[ind]
+
+        sum = n_sorted.cumsum()
+        if self.nel < sum[0]:
+            ifermi = 0
+        elif self.nel > sum[-1]:
+            raise ("number of electrons larger than number of orbital*spin")
+        else:
+            ifermi = np.searchsorted(sum, self.nel)
+        try:
+            if ifermi == 0:
+                elo = e_sorted[0]
+            else:
+                elo = e_sorted[ifermi - 1]
+            if ifermi == len(e_sorted) - 1:
+                ehi = e_sorted[-1]
+            else:
+                ehi = e_sorted[ifermi + 1]
+            guess = e_sorted[ifermi]
+            dmu = np.max((self.width, guess - elo, ehi - guess))
+            mu = brentq(self.root_function, guess - dmu, guess + dmu, xtol=xtol)
+            # mu = brent(
+            #    self.root_function,
+            #    brack=(guess - elo, guess, guess + dmu),
+            #    tol=xtol)
+        except Exception as E:
+            # probably a bad guess
+            print("Error in finding Fermi level: ", E)
+            dmu = self.width
+            if self.nel < 1e-3:
+                mu = min(e_sorted) - dmu * 20
+            elif self.nel - sum[-1] > -1e-3:
+                mu = max(e_sorted) + dmu * 20
+            else:
+                # mu = brent(
+                #         self.root_function,
+                #         brack=(e_sorted[0] - dmu * 10,
+                #                guess,
+                #                e_sorted[-1] + dmu * 10),
+                #         tol=xtol)
+                mu = brentq(
+                    self.root_function,
+                    e_sorted[0] - dmu * 20,
+                    e_sorted[-1] + dmu * 20,
+                    xtol=xtol,
+                )
+
+        if np.abs(self.root_function(mu)) > xtol * 1e4:
+            # raise RuntimeError(
+            #    'Fermi level could not be assigned reliably. Has the system fragmented?'
+            # )
+            print(
+                "Fermi level could not be assigned reliably. Has the system fragmented?"
+            )
+
+        f = self.fermi(mu)
+        # rho=(self.eigenvecs*f).dot(self.eigenvecs.transpose())
+
+        self.mu, self.f = mu, f
+        return f
+
+    def plot(self):
+        import pylab as pl
+
+        for ik in range(self.nk):
+            pl.plot(self.e[ik, :], self.f[ik, :])
+            pl.scatter(self.e[ik, :], self.f[ik, :])
+        pl.title("occupations")
+        pl.xlabel("energy (Ha)")
+        pl.ylabel("occupation")
+        pl.show()
+
+
+class GaussOccupations(Occupations):
+    def get_mu(self):
+        return self.mu
+
+    def delta(self, energy):
+        """Return a delta-function centered at 'energy'."""
+        x = -(((self.e - energy) / self.width) ** 2)
+        return np.exp(x) / (np.sqrt(np.pi) * self.width)
+
+    def get_dos(self, npts=500):
+        eflat = self.e.flatten()
+        ind = np.argsort(eflat)
+        ##e_sorted = eflat[ind]
+        if self.nspin == 1:
+            m = 2
+        elif self.nspin == 2:
+            m = 1
+        # n_sorted = (self.wk * np.ones_like(self.e) * m).flatten()[ind]
+        dos = np.zeros(npts)
+        for w, e_n in zip(self.w_k, self.e_skn[0]):
+            for e in e_n:
+                dos += w * self.delta(e)
+
+    def root_function(self, mu):
+        pass
+
+    # @profile
+    def occupy(self, e, xtol=1e-8, guess=0.0):
+        self.e = e
+        dos = myDOS(kweights=self.wk, eigenvalues=e, width=self.width, npts=501)
+        edos = dos.get_energies()
+        d = dos.get_dos()
+        idos = integrate.cumtrapz(d, edos, initial=0) - self.nel
+        # f_idos = interpolate.interp1d(edos, idos)
+        # ret = optimize.fmin(f_idos, x0=edos[400], xtol=xtol, disp=True)
+        ifermi = np.searchsorted(idos, 0.0)
+        # self.mu = ret[0]
+        self.mu = edos[ifermi]
+        self.f = self.fermi(self.mu)
+        return self.f
+
+
+class myDOS(DOS):
+    def __init__(
+        self, kweights, eigenvalues, nspin=1, width=0.1, window=None, npts=1001
+    ):
+        """Electronic Density Of States object.
+
+        calc: calculator object
+            Any ASE compliant calculator object.
+        width: float
+            Width of guassian smearing.  Use width=0.0 for linear tetrahedron
+            interpolation.
+        window: tuple of two float
+            Use ``window=(emin, emax)``.  If not specified, a window
+            big enough to hold all the eigenvalues will be used.
+        npts: int
+            Number of points.
+
+        """
+        self.npts = npts
+        self.width = width
+        # self.w_k = calc.get_k_point_weights()
+        self.w_k = kweights
+        self.nspins = nspin
+        # self.e_skn = np.array([[calc.get_eigenvalues(kpt=k, spin=s)
+        #                        for k in range(len(self.w_k))]
+        #                       for s in range(self.nspins)])
+        # self.e_skn -= calc.get_fermi_level()
+        self.e_skn = np.array([eigenvalues.T])  # eigenvalues: iband, ikpt
+
+        if window is None:
+            emin = None
+            emax = None
+        else:
+            emin, emax = window
+
+        if emin is None:
+            emin = self.e_skn.min() - 10 * self.width
+        if emax is None:
+            emax = self.e_skn.max() + 10 * self.width
+
+        self.energies = np.linspace(emin, emax, npts)
+
+        # if width == 0.0: # To use tetrahedron method
+        #    bzkpts = calc.get_bz_k_points()
+        #    size, offset = get_monkhorst_pack_size_and_offset(bzkpts)
+        #    bz2ibz = calc.get_bz_to_ibz_map()
+        #    shape = (self.nspins,) + tuple(size) + (-1,)
+        #    self.e_skn = self.e_skn[:, bz2ibz].reshape(shape)
+        #    self.cell = calc.atoms.cell
+
+    def get_idos(self):
+        e, d = self.get_dos()
+        return np.trapz(d, e)
+
+    def delta(self, energy):
+        """Return a delta-function centered at 'energy'."""
+        x = -(((self.energies - energy) / self.width) ** 2)
+        return np.exp(x) / (np.sqrt(np.pi) * self.width)
+
+    def get_dos(self, spin=None):
+        """Get array of DOS values.
+
+        The *spin* argument can be 0 or 1 (spin up or down) - if not
+        specified, the total DOS is returned.
+        """
+
+        if spin is None:
+            if self.nspins == 2:
+                # Spin-polarized calculation, but no spin specified -
+                # return the total DOS:
+                return self.get_dos(spin=0) + self.get_dos(spin=1)
+            else:
+                spin = 0
+
+        dos = np.zeros(self.npts)
+        for w, e_n in zip(self.w_k, self.e_skn[spin]):
+            for e in e_n:
+                dos += w * self.delta(e)
+        return dos

tb2j-0.9.1rc0/TB2J/abacus/test_density_matrix.py

@@ -0,0 +1,38 @@
+from scipy.linalg import eigh
+import numpy as np
+
+
+def gen_random_hermitean_matrix(n):
+    A = np.random.rand(n, n) + 1j * np.random.rand(n, n)
+    return A + A.conj().T
+
+
+def gen_overlap_matrix(n):
+    A = np.random.rand(n, n) + 1j * np.random.rand(n, n)
+    return np.dot(A, A.conj().T)
+
+
+def fermi_function(x, ef, beta):
+    return 1.0 / (np.exp(beta * (x - ef)) + 1)
+
+
+def test():
+    n = 10
+    A = gen_random_hermitean_matrix(n)
+    S = gen_overlap_matrix(n)
+    beta = 0.1
+    ef = 0
+
+    evals, evecs = eigh(A, S)
+
+    etot = np.sum(evals * fermi_function(evals, ef, beta))
+
+    rho = np.einsum("ib,b,jb->ij", evecs, fermi_function(evals, ef, beta), evecs.conj())
+
+    etot2 = np.trace(np.dot(A, rho))
+
+    print(etot, etot2)
+
+
+if __name__ == "__main__":
+    test()

{TB2J-0.9.0.1 → tb2j-0.9.1rc0}/TB2J/green.py

@@ -7,6 +7,8 @@ import tempfile
 from pathos.multiprocessing import ProcessPool
 import sys
 import pickle
+import warnings
+from TB2J.mathutils.fermi import fermi
 
 MAX_EXP_ARGUMENT = np.log(sys.float_info.max)
 
@@ -26,19 +28,6 @@ def eigen_to_G(evals, evecs, efermi, energy):
     )
 
 
-def fermi(e, mu, width=0.01):
-    """
-    the fermi function.
-     .. math::
-        f=\\frac{1}{\exp((e-\mu)/width)+1}
-
-    :param e,mu,width: e,\mu,width
-    """
-
-    x = (e - mu) / width
-    return np.where(x < MAX_EXP_ARGUMENT, 1 / (1.0 + np.exp(x)), 0.0)
-
-
 def find_energy_ingap(evals, rbound, gap=4.0):
     """
     find a energy inside a gap below rbound (right bound),

tb2j-0.9.1rc0/TB2J/mathutils/__init__.py

@@ -0,0 +1 @@
+from .lowdin import Lowdin

tb2j-0.9.1rc0/TB2J/mathutils/fermi.py

@@ -0,0 +1,22 @@
+import numpy as np
+import warnings
+import sys
+
+MAX_EXP_ARGUMENT = np.log(sys.float_info.max)
+
+
+def fermi(e, mu, width=0.01):
+    """
+    the fermi function.
+     .. math::
+        f=\\frac{1}{\exp((e-\mu)/width)+1}
+
+    :param e,mu,width: e,\mu,width
+    """
+    x = (e - mu) / width
+    # disable overflow warning
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore")
+        ret = np.where(x < MAX_EXP_ARGUMENT, 1 / (1.0 + np.exp(x)), 0.0)
+
+    return ret

tb2j-0.9.1rc0/TB2J/mathutils/kR_convert.py

@@ -0,0 +1,90 @@
+import numpy as np
+
+
+def HR_to_k(HR, Rlist, kpts):
+    # Hk[k,:,:] = sum_R (H[R] exp(i2pi k.R))
+    phase = np.exp(2.0j * np.pi * np.tensordot(kpts, Rlist, axes=([1], [1])))
+    Hk = np.einsum("rlm, kr -> klm", HR, phase)
+    return Hk
+
+
+def Hk_to_R(Hk, Rlist, kpts, kweights):
+    phase = np.exp(-2.0j * np.pi * np.tensordot(kpts, Rlist, axes=([1], [1])))
+    HR = np.einsum("klm, kr, k->rlm", Hk, phase, kweights)
+    return HR
+
+
+def k_to_R(kpts, Rlist, Mk, kweights=None):
+    """
+    Transform k-space wavefunctions to real space.
+    params:
+        kpts: k-points
+        Rlist: list of R vectors
+        Mk: matrix of shape [nkpt, n1, n2] in k-space.
+
+    return:
+        MR: matrix of shape [nR, n1, n2], the matrix in R-space.
+
+    """
+    nkpt, n1, n2 = Mk.shape
+    if kweights is None:
+        kweights = np.ones(nkpt, dtype=float) / nkpt
+    phase = np.exp(-2.0j * np.pi * np.tensordot(kpts, Rlist, axes=([1], [1])))
+    MR = np.einsum("klm, kr, k -> rlm", Mk, phase, kweights)
+    return MR
+
+    # nkpt, n1, n2 = Mk.shape
+    # nR = Rlist.shape[0]
+    # MR = np.zeros((nR, n1, n2), dtype=complex)
+    # if kweights is None:
+    #    kweights = np.ones(nkpt, dtype=float)/nkpt
+    # for iR, R in enumerate(Rlist):
+    #    for ik in range(nkpt):
+    #        MR[iR] += Mk[ik] * np.exp(-2.0j*np.pi * np.dot(kpts[ik], R)) * kweights[ik]
+    # return MR
+
+
+def R_to_k(kpts, Rlist, MR):
+    """
+    Transform real-space wavefunctions to k-space.
+    params:
+        kpts: k-points
+        Rlist: list of R vectors
+        MR: matrix of shape [nR, n1, n2] in R-space.
+
+    return:
+        Mk: matrix of shape [nkpt, n1, n2], the matrix in k-space.
+
+    """
+    phase = np.exp(2.0 * np.pi * 1j * np.tensordot(kpts, Rlist, axes=([1], [1])))
+    Mk = np.einsum("rlm, kr -> klm", MR, phase)
+
+    # nkpt, n1, n2 = Mk.shape
+    # nR = Rlist.shape[0]
+    # Mk = np.zeros((nkpt, n1, n2), dtype=complex)
+    # for iR, R in enumerate(Rlist):
+    #    for ik in range(nkpt):
+    #        Mk[ik] += MR[iR] * np.exp(2.0 * np.pi * 1j * np.dot(kpts[ik], R))
+    return Mk
+
+
+def R_to_onek(kpt, Rlist, MR):
+    """
+    Transform real-space wavefunctions to k-space.
+    params:
+        kpt: k-point
+        Rlist: list of R vectors
+        MR: matrix of shape [nR, n1, n2] in R-space.
+
+    return:
+        Mk: matrix of shape [n1, n2], the matrix in k-space.
+
+    """
+    phase = np.exp(2.0j * np.pi * np.dot(Rlist, kpt))
+    Mk = np.einsum("rlm, r -> lm", MR, phase)
+    return Mk
+    # n1, n2 = MR.shape[1:]
+    #    Mk = np.zeros((n1, n2), dtype=complex)
+    #    for iR, R in enumerate(Rlist):
+    #        Mk += MR[iR] * np.exp(2.0j*np.pi * np.dot(kpt, R))
+    #    return Mk

tb2j-0.9.1rc0/TB2J/mathutils/lowdin.py

@@ -0,0 +1,12 @@
+import numpy as np
+from scipy.linalg import inv, eigh
+
+
+def Lowdin(S):
+    """
+    Calculate S^(-1/2).
+    Which is used in lowind's symmetric orthonormalization.
+    psi_prime = S^(-1/2) psi
+    """
+    eigval, eigvec = eigh(S)
+    return eigvec @ np.diag(np.sqrt(1.0 / eigval)) @ (eigvec.T.conj())

tb2j-0.9.1rc0/TB2J/mathutils/rotate_spin.py

@@ -0,0 +1,35 @@
+import numpy as np
+from TB2J.pauli import pauli_block_all, s0, s1, s2, s3, gather_pauli_blocks
+
+
+def rotate_Matrix_from_z_to_axis(M, axis, normalize=True):
+    """
+    Given a spinor matrix M, rotate it from z-axis to axis.
+    The spinor matrix M is a 2x2 matrix, which can be decomposed as I, x, y, z components using Pauli matrices.
+    """
+    MI, Mx, My, Mz = pauli_block_all(M)
+    axis = axis / np.linalg.norm(axis)
+    # M_new = s0* MI +  Mz * (axis[0] * s1 + axis[1] * s2 + axis[2] * s3) *2
+    M_new = gather_pauli_blocks(MI, Mz * axis[0], Mz * axis[1], Mz * axis[2])
+    return M_new
+
+
+def test_rotate_Matrix_from_z_to_axis():
+    M = np.array([[1.1, 0], [0, 0.9]])
+    print(pauli_block_all(M))
+    Mnew = rotate_Matrix_from_z_to_axis(M, [1, 1, 1])
+    print(pauli_block_all(Mnew))
+    print(Mnew)
+
+    M = np.array(
+        [
+            [-9.90532976e-06 + 0.0j, 0.00000000e00 + 0.0j],
+            [0.00000000e00 + 0.0j, -9.88431291e-06 + 0.0j],
+        ]
+    )
+    print(M)
+    print(rotate_Matrix_from_z_to_axis(M, [0, 0, 1]))
+
+
+if __name__ == "__main__":
+    test_rotate_Matrix_from_z_to_axis()

{TB2J-0.9.0.1 → tb2j-0.9.1rc0}/TB2J/pauli.py

@@ -143,7 +143,24 @@ def pauli_block_all(M):
     return MI, Mx, My, Mz
 
 
+def gather_pauli_blocks(MI, Mx, My, Mz):
+    """
+    Gather the I, x, y, z component of a matrix.
+    """
+    return np.kron(MI, s0) + np.kron(Mx, s1) + np.kron(My, s2) + np.kron(Mz, s3)
+
+
+def test_gather_pauli_blocks():
+    M = np.random.rand(4, 4)
+    MI, Mx, My, Mz = pauli_block_all(M)
+    M2 = gather_pauli_blocks(MI, Mx, My, Mz)
+    assert np.allclose(M, M2)
+
+
 def op_norm(M):
+    """
+    Return the operator norm of a matrix.
+    """
     return max(svd(M)[1])
 
 

{TB2J-0.9.0.1 → tb2j-0.9.1rc0}/TB2J.egg-info/PKG-INFO

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

@@ -39,12 +39,15 @@ TB2J.egg-info/SOURCES.txt
 TB2J.egg-info/dependency_links.txt
 TB2J.egg-info/requires.txt
 TB2J.egg-info/top_level.txt
+TB2J/abacus/MAE.py
 TB2J/abacus/__init__.py
 TB2J/abacus/abacus_api.py
 TB2J/abacus/abacus_wrapper.py
 TB2J/abacus/gen_exchange_abacus.py
+TB2J/abacus/occupations.py
 TB2J/abacus/orbital_api.py
 TB2J/abacus/stru_api.py
+TB2J/abacus/test_density_matrix.py
 TB2J/abacus/test_read_HRSR.py
 TB2J/abacus/test_read_stru.py
 TB2J/external/__init__.py
@@ -56,6 +59,11 @@ TB2J/io_exchange/io_tomsasd.py
 TB2J/io_exchange/io_txt.py
 TB2J/io_exchange/io_uppasd.py
 TB2J/io_exchange/io_vampire.py
+TB2J/mathutils/__init__.py
+TB2J/mathutils/fermi.py
+TB2J/mathutils/kR_convert.py
+TB2J/mathutils/lowdin.py
+TB2J/mathutils/rotate_spin.py
 TB2J/spinham/__init__.py
 TB2J/spinham/base_parser.py
 TB2J/spinham/constants.py

{TB2J-0.9.0.1 → tb2j-0.9.1rc0}/setup.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 from setuptools import setup, find_packages
 
-__version__ = "0.9.0.1"
+__version__ = "0.9.1_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. """