TB2J 0.9.12.18__py3-none-any.whl → 0.9.12.22__py3-none-any.whl

TB2J/io_exchange/io_exchange.py

@@ -55,6 +55,7 @@ class SpinIO(object):
         write_experimental=True,
         description=None,
         standardize_Jani=False,
+        sia_tensor=None,
     ):
         """
         :param atoms: Ase atoms structure.
@@ -80,6 +81,7 @@ class SpinIO(object):
         :param gyro_ratio:  gyromagnetic ratio
         :param write_experimental: write_experimental data to output files
         :param description: add some description into the xml file.
+        :param sia_tensor: single ion anisotropy tensor, dictionary {i: 3x3 tensor}
         """
         self.atoms = atoms  #: atomic structures, ase.Atoms object
         self.index_spin = index_spin
@@ -103,12 +105,10 @@ class SpinIO(object):
                 self._ind_atoms[ispin] = iatom
 
         if exchange_Jdict is not None:
-            self.has_exchange = True  #: whether there is isotropic exchange
             #: The dictionary of :math:`J_{ij}(R)`, the keys are (i,j, R),
             # where R is a tuple, and the value is the isotropic exchange
             self.exchange_Jdict = exchange_Jdict
         else:
-            self.has_exchange = False
             self.exchange_Jdict = None
 
         self.Jiso_orb = Jiso_orb
@@ -120,21 +120,37 @@ class SpinIO(object):
         self.dJdx2 = dJdx2
 
         if dmi_ddict is not None:
-            self.has_dmi = True  #: Whether there is DMI.
             #: The dictionary of DMI. the key is the same as exchange_Jdict, the values are 3-d vectors (Dx, Dy, Dz).
             self.dmi_ddict = dmi_ddict
         else:
-            self.has_dmi = False
             self.dmi_ddict = None
 
         if Jani_dict is not None:
-            self.has_bilinear = True  #: Whether there is anisotropic exchange term
             #: The dictionary of anisotropic exchange. The vlaues are matrices of shape (3,3).
             self.Jani_dict = Jani_dict
         else:
-            self.has_bilinear = False
             self.Jani_dict = None
 
+        if k1 is not None and k1dir is not None:
+            # Convert uniaxial anisotropy to SIA tensor
+            if sia_tensor is None:
+                sia_tensor = {}
+            for i, (K, axis) in enumerate(zip(k1, k1dir)):
+                if abs(K) > 1e-10:
+                    e = np.array(axis)
+                    norm = np.linalg.norm(e)
+                    if norm > 1e-6:
+                        e = e / norm
+                        # A = K * e * e^T
+                        A = K * np.outer(e, e)
+                        if i in sia_tensor:
+                            sia_tensor[i] += A
+                        else:
+                            sia_tensor[i] = A
+            # Clear k1 and k1dir as they are now integrated into sia_tensor
+            k1 = None
+            k1dir = None
+
         if k1 is not None and k1dir is not None:
             self.has_uniaxial_anistropy = True
             self.k1 = k1
@@ -144,14 +160,19 @@ class SpinIO(object):
             self.k1 = None
             self.k1dir = None
 
-        self.has_bilinear = not (Jani_dict == {} or Jani_dict is None)
-
         self.has_biquadratic = not (
             biquadratic_Jdict == {} or biquadratic_Jdict is None
         )
 
         self.biquadratic_Jdict = biquadratic_Jdict
 
+        if sia_tensor is not None:
+            self.has_sia_tensor = True
+            self.sia_tensor = sia_tensor
+        else:
+            self.has_sia_tensor = False
+            self.sia_tensor = None
+
         if NJT_ddict is not None:
             self.has_NJT_dmi = True
         self.NJT_ddict = NJT_ddict
@@ -189,6 +210,18 @@ Generation time: {now.strftime("%y/%m/%d %H:%M:%S")}
         self.orbital_names = orbital_names
         self.TB2J_version = __version__
 
+    @property
+    def has_exchange(self):
+        return self.exchange_Jdict is not None
+
+    @property
+    def has_dmi(self):
+        return self.dmi_ddict is not None
+
+    @property
+    def has_bilinear(self):
+        return self.Jani_dict is not None
+
     def _build_Rlist(self):
         Rset = set()
         ispin_set = set()
