TB2J 0.8.2.5__tar.gz → 0.8.2.8__tar.gz

{TB2J-0.8.2.5 → TB2J-0.8.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: TB2J
-Version: 0.8.2.5
+Version: 0.8.2.8
 Summary: TB2J: First principle to Heisenberg exchange J using tight-binding Green function method
 Home-page: UNKNOWN
 Author: Xu He

{TB2J-0.8.2.5 → TB2J-0.8.2.8}/TB2J/Oiju.py

@@ -45,10 +45,6 @@ def gen_exchange_Oiju(
     kmesh=[5, 5, 5],
     emin=-12.0,
     emax=0.0,
-    height=0.2,
-    nz1=50,
-    nz2=200,
-    nz3=50,
     exclude_orbs=[],
     Rmesh=[1, 1, 1],
     description="",
@@ -93,10 +89,6 @@ def gen_exchange_Oiju(
             kmesh=kmesh,
             emin=emin,
             emax=emax,
-            height=height,
-            nz1=nz1,
-            nz2=nz2,
-            nz3=nz3,
             exclude_orbs=exclude_orbs,
             Rmesh=Rmesh,
             description=description,
@@ -123,10 +115,6 @@ if __name__ == "__main__":
         kmesh=[4, 4, 4],
         emin=-12.0,
         emax=0.0,
-        height=0.1,
-        nz1=50,
-        nz2=200,
-        nz3=50,
         exclude_orbs=[],
         Rmesh=[1, 1, 1],
         description="",

{TB2J-0.8.2.5 → TB2J-0.8.2.8}/TB2J/Oiju_epc.py

@@ -19,10 +19,6 @@ class OijuWannEPC(ExchangeCL2):
         kmesh=[4, 4, 4],
         emin=-15,  # integration lower bound, relative to fermi energy
         emax=0.05,  # integration upper bound. Should be 0 (fermi energy). But DFT codes define Fermi energy in various ways.
-        height=0.5,  # the delta in the (i delta) in green's function to prevent divergence
-        nz1=150,  # grid from emin to emin+(i delta)
-        nz2=300,  # grid from emin +(i delta) to emax+(i delta)
-        nz3=150,  # grid from emax + (i delta) to emax
         exclude_orbs=[],  #
         Rmesh=[0, 0, 0],  # Rmesh.
         description="",
@@ -40,10 +36,6 @@ class OijuWannEPC(ExchangeCL2):
             emin=-15,  # integration lower bound, relative to fermi energy
             emax=0.05,  # integration upper bound. Should be 0 (fermi energy).
             # But DFT codes define Fermi energy in various ways.
-            height=0.5,  # the delta in the (i delta) in green's function.
-            nz1=150,  # grid from emin to emin+(i delta)
-            nz2=300,  # grid from emin +(i delta) to emax+(i delta)
-            nz3=150,  # grid from emax + (i delta) to emax
             exclude_orbs=[],  #
             Rmesh=[0, 0, 0],  # Rmesh.
             description="",

TB2J-0.8.2.8/TB2J/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.8.2.8"

{TB2J-0.8.2.5 → TB2J-0.8.2.8}/TB2J/exchange.py

@@ -26,10 +26,6 @@ class ExchangeParams:
         emax=0.05,
         nz=100,
         # the delta in the (i delta) in green's function to prevent divergence
-        height=0.5,
-        nz1=150,  # grid from emin to emin+(i delta)
-        nz2=300,  # grid from emin +(i delta) to emax+(i delta)
-        nz3=150,  # grid from emax + (i delta) to emax
         exclude_orbs=[],  #
         ne=None,  # number of electrons in Wannier function.
         Rcut=None,  # Rcut.
@@ -44,12 +40,6 @@ class ExchangeParams:
         self.emin = emin
         self.emax = emax
         self.nz = nz
-        self.height = height
-        self.nz1 = nz1
-        self.nz2 = nz2
-        self.nz3 = nz3
-        if nz is None:
-            self.nz = nz1 + nz2 + nz3
         self.Rcut = Rcut
         self.basis = basis
         self.magnetic_elements = magnetic_elements
@@ -81,10 +71,6 @@ class Exchange(ExchangeParams):
         emax=0.05,
         nz=100,
         # the delta in the (i delta) in green's function to prevent divergence
-        height=0.5,
-        nz1=150,  # grid from emin to emin+(i delta)
-        nz2=300,  # grid from emin +(i delta) to emax+(i delta)
-        nz3=150,  # grid from emax + (i delta) to emax
         exclude_orbs=[],  #
         ne=None,  # number of electrons in Wannier function.
         Rcut=None,  # Rcut.
@@ -105,10 +91,6 @@ class Exchange(ExchangeParams):
             emin=emin,
             emax=emax,
             nz=nz,
-            height=height,
-            nz1=nz1,
-            nz2=nz2,
-            nz3=nz3,
             exclude_orbs=exclude_orbs,
             ne=ne,
             Rcut=Rcut,
@@ -164,11 +146,11 @@ class Exchange(ExchangeParams):
          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
-            )
-        elif method.lower() == "semicircle":
+        # 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)
@@ -362,7 +344,8 @@ class ExchangeNCL(Exchange):
         )
         self.norb = self.G.norb
         self.nbasis = self.G.nbasis
-        self.rho = np.zeros((self.nbasis, self.nbasis), dtype=complex)
+        # self.rho = np.zeros((self.nbasis, self.nbasis), dtype=complex)
+        self.rho = self.G.get_density_matrix().real
         self.A_ijR_list = defaultdict(lambda: [])
         self.A_ijR = defaultdict(lambda: np.zeros((4, 4), dtype=complex))
         self.A_ijR_orb = dict()
@@ -595,22 +578,22 @@ class ExchangeNCL(Exchange):
                 B = np.imag(val[3, 3])
                 self.B[keyspin] = Jprime, B
 
-    def get_N_e(self, GR, de):
-        """
-        calcualte density matrix for all R,i, j
-        """
-        self.N = defaultdict(lambda: 0.0)
-        for R, G in GR.items():
-            self.N[R] += -1.0 / np.pi * np.imag(G * de)
+    # def get_N_e(self, GR, de):
+    #    """
+    #    calcualte density matrix for all R,i, j
+    #    """
+    #    self.N = defaultdict(lambda: 0.0)
+    #    for R, G in GR.items():
+    #        self.N[R] += -1.0 / np.pi * np.imag(G * de)
 
-    def get_rho_e(self, rhoR):
-        """add component to density matrix from a green's function
-        :param GR: Green's funciton in real space.
-        """
-        return -1.0 / np.pi * rhoR[0, 0, 0]
+    # def get_rho_e(self, rhoR):
+    #    """add component to density matrix from a green's function
+    #    :param GR: Green's funciton in real space.
+    #    """
+    #    return -1.0 / np.pi * rhoR[0, 0, 0]
 
-    def get_total_charges(self):
-        return np.sum(np.imag(np.diag(self.rho)))
+    # def get_total_charges(self):
+    #    return np.sum(np.imag(np.diag(self.rho)))
 
     def get_rho_atom(self):
         """
@@ -623,9 +606,9 @@ class ExchangeNCL(Exchange):
             iorb = self.iorb(iatom)
             tmp = self.rho[np.ix_(iorb, iorb)]
             # *2 because there is a 1/2 in the paui_block_all function
-            rho[iatom] = np.array([np.trace(x) * 2 for x in pauli_block_all(tmp)])
-            self.charges[iatom] = np.imag(rho[iatom][0])
-            self.spinat[iatom, :] = np.imag(rho[iatom][1:])
+            rho[iatom] = np.array([np.trace(x) * 2 for x in pauli_block_all(tmp)]).real
+            self.charges[iatom] = rho[iatom][0]
+            self.spinat[iatom, :] = rho[iatom][1:]
         self.rho_dict = rho
         return self.rho_dict
 
@@ -676,7 +659,7 @@ class ExchangeNCL(Exchange):
         self.Ddict_NJT = Ddict_NJT
         return Ddict_NJT
 
-    def integrate(self, rhoRs, AijRs, AijRs_orb=None, method="simpson"):
+    def integrate(self, AijRs, AijRs_orb=None, method="simpson"):
         """
         AijRs: a list of AijR,
         wherer AijR: array of ((nR, n, n, 4,4), dtype=complex)
@@ -686,7 +669,7 @@ class ExchangeNCL(Exchange):
         elif method == "simpson":
             integrate = simpson_nonuniform
 
-        self.rho = integrate(self.contour.path, rhoRs)
+        # self.rho = integrate(self.contour.path, rhoRs)
         for iR, R in enumerate(self.R_ijatom_dict):
             for iatom, jatom in self.R_ijatom_dict[R]:
                 f = AijRs[(R, iatom, jatom)]
@@ -696,10 +679,10 @@ class ExchangeNCL(Exchange):
                         self.contour.path, AijRs_orb[(R, iatom, jatom)]
                     )
 
