TB2J 0.8.2.7__py3-none-any.whl → 0.9.0__py3-none-any.whl

TB2J/__init__.py

@@ -1 +1 @@
-__version__ = "0.8.2.7"
+__version__ = "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/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/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/io_merge.py

@@ -1,435 +1,184 @@
 import os
 import copy
+import warnings
 import numpy as np
-from scipy.spatial.transform import Rotation
+from itertools import combinations_with_replacement, product
 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
 
+u0 = np.zeros(3)
+uy = np.array([0.0, 1.0, 0.0])
+uz = np.array([0.0, 0.0, 1.0])
 
-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 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])
 
-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
+    return coefficients, u, v
 
+def get_projections(a, b, tol=1e-2):
 
-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
+    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
 
-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
+class SpinIO_merge(SpinIO):
+    def __init__(self, *args, **kwargs):
+        super(SpinIO_merge, self).__init__(*args, **kwargs)
+        self.projv = None
 
+    def _set_projection_vectors(self):
 
-def test_swap():
-    m = np.reshape(np.arange(9), (3, 3))
-    print(m)
-    print(swap_direction(m, [0, 1]))
+        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
 
-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
+    @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")
+    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"))
+        ret = SpinIO_merge.load_pickle(os.path.join(path, 'TB2J_results'))
     elif os.path.exists(p2):
-        ret = SpinIO.load_pickle(path)
+        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]
 
-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)
+        if main_path is None:
+            self.main_dat = copy.deepcopy(self.dat[-1])
         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
+            self.main_dat = read_pickle(main_path)
+            self.dat.append(copy.deepcopy(self.main_dat))
 
-    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
+        self._set_projv()
+        
+    def _set_projv(self):
 
-    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"
+        cell = self.main_dat.atoms.cell.array
+        rotated_cells = np.stack(
+            [obj.atoms.cell.array for obj in self.dat], axis=0
         )
-        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
+        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 = {}
-        Janixdict = self.dat_x.Jani_dict
-        Janiydict = self.dat_y.Jani_dict
-        Janizdict = self.dat_z.Jani_dict
-        for key, Janiz in Janizdict.items():
+        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
-                keyx = R
-                keyy = R
-                Janix = Janixdict[(tuple(keyx), i, j)]
-                Janiy = Janiydict[(tuple(keyy), i, j)]
+                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
-                )
-            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
+                    % 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 = {}
-        Jxdict = self.dat_x.exchange_Jdict
-        Jydict = self.dat_y.exchange_Jdict
-        Jzdict = self.dat_z.exchange_Jdict
-        for key, J in Jzdict.items():
+        Jdict={}
+        for key in self.main_dat.exchange_Jdict.keys():
             try:
-                Jx = Jxdict[key]
-                Jy = Jydict[key]
-                Jz = Jzdict[key]
+               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] = (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
+                        % err)
+            Jdict[key] = J
+        self.main_dat.exchange_Jdict = Jdict
+               
 
+    def merge_DMI(self):
         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():
+        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
-                    keyx = R
-                    keyy = R
-                    Dx = Dxdict[(tuple(keyx), i, j)]
-                    Dy = Dydict[(tuple(keyy), i, j)]
+                    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
-                    )
-                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
-
+                        % 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 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)
+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.write(path=path)
+        m.main_dat.write_all(path=write_path)
     return m.dat

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/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/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/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/spinham/h_matrix.py