@@ -228,12 +261,14 @@ Generation time: {now.strftime("%y/%m/%d %H:%M:%S")}
         return self.index_spin[symdict[symnum]]
 
     def i_spin(self, i):
-        if isinstance(i, int):
-            return i
+        if isinstance(i, (int, np.integer)):
+            return int(i)
         elif isinstance(i, str):
             return self.get_symbol_number_ispin(i)
         else:
-            raise ValueError("i must be either an integer or a string.")
+            raise ValueError(
+                f"i must be either an integer or a string. Got {type(i)}: {i}"
+            )
 
     def get_charge_ispin(self, i):
         i = self.i_spin(i)
@@ -332,7 +367,7 @@ Generation time: {now.strftime("%y/%m/%d %H:%M:%S")}
         else:
             return default
 
-    def get_J_tensor(self, i, j, R, Jiso=True, Jani=False, DMI=False):
+    def get_J_tensor(self, i, j, R, Jiso=True, Jani=True, DMI=True, SIA=True):
         """
         Return the full exchange tensor for atom i and j, and cell R.
         param i : spin index i
@@ -353,6 +388,20 @@ Generation time: {now.strftime("%y/%m/%d %H:%M:%S")}
             if Ja is not None:
                 Ja *= 1
         Jtensor = combine_J_tensor(Jiso=J, D=D, Jani=Ja)
+        if np.linalg.norm(R) < 0.001 and i == j:
+            print(f"{SIA=} , {i=}")
+            print(f"{self.has_sia_tensor=}")
+
+        if (
+            SIA
+            and self.has_sia_tensor
+            and self.sia_tensor is not None
+            and i == j
+            and np.linalg.norm(R) < 0.001
+        ):
+            if i in self.sia_tensor:
+                print(f"Adding SIA tensor for {i}, with {self.sia_tensor[i]}")
+                Jtensor += self.sia_tensor[i]
 
         # if iso_only:
         #    J = self.get_Jiso(i, j, R)
@@ -368,7 +417,9 @@ Generation time: {now.strftime("%y/%m/%d %H:%M:%S")}
         #    )
         return Jtensor
 
-    def get_full_Jtensor_for_one_R_i3j3(self, R, Jiso=True, Jani=True, DMI=True):
+    def get_full_Jtensor_for_one_R_i3j3(
+        self, R, Jiso=True, Jani=True, DMI=True, SIA=True
+    ):
         """
         Return the full exchange tensor of all i and j for cell R.
         param R (tuple of integers): cell index R
@@ -380,11 +431,13 @@ 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, Jiso=Jiso, Jani=Jani, DMI=DMI
+                    i, j, R, Jiso=Jiso, Jani=Jani, DMI=DMI, SIA=SIA
                 )
         return Jmat
 
