TB2J 0.9.9.9__tar.gz → 0.9.9.12__tar.gz

{tb2j-0.9.9.9 → tb2j-0.9.9.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: TB2J
-Version: 0.9.9.9
+Version: 0.9.9.12
 Summary: TB2J: First principle to Heisenberg exchange J using tight-binding Green function method
 Author: Xu He
 Author-email: mailhexu@gmail.com
@@ -21,10 +21,12 @@ Requires-Dist: ase>=3.19
 Requires-Dist: tqdm
 Requires-Dist: pathos
 Requires-Dist: packaging>=20.0
-Requires-Dist: HamiltonIO>=0.2.3
+Requires-Dist: HamiltonIO>=0.2.4
 Requires-Dist: pre-commit
 Requires-Dist: sympair>0.1.0
 Requires-Dist: sisl>=0.9.0
+Requires-Dist: tomli>=2.0.0
+Requires-Dist: tomli-w>=1.0.0
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

{tb2j-0.9.9.9 → tb2j-0.9.9.12}/TB2J/Jtensor.py

@@ -71,22 +71,21 @@ def decompose_J_tensor(Jtensor):
     return Jiso, D, Jani
 
 
-def combine_J_tensor(Jiso=0.0, D=np.zeros(3), Jani=np.zeros((3, 3), dtype=float)):
+def combine_J_tensor(Jiso=None, D=None, Jani=None, dtype=float):
     """Combine isotropic exchange, DMI, and anisotropic exchange into tensor form
-
     :param Jiso: scalar, isotropice exchange
     :param D: vector, DMI.
     :param Jani: 3x3 matrix anisotropic exchange
     :returns:  A 3x3 matrix, the exchange paraemter in tensor form.
     """
-    Jtensor = np.zeros((3, 3), dtype=complex)
+    Jtensor = np.zeros((3, 3), dtype=dtype)
     if Jiso is not None:
-        Jtensor += np.eye(3, dtype=float) * Jiso
+        Jtensor += np.eye(3, dtype=dtype) * Jiso
     if Jani is not None:
-        Jtensor += np.array(Jani, dtype=float)
+        Jtensor += np.array(Jani, dtype=dtype)
     if D is not None:
         Jtensor += np.array(
-            [[0, D[2], -D[1]], [-D[2], 0, D[0]], [D[1], -D[0], 0]], dtype=float
+            [[0, D[2], -D[1]], [-D[2], 0, D[0]], [D[1], -D[0], 0]], dtype=dtype
         )
     return Jtensor
 

{tb2j-0.9.9.9 → tb2j-0.9.9.12}/TB2J/MAEGreen.py

@@ -43,6 +43,8 @@ class MAEGreen(ExchangeNCL):
             self.set_angles_random()
         elif angles == "miller":
             self.set_angles_miller()
+        elif angles == "ztox":
+            self.set_angels_ztox()
         else:
             self.thetas = angles[0]
             self.phis = angles[1]
@@ -92,6 +94,12 @@ class MAEGreen(ExchangeNCL):
                 self.thetas.append(i * np.pi / 180)
                 self.phis.append(j * np.pi / 180)
 
+    def set_angels_ztox(self, n=16):  
+        """Set angles for a scan from z to x"""
+        self.thetas = np.linspace(0, np.pi, n)
+        self.phis = np.zeros(n)
+
+
     def set_angles_random(self, n=16):
         # n random pairs of theta, phi
         self.thetas = np.random.random(n) * np.pi

tb2j-0.9.9.12/TB2J/__init__.py

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

{tb2j-0.9.9.9 → tb2j-0.9.9.12}/TB2J/exchange.py

@@ -48,7 +48,7 @@ class Exchange(ExchangeParams):
         self.emin = self.G.find_energy_ingap(rbound=self.efermi - 15.0) - self.efermi
         # self.emin = self.G.find_energy_ingap(rbound=self.efermi - 15.0) - self.efermi
         # self.emin = -42.0
-        print(f"A gap is found at {self.emin}, set emin to it.")
+        #print(f"A gap is found at {self.emin}, set emin to it.")
 
     def set_tbmodels(self, tbmodels):
         pass

{tb2j-0.9.9.9 → tb2j-0.9.9.12}/TB2J/interfaces/abacus/stru_api.py

@@ -7,11 +7,13 @@
 Modified on Wed Aug 01 11:44:51 2022
 @author: Ji Yu-yang
 """
+import warnings
+warnings.simplefilter(action='ignore', category=FutureWarning)
+
 
 import os
 import re
 import shutil
-import warnings
 from pathlib import Path
 
 import numpy as np

{tb2j-0.9.9.9 → tb2j-0.9.9.12}/TB2J/interfaces/siesta_interface.py

@@ -157,7 +157,7 @@ Warning: The DMI component parallel to the spin orientation, the Jani which has
                 atoms=model.atoms,
                 basis=basis,
                 efermi=None,
-                angles="axis",
+                angles="xyz",
                 # magnetic_elements=magnetic_elements,
                 # include_orbs=include_orbs,
                 **exargs,
@@ -165,6 +165,7 @@ Warning: The DMI component parallel to the spin orientation, the Jani which has
             # thetas = [0, np.pi / 2, np.pi, 3 * np.pi / 2]
             # phis = [0, 0, 0, 0]
             # MAE.set_angles(thetas=thetas, phis=phis)
+            #MAE.set_xyz_angles()
             MAE.run(output_path=f"{output_path}_anisotropy", with_eigen=False)
             # print(
             #    f"MAE calculation finished. The results are in {output_path} directory."

{tb2j-0.9.9.9 → tb2j-0.9.9.12}/TB2J/io_exchange/io_exchange.py

@@ -54,6 +54,7 @@ class SpinIO(object):
         gyro_ratio=None,
         write_experimental=True,
         description=None,
+        standardize_Jani=False,
     ):
         """
         :param atoms: Ase atoms structure.
@@ -190,6 +191,7 @@ Generation time: {now.strftime("%y/%m/%d %H:%M:%S")}
     def _build_Rlist(self):
         Rset = set()
         ispin_set = set()
+        Rset.add((0, 0, 0))  # always add the zero vector
         for R, i, j in self.exchange_Jdict:
             Rset.add(R)
             ispin_set.add(i)
@@ -236,6 +238,23 @@ Generation time: {now.strftime("%y/%m/%d %H:%M:%S")}
         i = self.i_spin(i)
         return self.charges[self.iatom(i)]
 
+    def get_magnetic_moments(self):
+        """Get magnetic moments for magnetic atoms only.
+
+        Returns
+        -------
+        np.ndarray
+            Array of shape (n_magnetic_atoms, 3) containing the magnetic moments.
+            For collinear calculations, only the z component is meaningful.
+        """
+        mag_atoms = [i for i, idx in enumerate(self.index_spin) if idx >= 0]
+        if self.spinat.ndim == 1:  # Handle collinear case with only z-component
+            moments = np.zeros((len(mag_atoms), 3))
+            moments[:, 2] = self.spinat[mag_atoms]
+            return moments
+        else:  # Full 3D magnetic moments
+            return self.spinat[mag_atoms]
+
     def get_spin_iatom(self, iatom):
         return self.spinat[iatom]
 
@@ -289,7 +308,7 @@ Generation time: {now.strftime("%y/%m/%d %H:%M:%S")}
             j,
         )
         if self.dmi_ddict is not None and key in self.dmi_ddict:
