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

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} "

TB2J/io_merge.py

@@ -107,22 +107,23 @@ class Merger:
         projv = {}
         coeff_matrix = {}
         projectors = {}
-        for key in self.main_dat.projv.keys():
-            vectors = [obj.projv[key] for obj in self.dat]
-            coefficients, u, v = zip(
-                *[get_Jani_coefficients(vectors[i], R=R[i]) for i in indices]
-            )
-            projectors[key] = np.vstack([u[i] @ R[i].T for i in indices])
-            coeff_matrix[key] = np.vstack(coefficients)
-            proju[key] = np.stack(u)
-            projv[key] = np.stack(v)
-            if np.linalg.matrix_rank(coeff_matrix[key], tol=1e-2) < 6:
-                warnings.warn("""
-                    WARNING: The matrix of equations to reconstruct the exchange tensors is
-                    close to being singular. This happens when the magnetic moments between
-                    different configurations are cloes to being parallel. You need to consider 
-                    more rotated spin configurations, otherwise the results might have a large 
-                    error.""")
+        if self.main_dat.projv is not None:
+            for key in self.main_dat.projv.keys():
+                vectors = [obj.projv[key] for obj in self.dat]
+                coefficients, u, v = zip(
+                    *[get_Jani_coefficients(vectors[i], R=R[i]) for i in indices]
+                )
+                projectors[key] = np.vstack([u[i] @ R[i].T for i in indices])
+                coeff_matrix[key] = np.vstack(coefficients)
+                proju[key] = np.stack(u)
+                projv[key] = np.stack(v)
+                if np.linalg.matrix_rank(coeff_matrix[key], tol=1e-2) < 6:
+                    warnings.warn("""
+                        WARNING: The matrix of equations to reconstruct the exchange tensors is
+                        close to being singular. This happens when the magnetic moments between
+                        different configurations are cloes to being parallel. You need to consider 
+                        more rotated spin configurations, otherwise the results might have a large 
+                        error.""")
 
         self.proju = proju
         self.projv = projv
@@ -134,13 +135,23 @@ class Merger:
         proju = self.proju
         projv = self.projv
         coeff_matrix = self.coeff_matrix
-        for key in self.main_dat.Jani_dict.keys():
+        for key in self.main_dat.exchange_Jdict.keys():
             try:
                 R, i, j = key
                 u = proju[i, j]
                 v = projv[i, j]