-    def get_full_Jtensor_for_one_R_ij33(self, R, Jiso=True, Jani=True, DMI=True):
+    def get_full_Jtensor_for_one_R_ij33(
+        self, R, Jiso=True, Jani=True, DMI=True, SIA=True
+    ):
         """
         Return the full exchange tensor of all i and j for cell R.
         param R (tuple of integers): cell index R
@@ -396,20 +449,22 @@ Generation time: {now.strftime("%y/%m/%d %H:%M:%S")}
         for i in range(self.nspin):
             for j in range(self.nspin):
                 Jmat[i, j, :, :] = self.get_J_tensor(
-                    i, j, R, Jiso=Jiso, Jani=Jani, DMI=DMI
+                    i, j, R, Jiso=Jiso, Jani=Jani, DMI=DMI, SIA=SIA
                 )
         return Jmat
 
-    def get_full_Jtensor_for_one_R_ij(self, R, Jiso=True, Jani=True, DMI=True):
+    def get_full_Jtensor_for_one_R_ij(
+        self, R, Jiso=True, Jani=True, DMI=True, SIA=True,
+    ):
         """
         Return the full exchange tensor of all i and j for cell R.
         param R (tuple of integers): cell index R
         returns:
             Jmat: (nspin,nspin,3,3) matrix.
         """
-        if Jani or DMI:
+        if Jani or DMI or SIA:
             raise ValueError(
-                "Jani and DMI are not supported for this method. Use get_full_Jtensor_for_one_R_ij33 instead."
+                "Jani, DMI and SIA are not supported for this method. Use get_full_Jtensor_for_one_R_ij33 instead."
             )
         n = self.nspin
         Jmat = np.zeros((n, n), dtype=float)
@@ -421,7 +476,7 @@ Generation time: {now.strftime("%y/%m/%d %H:%M:%S")}
         return Jmat
 
     def get_full_Jtensor_for_Rlist(
-        self, asr=False, Jiso=True, Jani=True, DMI=True, order="i3j3"
+        self, asr=False, Jiso=True, Jani=True, DMI=True, SIA=True, order="i3j3"
     ):
         n = self.nspin
         n3 = n * 3
@@ -430,7 +485,7 @@ Generation time: {now.strftime("%y/%m/%d %H:%M:%S")}
             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, Jiso=Jiso, Jani=Jani, DMI=DMI
+                    R, Jiso=Jiso, Jani=Jani, DMI=DMI, SIA=SIA
                 )
             if asr:
                 iR0 = np.argmin(np.linalg.norm(self.Rlist, axis=1))
@@ -442,8 +497,9 @@ Generation time: {now.strftime("%y/%m/%d %H:%M:%S")}
         elif order == "ij33":
             Jmat = np.zeros((nR, n, n, 3, 3), dtype=float)
             for iR, R in enumerate(self.Rlist):
+                print(f"R={R}")
                 Jmat[iR] = self.get_full_Jtensor_for_one_R_ij33(
-                    R, Jiso=Jiso, Jani=Jani, DMI=DMI
+                    R, Jiso=Jiso, Jani=Jani, DMI=DMI, SIA=SIA
                 )
             if asr:
                 iR0 = np.argmin(np.linalg.norm(self.Rlist, axis=1))
@@ -454,8 +510,9 @@ Generation time: {now.strftime("%y/%m/%d %H:%M:%S")}
         elif order == "i3j3_2D":
             Jmat = np.zeros((nR, n3, n3), dtype=float)
             for iR, R in enumerate(self.Rlist):
+                print(f"R={R}")
                 Jmat[iR] = self.get_full_Jtensor_for_one_R_i3j3(
-                    R, Jiso=Jiso, Jani=Jani, DMI=DMI
+                    R, Jiso=Jiso, Jani=Jani, DMI=DMI, SIA=SIA
                 ).reshape((n3, n3))
             if asr:
                 iR0 = np.argmin(np.linalg.norm(self.Rlist, axis=1))
@@ -468,7 +525,7 @@ Generation time: {now.strftime("%y/%m/%d %H:%M:%S")}
             Jmat = np.zeros((nR, n, n), dtype=float)
             for iR, R in enumerate(self.Rlist):
                 Jmat[iR] = self.get_full_Jtensor_for_one_R_ij(
-                    R, Jiso=Jiso, Jani=Jani, DMI=DMI
+                    R, Jiso=Jiso, Jani=Jani, DMI=DMI, SIA=SIA
                 )
             if asr:
                 iR0 = np.argmin(np.linalg.norm(self.Rlist, axis=1))
@@ -565,17 +622,41 @@ Generation time: {now.strftime("%y/%m/%d %H:%M:%S")}
         marker="o",
         fname=None,
         show=False,
+        by_species=False,
         **kwargs,
     ):
         if ax is None:
             fig, ax = plt.subplots()
-        ds = []
-        Js = []
-        for key, val in self.exchange_Jdict.items():
-            d = self.distance_dict[key][1]
-            ds.append(d)
-            Js.append(val * 1e3)
-        ax.scatter(ds, Js, marker=marker, color=color, **kwargs)
+        if by_species:
+            groups = {}
+            for key, val in self.exchange_Jdict.items():
+                R, i, j = key
+                idx_i = self.ind_atoms[i]
+                idx_j = self.ind_atoms[j]
+                spec_i = self.atoms[idx_i].symbol
+                spec_j = self.atoms[idx_j].symbol
+                pair = tuple(sorted([spec_i, spec_j]))
+                pair_name = "-".join(pair)
+                if pair_name not in groups:
+                    groups[pair_name] = {"ds": [], "Js": []}
+                d = self.distance_dict[key][1]
+                groups[pair_name]["ds"].append(d)
+                groups[pair_name]["Js"].append(val * 1e3)
+
+            for pair_name, data in groups.items():
+                ax.scatter(
+                    data["ds"], data["Js"], marker=marker, label=pair_name, **kwargs
+                )
+            ax.legend()
+        else:
+            ds = []
+            Js = []
+            for key, val in self.exchange_Jdict.items():
+                d = self.distance_dict[key][1]
+                ds.append(d)
+                Js.append(val * 1e3)
+            ax.scatter(ds, Js, marker=marker, color=color, **kwargs)
+
         ax.axhline(color="gray")
         ax.set_xlabel(r"Distance ($\AA$)")
         ax.set_ylabel("J (meV)")
@@ -585,25 +666,68 @@ Generation time: {now.strftime("%y/%m/%d %H:%M:%S")}
             plt.show()
         return ax
 
-    def plot_DvsR(self, ax=None, fname=None, show=False):
+    def plot_DvsR(self, ax=None, fname=None, show=False, by_species=False):
         if ax is None:
             fig, ax = plt.subplots()
-        ds = []
-        Ds = []
-        for key, val in self.dmi_ddict.items():
-            d = self.distance_dict[key][1]
-            ds.append(d)
-            Ds.append(val * 1e3)
-        Ds = np.array(Ds)
-        ax.scatter(ds, Ds[:, 0], marker="s", color="r", label="Dx")
-        ax.scatter(
-            ds, Ds[:, 1], marker="o", edgecolors="g", facecolors="none", label="Dy"
-        )
-        ax.scatter(
-            ds, Ds[:, 2], marker="D", edgecolors="b", facecolors="none", label="Dz"
-        )
+        if by_species:
+            groups = {}
+            for key, val in self.dmi_ddict.items():
+                R, i, j = key
+                idx_i = self.ind_atoms[i]
+                idx_j = self.ind_atoms[j]
+                spec_i = self.atoms[idx_i].symbol
+                spec_j = self.atoms[idx_j].symbol
+                pair = tuple(sorted([spec_i, spec_j]))
+                pair_name = "-".join(pair)
+                if pair_name not in groups:
+                    groups[pair_name] = {"ds": [], "Ds": []}
+                d = self.distance_dict[key][1]
+                groups[pair_name]["ds"].append(d)
+                groups[pair_name]["Ds"].append(val * 1e3)
+
+            markers = ["s", "o", "D", "v", "^", "<", ">", "p", "*", "h", "H"]
+            for idx, (pair_name, data) in enumerate(groups.items()):
+                Ds = np.array(data["Ds"])
+                marker = markers[idx % len(markers)]
+                ax.scatter(
+                    data["ds"],
+                    Ds[:, 0],
+                    marker=marker,
+                    color="r",
+                    label=f"{pair_name} Dx",
+                )
+                ax.scatter(
+                    data["ds"],
+                    Ds[:, 1],
+                    marker=marker,
+                    color="g",
+                    label=f"{pair_name} Dy",
+                )
+                ax.scatter(
+                    data["ds"],
+                    Ds[:, 2],
+                    marker=marker,
+                    color="b",
+                    label=f"{pair_name} Dz",
+                )
+            ax.legend(ncol=3, fontsize="small")
+        else:
+            ds = []
+            Ds = []
+            for key, val in self.dmi_ddict.items():
+                d = self.distance_dict[key][1]
+                ds.append(d)
+                Ds.append(val * 1e3)
+            Ds = np.array(Ds)
+            ax.scatter(ds, Ds[:, 0], marker="s", color="r", label="Dx")
+            ax.scatter(
+                ds, Ds[:, 1], marker="o", edgecolors="g", facecolors="none", label="Dy"
+            )
+            ax.scatter(
+                ds, Ds[:, 2], marker="D", edgecolors="b", facecolors="none", label="Dz"
+            )
+            ax.legend(loc=1)
         ax.axhline(color="gray")
-        ax.legend(loc=1)
         ax.set_ylabel("D (meV)")
         ax.set_xlabel(r"Distance ($\AA$)")
         if fname is not None:
@@ -612,31 +736,71 @@ Generation time: {now.strftime("%y/%m/%d %H:%M:%S")}
             plt.show()
         return ax
 
-    def plot_JanivsR(self, ax=None, fname=None, show=False):
+    def plot_JanivsR(self, ax=None, fname=None, show=False, by_species=False):
         if ax is None:
             fig, ax = plt.subplots()
-        ds = []
-        Jani = []
-        for key, val in self.Jani_dict.items():
-            d = self.distance_dict[key][1]
-            ds.append(d)
-            # val = val - np.diag([np.trace(val) / 3] * 3)
-            Jani.append(val * 1e3)
-        Jani = np.array(Jani)
-        s = "xyz"
-        for i in range(3):
-            ax.scatter(ds, Jani[:, i, i], marker="s", label=f"J{s[i]}{s[i]}")
-        c = "rgb"
-        for ic, (i, j) in enumerate([(0, 1), (0, 2), (1, 2)]):
-            ax.scatter(
-                ds,
-                Jani[:, i, j],
-                edgecolors=c[ic],
-                facecolors="none",
-                label=f"J{s[i]}{s[j]}",
-            )
+        if by_species:
+            groups = {}
+            for key, val in self.Jani_dict.items():
+                R, i, j = key
+                idx_i = self.ind_atoms[i]
+                idx_j = self.ind_atoms[j]
+                spec_i = self.atoms[idx_i].symbol
+                spec_j = self.atoms[idx_j].symbol
+                pair = tuple(sorted([spec_i, spec_j]))
+                pair_name = "-".join(pair)
+                if pair_name not in groups:
+                    groups[pair_name] = {"ds": [], "Jani": []}
+                d = self.distance_dict[key][1]
+                groups[pair_name]["ds"].append(d)
+                groups[pair_name]["Jani"].append(val * 1e3)
+
+            markers = ["s", "o", "D", "v", "^", "<", ">", "p", "*", "h", "H"]
+            s = "xyz"
+            for idx, (pair_name, data) in enumerate(groups.items()):
+                Jani = np.array(data["Jani"])
+                marker = markers[idx % len(markers)]
+                # Diagonal
+                for i in range(3):
+                    ax.scatter(
+                        data["ds"],
+                        Jani[:, i, i],
+                        marker=marker,
+                        label=f"{pair_name} J{s[i]}{s[i]}",
+                    )
+                # Off-diagonal
+                for i, j in [(0, 1), (0, 2), (1, 2)]:
+                    ax.scatter(
+                        data["ds"],
+                        Jani[:, i, j],
+                        marker=marker,
+                        facecolors="none",
+                        label=f"{pair_name} J{s[i]}{s[j]}",
+                    )
+            ax.legend(ncol=3, fontsize="small")
+        else:
+            ds = []
+            Jani = []
+            for key, val in self.Jani_dict.items():
+                d = self.distance_dict[key][1]
+                ds.append(d)
+                # val = val - np.diag([np.trace(val) / 3] * 3)
+                Jani.append(val * 1e3)
+            Jani = np.array(Jani)
+            s = "xyz"
+            for i in range(3):
+                ax.scatter(ds, Jani[:, i, i], marker="s", label=f"J{s[i]}{s[i]}")
+            c = "rgb"
+            for ic, (i, j) in enumerate([(0, 1), (0, 2), (1, 2)]):
+                ax.scatter(
+                    ds,
+                    Jani[:, i, j],
+                    edgecolors=c[ic],
+                    facecolors="none",
+                    label=f"J{s[i]}{s[j]}",
+                )
+            ax.legend(loc=1, ncol=2)
         ax.axhline(color="gray")
-        ax.legend(loc=1, ncol=2)
         ax.set_xlabel(r"Distance ($\AA$)")
         ax.set_ylabel("Jani (meV)")
         if fname is not None:
@@ -645,7 +809,7 @@ Generation time: {now.strftime("%y/%m/%d %H:%M:%S")}
             plt.show()
         return ax
 
-    def plot_all(self, title=None, savefile=None, show=False):
+    def plot_all(self, title=None, savefile=None, show=False, by_species=False):
         if self.has_dmi and self.has_bilinear:
             naxis = 3
         else:
@@ -653,11 +817,11 @@ Generation time: {now.strftime("%y/%m/%d %H:%M:%S")}
         fig, axes = plt.subplots(naxis, 1, sharex=True, figsize=(5, 2.2 * naxis))
 
         if self.has_dmi and self.has_bilinear:
-            self.plot_JvsR(axes[0])
-            self.plot_DvsR(axes[1])
-            self.plot_JanivsR(axes[2])
+            self.plot_JvsR(axes[0], by_species=by_species)
+            self.plot_DvsR(axes[1], by_species=by_species)
+            self.plot_JanivsR(axes[2], by_species=by_species)
         else:
-            self.plot_JvsR(axes)
+            self.plot_JvsR(axes, by_species=by_species)
 
         if title is not None:
             fig.suptitle(title)

TB2J/io_exchange/io_tomsasd.py

@@ -1,7 +1,8 @@
-import numpy as np
 import os
 from itertools import groupby
 
+import numpy as np
+
 
 def write_tom_ucf(cls, fname):
     """