@@ -0,0 +1,68 @@
+import numpy as np
+import matplotlib.pyplot as plt
+import aiida
+from aiida_tb2j.data import ExchangeData
+
+def plot_dispersion(bands, kpoint_labels, color='blue', title=None):
+
+    fig, axs = plt.subplots(1, 1, constrained_layout=True)
+    fig.set_size_inches(6, 6/1.618)
+
+    '''
+    Plot the bands
+    '''
+    kpoints = np.arange(len(bands))
+    axs.plot(kpoints, bands, color=color, linewidth=1.5)
+
+    '''
+    Plot the symmetry points
+    '''
+    bmin = bands.min(); bmax = bands.max()
+    ymin = bmin - 0.05*np.abs(bmin-bmax); ymax = bmax + 0.05*np.abs(bmax-bmin);
+    axs.set_xticks(kpoint_labels[0], kpoint_labels[1], fontsize=10)
+    axs.vlines(x=kpoint_labels[0], ymin=ymin, ymax=ymax, color='black', linewidth=0.5)
+    axs.set_xlim([0, len(kpoints)])
+    axs.set_ylim([ymin, ymax])
+
+    if title is not None:
+        plt.title(title, fontsize=10)
+
+    plt.show()
+
+
+if __name__ == "__main__":
+    
+    from argparse import ArgumentParser
+
+    parser = ArgumentParser()
+    parser.add_argument('-f', '--pickle_filename', type=str, help="Path of the 'TB2J.pickle' file.", required=True)
+    args = parser.parse_args()
+    
+    '''
+    Right now the implementation depends on AiiDA and so we must create and load an AiiDA profile,
+    even if we do not store any information on a data base.
+    '''
+    aiida.load_profile()
+    '''
+    Create an ExchangeData object with the informations from the TB2J.pickle file
+    '''
+    exchange = ExchangeData.load_tb2j(pickle_file=args.pickle_filename, isotropic=False, pbc=(True, True, True))
+    '''
+    Compute the magnon band structure along a high symmetry path generated with
+    the ASE package. The informations is stored in an AiiDA BandsData object.
+    Here tol is the symmetry tolerance to determine the space group of the system.
+    They are in units of eV
+    '''
+    magnon_data = exchange.get_magnon_bands(npoints=300, tol=1e-1, with_DMI=True, with_Jani=True)
+    magnon_bands = 1000*magnon_data.get_bands() # Convert to meV
+    raw_labels = [(k, '$\Gamma$') if s == 'GAMMA' else (k, s) for k, s in magnon_data.labels]
+    kpoint_labels = list( zip( *raw_labels ) )
+    plot_dispersion(magnon_bands, kpoint_labels, color='blue', title='Magnon Bands')
+    '''
+    We can also obtain the dynamical matrix h instead of the actual magnon bands. The result
+    is stored in a numpy array with shape (number of kpoints, 2*natoms, 2*natoms)
+    '''
+    kpoints = magnon_data.get_kpoints() # The shape of the kpoints must be (nkpoints, 3)
+    h_matrix = 1000*exchange._H_matrix(kpoints, with_DMI=True, with_Jani=True) # Convert to meV
+    h_dispersion = np.linalg.eigvalsh(h_matrix) # We can also get the eigenvectors with np.linalg.eigh
+    plot_dispersion(h_dispersion, kpoint_labels, color='red', title='h matrix dispersion')

TB2J/spinham/obtain_J.py

@@ -0,0 +1,79 @@
+import numpy as np
+from aiida_tb2j.data import ExchangeData
+from aiida_tb2j.data.exchange import get_rotation_arrays
+from itertools import combinations_with_replacement
+
+ux, uy, uz = np.eye(3).reshape((3, 1, 3))
+
+def combine_arrays(u, v):
+
+    return np.concatenate([u*v, np.roll(u, -1, axis=-1)*v, np.roll(v, -1, axis=-1)*u], axis=-1)
+
+def get_coefficients(magmoms, indices):
+
+    i, j = indices
+
+    U, V = zip(*[get_rotation_arrays(magmoms, u=u) for u in [ux, uy, uz]])
+    U = np.stack(U).swapaxes(0, 1)
+    V = np.stack(V).swapaxes(0, 1)
+
+    uc = combine_arrays(U[i], U[j].conj())
+    ur = combine_arrays(U[i], U[j])
+    uc2 = combine_arrays(U[i].conj(), U[j])
+    u = np.concatenate([uc, ur, uc2], axis=1)
+
+    return u, V
+
+def get_C(H0, u, V):
+
+    n = int(H0.shape[-1]/2)
+    upi = np.triu_indices(n)
+    dig = np.diag_indices(n)
+    
+    i, j = upi
+    AB0 = H0[:, [i, i, i+n], [j, j+n, j+n]]
+    AB0 = np.swapaxes(AB0, 0, 2).reshape(len(i), 9)
+    J0_flat = np.linalg.solve(u, AB0)
+
+    J0 = np.empty((n, n, 3, 3), dtype=complex)
+    J0[*upi] = J0_flat[:, [0, 6, 5, 3, 1, 7, 8, 4, 2]].reshape(-1, 3, 3)
+    J0 += J0.swapaxes(0, 1)
+    J0[*dig] = 0.0
+
+    C = np.array([np.diag(a) for a in np.einsum('imx,ijxy,jmy->mi', V, 2*J0, V)]) 
+
+    return C
+
+def get_J(H, kpoints, exchange):
+
+    n = int(H.shape[-1]/2)
+    upi = np.triu_indices(n)
+    dig = np.diag_indices(n)
+    i, j = upi
+
+    magmoms = exchange.magmoms()[np.unique(exchange.pairs)]
+    magmoms /= np.linalg.norm(magmoms, axis=-1).reshape(-1, 1)
+    u, V = get_coefficients(magmoms, indices=upi)
+
+    H0 = np.stack([1000*exchange._H_matrix(kpoints=np.zeros((1, 3)), with_DMI=True, with_Jani=True, u=u) for u in [ux, uy, uz]])[:, 0, :, :]
+    C = get_C(H0, u, V)
+    H[:, :, :n, :n] += C.reshape(3, 1, n, n)
+    H[:, :, n:, n:] += C.reshape(3, 1, n, n)
+
+    AB = H[:, :, [i, i, i+n], [j, j+n, j+n]]
+    AB[:, :, 2, :] = AB[:, ::-1, 2, :]
+    AB = np.moveaxis(AB, [2, 3], [1, 0]).reshape(len(i), 9, -1)
+
+    vectors = exchange.get_vectors()
+    exp_summand = np.exp( -2j*np.pi*vectors @ kpoints.T )
+    nAB = np.einsum('nik,ndk->nid', AB, exp_summand) / len(kpoints)
+    
+    ii = np.where(i == j)
+    i0 = np.where(np.linalg.norm(vectors, axis=-1) == 0.0)
+    J = np.linalg.solve(u, nAB).swapaxes(1, 2)
+    J = J[:, :, [0, 6, 5, 3, 1, 7, 8, 4, 2]].reshape(len(i), -1, 3, 3)
+    J *= -1
+    J[ii] *= 2
+    J[i0] *= 0
+
+    return J

