TB2J 0.8.2.7__tar.gz → 0.9.0__tar.gz

{TB2J-0.8.2.7 → TB2J-0.9.0}/PKG-INFO

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

TB2J-0.9.0/TB2J/__init__.py

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

{TB2J-0.8.2.7 → TB2J-0.9.0}/TB2J/abacus/abacus_wrapper.py

@@ -18,8 +18,7 @@ class AbacusWrapper(AbstractTB):
     def __init__(self, HR, SR, Rlist, nbasis, nspin=1):
         self.R2kfactor = -2j * np.pi
         self.is_orthogonal = False
-        self.is_siesta = False
-        self._name = "Abacus"
+        self._name = "ABACUS"
         self.HR = HR
         self.SR = SR
         self.Rlist = Rlist

{TB2J-0.8.2.7 → TB2J-0.9.0}/TB2J/exchange.py

@@ -240,7 +240,7 @@ or badly localized. Please check the Wannier centers in the Wannier90 output fil
         self.mmats = {}
         self.orbital_names = {}
         self.norb_reduced = {}
-        if self.backend_name == "SIESTA":
+        if self.backend_name.upper() == "SIESTA":
             syms = self.atoms.get_chemical_symbols()
             for iatom, orbs in self.labels.items():
                 if (self.include_orbs is not None) and syms[iatom] in self.include_orbs:
@@ -305,7 +305,7 @@ or badly localized. Please check the Wannier centers in the Wannier90 output fil
         """
         sum up the contribution of all the orbitals with same (n,l,m)
         """
-        if self.backend_name == "SIESTA":
+        if self.backend_name.upper() == "SIESTA":
             mmat_i = self.mmats[iatom]
             mmat_j = self.mmats[jatom]
             Jorbij = mmat_i.T @ Jorbij @ mmat_j

{TB2J-0.8.2.7 → TB2J-0.9.0}/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):

TB2J-0.9.0/TB2J/io_merge.py

