TB2J 0.9.9rc5__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,12 +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
@@ -22,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]
@@ -38,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 = []
@@ -50,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,
@@ -78,6 +130,13 @@ 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.""")
+
         G0K = self.G.get_Gk_all(e)
         Hsoc_k = self.tbmodel.get_Hk_soc(self.G.kpts)
         na = len(thetas)
@@ -92,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}")
@@ -118,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
 
@@ -143,15 +200,33 @@ class MAEGreen(ExchangeNCL):
         if with_eigen:
             self.es2 = self.get_band_energy_vs_angles_from_eigen(thetas, phis)
 
-        for ie, e in enumerate(tqdm.tqdm(self.contour.path)):
-            dE_angle, dE_angle_atom, dE_angle_atom_orb = self.get_perturbed(
-                e, thetas, phis
-            )
-            self.es += dE_angle * self.contour.weights[ie]
-            self.es_atom += dE_angle_atom * self.contour.weights[ie]
+        # for ie, e in enumerate(tqdm.tqdm(self.contour.path)):
+        #    dE_angle, dE_angle_atom, dE_angle_atom_orb = self.get_perturbed(
+        #        e, thetas, phis
+        #    )
+        #    self.es += dE_angle * self.contour.weights[ie]
+        #    self.es_atom += dE_angle_atom * self.contour.weights[ie]
+        #    for key, value in dE_angle_atom_orb.items():
+        #        self.es_atom_orb[key] += (
+        #            dE_angle_atom_orb[key] * self.contour.weights[ie]
+        #        )
+
+        # rewrite the for loop above to use p_map
+        def func(e):
+            return self.get_perturbed(e, thetas, phis)
+
+        if self.nproc > 1:
+            results = p_map(func, self.contour.path, num_cpus=self.nproc)
+        else:
+            npole = len(self.contour.path)
+            results = map(func, tqdm.tqdm(self.contour.path, total=npole))
+        for i, result in enumerate(results):
+            dE_angle, dE_angle_atom, dE_angle_atom_orb = result
+            self.es += dE_angle * self.contour.weights[i]
+            self.es_atom += dE_angle_atom * self.contour.weights[i]
             for key, value in dE_angle_atom_orb.items():
                 self.es_atom_orb[key] += (
-                    dE_angle_atom_orb[key] * self.contour.weights[ie]
+                    dE_angle_atom_orb[key] * self.contour.weights[i]
                 )
 
         self.es = -np.imag(self.es) / (2 * np.pi)
@@ -159,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:
@@ -178,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/contour.py

@@ -1,5 +1,6 @@
 import numpy as np
 from scipy.special import roots_legendre
+
 from TB2J.utils import simpson_nonuniform_weight
 
 
@@ -15,6 +16,21 @@ class Contour:
             self._weights = simpson_nonuniform_weight(self.path)
         return self._weights
 
+    def integrate_func(self, func):
+        """
+        integrate f along the path
+        """
+        return np.dot(func(self.path), self.weights)
+
+    def integrate_values(self, values):
+        """
+        integrate f along the path
+        """
+        ret = 0
+        for i in range(len(values)):
+            ret += values[i] * self.weights[i]
+        return ret
+
     def build_path_semicircle(self, npoints, endpoint=True):
         R = (self.emax - self.emin) / 2.0
         R0 = (self.emin + self.emax) / 2.0