{TB2J-0.8.2.7.data → TB2J-0.9.0.data}/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.data → TB2J-0.9.0.data}/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.data/scripts/TB2J_rotateDM.py

@@ -0,0 +1,21 @@
+#!python
+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.dist-info → TB2J-0.9.0.dist-info}/METADATA

@@ -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.dist-info → TB2J-0.9.0.dist-info}/RECORD

@@ -2,31 +2,32 @@ TB2J/Jdownfolder.py,sha256=Nw2ixvn2Uq-o1wficz6rdaYHjfRN3U_kQCvrNJGNb68,6980
 TB2J/Jtensor.py,sha256=0fhfOcfVQGu75gytEnApKWTJZfg9ksKJ0anJgco5wRQ,3179
 TB2J/Oiju.py,sha256=cNGv8N5uH_swGq7cnAt2OyiDfqtjLlLrwseGu0E4iaM,3383
 TB2J/Oiju_epc.py,sha256=oytM3NYW7nWmklrGgNlqwIpI_JYv_hb7ZnR4o9nYNog,6809
-TB2J/__init__.py,sha256=SgNb_x-EiSsKRMJsfDX9rLKVaPFJDAj-eBAlhqvvaFM,24
+TB2J/__init__.py,sha256=H9NWRZb7NbeRRPLP_V1fARmLNXranorVM-OOY-8_2ug,22
 TB2J/basis.py,sha256=DFo6_QUwjBwisP6zGxvoO0lpGTMDPAOkiL9giNCjOjA,1558
 TB2J/citation.py,sha256=gcQeyJZaT1Qrtsl8Y3s4neOH3-vvgmIcCvXeV2o3vj0,2891
 TB2J/contour.py,sha256=aw8LX6wVFCRPhcpkzuI0jGnHisvk4cezvUhkF_6Yx94,2633
 TB2J/cut_cell.py,sha256=kr9WeQhBQLm8QXL2B3NcsSYmSw-OAtJk3f9wksAOZbs,2952
 TB2J/density_matrix.py,sha256=D5k8Oe21OCiLVORNYbo4TZOFG0slrQSbj91kJ3TMFjs,1514
 TB2J/epc.py,sha256=zLbtqZJhDr8DnnGN6YENcXwrMb3Qxu6KB08mLy9Pw20,3474
