TB2J 0.9.9rc6__py3-none-any.whl → 0.9.9rc7__py3-none-any.whl

TB2J/Jdownfolder.py

@@ -1,7 +1,9 @@
 import os
 from collections import defaultdict
+
 import numpy as np
 from ase.dft.kpoints import monkhorst_pack
+
 from TB2J.io_exchange import SpinIO
 from TB2J.Jtensor import decompose_J_tensor
 
@@ -73,8 +75,8 @@ class JDownfolder:
 class PWFDownfolder:
     def __init__(self, JR, Rlist, iM, iL, qmesh, atoms=None, iso_only=False, **kwargs):
         from lawaf.interfaces.magnon.magnon_downfolder import (
-            MagnonWrapper,
             MagnonDownfolder,
+            MagnonWrapper,
         )
 
         model = MagnonWrapper(JR, Rlist, atoms)
@@ -92,13 +94,13 @@ class PWFDownfolder:
             # anchors={(0, 0, 0): (-1, -2, -3, -4)},
             # anchors={(0, 0, 0): ()},
             # use_proj=True,
-            enhance_Amn=2.0,
+            enhance_Amn=0.0,
         )
         params.update(kwargs)
         wann.set_parameters(**params)
         print("begin downfold")
         ewf = wann.downfold()
-        ewf.save_hr_pickle("downfolded_JR.pickle")
+        # ewf.save_hr_pickle("downfolded_JR.pickle")
 
         # Plot the band structure.
         wann.plot_band_fitting(
@@ -135,7 +137,7 @@ class JDownfolder_pickle:
         qmesh=[7, 7, 7],
         iso_only=False,
         method="pwf",
-        **kwargs
+        **kwargs,
     ):
         self.exc = SpinIO.load_pickle(path=inpath, fname="TB2J.pickle")
 
@@ -193,7 +195,7 @@ class JDownfolder_pickle:
                 qmesh=self.qmesh,
                 atoms=self.atoms,
                 iso_only=self.iso_only,
-                **kwargs
+                **kwargs,
             )
             Jd, Rlist = d.get_JR()
         return Jd, Rlist
@@ -274,10 +276,10 @@ class JDownfolder_pickle:
 def test():
     # pass
     # inpath = "/home/hexu/projects/NiCl2/vasp_inputs/TB2J_results"
