TB2J 0.9.1rc0__py3-none-any.whl → 0.9.3rc0__py3-none-any.whl

TB2J/Jdownfolder.py

@@ -17,9 +17,23 @@ def ind_to_indn(ind, n=3):
     return indn
 
 
+class JR_model:
+    def __init__(self, JR, Rlist):
+        self.JR = JR
+        self.Rlist = Rlist
+        self.nR = len(Rlist)
+
+    def get_Jq(self, q):
+        Jq = np.zeros(self.JR[0].shape, dtype=complex)
+        for iR, R in enumerate(self.Rlist):
+            phase = np.exp(2.0j * np.pi * np.dot(q, R))
+            Jq += self.JR[iR] * phase
+        return Jq
+
+
 class JDownfolder:
     def __init__(self, JR, Rlist, iM, iL, qmesh, iso_only=False):
-        self.JR = JR
+        self.model = JR_model(JR, Rlist)
         self.Rlist = Rlist
         self.nR = len(Rlist)
         self.nM = len(iM)
@@ -34,25 +48,18 @@ class JDownfolder:
         self.nLn = self.nL * 3
         self.iso_only = iso_only
 
-    def get_Jq(self, q):
-        Jq = np.zeros(self.JR[0].shape, dtype=complex)
-        for iR, R in enumerate(self.Rlist):
-            phase = np.exp(2.0j * np.pi * np.dot(q, R))
-            Jq += self.JR[iR] * phase
-        return Jq
-
     def get_JR(self):
         JR_downfolded = np.zeros((self.nR, self.nMn, self.nMn), dtype=float)
         Jq_downfolded = np.zeros((self.nqpt, self.nMn, self.nMn), dtype=complex)
         self.iMn = ind_to_indn(self.iM, n=3)
         self.iLn = ind_to_indn(self.iL, n=3)
         for iq, q in enumerate(self.qpts):
-            Jq = self.get_Jq(q)
+            Jq = self.model.get_Jq(q)
             Jq_downfolded[iq] = self.downfold_oneq(Jq)
             for iR, R in enumerate(self.Rlist):
                 phase = np.exp(-2.0j * np.pi * np.dot(q, R))
                 JR_downfolded[iR] += np.real(Jq_downfolded[iq] * phase / self.nqpt)
-        return JR_downfolded
+        return JR_downfolded, self.Rlist
 
     def downfold_oneq(self, J):
         JMM = J[np.ix_(self.iMn, self.iMn)]
@@ -63,17 +70,80 @@ class JDownfolder:
         return Jn
 
 
+class PWFDownfolder:
+    def __init__(self, JR, Rlist, iM, iL, qmesh, atoms=None, iso_only=False, **kwargs):
+        from lawaf.interfaces.magnon.magnon_downfolder import (
+            MagnonWrapper,
+            MagnonDownfolder,
+        )
+
+        model = MagnonWrapper(JR, Rlist, atoms)
+        wann = MagnonDownfolder(model)
+        # Downfold the band structure.
+        index_basis = []
+        for i in iM:
+            index_basis += list(range(i * 3, i * 3 + 3))
+        params = dict(
+            method="projected",
+            # method="maxprojected",
+            kmesh=qmesh,
+            nwann=len(index_basis),
+            selected_basis=index_basis,
+            # anchors={(0, 0, 0): (-1, -2, -3, -4)},
+            # anchors={(0, 0, 0): ()},
+            # use_proj=True,
+            enhance_Amn=2.0,
+        )
+        params.update(kwargs)
+        wann.set_parameters(**params)
+        print("begin downfold")
+        ewf = wann.downfold()
+        ewf.save_hr_pickle("downfolded_JR.pickle")
+
+        # Plot the band structure.
+        wann.plot_band_fitting(
+            # kvectors=np.array([[0, 0, 0], [0.5, 0, 0],
+            #                   [0.5, 0.5, 0], [0, 0, 0],
+            #                   [.5, .5, .5]]),
+            # knames=['$\Gamma$', 'X', 'M', '$\Gamma$', 'R'],
+            cell=model.atoms.cell,
+            supercell_matrix=None,
+            npoints=100,
+            efermi=None,
+            erange=None,
+            fullband_color="blue",
+            downfolded_band_color="green",
+            marker="o",
+            ax=None,
+            savefig="downfold_band.png",
+            show=True,
+        )
+        self.JR_downfolded = ewf.HwannR
+        self.Rlist = ewf.Rlist
+
+    def get_JR(self):
+        return self.JR_downfolded, self.Rlist
+
+
 class JDownfolder_pickle:
     def __init__(
-        self, inpath, metals, ligands, outpath, qmesh=[7, 7, 7], iso_only=False
+        self,
+        inpath,
+        metals,
+        ligands,
+        outpath,
+        qmesh=[7, 7, 7],
+        iso_only=False,
+        method="pwf",
+        **kwargs
     ):
         self.exc = SpinIO.load_pickle(path=inpath, fname="TB2J.pickle")
 
         self.iso_only = (self.exc.dmi_ddict is None) or iso_only
-
         self.metals = metals
         self.ligands = ligands
         self.outpath = outpath
+        self.method = method
 
         # read atomic structure
         self.atoms = self.exc.atoms
@@ -83,7 +153,8 @@ class JDownfolder_pickle:
         self.Rcut = None
         self._build_atom_index()
         self._prepare_distance()
-        self._downfold()
+        Jd, Rlist = self._downfold(**kwargs)
+        self._Jd_to_exchange(Jd, Rlist)
 
     def _build_atom_index(self):
         self.magnetic_elements = self.metals
@@ -101,18 +172,33 @@ class JDownfolder_pickle:
         self.nL = len(self.iL)
         self.nsite = self.nM + self.nL
 