-TB2J/exchange.py,sha256=UmZU5h91BPql3ylNALvzMJWTxkfzObZ1OVMxj2Hmp7A,29570
+TB2J/exchange.py,sha256=Xg2fuUZbj-Icpqc65Ictllxvdvct8Ec4KQPAmEyo0oM,29586
 TB2J/exchangeCL2.py,sha256=TIr-d2X56AiGe4qEhyXyZhRuwXvQG6clJMwDmjnTOaE,10985
 TB2J/exchange_pert.py,sha256=jmFMtQbYa_uczM4VAeS6TijkIHRFIqEzZJswzE9Wfuo,8523
 TB2J/exchange_qspace.py,sha256=ZL68qBGFUaQ9BsSPsJaaoWOr9RssPiqX34R_9I3nk_8,8436
 TB2J/gpaw_wrapper.py,sha256=aJ--9Dtyq7jOP1Hkh-Sh1nWcfXm6zKcljOCO0DNCAr0,6890
-TB2J/green.py,sha256=UCDIkpH2HNVglvZZKnxigOOBMLdRBUpkiOqC13fitQE,13011
+TB2J/green.py,sha256=X-D8UZcIyz6zh_0W9VgUUv5yXPP3KWJ6C03m6CMWE3o,13377
 TB2J/greentest.py,sha256=2ISSfhor9ecSEOi_E6b4Cv26wEIQlwlzca0ru8z44_E,1603
-TB2J/io_merge.py,sha256=2dYrQFHSnb_8fwbQiVod9GyaT-BotawA26eagXWUyMg,15265
+TB2J/io_merge.py,sha256=t85k3L6IL9X5ys-PWK7CzResb3xJsyqM3LAlKPUe9vM,6825
 TB2J/kpoints.py,sha256=6XK2KqTncidEq3o9GuO6VEZRPNTRtWeXg9QfcV-9smI,532
 TB2J/manager.py,sha256=4-4x9jJRHpUEqJuhc5HqpXfh2-Ze5G9Wg8gOtn-AqR4,15372
 TB2J/mathutils.py,sha256=tHA6q3KPDpXLIbZHdDZ2NU5s886VVM_oEG490zQ6Ris,300
-TB2J/myTB.py,sha256=cm9Kkyzi686QyoxrR3lm4rsSnE6Imee3-j2xM78XnGI,17721
+TB2J/myTB.py,sha256=ok_B4my29bOIghMSZfx0Es6G8FaXaIiLP4gPxTdSj00,17659
 TB2J/orbmap.py,sha256=RCMJkOPGbfPrcZzcc5ia1ZMKBQWxGcyj8W1ve8BJaEw,6669
 TB2J/pauli.py,sha256=_FIF62jq2CkQdWC473a3S2F6NmzCdeCnglO9PjNVmMI,4120
 TB2J/pert.py,sha256=RaCJfewl0doht4cjAnzzGKe-uj2le4aqe0iPKFrq9fo,1192
 TB2J/plot.py,sha256=AnFIFWE2vlmj7Z6f_7-dX_O1stJN-qbuiurPj43dUCM,4104
-TB2J/rotate_atoms.py,sha256=-fxlQN7LbyQAbGUCUBqDJ5ENR0pT8MLBd-5sLxaX_vI,3031
-TB2J/sisl_wrapper.py,sha256=BMYaj7-nVxKhYENEwafsyZHcRm1Z66p5Yr-zsxdiFcY,14823
+TB2J/rotate_atoms.py,sha256=Dwptn-wdDW4zYzjYb95yxTzuZOe9WPuLjh3d3-YcSs0,3277
+TB2J/rotate_siestaDM.py,sha256=eR97rspdrRaK9YTwQwUKfobI0S9UnEcbEZ2f5IgR7Tk,1070
+TB2J/sisl_wrapper.py,sha256=A5x1-tt8efUSPeGY5wM5m6-pJYQFXTCzQHVqD6RBa2g,14792
 TB2J/supercell.py,sha256=4hgLGPBLRUDhtD-eF29v46ex7fHdkH-OENjS2wGLFww,19588
 TB2J/tensor_rotate.py,sha256=4-DfT_Mg5e40fbd74M5W0D5DqmUq-kVOOLDkkkI834A,8083
 TB2J/utest.py,sha256=z_ahi7tpHQF9WlHNQihcQ7qzfezRJQXQt28eB1X_z64,3897