-    def get_AijR_rhoR(self, e):
-        GR, rhoR = self.G.get_GR(self.short_Rlist, energy=e, get_rho=True)
+    def get_AijR(self, e):
+        GR = self.G.get_GR(self.short_Rlist, energy=e, get_rho=False)
         AijR, AijR_orb = self.get_all_A(GR)
-        return AijR, AijR_orb, self.get_rho_e(rhoR)
+        return AijR, AijR_orb
 
     def save_AijR(self, AijRs, fname):
         result = dict(path=self.contour.path, AijRs=AijRs)
@@ -717,7 +700,6 @@ class ExchangeNCL(Exchange):
         """
         print("Green's function Calculation started.")
 
-        rhoRs = []
         AijRs = {}
 
         AijRs_orb = {}
@@ -726,11 +708,9 @@ class ExchangeNCL(Exchange):
 
         npole = len(self.contour.path)
         if self.np > 1:
-            # executor = ProcessPool(nodes=self.np)
-            # results = executor.map(self.get_AijR_rhoR, self.contour.path)
-            results = p_map(self.get_AijR_rhoR, self.contour.path, num_cpus=self.np)
+            results = p_map(self.get_AijR, self.contour.path, num_cpus=self.np)
         else:
-            results = map(self.get_AijR_rhoR, tqdm(self.contour.path, total=npole))
+            results = map(self.get_AijR, tqdm(self.contour.path, total=npole))
 
         for i, result in enumerate(results):
             for iR, R in enumerate(self.R_ijatom_dict):
@@ -750,7 +730,6 @@ class ExchangeNCL(Exchange):
                             AijRs_orb[(R, iatom, jatom)].append(
                                 result[1][R, iatom, jatom]
                             )
-            rhoRs.append(result[2])
         if self.np > 1:
             # executor.close()
             # executor.join()
@@ -758,8 +737,7 @@ class ExchangeNCL(Exchange):
             pass
 
         # self.save_AijRs(AijRs)
-        self.integrate(rhoRs, AijRs, AijRs_orb)
-
+        self.integrate(AijRs, AijRs_orb)
         self.get_rho_atom()
         self.A_to_Jtensor()
         self.A_to_Jtensor_orb()

{TB2J-0.8.2.5 → TB2J-0.8.2.8}/TB2J/exchangeCL2.py

@@ -42,10 +42,10 @@ class ExchangeCL2(ExchangeCL):
             )
         self.norb = self.Gup.norb
         self.nbasis = self.Gup.nbasis + self.Gdn.nbasis
-        self.rho_up_list = []
-        self.rho_dn_list = []
-        self.rho_up = np.zeros((self.norb, self.norb), dtype=float)
-        self.rho_dn = np.zeros((self.norb, self.norb), dtype=float)
+        # self.rho_up_list = []
+        # self.rho_dn_list = []
+        self.rho_up = self.Gup.get_density_matrix()
+        self.rho_dn = self.Gdn.get_density_matrix()
         self.Jorb_list = defaultdict(lambda: [])
         self.JJ_list = defaultdict(lambda: [])
         self.JJ = defaultdict(lambda: 0.0j)
@@ -225,8 +225,6 @@ class ExchangeCL2(ExchangeCL):
             integrate = trapezoidal_nonuniform
         elif method == "simpson":
             integrate = simpson_nonuniform
-        self.rho_up = np.imag(integrate(self.contour.path, self.rho_up_list))
-        self.rho_dn = np.imag(integrate(self.contour.path, self.rho_dn_list))
         for R, ijpairs in self.R_ijatom_dict.items():
             for iatom, jatom in ijpairs:
                 self.Jorb[(R, iatom, jatom)] = integrate(
@@ -236,12 +234,11 @@ class ExchangeCL2(ExchangeCL):
                     self.contour.path, self.JJ_list[(R, iatom, jatom)]
                 )
 
-    def get_AijR_rhoR(self, e):
-        GR_up, rho_up = self.Gup.get_GR(self.short_Rlist, energy=e, get_rho=True)
-        GR_dn, rho_dn = self.Gdn.get_GR(self.short_Rlist, energy=e, get_rho=True)
-        rup, rdn = self.get_rho_e(rho_up, rho_dn)
+    def get_AijR(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 rup, rdn, Jorb_list, JJ_list
+        return Jorb_list, JJ_list
 
     def calculate_all(self):
         """