-    def _downfold(self):
+    def _downfold(self, **kwargs):
         JR2 = self.exc.get_full_Jtensor_for_Rlist(asr=True)
-        d = JDownfolder(
-            JR2,
-            self.exc.Rlist,
-            iM=self.iM,
-            iL=self.iL,
-            qmesh=self.qmesh,
-            iso_only=self.iso_only,
-        )
-        Jd = d.get_JR()
+        if self.method == "lowdin":
+            d = JDownfolder(
+                JR2,
+                self.exc.Rlist,
+                iM=self.iM,
+                iL=self.iL,
+                qmesh=self.qmesh,
+                iso_only=self.iso_only,
+            )
+            Jd, Rlist = d.get_JR()
+        else:
+            d = PWFDownfolder(
+                JR2,
+                self.exc.Rlist,
+                iM=self.iM,
+                iL=self.iL,
+                qmesh=self.qmesh,
+                atoms=self.atoms,
+                iso_only=self.iso_only,
+                **kwargs
+            )
+            Jd, Rlist = d.get_JR()
+        return Jd, Rlist
 
+    def _Jd_to_exchange(self, Jd, Rlist):
         self._prepare_distance()
         self._prepare_index_spin()
         self.Jdict = {}
@@ -123,7 +209,7 @@ class JDownfolder_pickle:
             self.DMIdict = {}
             self.Janidict = {}
 
-        for iR, R in enumerate(d.Rlist):
+        for iR, R in enumerate(Rlist):
             for i, ispin in enumerate(self.index_spin):
                 for j, jspin in enumerate(self.index_spin):
                     if ispin >= 0 and jspin >= 0:

TB2J/Jtensor.py

@@ -79,7 +79,7 @@ def combine_J_tensor(Jiso=0.0, D=np.zeros(3), Jani=np.zeros((3, 3), dtype=float)
     :param Jani: 3x3 matrix anisotropic exchange
     :returns:  A 3x3 matrix, the exchange paraemter in tensor form.
     """
-    Jtensor = np.zeros((3, 3), dtype=float)
+    Jtensor = np.zeros((3, 3), dtype=complex)
     if Jiso is not None:
         Jtensor += np.eye(3, dtype=float) * Jiso
     if Jani is not None:

TB2J/MAE.py

@@ -0,0 +1,185 @@
+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.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
+
+
+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
+
+
+class MAE:
+    def __init__(self, model, kmesh, gamma=True, 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)
+        self.width = width
+
+    def get_band_energy(self):
+        evals, evecs = self.model.solve_all(self.kpts)
+        occ = get_occupation(evals, self.kweights, self.model.nel, width=self.width)
+        eband = np.sum(evals * occ * self.kweights[:, np.newaxis])
+        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_vs_angles(
+        self,
+        thetas,
+        phis,
+    ):
+        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 tqdm.tqdm(enumerate(zip(thetas, phis))):
+            self.model.set_Hsoc_rotation_angle([theta, phi])
+            e = self.get_band_energy()
+            es.append(e)
+            # es2.append(e2)
+        return es
+
+
+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
+):
+    """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 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 siesta_get_MAE(fdf_fname, kmesh, thetas, phis, gamma=True, outfile="MAE.txt"):
+    """ """
+    parser = SiestaParser(fdf_fname=fdf_fname, read_H_soc=True)
+    model = parser.parse()
+    ham = MAE(model, kmesh, gamma=gamma)
+    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")
+    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 = MAE(model, kmesh, gamma=True)
+    # 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),
+        rotation_axis="y",
+        initial_direction=(0, 0, 1),
+        npoints=11,
+    )
+    # print the table of thetas and es, es2
+    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/abacus/abacus_wrapper.py

@@ -7,6 +7,8 @@ from pathlib import Path
 import os
 import numpy as np
 from scipy.linalg import eigh
+from copy import deepcopy
+from TB2J.mathutils.rotate_spin import rotate_Matrix_from_z_to_spherical
 from TB2J.utils import symbol_number_list
 from TB2J.myTB import AbstractTB
 from TB2J.abacus.abacus_api import read_HR_SR
@@ -15,9 +17,12 @@ from TB2J.abacus.stru_api import read_abacus, read_abacus_out
 
 
 class AbacusWrapper(AbstractTB):
-    def __init__(self, HR, SR, Rlist, nbasis, nspin=1):
+    def __init__(
+        self, HR, SR, Rlist, nbasis, nspin=1, HR_soc=None, HR_nosoc=None, nel=None
+    ):
         self.R2kfactor = 2j * np.pi
         self.is_orthogonal = False
+        self.split_soc = False
         self._name = "ABACUS"
         self._HR = HR
         self.SR = SR
@@ -25,11 +30,38 @@ class AbacusWrapper(AbstractTB):
         self.nbasis = nbasis
         self.nspin = nspin
         self.norb = nbasis * nspin
+        self.nel = nel
         self._build_Rdict()
+        if HR_soc is not None:
+            self.set_HR_soc(HR_soc=HR_soc, HR_nosoc=HR_nosoc, HR_full=HR)
+        self.soc_rotation_angle = 0.0
+
+    def set_HR_soc(self, HR_soc=None, HR_nosoc=None, HR_full=None):
+        self.split_soc = True
+        self.HR_soc = HR_soc
+        if HR_nosoc is not None:
+            self.HR_nosoc = HR_nosoc
+        if HR_full is not None:
+            self.HR_nosoc = HR_full - HR_soc
+
+    def set_Hsoc_rotation_angle(self, angle):
+        """
+        Set the rotation angle for SOC part of Hamiltonian
+        """
+        self.soc_rotation_angle = angle
 
     @property
     def HR(self):