-    # inpath = "/home/hexu/projects/TB2J_example/CrI3/TB2J_results"
-    inpath = "/home/hexu/projects/TB2J_projects/NiCl2/TB2J_NiCl/TB2J_results"
-    fname = os.path.join(inpath, "TB2J.pickle")
-    p = JDownfolder_pickle(
+    inpath = "/home/hexu/projects/TB2J_example/CrI3/TB2J_results"
+    # inpath = "/home/hexu/projects/TB2J_projects/NiCl2/TB2J_NiCl/TB2J_results"
+    _fname = os.path.join(inpath, "TB2J.pickle")
+    _p = JDownfolder_pickle(
         inpath=inpath, metals=["Ni"], ligands=["Cl"], outpath="TB2J_results_downfolded"
     )
 

TB2J/MAEGreen.py

@@ -1,13 +1,17 @@
+import gc
 from pathlib import Path
 
+import matplotlib.pyplot as plt
 import numpy as np
 import tqdm
 from HamiltonIO.abacus.abacus_wrapper import AbacusSplitSOCParser
 from HamiltonIO.model.occupations import GaussOccupations
 from typing_extensions import DefaultDict
 
+from TB2J.anisotropy import Anisotropy
 from TB2J.exchange import ExchangeNCL
 from TB2J.external import p_map
+from TB2J.mathutils.fibonacci_sphere import fibonacci_semisphere
 
 # from HamiltonIO.model.rotate_spin import rotate_Matrix_from_z_to_axis, rotate_Matrix_from_z_to_sperical
 # from TB2J.abacus.abacus_wrapper import AbacusWrapper, AbacusParser
@@ -23,12 +27,21 @@ def get_occupation(evals, kweights, nel, width=0.1):
 
 class MAEGreen(ExchangeNCL):
     def __init__(self, angles=None, **kwargs):
+        """
+        angles are defined as theta, phi pairs, where theta is the angle between the z-axis and the magnetization direction, and phi is the angle between the x-axis and the projection of the magnetization direction on the x-y plane.
+        """
         super().__init__(**kwargs)
         self.natoms = len(self.atoms)
         if angles is None or angles == "axis":
             self.set_angles_axis()
         elif angles == "scan":
             self.set_angles_scan()
+        elif angles == "fib":
+            self.set_angles_fib()
+        elif angles == "random":
+            self.set_angles_random()
+        elif angles == "miller":
+            self.set_angles_miller()
         else:
             self.thetas = angles[0]
             self.phis = angles[1]
@@ -39,9 +52,32 @@ class MAEGreen(ExchangeNCL):
         self.es_atom_orb = DefaultDict(lambda: 0)
 
     def set_angles_axis(self):
-        """theta and phi are defined as the x, y, z, axis."""
-        self.thetas = [0, np.pi / 2, np.pi / 2, np.pi / 2, np.pi]
-        self.phis = [0, 0, np.pi / 2, np.pi / 4, 0]
+        """theta and phi are defined as the x, y, z, xy, yz, xz, xyz, x-yz, -xyz, -x-yz axis."""
+        self.thetas = [0, np.pi / 2, np.pi / 2, np.pi / 2, np.pi, 0, np.pi / 2, 0, 0, 0]
+        self.phis = [0, 0, np.pi / 2, np.pi / 4, 0, 0, 0, np.pi]
+
+    def set_angles_miller(self, nmax=2):
+        """theta and angles corresponding to the miller index. remove duplicates.
+        e.g. 002 and 001 are the same.
+        """
+        thetas = []
+        phis = []
+        for k in range(0, nmax + 1):
+            for j in range(-nmax, nmax + 1):
+                for i in range(-nmax, nmax + 1):
+                    if i == 0 and j == 0 and k == 0:
+                        continue
+                    thetas.append(np.arccos(k / np.sqrt(i**2 + j**2 + k**2)))
+                    if i == 0 and j == 0:
+                        phis.append(0)
+                    else:
+                        phis.append(np.arctan2(j, i))
+        self.thetas = thetas
+        self.phis = phis
+        self.angle_pairs = list(zip(thetas, phis))
+        # remove duplicates of angles using sets.
+        self.angle_pairs = list(set(self.angle_pairs))
+        self.thetas, self.phis = zip(*self.angle_pairs)
 
     def set_angles_scan(self, step=15):
         self.thetas = []
@@ -51,6 +87,21 @@ class MAEGreen(ExchangeNCL):
                 self.thetas.append(i * np.pi / 180)
                 self.phis.append(j * np.pi / 180)
 
+    def set_angles_random(self, n=16):
+        # n random pairs of theta, phi
+        self.thetas = np.random.random(n) * np.pi
+        self.phis = np.random.random(n) * 2 * np.pi
+
+    def set_angles_fib(self, n=35):
+        self.thetas, self.phis = fibonacci_semisphere(n)
+        # thetas and phis are np.array
+        # add (theta, phi): (pi/2, pi/2) and (pi/2, pi/4)
+        # self.thetas += [np.pi / 2, np.pi / 2]
+        # self.phis += [np.pi / 2, np.pi / 4]
+        for i in range(8):
+            self.thetas = np.concatenate([self.thetas, [np.pi / 2]])
+            self.phis = np.concatenate([self.phis, [np.pi * i / 8]])
+
     def get_band_energy_vs_angles_from_eigen(
         self,
         thetas,
@@ -79,16 +130,12 @@ class MAEGreen(ExchangeNCL):
 
     def get_perturbed(self, e, thetas, phis):
         self.tbmodel.set_so_strength(0.0)
-        maxsoc = self.tbmodel.get_max_Hsoc_abs()
-        maxH0 = self.tbmodel.get_max_H0_spin_abs()
-        if maxsoc > maxH0 * 0.01:
-            print(f"""Warning: The SOC of the Hamiltonian has a maximum of {maxsoc} eV,
-                  comparing to the maximum of {maxH0} eV of the spin part of the Hamiltonian.
-                  The SOC is too strong, the perturbation theory may not be valid.""")
-
-        print(f"""Warning: The SOC of the Hamiltonian has a maximum of {maxsoc} eV,
-                  comparing to the maximum of {maxH0} eV of the spin part of the Hamiltonian.
-                  The SOC is too strong, the perturbation theory may not be valid.""")
+        # maxsoc = self.tbmodel.get_max_Hsoc_abs()
+        # maxH0 = self.tbmodel.get_max_H0_spin_abs()
+        # if maxsoc > maxH0 * 0.01:
+        #    print(f"""Warning: The SOC of the Hamiltonian has a maximum of {maxsoc} eV,
+        #          comparing to the maximum of {maxH0} eV of the spin part of the Hamiltonian.
+        #          The SOC is too strong, the perturbation theory may not be valid.""")
 
         G0K = self.G.get_Gk_all(e)
         Hsoc_k = self.tbmodel.get_Hk_soc(self.G.kpts)
@@ -104,12 +151,12 @@ class MAEGreen(ExchangeNCL):
                 GdH = G0K[ik] @ dHi
                 # dE += np.trace(GdH @ G0K[i].T.conj() @ dHi) * self.kweights[i]
                 # diagonal of second order perturbation.
-                dG2diag = np.diag(GdH @ GdH)
+                # dG2diag = np.diag(GdH @ GdH)
                 # dG2 = np.einsum("ij,ji->ij", GdH,   GdH)
                 dG2 = GdH * GdH.T
                 dG2sum = np.sum(dG2)
                 # print(f"dG2sum-sum: {dG2sum}")
-                dG2sum = np.sum(dG2diag)
+                # dG2sum = np.sum(dG2diag)
 
                 # dG2sum = np.trace(GdH @ GdH)
                 # print(f"dG2sum-Tr: {dG2sum}")
@@ -130,13 +177,11 @@ class MAEGreen(ExchangeNCL):
                         + dE_atom_orb[1::2, ::2]
                         + dE_atom_orb[::2, 1::2]
                     )
+                    dE_atom = np.sum(dE_atom_orb)
                     mmat = self.mmats[iatom]
                     dE_atom_orb = mmat.T @ dE_atom_orb @ mmat
-
                     dE_angle_atom_orb[(iangle, iatom)] += dE_atom_orb
-
-                    dE_atom = np.sum(dG2diag[iorb]) * self.G.kweights[ik]
-                    # dE_atom = np.sum(dE_atom_orb)
+                    # dE_atom = np.sum(dG2diag[iorb]) * self.G.kweights[ik]
                     dE_angle_atom[iangle, iatom] += dE_atom
         return dE_angle, dE_angle_atom, dE_angle_atom_orb
 
@@ -189,10 +234,25 @@ class MAEGreen(ExchangeNCL):
         for key, value in self.es_atom_orb.items():
             self.es_atom_orb[key] = -np.imag(value) / (2 * np.pi)
 
-    def output(self, output_path="TB2J_anisotropy", with_eigen=True):
+    def fit_anisotropy_tensor(self):
+        self.ani = Anisotropy.fit_from_data(self.thetas, self.phis, self.es)
+        return self.ani
+
+    def output(
+        self,
+        output_path="TB2J_anisotropy",
+        with_eigen=True,
+        figure3d="MAE_3d.png",
+        figure_contourf="MAE_contourf.png",
+    ):
         Path(output_path).mkdir(exist_ok=True)
         fname = f"{output_path}/MAE.dat"
         fname_orb = f"{output_path}/MAE_orb.dat"
+        fname_tensor = f"{output_path}/MAE_tensor.dat"
+        if figure3d is not None:
+            fname_fig3d = f"{output_path}/{figure3d}"
+        if figure_contourf is not None:
+            fname_figcontourf = f"{output_path}/{figure_contourf}"
 
         # ouput with eigenvalues.
         if with_eigen:
@@ -208,15 +268,29 @@ class MAEGreen(ExchangeNCL):
                     f.write("\n")
 
         with open(fname, "w") as f:
-            f.write("# theta, phi, MAE(total), MAE(atom-wise) Unit: meV\n")
+            f.write("# theta (rad), phi(rad), MAE(total), MAE(atom-wise) Unit: meV\n")
             for i, (theta, phi, e, es) in enumerate(
                 zip(self.thetas, self.phis, self.es, self.es_atom)
             ):
-                f.write(f"{theta:.5f} {phi:.5f} {e*1e3:.8f} ")
+                f.write(f"{theta%np.pi:.5f} {phi%(2*np.pi):.5f} {e*1e3:.8f} ")
                 for ea in es:
                     f.write(f"{ea*1e3:.8f} ")
                 f.write("\n")
 
+        self.ani = self.fit_anisotropy_tensor()
+        with open(fname_tensor, "w") as f:
+            f.write("# Anisotropy tensor in meV\n")
+            f.write(f"{self.ani.tensor_strings(include_isotropic=False)}\n")
+
+        if figure3d is not None:
+            self.ani.plot_3d(figname=fname_fig3d, show=False)
+
+        if figure_contourf is not None:
+            self.ani.plot_contourf(figname=fname_figcontourf, show=False)
+
+        plt.close()
+        gc.collect()
+
         with open(fname_orb, "w") as f:
             f.write("=" * 80 + "\n")
             f.write("Orbitals for each atom: \n")

TB2J/anisotropy.py

@@ -1,11 +1,12 @@
 import random
-import numpy as np
+from dataclasses import dataclass
+from pathlib import Path
+
 import matplotlib.pyplot as plt
+import numpy as np
+from numpy.linalg import matrix_rank
 from scipy.interpolate import LinearNDInterpolator
 from scipy.optimize import curve_fit
-from numpy.linalg import matrix_rank
-from dataclasses import dataclass
-from pathlib import Path
 
 
 @dataclass
@@ -18,8 +19,9 @@ class Anisotropy:
     @classmethod
     def from_T6(cls, T6):
         T = T6_to_T(T6)
-        T -= np.trace(T) / 3 * np.eye(3)
-        direction, amplitude = aniostropy_tensor_to_vector(T)
+        isotropic_part = np.trace(T) / 3
+        T -= isotropic_part * np.eye(3)
+        direction, amplitude = anisotropy_tensor_to_vector(T)
         return cls(
             direction=direction, amplitude=amplitude, isotropic_part=isotropic_part, T=T
         )
@@ -33,9 +35,9 @@ class Anisotropy:
 
     @classmethod
     def from_tensor(cls, T):
-        isotropic_part = np.trace(T) / 3
+        isotropic_part = np.trace(T) / 3 * np.eye(3)
         T -= np.trace(T) / 3 * np.eye(3)
-        direction, amplitude = aniostropy_tensor_to_vector(T)
+        direction, amplitude = anisotropy_tensor_to_vector(T)
         return cls(
             T=T, direction=direction, amplitude=amplitude, isotropic_part=isotropic_part
         )
@@ -44,13 +46,14 @@ class Anisotropy:
         if self.isotropic_part is None:
             self.isotropic_part = 0
         if self.T is None:
-            self.T = anisotropy_vector_to_tensor(
-                self.direction, self.amplitude
-            ) + self.isotropic_part * np.eye(3)
+            self.T = (
+                anisotropy_vector_to_tensor(self.direction, self.amplitude)
+                + self.isotropic_part
+            )
         elif self.direction is None or self.amplitude is None:
-            self.isotropic_part = np.trace(self.T) / 3
-            # print(f'aniostropic tensor = {self.anisotropic_part}')
-            self.direction, self.amplitude = aniostropy_tensor_to_vector(
+            self.isotropic_part = np.trace(self.T) / 3 * np.eye(3)
+            # print(f'anisotropic tensor = {self.anisotropic_part}')
+            self.direction, self.amplitude = anisotropy_tensor_to_vector(
                 self.anisotropic_part
             )
             self.isotropic_part = np.trace(self.T) / 3
@@ -113,7 +116,6 @@ class Anisotropy:
         E = -self.amplitude * (S @ self.direction) ** 2
         if include_isotropic:
             E = E + self.isotropic_part
-        print(f"E shape = {E.shape}")
         return E
 
     def energy_tensor_form(self, S=None, angle=None, include_isotropic=False):
@@ -126,7 +128,7 @@ class Anisotropy:
             return -S.T @ self.anisotropic_part @ S
 
     @classmethod
-    def fit_from_data(cls, thetas, phis, values, test=False):
+    def fit_from_data(cls, thetas, phis, values, test=False, units="rad"):
         """
         Fit the anisotropic tensor to the data
         parameters:
@@ -137,14 +139,16 @@ class Anisotropy:
            the anisotropic object fitted from the data
         """
         angles = np.vstack([thetas, phis])
+        if units.lower().startswith("deg"):
+            angles = np.deg2rad(angles)
         params, cov = curve_fit(anisotropy_energy, angles, values)
         fitted_values = anisotropy_energy(angles, *params)
 
         delta = fitted_values - values
 
         # print(f'Max value = {np.max(values)}, Min value = {np.min(values)}')
-        if np.abs(delta).max() > 1e-5:
-            print(f"Warning: The fitting is not consistent with the data.")
+        if np.abs(delta).max() > 1e-4:
+            print("Warning: The fitting is not consistent with the data.")
             print(f"Max-min = {np.max(values) - np.min(values)}")
             print(f"delta = {np.max(np.abs(delta))}")
         T = T6_to_T(params)
@@ -157,7 +161,7 @@ class Anisotropy:
                     angle=[thetas[i], phis[i]], include_isotropic=True
                 )
                 values2.append(E)
-            delta2 = np.array(values2) - values
+            # delta2 = np.array(values2) - values
             # print(delta2)
 
             ax = plot_3D_scatter(angles, values - np.min(values), color="r")
@@ -183,7 +187,7 @@ class Anisotropy:
         delta = fitted_values - values
         print(f"Max value = {np.max(values)}, Min value = {np.min(values)}")
         print(f"Max-min = {np.max(values) - np.min(values)}")
-        # print(f'delta = {delta}')
+        print(f"delta = {delta}")
         theta_a, phi_a, amplitude, isotropic_part = params
         direction = sphere_to_cartesian([theta_a, phi_a])
         return cls.from_direction_amplitude(
@@ -208,6 +212,25 @@ class Anisotropy:
         else:
             raise ValueError(f"Unknown method {method}")
 
+    @classmethod
+    def fit_from_xyz_data_file(cls, fname, method="tensor"):
+        """
+        Fit the anisotropic tensor to the data with x y z val form
+        parameters:
+           fname: the file name of the data
+        Return:
+              anisotropy: the anisotropic object
+        """
+        data = np.loadtxt(fname)
+        xyz, value = data[:, 0:3], data[:, 3]
+        theta, phi = np.array([cartesian_to_sphere(t) for t in xyz]).T
+        if method == "tensor":
+            return cls.fit_from_data(theta, phi, value)
+        elif method == "vector":
+            return cls.fit_from_data_vector_form(theta, phi, value)
+        else:
+            raise ValueError(f"Unknown method {method}")
+
     def plot_3d(self, ax=None, figname=None, show=True, surface=True):
         """
         plot the anisotropic energy in all directions in 3D
@@ -297,6 +320,55 @@ class Anisotropy:
         if show:
             plt.show()
 
+    def plot_contourf(self, ax=None, figname=None, show=False):
+        if ax is None:
+            fig, ax = plt.subplots()
+        X, Y = np.meshgrid(np.arange(0, 180, 1), np.arange(-180, 180, 1))
+        Z = np.zeros(X.shape)
+        ntheta, nphi = X.shape
+        for i in range(ntheta):
+            for j in range(nphi):
+                E = self.energy_tensor_form(angle=[X[i, j], Y[i, j]])
+                Z[i, j] = E
+        # find the X, Y for min and max of Z
+        X_max, Y_max = np.unravel_index(np.argmax(Z), Z.shape)
+        X_min, Y_min = np.unravel_index(np.argmin(Z), Z.shape)
+        X_max, Y_max = X[X_max, Y_max], Y[X_max, Y_max]
+        X_min, Y_min = X[X_min, Y_min], Y[X_min, Y_min]
+        c = ax.contourf(X, Y, Z, cmap="viridis", levels=200)
+        # print(X_max, Y_max, X_min, Y_min)
+        # ax.scatter(X_max, Y_max, color="r", marker="o")
+        # ax.scatter(X_min, Y_min, color="b", marker="o")
+        ax.set_xlabel("$\theta$ (degree)")
+        ax.set_ylabel("$\phi$ degree")
+        # ax.scatter(X_max, Y_max, color="r", marker="o")
+        # ax.scatter(X_min, Y_min, color="r", marker="o")
+
+        # colorbar
+        _cbar = plt.colorbar(c, ax=ax)
+
+        if figname is not None:
+            plt.savefig(figname)
+            plt.close()
+        if show:
+            print(f"Max = {X_max}, {Y_max}, Min = {X_min}, {Y_min}")
+            plt.show()
+        return ax
+
+    def tensor_strings(self, include_isotropic=False, multiplier=1):
+        """
+        convert the energy tensor to strings for easy printing
+        parameters:
+        include_isotropic: if include the isotropic part
+        multiplier: the multiplier for the tensor. Use for scaling the tensor by units.
+        """
+        if include_isotropic:
+            T = self.T
+        else:
+            T = self.T
+        strings = np.array2string(T * multiplier, precision=5, separator=" ")
+        return strings
+
 
 def plot_3D_scatter(angles, values, ax=None, **kwargs):
     if ax is None:
@@ -389,7 +461,7 @@ def sphere_to_cartesian(angles, r=1):
     return np.array([x, y, z])
 
 
-def cartesian_to_sphere(xyz):
+def cartesian_to_sphere(xyz, unit="deg"):
     """
     Transform the cartesian coordinates to the spherical coordinates
     parameters:
@@ -401,8 +473,13 @@ def cartesian_to_sphere(xyz):
     r = np.linalg.norm(xyz)
     theta = np.arccos(z / r)
     phi = np.arctan2(y, x)
-    theta = theta * 180 / np.pi
-    phi = phi * 180 / np.pi
+    if unit.lower().startswith("deg"):
+        theta = theta * 180 / np.pi
+        phi = phi * 180 / np.pi
+    elif unit.lower.startswith("rad"):
+        pass
+    else:
+        raise ValueError("unit must be 'deg' or 'rad'")
     return np.array([theta, phi])
 
 
@@ -470,7 +547,7 @@ def fit_anisotropy(thetas, phis, values):
     params, cov = curve_fit(anisotropy_energy, angles, values)
     # check if the fitting is consistent with the data
     T = T6_to_T(params)
-    direction, amp = anisostropy_tensor_to_vector(T)
+    direction, amp = anisotropy_tensor_to_vector(T)
     return direction, amp
 
 
@@ -518,7 +595,7 @@ def anisotropy_vector_to_tensor(direction, amplitude):
     return T
 
 
-def aniostropy_tensor_to_vector(T):
+def anisotropy_tensor_to_vector(T):
     """
     Transform the anisotropic tensor to the anisotropic vector
     parameters:
@@ -553,7 +630,7 @@ def test_anisotorpy_vector_to_tensor():
     assert np.abs(diff) < 1e-10
 
     # test if the inverse transformation get the direction and amplitude back
-    dir2, amp2 = aniostropy_tensor_to_vector(T)
+    dir2, amp2 = anisotropy_tensor_to_vector(T)
 
     # set the first element of the direction to be positive
     if direction[0] * dir2[0] < 0:
@@ -569,7 +646,7 @@ def test_anisotropy_tensor_to_vector():
     T = np.random.rand(3, 3)
     T = T + T.T
     T = T - np.trace(T) / 3
-    direction, amplitude = aniostropy_tensor_to_vector(T)
+    direction, amplitude = anisotropy_tensor_to_vector(T)
     T2 = anisotropy_vector_to_tensor(direction, amplitude)
     print(f"T = {T}")
     print(f"T2 = {T2}")
@@ -597,9 +674,6 @@ def test_fit_anisotropy():
             f"theta = {theta[i]}, phi = {phi[i]}, value = {value[i]}, fitted value = {fitted_values[i]}, delta = {delta[i]}"
         )
 
-    easy_axis = easy_axis_from_tensor(T6)
-    print(f"easy_axis = {easy_axis}")
-
 
 def view_anisotropy_strain():
     strains1 = [(x, 0.0) for x in np.arange(0.000, 0.021, 0.002)]

TB2J/exchange.py

@@ -566,23 +566,12 @@ class ExchangeNCL(Exchange):
         AijRs: a list of AijR,
         wherer AijR: array of ((nR, n, n, 4,4), dtype=complex)
         """
-        # if method == "trapezoidal":
-        #    integrate = trapezoidal_nonuniform
-        # elif method == "simpson":
-        #    integrate = simpson_nonuniform
-        #
-
-        # self.rho = integrate(self.contour.path, rhoRs)
         for iR, R in enumerate(self.R_ijatom_dict):
             for iatom, jatom in self.R_ijatom_dict[R]:
                 f = AijRs[(R, iatom, jatom)]
-                # self.A_ijR[(R, iatom, jatom)] = integrate(self.contour.path, f)
                 self.A_ijR[(R, iatom, jatom)] = self.contour.integrate_values(f)
 
                 if self.orb_decomposition:
-                    # self.A_ijR_orb[(R, iatom, jatom)] = integrate(
-                    #    self.contour.path, AijRs_orb[(R, iatom, jatom)]
-                    # )
                     self.contour.integrate_values(AijRs_orb[(R, iatom, jatom)])
 
     def get_quantities_per_e(self, e):

TB2J/interfaces/siesta_interface.py

@@ -156,6 +156,7 @@ Warning: The DMI component parallel to the spin orientation, the Jani which has
                 atoms=model.atoms,
                 basis=basis,
                 efermi=None,
+                angles="miller",
                 # magnetic_elements=magnetic_elements,
                 # include_orbs=include_orbs,
                 **exargs,
@@ -163,7 +164,7 @@ Warning: The DMI component parallel to the spin orientation, the Jani which has
             # thetas = [0, np.pi / 2, np.pi, 3 * np.pi / 2]
             # phis = [0, 0, 0, 0]
             # MAE.set_angles(thetas=thetas, phis=phis)
-            MAE.run(output_path=f"{output_path}_anisotropy", with_eigen=True)
+            MAE.run(output_path=f"{output_path}_anisotropy", with_eigen=False)
             print(
                 f"MAE calculation finished. The results are in {output_path} directory."
             )

TB2J/io_exchange/io_exchange.py

@@ -13,6 +13,11 @@ import pickle
 from collections.abc import Iterable
 from datetime import datetime
 
+import matplotlib
+
+matplotlib.use("Agg")
+import gc
+
 import matplotlib.pyplot as plt
 import numpy as np
 
@@ -320,7 +325,11 @@ Generation time: {now.strftime("%y/%m/%d %H:%M:%S")}
         i = self.i_spin(i)
         j = self.i_spin(j)
         if iso_only:
-            Jtensor = np.eye(3) * self.get_J(i, j, R)
+            J = self.get_Jiso(i, j, R)
+            if J is not None:
+                Jtensor = np.eye(3) * self.get_J(i, j, R)
+            else:
+                Jtensor = np.eye(3) * 0
         else:
             Jtensor = combine_J_tensor(
                 Jiso=self.get_J(i, j, R),
@@ -329,7 +338,13 @@ Generation time: {now.strftime("%y/%m/%d %H:%M:%S")}
             )
         return Jtensor
 
-    def get_full_Jtensor_for_one_R(self, R):
+    def get_J_tensor_dict(self):
+        Jdict = {}
+        for i, j, R in self.ijR_list():
+            Jdict[(i, j, R)] = self.get_J_tensor(i, j, R)
+        return Jdict
+
+    def get_full_Jtensor_for_one_R(self, R, iso_only=False):
         """
         Return the full exchange tensor of all i and j for cell R.
         param R (tuple of integers): cell index R
@@ -340,15 +355,17 @@ Generation time: {now.strftime("%y/%m/%d %H:%M:%S")}
         Jmat = np.zeros((n3, n3), dtype=float)
         for i in range(self.nspin):
             for j in range(self.nspin):
-                Jmat[i * 3 : i * 3 + 3, j * 3 : j * 3 + 3] = self.get_J_tensor(i, j, R)
+                Jmat[i * 3 : i * 3 + 3, j * 3 : j * 3 + 3] = self.get_J_tensor(
+                    i, j, R, iso_only=iso_only
+                )
         return Jmat
 
-    def get_full_Jtensor_for_Rlist(self, asr=False, iso_only=False):
+    def get_full_Jtensor_for_Rlist(self, asr=False, iso_only=True):
         n3 = self.nspin * 3
         nR = len(self.Rlist)
         Jmat = np.zeros((nR, n3, n3), dtype=float)
         for iR, R in enumerate(self.Rlist):
-            Jmat[iR] = self.get_full_Jtensor_for_one_R(R)
+            Jmat[iR] = self.get_full_Jtensor_for_one_R(R, iso_only=iso_only)
         if asr:
             iR0 = np.argmin(np.linalg.norm(self.Rlist, axis=1))
             assert np.linalg.norm(self.Rlist[iR0]) == 0
@@ -394,6 +411,7 @@ Generation time: {now.strftime("%y/%m/%d %H:%M:%S")}
         self.write_multibinit(path=os.path.join(path, "Multibinit"))
         self.write_tom_format(path=os.path.join(path, "TomASD"))
         self.write_vampire(path=os.path.join(path, "Vampire"))
+        self.write_matjes(path=os.path.join(path, "Matjes"))
 
         self.plot_all(savefile=os.path.join(path, "JvsR.pdf"))
         # self.write_Jq(kmesh=[9, 9, 9], path=path)
@@ -544,6 +562,7 @@ Generation time: {now.strftime("%y/%m/%d %H:%M:%S")}
             plt.show()
         plt.clf()
         plt.close()
+        gc.collect()  # This is to fix the tk error if multiprocess is used.
         return fig, axes
 
     def write_tom_format(self, path):
@@ -561,6 +580,11 @@ Generation time: {now.strftime("%y/%m/%d %H:%M:%S")}
 
         write_uppasd(self, path=path)
 
+    def write_matjes(self, path):
+        from TB2J.io_exchange.io_matjes import write_matjes
+
+        write_matjes(self, path=path)
+
 
 def gen_distance_dict(ind_mag_atoms, atoms, Rlist):
     distance_dict = {}
@@ -576,6 +600,21 @@ def gen_distance_dict(ind_mag_atoms, atoms, Rlist):
     return distance_dict
 
 
+def get_ind_shell(distance_dict, symprec=1e-5):
+    """
+    return a dictionary of shell index for each pair of atoms.
+    The index of shell is the ith shortest distances between all magnetic atom pairs.
+    """
+    shell_dict = {}
+    distances = np.array([x[1] for x in distance_dict.values()])
+    distances_int = np.round(distances / symprec).astype(int)
+    dint = sorted(np.unique(distances_int))
+    dintdict = dict(zip(dint, range(len(dint))))
+    for key, val in enumerate(distances_int):
+        shell_dict[key] = dintdict[val]
+    return shell_dict
+
+
 def test_spin_io():
     import numpy as np
     from ase import Atoms

TB2J/io_exchange/io_matjes.py

@@ -0,0 +1,225 @@
+import os
+
+import numpy as np
+
+from TB2J.utils import symbol_number
+from ase.units import Bohr, nm
+
+
+def get_ind_shell(distance_dict, symprec=1e-5):
+    """
+    return a dictionary of shell index for each pair of atoms.
+    The index of shell is the ith shortest distances between all magnetic atom pairs.
+    """
+    shell_dict = {}
+    distances = np.array([x[1] for x in distance_dict.values()])
+    distances_int = np.round(distances / symprec).astype(int)
+    dint = sorted(np.unique(distances_int))
+    dintdict = dict(zip(dint, range(len(dint))))
+    for key, val in distance_dict.items():
+        di = np.round(val[1] / symprec).astype(int)
+        shell_dict[key] = dintdict[di]
+    return shell_dict
+
+
+def _write_symmetry(cls, path, fname="symmetry.in", symmetry=True):
+    fname = os.path.join(path, fname)
+    if not symmetry:
+        with open(fname, "w") as myfile:
+            myfile.write("1 \n")
+            myfile.write("\n")
+            myfile.write("! identity operation\n")
+            myfile.write("1.0000000000 0.0000000000 0.0000000000\n")
+            myfile.write("0.0000000000 1.0000000000 0.0000000000\n")
+            myfile.write("0.0000000000 0.0000000000 1.0000000000\n")
+            myfile.write("0.0000000000 0.0000000000 0.0000000000\n")
+    else:
+        raise NotImplementedError("Symmetry not implemented yet")
+
+
+def write_matjes(cls, path="TB2J_results/Matjes", symmetry=False):
+    if not os.path.exists(path):
+        os.makedirs(path)
+    inputfname = os.path.join(path, "input")
+    with open(inputfname, "w") as myfile:
+        _write_lattice_supercell(cls, myfile)
+        _write_atoms(cls, myfile)
+        _write_magnetic_interactions(cls, myfile)
+        #_write_isotropic_exchange(cls, myfile, symmetry=symmetry)
+        _write_magnetic_anisotropy(cls, myfile)
+        # _write_dmi(cls, myfile)
+        _write_exchange_tensor(cls, myfile, symmetry=symmetry)
+        _write_parameters(cls, myfile, symmetry=symmetry)
+    print(f"writting symmetries ")
+    _write_symmetry(cls, path,  fname="symmetries.in", symmetry=False)
+
+def _write_parameters(cls, myfile, symmetry=False):
+    if symmetry:
+        myfile.write("cal_sym T\n")
+        myfile.write("sym_mode 2\n")
+    else:
+        myfile.write("cal_sym F \n")
+        myfile.write("sym_mode 0\n")
+
+def _write_lattice_supercell(cls, myfile):
+    myfile.write("# Lattice and supercell\n")
+    myfile.write(
+        "Periodic_log .T. .T. .T.      # periodic boundary conditions along vector 1, 2 and 3\n"
+    )
+    myfile.write("Nsize 8 8 8                 # size of the supercell\n")
+    try:
+        unitcell = cls.atoms.get_cell().reshape((3, 3))
+    except Exception:
+        unitcell = cls.atoms.get_cell().array.reshape((3, 3))
+    uc_lengths = np.linalg.norm(unitcell, axis=1) 
+    unitcell /= uc_lengths[:, None]
+    myfile.write(f"alat {uc_lengths[0]/nm}  {uc_lengths[1]/nm} {uc_lengths[2]/nm}              #lattice constant lengths\n")
+    myfile.write(
+        "lattice                         #lattice vector should be orthogonal or expressed in cartesian\n")
+    myfile.write(
+        f"{unitcell[0][0]} {unitcell[0][1]} {unitcell[0][2]}     # a_11 a_12 a_1      first lattice vector in line (does not need to be normalize)\n"
+    )
+    myfile.write(
+        f"{unitcell[1][0]} {unitcell[1][1]} {unitcell[1][2]}      # a_21 a_22 a_23    second lattice vector in line (does not need to be normalize)\n"
+    )
+    myfile.write(
+        f"{unitcell[2][0]} {unitcell[2][1]} {unitcell[2][2]}     # a_31 a_32 a_33                     third lattice vector in line\n"
+    )
+
+
+def get_atoms_info(atoms, spinat, symmetry=False):
+    if symmetry:
+        raise NotImplementedError("Symmetry not implemented yet")
+    else:
+        symnum = symbol_number(atoms)
+        atom_types = list(symnum.keys())
+        magmoms = np.linalg.norm(spinat, axis=1)
+        masses = atoms.get_masses()
+        tags = [i for i in range(len(atom_types))]
+    return atom_types, magmoms, masses, tags
+
+
+def _write_atoms(cls, myfile, symmetry=False):
+    myfile.write("\n")
+    myfile.write("# Atoms\n")
+    atom_types, magmoms, masses, tags = get_atoms_info(
+        cls.atoms, cls.spinat, symmetry=symmetry
+    )
+
+    myfile.write(f"atomtypes  {len(atom_types)}       #Number of types atom\n")
+    for i, atom_type in enumerate(atom_types):
+        m = magmoms[i]
+        mass = masses[i]
+        charge = 0
+        myfile.write(
+            f"{atom_type} {m} {mass} 0.0  F 0 # atom type: (name, mag. moment, mass, charge, displacement, number TB-orb.)\n"
+        )
+
+    myfile.write(
+        f"\natoms {len(cls.atoms)}          positions of the atom in the unit cell\n"
+    )
+    for i, atom in enumerate(cls.atoms):
+        spos = cls.atoms.get_scaled_positions()[i]
+        myfile.write(f"{atom_types[tags[i]]} {spos[0]}, {spos[1]}, {spos[2]}  \n")
+
+
+def _write_magnetic_interactions(cls, myfile, symmetry=False):
+    myfile.write("\nThe Hamiltonian\n")
+    myfile.write("# Magnetic interactions\n")
+
+
+def _write_isotropic_exchange(cls, myfile, symmetry=False):
+    myfile.write("\nmagnetic_J\n")
+    shell_dict = get_ind_shell(cls.distance_dict)
+    if symmetry:
+        Jdict = cls.reduced_exchange_Jdict
+    else:
+        Jdict = cls.exchange_Jdict
+    for key, val in Jdict.items():
+        R, i, j = key
+        ishell = shell_dict[(R, i, j)]
+        myfile.write(
+            f"{i+1} {j+1} {ishell} {val}     # between atoms type {i+1} and {j+1}, shell {R}, amplitude in eV  \n"
+        )
+    myfile.write(
+        "\nc_H_J -1        apply 1/2 in front of the sum of the exchange energy - default is -1\n"
+    )
+
+
+def _write_magnetic_anisotropy(cls, myfile):
+    if cls.k1 is None:
+        return
+    else:
+        myfile.write("\nmagnetic_anisotropy \n")
+        for i, k1 in enumerate(cls.k1):
+            myfile.write(
+                f"{i+1} {cls.k1dir[i][0]} {cls.k1dir[i][1]} {cls.k1dir[i][2]} {k1}     anisotropy of atoms type {i+1}, direction {cls.k1dir[i][0]} {cls.k1dir[i][1]} {cls.k1dir[i][2]} and amplitude in eV\n"
+            )
+        myfile.write("\nc_H_ani 1.0\n")
+
+
+def _write_dmi(cls, myfile):
+    if cls.has_dmi:
+        myfile.write("\nmagnetic_D\n")
+        for key, val in cls.dmi_ddict.items():
+            R, i, j = key
+            myfile.write(
+                f"{i+1} {j+1} {R[0]} {R[1]} {R[2]} {val}         #between atoms type {i+1} and {j+1}, mediated by atom type {R}, shell {R}, amplitude in eV\n"
+            )
+        myfile.write(
+            "\nc_H_D   -1.0             # coefficients to put in from of the sum - default is -1\n"
+        )
+
+
+def _write_exchange_tensor(cls, myfile, symmetry=False):
+    myfile.write(
+        "\nmagnetic_r2_tensor #Exchange tensor elements, middle 9 entries: xx, xy, xz, yx, etc. (in units of eV) and direction in which it should be applied\n"
+    )
+
+    Jtensor = cls.get_J_tensor_dict()
+    shelldict = get_ind_shell(cls.distance_dict)
+    unitcell = cls.atoms.get_cell().array.reshape((3, 3))
+    uc_lengths = np.linalg.norm(unitcell, axis=1) 
+    if Jtensor is not None:
+        for key, val in Jtensor.items():
+            i, j, R = key
+            # distance vector
+            dvec = cls.distance_dict[(R, i, j)][0]/nm/uc_lengths
+            dscalar = np.linalg.norm(dvec)
+            val = np.real(val)
+            ishell = shelldict[(R, i, j)]
+            myfile.write(
+                f"{i+1} {j+1} {ishell} {' '.join([str(x) for x in val.flatten()])}  {dvec[0]} {dvec[1]} {dvec[2]} \n"
+                #f"{i+1} {j+1} {dscalar} {' '.join([str(x) for x in val.flatten()])}  {dvec[0]} {dvec[1]} {dvec[2]} \n"
+            )
+        myfile.write(
+            "\nc_H_Exchten -1         apply 1/2 in front of the sum of the exchange tensor energy - default is -1\n"
+        )
+
+def rattle_atoms_and_cell(atoms, stdev=0.001, cell_stdev=0.001):
+    """
+    Rattle both atomic positions and cell parameters.
+    
+    Parameters:
+    -----------
+    atoms: ASE atoms object
+        The atoms to be rattled
+    stdev: float
+        Standard deviation for atomic displacement in Angstrom
+    cell_stdev: float
+        Standard deviation for cell parameter variation (fractional)
+    
+    Returns:
+    --------
+    None
+        The atoms object is modified in-place
+    """
+    # Rattle atomic positions
+    positions = atoms.get_positions()
+    displacement = np.random.normal(0, stdev, positions.shape)
+    atoms.set_positions(positions + displacement)
+    
+    # Rattle cell parameters
+    cell = atoms.get_cell()
+    cell_noise = np.random.normal(0, cell_stdev, cell.shape)
+    atoms.set_cell(cell * (1 + cell_noise), scale_atoms=True)

TB2J/mathutils/fibonacci_sphere.py

@@ -0,0 +1,74 @@
+# -*- coding: utf-8 -*-
+"""
+scan the spheres in the space of (theta, phi), so that the points are uniformly distributed on a sphere.
+The algorithm is based on fibonacci spiral sampling method.
+Reference:
+https://extremelearning.com.au/how-to-evenly-distribute-points-on-a-sphere-more-effectively-than-the-canonical-fibonacci-lattice/
+
+But note that the convention of theta and phi are different from the one in the reference.
+Here, cos(theta) = z, and phi is the azimuthal angle in the x-y plane.
+In the reference, theta is the azimuthal angle in the x-y plane, and phi is the polar angle.
+"""
+
+import numpy as np
+from numpy import pi
+
+
+def fibonacci_sphere(samples=100):
+    """
+    Fibonacci Sphere Sampling Method
+    Parameters:
+        samples (int): number of points to sample on the sphere
+    Returns:
+        theta and phi: numpy arrays with shape (samples,) containing the angles of the sampled points.
+    """
+    # Initialize the golden ratio and angles
+    goldenRatio = (1 + np.sqrt(5)) / 2
+    phi = np.arange(samples) * (2 * pi / goldenRatio)
+    theta = np.arccos(1 - 2 * np.arange(samples) / samples)
+    return theta, phi
+
+
+def fibonacci_semisphere(samples=100):
+    """
+    Fibonacci Sphere Sampling Method for the upper hemisphere of a sphere.
+
+    Parameters:
+        samples (int): number of points to sample on the sphere
+
+    Returns:
+        theta and phi: numpy arrays with shape (samples,) containing the angles of the sampled points.
+    """
+    # Initialize the golden ratio and angles
+    goldenRatio = (1 + np.sqrt(5)) / 2
+    phi = np.arange(samples) * (2 * pi / goldenRatio)
+    theta = np.arccos(np.linspace(0, 1, samples))
+    return theta, phi
+
+
+def test_fibonacci_sphere():
+    import matplotlib.pyplot as plt
+
+    # Generate points on the sphere
+    samples = 20000
+    theta, phi = fibonacci_sphere(samples)
+    # theta, phi = fibonacci_semisphere(samples)
+
+    # Convert spherical coordinates to Cartesian coordinates
+    x = np.cos(phi) * np.sin(theta)
+    y = np.sin(phi) * np.sin(theta)
+    z = np.cos(theta)
+
+    fig = plt.figure()
+    ax = fig.add_subplot(111, projection="3d")
+    ax.scatter(x, y, z, s=13.5)
+    # ax.plot(x, y, z)
+
+    # Set aspect to 'equal' for equal scaling in all directions
+    ax.set_aspect("equal")
+
+    plt.show()
+
+
+if __name__ == "__main__":
+    test_fibonacci_sphere()

TB2J/orbital_magmom.py

@@ -0,0 +1,36 @@
+"""
+utilities to handel orbital magnetic moments
+"""
+
+import numpy as np
+
+
+def complex_spherical_harmonic_to_real_spherical_harmonic(l=1):
+    """
+    matrix to convert the complex spherical harmonics to real spherical harmonics
+    """
+    MCR = np.zeros((2 * l + 1, 2 * l + 1), dtype=np.complex128)
+    MCR[0 + l, 0 + l] = 1.0
+    for m in range(1, l + 1):
+        mi = m + l
+        mpi = -m + l
+        MCR[mi, mi] = (-1) ** m / 2
+        MCR[mi, mpi] = 1.0 / 2
+        MCR[mpi, mi] = -1j * (-1) ** m / 2
+        MCR[mpi, mpi] = 1j / 2
+
+    return MCR
+
+
+def test_complex_spherical_harmonic_to_real_spherical_harmonic():
+    """
+    test the conversion matrix
+    """
+    l = 3
+    MCR = complex_spherical_harmonic_to_real_spherical_harmonic(l)
+    # print(MCR*np.sqrt(2))
+    print(MCR * 2)
+
+
+if __name__ == "__main__":
+    test_complex_spherical_harmonic_to_real_spherical_harmonic()

TB2J/symmetrize_J.py

@@ -9,7 +9,7 @@ from TB2J.versioninfo import print_license
 
 
 class TB2JSymmetrizer:
-    def __init__(self, exc, symprec=1e-8, verbose=True, Jonly=False):
+    def __init__(self, exc, symprec=1e-8, verbose=True, Jonly=True):
         # list of pairs with the index of atoms
         ijRs = exc.ijR_list_index_atom()
         finder = SymmetryPairFinder(atoms=exc.atoms, pairs=ijRs, symprec=symprec)
@@ -25,6 +25,12 @@ class TB2JSymmetrizer:
             )
             print("-" * 30)
             if exc.has_dmi:
+                # raise NotImplementedError(
+                #    "Symmetrization of DMI is not yet implemented."
+                #    )
+                # raise Warning(
+                #        "WARNING: Symmetrization of DMI is not yet implemented."
+                #        )
                 print(
                     "WARNING: Currently only the isotropic exchange is symmetrized. Symmetrization of DMI and anisotropic exchange are not yet implemented."
                 )
@@ -33,7 +39,7 @@ class TB2JSymmetrizer:
             print("Symmetry found:")
             print(finder.spacegroup)
             print("-" * 30)
-        self.pgdict = finder.get_symmetry_pair_group_dict()
+        self.pldict = finder.get_symmetry_pair_list_dict()
         self.exc = exc
         self.new_exc = copy.deepcopy(exc)
         self.Jonly = Jonly
@@ -46,21 +52,25 @@ class TB2JSymmetrizer:
         Symmetrize the exchange parameters J.
         """
         symJdict = {}
+        reduced_symJdict = {}
         # Jdict = self.exc.exchange_Jdict
-        # ngroup = self.pgdict
-        for pairgroup in self.pgdict.groups:
-            ijRs = pairgroup.get_all_ijR()
+        for ishell, pairlist in enumerate(self.pldict.pairlists):
+            ijRs = pairlist.get_all_ijR()
             ijRs_spin = [self.exc.ijR_index_atom_to_spin(*ijR) for ijR in ijRs]
             Js = [self.exc.get_J(*ijR_spin) for ijR_spin in ijRs_spin]
             Javg = np.average(Js)
             for i, j, R in ijRs_spin:
                 symJdict[(R, i, j)] = Javg
+            ijRs_ref = ijRs_spin[0]
+            i, j, R = ijRs_ref
+            reduced_symJdict[(R, i, j)] = Javg
         self.new_exc.exchange_Jdict = symJdict
         if self.Jonly:
             self.new_exc.has_dmi = False
             self.new_exc.dmi_ddict = None
             self.new_exc.has_bilinear = False
             self.new_exc.Jani_dict = None
+            self.new_exc.reduced_exchange_Jdict = reduced_symJdict
             self.has_uniaxial_anisotropy = False
             self.k1 = None
             self.k1dir = None
@@ -124,12 +134,12 @@ def symmetrize_J_cli():
         help="precision for symmetry detection. default is 1e-5 Angstrom",
     )
 
-    parser.add_argument(
-        "--Jonly",
-        action="store_true",
-        help="symmetrize only the exchange parameters and discard the DMI and anisotropic exchange",
-        default=False,
-    )
+    # parser.add_argument(
+    #    "--Jonly",
+    #    action="store_true",
+    #    help="symmetrize only the exchange parameters and discard the DMI and anisotropic exchange",
+    #    default=True,
+    # )
 
     args = parser.parse_args()
     if args.inpath is None:
@@ -139,7 +149,8 @@ def symmetrize_J_cli():
         path=args.inpath,
         output_path=args.outpath,
         symprec=args.symprec,
-        Jonly=args.Jonly,
+        # Jonly=args.Jonly,
+        Jonly=True,
     )
 
 

