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

TB2J/exchange.py

@@ -10,13 +10,12 @@ from TB2J.exchange_params import ExchangeParams
 from TB2J.external import p_map
 from TB2J.green import TBGreen
 from TB2J.io_exchange import SpinIO
+from TB2J.mycfr import CFR
 from TB2J.orbmap import map_orbs_matrix
 from TB2J.pauli import pauli_block_all, pauli_block_sigma_norm
 from TB2J.utils import (
     kmesh_to_R,
-    simpson_nonuniform,
     symbol_number,
-    trapezoidal_nonuniform,
 )
 
 
@@ -28,6 +27,7 @@ class Exchange(ExchangeParams):
         self._prepare_Rlist()
         self.set_tbmodels(tbmodels)
         self._adjust_emin()
+        # self._prepare_elist(method="CFR")
         self._prepare_elist(method="legendre")
         self._prepare_basis()
         self._prepare_orb_dict()
@@ -45,8 +45,9 @@ class Exchange(ExchangeParams):
         os.makedirs(self.orbpath, exist_ok=True)
 
     def _adjust_emin(self):
-        self.emin = self.G.find_energy_ingap(rbound=self.efermi - 10.0) - self.efermi
-        # self.emin = -22.0
+        self.emin = self.G.find_energy_ingap(rbound=self.efermi - 15.0) - self.efermi
+        # self.emin = self.G.find_energy_ingap(rbound=self.efermi - 15.0) - self.efermi
+        # self.emin = -42.0
         print(f"A gap is found at {self.emin}, set emin to it.")
 
     def set_tbmodels(self, tbmodels):