@@ -34,7 +35,7 @@ TB2J/utils.py,sha256=_ARYKAeWfP1p5w0mEl-d7KwNfXoqC85TveYl0iCBD3c,9880
 TB2J/versioninfo.py,sha256=wZwS9QDFRVDe7rf8JyPDDI8UGdTQiO6Pb_sWv8GAegA,337
 TB2J/abacus/__init__.py,sha256=5sHiDnF2L-Y80QeET9zOiS83a5T_TQAXvnIhcYB6wNU,56
 TB2J/abacus/abacus_api.py,sha256=D_NyXW-Pno92d3RVHByx0l1HDPHQAvXsmQVt8cfIGR8,7267
-TB2J/abacus/abacus_wrapper.py,sha256=Pqm1MMcD5oQ1Pd4x0EkBh6yRindAps0FIf8LNGOlQok,8492
+TB2J/abacus/abacus_wrapper.py,sha256=QR3ZW6v-d7dgneKwBO5s9FfCjBp-fkWMEaTO4SlcROA,8461
 TB2J/abacus/gen_exchange_abacus.py,sha256=lKZqkWMnLQtaSwgn8O5Fzr-pV6tzwoMqfZU_vbET6gU,2973
 TB2J/abacus/orbital_api.py,sha256=l48Hn5z7TA0TH7Is4NDmz74b6B9L2ztYO4dRR37U4mQ,1562
 TB2J/abacus/stru_api.py,sha256=aBKKlZ2hvAZChVCfNxRdxH51rfHKqZn6kOlazY-yW8k,67888
@@ -53,8 +54,10 @@ TB2J/io_exchange/io_vampire.py,sha256=UllC4twf06_q2vBCnAYFzEDGvS8mSefwQXDquBuyc0
 TB2J/spinham/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 TB2J/spinham/base_parser.py,sha256=oQRHvFE_BlUtTaTZykKgvicu40oXcbICB-D1aAt-qlA,2196
 TB2J/spinham/constants.py,sha256=y4-hRyl5EAR42k24Oa5XhAsUQtKVn1MAgyqNf-p3PrM,762
+TB2J/spinham/h_matrix.py,sha256=MfHIz6RViKkEB3Mu-WcwNx5uk7A5sjAlbqVG9wYA4xk,2784
 TB2J/spinham/hamiltonian.py,sha256=OfsjlGIgFwpXaohopZcgPamSfjm3X46_zc245eyTr_A,16607
 TB2J/spinham/hamiltonian_terms.py,sha256=7e84tfEjvAfZltUkrSWi1sUEiW_itLKy83lxi5iBpcQ,9714
+TB2J/spinham/obtain_J.py,sha256=sg8tiCRRLEN57Olb3MHIuqkDhAkmu-w87AkM00ylXtA,2401
 TB2J/spinham/plot.py,sha256=tLLNqFAATVrP1kmSVLPKzn686i-CUyqu4qgOcs-okHI,6599
 TB2J/spinham/qsolver.py,sha256=Sr9I3aGfVNYn5wzwPx1QonHe6ZZUXBAujWRa7nTA5u4,4986
 TB2J/spinham/spin_api.py,sha256=oN3AKg1WQl0YzR4f5ealcJOaVoAy8d7HodIwrbXvQeY,2219
@@ -63,17 +66,18 @@ TB2J/spinham/supercell.py,sha256=y17uUC6r3gQb278FhxIW4CABihfLTvKFj6flyXrCPR8,122
 TB2J/wannier/__init__.py,sha256=7ojCbM84PYv1X1Tbo4NHI-d3gWmQsZB_xiYqbfxVV1E,80
 TB2J/wannier/w90_parser.py,sha256=dbd63LuKyv2DVUzqRINGsbDzEsOxsQyE8_Ear_LQIRg,4620
 TB2J/wannier/w90_tb_parser.py,sha256=qt8pnuprmPp9iIAYwPkPbmEzk6ZPgMq2xognoQp7vwc,4610