-            return np.real(self.dmi_ddict[(tuple(R), i, j)])
+            return self.dmi_ddict[(tuple(R), i, j)]
         else:
             return default
 
@@ -308,11 +327,11 @@ Generation time: {now.strftime("%y/%m/%d %H:%M:%S")}
             j,
         )
         if self.Jani_dict is not None and key in self.Jani_dict:
-            return np.real(self.Jani_dict[(tuple(R), i, j)])
+            return self.Jani_dict[(tuple(R), i, j)]
         else:
             return default
 
-    def get_J_tensor(self, i, j, R, iso_only=False):
+    def get_J_tensor(self, i, j, R, Jiso=True, Jani=False, DMI=False):
         """
         Return the full exchange tensor for atom i and j, and cell R.
         param i : spin index i
@@ -321,21 +340,35 @@ Generation time: {now.strftime("%y/%m/%d %H:%M:%S")}
         """
         i = self.i_spin(i)
         j = self.i_spin(j)
-        if iso_only:
-            J = self.get_Jiso(i, j, R)
-            if J is not None:
-                Jtensor = np.eye(3) * self.get_J(i, j, R)
-            else:
-                Jtensor = np.eye(3) * 0
-        else:
-            Jtensor = combine_J_tensor(
-                Jiso=self.get_J(i, j, R),
-                D=self.get_DMI(i, j, R),
-                Jani=self.get_Jani(i, j, R),
-            )
+        J=D=Ja = None
+        if Jiso:
+            J= self.get_Jiso(i, j, R)
+        if DMI:
+            D = self.get_DMI(i, j, R)
+            if D is not None:
+                D*=1
+        if Jani:
+            Ja = self.get_Jani(i, j, R)
+            if Ja is not None:
+                Ja*=1
+        Jtensor = combine_J_tensor(Jiso=J, D=D, Jani=Ja)
+
+
+        # if iso_only:
+        #    J = self.get_Jiso(i, j, R)
+        #    if J is not None:
+        #        Jtensor = np.eye(3) * self.get_J(i, j, R)
+        #    else:
+        #        Jtensor = np.eye(3) * 0
+        # else:
+        #    Jtensor = combine_J_tensor(
+        #        Jiso=self.get_J(i, j, R),
+        #        D=self.get_DMI(i, j, R),
+        #        Jani=self.get_Jani(i, j, R),
+        #    )
         return Jtensor
 