@@ -61,21 +62,24 @@ class Exchange(ExchangeParams):
         for k in kmesh:
             self.kmesh = list(map(lambda x: x // 2 * 2 + 1, kmesh))
 
-    def _prepare_elist(self, method="legendre"):
+    def _prepare_elist(self, method="CFR"):
         """
         prepare list of energy for integration.
         The path has three segments:
          emin --1-> emin + 1j*height --2-> emax+1j*height --3-> emax
         """
-        self.contour = Contour(self.emin, self.emax)
         # if method.lower() == "rectangle":
         #    self.contour.build_path_rectangle(
         #        height=self.height, nz1=self.nz1, nz2=self.nz2, nz3=self.nz3
         #    )
         if method.lower() == "semicircle":
+            self.contour = Contour(self.emin, self.emax)
             self.contour.build_path_semicircle(npoints=self.nz, endpoint=True)
         elif method.lower() == "legendre":
+            self.contour = Contour(self.emin, self.emax)
             self.contour.build_path_legendre(npoints=self.nz, endpoint=True)
+        elif method.lower() == "cfr":
+            self.contour = CFR(nz=self.nz, T=600)
         else:
             raise ValueError(f"The path cannot be of type {method}.")
 
@@ -114,6 +118,7 @@ class Exchange(ExchangeParams):
                 else:
                     try:
                         atom_sym, orb_sym = base[:2]
+                        iatom = sdict[atom_sym]
                     except Exception:
                         iatom = base.iatom
                         atom_sym = base.iatom
@@ -168,7 +173,6 @@ or badly localized. Please check the Wannier centers in the Wannier90 output fil
         self.mmats = {}
         self.orbital_names = {}
         self.norb_reduced = {}
-        print(f"self.backend_name: {self.backend_name}")
         if self.backend_name.upper() in ["SIESTA", "ABACUS", "LCAOHAMILTONIAN"]:
             # print(f"magntic_elements: {self.magnetic_elements}")
             # print(f"include_orbs: {self.include_orbs}")
@@ -562,20 +566,13 @@ 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):
         Gk_all = self.G.get_Gk_all(e)

TB2J/exchangeCL2.py

@@ -1,15 +1,18 @@
 """
 Exchange from Green's function
 """
+
 import os
 from collections import defaultdict
+
 import numpy as np
-from TB2J.green import TBGreen
-from TB2J.io_exchange import SpinIO
 from tqdm import tqdm
+
 from TB2J.external import p_map
+from TB2J.green import TBGreen
+from TB2J.io_exchange import SpinIO
+
 from .exchange import ExchangeCL
-from .utils import simpson_nonuniform, trapezoidal_nonuniform
 
 
 class ExchangeCL2(ExchangeCL):
@@ -221,17 +224,23 @@ class ExchangeCL2(ExchangeCL):
         #    shutil.rmtree(path)
 
     def integrate(self, method="simpson"):
-        if method == "trapezoidal":
-            integrate = trapezoidal_nonuniform
-        elif method == "simpson":
-            integrate = simpson_nonuniform
+        # if method == "trapezoidal":
+        #    integrate = trapezoidal_nonuniform
+        # elif method == "simpson":
+        #    integrate = simpson_nonuniform
         for R, ijpairs in self.R_ijatom_dict.items():
             for iatom, jatom in ijpairs:
-                self.Jorb[(R, iatom, jatom)] = integrate(
-                    self.contour.path, self.Jorb_list[(R, iatom, jatom)]
+                # self.Jorb[(R, iatom, jatom)] = integrate(
+                #    self.contour.path, self.Jorb_list[(R, iatom, jatom)]
+                # )
+                # self.JJ[(R, iatom, jatom)] = integrate(
+                #    self.contour.path, self.JJ_list[(R, iatom, jatom)]
+                # )
+                self.Jorb[(R, iatom, jatom)] = self.contour.integrate_values(
+                    self.Jorb_list[(R, iatom, jatom)]
                 )
-                self.JJ[(R, iatom, jatom)] = integrate(
-                    self.contour.path, self.JJ_list[(R, iatom, jatom)]
+                self.JJ[(R, iatom, jatom)] = self.contour.integrate_values(
+                    self.JJ_list[(R, iatom, jatom)]
                 )
 
     def get_quantities_per_e(self, e):

TB2J/exchange_params.py

@@ -115,6 +115,14 @@ def add_exchange_args_to_parser(parser: argparse.ArgumentParser):
         type=str,
         nargs="*",
     )
+
+    parser.add_argument(
+        "--spinor",
+        help="whether the Wannier functions are spinor. Default: False",
+        action="store_true",
+        default=False,
+    )
+
     parser.add_argument(
         "--rcut",
         help="cutoff of spin pair distance. The default is to calculate all commensurate R point to the k mesh.",

TB2J/green.py

@@ -18,6 +18,17 @@ from TB2J.kpoints import ir_kpts, monkhorst_pack
 MAX_EXP_ARGUMENT = np.log(sys.float_info.max)
 
 
+def eigen_to_G2(H, S, efermi, energy):
+    """calculate green's function from eigenvalue/eigenvector for energy(e-ef): G(e-ef).
+    :param H: Hamiltonian matrix in eigenbasis
+    :param S: Overlap matrix in eigenbasis
+    :param efermi: fermi energy
+    :param energy: energy level e - efermi
+    """
+    # G = ((E+Ef) S - H)^-1
+    return np.linalg.inv((energy + efermi) * S - H)
+
+
 def eigen_to_G(evals, evecs, efermi, energy):
     """calculate green's function from eigenvalue/eigenvector for energy(e-ef): G(e-ef).
     :param evals:  eigen values
@@ -121,7 +132,10 @@ class TBGreen:
         elif kmesh is not None:
             if ibz:
                 self.kpts, self.kweights = ir_kpts(
-                    atoms=tbmodel.atoms, mp_grid=kmesh, ir=True, is_time_reversal=False
+                    atoms=tbmodel.atoms,
+                    mp_grid=kmesh,
+                    ir=True,
+                    is_time_reversal=False,
                 )
                 self.nkpts = len(self.kpts)
                 print(f"Using IBZ of kmesh of {kmesh}")

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")
+            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/kpoints.py

@@ -70,7 +70,21 @@ def ir_kpts(
     # Irreducible k-points
     # print("Number of ir-kpoints: %d" % len(np.unique(mapping)))
     # print(grid[np.unique(mapping)] / np.array(mesh, dtype=float))
-    return ird_kpts, weight
+
+    new_ir_kpts = []
+    new_weight = []
+    for ik, k in enumerate(ird_kpts):
+        # add k and -k to ird_kpts if -k is not in ird_kpts
+        if not any([np.allclose(-1.0 * k, kpt) for kpt in new_ir_kpts]):
+            new_ir_kpts.append(k)
+            new_ir_kpts.append(-1.0 * k)
+            new_weight.append(weight[ik] / 2)
+            new_weight.append(weight[ik] / 2)
+        else:
+            new_ir_kpts.append(k)
+            new_weight.append(weight[ik])
+    # return ird_kpts, weight
+    return np.array(new_ir_kpts), np.array(new_weight)
 
 
 def test_ir_kpts():

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()