-        return self._HR
+        if self.split_soc:
+            _HR = np.zeros_like(self.HR_soc)
+            for iR, _ in enumerate(self.Rlist):
+                theta, phi = self.soc_rotation_angle
+                _HR[iR] = self.HR_nosoc[iR] + rotate_Matrix_from_z_to_spherical(
+                    self.HR_soc[iR], theta, phi
+                )
+            return _HR
+        else:
+            return self._HR
 
     @HR.setter
     def set_HR(self, HR):
@@ -214,6 +246,20 @@ class AbacusParser:
             raise ValueError(f"EFERMI not found in the {str(fname)}  file.")
         return efermi
 
+    def read_nel(self):
+        """
+        Reading the number of electrons from the scf log file.
+        """
+        fname = str(Path(self.outpath) / "running_scf.log")
+        nel = None
+        with open(fname, "r") as myfile:
+            for line in myfile:
+                if "NELECT" in line:
+                    nel = float(line.split()[2])
+        if nel is None:
+            raise ValueError(f"NELECT not found in the {str(fname)}  file.")
+        return nel
+
     def get_basis(self):
         slist = symbol_number_list(self.atoms)
         if self.spin == "collinear":
@@ -231,6 +277,42 @@ class AbacusParser:
             return basis
 
 
+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_nosoc, SR = self.parser_nosoc.Read_HSR_noncollinear()
+        nbasis2, Rlist2, HR2, SR2 = self.parser_soc.Read_HSR_noncollinear()
+        # print(HR[0])
+        HR_soc = HR2 - HR_nosoc
+        model = AbacusWrapper(
+            HR=None,
+            SR=SR,
+            Rlist=Rlist,
+            nbasis=nbasis,
+            nspin=2,
+            HR_soc=HR_soc,
+            HR_nosoc=HR_nosoc,
+        )
+        model.efermi = self.parser_soc.efermi
+        model.basis = self.parser_nosoc.basis
+        model.atoms = self.parser_nosoc.atoms
+        return model
+
+
 def test_abacus_wrapper_collinear():
     outpath = "/Users/hexu/projects/TB2J_abacus/abacus-tb2j-master/abacus_example/case_Fe/1_no_soc/OUT.Fe"
     parser = AbacusParser(outpath=outpath, spin=None, binary=False)
@@ -239,7 +321,6 @@ def test_abacus_wrapper_collinear():
     # parser.read_HSR_collinear()
     model_up, model_dn = parser.get_models()
     H, S, E, V = model_up.HSE_k([0, 0, 0])
-    # print(H.shape)
     # print(H.diagonal().real)
     # print(model_up.get_HR0().diagonal().real)
     print(parser.efermi)

TB2J/exchange.py

@@ -1,6 +1,9 @@
 from collections import defaultdict, OrderedDict
 import os
 import numpy as np
+import pickle
+from dataclasses import dataclass
+import yaml
 from TB2J.green import TBGreen
 from TB2J.pauli import pauli_block_all, pauli_block_sigma_norm, pauli_mat
 from TB2J.utils import symbol_number, kmesh_to_R
@@ -10,25 +13,47 @@ from TB2J.external import p_map
 from TB2J.contour import Contour
 from TB2J.utils import simpson_nonuniform, trapezoidal_nonuniform, split_symbol_number
 from TB2J.orbmap import map_orbs_matrix
-import pickle
+from typing import List, Tuple
 
 
+@dataclass
 class ExchangeParams:
+    """
+    A class to store the parameters for exchange calculation.
+    """
+
+    efermi: float
+    basis: list = None
+    magnetic_elements: list = None
+    include_orbs = {}
+    _kmesh = [4, 4, 4]
+    emin: float = -15
+    emax: float = 0.05
+    nz: int = 100
+    exclude_orbs = []
+    ne: int = None
+    Rcut: float = None
+    _use_cache: bool = False
+    np: int = 1
+    description: str = ""
+    write_density_matrix: bool = False
+    orb_decomposition: bool = False
+    output_path: str = "TB2J_results"
+    mae_angles = None
+
     def __init__(
         self,
-        efermi,
+        efermi=-10.0,
         basis=None,
-        magnetic_elements=[],
-        include_orbs={},
+        magnetic_elements=None,
+        include_orbs=None,
         kmesh=[4, 4, 4],
-        emin=-15,  # integration lower bound, relative to fermi energy
-        # integration upper bound. Should be 0 (fermi energy). But DFT codes define Fermi energy in various ways.
+        emin=-15,
         emax=0.05,
         nz=100,
-        # the delta in the (i delta) in green's function to prevent divergence
-        exclude_orbs=[],  #
-        ne=None,  # number of electrons in Wannier function.
-        Rcut=None,  # Rcut.
+        exclude_orbs=[],
+        ne=None,
+        Rcut=None,
         use_cache=False,
         np=1,
         description="",
@@ -37,70 +62,41 @@ class ExchangeParams:
         output_path="TB2J_results",
     ):
         self.efermi = efermi
-        self.emin = emin
-        self.emax = emax
-        self.nz = nz
-        self.Rcut = Rcut
         self.basis = basis
         self.magnetic_elements = magnetic_elements
         self.include_orbs = include_orbs
-
+        self._kmesh = kmesh
+        self.emin = emin
+        self.emax = emax
+        self.nz = nz
         self.exclude_orbs = exclude_orbs
         self.ne = ne
+        self.Rcut = Rcut
         self._use_cache = use_cache
         self.np = np
-        self._kmesh = kmesh
-        self.orb_decomposition = orb_decomposition
-        self.write_density_matrix = write_density_matrix
         self.description = description
+        self.write_density_matrix = write_density_matrix
+        self.orb_decomposition = orb_decomposition
         self.output_path = output_path
 