-    def get_full_Jtensor_for_one_R_i3j3(self, R, iso_only=False):
+    def get_full_Jtensor_for_one_R_i3j3(self, R, Jiso=True, Jani=True, DMI=True):
         """
         Return the full exchange tensor of all i and j for cell R.
         param R (tuple of integers): cell index R
@@ -347,11 +380,11 @@ Generation time: {now.strftime("%y/%m/%d %H:%M:%S")}
         for i in range(self.nspin):
             for j in range(self.nspin):
                 Jmat[i * 3 : i * 3 + 3, j * 3 : j * 3 + 3] = self.get_J_tensor(
-                    i, j, R, iso_only=iso_only
+                    i, j, R, Jiso=Jiso, Jani=Jani, DMI=DMI
                 )
         return Jmat
 
-    def get_full_Jtensor_for_one_R_ij33(self, R, iso_only=False):
+    def get_full_Jtensor_for_one_R_ij33(self, R, Jiso=True, Jani=True, DMI=True):
         """
         Return the full exchange tensor of all i and j for cell R.
         param R (tuple of integers): cell index R
@@ -362,27 +395,36 @@ Generation time: {now.strftime("%y/%m/%d %H:%M:%S")}
         Jmat = np.zeros((n, n, 3, 3), dtype=float)
         for i in range(self.nspin):
             for j in range(self.nspin):
-                Jmat[i, j, :, :] = self.get_J_tensor(i, j, R, iso_only=iso_only)
+                Jmat[i, j, :, :] = self.get_J_tensor(
+                    i, j, R, Jiso=Jiso, Jani=Jani, DMI=DMI
+                )
         return Jmat
 
-    def get_full_Jtensor_for_Rlist(self, asr=False, iso_only=True, order="i3j3"):
+    def get_full_Jtensor_for_Rlist(
+        self, asr=False, Jiso=True, Jani=True, DMI=True, order="i3j3"
+    ):
         n = self.nspin
         n3 = n * 3
         nR = len(self.Rlist)
         if order == "i3j3":
             Jmat = np.zeros((nR, n3, n3), dtype=float)
             for iR, R in enumerate(self.Rlist):
