TB2J 0.9.9.8__py3-none-any.whl → 0.9.9.10__py3-none-any.whl

TB2J/__init__.py

@@ -1 +1 @@
-__version__ = "0.9.9.8"
+__version__ = "0.9.9.9"

TB2J/io_exchange/io_exchange.py

@@ -190,6 +190,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 +237,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]
 
@@ -263,7 +281,7 @@ Generation time: {now.strftime("%y/%m/%d %H:%M:%S")}
             j,
         )
         if self.exchange_Jdict is not None and key in self.exchange_Jdict:
-            return self.exchange_Jdict[key]
+            return np.real(self.exchange_Jdict[key])
         else:
             return default
 
@@ -276,7 +294,7 @@ Generation time: {now.strftime("%y/%m/%d %H:%M:%S")}
             j,
         )
         if self.exchange_Jdict is not None and key in self.exchange_Jdict:
-            return self.exchange_Jdict[key]
+            return np.real(self.exchange_Jdict[key])
         else:
             return default
 
@@ -289,7 +307,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 self.dmi_ddict[(tuple(R), i, j)]
+            return np.real(self.dmi_ddict[(tuple(R), i, j)])
         else:
             return default
 
@@ -308,11 +326,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 self.Jani_dict[(tuple(R), i, j)]
+            return np.real(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 +339,26 @@ 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),
-            )
+        Jtensor = combine_J_tensor(
+            Jiso=self.get_J(i, j, R) if Jiso else None,
+            D=self.get_DMI(i, j, R) if DMI else None,
+            Jani=self.get_Jani(i, j, R) if Jani else None,
+        )
+        # 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 +370,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 +385,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/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,15 @@ 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} {ispin} {jspin} {R[0]} {R[1]} {R[2]} ")
+            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):
-                    myfile.write(f"{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} ")
             myfile.write("\n")
 
 

TB2J/magnon/__init__.py

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