+    def set_params(self, **kwargs):
+        for key, val in kwargs.items():
+            setattr(self, key, val)
+
+    def save_to_yaml(self, fname):
+        with open(fname, "w") as myfile:
+            yaml.dump(self.__dict__, myfile)
+
 
 class Exchange(ExchangeParams):
     def __init__(
         self,
         tbmodels,
         atoms,
-        efermi,
-        basis=None,
-        magnetic_elements=[],
-        include_orbs={},
-        kmesh=[4, 4, 4],
-        emin=-15,  # integration lower bound, relative to fermi energy
-        # integration upper bound. Should be 0 (fermi energy). But DFT codes define Fermi energy in various ways.
-        emax=0.05,
-        nz=100,
-        # the delta in the (i delta) in green's function to prevent divergence
-        exclude_orbs=[],  #
-        ne=None,  # number of electrons in Wannier function.
-        Rcut=None,  # Rcut.
-        use_cache=False,
-        np=1,
-        description="",
-        write_density_matrix=False,
-        output_path="TB2J_results",
-        orb_decomposition=False,
+        **params: ExchangeParams,
     ):
         self.atoms = atoms
-        super().__init__(
-            efermi=efermi,
-            basis=basis,
-            magnetic_elements=magnetic_elements,
-            include_orbs=include_orbs,
-            kmesh=kmesh,
-            emin=emin,
-            emax=emax,
-            nz=nz,
-            exclude_orbs=exclude_orbs,
-            ne=ne,
-            Rcut=Rcut,
-            use_cache=use_cache,
-            np=np,
-            description=description,
-            write_density_matrix=write_density_matrix,
-            orb_decomposition=orb_decomposition,
-            output_path=output_path,
-        )
+        super().__init__(**params)
         self._prepare_kmesh(self._kmesh)
         self._prepare_Rlist()
         self.set_tbmodels(tbmodels)
@@ -334,7 +330,6 @@ class ExchangeNCL(Exchange):
         """
         self.tbmodel = tbmodels
         self.backend_name = self.tbmodel.name
-        # TODO: check if tbmodels are really a tbmodel with SOC.
         self.G = TBGreen(
             self.tbmodel,
             self.kmesh,
@@ -355,6 +350,12 @@ class ExchangeNCL(Exchange):
         if self.write_density_matrix:
             self.G.write_rho_R()
 
+    def get_MAE(self, thetas, phis):
+        """
+        Calculate the magnetic anisotropy energy.
+        """
+        pass
+
     def _prepare_NijR(self):
         self.N = {}
         for R in self.Rlist:
@@ -615,7 +616,7 @@ class ExchangeNCL(Exchange):
     def calculate_DMI_NJT(self):
         """
         calculate exchange and DMI with the
-        D(i,j) =
+        This did not work and should be removed.
         """
         Ddict_NJT = {}
         Jdict_NJT = {}
@@ -679,10 +680,36 @@ class ExchangeNCL(Exchange):
                         self.contour.path, AijRs_orb[(R, iatom, jatom)]
                     )
 
-    def get_AijR(self, e):
-        GR = self.G.get_GR(self.short_Rlist, energy=e, get_rho=False)
+    def get_quantities_per_e(self, e):
+        Gk_all = self.G.get_Gk_all(e)
+        mae = self.get_mae_kspace(Gk_all)
+        # 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 AijR, AijR_orb
+        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
+        Hso_k = self.model.get_Hso_k(k)
+        mae_e = np.zeros(len(self.mae_angles), dtype=complex)
+        # rotate the Hso_k to angles
+        for ik, k in enumerate(self.G.kpoints):
+            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
+        """
 
     def save_AijR(self, AijRs, fname):
         result = dict(path=self.contour.path, AijRs=AijRs)
@@ -693,6 +720,7 @@ class ExchangeNCL(Exchange):
         """
         Do some sanity check before proceding.
         """
+        pass
 
     def calculate_all(self):
         """
@@ -701,40 +729,38 @@ class ExchangeNCL(Exchange):
         print("Green's function Calculation started.")
 
         AijRs = {}
-
         AijRs_orb = {}
 
         self.validate()
 
         npole = len(self.contour.path)
         if self.np > 1:
-            results = p_map(self.get_AijR, self.contour.path, num_cpus=self.np)
+            results = p_map(
+                self.get_quantities_per_e, self.contour.path, num_cpus=self.np
+            )
         else:
-            results = map(self.get_AijR, tqdm(self.contour.path, total=npole))
+            results = map(
+                self.get_quantities_per_e, tqdm(self.contour.path, total=npole)
+            )
 
         for i, result in enumerate(results):
             for iR, R in enumerate(self.R_ijatom_dict):
                 for iatom, jatom in self.R_ijatom_dict[R]:
                     if (R, iatom, jatom) in AijRs:
-                        AijRs[(R, iatom, jatom)].append(result[0][R, iatom, jatom])
+                        AijRs[(R, iatom, jatom)].append(result["AijR"][R, iatom, jatom])
                         if self.orb_decomposition:
                             AijRs_orb[(R, iatom, jatom)].append(
-                                result[1][R, iatom, jatom]
+                                result["AijR_orb"][R, iatom, jatom]
                             )
 
                     else:
                         AijRs[(R, iatom, jatom)] = []
-                        AijRs[(R, iatom, jatom)].append(result[0][R, iatom, jatom])
+                        AijRs[(R, iatom, jatom)].append(result["AijR"][R, iatom, jatom])
                         if self.orb_decomposition:
                             AijRs_orb[(R, iatom, jatom)] = []
                             AijRs_orb[(R, iatom, jatom)].append(
-                                result[1][R, iatom, jatom]
+                                result["AijR_orb"][R, iatom, jatom]
                             )
-        if self.np > 1:
-            # executor.close()
-            # executor.join()
-            # executor.clear()
-            pass
 
         # self.save_AijRs(AijRs)
         self.integrate(AijRs, AijRs_orb)

TB2J/exchangeCL2.py

@@ -234,11 +234,11 @@ class ExchangeCL2(ExchangeCL):
                     self.contour.path, self.JJ_list[(R, iatom, jatom)]
                 )
 
-    def get_AijR(self, e):
+    def get_quantities_per_e(self, e):
         GR_up = self.Gup.get_GR(self.short_Rlist, energy=e, get_rho=False)
         GR_dn = self.Gdn.get_GR(self.short_Rlist, energy=e, get_rho=False)
         Jorb_list, JJ_list = self.get_all_A(GR_up, GR_dn)
-        return Jorb_list, JJ_list
+        return dict(Jorb_list=Jorb_list, JJ_list=JJ_list)
 
     def calculate_all(self):
         """
