TB2J 0.9.12.6__py3-none-any.whl → 0.9.12.17__py3-none-any.whl

TB2J/io_exchange/io_espins.py

@@ -0,0 +1,276 @@
+import os
+
+import numpy as np
+
+
+def _get_shell_index(cls, key):
+    """Determine shell index based on distance grouping.
+
+    Parameters
+    ----------
+    cls : SpinIO
+        SpinIO instance
+    key : tuple
+        (R, i, j) key for exchange parameter
+
+    Returns
+    -------
+    int
+        Shell index (1 for nearest neighbors, 2 for next nearest, etc.)
+    """
+    if not hasattr(cls, "_distance_shells"):
+        # Calculate all distances and group into shells
+        distances = []
+        for k in cls.exchange_Jdict:
+            if cls.distance_dict and k in cls.distance_dict:
+                distances.append(cls.distance_dict[k][1])
+
+        if distances:
+            # Sort distances and group by rounding to nearest 0.01 Å
+            sorted_distances = sorted(set(round(d * 100) for d in distances))
+            cls._distance_shells = {}
+            for shell_idx, dist_int in enumerate(sorted_distances, 1):
+                cls._distance_shells[dist_int / 100] = shell_idx
+        else:
+            cls._distance_shells = {}
+
+    if cls.distance_dict and key in cls.distance_dict:
+        distance = cls.distance_dict[key][1]
+        rounded_dist = round(distance * 100)
+        return cls._distance_shells.get(rounded_dist / 100, 1)
+
+    return 1
+
+
+def write_espins(cls, path="TB2J_results/ESPInS"):
+    """Write ESPInS format input files.
+
+    Parameters
+    ----------
+    cls : SpinIO
+        SpinIO instance containing exchange parameters
+    path : str
+        Output directory path
+    """
+    if not os.path.exists(path):
+        os.makedirs(path)
+
+    write_espins_input(cls, os.path.join(path, "espins.in"))
+
+
+def write_espins_input(cls, fname):
+    """Write the main ESPInS input file.
+
+    Parameters
+    ----------
+    cls : SpinIO
+        SpinIO instance
+    fname : str
+        Output filename
+    """
+    with open(fname, "w") as myfile:
+        # Write unit cell
+        myfile.write("! ESPInS input file generated by TB2J\n")
+        # myfile.write("! Compatible with ESPInS version > 1.0 \n")
+        myfile.write("! The unit cell in angstrom\n")
+        myfile.write("Begin Unit_Cell_Cart\n")
+        cell = cls.atoms.get_cell()
+        for i in range(3):
+            myfile.write("     " + " ".join(f"{x:12.8f}" for x in cell[i]) + "\n")
+        myfile.write("End Unit_Cell_Cart\n\n")
+
+        # Write atomic positions
+        myfile.write("! Atomic positions in reduced coordinates\n")
+        myfile.write("Begin Atoms_Frac\n")
+        scaled_positions = cls.atoms.get_scaled_positions()
+        symbols = cls.atoms.get_chemical_symbols()
+
+        for i, (symbol, pos) in enumerate(zip(symbols, scaled_positions)):
+            if cls.index_spin[i] >= 0:  # Only magnetic atoms
+                myfile.write(
+                    f"  {symbol:<8} {pos[0]:10.7f} {pos[1]:10.7f} {pos[2]:10.7f}    1.00\n"
+                )
+        myfile.write("End Atoms_Frac\n\n\n")
+
+        # Write temperature settings (default values)
+        myfile.write("tem_start          =   1\n")
+        myfile.write("tem_end            =   30\n")
+        myfile.write("tems_num           =   30\n")
+        # myfile.write("!! tems_mode          = man\n")
+        # myfile.write("!! tems               = 5.00 10.00 15.00 20.00\n\n")
+
+        # Write Monte Carlo parameters (default values)
+        myfile.write("! Pt                 = .True.\n")
+        myfile.write("! Pt_steps_swap      = 40\n\n")
+
+        myfile.write("steps_warmup      =       100000\n")
+        myfile.write("steps_mc          =       100000\n")
+        myfile.write("steps_measure     =           2\n\n")
+
+        myfile.write("initial_sconfig   =        ferro\n")
+        myfile.write("mcarlo_mode       =       random\n\n")
+
+        myfile.write("supercell_size    =      10     10     1\n\n")
+
+        # Write Hamiltonian settings
+        myfile.write(" ## Hamiltonian\n")
+        myfile.write("Ham_bij           = .False.\n")
+        myfile.write("Ham_jij_matrix    = .True.\n")
+        myfile.write("! We don't have single ion anisotropy, put it to .False.\n")
+        myfile.write("Ham_singleion_matrix    = .False.\n\n\n")
+
+        # Write single ion anisotropy matrix if available
+        # if cls.has_uniaxial_anistropy:
+        #    myfile.write("! Don't put this block\n")
+        #    myfile.write("!Begin SingleIon_Matrix\n")
+        #    # Placeholder for single ion anisotropy
+        #    myfile.write("@Axx=0.000 , Axy=-1.65e-07 , Axz=6e-08 , Ayx=-1.65e-07 , Ayy=7.73e-05 , Ayz=-1.5e-05 , Azx=6e-08 , Azz= 6.8e-05\n")
+        #    myfile.write("!End SingleIon_Matrix\n\n")
+
+        # Write exchange parameters
+        myfile.write(
+            """! f1 is the fractional coordinate of atom i, and f2 is of atom j (rj+Rj). Then jij in eV, sh is index of shell, t1 is index of i, t2 is index of j (counting from 1).  \n
+            !The convention of the Hamiltonian is H = - sum_<ij> Jij Si Sj, and i, j are ordererd so that there is no double counting (ij and ji). To convert from TB2J exchange.out (which has both ij and ji), multiply Jij by 2.  \n 
+            \n"""
+        )
+
+        if cls.has_exchange:
+            myfile.write("Begin Jij_parameters\n")
+
+            # Create a list of unique exchange parameters sorted by distance
+            exchange_list = []
+            # written_keys = set()
+
+            for key, jval in cls.exchange_Jdict.items():
+                R, i, j = key
+
+                # Skip if this is the symmetric counterpart of an already written pair
+                # symmetric_key = (tuple(-np.array(R)), j, i)
+                # if symmetric_key in written_keys:
+                #    continue
+
+                # Get distance for sorting
+                distance = (
+                    cls.distance_dict[key][1]
+                    if cls.distance_dict and key in cls.distance_dict
+                    else 0.0
+                )
+
+                exchange_list.append((distance, key, jval))
+                # written_keys.add(key)
+
+            # Sort by distance
+            exchange_list.sort(key=lambda x: x[0])
+
+            for distance, key, jval in exchange_list:
+                R, i, j = key
+                iatom = cls.iatom(i)
+                jatom = cls.iatom(j)
+
+                # Get fractional coordinates
+                pos_i = cls.atoms.get_scaled_positions()[iatom]
+                pos_j = cls.atoms.get_scaled_positions()[jatom]
+
+                # Calculate fractional coordinates for j+R
+                pos_jR = pos_j + R
+                # Determine shell index based on distance
+                shell = _get_shell_index(cls, key)
+
+                myfile.write(
+                    f"  f1=    {pos_i[0]:10.6f},    {pos_i[1]:10.6f},    {pos_i[2]:10.6f}:f2=    {pos_jR[0]:10.6f},    {pos_jR[1]:10.6f},    {pos_jR[2]:10.6f}:jij=  {jval*2:10.8f}!:sh=  {shell}!:t1=  {i+1}:t2=  {j+1}\n"
+                )
+
+            myfile.write("End Jij_parameters\n\n")
+
+        # Write exchange matrix if available
+        if cls.has_exchange:
+            myfile.write(
+                "! Each matrix element is corresponding to the previous block. The J tensor include the isotropic, anisotropic exchange and DMI. \n"
+            )
+            myfile.write("Begin Jij_matrix\n")
+
+            # Create a list of unique exchange parameters sorted by distance
+            exchange_list = []
+            # written_keys = set()
+
+            for key in cls.exchange_Jdict:
+                R, i, j = key
+
+                # Skip if this is the symmetric counterpart of an already written pair
+                # symmetric_key = (tuple(-np.array(R)), j, i)
+                # if symmetric_key in written_keys:
+                #    continue
+
+                # Get distance for sorting
+                distance = (
+                    cls.distance_dict[key][1]
+                    if cls.distance_dict and key in cls.distance_dict
+                    else 0.0
+                )
+
+                exchange_list.append((distance, key))
+                # written_keys.add(key)
+
+            # Sort by distance
+            exchange_list.sort(key=lambda x: x[0])
+
+            for distance, key in exchange_list:
+                R, i, j = key
+                # Get full J tensor
+                J_tensor = cls.get_J_tensor(i, j, R, Jiso=True, Jani=True, DMI=True) * 2
+
+                # Format matrix elements exactly as in the example
+                myfile.write(
+                    f"Jxx={J_tensor[0, 0]:.8f}, Jxy={J_tensor[0, 1]:.8f}, Jxz={J_tensor[0, 2]:.8f}, Jyx={J_tensor[1, 0]:.8f}, Jyy={J_tensor[1, 1]:.8f}, Jyz={J_tensor[1, 2]:.8f}, Jzx={J_tensor[2, 0]:.8f}, Jzy={J_tensor[2, 1]:.8f}, Jzz={J_tensor[2, 2]:.8f}\n"
+                )
+
+            myfile.write("End Jij_matrix\n\n")
+
+        # Write biquadratic exchange if available
+        # if cls.has_biquadratic and cls.biquadratic_Jdict:
+        if False:
+            myfile.write("! Biquadratic, don't put it. \n")
+            myfile.write("Begin Bij_parameters\n")
+
+            # Create a list of unique biquadratic parameters sorted by distance
+            biquadratic_list = []
+            written_keys = set()
+
+            for key, bval in cls.biquadratic_Jdict.items():
+                R, i, j = key
+
+                # Skip if this is the symmetric counterpart of an already written pair
+                symmetric_key = (tuple(-np.array(R)), j, i)
+                if symmetric_key in written_keys:
+                    continue
+
+                # Get distance for sorting
+                distance = (
+                    cls.distance_dict[key][1]
+                    if cls.distance_dict and key in cls.distance_dict
+                    else 0.0
+                )
+
+                biquadratic_list.append((distance, key, bval))
+                written_keys.add(key)
+
+            # Sort by distance
+            biquadratic_list.sort(key=lambda x: x[0])
+
+            for distance, key, bval in biquadratic_list:
+                R, i, j = key
+                iatom = cls.iatom(i)
+                jatom = cls.iatom(j)
+
+                # Get fractional coordinates
+                pos_i = cls.atoms.get_scaled_positions()[iatom]
+                pos_j = cls.atoms.get_scaled_positions()[jatom]
+
+                # Calculate fractional coordinates for j+R
+                pos_jR = pos_j + np.dot(R, np.linalg.inv(cls.atoms.get_cell()))
+
+                myfile.write(
+                    f"  f1=    {pos_i[0]:10.6f},    {pos_i[1]:10.6f},    {pos_i[2]:10.6f}:f2=    {pos_jR[0]:10.6f},    {pos_jR[1]:10.6f},    {pos_jR[2]:10.6f}:bij= {bval:10.6f} !t1=  {i+1}:t2=  {j+1}\n"
+                )
+
+            myfile.write("End Bij_parameters\n")