-TB2J-0.8.2.7.data/scripts/TB2J_downfold.py,sha256=F9oImXFysejCMP7eIBjbCX2jdHFOCvDW5beF1sG-UM8,1854
-TB2J-0.8.2.7.data/scripts/TB2J_eigen.py,sha256=Qs9v2hnMm2Tpfoa4h53muUKty2dZjwx8948MBoQooNg,1128
-TB2J-0.8.2.7.data/scripts/TB2J_magnon.py,sha256=q7UwAmorRcFNk4tfE7gl_ny05l6p7pbD9Wm_LkIpKEw,3101
-TB2J-0.8.2.7.data/scripts/TB2J_magnon_dos.py,sha256=TMXQvD2dIbO5FZ4tUMmxJgCgH2O2hDAPUNfEKO4z-x4,110
-TB2J-0.8.2.7.data/scripts/TB2J_merge.py,sha256=uZKLM__EyCHwxrQvx3Wd73dOEADp_SqfYC8KQvA-N9g,1622
-TB2J-0.8.2.7.data/scripts/TB2J_rotate.py,sha256=XPacPb7-DaFafBXFdWuNW_eNbjd5XPdNhBRNYhge_cg,634
-TB2J-0.8.2.7.data/scripts/abacus2J.py,sha256=M4B07lvTCDczTPTqvnDh_PERzCARAd09TLKv4aIdSQM,4408
-TB2J-0.8.2.7.data/scripts/siesta2J.py,sha256=hBzS7ZgoHM3oXlTCQd-xVA07Ks2FiIwyRpQWUFITRPE,4303
-TB2J-0.8.2.7.data/scripts/wann2J.py,sha256=2t2hWwyELskYCwkGDziCgiIAnfr6odLLJ6cQBJ2RQwQ,5714
-TB2J-0.8.2.7.dist-info/LICENSE,sha256=CbZI-jyRTjiqIcWa244cRSHJdjjtUNqGR4HeJkgEwJw,1332
-TB2J-0.8.2.7.dist-info/METADATA,sha256=VwLdf9LlN_meROiv7NTa47fBvw1fwVf97mrz4RqWc-c,1464
-TB2J-0.8.2.7.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
-TB2J-0.8.2.7.dist-info/top_level.txt,sha256=whYa5ByLYhl5XnTPBHSWr-IGD6VWmr5Ql2bye2qwV_s,5
-TB2J-0.8.2.7.dist-info/RECORD,,
+TB2J-0.9.0.data/scripts/TB2J_downfold.py,sha256=F9oImXFysejCMP7eIBjbCX2jdHFOCvDW5beF1sG-UM8,1854
+TB2J-0.9.0.data/scripts/TB2J_eigen.py,sha256=Qs9v2hnMm2Tpfoa4h53muUKty2dZjwx8948MBoQooNg,1128
+TB2J-0.9.0.data/scripts/TB2J_magnon.py,sha256=q7UwAmorRcFNk4tfE7gl_ny05l6p7pbD9Wm_LkIpKEw,3101
+TB2J-0.9.0.data/scripts/TB2J_magnon_dos.py,sha256=TMXQvD2dIbO5FZ4tUMmxJgCgH2O2hDAPUNfEKO4z-x4,110
+TB2J-0.9.0.data/scripts/TB2J_merge.py,sha256=y834SF4rIRn1L1ptkhczvavQpC-8Px6DTmDOOSaq_DE,1854
+TB2J-0.9.0.data/scripts/TB2J_rotate.py,sha256=zgiDFuYZNmzKK0rwDmTaYD2OpRlmKA_VGeBx83w2Xwc,873
+TB2J-0.9.0.data/scripts/TB2J_rotateDM.py,sha256=kCvF7gotuqAX1VnJ06cwfVm7RrhrdtiV5v7d9P2Pn_E,567
+TB2J-0.9.0.data/scripts/abacus2J.py,sha256=M4B07lvTCDczTPTqvnDh_PERzCARAd09TLKv4aIdSQM,4408
+TB2J-0.9.0.data/scripts/siesta2J.py,sha256=hBzS7ZgoHM3oXlTCQd-xVA07Ks2FiIwyRpQWUFITRPE,4303
+TB2J-0.9.0.data/scripts/wann2J.py,sha256=2t2hWwyELskYCwkGDziCgiIAnfr6odLLJ6cQBJ2RQwQ,5714
+TB2J-0.9.0.dist-info/LICENSE,sha256=CbZI-jyRTjiqIcWa244cRSHJdjjtUNqGR4HeJkgEwJw,1332
+TB2J-0.9.0.dist-info/METADATA,sha256=4ooTIlcMyCl-axTuL5PI9qfK4i7k5zFEoHFl-CiYXOc,1462
+TB2J-0.9.0.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
+TB2J-0.9.0.dist-info/top_level.txt,sha256=whYa5ByLYhl5XnTPBHSWr-IGD6VWmr5Ql2bye2qwV_s,5
+TB2J-0.9.0.dist-info/RECORD,,