-                Jmat[iR] = self.get_full_Jtensor_for_one_R_i3j3(R, iso_only=iso_only)
+                Jmat[iR] = self.get_full_Jtensor_for_one_R_i3j3(
+                    R, Jiso=Jiso, Jani=Jani, DMI=DMI
+                )
             if asr:
                 iR0 = np.argmin(np.linalg.norm(self.Rlist, axis=1))
                 assert np.linalg.norm(self.Rlist[iR0]) == 0
                 for i in range(n3):
                     sum_JRi = np.sum(np.sum(Jmat, axis=0)[i])
-                    Jmat[iR0][i, i] -= sum_JRi
+                    Jmat[iR0][i, :, i, :] -= sum_JRi
 
         elif order == "ij33":
             Jmat = np.zeros((nR, n, n, 3, 3), dtype=float)
-            Jmat[iR] = self.get_full_Jtensor_for_one_R_ij33(R, iso_only=iso_only)
+            for iR, R in enumerate(self.Rlist):
+                Jmat[iR] = self.get_full_Jtensor_for_one_R_ij33(
+                    R, Jiso=Jiso, Jani=Jani, DMI=DMI
+                )
             if asr:
                 iR0 = np.argmin(np.linalg.norm(self.Rlist, axis=1))
                 assert np.linalg.norm(self.Rlist[iR0]) == 0

{tb2j-0.9.9.9 → tb2j-0.9.9.12}/TB2J/io_exchange/io_vampire.py

@@ -1,5 +1,6 @@
-import numpy as np
 import os
+
+import numpy as np
 from ase.units import J
 
 
@@ -51,10 +52,12 @@ def write_vampire_unitcell_file(cls, fname):
             R, ispin, jspin = key
             Jtensor = cls.get_J_tensor(ispin, jspin, R)
             counter += 1  # starts at 0
-            myfile.write(f"{counter:5d} {ispin:3d} {jspin:3d} {R[0]:3d} {R[1]:3d} {R[2]:3d} ")
+            myfile.write(
+                f"{counter:5d} {ispin:3d} {jspin:3d} {R[0]:3d} {R[1]:3d} {R[2]:3d} "
+            )
             for i in range(3):
                 for j in range(3):
-                    val =np.real(Jtensor[i,j]*2.0/J)
+                    val = np.real(Jtensor[i, j] * 2.0 / J)
                     if np.abs(val) < 1e-30:
                         val = 0.0
                     myfile.write(f"{val:<012.5e} ")

{tb2j-0.9.9.9 → tb2j-0.9.9.12}/TB2J/io_merge.py

@@ -92,7 +92,6 @@ class Merger():
         self._set_projv()
         
     def _set_projv(self):
-
         cell = self.main_dat.atoms.cell.array
         rotated_cells = np.stack(
             [obj.atoms.cell.array for obj in self.dat], axis=0
@@ -175,11 +174,26 @@ class Merger():
                 dmi_ddict[key] = newDMI
             self.main_dat.dmi_ddict = dmi_ddict
 
+    def standardize(self):
+        # make sure that the Jani has the trace of zero
+        Jdict=self.main_dat.exchange_Jdict
+        Jani_dict=self.main_dat.Jani_dict
+        for key in self.main_dat.Jani_dict.keys():
+            Jani = self.main_dat.Jani_dict[key]
+            shift = np.trace(Jani)/3.0
+            Jani_dict[key]  -= shift * np.eye(3)
+            Jdict[key] += shift
+        self.main_dat.Jani_dict = Jani_dict
+        self.main_dat.exchange_Jdict = Jdict
+        
+
 def merge(*paths, main_path=None, save=True, write_path='TB2J_results'):
     m = Merger(*paths, main_path=main_path)
     m.merge_Jiso()
     m.merge_DMI()
     m.merge_Jani()
+    m.standardize()
+
     if save:
         m.main_dat.write_all(path=write_path)
     return m.dat

tb2j-0.9.9.12/TB2J/magnon/__init__.py

@@ -0,0 +1,3 @@
+# from .io_exchange2 import ExchangeIO, plot_tb2j_magnon_bands
+
+# __all__ = ["ExchangeIO", "plot_tb2j_magnon_bands"]