TB2J/io_exchange/io_exchange.py

@@ -18,12 +18,12 @@ from datetime import datetime
 import matplotlib.pyplot as plt
 import numpy as np
 
-from TB2J import __version__
 from TB2J.io_exchange.io_txt import write_Jq_info
 from TB2J.Jtensor import combine_J_tensor
 from TB2J.kpoints import monkhorst_pack
 from TB2J.spinham.spin_api import SpinModel
 from TB2J.utils import symbol_number
+from TB2J.versioninfo import __version__
 
 
 class SpinIO(object):
@@ -149,6 +149,7 @@ class SpinIO(object):
         self.has_biquadratic = not (
             biquadratic_Jdict == {} or biquadratic_Jdict is None
         )
+
         self.biquadratic_Jdict = biquadratic_Jdict
 
         if NJT_ddict is not None:
@@ -459,9 +460,10 @@ Generation time: {now.strftime("%y/%m/%d %H:%M:%S")}
             if asr:
                 iR0 = np.argmin(np.linalg.norm(self.Rlist, axis=1))
                 assert np.linalg.norm(self.Rlist[iR0]) == 0
-                sum_JR = np.sum(np.sum(Jmat, axis=0))
+                sum_JR = np.sum(np.sum(Jmat, axis=0), axis=0)
+                print(sum_JR)
                 for i in range(n3):
