TB2J 0.9.4rc0__py3-none-any.whl → 0.9.6rc0__py3-none-any.whl

TB2J/io_exchange/io_exchange.py

@@ -9,16 +9,18 @@ write not only xml output.
 """
 
 import os
+import pickle
 from collections.abc import Iterable
+from datetime import datetime
+
+import matplotlib.pyplot as plt
 import numpy as np
-from TB2J.kpoints import monkhorst_pack
-import pickle
+
 from TB2J import __version__
+from TB2J.io_exchange.io_txt import write_Jq_info
 from TB2J.Jtensor import combine_J_tensor
-from datetime import datetime
-import matplotlib.pyplot as plt
+from TB2J.kpoints import monkhorst_pack
 from TB2J.spinham.spin_api import SpinModel
-from TB2J.io_exchange.io_txt import write_Jq_info
 from TB2J.utils import symbol_number
 
 
@@ -238,6 +240,18 @@ Generation time: {now.strftime("%y/%m/%d %H:%M:%S")}
     def get_charge_iatom(self, iatom):
         return self.charges[iatom]
 
+    def ijR_index_spin_to_atom(self, i, j, R):
+        return (self.iatom(i), self.iatom(j), R)
+
+    def ijR_index_atom_to_spin(self, iatom, jatom, R):
+        return (self.index_spin[iatom], self.index_spin[jatom], R)
+
+    def ijR_list(self):
+        return [(i, j, R) for R, i, j in self.exchange_Jdict]
+
+    def ijR_list_index_atom(self):
+        return [self.ijR_index_spin_to_atom(i, j, R) for R, i, j in self.exchange_Jdict]
+
     def get_J(self, i, j, R, default=None):
         i = self.i_spin(i)
         j = self.i_spin(j)
@@ -380,6 +394,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.plot_all(savefile=os.path.join(path, "JvsR.pdf"))
         # self.write_Jq(kmesh=[9, 9, 9], path=path)
 
@@ -562,8 +577,8 @@ def gen_distance_dict(ind_mag_atoms, atoms, Rlist):
 
 
 def test_spin_io():
-    from ase import Atoms
     import numpy as np
+    from ase import Atoms
 
     atoms = Atoms(
         "SrMnO3",
@@ -579,7 +594,6 @@ def test_spin_io():
     spinat = [[0, 0, x] for x in [0, 3, 0, 0, 0]]
     charges = [2, 4, 5, 5, 5]
     index_spin = [-1, 0, -1, -1, -1]
-    colinear = True
     Rlist = [[0, 0, 0], [0, 0, 1]]
     ind_mag_atoms = [1]
     distance_dict = gen_distance_dict(ind_mag_atoms, atoms, Rlist)

TB2J/io_merge.py

@@ -48,7 +48,8 @@ class SpinIO_merge(SpinIO):
 
     def _set_projection_vectors(self):
 
-        spinat = self.spinat
+        norm = np.linalg.norm(self.spinat, axis=-1).reshape(-1, 1)
+        spinat = self.spinat / norm
         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):

TB2J/mathutils/fermi.py

@@ -1,8 +1,9 @@
-import numpy as np
-import warnings
 import sys
 
-MAX_EXP_ARGUMENT = np.log(sys.float_info.max)
+import numpy as np
+
+MAX_EXP_ARGUMENT = np.log(sys.float_info.max / 100000)
+print(MAX_EXP_ARGUMENT)
 
 
 def fermi(e, mu, width=0.01):
@@ -15,8 +16,12 @@ def fermi(e, mu, width=0.01):
     """
     x = (e - mu) / width
     # disable overflow warning
-    with warnings.catch_warnings():
-        warnings.simplefilter("ignore")
-        ret = np.where(x < MAX_EXP_ARGUMENT, 1 / (1.0 + np.exp(x)), 0.0)
+    # with warnings.catch_warnings():
+    #    warnings.simplefilter("ignore")
+    #    ret = np.where(x < MAX_EXP_ARGUMENT, 1 / (1.0 + np.exp(x)), 0.0)
 