@@ -0,0 +1,184 @@
+import os
+import copy
+import warnings
+import numpy as np
+from itertools import combinations_with_replacement, product
+from TB2J.io_exchange import SpinIO
+
+u0 = np.zeros(3)
+uy = np.array([0.0, 1.0, 0.0])
+uz = np.array([0.0, 0.0, 1.0])
+
+def get_Jani_coefficients(a, R=np.eye(3)):
+
+    if len(a) == 1:
+        u = a
+        v = a
+    else:
+        u = a[[0, 0, 1]]
+        v = a[[0, 1, 1]]
+    
+    ur = u @ R.T
+    vr = v @ R.T
+    coefficients = np.hstack([ur*vr, np.roll(ur, -1, axis=-1)*vr + np.roll(vr, -1, axis=-1)*ur])
+
+    return coefficients, u, v
+
+def get_projections(a, b, tol=1e-2):
+
+    projections = np.empty((2, 3))
+    if np.linalg.matrix_rank([a, b], tol=tol) == 1:
+        if np.linalg.matrix_rank([a, uy], tol=tol) == 1:
+            projections[0] = np.cross(a, uz)
+        else:
+            projections[0] = np.cross(a, uy)
+        projections[1] = np.cross(a, projections[0])
+        projections /= np.linalg.norm(projections, axis=-1).reshape(-1, 1)
+    else:
+        projections[0] = np.cross(a, b)
+        projections[0] /= np.linalg.norm(projections[0])
+        projections[1] = u0
+
+    return projections
+
+class SpinIO_merge(SpinIO):
+    def __init__(self, *args, **kwargs):
+        super(SpinIO_merge, self).__init__(*args, **kwargs)
+        self.projv = None
+
+    def _set_projection_vectors(self):
+
+        spinat = self.spinat
+        idx = [self.ind_atoms[i] for i in self.index_spin if i >= 0]
+        projv = {}
+        for i, j in combinations_with_replacement(range(self.nspin), 2):
+            a, b = spinat[idx][[i, j]]
+            projv[i, j] = get_projections(a, b)
+            projv[j, i] = projv[i, j]
+
+        self.projv = projv
+
+    @classmethod
+    def load_pickle(cls, path='TB2J_results', fname='TB2J.pickle'):
+        obj = super(SpinIO_merge, cls).load_pickle(path=path, fname=fname)
+        obj._set_projection_vectors()
+
+        return obj
+
+def read_pickle(path):
+    p1 = os.path.join(path, 'TB2J_results', 'TB2J.pickle')
+    p2 = os.path.join(path, 'TB2J.pickle')
+    if os.path.exists(p1) and os.path.exists(p2):
+        print(f" WARNING!: Both file {p1} and {p2} exist. Use default {p1}.")
+    if os.path.exists(p1):
+        ret = SpinIO_merge.load_pickle(os.path.join(path, 'TB2J_results'))
+    elif os.path.exists(p2):
+        ret = SpinIO_merge.load_pickle(path)
+    else:
+        raise FileNotFoundError(f"Cannot find either file {p1} or {p2}")
+    return ret
+
+class Merger():
+    def __init__(self, *paths, main_path=None): 
+        self.dat = [read_pickle(path) for path in paths]
+
+        if main_path is None:
+            self.main_dat = copy.deepcopy(self.dat[-1])
+        else:
+            self.main_dat = read_pickle(main_path)
+            self.dat.append(copy.deepcopy(self.main_dat))
+
+        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
+        )
+        R = np.linalg.solve(cell, rotated_cells)
+        indices = range(len(self.dat))
+
+        proju = {}; 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.'''
+                )
+        
+        self.proju = proju
+        self.projv = projv
+        self.coeff_matrix = coeff_matrix
+        self.projectors = projectors
+
+    def merge_Jani(self):
+        Jani_dict = {}
+        proju = self.proju; projv = self.projv; coeff_matrix = self.coeff_matrix;
+        for key in self.main_dat.Jani_dict.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()
+            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)
+            newJani = np.linalg.lstsq(coeff_matrix[i, j], projections, rcond=1e-2)[0]
+            Jani_dict[key] = np.array([
+                [newJani[0], newJani[3], newJani[5]],
+                [newJani[3], newJani[1], newJani[4]],
+                [newJani[5], newJani[4], newJani[2]]
+            ])
+        self.main_dat.Jani_dict = Jani_dict
+
+    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
+               
+
+    def merge_DMI(self):
+        dmi_ddict = {}
+        if all(obj.has_dmi for obj in self.dat):
+            projectors = self.projectors; proju = self.proju;
+            for key in self.main_dat.dmi_ddict.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()
+                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)
+                newDMI = np.linalg.lstsq(projectors[i, j], projections, rcond=4e-1)[0]
+                dmi_ddict[key] = newDMI
+            self.main_dat.dmi_ddict = dmi_ddict
+
+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()
+    if save:
+        m.main_dat.write_all(path=write_path)
+    return m.dat

{TB2J-0.8.2.7 → TB2J-0.9.0}/TB2J/myTB.py

@@ -16,7 +16,6 @@ class AbstractTB:
     def __init__(self, R2kfactor, nspin, norb):
         #: :math:`\alpha` used in :math:`H(k)=\sum_R  H(R) \exp( \alpha k \cdot R)`,
         #: Should be :math:`2\pi i` or :math:`-2\pi i`
-        self.is_siesta = False
         self.is_orthogonal = True
         self.R2kfactor = R2kfactor
 
@@ -125,7 +124,6 @@ class MyTB(AbstractTB):
         self.atoms = None
         self.R2kfactor = 2.0j * np.pi
         self.k2Rfactor = -2.0j * np.pi
-        self.is_siesta = False
         self.is_orthogonal = True
         self._name = "Wannier"
 

{TB2J-0.8.2.7 → TB2J-0.9.0}/TB2J/rotate_atoms.py

@@ -5,19 +5,24 @@ import numpy as np
 from TB2J.tensor_rotate import Rxx, Rxy, Rxz, Ryx, Ryy, Ryz, Rzx, Rzy, Rzz
 
 
-def rotate_atom_xyz(atoms):
+def rotate_atom_xyz(atoms, noncollinear=False):
     """
-    given a atoms, return:
-    - 'z'->'x'
-    - 'z'->'y'
-    - 'z'->'z'
+    given a atoms, return rotated atoms:
+    atoms_1, ..., atoms_n,
+    where we considered n diffeerent roation axes.
+
+    When noncollinear == True, more rotated structures
+    will be generated.
     """
-    atoms_x = copy.deepcopy(atoms)
-    atoms_x.rotate(90, "y", rotate_cell=True)
-    atoms_y = copy.deepcopy(atoms)
-    atoms_y.rotate(90, "x", rotate_cell=True)
-    atoms_z = atoms
-    return atoms_x, atoms_y, atoms_z
+
+    rotation_axes = [(1, 0, 0), (0, 1, 0)]
+    if noncollinear:
+        rotation_axes += [(1, 1, 0), (1, 0, 1), (0, 1, 1)]
+    
+    for axis in rotation_axes:
+        rotated_atoms = copy.deepcopy(atoms)
+        rotated_atoms.rotate(90, axis, rotate_cell=True)
+        yield rotated_atoms
 
 
 def rotate_atom_spin_one_rotation(atoms, Rotation):
@@ -96,18 +101,15 @@ def check_ftype(ftype):
         print("=" * 40)
 
 
-def rotate_xyz(fname, ftype="xyz"):
+def rotate_xyz(fname, ftype="xyz", noncollinear=False):
     check_ftype(ftype)
     atoms = read(fname)
     atoms.set_pbc(True)
 
-    atoms_x, atoms_y, atoms_z = rotate_atom_xyz(atoms)
+    rotated = rotate_atom_xyz(atoms, noncollinear=noncollinear)
 
-    fname_x = f"atoms_x.{ftype}"
-    fname_y = f"atoms_y.{ftype}"
-    fname_z = f"atoms_z.{ftype}"
+    for i, rotated_atoms in enumerate(rotated):
+        write(f"atoms_{i+1}.{ftype}", rotated_atoms)
+    write(f"atoms_0.{ftype}", atoms)
 
-    write(fname_x, atoms_x)
-    write(fname_y, atoms_y)
-    write(fname_z, atoms_z)
-    print(f"The output has been written to {fname_x}, {fname_y}, {fname_z}")
+    print(f"The output has been written to the atoms_i.{ftype} files. atoms_0.{ftype} contains the reference structure.")

TB2J-0.9.0/TB2J/rotate_siestaDM.py

@@ -0,0 +1,36 @@
+import sisl
+
+def rotate_siesta_DM(DM, noncollinear=False):
+    
+    angles_list = [ [0.0, 90.0, 0.0], [0.0, 90.0, 90.0] ]
+    if noncollinear:
+        angles_list += [[0.0, 45.0, 0.0], [0.0, 90.0, 45.0], [0.0, 45.0, 90.0]]
+
+    for angles in angles_list:
+        yield DM.spin_rotate(angles)
+
+def read_label(fdf_fname):
+
+    label = 'siesta'
+    with open(fdf_fname, 'r') as File:
+        for line in File:
+            corrected_line = line.lower().replace('.', '').replace('-', '')
+            if 'systemlabel' in corrected_line:
+                label = line.split()[1]
+                break
+
+    return label
+
+def rotate_DM(fdf_fname, noncollinear=False):
+
+    fdf = sisl.get_sile(fdf_fname)
+    DM = fdf.read_density_matrix()
+    label = read_label(fdf_fname)
+
+    rotated = rotate_siesta_DM(DM, noncollinear=noncollinear)
+
+    for i, rotated_DM in enumerate(rotated):
+        rotated_DM.write(f"{label}_{i+1}.DM")
+    DM.write(f"{label}_0.DM")
+
+    print(f"The output has been written to the {label}_i.DM files. {label}_0.DM contains the reference density matrix.")

{TB2J-0.8.2.7 → TB2J-0.9.0}/TB2J/sisl_wrapper.py

@@ -10,7 +10,6 @@ from TB2J.mathutils import Lowdin
 
 class SislWrapper(AbstractTB):
     def __init__(self, sisl_hamiltonian, geom=None, spin=None):
-        self.is_siesta = False
         self.is_orthogonal = False
         self.ham = sisl_hamiltonian
         # k2Rfactor : H(k) = \int_R H(R) * e^(k2Rfactor * k.R)

{TB2J-0.8.2.7 → TB2J-0.9.0}/TB2J.egg-info/PKG-INFO

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

{TB2J-0.8.2.7 → TB2J-0.9.0}/TB2J.egg-info/SOURCES.txt

@@ -28,6 +28,7 @@ TB2J/pauli.py
 TB2J/pert.py
 TB2J/plot.py
 TB2J/rotate_atoms.py
+TB2J/rotate_siestaDM.py
 TB2J/sisl_wrapper.py
 TB2J/tensor_rotate.py
 TB2J/utest.py
@@ -74,6 +75,7 @@ scripts/TB2J_magnon.py
 scripts/TB2J_magnon_dos.py
 scripts/TB2J_merge.py
 scripts/TB2J_rotate.py
+scripts/TB2J_rotateDM.py
 scripts/abacus2J.py
 scripts/siesta2J.py
 scripts/wann2J.py

{TB2J-0.8.2.7 → TB2J-0.9.0}/scripts/TB2J_merge.py

@@ -2,7 +2,7 @@
 import argparse
 import os
 import sys
-from TB2J.io_merge import merge, merge2
+from TB2J.io_merge import merge
 
 
 def main():
@@ -28,11 +28,18 @@ def main():
         type=str,
         default="TB2J_results",
     )
+    parser.add_argument(
+        "--main_path",
+        help="The path containning the reference structure.",
+        type=str,
+        default=None
+    )
 
     args = parser.parse_args()
     # merge(*(args.directories), args.type.strip().lower(), path=args.output_path)
     # merge(*(args.directories), method=args.type.strip().lower(), path=args.output_path)
-    merge2(args.directories, args.type.strip().lower(), path=args.output_path)
+    #merge2(args.directories, args.type.strip().lower(), path=args.output_path)
+    merge(*args.directories, main_path=args.main_path, write_path=args.output_path)
 
 
 main()

{TB2J-0.8.2.7 → TB2J-0.9.0}/scripts/TB2J_rotate.py

@@ -14,9 +14,14 @@ def main():
         default="xyz",
         type=str,
     )
+    parser.add_argument(
+        "--noncollinear",
+        action="store_true",
+        help="If present, six different configurations will be generated. These are required for non-collinear systems."
+    )
 
     args = parser.parse_args()
-    rotate_xyz(args.fname, ftype=args.ftype)
+    rotate_xyz(args.fname, ftype=args.ftype, noncollinear=args.noncollinear)
 
 
 if __name__ == "__main__":

TB2J-0.9.0/scripts/TB2J_rotateDM.py

@@ -0,0 +1,21 @@
+#!/usr/bin/env python3
+import argparse
+from TB2J.rotate_siestaDM import rotate_DM
+
+def main():
+    parser = argparse.ArgumentParser(description="")
+    parser.add_argument(
+        "--fdf_fname", help="Name of the *.fdf siesta file."
+    )
+    parser.add_argument(
+        "--noncollinear",
+        action="store_true",
+        help="If present, six different configurations will be generated. These are required for non-collinear systems."
+    )
+
+    args = parser.parse_args()
+    rotate_DM(args.fdf_fname, noncollinear=args.noncollinear)
+
+
+if __name__ == "__main__":
+    main()

{TB2J-0.8.2.7 → TB2J-0.9.0}/setup.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 from setuptools import setup, find_packages
 
-__version__ = "0.8.2.7"
+__version__ = "0.9.0"
 
 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. """
 
@@ -19,6 +19,7 @@ setup(
         "scripts/siesta2J.py",
         "scripts/abacus2J.py",
         "scripts/TB2J_rotate.py",
+        "scripts/TB2J_rotateDM.py",
         "scripts/TB2J_merge.py",
         "scripts/TB2J_magnon.py",
         "scripts/TB2J_magnon_dos.py",

TB2J-0.8.2.7/TB2J/__init__.py

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

TB2J-0.8.2.7/TB2J/io_merge.py

@@ -1,435 +0,0 @@
-import os
-import copy
-import numpy as np
-from scipy.spatial.transform import Rotation
-from TB2J.io_exchange import SpinIO
-from TB2J.tensor_rotate import remove_components
-from TB2J.Jtensor import DMI_to_Jtensor, Jtensor_to_DMI
-from TB2J.tensor_rotate import Rzx, Rzy, Rzz, Ryz, Rxz
-
-
-def test_rotation_matrix():
-    x = [1, 0, 0]
-    y = [0, 1, 0]
-    z = [0, 0, 1]
-    print(Rxz.apply(x))
-    print(Ryz.apply(y))
-    print(Rzx.apply(z))
-    print(Rzy.apply(z))
-
-
-def recover_DMI_from_rotated_structure(Ddict, rotation):
-    """
-    Recover the DMI vector from the rotated structure.
-    D: the dictionary of DMI vector in the rotated structure.
-    rotation: the rotation operator from the original structure to the rotated structure.
-    """
-    for key, val in Ddict.items():
-        Ddict[key] = rotation.apply(val, inverse=True)
-    return Ddict
-
-
-def recover_Jani_fom_rotated_structure(Janidict, rotation):
-    """
-    Recover the Jani tensor from the rotated structure.
-    Janidict: the dictionary of Jani tensor in the rotated structure.
-    rotation: the  from the original structure to the rotated structure.
-    """
-    R = rotation.as_matrix()
-    RT = R.T
-    for key, Jani in Janidict.items():
-        # Note: E=Si J Sj , Si'= Si RT, Sj' = R Sj,
-        #       Si' J' Sj' = Si RT R J RT R Sj => J' = R J RT
-        #       But here we are doing the opposite rotation back to
-        #       the original axis, so we replace R with RT.
-        Janidict[key] = RT @ Jani @ R
-    return Janidict
-
-
-def recover_spinat_from_rotated_structure(spinat, rotation):
-    """
-    Recover the spinat from the rotated structure.
-    spinat: the spinat in the rotated structure.
-    rotation: the rotation operator from the original structure to the rotated structure.
-    """
-    for i, spin in enumerate(spinat):
-        spinat[i] = rotation.apply(spin, inverse=True)
-    return spinat
-
-
-# test_rotation_matrix()
-
-# R_xyz = [Rxz.as_matrix(), Ryz.as_matrix(), np.eye(3, dtype=float)]
-
-
-def rot_merge_DMI(Dx, Dy, Dz):
-    Dx_z = Rzx.apply(Dx)
-    Dy_z = Rzy.apply(Dy)
-    D = (
-        np.array([0.0, 0.5, 0.5]) * Dx_z
-        + np.array([0.5, 0.0, 0.5]) * Dy_z
-        + np.array([0.5, 0.5, 0.0]) * Dz
-    )
-    return D
-
-
-def rot_merge_DMI2(Dx, Dy, Dz):
-    Dx_z = Rzx.apply(Dx)
-    Dy_z = Rzy.apply(Dy)
-    D = (
-        np.array([1, 0, 0]) * Dx_z
-        + np.array([0, 1, 0]) * Dy_z
-        + np.array([0, 0, 1]) * Dz
-    )
-    return D
-
-
-def merge_DMI(Dx, Dy, Dz):
-    D = (
-        np.array([0.0, 0.5, 0.5]) * Dx
-        + np.array([0.5, 0.0, 0.5]) * Dy
-        + np.array([0.5, 0.5, 0.0]) * Dz
-    )
-    return D
-
-
-def merge_DMI2(Dx, Dy, Dz):
-    D = np.array([1, 0, 0]) * Dx + np.array([0, 1, 0]) * Dy + np.array([0, 0, 1]) * Dz
-    return D
-
-
-def swap_direction(m, idirections):
-    """
-    swap two directions of a tensor m.
-    idirections: the index of the two directions.
-    """
-    idirections = list(idirections)
-    inv = [idirections[1], idirections[0]]
-    n = np.copy(m)
-    n[:, idirections] = n[:, inv]
-    n[idirections, :] = n[inv, :]
-    return n
-
-
-def test_swap():
-    m = np.reshape(np.arange(9), (3, 3))
-    print(m)
-    print(swap_direction(m, [0, 1]))
-
-
-def merge_Jani(Janix, Janiy, Janiz):
-    # This is wrong.
-    # Jani = (
-    #    np.array([[0, 0, 0], [0, 1, 1], [0, 1, 1]]) * Janix
-    #    + np.array([[1, 0, 1], [0, 0, 0], [1, 0, 1]]) * Janiy
-    #    + np.array([[1, 1, 0], [1, 1, 0], [0, 0, 0]]) * Janiz
-    # ) / 2.0
-    wx = np.array([[0, 0, 0], [0, 1, 1], [0, 1, 1]])
-    wy = np.array([[1, 0, 1], [0, 0, 0], [1, 0, 1]])
-    wz = np.array([[1, 1, 0], [1, 1, 0], [0, 0, 0]])
-    Jani = (wx * Janix + wy * Janiy + wz * Janiz) / (wx + wy + wz)
-    return Jani
-
-
-def read_pickle(path):
-    p1 = os.path.join(path, "TB2J_results", "TB2J.pickle")
-    p2 = os.path.join(path, "TB2J.pickle")
-    if os.path.exists(p1) and os.path.exists(p2):
-        print(f" WARNING!: Both file {p1} and {p2} exist. Use default {p1}.")
-    if os.path.exists(p1):
-        ret = SpinIO.load_pickle(os.path.join(path, "TB2J_results"))
-    elif os.path.exists(p2):
-        ret = SpinIO.load_pickle(path)
-    else:
-        raise FileNotFoundError(f"Cannot find either file {p1} or {p2}")
-    return ret
-
-
-class Merger2:
-    def __init__(self, paths, method):
-        self.method = method
-        if method.lower() == "spin":
-            self.load_with_rotated_spin(paths)
-        elif method.lower() == "structure":
-            self.load_with_rotated_structure(paths)
-        else:
-            raise ValueError("method should be either 'spin' or 'structure'")
-
-    def load_with_rotated_structure(self, paths):
-        """
-        Merge TB2J results from multiple calculations.
-        :param paths: a list of paths to the TB2J results.
-        :param method: 'structure' or 'spin'
-        """
-        self.paths = paths
-        if len(self.paths) != 3:
-            raise ValueError(
-                "The number of paths should be 3, with structure rotated from z to x, y, z"
-            )
-        for i, path in enumerate(self.paths):
-            read_pickle(path)
-        self.indata = [read_pickle(path) for path in paths]
-
-        self.dat = copy.deepcopy(self.indata[-1])
-        # self.dat.description += (
-        #    "Merged from TB2J results in paths: \n  " + "\n  ".join(paths) + "\n"
-        # )
-        Rotations = [Rzx, Rzy, Rzz]
-        for dat, rotation in zip(self.indata, Rotations):
-            dat.spinat = recover_spinat_from_rotated_structure(dat.spinat, rotation)
-            dat.dmi_ddict = recover_DMI_from_rotated_structure(dat.dmi_ddict, rotation)
-            dat.Jani_dict = recover_Jani_fom_rotated_structure(dat.Jani_dict, rotation)
-
-    def load_with_rotated_spin(self, paths):
-        """
-        Merge TB2J results from multiple calculations.
-        :param paths: a list of paths to the TB2J results.
-        :param method: 'structure' or 'spin'
-        """
-        self.paths = paths
-        self.indata = [read_pickle(path) for path in paths]
-        self.dat = copy.deepcopy(self.indata[-1])
-        # self.dat.description += (
-        #    "Merged from TB2J results in paths: \n  " + "\n  ".join(paths) + "\n"
-        # )
-
-    def merge_Jani(self):
-        """
-        Merge the anisotropic exchange tensor.
-        """
-        Jani_dict = {}
-        for key, Jani in self.dat.Jani_dict.items():
-            R, i, j = key
-            weights = np.zeros((3, 3), dtype=float)
-            Jani_sum = np.zeros((3, 3), dtype=float)
-            for dat in self.indata:
-                Si = dat.get_spin_ispin(i)
-                Sj = dat.get_spin_ispin(j)
-                # print(f"{Si=}, {Sj=}")
-                Jani = dat.get_Jani(i, j, R, default=np.zeros((3, 3), dtype=float))
-                Jani_removed, w = remove_components(
-                    Jani,
-                    Si,
-                    Sj,
-                    remove_indices=[[0, 2], [1, 2], [2, 2], [2, 1], [2, 0]],
-                )
-                w = Jani_removed / Jani
-                Jani_sum += Jani * w  # Jani_removed
-                # print(f"{Jani* w=}")
-                weights += w
-            # print(f"{weights=}")
-            if np.any(weights == 0):
-                raise RuntimeError(
-                    "The data set to be merged does not give a complete anisotropic J tensor, please add more data"
-                )
-            Jani_dict[key] = Jani_sum / weights
-        self.dat.Jani_dict = Jani_dict
-
-    def merge_DMI(self):
-        """
-        merge the DMI vector
-        """
-        DMI = {}
-        for key, D in self.dat.dmi_ddict.items():
-            R, i, j = key
-            weights = np.zeros((3, 3), dtype=float)
-            Dtensor_sum = np.zeros((3, 3), dtype=float)
-            for dat in self.indata:
-                Si = dat.get_spin_ispin(i)
-                Sj = dat.get_spin_ispin(j)
-                D = dat.get_DMI(i, j, R, default=np.zeros((3,), dtype=float))
-                Dtensor = DMI_to_Jtensor(D)
-                Dtensor_removed, w = remove_components(
-                    Dtensor, Si, Sj, remove_indices=[[0, 1], [1, 0]]
-                )
-                Dtensor_sum += Dtensor * w  # Dtensor_removed
-                weights += w
-            if np.any(weights == 0):
-                raise RuntimeError(
-                    "The data set to be merged does not give a complete DMI vector, please add more data"
-                )
-            DMI[key] = Jtensor_to_DMI(Dtensor_sum / weights)
-        self.dat.dmi_ddict = DMI
-
-    def merge_Jiso(self):
-        """
-        merge the isotropic exchange
-        """
-        Jiso = {}
-        for key, J in self.dat.exchange_Jdict.items():
-            R, i, j = key
-            weights = 0.0
-            Jiso_sum = 0.0
-            for dat in self.indata:
-                Si = dat.get_spin_ispin(i)
-                Sj = dat.get_spin_ispin(j)
-                J = dat.get_Jiso(i, j, R, default=0.0)
-                Jiso_sum += J  # *np.eye(3, dtype=float)
-                weights += 1.0
-            if np.any(weights == 0):
-                raise RuntimeError(
-                    "The data set to be merged does not give a complete isotropic exchange, please add more data"
-                )
-            Jiso[key] = Jiso_sum / weights
-        self.dat.exchange_Jdict = Jiso
-
-    def write(self, path="TB2J_results"):
-        """
-        Write the merged TB2J results to a folder.
-        :param path: the path to the folder to write the results.
-        """
-        self.dat.description += (
-            "Merged from TB2J results in paths: \n  " + "\n  ".join(self.paths) + "\n"
-        )
-        if self.method == "spin":
-            self.dat.description += (
-                ", which are from DFT data with various spin orientations. \n"
-            )
-        elif self.method == "structure":
-            self.dat.description += ", which are from DFT data with structure with z axis rotated to x, y, z\n"
-        self.dat.description += "\n"
-        self.dat.write_all(path=path)
-
-
-class Merger:
-    def __init__(self, path_x, path_y, path_z, method="structure"):
-        assert method in ["structure", "spin"]
-        self.dat_x = read_pickle(path_x)
-        self.dat_y = read_pickle(path_y)
-        self.dat_z = read_pickle(path_z)
-        self.dat = copy.copy(self.dat_z)
-        self.paths = [path_x, path_y, path_z]
-        self.method = method
-
-    def merge_Jani(self):
-        Jani_dict = {}
-        Janixdict = self.dat_x.Jani_dict
-        Janiydict = self.dat_y.Jani_dict
-        Janizdict = self.dat_z.Jani_dict
-        for key, Janiz in Janizdict.items():
-            try:
-                R, i, j = key
-                keyx = R
-                keyy = R
-                Janix = Janixdict[(tuple(keyx), i, j)]
-                Janiy = Janiydict[(tuple(keyy), i, j)]
-            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
-                )
-            if self.method == "spin":
-                Jani_dict[key] = merge_Jani(Janix, Janiy, Janiz)
-            else:
-                Jani_dict[key] = merge_Jani(
-                    swap_direction(Janix, (0, 2)), swap_direction(Janiy, (1, 2)), Janiz
-                )
-        self.dat.Jani_dict = Jani_dict
-
-    def merge_Jiso(self):
-        Jdict = {}
-        Jxdict = self.dat_x.exchange_Jdict
-        Jydict = self.dat_y.exchange_Jdict
-        Jzdict = self.dat_z.exchange_Jdict
-        for key, J in Jzdict.items():
-            try:
-                Jx = Jxdict[key]
-                Jy = Jydict[key]
-                Jz = Jzdict[key]
-            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] = (Jx + Jy + Jz) / 3.0
-        self.dat.exchange_Jdict = Jdict
-
-    def merge_DMI(self):
-        dmi_ddict = {}
-        if self.dat_x.has_dmi and self.dat_y.has_dmi and self.dat_z.has_dmi:
-            Dxdict = self.dat_x.dmi_ddict
-            Dydict = self.dat_y.dmi_ddict
-            Dzdict = self.dat_z.dmi_ddict
-            for key, Dz in Dzdict.items():
-                try:
-                    R, i, j = key
-                    keyx = R
-                    keyy = R
-                    Dx = Dxdict[(tuple(keyx), i, j)]
-                    Dy = Dydict[(tuple(keyy), i, j)]
-                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
-                    )
-                if self.method == "structure":
-                    dmi_ddict[key] = rot_merge_DMI(Dx, Dy, Dz)
-                else:
-                    dmi_ddict[key] = merge_DMI(Dx, Dy, Dz)
-            self.dat.dmi_ddict = dmi_ddict
-
-        dmi_ddict = {}
-        try:
-            Dxdict = self.dat_x.debug_dict["DMI2"]
-            Dydict = self.dat_y.debug_dict["DMI2"]
-            Dzdict = self.dat_z.debug_dict["DMI2"]
-            for key, Dz in Dzdict.items():
-                try:
-                    R, i, j = key
-                    keyx = R
-                    keyy = R
-                    Dx = Dxdict[(tuple(keyx), i, j)]
-                    Dy = Dydict[(tuple(keyy), i, j)]
-                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
-                    )
-                if self.method == "structure":
-                    dmi_ddict[key] = rot_merge_DMI2(Dx, Dy, Dz)
-                elif self.method == "spin":
-                    dmi_ddict[key] = merge_DMI2(Dx, Dy, Dz)
-
-            self.dat.debug_dict["DMI2"] = dmi_ddict
-        except:
-            pass
-
-    def write(self, path="TB2J_results"):
-        self.dat.description += (
-            "Merged from TB2J results in paths: \n  " + "\n  ".join(self.paths) + "\n"
-        )
-        if self.method == "spin":
-            self.dat.description += (
-                ", which are from DFT data with spin along x, y, z orientation\n"
-            )
-        elif self.method == "structure":
-            self.dat.description += ", which are from DFT data with structure with z axis rotated to x, y, z\n"
-        self.dat.description += "\n"
-        self.dat.write_all(path=path)
-
-
-def merge(path_x, path_y, path_z, method, save=True, path="TB2J_results"):
-    m = Merger(path_x, path_y, path_z, method)
-    m.merge_Jiso()
-    m.merge_DMI()
-    m.merge_Jani()
-    if save:
-        m.write(path=path)
-    return m.dat
-
-
-def merge2(paths, method, save=True, path="TB2J_results"):
-    """
-    Merge TB2J results from multiple calculations.
-    :param paths: a list of paths to the TB2J results.
-    :param method: 'structure' or 'spin'
-    :param save: whether to save the merged results.
-    :param path: the path to the folder to write the results.
-    """
-    m = Merger2(paths, method)
-    m.merge_Jiso()
-    m.merge_DMI()
-    m.merge_Jani()
-    if save:
-        m.write(path=path)
-    return m.dat