{TB2J-0.9.9rc6.dist-info → tb2j-0.9.9rc7.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: TB2J
-Version: 0.9.9rc6
+Version: 0.9.9rc7
 Summary: TB2J: First principle to Heisenberg exchange J using tight-binding Green function method
 Author: Xu He
 Author-email: mailhexu@gmail.com
@@ -14,15 +14,24 @@ Classifier: Topic :: Scientific/Engineering :: Physics
 Classifier: License :: OSI Approved :: BSD License
 Requires-Python: >=3.6
 License-File: LICENSE
-Requires-Dist: numpy <2.0
+Requires-Dist: numpy<2.0
 Requires-Dist: scipy
 Requires-Dist: matplotlib
-Requires-Dist: ase >=3.19
+Requires-Dist: ase>=3.19
 Requires-Dist: tqdm
 Requires-Dist: pathos
-Requires-Dist: packaging >=20.0
-Requires-Dist: HamiltonIO >=0.1.9
+Requires-Dist: packaging>=20.0
+Requires-Dist: HamiltonIO>=0.1.9
 Requires-Dist: pre-commit
-Requires-Dist: sympair >0.1.0
+Requires-Dist: sympair>0.1.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 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. 

{TB2J-0.9.9rc6.dist-info → tb2j-0.9.9rc7.dist-info}/RECORD

@@ -1,17 +1,17 @@
-TB2J/Jdownfolder.py,sha256=Rmg6KfQ-Lkhei5daTJ2POzr0XL-R1WM-rzUnDcfoDhc,9595
+TB2J/Jdownfolder.py,sha256=xs0gmcKwOA3ejXqk3JPPgnYVu8CvkK8cteuvHuu1oSk,9603
 TB2J/Jtensor.py,sha256=t6OsqrSlYW6Im4H7ykVAW8Al_pFXN4C5yj2UEsV6r7g,3181
 TB2J/MAE.py,sha256=fM8U-Dgp9HcQOEeC_kyZV1oVrygBvcux9BraUXVouvY,10994
-TB2J/MAEGreen.py,sha256=MoLoE5fLpbp1knAP_oU-egHr0jnpTQpqD9FgoVtDkgk,12322
+TB2J/MAEGreen.py,sha256=pCX12GDNaOz8XgMlui8NjAERM43Ux3HyOKfiD80czXI,15306
 TB2J/Oiju.py,sha256=cNGv8N5uH_swGq7cnAt2OyiDfqtjLlLrwseGu0E4iaM,3383
 TB2J/Oiju_epc.py,sha256=oytM3NYW7nWmklrGgNlqwIpI_JYv_hb7ZnR4o9nYNog,6809
 TB2J/__init__.py,sha256=hcEWkag_UvLm1ZSbjsgcTWkGVlR3Bwmzg1QYAwsvf-g,24
-TB2J/anisotropy.py,sha256=zz4ID6_Yjf5gxPJt1psc6liNKhTG8X5AtHdpq0dCEzM,22616
+TB2J/anisotropy.py,sha256=0zmvXkmDmakbBOwGYLa3IIkv5cE99SHLAQJsGoZz7JQ,25463
 TB2J/basis.py,sha256=DFo6_QUwjBwisP6zGxvoO0lpGTMDPAOkiL9giNCjOjA,1558
 TB2J/citation.py,sha256=gcQeyJZaT1Qrtsl8Y3s4neOH3-vvgmIcCvXeV2o3vj0,2891
 TB2J/contour.py,sha256=zLHQZZ3hhgLkLFPATCraLOJyLJKLC0fba_L_5sRz23o,3246
 TB2J/density_matrix.py,sha256=D5k8Oe21OCiLVORNYbo4TZOFG0slrQSbj91kJ3TMFjs,1514
 TB2J/epc.py,sha256=zLbtqZJhDr8DnnGN6YENcXwrMb3Qxu6KB08mLy9Pw20,3474
-TB2J/exchange.py,sha256=1kkrrQvmoOaPgT_rKG7wgLy31rWpbFGNYXai1ysd58M,26221
+TB2J/exchange.py,sha256=742vEE8DQJuWBTlq45RQoPy0-_n_TT6BZOb_DoTpDKI,25739
 TB2J/exchangeCL2.py,sha256=P7bklMXVYX_tn9DbjEPqeTir1SeZyfPBIP1fhWUzLmY,11419
 TB2J/exchange_params.py,sha256=AcGYYky27DXSF3yDZWVjksr_3rt6im6qeIzpOwvqssk,7141
 TB2J/exchange_pert.py,sha256=jmFMtQbYa_uczM4VAeS6TijkIHRFIqEzZJswzE9Wfuo,8523
@@ -23,6 +23,7 @@ TB2J/io_merge.py,sha256=E1_GfAB2HGpW-ipaO2lqU9SvaslwkiLxssn4DqJpMT8,6899
 TB2J/kpoints.py,sha256=9L7tBarFBHoIhpuc9zuwA6HdnlgH834SQrPek4yRoWk,3191
 TB2J/myTB.py,sha256=ok_B4my29bOIghMSZfx0Es6G8FaXaIiLP4gPxTdSj00,17659
 TB2J/mycfr.py,sha256=Wgj6PpA-oVuxm8Hh32FVw_vthozVBrDJhRV1hA1ku44,3752
+TB2J/orbital_magmom.py,sha256=JTwO9ZDgRRQndqR9aFIua4eTvwLMoGsTiY_HaIPMZ2I,889
 TB2J/orbmap.py,sha256=XLQjKMxCy2eADaM5eb2F_zG08V7lzpXJxp5uEtTeVYI,7194
 TB2J/pauli.py,sha256=ESpAhk6LG5ugzuW1YFUTqiDxcg-pQ7wNnzR2FtUnvKM,5295
 TB2J/pert.py,sha256=RaCJfewl0doht4cjAnzzGKe-uj2le4aqe0iPKFrq9fo,1192
@@ -30,7 +31,7 @@ TB2J/plot.py,sha256=AnFIFWE2vlmj7Z6f_7-dX_O1stJN-qbuiurPj43dUCM,4104
 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/symmetrize_J.py,sha256=IypvLL0JxExq-cmqc4o0nLL8psE7OC9ijj9YMcsqJeA,4487
+TB2J/symmetrize_J.py,sha256=gN6Y8zV4IrO5rPh0SG8KHkekrJjMQzNY4GGe2ZBtwbc,4993
 TB2J/tensor_rotate.py,sha256=4-DfT_Mg5e40fbd74M5W0D5DqmUq-kVOOLDkkkI834A,8083
 TB2J/utest.py,sha256=z_ahi7tpHQF9WlHNQihcQ7qzfezRJQXQt28eB1X_z64,3897
 TB2J/utils.py,sha256=DHkc7BK0KUGesfoAv1OxMgIw_iZzcFXh--3ybsFSd_c,12535
@@ -41,7 +42,7 @@ TB2J/interfaces/__init__.py,sha256=4tiLoXQ73Nlyi9L4j8jJXOYzXluVNPxQZkwfkQZEGHg,3
 TB2J/interfaces/gpaw_interface.py,sha256=GCDlJ-hRWfChvWwsgBDYSmVqO4sH9HAuGZTV9GqgN6c,1504
 TB2J/interfaces/lawaf_interface.py,sha256=PieLnmppdafOYsgeHznqOou1g9L1sam5jOm3KaObdqo,4408
 TB2J/interfaces/manager.py,sha256=PQMLEfMCT5GnDWSl2nI4JOgRPm_fysyR-6Y6l97xWcw,860
-TB2J/interfaces/siesta_interface.py,sha256=C9dMmFAc8HlCGFJeHLn0nUvOJA1rhVYIFIz8udMdJjE,7332
+TB2J/interfaces/siesta_interface.py,sha256=olvo2xdBOSNk3zn67nuKrxbW--EKPoWwEzKRBwJbrVY,7366
 TB2J/interfaces/wannier90_interface.py,sha256=qzRgXUBb7t1Aiegrl_RV51BB8csdtVM0EP0Z4pjmTcs,4467
 TB2J/interfaces/abacus/__init__.py,sha256=leas71oCvM_HxrF4gnO5A_VKcJmDAgsI1BUctLU3OBw,177
 TB2J/interfaces/abacus/abacus_api.py,sha256=lNV4LNkLcKw7Zux4MQYM9wnh3eFTlcSqbf4Pb7pqhrk,7243
@@ -53,7 +54,8 @@ TB2J/interfaces/abacus/test_density_matrix.py,sha256=bMWWJYtDS57SpPZ-eZXZ9Hr_UK4
 TB2J/interfaces/abacus/test_read_HRSR.py,sha256=W1oO_yigT50Yb5_u-KB_IfTpM7kArGkBuMSMs0H4CTs,1235
 TB2J/interfaces/abacus/test_read_stru.py,sha256=hoKPHVco8vwzC7Gao4bOPCdAPhh29x-9DTJJqRr7AYM,788
 TB2J/io_exchange/__init__.py,sha256=KfGHum7B8E4G_KKfillqw0lErtoyKEuFUUttHLs-mg4,32
-TB2J/io_exchange/io_exchange.py,sha256=ZeA8lpYUAQO1CqZnQL70IgS9TbAFyfPuadLGfKVf-Ms,19769
+TB2J/io_exchange/io_exchange.py,sha256=7-Xt7_K5FKVrFkFvBrHhJGCRrL2Sw7zY-93GRBBv2GM,21050
+TB2J/io_exchange/io_matjes.py,sha256=klM5Z_t2kk0y_1IoqIILLnhUgjHQmXXmsXiono2LeMU,8594
 TB2J/io_exchange/io_multibinit.py,sha256=8PDmWxzGuv-GwJosj2ZTmiyNY_duFVWJ4ekCuSqGdd8,6739
 TB2J/io_exchange/io_tomsasd.py,sha256=NqkAC1Fl-CUnFA21eBzSy_S5F_oeQFJysw4UukQbN8o,4173
 TB2J/io_exchange/io_txt.py,sha256=BMr1eSILlKpgtjvDx7uw2VMAkEKSvGEPNxpaT_zev0I,10547
@@ -61,6 +63,7 @@ TB2J/io_exchange/io_uppasd.py,sha256=bI4iPEgnK4TvCZNvb6x2xYXgjW7pEehCqmcizy2pqFU
 TB2J/io_exchange/io_vampire.py,sha256=UllC4twf06_q2vBCnAYFzEDGvS8mSefwQXDquBuyc0M,5583
 TB2J/mathutils/__init__.py,sha256=tQLBfHkZqdVfVxPOahy42qMUkFYnFFFhM-uc4QsYFxI,27
 TB2J/mathutils/fermi.py,sha256=72tZ5CptGmYaBUD0xLWltuH7LBXcrMUwODyW6-WqlzI,638
+TB2J/mathutils/fibonacci_sphere.py,sha256=l0USn25ZCAWF6l4UleyWaeLthsj9TThV9iWmfi6DbaM,2344
 TB2J/mathutils/kR_convert.py,sha256=p_9XWJVNanTzTK2rI6KRjTkbSq42la6N448-zJOsMwY,2671
 TB2J/mathutils/lowdin.py,sha256=RYbm9OcnFnjcZFdC5YcNUsI9cOJmoDLsWSSCaP0GqKQ,499
 TB2J/mathutils/rotate_spin.py,sha256=lbGzve_36FyNjanXqdxYDb102kA4_5OycRlBcm-tH-g,8360
@@ -77,19 +80,19 @@ 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.9.9rc6.data/scripts/TB2J_downfold.py,sha256=i4BVqnpDdgrX_amookVWeLGefGBn-qeAutWiwuY9SfQ,2099
-TB2J-0.9.9rc6.data/scripts/TB2J_eigen.py,sha256=Qs9v2hnMm2Tpfoa4h53muUKty2dZjwx8948MBoQooNg,1128
-TB2J-0.9.9rc6.data/scripts/TB2J_magnon.py,sha256=q7UwAmorRcFNk4tfE7gl_ny05l6p7pbD9Wm_LkIpKEw,3101
-TB2J-0.9.9rc6.data/scripts/TB2J_magnon_dos.py,sha256=TMXQvD2dIbO5FZ4tUMmxJgCgH2O2hDAPUNfEKO4z-x4,110
-TB2J-0.9.9rc6.data/scripts/TB2J_merge.py,sha256=y834SF4rIRn1L1ptkhczvavQpC-8Px6DTmDOOSaq_DE,1854
-TB2J-0.9.9rc6.data/scripts/TB2J_rotate.py,sha256=zgiDFuYZNmzKK0rwDmTaYD2OpRlmKA_VGeBx83w2Xwc,873
-TB2J-0.9.9rc6.data/scripts/TB2J_rotateDM.py,sha256=kCvF7gotuqAX1VnJ06cwfVm7RrhrdtiV5v7d9P2Pn_E,567
-TB2J-0.9.9rc6.data/scripts/abacus2J.py,sha256=0HLXoJhAkiZ-ZM1cs26lncccxE8-TzC8JiDTba1h1uM,4163
-TB2J-0.9.9rc6.data/scripts/siesta2J.py,sha256=gp31LioqpPkDmMY0y_5gXIjOBPNnf080P37pRo0yjw8,4886
-TB2J-0.9.9rc6.data/scripts/wann2J.py,sha256=pTFDf6h72I_LN_NX5UivyCoJPgwvyAyHW175nSAJvLo,2987
-TB2J-0.9.9rc6.dist-info/LICENSE,sha256=CbZI-jyRTjiqIcWa244cRSHJdjjtUNqGR4HeJkgEwJw,1332
-TB2J-0.9.9rc6.dist-info/METADATA,sha256=liNOEG_iKPUW6hOrcu08SqCBqzeEd3RxGRt3_YxBh2M,1482
-TB2J-0.9.9rc6.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-TB2J-0.9.9rc6.dist-info/entry_points.txt,sha256=Hdz1WC9waUzyFVmowKnbbZ6j-J4adHh_Ko6JpxGYAtE,131
-TB2J-0.9.9rc6.dist-info/top_level.txt,sha256=whYa5ByLYhl5XnTPBHSWr-IGD6VWmr5Ql2bye2qwV_s,5
-TB2J-0.9.9rc6.dist-info/RECORD,,
+tb2j-0.9.9rc7.data/scripts/TB2J_downfold.py,sha256=i4BVqnpDdgrX_amookVWeLGefGBn-qeAutWiwuY9SfQ,2099
+tb2j-0.9.9rc7.data/scripts/TB2J_eigen.py,sha256=Qs9v2hnMm2Tpfoa4h53muUKty2dZjwx8948MBoQooNg,1128
+tb2j-0.9.9rc7.data/scripts/TB2J_magnon.py,sha256=q7UwAmorRcFNk4tfE7gl_ny05l6p7pbD9Wm_LkIpKEw,3101
+tb2j-0.9.9rc7.data/scripts/TB2J_magnon_dos.py,sha256=TMXQvD2dIbO5FZ4tUMmxJgCgH2O2hDAPUNfEKO4z-x4,110
+tb2j-0.9.9rc7.data/scripts/TB2J_merge.py,sha256=y834SF4rIRn1L1ptkhczvavQpC-8Px6DTmDOOSaq_DE,1854
+tb2j-0.9.9rc7.data/scripts/TB2J_rotate.py,sha256=zgiDFuYZNmzKK0rwDmTaYD2OpRlmKA_VGeBx83w2Xwc,873
+tb2j-0.9.9rc7.data/scripts/TB2J_rotateDM.py,sha256=kCvF7gotuqAX1VnJ06cwfVm7RrhrdtiV5v7d9P2Pn_E,567
+tb2j-0.9.9rc7.data/scripts/abacus2J.py,sha256=0HLXoJhAkiZ-ZM1cs26lncccxE8-TzC8JiDTba1h1uM,4163
+tb2j-0.9.9rc7.data/scripts/siesta2J.py,sha256=gp31LioqpPkDmMY0y_5gXIjOBPNnf080P37pRo0yjw8,4886
+tb2j-0.9.9rc7.data/scripts/wann2J.py,sha256=pTFDf6h72I_LN_NX5UivyCoJPgwvyAyHW175nSAJvLo,2987
+tb2j-0.9.9rc7.dist-info/licenses/LICENSE,sha256=CbZI-jyRTjiqIcWa244cRSHJdjjtUNqGR4HeJkgEwJw,1332
+tb2j-0.9.9rc7.dist-info/METADATA,sha256=H5g8ApE237zxKx8_mx0Fr1fUCz2m97VkgDY5LBFYzlg,1660
+tb2j-0.9.9rc7.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
+tb2j-0.9.9rc7.dist-info/entry_points.txt,sha256=Hdz1WC9waUzyFVmowKnbbZ6j-J4adHh_Ko6JpxGYAtE,131
+tb2j-0.9.9rc7.dist-info/top_level.txt,sha256=whYa5ByLYhl5XnTPBHSWr-IGD6VWmr5Ql2bye2qwV_s,5
+tb2j-0.9.9rc7.dist-info/RECORD,,

{TB2J-0.9.9rc6.dist-info → tb2j-0.9.9rc7.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.1.0)
+Generator: setuptools (77.0.3)
 Root-Is-Purelib: true
 Tag: py3-none-any