@@ -25,8 +26,8 @@ def write_tom_ucf(cls, fname):
                 gyro_ratio = cls.gyro_ratio[i]
                 symbol = cls.atoms.get_chemical_symbols()[i]
                 if cls.has_uniaxial_anistropy:
-                    k1 = cls.k1[i]
-                    k1dir = cls.k1dir[i]
+                    k1 = cls.k1[id_spin]
+                    k1dir = cls.k1dir[id_spin]
                 else:
                     k1 = 0.0
                     k1dir = [0.0, 0.0, 1.0]

TB2J/io_exchange/io_txt.py

@@ -1,4 +1,5 @@
 import os
+import sys
 
 import numpy as np
 from numpy import array_str
@@ -9,6 +10,7 @@ from TB2J.utils import symbol_number
 def write_info_section(cls, myfile):
     myfile.write("=" * 90 + "\n")
     myfile.write("Information: \n")
+    myfile.write(f"Executed:  \n{' '.join(sys.argv)}\n")
     # myfile.write("Exchange parameters generated by TB2J %s\n" % (__version__))
     # myfile.write("Generation time: %s\n" % (now.strftime("%y/%m/%d %H:%M:%S")))
     myfile.write(cls.description)
@@ -82,6 +84,24 @@ def write_atom_section(cls, myfile):
             )
         )
 