@@ -248,13 +248,18 @@ class ExchangeCL2(ExchangeCL):
 
         npole = len(self.contour.path)
         if self.np == 1:
-            results = map(self.get_AijR, tqdm(self.contour.path, total=npole))
+            results = map(
+                self.get_quantities_per_e, tqdm(self.contour.path, total=npole)
+            )
         else:
             # pool = ProcessPool(nodes=self.np)
             # results = pool.map(self.get_AijR_rhoR ,self.contour.path)
-            results = p_map(self.get_AijR, self.contour.path, num_cpus=self.np)
+            results = p_map(
+                self.get_quantities_per_e, self.contour.path, num_cpus=self.np
+            )
         for i, result in enumerate(results):
-            Jorb_list, JJ_list = result
+            Jorb_list = result["Jorb_list"]
+            JJ_list = result["JJ_list"]
             for iR, R in enumerate(self.R_ijatom_dict):
                 for iatom, jatom in self.R_ijatom_dict[R]:
                     key = (R, iatom, jatom)

TB2J/green.py

@@ -270,7 +270,14 @@ class TBGreen:
         # Gk = np.linalg.inv((energy+self.efermi)*self.S[ik,:,:] - self.H[ik,:,:])
         return Gk
 
-    def get_GR(self, Rpts, energy, get_rho=False):
+    def get_Gk_all(self, energy):
+        """Green's function G(k) for one energy for all kpoints"""
+        Gk_all = np.zeros((self.nkpts, self.nbasis, self.nbasis), dtype=complex)
+        for ik, _ in enumerate(self.kpts):
+            Gk_all[ik] = self.get_Gk(ik, energy)
+        return Gk_all
+
+    def get_GR(self, Rpts, energy, get_rho=False, Gk_all=None):
         """calculate real space Green's function for one energy, all R points.
         G(R, epsilon) = G(k, epsilon) exp(-2\pi i R.dot. k)
         :param Rpts: R points
@@ -282,7 +289,10 @@ class TBGreen:
         GR = defaultdict(lambda: 0.0j)
         rhoR = defaultdict(lambda: 0.0j)
         for ik, kpt in enumerate(self.kpts):
-            Gk = self.get_Gk(ik, energy)
+            if Gk_all is None:
+                Gk = self.get_Gk(ik, energy)
+            else:
+                Gk = Gk_all[ik]
             if get_rho:
                 if self.is_orthogonal:
                     rhok = Gk

TB2J/manager.py

@@ -6,7 +6,13 @@ from TB2J.exchangeCL2 import ExchangeCL2
 from TB2J.exchange_qspace import ExchangeCLQspace
 from TB2J.utils import read_basis, auto_assign_basis_name
 from ase.io import read
-from TB2J.sisl_wrapper import SislWrapper
+
+#from TB2J.sisl_wrapper import SislWrapper
+try:
+    from HamiltonIO.siesta import SislWrapper
+except ImportError:
+    print("Cannot import SislWrapper from HamiltonIO.siesta. Please install HamiltonIO first.")
+    from TB2J.sisl_wrapper import SislWrapper
 from TB2J.gpaw_wrapper import GPAWWrapper
 from TB2J.wannier import parse_atoms
 
@@ -283,8 +289,8 @@ def gen_exchange_siesta(
     geom = H.geometry
     if H.spin.is_colinear:
         print("Reading Siesta hamiltonian: colinear spin.")
-        tbmodel_up = SislWrapper(H, spin=0, geom=geom)
-        tbmodel_dn = SislWrapper(H, spin=1, geom=geom)
+        tbmodel_up = SislWrapper(fdf_fname=None,sisl_hamiltonian=H, spin=0, geom=geom)
+        tbmodel_dn = SislWrapper(fdf_fname=None, sisl_hamiltonian=H, spin=1, geom=geom)
         basis = dict(zip(tbmodel_up.orbs, list(range(tbmodel_up.norb))))
         print("Starting to calculate exchange.")
         description = f""" Input from collinear Siesta data.