@@ -251,15 +248,13 @@ class ExchangeCL2(ExchangeCL):
 
         npole = len(self.contour.path)
         if self.np == 1:
-            results = map(self.get_AijR_rhoR, tqdm(self.contour.path, total=npole))
+            results = map(self.get_AijR, 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_rhoR, self.contour.path, num_cpus=self.np)
+            results = p_map(self.get_AijR, self.contour.path, num_cpus=self.np)
         for i, result in enumerate(results):
-            rup, rdn, Jorb_list, JJ_list = result
-            self.rho_up_list.append(rup)
-            self.rho_dn_list.append(rdn)
+            Jorb_list, JJ_list = result
             for iR, R in enumerate(self.R_ijatom_dict):
                 for iatom, jatom in self.R_ijatom_dict[R]:
                     key = (R, iatom, jatom)

{TB2J-0.8.2.5 → TB2J-0.8.2.8}/TB2J/exchange_pert.py

@@ -194,7 +194,7 @@ class ExchangePert(ExchangeNCL):
             e = self.contour.elist[ie]
             de = self.contour.de[ie]
             GR, dGdx = self.G.get_GR_and_dGRdx(self.Rlist, energy=e, dHdx=self.dHdx)
-            self.get_rho_e(GR, de)
+            # self.get_rho_e(GR, de)
             self.get_all_A(GR, dGdx, de)
             if self.calc_NJt:
                 self.get_N_e(GR, de)