+    ret = np.zeros_like(x, dtype=float)
+    for i, xi in enumerate(x):
+        if xi < 700:
+            ret[i] = 1 / (1.0 + np.exp(xi))
     return ret

TB2J/mathutils/lowdin.py

@@ -1,5 +1,5 @@
 import numpy as np
-from scipy.linalg import inv, eigh
+from scipy.linalg import eigh
 
 
 def Lowdin(S):
@@ -9,4 +9,14 @@ def Lowdin(S):
     psi_prime = S^(-1/2) psi
     """
     eigval, eigvec = eigh(S)
-    return eigvec @ np.diag(np.sqrt(1.0 / eigval)) @ (eigvec.T.conj())
+    S_half = eigvec @ np.diag(np.sqrt(1.0 / eigval)) @ (eigvec.T.conj())
+    return S_half
+
+
+def Lowdin_symmetric_orthonormalization(H, S):
+    """
+    Lowdin's symmetric orthonormalization.
+    """
+    S_half = Lowdin(S)
+    H_prime = S_half @ H @ S_half
+    return H_prime

TB2J/mathutils/rotate_spin.py

@@ -1,5 +1,7 @@
 import numpy as np
-from TB2J.pauli import pauli_block_all, s0, s1, s2, s3, gather_pauli_blocks
+from scipy.sparse import eye_array, kron
+
+from TB2J.pauli import gather_pauli_blocks, pauli_block_all
 
 
 def rotate_Matrix_from_z_to_axis(M, axis, normalize=True):
@@ -27,12 +29,224 @@ def spherical_to_cartesian(theta, phi, normalize=True):
     return vec
 
 
+def rotation_matrix(theta, phi):
+    """
+    The unitray operator U, that U^dagger * s3 * U is the rotated s3 by theta and phi
+    """
+    U = np.array(
+        [
+            [np.cos(theta / 2), np.exp(-1j * phi) * np.sin(theta / 2)],
+            [-np.exp(1j * phi) * np.sin(theta / 2), np.cos(theta / 2)],
+        ]
+    )
+    return U
+
+
+def rotate_spinor_single_block(M, theta, phi):
+    """
+    Rotate the spinor matrix M by theta and phi
+    """
+    U = rotation_matrix(theta, phi)
+    Uinv = np.linalg.inv(U)
+    return Uinv @ M @ U
+
+
+def rotate_spinor_matrix(M, theta, phi, method="einsum"):
+    """
+    Rotate the spinor matrix M by theta and phi,
+    """
+    if method == "plain":
+        return rotate_spinor_matrix_plain(M, theta, phi)
+    elif method == "einsum":
+        return rotate_spinor_matrix_einsum(M, theta, phi)
+    elif method == "reshape":
+        return rotate_spinor_matrix_reshape(M, theta, phi)
+    elif method == "kron":
+        return rotate_spinor_matrix_kron(M, theta, phi)
+    elif method == "spkron":
+        return rotate_spinor_matrix_spkron(M, theta, phi)
+    else:
+        raise ValueError(f"Unknown method: {method}")
+
+
+def rotate_spinor_matrix_plain(M, theta, phi):
+    """
+    M is a matrix with shape (2N, 2N), where N is the number of sites, and each site has a 2x2 matrix
+    rotate each 2x2 block by theta and phi
+    """
+    Mnew = np.zeros_like(M)
+    U = rotation_matrix(theta, phi)
+    UT = U.conj().T
+    tmp = np.zeros((2, 2), dtype=np.complex128)
+    for i in range(M.shape[0] // 2):
+        for j in range(M.shape[0] // 2):
+            for k in range(2):
+                for l in range(2):
+                    tmp[k, l] = M[2 * i + k, 2 * j + l]
+            # tmp[:, :]=M[2*i:2*i+2, 2*j:2*j+2]
+            Mnew[2 * i : 2 * i + 2, 2 * j : 2 * j + 2] = UT @ tmp @ U
+    return Mnew
+
+
+def rotate_spinor_matrix_einsum(M, theta, phi):
+    """
+    Rotate the spinor matrix M by theta and phi,
+    """
+    N = M.shape[0] // 2
+    Mnew = np.reshape(M, (N, 2, N, 2))  # .swapaxes(1, 2)
+    # print("Mnew:", Mnew)
+    U = rotation_matrix(theta, phi)
+    UT = U.conj().T
+    Mnew = np.einsum(
+        "ij, rjsk, kl -> risl", UT, Mnew, U, optimize=True, dtype=np.complex128
+    )
+    Mnew = Mnew.reshape(2 * N, 2 * N)
+    return Mnew
+
+
+def rotate_spinor_matrix_einsum_R(M, theta, phi):
+    """
+    Rotate the spinor matrix M by theta and phi,
+    """
+    nR = M.shape[0]
+    N = M.shape[1] // 2
+    Mnew = np.reshape(M, (nR, N, 2, N, 2))  # .swapaxes(1, 2)
+    # print("Mnew:", Mnew)
+    U = rotation_matrix(theta, phi)
+    UT = U.conj().T
+    Mnew = np.einsum(
+        "ij, nrjsk, kl -> nrisl", UT, Mnew, U, optimize=True, dtype=np.complex128
+    )
+    Mnew = Mnew.reshape(nR, 2 * N, 2 * N)
+    return Mnew
+
+
+def rotate_spinor_Matrix_R(M, theta, phi):
+    return rotate_spinor_matrix_einsum_R(M, theta, phi)
+
+
+def rotate_spinor_matrix_reshape(M, theta, phi):
+    """
+    Rotate the spinor matrix M by theta and phi,
+    """
+    N = M.shape[0] // 2
+    Mnew = np.reshape(M, (N, 2, N, 2)).swapaxes(1, 2)
+    # print("Mnew:", Mnew)
+    U = rotation_matrix(theta, phi)
+    UT = U.conj().T
+    Mnew = UT @ Mnew @ U
+    Mnew = Mnew.swapaxes(1, 2).reshape(2 * N, 2 * N)
+    return Mnew
+
+
+def rotate_spinor_matrix_kron(M, theta, phi):
+    """ """
+    U = rotation_matrix(theta, phi)
+    # U = np.kron( U, np.eye(M.shape[0]//2))
+    # U = kron(eye_array(M.shape[0]//2), U)
+    U = np.kron(np.eye(M.shape[0] // 2), U)
+    M = U.conj().T @ M @ U
+    return M
+
+
+def rotate_spinor_matrix_spkron(M, theta, phi):
+    """ """
+    U = rotation_matrix(theta, phi)
+    # U = np.kron( U, np.eye(M.shape[0]//2))
+    U = kron(eye_array(M.shape[0] // 2), U)
+    # U = np.kron(np.eye(M.shape[0]//2), U)
+    M = U.conj().T @ M @ U
+    return M
+
+
+def test_rotate_spinor_M():
+    N = 2
+    M_re = np.random.rand(N * 2, N * 2)
+    M_im = np.random.rand(N * 2, N * 2)
+    M = M_re + 1j * M_im
+    M = M + M.T.conj()
+    # M=np.array([[1, 0], [0, 1]], dtype=np.complex128)
+    print(f"Original M: {M}")
+
+    import timeit
+
+    print("Time for rotate_spinor_matrix")
+    print(
+        timeit.timeit(lambda: rotate_spinor_matrix(M, np.pi / 2, np.pi / 2), number=10)
+    )
+    print("Time for rotate_spinor_matrix_einsum")
+    print(
+        timeit.timeit(
+            lambda: rotate_spinor_matrix_einsum(M, np.pi / 2, np.pi / 2), number=10
+        )
+    )
+    print("Time for rotate_spinor_matrix_reshape")
+    print(
+        timeit.timeit(
+            lambda: rotate_spinor_matrix_reshape(M, np.pi / 2, np.pi / 2), number=10
+        )
+    )
+    print("Time for rotate_spinor_matrix_kron")
+    print(
+        timeit.timeit(
+            lambda: rotate_spinor_matrix_kron(M, np.pi / 2, np.pi / 2), number=10
+        )
+    )
+    print("Time for rotate_spinor_matrix_spkron")
+    print(
+        timeit.timeit(
+            lambda: rotate_spinor_matrix_spkron(M, np.pi / 2, np.pi / 2), number=10
+        )
+    )
+
+    Mrot1 = rotate_spinor_matrix(M, np.pi / 2, np.pi / 2)
+    Mrot2 = rotate_spinor_matrix_einsum(M, np.pi / 2, np.pi / 2)
+    Mrot3 = rotate_spinor_matrix_reshape(M, np.pi / 2, np.pi / 2)
+    Mrot4 = rotate_spinor_matrix_kron(M, np.pi / 2, np.pi / 2)
+    Mrot5 = rotate_spinor_matrix_spkron(M, np.pi / 2, np.pi / 2)
+    print(f"Rotated M with jit:\n {Mrot1}")
+    print(f"Rotated M with einsum:\n {Mrot2-Mrot1}")
+    print(f"Rotated M with reshape:\n {Mrot3-Mrot1}")
+    print(f"Rotated M with kron:\n {Mrot4-Mrot1}")
+    print(f"Rotated M with spkron:\n {Mrot5-Mrot1}")
+
+    M_rot00 = rotate_spinor_matrix(M, 0, 0)
+    M_rot00_sph = rotate_Matrix_from_z_to_spherical(M, 0, 0)
+    print(f"Rotated M with theta=0, phi=0 compared with M:\n {M_rot00-M}")
+    print(f"Rotated M with theta=0, phi=0 compared with M:\n {M_rot00_sph-M}")
+
+
+def test_rotate_spinor_oneblock():
+    M = np.array([[1.1, 0], [0, 0.9]])
+    print(np.array(pauli_block_all(M)).ravel())
+    print("Rotate by pi/2, pi/2 (z to y)")
+    Mnew = rotate_spinor_matrix_einsum(M, np.pi / 2, np.pi / 2)
+    print(np.array(pauli_block_all(Mnew)).ravel())
+
+    print("Rotate by pi/2, 0 (z to x)")
+    Mnew = rotate_spinor_matrix_kron(M, np.pi / 2, 0)
+
+    print(np.array(pauli_block_all(Mnew)).ravel())
+
+    print(Mnew)
+
+
 def rotate_Matrix_from_z_to_spherical(M, theta, phi, normalize=True):
     """
     Given a spinor matrix M, rotate it from z-axis to spherical coordinates
     """
-    axis = spherical_to_cartesian(theta, phi, normalize)
-    return rotate_Matrix_from_z_to_axis(M, axis, normalize)
+    # axis = spherical_to_cartesian(theta, phi, normalize)
+    # return rotate_Matrix_from_z_to_axis(M, axis, normalize)
+    return rotate_spinor_matrix_einsum(M, theta, phi)
+
+
+def test_rotate_Matrix_from_z_to_spherical():
+    M_re = np.random.rand(2, 2)
+    M_im = np.random.rand(2, 2)
+    M = M_re + 1j * M_im
+    print(M)
+    M_rot = rotate_Matrix_from_z_to_spherical(M, 0, 0)
+    print(M_rot)
 
 
 def test_rotate_Matrix_from_z_to_axis():
@@ -53,4 +267,8 @@ def test_rotate_Matrix_from_z_to_axis():
 
 
 if __name__ == "__main__":
-    test_rotate_Matrix_from_z_to_axis()
+    # test_rotate_Matrix_from_z_to_axis()
+    # test_rotate_Matrix_from_z_to_spherical()
+    test_rotate_spinor_M()
+    # test_rotate_spinor_oneblock()
+    pass

TB2J/pauli.py

@@ -143,11 +143,47 @@ def pauli_block_all(M):
     return MI, Mx, My, Mz
 
 
-def gather_pauli_blocks(MI, Mx, My, Mz):
+def gather_pauli_blocks(MI, Mx, My, Mz, coeffs=[1.0, 1.0, 1.0, 1.0]):
     """
     Gather the I, x, y, z component of a matrix.
     """
-    return np.kron(MI, s0) + np.kron(Mx, s1) + np.kron(My, s2) + np.kron(Mz, s3)
+    cI, cx, cy, cz = coeffs
+    return (
+        cI * np.kron(MI, s0)
+        + cx * np.kron(Mx, s1)
+        + cy * np.kron(My, s2)
+        + cz * np.kron(Mz, s3)
+    )
+
+
+def pauli_part(M, coeffs=[1.0, 1.0, 1.0, 1.0]):
+    """
+    Get the I, x, y, z part of a matrix.
+    """
+    MI, Mx, My, Mz = pauli_block_all(M)
+    return gather_pauli_blocks(MI, Mx, My, Mz, coeffs=coeffs)
+
+
+def chargepart(M):
+    """
+    Get the charge part of a matrix.
+    """
+    MI = (M[::2, ::2] + M[1::2, 1::2]) / 2.0
+    Mcopy = np.zeros_like(M)
+    Mcopy[::2, ::2] = MI
+    Mcopy[1::2, 1::2] = MI
+    return Mcopy
+
+
+def spinpart(M):
+    """
+    Get the spin part of a matrix.
+    """
+    MI = (M[::2, ::2] + M[1::2, 1::2]) / 2.0
+    Mcopy = M.copy()
+    Mcopy[::2, ::2] -= MI
+    Mcopy[1::2, 1::2] -= MI
+    return Mcopy
 
 
 def test_gather_pauli_blocks():

TB2J/symmetrize_J.py

@@ -0,0 +1,120 @@
+from sympair import SymmetryPairFinder, SymmetryPairGroupDict
+import numpy as np
+from pathlib import Path
+from TB2J.versioninfo import print_license
+import copy
+
+
+class TB2JSymmetrizer:
+    def __init__(self, exc, symprec=1e-8, verbose=True):
+        # list of pairs with the index of atoms
+        ijRs = exc.ijR_list_index_atom()
+        finder = SymmetryPairFinder(atoms=exc.atoms, pairs=ijRs, symprec=symprec)
+        self.verbose = verbose
+
+        if verbose:
+            print("=" * 30)
+            print_license()
+            print("-" * 30)
+            print(
+                "WARNING: The symmetry detection is based on the crystal symmetry, not the magnetic symmetry. Make sure if this is what you want."
+            )
+            print("-" * 30)
+            if exc.has_dmi:
+                print(
+                    "WARNING: Currently only the isotropic exchange is symmetrized. Symmetrization of DMI and anisotropic exchange are not yet implemented."
+                )
+
+            print(f"Finding crystal symmetry with symprec of {symprec} Angstrom.")
+            print("Symmetry found:")
+            print(finder.spacegroup)
+            print(f"-" * 30)
+        self.pgdict = finder.get_symmetry_pair_group_dict()
+        self.exc = exc
+        self.new_exc = copy.deepcopy(exc)
+
+    def print_license(self):
+        print_license()
+
+    def symmetrize_J(self):
+        """
+        Symmetrize the exchange parameters J.
+        """
+        symJdict = {}
+        Jdict = self.exc.exchange_Jdict
+        ngroup = self.pgdict
+        for pairgroup in self.pgdict.groups:
+            ijRs = pairgroup.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
+        self.new_exc.exchange_Jdict = symJdict
+
+    def output(self, path="TB2J_symmetrized"):
+        if path is None:
+            path = Path(".")
+        self.new_exc.write_all(path=path)
+
+    def run(self, path=None):
+        print("** Symmetrizing exchange parameters.")
+        self.symmetrize_J()
+        print("** Outputing the symmetrized exchange parameters.")
+        print(f"** Output path: {path} .")
+        self.output(path=path)
+        print("** Finished.")
+
+
+def symmetrize_J(
+    exc=None,
+    path=None,
+    fname="TB2J.pickle",
+    symprec=1e-5,
+    output_path="TB2J_symmetrized",
+):
+    """
+    symmetrize the exchange parameters
+    parameters:
+    exc: exchange
+    """
+    if exc is None:
+        exc = SpinIO.load_pickle(path=path, fname=fname)
+    symmetrizer = TB2JSymmetrizer(exc, symprec=symprec)
+    symmetrizer.run(path=output_path)
+
+
+def symmetrize_J_cli():
+    from argparse import ArgumentParser
+
+    parser = ArgumentParser(
+        description="Symmetrize exchange parameters. Currently, it take the crystal symmetry into account and  not the magnetic moment into account."
+    )
+    parser.add_argument(
+        "-i",
+        "--inpath",
+        default=None,
+        help="input path to the exchange parameters",
+    )
+    parser.add_argument(
+        "-o",
+        "--outpath",
+        default="TB2J_results_symmetrized",
+        help="output path to the symmetrized exchange parameters",
+    )
+    parser.add_argument(
+        "-s",
+        "--symprec",
+        type=float,
+        default=1e-5,
+        help="precision for symmetry detection. default is 1e-5 Angstrom",
+    )
+    args = parser.parse_args()
+    if args.inpath is None:
+        parser.print_help()
+        raise ValueError("Please provide the input path to the exchange.")
+    symmetrize_J(path=args.inpath, output_path=args.outpath, symprec=args.symprec)
+
+
+if __name__ == "__main__":
+    symmetrize_J_cli()

TB2J/utils.py

@@ -87,6 +87,7 @@ def auto_assign_wannier_to_atom(positions, atoms, max_distance=0.1, half=False):
     """
     pos = np.array(positions)
     atompos = atoms.get_scaled_positions(wrap=False)