-                Jani = np.stack([sio.Jani_dict[key] for sio in self.dat])
-                projections = np.einsum("nmi,nij,nmj->nm", u, Jani, v).flatten()
+                projections = []
+                for idx, sio in enumerate(self.dat):
+                    if sio.has_bilinear and key in sio.Jani_dict:
+                        Jmat = sio.get_J_tensor(
+                            i, j, R, Jiso=False, Jani=True, DMI=False
+                        )
+                    else:
+                        # J_scalar = sio.exchange_Jdict.get(key, 0.0)
+                        Jmat = np.eye(3) * 0.0
+                    proj = np.einsum("mi,ij,mj->m", u[idx], Jmat, v[idx])
+                    projections.append(proj)
+                projections = np.concatenate(projections)
             except KeyError as err:
                 raise KeyError(
                     "Can not find key: %s, Please make sure the three calculations use the same k-mesh and same Rcut."
@@ -158,28 +169,36 @@ class Merger:
 
     def merge_Jiso(self):
         Jdict = {}
-        for key in self.main_dat.exchange_Jdict.keys():
-            try:
-                J = np.mean([obj.exchange_Jdict[key] for obj in self.dat])
-            except KeyError as err:
-                raise KeyError(
-                    "Can not find key: %s, Please make sure the three calculations use the same k-mesh and same Rcut."
-                    % err
-                )
-            Jdict[key] = J
-        self.main_dat.exchange_Jdict = Jdict
+        if self.main_dat.exchange_Jdict is not None:
+            for key in self.main_dat.exchange_Jdict.keys():
+                try:
+                    J = np.mean([obj.exchange_Jdict[key] for obj in self.dat])
+                except KeyError as err:
+                    raise KeyError(
+                        "Can not find key: %s, Please make sure the three calculations use the same k-mesh and same Rcut."
+                        % err
+                    )
+                Jdict[key] = J
+            self.main_dat.exchange_Jdict = Jdict
 
     def merge_DMI(self):
         dmi_ddict = {}
-        if all(obj.has_dmi for obj in self.dat):
+        if any(obj.has_dmi for obj in self.dat):
             projectors = self.projectors
             proju = self.proju
-            for key in self.main_dat.dmi_ddict.keys():
+            for key in self.main_dat.exchange_Jdict.keys():
                 try:
                     R, i, j = key
                     u = proju[i, j]
-                    DMI = np.stack([sio.dmi_ddict[key] for sio in self.dat])
-                    projections = np.einsum("nmi,ni->nm", u, DMI).flatten()
+                    projections = []
+                    for idx, sio in enumerate(self.dat):
+                        if sio.has_dmi and key in sio.dmi_ddict:
+                            DMI = sio.dmi_ddict[key]
+                        else:
+                            DMI = np.zeros(3)
+                        proj = np.einsum("mi,i->m", u[idx], DMI)
+                        projections.append(proj)
+                    projections = np.concatenate(projections)
                 except KeyError as err:
                     raise KeyError(
                         "Can not find key: %s, Please make sure the three calculations use the same k-mesh and same Rcut."
@@ -193,13 +212,14 @@ class Merger:
         # 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
+        if Jani_dict is not None:
+            for key in Jani_dict.keys():
+                Jani = 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"):

TB2J/magnon/magnon3.py

@@ -28,6 +28,7 @@ class MagnonParameters:
     Jiso: bool = True
     Jani: bool = False
     DMI: bool = False
+    SIA: bool = True
     Q: Optional[List[float]] = None
     uz_file: Optional[str] = None
     n: Optional[List[float]] = None
@@ -398,11 +399,18 @@ class Magnon:
         cell = exc.atoms.get_cell()
         pbc = exc.atoms.get_pbc()
 
+        # Extract SIA from kwargs, default True if not present
+        include_SIA = kwargs.pop("SIA", True)
+
+        JR = exc.get_full_Jtensor_for_Rlist(
+            order="ij33", asr=False, SIA=include_SIA, **kwargs
+        )
+
         return cls(
             nspin=exc.nspin,
             magmom=magmoms,
             Rlist=exc.Rlist,
-            JR=exc.get_full_Jtensor_for_Rlist(order="ij33", asr=False, **kwargs),
+            JR=JR,
             cell=cell,
             _Q=np.zeros(3),  # Default propagation vector
             _uz=np.array([[0.0, 0.0, 1.0]]),  # Default quantization axis
@@ -654,7 +662,11 @@ def plot_magnon_bands_from_TB2J(
     # Load magnon calculator from TB2J results
     print(f"Loading exchange parameters from {params.path}...")
     magnon = Magnon.from_TB2J_results(
-        path=params.path, Jiso=params.Jiso, Jani=params.Jani, DMI=params.DMI
+        path=params.path,
+        Jiso=params.Jiso,
+        Jani=params.Jani,
+        DMI=params.DMI,
+        SIA=params.SIA,
     )
 
     # Set reference vectors if provided
@@ -815,6 +827,18 @@ def plot_magnon_bands_cli():
         default=False,
         help="Include anisotropic exchange interactions (default: False)",
     )
+    parser.add_argument(
+        "--SIA",
+        action="store_true",
+        default=True,
+        help="Include single ion anisotropy (default: True)",
+    )
+    parser.add_argument(
+        "--no-SIA",
+        action="store_false",
+        dest="SIA",
+        help="Exclude single ion anisotropy",
+    )
     parser.add_argument(
         "-d",
         "--DMI",
@@ -881,6 +905,7 @@ def plot_magnon_bands_cli():
             filename=args.output,
             Jiso=args.Jiso,
             Jani=args.Jani,
+            SIA=args.SIA,
             DMI=args.DMI,
             Q=args.Q if args.Q is not None else None,
             uz_file=args.uz_file,

TB2J/mathutils/rotate_spin.py

@@ -92,7 +92,7 @@ def rotate_spinor_matrix_einsum(M, theta, phi):
     Rotate the spinor matrix M by theta and phi,
     """
     shape = M.shape
-    n1 = np.product(shape[:-1]) // 2
+    n1 = np.prod(shape[:-1]) // 2
     n2 = M.shape[-1] // 2
     Mnew = np.reshape(M, (n1, 2, n2, 2))  # .swapaxes(1, 2)
     U = rotation_matrix(theta, phi)
@@ -203,15 +203,15 @@ def test_rotate_spinor_M():
     Mrot4 = rotate_spinor_matrix_kron(M, np.pi / 2, np.pi / 2)
     Mrot5 = rotate_spinor_matrix_spkron(M, np.pi / 2, np.pi / 2)
     print(f"Rotated M with jit:\n {Mrot1}")
-    print(f"Rotated M with einsum:\n {Mrot2-Mrot1}")
-    print(f"Rotated M with reshape:\n {Mrot3-Mrot1}")
-    print(f"Rotated M with kron:\n {Mrot4-Mrot1}")
-    print(f"Rotated M with spkron:\n {Mrot5-Mrot1}")
+    print(f"Rotated M with einsum:\n {Mrot2 - Mrot1}")
+    print(f"Rotated M with reshape:\n {Mrot3 - Mrot1}")
+    print(f"Rotated M with kron:\n {Mrot4 - Mrot1}")
+    print(f"Rotated M with spkron:\n {Mrot5 - Mrot1}")
 
     M_rot00 = rotate_spinor_matrix(M, 0, 0)
     M_rot00_sph = rotate_Matrix_from_z_to_spherical(M, 0, 0)
-    print(f"Rotated M with theta=0, phi=0 compared with M:\n {M_rot00-M}")
-    print(f"Rotated M with theta=0, phi=0 compared with M:\n {M_rot00_sph-M}")
+    print(f"Rotated M with theta=0, phi=0 compared with M:\n {M_rot00 - M}")
+    print(f"Rotated M with theta=0, phi=0 compared with M:\n {M_rot00_sph - M}")
 
 
 def test_rotate_spinor_oneblock():

TB2J/mycfr.py

@@ -6,20 +6,17 @@ Continued fraction representation.
 """
 
 import numpy as np
+from ase.units import kB
 from scipy.linalg import eig
 
-kb = 8.61733e-5  # Boltzmann constant in eV
-
 
 class CFR:
-    """
-    Integration with the continued fraction representation.
-    """
+    """Integration with the continued fraction representation."""
 
-    def __init__(self, nz=50, T=60):
+    def __init__(self, nz: int = 50, T: float = 200.0):
         self.nz = nz
-        self.T = 600
-        self.beta = 1 / (kb * self.T)
+        self.T = float(T)
+        self.beta = 1.0 / (kB * self.T)
         self.Rinf = 1e10
         if nz <= 0:
             raise ValueError("nz should be larger than 0.")
@@ -27,7 +24,7 @@ class CFR:
             self.prepare_poles()
 
     def prepare_poles(self):
-        ##b_mat = [1 / (2.0 * np.sqrt((2 * (j + 1) - 1) * (2 * (j + 1) + 1)) / (kb * self.#T)) for j in range(0, self.nz- 1)]
+        ##b_mat = [1 / (2.0 * np.sqrt((2 * (j + 1) - 1) * (2 * (j + 1) + 1)) / (kB * self.#T)) for j in range(0, self.nz- 1)]
         jmat = np.arange(0, self.nz - 1)
         b_mat = 1 / (2.0 * np.sqrt((2 * (jmat + 1) - 1) * (2 * (jmat + 1) + 1)))
         b_mat = np.diag(b_mat, -1) + np.diag(b_mat, 1)
@@ -42,16 +39,16 @@ class CFR:
         #    np.real(self.poles) > 0, 2.0j / self.beta * residules, 0.0
         # )
 
-        # self.path = 1j / self.poles * kb * self.T
+        # self.path = 1j / self.poles * kB * self.T
 
         self.path = []
         self.weights = []
         for p, r in zip(self.poles, residules):
             if p > 0:
-                self.path.append(1j / p * kb * self.T)
+                self.path.append(1j / p * kB * self.T)
                 w = 2.0j / self.beta * r
                 self.weights.append(w)
-                self.path.append(-1j / p * kb * self.T)
+                self.path.append(-1j / p * kB * self.T)
                 self.weights.append(w)
 
         self.path = np.array(self.path)
@@ -61,12 +58,12 @@ class CFR:
         # A_mat =  -1/2 *np.diag(1, -1) + np.diag(1, 1)
         # B_mat = np.diag([2*i-1 for i in range(1, self.nz)])
         # eigp, eigv = eig(A_mat, B_mat)
-        # zp = 1j / eigp * kb * self.T
+        # zp = 1j / eigp * kB * self.T
         # Rp = 0.25 * np.diag(eigv)**2 * zp **2
 
         # print the poles and the weights
-        for i in range(len(self.poles)):
-            print("Pole: ", self.poles[i], "Weight: ", self.weights[i])
+        # for i in range(len(self.poles)):
+        #    print("Pole: ", self.poles[i], "Weight: ", self.weights[i])
 
         # add a point to the poles: 1e10j
         self.path = np.concatenate((self.path, [self.Rinf * 1j]))
@@ -110,7 +107,10 @@ def test_cfr():
 
     r = cfr.integrate_func(test_gf, ef=2)
     r = -np.imag(r) / np.pi * 2
-    print(r)
+    if not np.close(r, -1.0):
+        raise AssertionError(
+            f"Test failed, the integration should be close to -1.0 but get {r}"
+        )
     return r
 
 

TB2J/plot.py

@@ -14,6 +14,32 @@ def write_eigen(qmesh, gamma=True, path="./", output_fname="EigenJq.txt", **kwar
     m.write_Jq(kmesh=qmesh, path=path, gamma=gamma, output_fname=output_fname, **kwargs)
 
 
+def plot_exchange(
+    input_data,
+    ax=None,
+    marker="o",
+    fname=None,
+    show=False,
+    by_species=True,
+    **kwargs,
+):
+    """Plot exchange parameters vs distance grouped by species.
+    input_data: SpinIO object or path to the pickle file/directory.
+    """
+    if isinstance(input_data, str):
+        if os.path.isdir(input_data):
+            m = SpinIO.load_pickle(input_data)
+        else:
+            m = SpinIO.load_pickle(
+                os.path.dirname(input_data), os.path.basename(input_data)
+            )
+    else:
+        m = input_data
+    return m.plot_JvsR(
+        ax=ax, marker=marker, fname=fname, show=show, by_species=by_species, **kwargs
+    )
+
+
 def plot_magnon_band(
     fname="exchange.xml",
     path="./",