{TB2J-0.8.2.5 → TB2J-0.8.2.8}/TB2J/green.py

@@ -225,12 +225,22 @@ class TBGreen:
 
     def get_density_matrix(self):
         rho = np.zeros((self.nbasis, self.nbasis), dtype=complex)
-        for ik, _ in enumerate(self.kpts):
-            rho += (
-                (self.get_evecs(ik) * fermi(self.evals[ik], self.efermi))
-                @ self.get_evecs(ik).T.conj()
-                * self.kweights[ik]
-            )
+        if self.is_orthogonal:
+            for ik, _ in enumerate(self.kpts):
+                rho += (
+                    (self.get_evecs(ik) * fermi(self.evals[ik], self.efermi))
+                    @ self.get_evecs(ik).T.conj()
+                    * self.kweights[ik]
+                )
+        else:
+            for ik, _ in enumerate(self.kpts):
+                rho += (
+                    (self.get_evecs(ik) * fermi(self.evals[ik], self.efermi))
+                    @ self.get_evecs(ik).T.conj()
+                    @ self.get_Sk(ik)
+                    * self.kweights[ik]
+                )
+
         return rho
 
     def get_rho_R(self, Rlist):
@@ -238,9 +248,6 @@ class TBGreen:
         rho_R = np.zeros((nR, self.nbasis, self.nbasis), dtype=complex)
         for ik, kpt in enumerate(self.kpts):
             evec = self.get_evecs(ik)
-            # rhok=(evec * fermi(self.evals[ik], self.efermi)
-            #        ) @ evec.T.conj()
-            # print(fermi(self.evals[ik] , self.efermi))
             rhok = np.einsum(
                 "ib,b, bj-> ij", evec, fermi(self.evals[ik], self.efermi), evec.conj().T
             )