+    # write single ion anisotropy
+    if cls.k1 is not None and cls.k1dir is not None:
+        myfile.write("\n")
+        myfile.write("-" * 90 + "\n")
+        myfile.write("Single Ion Anisotropy (meV): \n")
+        myfile.write("(k1 is the anisotropy constant, k1dir is the direction vector)\n")
+        myfile.write("{:^12s} {:^12s} {:^24s}\n".format("Atom number", "k1", "k1dir"))
+        for i, s in enumerate(symnum):
+            ispin = cls.index_spin[i]
+            if ispin >= 0:
+                k1 = cls.k1[ispin] * 1e3
+                k1dir = cls.k1dir[ispin]
+                myfile.write(
+                    "{:<12s} {:12.4f} ({:7.4f}, {:7.4f}, {:7.4f})\n".format(
+                        s, k1, k1dir[0], k1dir[1], k1dir[2]
+                    )
+                )
+
     myfile.write("\n")
 
 
@@ -159,17 +179,17 @@ def write_exchange_section(
 
         if cls.has_biquadratic and write_experimental:
             Jprime, B = cls.biquadratic_Jdict[ll]
-            myfile.write(f"[Testing!] Jprime: {Jprime*1e3:.3f},  B: {B*1e3:.3f}\n")
+            myfile.write(f"[Testing!] Jprime: {Jprime * 1e3:.3f},  B: {B * 1e3:.3f}\n")
 
         if cls.dJdx is not None:
             dJdx = cls.dJdx[ll]
-            myfile.write(f"dJ/dx: {dJdx*1e3:.3f}\n")
+            myfile.write(f"dJ/dx: {dJdx * 1e3:.3f}\n")
 
         if cls.dJdx2 is not None:
             dJdx2 = cls.dJdx2[ll]
-            myfile.write(f"d2J/dx2: {dJdx2*1e3:.3f}\n")
+            myfile.write(f"d2J/dx2: {dJdx2 * 1e3:.3f}\n")
 
-        if cls.dmi_ddict is not None:
+        if cls.dmi_ddict is not None and ll in cls.dmi_ddict:
             DMI = cls.dmi_ddict[ll] * 1e3
             myfile.write(
                 "[Testing!] DMI: ({:7.4f} {:7.4f} {:7.4f})\n".format(
@@ -188,13 +208,13 @@ def write_exchange_section(
             except Exception as e:
                 myfile.write(f"[Debug!] DMI2 not available: {e}\n")
 
-        if cls.Jani_dict is not None:
+        if cls.Jani_dict is not None and ll in cls.Jani_dict:
             J = cls.Jani_dict[ll] * 1e3
             myfile.write(
                 f"[Testing!]J_ani:\n{array_str(J, precision=3, suppress_small=True)}\n"
             )
 
-        if cls.NJT_ddict is not None:
+        if cls.NJT_ddict is not None and ll in cls.NJT_ddict:
             DMI = cls.NJT_ddict[ll] * 1e3
             myfile.write(
                 "[Experimental!] DMI_NJt: ({:7.4f} {:7.4f} {:7.4f})\n".format(
@@ -202,7 +222,7 @@ def write_exchange_section(
                 )
             )
 
-        if cls.NJT_Jdict is not None:
+        if cls.NJT_Jdict is not None and ll in cls.NJT_Jdict:
             J = cls.NJT_Jdict[ll] * 1e3
             myfile.write(
                 "[Testing!] Jani_NJt: ({:7.4f} {:7.4f} {:7.4f})\n".format(
@@ -305,6 +325,50 @@ def write_Jq_info(cls, kpts, evals, evecs, myfile, special_kpoints={}):
         print(f"{sns[cls.ind_atoms[i]]}, {v[0]: 8.3f}, {v[2]: 8.3f}, {v[2]: 8.3f}\n")
 
 
+def write_sia_section(cls, myfile):
+    """
+    Write single ion anisotropy tensor section.
+    """
+    if cls.has_sia_tensor and cls.sia_tensor is not None:
+        myfile.write("\n")
+        myfile.write("=" * 90 + "\n")
+        myfile.write("Single Ion Anisotropy: \n")
+        symnum = symbol_number(cls.atoms)
+        sns = list(symnum.keys())
+        myfile.write(
+            "{:^12s} {:^13s} {:^13s} {:^13s}\n".format(
+                "Atom_number", "A_xx", "A_xy", "A_xz"
+            )
+        )
+        myfile.write(
+            "{:^12s} {:^13s} {:^13s} {:^13s}\n".format("", "A_yx", "A_yy", "A_yz")
+        )
+        myfile.write(
+            "{:^12s} {:^13s} {:^13s} {:^13s}\n".format("", "A_zx", "A_zy", "A_zz")
+        )
+        for i, tensor in cls.sia_tensor.items():
+            iatom = cls.ind_atoms[i]
+            myfile.write(
+                "{:<12s} {:13.8f} {:13.8f} {:13.8f}\n".format(
+                    sns[iatom],
+                    tensor[0, 0] * 1e3,
+                    tensor[0, 1] * 1e3,
+                    tensor[0, 2] * 1e3,
+                )
+            )
+            myfile.write(
+                "{:<12s} {:13.8f} {:13.8f} {:13.8f}\n".format(
+                    "", tensor[1, 0] * 1e3, tensor[1, 1] * 1e3, tensor[1, 2] * 1e3
+                )
+            )
+            myfile.write(
+                "{:<12s} {:13.8f} {:13.8f} {:13.8f}\n".format(
+                    "", tensor[2, 0] * 1e3, tensor[2, 1] * 1e3, tensor[2, 2] * 1e3
+                )
+            )
+            myfile.write("-" * 88 + "\n")
+
+
 def write_txt(
     cls,
     path="TB2J_results",
@@ -321,6 +385,7 @@ def write_txt(
         write_info_section(cls, myfile)
         write_atom_section(cls, myfile)
         write_orbital_section(cls, myfile)
+        write_sia_section(cls, myfile)
         write_exchange_section(
             cls,
             myfile,

TB2J/io_exchange/io_vampire.py

@@ -50,7 +50,7 @@ def write_vampire_unitcell_file(cls, fname):
         counter = -1
         for key in cls.exchange_Jdict:
             R, ispin, jspin = key
-            Jtensor = cls.get_J_tensor(ispin, jspin, R)
+            Jtensor = cls.get_J_tensor(ispin, jspin, R, Jani=True, DMI=True)
             counter += 1  # starts at 0
             myfile.write(
                 f"{counter:5d} {ispin:3d} {jspin:3d} {R[0]:3d} {R[1]:3d} {R[2]:3d} "