+    cell = atoms.get_cell()
     ind_atoms = []
     newpos = []
     refpos = []
@@ -95,8 +96,9 @@ def auto_assign_wannier_to_atom(positions, atoms, max_distance=0.1, half=False):
         dp = p[None, :] - atompos
         # residual of d
         r = dp - np.round(dp)
+        r_cart = r @ cell
         # find the min of residual
-        normd = np.linalg.norm(r, axis=1)
+        normd = np.linalg.norm(r_cart, axis=1)
         iatom = np.argmin(normd)
         # ref+residual
         rmin = r[iatom]
@@ -330,3 +332,82 @@ def simpson_nonuniform(x, f):
         result += f[N - 1] * (h[N - 1] ** 2 + 3 * h[N - 1] * h[N - 2]) / (6 * h[N - 2])
         result -= f[N - 2] * h[N - 1] ** 3 / (6 * h[N - 2] * (h[N - 2] + h[N - 1]))
     return result
+
+
+def simpson_nonuniform_weight(x):
+    """
+    Simpson rule for irregularly spaced data.
+    x: list or np.array of floats
+        Sampling points for the function values
+    Returns
+    -------
+    weight : list or np.array of floats
+        weight for the Simpson rule
+    For the function f(x), the integral is approximated as
+    $\int f(x) dx \approx \sum_i weight[i] * f(x[i])$
+    """
+
+    weight = np.zeros_like(x)
+    N = len(x) - 1
+    h = np.diff(x)
+
+    for i in range(1, N, 2):
+        hph = h[i] + h[i - 1]
+        weight[i] += (h[i] ** 3 + h[i - 1] ** 3 + 3.0 * h[i] * h[i - 1] * hph) / (
+            6 * h[i] * h[i - 1]
+        )
+        weight[i - 1] += (
+            2.0 * h[i - 1] ** 3 - h[i] ** 3 + 3.0 * h[i] * h[i - 1] ** 2
+        ) / (6 * h[i - 1] * hph)
+        weight[i + 1] += (
+            2.0 * h[i] ** 3 - h[i - 1] ** 3 + 3.0 * h[i - 1] * h[i] ** 2
+        ) / (6 * h[i] * hph)
+
+    if (N + 1) % 2 == 0:
+        weight[N] += (2 * h[N - 1] ** 2 + 3.0 * h[N - 2] * h[N - 1]) / (
+            6 * (h[N - 2] + h[N - 1])
+        )
+        weight[N - 1] += (h[N - 1] ** 2 + 3 * h[N - 1] * h[N - 2]) / (6 * h[N - 2])
+        weight[N - 2] -= h[N - 1] ** 3 / (6 * h[N - 2] * (h[N - 2] + h[N - 1]))
+    return weight
+
+
+def trapz_nonuniform_weight(x):
+    """
+    trapezoidal rule for irregularly spaced data.
+    x: list or np.array of floats
+        Sampling points for the function values
+    Returns
+    -------
+    weight : list or np.array of floats
+        weight for the trapezoidal rule
+    For the function f(x), the integral is approximated as
+    $\int f(x) dx \approx \sum_i weight[i] * f(x[i])$
+    """
+    h = np.diff(x)
+    weight = np.zeros_like(x)
+    weight[0] = h[0] / 2.0
+    weight[1:-1] = (h[1:] + h[:-1]) / 2.0
+    weight[-1] = h[-1] / 2.0
+    return weight
+
+
+def test_simpson_nonuniform():
+    x = np.array([0.0, 0.1, 0.3, 0.5, 0.8, 1.0])
+    w = simpson_nonuniform_weight(x)
+    # assert np.allclose(w, [0.1, 0.4, 0.4, 0.4, 0.4, 0.1])
+    assert np.allclose(simpson_nonuniform(x, x**8), 0.12714277533333335)
+    print("simpson_weight:", simpson_nonuniform_weight(x) @ x**8, 0.12714277533333335)
+    print("trapz_weight:", trapz_nonuniform_weight(x) @ x**8)
+
+    x2 = np.linspace(0, 1, 500)
+    print(simpson_nonuniform_weight(x2) @ x2**8, 1 / 9.0)
+    print(simpson_nonuniform_weight(x2) @ x2**8)
+    print("simpson_weight:", simpson_nonuniform_weight(x2) @ x2**8)
+    print("trapz_weight:", trapz_nonuniform_weight(x2) @ x2**8)
+
+    assert np.allclose(simpson_nonuniform(x, x**8), 1 / 9.0)
+
+
+if __name__ == "__main__":
+    test_simpson_nonuniform()

{TB2J-0.9.4rc0.data → TB2J-0.9.6rc0.data}/scripts/abacus2J.py

@@ -1,8 +1,9 @@
 #!python
-from TB2J.abacus.gen_exchange_abacus import gen_exchange_abacus
-from TB2J.versioninfo import print_license
-import sys
 import argparse
+import sys
+
+from TB2J.interfaces import gen_exchange_abacus
+from TB2J.versioninfo import print_license
 
 
 def run_abacus2J():
@@ -141,7 +142,7 @@ def run_abacus2J():
         description=args.description,
         output_path=args.output_path,
         use_cache=args.use_cache,
-        np=args.np,
+        nproc=args.np,
         exclude_orbs=args.exclude_orbs,
         orb_decomposition=args.orb_decomposition,
     )