{TB2J-0.8.2.5 → TB2J-0.8.2.8}/TB2J/manager.py

@@ -27,10 +27,6 @@ def gen_exchange(
     emin=-12.0,
     emax=0.0,
     nz=100,
-    height=0.2,
-    nz1=50,
-    nz2=200,
-    nz3=50,
     exclude_orbs=[],
     Rcut=None,
     ne=None,
@@ -113,10 +109,6 @@ Warning: Please check if the noise level of Wannier function Hamiltonian to make
                 emin=emin,
                 emax=emax,
                 nz=nz,
-                height=height,
-                nz1=nz1,
-                nz2=nz2,
-                nz3=nz3,
                 exclude_orbs=exclude_orbs,
                 Rcut=Rcut,
                 ne=ne,
@@ -137,10 +129,6 @@ Warning: Please check if the noise level of Wannier function Hamiltonian to make
                 emin=emin,
                 emax=emax,
                 nz=nz,
-                height=height,
-                nz1=nz1,
-                nz2=nz2,
-                nz3=nz3,
                 exclude_orbs=exclude_orbs,
                 Rcut=Rcut,
                 ne=ne,
@@ -185,10 +173,6 @@ Warning: Please check if the noise level of Wannier function Hamiltonian to make
             emin=emin,
             emax=emax,
             nz=nz,
-            height=height,
-            nz1=nz1,
-            nz2=nz2,
-            nz3=nz3,
             exclude_orbs=exclude_orbs,
             Rcut=Rcut,
             ne=ne,
@@ -237,10 +221,6 @@ Warning: Please check if the noise level of Wannier function Hamiltonian to make
             emin=emin,
             emax=emax,
             nz=nz,
-            height=height,
-            nz1=nz1,
-            nz2=nz2,
-            nz3=nz3,
             exclude_orbs=exclude_orbs,
             Rcut=Rcut,
             ne=ne,

TB2J-0.8.2.8/TB2J/spinham/h_matrix.py

@@ -0,0 +1,68 @@
+import numpy as np
+import matplotlib.pyplot as plt
+import aiida
+from aiida_tb2j.data import ExchangeData
+
+def plot_dispersion(bands, kpoint_labels, color='blue', title=None):
+
+    fig, axs = plt.subplots(1, 1, constrained_layout=True)
+    fig.set_size_inches(6, 6/1.618)
+
+    '''
+    Plot the bands
+    '''
+    kpoints = np.arange(len(bands))
+    axs.plot(kpoints, bands, color=color, linewidth=1.5)
+
+    '''
+    Plot the symmetry points
+    '''
+    bmin = bands.min(); bmax = bands.max()
+    ymin = bmin - 0.05*np.abs(bmin-bmax); ymax = bmax + 0.05*np.abs(bmax-bmin);
+    axs.set_xticks(kpoint_labels[0], kpoint_labels[1], fontsize=10)
+    axs.vlines(x=kpoint_labels[0], ymin=ymin, ymax=ymax, color='black', linewidth=0.5)
+    axs.set_xlim([0, len(kpoints)])
+    axs.set_ylim([ymin, ymax])
+
+    if title is not None:
+        plt.title(title, fontsize=10)
+
+    plt.show()
+
+
+if __name__ == "__main__":
+    
+    from argparse import ArgumentParser
+
+    parser = ArgumentParser()
+    parser.add_argument('-f', '--pickle_filename', type=str, help="Path of the 'TB2J.pickle' file.", required=True)
+    args = parser.parse_args()
+    
+    '''
+    Right now the implementation depends on AiiDA and so we must create and load an AiiDA profile,
+    even if we do not store any information on a data base.
+    '''
+    aiida.load_profile()
+    '''
+    Create an ExchangeData object with the informations from the TB2J.pickle file
+    '''
+    exchange = ExchangeData.load_tb2j(pickle_file=args.pickle_filename, isotropic=False, pbc=(True, True, True))
+    '''
+    Compute the magnon band structure along a high symmetry path generated with
+    the ASE package. The informations is stored in an AiiDA BandsData object.
+    Here tol is the symmetry tolerance to determine the space group of the system.
+    They are in units of eV
+    '''
+    magnon_data = exchange.get_magnon_bands(npoints=300, tol=1e-1, with_DMI=True, with_Jani=True)
+    magnon_bands = 1000*magnon_data.get_bands() # Convert to meV
+    raw_labels = [(k, '$\Gamma$') if s == 'GAMMA' else (k, s) for k, s in magnon_data.labels]
+    kpoint_labels = list( zip( *raw_labels ) )
+    plot_dispersion(magnon_bands, kpoint_labels, color='blue', title='Magnon Bands')
+    '''
+    We can also obtain the dynamical matrix h instead of the actual magnon bands. The result
+    is stored in a numpy array with shape (number of kpoints, 2*natoms, 2*natoms)
+    '''
+    kpoints = magnon_data.get_kpoints() # The shape of the kpoints must be (nkpoints, 3)
+    h_matrix = 1000*exchange._H_matrix(kpoints, with_DMI=True, with_Jani=True) # Convert to meV
+    h_dispersion = np.linalg.eigvalsh(h_matrix) # We can also get the eigenvectors with np.linalg.eigh
+    plot_dispersion(h_dispersion, kpoint_labels, color='red', title='h matrix dispersion')

TB2J-0.8.2.8/TB2J/spinham/obtain_J.py

@@ -0,0 +1,79 @@
+import numpy as np
+from aiida_tb2j.data import ExchangeData
+from aiida_tb2j.data.exchange import get_rotation_arrays
+from itertools import combinations_with_replacement
+
+ux, uy, uz = np.eye(3).reshape((3, 1, 3))
+
+def combine_arrays(u, v):
+
+    return np.concatenate([u*v, np.roll(u, -1, axis=-1)*v, np.roll(v, -1, axis=-1)*u], axis=-1)
+
+def get_coefficients(magmoms, indices):
+
+    i, j = indices
+
+    U, V = zip(*[get_rotation_arrays(magmoms, u=u) for u in [ux, uy, uz]])
+    U = np.stack(U).swapaxes(0, 1)
+    V = np.stack(V).swapaxes(0, 1)
+
+    uc = combine_arrays(U[i], U[j].conj())
+    ur = combine_arrays(U[i], U[j])
+    uc2 = combine_arrays(U[i].conj(), U[j])
+    u = np.concatenate([uc, ur, uc2], axis=1)
+
+    return u, V
+
+def get_C(H0, u, V):
+
+    n = int(H0.shape[-1]/2)
+    upi = np.triu_indices(n)
+    dig = np.diag_indices(n)
+    
+    i, j = upi
+    AB0 = H0[:, [i, i, i+n], [j, j+n, j+n]]
+    AB0 = np.swapaxes(AB0, 0, 2).reshape(len(i), 9)
+    J0_flat = np.linalg.solve(u, AB0)
+
+    J0 = np.empty((n, n, 3, 3), dtype=complex)
+    J0[*upi] = J0_flat[:, [0, 6, 5, 3, 1, 7, 8, 4, 2]].reshape(-1, 3, 3)
+    J0 += J0.swapaxes(0, 1)
+    J0[*dig] = 0.0
+
+    C = np.array([np.diag(a) for a in np.einsum('imx,ijxy,jmy->mi', V, 2*J0, V)]) 
+
+    return C
+
+def get_J(H, kpoints, exchange):
+
+    n = int(H.shape[-1]/2)
+    upi = np.triu_indices(n)
+    dig = np.diag_indices(n)
+    i, j = upi
+
+    magmoms = exchange.magmoms()[np.unique(exchange.pairs)]
+    magmoms /= np.linalg.norm(magmoms, axis=-1).reshape(-1, 1)
+    u, V = get_coefficients(magmoms, indices=upi)
+
+    H0 = np.stack([1000*exchange._H_matrix(kpoints=np.zeros((1, 3)), with_DMI=True, with_Jani=True, u=u) for u in [ux, uy, uz]])[:, 0, :, :]
+    C = get_C(H0, u, V)
+    H[:, :, :n, :n] += C.reshape(3, 1, n, n)
+    H[:, :, n:, n:] += C.reshape(3, 1, n, n)
+
+    AB = H[:, :, [i, i, i+n], [j, j+n, j+n]]
+    AB[:, :, 2, :] = AB[:, ::-1, 2, :]
+    AB = np.moveaxis(AB, [2, 3], [1, 0]).reshape(len(i), 9, -1)
+
+    vectors = exchange.get_vectors()
+    exp_summand = np.exp( -2j*np.pi*vectors @ kpoints.T )
+    nAB = np.einsum('nik,ndk->nid', AB, exp_summand) / len(kpoints)
+    
+    ii = np.where(i == j)
+    i0 = np.where(np.linalg.norm(vectors, axis=-1) == 0.0)
+    J = np.linalg.solve(u, nAB).swapaxes(1, 2)
+    J = J[:, :, [0, 6, 5, 3, 1, 7, 8, 4, 2]].reshape(len(i), -1, 3, 3)
+    J *= -1
+    J[ii] *= 2
+    J[i0] *= 0
+
+    return J

{TB2J-0.8.2.5 → TB2J-0.8.2.8}/TB2J.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: TB2J
-Version: 0.8.2.5
+Version: 0.8.2.8
 Summary: TB2J: First principle to Heisenberg exchange J using tight-binding Green function method
 Home-page: UNKNOWN
 Author: Xu He

{TB2J-0.8.2.5 → TB2J-0.8.2.8}/TB2J.egg-info/SOURCES.txt

@@ -58,8 +58,10 @@ TB2J/io_exchange/io_vampire.py
 TB2J/spinham/__init__.py
 TB2J/spinham/base_parser.py
 TB2J/spinham/constants.py
+TB2J/spinham/h_matrix.py
 TB2J/spinham/hamiltonian.py
 TB2J/spinham/hamiltonian_terms.py
+TB2J/spinham/obtain_J.py
 TB2J/spinham/plot.py
 TB2J/spinham/qsolver.py
 TB2J/spinham/spin_api.py

{TB2J-0.8.2.5 → TB2J-0.8.2.8}/scripts/siesta2J.py

@@ -54,19 +54,9 @@ def run_siesta2J():
         action="store_true",
         default=False,
     )