@@ -351,7 +357,7 @@ def gen_exchange_siesta(
 
     elif H.spin.is_spinorbit or H.spin.is_noncolinear:
         print("Reading Siesta hamiltonian: non-colinear spin.")
-        tbmodel = SislWrapper(H, spin=None, geom=geom)
+        tbmodel = SislWrapper(fdf_fname=None, sisl_hamiltonian=H, spin=None, geom=geom)
         basis = dict(zip(tbmodel.orbs, list(range(tbmodel.nbasis))))
         print("Starting to calculate exchange.")
         description = f""" Input from non-collinear Siesta data.

TB2J/mathutils/rotate_spin.py

@@ -14,6 +14,27 @@ def rotate_Matrix_from_z_to_axis(M, axis, normalize=True):
     return M_new
 
 
+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
+
+
+def rotate_Matrix_from_z_to_spherical(M, theta, phi, normalize=True):
+    """
+    Given a spinor matrix M, rotate it from z-axis to spherical coordinates
+    """
+    axis = spherical_to_cartesian(theta, phi, normalize)
+    return rotate_Matrix_from_z_to_axis(M, axis, normalize)
+
+
 def test_rotate_Matrix_from_z_to_axis():
     M = np.array([[1.1, 0], [0, 0.9]])
     print(pauli_block_all(M))

TB2J/patch.py

@@ -0,0 +1,50 @@
+import types
+from unittest import mock
+
+class A(object):#but seems to work for old style objects too
+    def funcx(self,x):
+        print("x1=",x)
+        print("called from", self)
+
+    def method(self,x):
+        print("xmethod=",x)
+        print("called from", self)
+
+def patch_me(target):
+    def method(target,x):
+        print("x=",x)
+        print("called from", target)
+        target.method = types.MethodType(method,target)
+
+def method(self,x):
+    print("x=",x)
+    print("called from", self)
+
+@mock.patch("__main__.A")
+def funcx(self,x):
+    print("new x=",x)
+    print("called from", self)
+        
+A.method=method
+#add more if needed
+a = A()
+print(A.__dict__)
+print(a)
+#out: <__main__.A object at 0x2b73ac88bfd0>  
+
+@mock.patch("__main__.a")
+def funcx(self,x):
+    print("x=",x)
+    print("called from", self)
+ 
+a.funcx(3)
+patch_me(a)    #patch instance
+a.method=method
+#a.method(5)
+#out: x= 5
+#out: called from <__main__.A object at 0x2b73ac88bfd0>
+patch_me(A)
+
+a.method(6)        #can patch class too
+#out: x= 6
+#out: called from <class '__main__.A'>

{TB2J-0.9.1rc0.data → TB2J-0.9.3rc0.data}/scripts/TB2J_downfold.py

@@ -58,6 +58,13 @@ def main():
         default=False,
     )
 
+    parser.add_argument(
+        "--method",
+        help="The method to downfold the exchange parameter. Options are Lowdin and PWF (projected Wannier function). ",
+        type=str,
+        default="Lowdin",
+    )
+
     args = parser.parse_args()
 
     if len(args.metals) == []:
@@ -73,6 +80,7 @@ def main():
         outpath=args.outpath,
         qmesh=args.qmesh,
         iso_only=args.iso_only,
+        method=args.method,
     )
 
 

{TB2J-0.9.1rc0.dist-info → TB2J-0.9.3rc0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: TB2J
-Version: 0.9.1rc0
+Version: 0.9.3rc0
 Summary: TB2J: First principle to Heisenberg exchange J using tight-binding Green function method
 Author: Xu He
 Author-email: mailhexu@gmail.com
@@ -22,5 +22,6 @@ Requires-Dist: tqdm
 Requires-Dist: pathos
 Requires-Dist: packaging >=20.0
 Requires-Dist: pre-commit
+Requires-Dist: HamiltonIO >=0.1.4
 
 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.1rc0.dist-info → TB2J-0.9.3rc0.dist-info}/RECORD

@@ -1,5 +1,6 @@
-TB2J/Jdownfolder.py,sha256=Nw2ixvn2Uq-o1wficz6rdaYHjfRN3U_kQCvrNJGNb68,6980
-TB2J/Jtensor.py,sha256=0fhfOcfVQGu75gytEnApKWTJZfg9ksKJ0anJgco5wRQ,3179
+TB2J/Jdownfolder.py,sha256=Rmg6KfQ-Lkhei5daTJ2POzr0XL-R1WM-rzUnDcfoDhc,9595
+TB2J/Jtensor.py,sha256=t6OsqrSlYW6Im4H7ykVAW8Al_pFXN4C5yj2UEsV6r7g,3181
+TB2J/MAE.py,sha256=0yU11DNKwcW5fL2EWgangIqHdWW4Vp97IiXGdi70Ayo,7396
 TB2J/Oiju.py,sha256=cNGv8N5uH_swGq7cnAt2OyiDfqtjLlLrwseGu0E4iaM,3383
 TB2J/Oiju_epc.py,sha256=oytM3NYW7nWmklrGgNlqwIpI_JYv_hb7ZnR4o9nYNog,6809
 TB2J/__init__.py,sha256=hcEWkag_UvLm1ZSbjsgcTWkGVlR3Bwmzg1QYAwsvf-g,24
@@ -9,19 +10,20 @@ TB2J/contour.py,sha256=aw8LX6wVFCRPhcpkzuI0jGnHisvk4cezvUhkF_6Yx94,2633
 TB2J/cut_cell.py,sha256=kr9WeQhBQLm8QXL2B3NcsSYmSw-OAtJk3f9wksAOZbs,2952
 TB2J/density_matrix.py,sha256=D5k8Oe21OCiLVORNYbo4TZOFG0slrQSbj91kJ3TMFjs,1514
 TB2J/epc.py,sha256=zLbtqZJhDr8DnnGN6YENcXwrMb3Qxu6KB08mLy9Pw20,3474
-TB2J/exchange.py,sha256=dsXQhlxXaBurxa7z3YkBjqmEFFtfEy1xaHf0VT3eKZE,29581
-TB2J/exchangeCL2.py,sha256=TIr-d2X56AiGe4qEhyXyZhRuwXvQG6clJMwDmjnTOaE,10985
+TB2J/exchange.py,sha256=Tltunv85eNr-jsVL_SvfqG_WVkQyJX99RszaJRQRBD8,29945
+TB2J/exchangeCL2.py,sha256=QSbQ_WxgJyiByn2U-tJ3xy2iYIQI8YMrN3vhw9_k2Cs,11149
 TB2J/exchange_pert.py,sha256=jmFMtQbYa_uczM4VAeS6TijkIHRFIqEzZJswzE9Wfuo,8523
 TB2J/exchange_qspace.py,sha256=ZL68qBGFUaQ9BsSPsJaaoWOr9RssPiqX34R_9I3nk_8,8436
 TB2J/gpaw_wrapper.py,sha256=aJ--9Dtyq7jOP1Hkh-Sh1nWcfXm6zKcljOCO0DNCAr0,6890
-TB2J/green.py,sha256=QAJbDaR91QLres5gUPk37iqVsuQdPTt92VtEYLCl240,13170
+TB2J/green.py,sha256=giWSPhrLKc3ZKOpwyY3snUKFWH08GMqBlsJWbFG9Qo8,13565
 TB2J/greentest.py,sha256=2ISSfhor9ecSEOi_E6b4Cv26wEIQlwlzca0ru8z44_E,1603
 TB2J/io_merge.py,sha256=t85k3L6IL9X5ys-PWK7CzResb3xJsyqM3LAlKPUe9vM,6825
 TB2J/kpoints.py,sha256=6XK2KqTncidEq3o9GuO6VEZRPNTRtWeXg9QfcV-9smI,532
-TB2J/manager.py,sha256=4-4x9jJRHpUEqJuhc5HqpXfh2-Ze5G9Wg8gOtn-AqR4,15372
+TB2J/manager.py,sha256=Ogb_yRCnroNmGttKPRcbF70ddF9UNV_1UytdKbNFN4E,15685
 TB2J/mathutils.py,sha256=tHA6q3KPDpXLIbZHdDZ2NU5s886VVM_oEG490zQ6Ris,300
 TB2J/myTB.py,sha256=ok_B4my29bOIghMSZfx0Es6G8FaXaIiLP4gPxTdSj00,17659
 TB2J/orbmap.py,sha256=RCMJkOPGbfPrcZzcc5ia1ZMKBQWxGcyj8W1ve8BJaEw,6669
+TB2J/patch.py,sha256=Z3KZklID9U8zKuk6Ek1Tq95JcY3eT4770dsdcXz6mAA,1067
 TB2J/pauli.py,sha256=zOELm7Vgxw6SMaO5l7qVWx1pBKZt25RLnEpnVM3dz_0,4545
 TB2J/pert.py,sha256=RaCJfewl0doht4cjAnzzGKe-uj2le4aqe0iPKFrq9fo,1192
 TB2J/plot.py,sha256=AnFIFWE2vlmj7Z6f_7-dX_O1stJN-qbuiurPj43dUCM,4104
@@ -36,7 +38,7 @@ TB2J/versioninfo.py,sha256=wZwS9QDFRVDe7rf8JyPDDI8UGdTQiO6Pb_sWv8GAegA,337
 TB2J/abacus/MAE.py,sha256=q9aSVDRZFAnZL3gHdNmde7sxj80oe-BRjwDO-ipyfew,12237
 TB2J/abacus/__init__.py,sha256=5sHiDnF2L-Y80QeET9zOiS83a5T_TQAXvnIhcYB6wNU,56
 TB2J/abacus/abacus_api.py,sha256=D_NyXW-Pno92d3RVHByx0l1HDPHQAvXsmQVt8cfIGR8,7267
-TB2J/abacus/abacus_wrapper.py,sha256=PaO7qEE-h1tv2nKsV8h2RZUrmAWjkw8MKapj8Fk9U5s,9006
+TB2J/abacus/abacus_wrapper.py,sha256=k0ZyTQ0jungp7jtlVCcdFQVK9YKeWokZvASCvfKCuKs,11880
 TB2J/abacus/gen_exchange_abacus.py,sha256=lKZqkWMnLQtaSwgn8O5Fzr-pV6tzwoMqfZU_vbET6gU,2973
 TB2J/abacus/occupations.py,sha256=vaMVeZwldgzGDxjA7i3-2-V6akXjpgJwJFWKozJ-l2k,8947
 TB2J/abacus/orbital_api.py,sha256=l48Hn5z7TA0TH7Is4NDmz74b6B9L2ztYO4dRR37U4mQ,1562
@@ -58,7 +60,7 @@ TB2J/mathutils/__init__.py,sha256=tQLBfHkZqdVfVxPOahy42qMUkFYnFFFhM-uc4QsYFxI,27
 TB2J/mathutils/fermi.py,sha256=tzEicVoxE_5DxPDDZMvi4ynR1_Iqf-Qh0-0zfm-iVBo,480
 TB2J/mathutils/kR_convert.py,sha256=p_9XWJVNanTzTK2rI6KRjTkbSq42la6N448-zJOsMwY,2671
 TB2J/mathutils/lowdin.py,sha256=tHA6q3KPDpXLIbZHdDZ2NU5s886VVM_oEG490zQ6Ris,300
-TB2J/mathutils/rotate_spin.py,sha256=XtfwHGfIqI9nRYZcCd_yQ3Ud1AXVJj9fwqIHloMcaCs,1111
+TB2J/mathutils/rotate_spin.py,sha256=NT12khB8lN1qf_jQ2SwnAhhtWxptZXkzpUQ2JvZEnkM,1710
 TB2J/spinham/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 TB2J/spinham/base_parser.py,sha256=oQRHvFE_BlUtTaTZykKgvicu40oXcbICB-D1aAt-qlA,2196
 TB2J/spinham/constants.py,sha256=y4-hRyl5EAR42k24Oa5XhAsUQtKVn1MAgyqNf-p3PrM,762
@@ -74,18 +76,18 @@ TB2J/spinham/supercell.py,sha256=y17uUC6r3gQb278FhxIW4CABihfLTvKFj6flyXrCPR8,122
 TB2J/wannier/__init__.py,sha256=7ojCbM84PYv1X1Tbo4NHI-d3gWmQsZB_xiYqbfxVV1E,80
 TB2J/wannier/w90_parser.py,sha256=dbd63LuKyv2DVUzqRINGsbDzEsOxsQyE8_Ear_LQIRg,4620
 TB2J/wannier/w90_tb_parser.py,sha256=qt8pnuprmPp9iIAYwPkPbmEzk6ZPgMq2xognoQp7vwc,4610
-TB2J-0.9.1rc0.data/scripts/TB2J_downfold.py,sha256=F9oImXFysejCMP7eIBjbCX2jdHFOCvDW5beF1sG-UM8,1854
-TB2J-0.9.1rc0.data/scripts/TB2J_eigen.py,sha256=Qs9v2hnMm2Tpfoa4h53muUKty2dZjwx8948MBoQooNg,1128
-TB2J-0.9.1rc0.data/scripts/TB2J_magnon.py,sha256=q7UwAmorRcFNk4tfE7gl_ny05l6p7pbD9Wm_LkIpKEw,3101
-TB2J-0.9.1rc0.data/scripts/TB2J_magnon_dos.py,sha256=TMXQvD2dIbO5FZ4tUMmxJgCgH2O2hDAPUNfEKO4z-x4,110
-TB2J-0.9.1rc0.data/scripts/TB2J_merge.py,sha256=y834SF4rIRn1L1ptkhczvavQpC-8Px6DTmDOOSaq_DE,1854
-TB2J-0.9.1rc0.data/scripts/TB2J_rotate.py,sha256=zgiDFuYZNmzKK0rwDmTaYD2OpRlmKA_VGeBx83w2Xwc,873
-TB2J-0.9.1rc0.data/scripts/TB2J_rotateDM.py,sha256=kCvF7gotuqAX1VnJ06cwfVm7RrhrdtiV5v7d9P2Pn_E,567
-TB2J-0.9.1rc0.data/scripts/abacus2J.py,sha256=M4B07lvTCDczTPTqvnDh_PERzCARAd09TLKv4aIdSQM,4408
-TB2J-0.9.1rc0.data/scripts/siesta2J.py,sha256=hBzS7ZgoHM3oXlTCQd-xVA07Ks2FiIwyRpQWUFITRPE,4303
-TB2J-0.9.1rc0.data/scripts/wann2J.py,sha256=2t2hWwyELskYCwkGDziCgiIAnfr6odLLJ6cQBJ2RQwQ,5714
-TB2J-0.9.1rc0.dist-info/LICENSE,sha256=CbZI-jyRTjiqIcWa244cRSHJdjjtUNqGR4HeJkgEwJw,1332
-TB2J-0.9.1rc0.dist-info/METADATA,sha256=ymoIhPvH2rmZH5KQRPcDlCBqhctXKTukTDCmdFzZM4w,1421
-TB2J-0.9.1rc0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-TB2J-0.9.1rc0.dist-info/top_level.txt,sha256=whYa5ByLYhl5XnTPBHSWr-IGD6VWmr5Ql2bye2qwV_s,5
-TB2J-0.9.1rc0.dist-info/RECORD,,
+TB2J-0.9.3rc0.data/scripts/TB2J_downfold.py,sha256=i4BVqnpDdgrX_amookVWeLGefGBn-qeAutWiwuY9SfQ,2099
+TB2J-0.9.3rc0.data/scripts/TB2J_eigen.py,sha256=Qs9v2hnMm2Tpfoa4h53muUKty2dZjwx8948MBoQooNg,1128
+TB2J-0.9.3rc0.data/scripts/TB2J_magnon.py,sha256=q7UwAmorRcFNk4tfE7gl_ny05l6p7pbD9Wm_LkIpKEw,3101
+TB2J-0.9.3rc0.data/scripts/TB2J_magnon_dos.py,sha256=TMXQvD2dIbO5FZ4tUMmxJgCgH2O2hDAPUNfEKO4z-x4,110
+TB2J-0.9.3rc0.data/scripts/TB2J_merge.py,sha256=y834SF4rIRn1L1ptkhczvavQpC-8Px6DTmDOOSaq_DE,1854
+TB2J-0.9.3rc0.data/scripts/TB2J_rotate.py,sha256=zgiDFuYZNmzKK0rwDmTaYD2OpRlmKA_VGeBx83w2Xwc,873
+TB2J-0.9.3rc0.data/scripts/TB2J_rotateDM.py,sha256=kCvF7gotuqAX1VnJ06cwfVm7RrhrdtiV5v7d9P2Pn_E,567
+TB2J-0.9.3rc0.data/scripts/abacus2J.py,sha256=M4B07lvTCDczTPTqvnDh_PERzCARAd09TLKv4aIdSQM,4408
+TB2J-0.9.3rc0.data/scripts/siesta2J.py,sha256=hBzS7ZgoHM3oXlTCQd-xVA07Ks2FiIwyRpQWUFITRPE,4303
+TB2J-0.9.3rc0.data/scripts/wann2J.py,sha256=2t2hWwyELskYCwkGDziCgiIAnfr6odLLJ6cQBJ2RQwQ,5714
+TB2J-0.9.3rc0.dist-info/LICENSE,sha256=CbZI-jyRTjiqIcWa244cRSHJdjjtUNqGR4HeJkgEwJw,1332
+TB2J-0.9.3rc0.dist-info/METADATA,sha256=9kUPr5GCrvzdnzjbhCmByaSBj6qZ-991Hab3hJ7WUzE,1455
+TB2J-0.9.3rc0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+TB2J-0.9.3rc0.dist-info/top_level.txt,sha256=whYa5ByLYhl5XnTPBHSWr-IGD6VWmr5Ql2bye2qwV_s,5
+TB2J-0.9.3rc0.dist-info/RECORD,,