-                    Jmat[iR0][i, i] -= sum_JRi[i]
+                    Jmat[iR0][i, i] -= sum_JR[i]
         elif order == "ij":
             Jmat = np.zeros((nR, n, n), dtype=float)
             for iR, R in enumerate(self.Rlist):
@@ -521,6 +523,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_espins(path=os.path.join(path, "ESPInS"))
 
         self.plot_all(savefile=os.path.join(path, "JvsR.pdf"))
         # self.write_Jq(kmesh=[9, 9, 9], path=path)
@@ -684,6 +687,11 @@ Generation time: {now.strftime("%y/%m/%d %H:%M:%S")}
 
         write_uppasd(self, path=path)
 
+    def write_espins(self, path):
+        from TB2J.io_exchange.io_espins import write_espins
+
+        write_espins(self, path=path)
+
 
 def gen_distance_dict(ind_mag_atoms, atoms, Rlist):
     distance_dict = {}

TB2J/io_exchange/io_uppasd.py

@@ -63,7 +63,6 @@ def write_uppasd_exchange(cls, fname):
             d = np.dot(np.array(R), cls.atoms.get_cell()) + pos[j] - pos[i]
             myfile.write(
                 "{i} {j} {Rx} {Ry} {Rz} {Jij}\n".format(
-                    IID=counter,
                     i=i + 1,
                     j=j + 1,
                     Rx=d[0],

TB2J/io_exchange/io_vampire.py

@@ -66,7 +66,7 @@ def write_vampire_unitcell_file(cls, fname):
 
 def write_vampire_mat_file(cls, fname):
     mat_tmpl = """#---------------------------------------------------
-# Material {id} 
+# Material {id}
 #---------------------------------------------------
 material[{id}]:material-name={name}
 material[{id}]:damping-constant={damping}
@@ -75,6 +75,8 @@ material[{id}]:uniaxial-anisotropy-constant={k1}
 material[{id}]:material-element={name}
 material[{id}]:initial-spin-direction = {spinat}
 material[{id}]:uniaxial-anisotropy-direction = {k1dir}
+# The following line is required for vampire 5 and later. 
+material[{id}]:unit-cell-category =  {id}
 #---------------------------------------------------
 """
     with open(fname, "w") as myfile:

TB2J/myTB.py

@@ -1,15 +1,17 @@
-import os
-import numpy as np
 import copy
-from scipy.linalg import eigh
-from scipy.sparse import csr_matrix
-from scipy.io import netcdf_file
+import os
 from collections import defaultdict
 
+import numpy as np
+
 # from tbmodels import Model
 from ase.atoms import Atoms
+from scipy.io import netcdf_file
+from scipy.linalg import eigh
+from scipy.sparse import csr_matrix
+
 from TB2J.utils import auto_assign_basis_name
-from TB2J.wannier import parse_ham, parse_xyz, parse_atoms, parse_tb
+from TB2J.wannier import parse_atoms, parse_ham, parse_tb, parse_xyz
 
 
 class AbstractTB:
@@ -187,9 +189,7 @@ class MyTB(AbstractTB):
         if os.path.exists(tb_fname):
             xcart, nbasis, data, R_degens = parse_tb(fname=tb_fname)
         else:
-            nbasis, data, R_degens = parse_ham(
-                fname=os.path.join(path, prefix + "_hr.dat")
-            )
+            nbasis, data, R_degens = parse_ham(fname=hr_fname)
             xcart, _, _ = parse_xyz(fname=os.path.join(path, prefix + "_centres.xyz"))
 
         if atoms is None:
@@ -237,7 +237,7 @@ class MyTB(AbstractTB):
         return m
 
     def gen_ham(self, k, convention=2):
-        """
+        r"""
         generate hamiltonian matrix at k point.
         H_k( i, j)=\sum_R H_R(i, j)^phase.
         There are two conventions,
@@ -451,7 +451,7 @@ class MyTB(AbstractTB):
         nbasis = root.dimensions["nbasis"]
         nspin = root.dimensions["nspin"]
         ndim = root.dimensions["ndim"]
-        natom = root.dimensions["natom"]
+        _natom = root.dimensions["natom"]
         Rlist = root.variables["R"][:]
         mdata_real = root.variables["data_real"][:]
         mdata_imag = root.variables["data_imag"][:]

TB2J/pauli.py

@@ -59,7 +59,7 @@ def pauli_decomp2(M):
     )
 
 
-def pauli_sigma_norm(M):
+def pauli_sigma_norm_old(M):
     MI, Mx, My, Mz = pauli_decomp2(M)
     return np.linalg.norm([Mx, My, Mz])
 
@@ -134,7 +134,7 @@ def pauli_block(M, idim):
     return tmp
 
 
-def pauli_block_all(M):
+def pauli_block_all_old(M):
     MI = (M[::2, ::2] + M[1::2, 1::2]) / 2.0
     Mx = (M[::2, 1::2] + M[1::2, ::2]) / 2.0
     # Note that this is not element wise product with sigma_y but dot product
@@ -143,6 +143,28 @@ def pauli_block_all(M):
     return MI, Mx, My, Mz
 
 
+def pauli_block_all(array):
+    A00 = array[..., ::2, ::2]
+    A01 = array[..., ::2, 1::2]
+    A10 = array[..., 1::2, ::2]
+    A11 = array[..., 1::2, 1::2]
+    n2 = array.shape[-1] // 2
+
+    out_dtype = np.result_type(array.dtype, np.complex64)
+    block = np.empty((*array.shape[:-2], 4, n2, n2), dtype=out_dtype)
+
+    np.add(A00, A11, out=block[..., 0, :, :])
+    block[..., 0, :, :] *= 0.5
+    np.add(A01, A10, out=block[..., 1, :, :])
+    block[..., 1, :, :] *= 0.5
+    np.subtract(A01, A10, out=block[..., 2, :, :])
+    block[..., 2, :, :] *= 0.5j
+    np.subtract(A00, A11, out=block[..., 3, :, :])
+    block[..., 3, :, :] *= 0.5
+
+    return block
+
+
 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.
@@ -212,3 +234,11 @@ def pauli_block_sigma_norm(M):
     evec = np.array((ex, ey, ez))
     evec = evec / np.linalg.norm(evec)
     return Mx * evec[0] + My * evec[1] + Mz * evec[2]
+
+
+def pauli_sigma_norm(array):
+    block = pauli_block_all(array)[..., 1:, :, :]
+    E = np.trace(block, axis1=-2, axis2=-1)
+    E /= np.linalg.norm(E, axis=-1, keepdims=True)
+    np.multiply(block, E[..., None, None], out=block)
+    return block.sum(axis=-3)

TB2J/plot.py

@@ -1,11 +1,12 @@
+import argparse
+import os
+
 import matplotlib.pyplot as plt
-from TB2J.spinham.spin_api import SpinModel
-from TB2J.io_exchange.io_exchange import SpinIO
 import numpy as np
-from TB2J import __version__
+
+from TB2J.io_exchange.io_exchange import SpinIO
 from TB2J.spinham.qsolver import QSolverASEWrapper
-import argparse
-import os
+from TB2J.spinham.spin_api import SpinModel
 
 
 def write_eigen(qmesh, gamma=True, path="./", output_fname="EigenJq.txt", **kwargs):
@@ -25,7 +26,7 @@ def plot_magnon_band(
     Jq=False,
     kpath_fname="exchange_kpth.txt",
     ax=None,
-    **kwargs
+    **kwargs,
 ):
     m = SpinModel(fname=fname, sc_matrix=None)
     m.set_ham(**kwargs)
@@ -57,7 +58,7 @@ def plot_magnon_dos(
     txt_filename="magnon_dos.txt",
     Jq=False,
     ax=None,
-    **kwargs
+    **kwargs,
 ):
     ffname = os.path.join(path, "exchange.xml")
     if not (os.path.exists(ffname) and os.path.isfile(ffname)):

TB2J/rotate_atoms.py

@@ -1,8 +1,9 @@
 #!/usr/bin/env python3
 import copy
-from ase.io import read, write
+
 import numpy as np
-from TB2J.tensor_rotate import Rxx, Rxy, Rxz, Ryx, Ryy, Ryz, Rzx, Rzy, Rzz
+from ase.io import read, write
+from TB2J.tensor_rotate import Rzx, Rzy, Rzz
 
 
 def rotate_atom_xyz(atoms, noncollinear=False):
@@ -15,14 +16,16 @@ def rotate_atom_xyz(atoms, noncollinear=False):
     will be generated.
     """
 
+    yield atoms
     rotation_axes = [(1, 0, 0), (0, 1, 0)]
     if noncollinear:
         rotation_axes += [(1, 1, 0), (1, 0, 1), (0, 1, 1)]
-    
+
     for axis in rotation_axes:
         rotated_atoms = copy.deepcopy(atoms)
         rotated_atoms.rotate(90, axis, rotate_cell=True)
         yield rotated_atoms
+    yield atoms
 
 
 def rotate_atom_spin_one_rotation(atoms, Rotation):
@@ -109,7 +112,7 @@ def rotate_xyz(fname, ftype="xyz", noncollinear=False):
     rotated = rotate_atom_xyz(atoms, noncollinear=noncollinear)
 
     for i, rotated_atoms in enumerate(rotated):
-        write(f"atoms_{i+1}.{ftype}", rotated_atoms)
-    write(f"atoms_0.{ftype}", atoms)
-
-    print(f"The output has been written to the atoms_i.{ftype} files. atoms_0.{ftype} contains the reference structure.")
+        write(f"atoms_{i}.{ftype}", rotated_atoms)
+    print(
+        f"The output has been written to the atoms_i.{ftype} files. atoms_0.{ftype} contains the reference structure."
+    )

TB2J/spinham/hamiltonian.py

@@ -19,7 +19,6 @@ from .plot import group_band_path
 from ase.cell import Cell
 from .qsolver import QSolver
 import json
-import os
 
 
 class NumpyEncoder(json.JSONEncoder):

TB2J/symmetrize_J.py

@@ -33,7 +33,7 @@ class TB2JSymmetrizer:
             print("Symmetry found:")
             print(finder.spacegroup)
             print("-" * 30)
-        self.pgdict = finder.get_symmetry_pair_group_dict()
+        self.pgdict = finder.get_symmetry_pair_list_dict()
         self.exc = exc
         self.new_exc = copy.deepcopy(exc)
         self.Jonly = Jonly
@@ -48,7 +48,7 @@ class TB2JSymmetrizer:
         symJdict = {}
         # Jdict = self.exc.exchange_Jdict
         # ngroup = self.pgdict
-        for pairgroup in self.pgdict.groups:
+        for pairgroup in self.pgdict.pairlists:
             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]

TB2J/tensor_rotate.py

@@ -1,7 +1,6 @@
 import numpy as np
-import scipy as sp
 from scipy.spatial.transform import Rotation
-from numpy.linalg import norm, det
+from numpy.linalg import norm
 
 
 # Rotation from a to b

TB2J/wannier/w90_tb_parser.py

@@ -2,10 +2,8 @@
 parse the tb files in Wannier90
 """
 
-import os
 import re
 import numpy as np
-from typing import List, Tuple, Dict
 
 
 def ssrline(file):

{tb2j-0.9.12.6.dist-info → tb2j-0.9.12.17.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: TB2J
-Version: 0.9.12.6
+Version: 0.9.12.17
 Summary: TB2J: First principle to Heisenberg exchange J using tight-binding Green function method
 Author-email: Xu He <mailhexu@gmail.com>
 Maintainer-email: Xu He <mailhexu@gmail.com>
@@ -23,30 +23,30 @@ Classifier: Intended Audience :: Science/Research
 Classifier: Topic :: Scientific/Engineering :: Chemistry
 Classifier: Topic :: Scientific/Engineering :: Physics
 Classifier: License :: OSI Approved :: BSD License
-Requires-Python: >=3.6
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: numpy<2.0
+Requires-Dist: numpy
 Requires-Dist: scipy
 Requires-Dist: matplotlib
 Requires-Dist: ase>=3.19
 Requires-Dist: tqdm
 Requires-Dist: pathos
 Requires-Dist: packaging>=20.0
-Requires-Dist: HamiltonIO>=0.2.4
+Requires-Dist: HamiltonIO>=0.2.8
 Requires-Dist: pre-commit
-Requires-Dist: sympair>0.1.0
+Requires-Dist: sympair>0.1.1
 Requires-Dist: tomli>=2.0.0
 Requires-Dist: tomli-w>=1.0.0
+Requires-Dist: typing_extensions
 Provides-Extra: siesta
 Requires-Dist: sisl>=0.9.0; extra == "siesta"
 Requires-Dist: netcdf4; extra == "siesta"
 Provides-Extra: lawaf
-Requires-Dist: lawaf==0.2.3; extra == "lawaf"
+Requires-Dist: lawaf>=0.2.3; extra == "lawaf"
 Provides-Extra: all
 Requires-Dist: sisl>=0.9.0; extra == "all"
 Requires-Dist: netcdf4; extra == "all"
-Requires-Dist: lawaf==0.2.3; extra == "all"
+Requires-Dist: lawaf>=0.2.3; extra == "all"
 Dynamic: license-file
 
 [![Python application](https://github.com/mailhexu/TB2J/actions/workflows/python-app.yml/badge.svg)](https://github.com/mailhexu/TB2J/actions/workflows/python-app.yml)