-    # parser.add_argument(
-    #    '--height',
-    #    help=
-    #    'energy contour, a small number (often between 0.1 to 0.5, default 0.2)',
-    #    type=float,
-    #    default=0.1)
     parser.add_argument(
         "--nz", help="number of integration steps. Default: 50", default=50, type=int
     )
-    # parser.add_argument(
-    #    '--nz2', help='number of steps 2, default: 200', default=200, type=int)
-    # parser.add_argument(
-    #    '--nz3', help='number of steps 3, default: 50', default=50, type=int)
     parser.add_argument(
         "--cutoff",
         help="The minimum of J amplitude to write, (in eV). Default: 1e-5 eV",

{TB2J-0.8.2.5 → TB2J-0.8.2.8}/scripts/wann2J.py

@@ -86,24 +86,6 @@ def run_wann2J():
         default=100,
         type=int,
     )
-    # parser.add_argument(
-    #    '--height',
-    #    help=
-    #    'energy contour, a small number (often between 0.1 to 0.5, default 0.1)',
-    #    type=float,
-    #    default=0.1)
-    # parser.add_argument('--nz1',
-    #                    help='number of steps 1, default: 50',
-    #                    default=50,
-    #                    type=int)
-    # parser.add_argument('--nz2',
-    #                    help='number of steps 2, default: 200',
-    #                    default=200,
-    #                    type=int)
-    # parser.add_argument('--nz3',
-    #                    help='number of steps 3, default: 50',
-    #                    default=50,
-    #                    type=int)
     parser.add_argument(
         "--cutoff",
         help="The minimum of J amplitude to write, (in eV), default is 1e-5 eV",
@@ -196,10 +178,6 @@ def run_wann2J():
         emin=args.emin,
         emax=args.emax,
         nz=args.nz,
-        # height=args.height,
-        # nz1=args.nz1,
-        # nz2=args.nz2,
-        # nz3=args.nz3,
         use_cache=args.use_cache,
         np=args.np,
         description=args.description,

{TB2J-0.8.2.5 → TB2J-0.8.2.8}/setup.py

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

TB2J-0.8.2.5/TB2J/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.8.2.5"