TB2J 0.9.0.2__py3-none-any.whl → 0.9.0.3__py3-none-any.whl

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-0.9.0.2.dist-info → TB2J-0.9.0.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: TB2J
-Version: 0.9.0.2
+Version: 0.9.0.3
 Summary: TB2J: First principle to Heisenberg exchange J using tight-binding Green function method
 Author: Xu He
 Author-email: mailhexu@gmail.com

{TB2J-0.9.0.2.dist-info → TB2J-0.9.0.3.dist-info}/RECORD

@@ -1,13 +1,11 @@
 TB2J/Jdownfolder.py,sha256=Rmg6KfQ-Lkhei5daTJ2POzr0XL-R1WM-rzUnDcfoDhc,9595
 TB2J/Jtensor.py,sha256=t6OsqrSlYW6Im4H7ykVAW8Al_pFXN4C5yj2UEsV6r7g,3181
-TB2J/MAE.py,sha256=-KWqxjKJvPFuxsMjm0c3nESyUFDeFTqsV7QzPJN-Fxo,7579
 TB2J/Oiju.py,sha256=cNGv8N5uH_swGq7cnAt2OyiDfqtjLlLrwseGu0E4iaM,3383
 TB2J/Oiju_epc.py,sha256=oytM3NYW7nWmklrGgNlqwIpI_JYv_hb7ZnR4o9nYNog,6809
 TB2J/__init__.py,sha256=hcEWkag_UvLm1ZSbjsgcTWkGVlR3Bwmzg1QYAwsvf-g,24
 TB2J/basis.py,sha256=DFo6_QUwjBwisP6zGxvoO0lpGTMDPAOkiL9giNCjOjA,1558
 TB2J/citation.py,sha256=gcQeyJZaT1Qrtsl8Y3s4neOH3-vvgmIcCvXeV2o3vj0,2891
 TB2J/contour.py,sha256=aw8LX6wVFCRPhcpkzuI0jGnHisvk4cezvUhkF_6Yx94,2633
-TB2J/cut_cell.py,sha256=kr9WeQhBQLm8QXL2B3NcsSYmSw-OAtJk3f9wksAOZbs,2952
 TB2J/density_matrix.py,sha256=D5k8Oe21OCiLVORNYbo4TZOFG0slrQSbj91kJ3TMFjs,1514
 TB2J/epc.py,sha256=zLbtqZJhDr8DnnGN6YENcXwrMb3Qxu6KB08mLy9Pw20,3474
 TB2J/exchange.py,sha256=dsXQhlxXaBurxa7z3YkBjqmEFFtfEy1xaHf0VT3eKZE,29581
@@ -17,20 +15,18 @@ TB2J/exchange_qspace.py,sha256=ZL68qBGFUaQ9BsSPsJaaoWOr9RssPiqX34R_9I3nk_8,8436
 TB2J/gpaw_wrapper.py,sha256=aJ--9Dtyq7jOP1Hkh-Sh1nWcfXm6zKcljOCO0DNCAr0,6890
 TB2J/green.py,sha256=QAJbDaR91QLres5gUPk37iqVsuQdPTt92VtEYLCl240,13170
 TB2J/greentest.py,sha256=2ISSfhor9ecSEOi_E6b4Cv26wEIQlwlzca0ru8z44_E,1603
-TB2J/io_merge.py,sha256=t85k3L6IL9X5ys-PWK7CzResb3xJsyqM3LAlKPUe9vM,6825
+TB2J/io_merge.py,sha256=E1_GfAB2HGpW-ipaO2lqU9SvaslwkiLxssn4DqJpMT8,6899
 TB2J/kpoints.py,sha256=6XK2KqTncidEq3o9GuO6VEZRPNTRtWeXg9QfcV-9smI,532
 TB2J/manager.py,sha256=4-4x9jJRHpUEqJuhc5HqpXfh2-Ze5G9Wg8gOtn-AqR4,15372
 TB2J/mathutils.py,sha256=tHA6q3KPDpXLIbZHdDZ2NU5s886VVM_oEG490zQ6Ris,300
 TB2J/myTB.py,sha256=ok_B4my29bOIghMSZfx0Es6G8FaXaIiLP4gPxTdSj00,17659
 TB2J/orbmap.py,sha256=RCMJkOPGbfPrcZzcc5ia1ZMKBQWxGcyj8W1ve8BJaEw,6669
-TB2J/patch.py,sha256=Z3KZklID9U8zKuk6Ek1Tq95JcY3eT4770dsdcXz6mAA,1067
 TB2J/pauli.py,sha256=zOELm7Vgxw6SMaO5l7qVWx1pBKZt25RLnEpnVM3dz_0,4545
 TB2J/pert.py,sha256=RaCJfewl0doht4cjAnzzGKe-uj2le4aqe0iPKFrq9fo,1192
 TB2J/plot.py,sha256=AnFIFWE2vlmj7Z6f_7-dX_O1stJN-qbuiurPj43dUCM,4104
 TB2J/rotate_atoms.py,sha256=Dwptn-wdDW4zYzjYb95yxTzuZOe9WPuLjh3d3-YcSs0,3277
 TB2J/rotate_siestaDM.py,sha256=eR97rspdrRaK9YTwQwUKfobI0S9UnEcbEZ2f5IgR7Tk,1070
 TB2J/sisl_wrapper.py,sha256=A5x1-tt8efUSPeGY5wM5m6-pJYQFXTCzQHVqD6RBa2g,14792
-TB2J/supercell.py,sha256=4hgLGPBLRUDhtD-eF29v46ex7fHdkH-OENjS2wGLFww,19588
 TB2J/tensor_rotate.py,sha256=4-DfT_Mg5e40fbd74M5W0D5DqmUq-kVOOLDkkkI834A,8083
 TB2J/utest.py,sha256=z_ahi7tpHQF9WlHNQihcQ7qzfezRJQXQt28eB1X_z64,3897
 TB2J/utils.py,sha256=DHkc7BK0KUGesfoAv1OxMgIw_iZzcFXh--3ybsFSd_c,12535
@@ -51,7 +47,6 @@ TB2J/external/p_tqdm.py,sha256=ug1jy3-43r8iW7bC37xzPSIe0EjYKH_GUluGzMiQiDw,5831
 TB2J/io_exchange/__init__.py,sha256=KfGHum7B8E4G_KKfillqw0lErtoyKEuFUUttHLs-mg4,32
 TB2J/io_exchange/io_exchange.py,sha256=RxCZ7OOxhiIzGrIidCOqxNbgLsrHUfCqDVinMvrPdmI,19354
 TB2J/io_exchange/io_multibinit.py,sha256=8PDmWxzGuv-GwJosj2ZTmiyNY_duFVWJ4ekCuSqGdd8,6739
-TB2J/io_exchange/io_pickle.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 TB2J/io_exchange/io_tomsasd.py,sha256=NqkAC1Fl-CUnFA21eBzSy_S5F_oeQFJysw4UukQbN8o,4173
 TB2J/io_exchange/io_txt.py,sha256=BMr1eSILlKpgtjvDx7uw2VMAkEKSvGEPNxpaT_zev0I,10547
 TB2J/io_exchange/io_uppasd.py,sha256=bI4iPEgnK4TvCZNvb6x2xYXgjW7pEehCqmcizy2pqFU,3301
@@ -64,10 +59,8 @@ TB2J/mathutils/rotate_spin.py,sha256=XtfwHGfIqI9nRYZcCd_yQ3Ud1AXVJj9fwqIHloMcaCs
 TB2J/spinham/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 TB2J/spinham/base_parser.py,sha256=oQRHvFE_BlUtTaTZykKgvicu40oXcbICB-D1aAt-qlA,2196
 TB2J/spinham/constants.py,sha256=y4-hRyl5EAR42k24Oa5XhAsUQtKVn1MAgyqNf-p3PrM,762
-TB2J/spinham/h_matrix.py,sha256=MfHIz6RViKkEB3Mu-WcwNx5uk7A5sjAlbqVG9wYA4xk,2784
 TB2J/spinham/hamiltonian.py,sha256=OfsjlGIgFwpXaohopZcgPamSfjm3X46_zc245eyTr_A,16607
 TB2J/spinham/hamiltonian_terms.py,sha256=7e84tfEjvAfZltUkrSWi1sUEiW_itLKy83lxi5iBpcQ,9714
-TB2J/spinham/obtain_J.py,sha256=sg8tiCRRLEN57Olb3MHIuqkDhAkmu-w87AkM00ylXtA,2401
 TB2J/spinham/plot.py,sha256=tLLNqFAATVrP1kmSVLPKzn686i-CUyqu4qgOcs-okHI,6599
 TB2J/spinham/qsolver.py,sha256=Sr9I3aGfVNYn5wzwPx1QonHe6ZZUXBAujWRa7nTA5u4,4986
 TB2J/spinham/spin_api.py,sha256=oN3AKg1WQl0YzR4f5ealcJOaVoAy8d7HodIwrbXvQeY,2219
@@ -76,18 +69,18 @@ TB2J/spinham/supercell.py,sha256=y17uUC6r3gQb278FhxIW4CABihfLTvKFj6flyXrCPR8,122
 TB2J/wannier/__init__.py,sha256=7ojCbM84PYv1X1Tbo4NHI-d3gWmQsZB_xiYqbfxVV1E,80
 TB2J/wannier/w90_parser.py,sha256=dbd63LuKyv2DVUzqRINGsbDzEsOxsQyE8_Ear_LQIRg,4620
 TB2J/wannier/w90_tb_parser.py,sha256=qt8pnuprmPp9iIAYwPkPbmEzk6ZPgMq2xognoQp7vwc,4610
-TB2J-0.9.0.2.data/scripts/TB2J_downfold.py,sha256=i4BVqnpDdgrX_amookVWeLGefGBn-qeAutWiwuY9SfQ,2099
-TB2J-0.9.0.2.data/scripts/TB2J_eigen.py,sha256=Qs9v2hnMm2Tpfoa4h53muUKty2dZjwx8948MBoQooNg,1128
-TB2J-0.9.0.2.data/scripts/TB2J_magnon.py,sha256=q7UwAmorRcFNk4tfE7gl_ny05l6p7pbD9Wm_LkIpKEw,3101
-TB2J-0.9.0.2.data/scripts/TB2J_magnon_dos.py,sha256=TMXQvD2dIbO5FZ4tUMmxJgCgH2O2hDAPUNfEKO4z-x4,110
-TB2J-0.9.0.2.data/scripts/TB2J_merge.py,sha256=y834SF4rIRn1L1ptkhczvavQpC-8Px6DTmDOOSaq_DE,1854
-TB2J-0.9.0.2.data/scripts/TB2J_rotate.py,sha256=zgiDFuYZNmzKK0rwDmTaYD2OpRlmKA_VGeBx83w2Xwc,873
-TB2J-0.9.0.2.data/scripts/TB2J_rotateDM.py,sha256=kCvF7gotuqAX1VnJ06cwfVm7RrhrdtiV5v7d9P2Pn_E,567
-TB2J-0.9.0.2.data/scripts/abacus2J.py,sha256=M4B07lvTCDczTPTqvnDh_PERzCARAd09TLKv4aIdSQM,4408
-TB2J-0.9.0.2.data/scripts/siesta2J.py,sha256=hBzS7ZgoHM3oXlTCQd-xVA07Ks2FiIwyRpQWUFITRPE,4303
-TB2J-0.9.0.2.data/scripts/wann2J.py,sha256=2t2hWwyELskYCwkGDziCgiIAnfr6odLLJ6cQBJ2RQwQ,5714
-TB2J-0.9.0.2.dist-info/LICENSE,sha256=CbZI-jyRTjiqIcWa244cRSHJdjjtUNqGR4HeJkgEwJw,1332
-TB2J-0.9.0.2.dist-info/METADATA,sha256=WhFy-Jej3lhp1tyTWrIr_J4hbutGY_DD1S5zJk1YqYk,1420
-TB2J-0.9.0.2.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-TB2J-0.9.0.2.dist-info/top_level.txt,sha256=whYa5ByLYhl5XnTPBHSWr-IGD6VWmr5Ql2bye2qwV_s,5
-TB2J-0.9.0.2.dist-info/RECORD,,
+TB2J-0.9.0.3.data/scripts/TB2J_downfold.py,sha256=i4BVqnpDdgrX_amookVWeLGefGBn-qeAutWiwuY9SfQ,2099
+TB2J-0.9.0.3.data/scripts/TB2J_eigen.py,sha256=Qs9v2hnMm2Tpfoa4h53muUKty2dZjwx8948MBoQooNg,1128
+TB2J-0.9.0.3.data/scripts/TB2J_magnon.py,sha256=q7UwAmorRcFNk4tfE7gl_ny05l6p7pbD9Wm_LkIpKEw,3101
+TB2J-0.9.0.3.data/scripts/TB2J_magnon_dos.py,sha256=TMXQvD2dIbO5FZ4tUMmxJgCgH2O2hDAPUNfEKO4z-x4,110
+TB2J-0.9.0.3.data/scripts/TB2J_merge.py,sha256=y834SF4rIRn1L1ptkhczvavQpC-8Px6DTmDOOSaq_DE,1854
+TB2J-0.9.0.3.data/scripts/TB2J_rotate.py,sha256=zgiDFuYZNmzKK0rwDmTaYD2OpRlmKA_VGeBx83w2Xwc,873
+TB2J-0.9.0.3.data/scripts/TB2J_rotateDM.py,sha256=kCvF7gotuqAX1VnJ06cwfVm7RrhrdtiV5v7d9P2Pn_E,567
+TB2J-0.9.0.3.data/scripts/abacus2J.py,sha256=M4B07lvTCDczTPTqvnDh_PERzCARAd09TLKv4aIdSQM,4408
+TB2J-0.9.0.3.data/scripts/siesta2J.py,sha256=hBzS7ZgoHM3oXlTCQd-xVA07Ks2FiIwyRpQWUFITRPE,4303
+TB2J-0.9.0.3.data/scripts/wann2J.py,sha256=2t2hWwyELskYCwkGDziCgiIAnfr6odLLJ6cQBJ2RQwQ,5714
+TB2J-0.9.0.3.dist-info/LICENSE,sha256=CbZI-jyRTjiqIcWa244cRSHJdjjtUNqGR4HeJkgEwJw,1332
+TB2J-0.9.0.3.dist-info/METADATA,sha256=Vj1aJnognG0_1yHXRKsFzGEce2uxyCA6xo7t7KCE8jQ,1420
+TB2J-0.9.0.3.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+TB2J-0.9.0.3.dist-info/top_level.txt,sha256=whYa5ByLYhl5XnTPBHSWr-IGD6VWmr5Ql2bye2qwV_s,5
+TB2J-0.9.0.3.dist-info/RECORD,,

TB2J/MAE.py

@@ -1,188 +0,0 @@
-import numpy as np
-from TB2J.abacus.abacus_wrapper import AbacusWrapper, AbacusParser
-from TB2J.mathutils.rotate_spin import rotate_Matrix_from_z_to_axis
-from TB2J.kpoints import monkhorst_pack
-from TB2J.mathutils.fermi import fermi
-from TB2J.mathutils.kR_convert import R_to_k
-from scipy.linalg import eigh
-from copy import deepcopy
-from scipy.spatial.transform import Rotation
-import matplotlib.pyplot as plt
-from pathlib import Path
-from TB2J.mathutils.rotate_spin import spherical_to_cartesian
-from HamiltonIO.model.occupations import Occupations
-#from TB2J.abacus.abacus_wrapper import AbacusSplitSOCParser
-from HamiltonIO.abacus.abacus_wrapper import AbacusSplitSOCParser
-from HamiltonIO.siesta import SislParser, SiestaHamiltonian
-import tqdm
-
-
-def get_occupation(evals, kweights, nel, width=0.1):
-    occ = Occupations(nel=nel, width=width, wk=kweights, nspin=2)
-    return occ.occupy(evals)
-
-
-def get_density_matrix(evals=None, evecs=None, kweights=None, nel=None, width=0.1):
-    occ = get_occupation(evals, kweights, nel, width=width)
-    rho = np.einsum("kib, kb, kjb -> kij", evecs, occ, evecs.conj())
-    return rho
-
-
-class MAE:
-    def __init__(self, model, kmesh, gamma=True, width=0.1, nel=None):
-        self.model = model
-        if nel is not None:
-            self.model.nel = nel
-        self.kpts = monkhorst_pack(kmesh, gamma_center=gamma)
-        self.kweights = np.ones(len(self.kpts), dtype=float) / len(self.kpts)
-        self.width = width
-
-    def get_band_energy(self):
-        evals, evecs = self.model.solve_all(self.kpts)
-        occ = get_occupation(evals, self.kweights, self.model.nel, width=self.width)
-        eband = np.sum(evals * occ * self.kweights[:, np.newaxis])
-        return eband
-
-    def calc_ref(self):
-        # calculate the Hk_ref, Sk_ref, Hk_soc_ref, and rho_ref
-        self.Sk_ref = R_to_k(self.kpts, self.model.Rlist, self.model.SR)
-        self.Hk_xc_ref = R_to_k(self.kpts, self.model.Rlist, self.model._HR_copy)
-        self.Hk_soc_ref = R_to_k(self.kpts, self.model.Rlist, self.model.HR_soc)
-        self.rho_ref = np.zeros(
-            (len(self.kpts), self.model.nbasis, self.model.nbasis), dtype=complex
-        )
-
-        evals = np.zeros((len(self.kpts), self.model.nbasis), dtype=float)
-        evecs = np.zeros(
-            (len(self.kpts), self.model.nbasis, self.model.nbasis), dtype=complex
-        )
-
-        for ik, kpt in enumerate(self.kpts):
-            # evals, evecs = eigh(self.Hk_xc_ref[ik]+self.Hk_soc_ref[ik], self.Sk_ref[ik])
-            evals[ik], evecs[ik] = eigh(self.Hk_xc_ref[ik], self.Sk_ref[ik])
-        occ = get_occupation(
-            evals, self.kweights, self.model.nel, width=self.model.width
-        )
-        # occ = fermi(evals, self.model.efermi, width=self.model.width)
-        self.rho_ref = np.einsum("kib, kb, kjb -> kij", evecs, occ, evecs.conj())
-
-    def get_band_energy_vs_angles(
-        self,
-        thetas,
-        phis,
-    ):
-        es = []
-        # es2 = []
-        # e,rho = self.model.get_band_energy(dm=True)
-        # self.calc_ref()
-        # thetas = np.linspace(*angle_range, npoints)
-        nangles = len(thetas)
-        for i in tqdm.trange(nangles):
-            theta = thetas[i]
-            phi = phis[i]
-            self.model.set_Hsoc_rotation_angle([theta, phi])
-            e = self.get_band_energy()
-            es.append(e)
-            # es2.append(e2)
-        return es
-
-
-def get_model_energy(model, kmesh, gamma=True):
-    ham = MAE(model, kmesh, gamma=gamma)
-    return ham.get_band_energy()
-
-
-def abacus_get_MAE(
-    path_nosoc, path_soc, kmesh, thetas, psis, gamma=True, outfile="MAE.txt", nel=None
-):
-    """Get MAE from Abacus with magnetic force theorem. Two calculations are needed. First we do an calculation with SOC but the soc_lambda is set to 0. Save the density. The next calculatin we start with the density from the first calculation and set the SOC prefactor to 1. With the information from the two calcualtions, we can get the band energy with magnetic moments in the direction, specified in two list, thetas, and phis."""
-    parser = AbacusSplitSOCParser(
-        outpath_nosoc=path_nosoc, outpath_soc=path_soc, binary=False
-    )
-    model = parser.parse()
-    ham = MAE(model, kmesh, gamma=gamma)
-    es = ham.get_band_energy_vs_angles(thetas, psis)
-    if outfile:
-        with open(outfile, "w") as f:
-            f.write("#theta, psi, energy\n")
-            for theta, psi, e in zip(thetas, psis, es):
-                f.write(f"{theta:5.3f}, {psi:5.3f}, {e:10.9f}\n")
-    return es
-
-
-def siesta_get_MAE(fdf_fname, kmesh, thetas, phis, gamma=True, outfile="MAE.txt"):
-    """ """
-    model= SislParser(fdf_fname=fdf_fname, read_H_soc=True).get_model()
-    ham = MAE(model, kmesh, gamma=gamma)
-    es = ham.get_band_energy_vs_angles(thetas, phis)
-    if outfile:
-        with open(outfile, "w") as f:
-            f.write("#theta, psi, energy\n")
-            for theta, psi, e in zip(thetas, phis, es):
-                #f.write(f"{theta}, {psi}, {e}\n")
-                f.write(f"{theta:5.3f}, {psi:5.3f}, {e:10.9f}\n")
-    return es
-
-
-def test_AbacusSplitSOCWrapper():
-    # path = Path("~/projects/2D_Fe").expanduser()
-    path = Path("~/projects/TB2Jflows/examples/2D_Fe/Fe_z").expanduser()
-    outpath_nosoc = f"{path}/soc0/OUT.ABACUS"
-    outpath_soc = f"{path}/soc1/OUT.ABACUS"
-    parser = AbacusSplitSOCParser(
-        outpath_nosoc=outpath_nosoc, outpath_soc=outpath_soc, binary=False
-    )
-    model = parser.parse()
-    kmesh = [6, 6, 1]
-
-    r = MAE(model, kmesh, gamma=True)
-    # thetas, es = r.get_band_energy_vs_theta(angle_range=(0, np.pi*2), rotation_axis="z", initial_direction=(1,0,0),  npoints=21)
-    thetas, es, es2 = r.get_band_energy_vs_theta(
-        angle_range=(0, np.pi),
-        rotation_axis="y",
-        initial_direction=(0, 0, 1),
-        npoints=11,
-    )
-    # print the table of thetas and es, es2
-    for theta, e, e2 in zip(thetas, es, es2):
-        print(f"{theta=}, {e=}, {e2=}")
-
-    plt.plot(thetas / np.pi, es - es[0], marker="o")
-    plt.plot(thetas / np.pi, es2 - es2[0], marker=".")
-    plt.savefig("E_along_z_x_z.png")
-    plt.show()
-
-
-def abacus_get_MAE_cli():
-    import argparse
-
-    parser = argparse.ArgumentParser(
-        description="Get MAE from Abacus with magnetic force theorem. Two calculations are needed. First we do an calculation with SOC but the soc_lambda is set to 0. Save the density. The next calculatin we start with the density from the first calculation and set the SOC prefactor to 1. With the information from the two calcualtions, we can get the band energy with magnetic moments in the direction, specified in two list, thetas, and phis. "
-    )
-    parser.add_argument("path_nosoc", type=str, help="Path to the  calculation with ")
-    parser.add_argument("path_soc", type=str, help="Path to the SOC calculation")
-    parser.add_argument("thetas", type=float, nargs="+", help="Thetas")
-    parser.add_argument("psis", type=float, nargs="+", help="Phis")
-    parser.add_argument("kmesh", type=int, nargs=3, help="K-mesh")
-    parser.add_argument(
-        "--gamma", action="store_true", help="Use Gamma centered kpoints"
-    )
-    parser.add_argument(
-        "--outfile",
-        type=str,
-        help="The angles and the energey will be saved in this file.",
-    )
-    args = parser.parse_args()
-    abacus_get_MAE(
-        args.path_nosoc,
-        args.path_soc,
-        args.kmesh,
-        args.thetas,
-        args.psis,
-        gamma=args.gamma,
-        outfile=args.outfile,
-    )
-
-
-if __name__ == "__main__":
-    abacus_get_MAE_cli()

TB2J/cut_cell.py

@@ -1,82 +0,0 @@
-import numpy as np
-from TB2J.supercell import find_primitive_cell, map_to_primitive
-from TB2J.io_exchange.io_exchange import SpinIO, gen_distance_dict
-
-
-def cut_cell(path, output_path, sc_matrix, origin_atom_id, thr=1e-5):
-    """
-    Cut the exchange parameters
-    :param path: the original TB2J_results path
-    :param output_path: the output path.
-    :param sc_matrix: the matrix which maps the primitive cell to supercell.
-    :param origin: the origin of the primitive cell.
-    :param thr: the atoms which the reduced position is within -thr to 1.0+thr are considered as inside the primitive atoms
-    :returns:
-    """
-    sc_matrix = np.asarray(sc_matrix, dtype=int)
-    sc_excparams = SpinIO.load_pickle(path=path, fname='TB2J.pickle')
-    sc_atoms = sc_excparams.atoms
-    uc_atoms, ids = find_primitive_cell(sc_atoms,
-                                        sc_matrix,
-                                        origin_atom_id=origin_atom_id,
-                                        thr=thr,
-                                        perfect=False)
-    uc_charges = sc_excparams.charges[ids]
-    uc_spinat = sc_excparams.spinat[ids]
-    indmap, Rmap = map_to_primitive(sc_atoms, uc_atoms)
-
-    # TODO index_spin: {iatom: ispin}
-
-    # list of iatom for each spin index.
-    uc_index_spin = [sc_excparams.index_spin[i] for i in ids]
-
-    uc_ind_atoms = {}
-    for iatom, ispin in enumerate(uc_index_spin):
-        if ispin >= 0:
-            uc_ind_atoms[ispin] = iatom
-
-    uc_Jdict = {}
-    uc_Rset = set()
-    for key, val in sc_excparams.exchange_Jdict.items():
-        R, ispin, jspin = key
-        iatom = sc_excparams.ind_atoms[ispin]
-        jatom = sc_excparams.ind_atoms[jspin]
-        uc_ispin = uc_index_spin[indmap[iatom]]
-        uc_jspin = uc_index_spin[indmap[jatom]]
-        uc_R = R @ sc_matrix + Rmap[jatom] - Rmap[iatom]
-        uc_R = tuple(uc_R)
-        if iatom in ids:
-            #print(f"{iatom=}, {indmap[iatom]=},{uc_ispin=}, {uc_jspin=}, {uc_R=} ")
-            uc_Jdict[(uc_R, uc_ispin, uc_jspin)] = val
-            uc_Rset.add(uc_R)
-
-    uc_distance_dict = gen_distance_dict(uc_ind_atoms, uc_atoms, list(uc_Rset))
-
-    assert sc_excparams.colinear, "Cut supercell for non-collinear spin is not yet implemented."
-
-    uc_exc = SpinIO(uc_atoms,
-                    spinat=uc_spinat,
-                    charges=uc_charges,
-                    index_spin=uc_index_spin,
-                    colinear=sc_excparams.colinear,
-                    distance_dict=uc_distance_dict,
-                    exchange_Jdict=uc_Jdict,
-                    description="Cutted")
-
-    uc_exc.write_all(output_path)
-
-
-def run_cut_cell(
-    path="TB2J_results",
-    output_path="./TB2J_cutted",
-    sc_matrix=np.array([[1, 1, 0], [-1, 1, 0], [0, 0, 2]]),
-):
-    cut_cell(path,
-             output_path,
-             np.array(sc_matrix),
-             origin_atom_id=0,
-             thr=1e-19)
-
-
-if __name__ == "__main__":
-    run_cut_cell()

TB2J/patch.py

@@ -1,50 +0,0 @@
-import types
-from unittest import mock
-
-class A(object):#but seems to work for old style objects too
-    def funcx(self,x):
-        print("x1=",x)
-        print("called from", self)
-
-    def method(self,x):
-        print("xmethod=",x)
-        print("called from", self)
-
-def patch_me(target):
-    def method(target,x):
-        print("x=",x)
-        print("called from", target)
-        target.method = types.MethodType(method,target)
-
-def method(self,x):
-    print("x=",x)
-    print("called from", self)
-
-@mock.patch("__main__.A")
-def funcx(self,x):
-    print("new x=",x)
-    print("called from", self)
-        
-A.method=method
-#add more if needed
-a = A()
-print(A.__dict__)
-print(a)
-#out: <__main__.A object at 0x2b73ac88bfd0>  
-
-@mock.patch("__main__.a")
-def funcx(self,x):
-    print("x=",x)
-    print("called from", self)
- 
-a.funcx(3)
-patch_me(a)    #patch instance
-a.method=method
-#a.method(5)
-#out: x= 5
-#out: called from <__main__.A object at 0x2b73ac88bfd0>
-patch_me(A)
-
-a.method(6)        #can patch class too
-#out: x= 6
-#out: called from <class '__main__.A'>

TB2J/spinham/h_matrix.py

@@ -1,68 +0,0 @@
-import numpy as np
-import matplotlib.pyplot as plt
-import aiida
-from aiida_tb2j.data import ExchangeData
-
-def plot_dispersion(bands, kpoint_labels, color='blue', title=None):
-
-    fig, axs = plt.subplots(1, 1, constrained_layout=True)
-    fig.set_size_inches(6, 6/1.618)
-
-    '''
-    Plot the bands
-    '''
-    kpoints = np.arange(len(bands))
-    axs.plot(kpoints, bands, color=color, linewidth=1.5)
-
-    '''
-    Plot the symmetry points
-    '''
-    bmin = bands.min(); bmax = bands.max()
-    ymin = bmin - 0.05*np.abs(bmin-bmax); ymax = bmax + 0.05*np.abs(bmax-bmin);
-    axs.set_xticks(kpoint_labels[0], kpoint_labels[1], fontsize=10)
-    axs.vlines(x=kpoint_labels[0], ymin=ymin, ymax=ymax, color='black', linewidth=0.5)
-    axs.set_xlim([0, len(kpoints)])
-    axs.set_ylim([ymin, ymax])
-
-    if title is not None:
-        plt.title(title, fontsize=10)
-
-    plt.show()
-
-
-if __name__ == "__main__":
-    
-    from argparse import ArgumentParser
-
-    parser = ArgumentParser()
-    parser.add_argument('-f', '--pickle_filename', type=str, help="Path of the 'TB2J.pickle' file.", required=True)
-    args = parser.parse_args()
-    
-    '''
-    Right now the implementation depends on AiiDA and so we must create and load an AiiDA profile,
-    even if we do not store any information on a data base.
-    '''
-    aiida.load_profile()
-    '''
-    Create an ExchangeData object with the informations from the TB2J.pickle file
-    '''
-    exchange = ExchangeData.load_tb2j(pickle_file=args.pickle_filename, isotropic=False, pbc=(True, True, True))
-    '''
-    Compute the magnon band structure along a high symmetry path generated with
-    the ASE package. The informations is stored in an AiiDA BandsData object.
-    Here tol is the symmetry tolerance to determine the space group of the system.
-    They are in units of eV
-    '''
-    magnon_data = exchange.get_magnon_bands(npoints=300, tol=1e-1, with_DMI=True, with_Jani=True)
-    magnon_bands = 1000*magnon_data.get_bands() # Convert to meV
-    raw_labels = [(k, '$\Gamma$') if s == 'GAMMA' else (k, s) for k, s in magnon_data.labels]
-    kpoint_labels = list( zip( *raw_labels ) )
-    plot_dispersion(magnon_bands, kpoint_labels, color='blue', title='Magnon Bands')
-    '''
-    We can also obtain the dynamical matrix h instead of the actual magnon bands. The result
-    is stored in a numpy array with shape (number of kpoints, 2*natoms, 2*natoms)
-    '''
-    kpoints = magnon_data.get_kpoints() # The shape of the kpoints must be (nkpoints, 3)
-    h_matrix = 1000*exchange._H_matrix(kpoints, with_DMI=True, with_Jani=True) # Convert to meV
-    h_dispersion = np.linalg.eigvalsh(h_matrix) # We can also get the eigenvectors with np.linalg.eigh
-    plot_dispersion(h_dispersion, kpoint_labels, color='red', title='h matrix dispersion')

TB2J/spinham/obtain_J.py

@@ -1,79 +0,0 @@
-import numpy as np
-from aiida_tb2j.data import ExchangeData
-from aiida_tb2j.data.exchange import get_rotation_arrays
-from itertools import combinations_with_replacement
-
-ux, uy, uz = np.eye(3).reshape((3, 1, 3))
-
-def combine_arrays(u, v):
-
-    return np.concatenate([u*v, np.roll(u, -1, axis=-1)*v, np.roll(v, -1, axis=-1)*u], axis=-1)
-
-def get_coefficients(magmoms, indices):
-
-    i, j = indices
-
-    U, V = zip(*[get_rotation_arrays(magmoms, u=u) for u in [ux, uy, uz]])
-    U = np.stack(U).swapaxes(0, 1)
-    V = np.stack(V).swapaxes(0, 1)
-
-    uc = combine_arrays(U[i], U[j].conj())
-    ur = combine_arrays(U[i], U[j])
-    uc2 = combine_arrays(U[i].conj(), U[j])
-    u = np.concatenate([uc, ur, uc2], axis=1)
-
-    return u, V
-
-def get_C(H0, u, V):
-
-    n = int(H0.shape[-1]/2)
-    upi = np.triu_indices(n)
-    dig = np.diag_indices(n)
-    
-    i, j = upi
-    AB0 = H0[:, [i, i, i+n], [j, j+n, j+n]]
-    AB0 = np.swapaxes(AB0, 0, 2).reshape(len(i), 9)
-    J0_flat = np.linalg.solve(u, AB0)
-
-    J0 = np.empty((n, n, 3, 3), dtype=complex)
-    J0[*upi] = J0_flat[:, [0, 6, 5, 3, 1, 7, 8, 4, 2]].reshape(-1, 3, 3)
-    J0 += J0.swapaxes(0, 1)
-    J0[*dig] = 0.0
-
-    C = np.array([np.diag(a) for a in np.einsum('imx,ijxy,jmy->mi', V, 2*J0, V)]) 
-
-    return C
-
-def get_J(H, kpoints, exchange):
-
-    n = int(H.shape[-1]/2)
-    upi = np.triu_indices(n)
-    dig = np.diag_indices(n)
-    i, j = upi
-
-    magmoms = exchange.magmoms()[np.unique(exchange.pairs)]
-    magmoms /= np.linalg.norm(magmoms, axis=-1).reshape(-1, 1)
-    u, V = get_coefficients(magmoms, indices=upi)
-
-    H0 = np.stack([1000*exchange._H_matrix(kpoints=np.zeros((1, 3)), with_DMI=True, with_Jani=True, u=u) for u in [ux, uy, uz]])[:, 0, :, :]
-    C = get_C(H0, u, V)
-    H[:, :, :n, :n] += C.reshape(3, 1, n, n)
-    H[:, :, n:, n:] += C.reshape(3, 1, n, n)
-
-    AB = H[:, :, [i, i, i+n], [j, j+n, j+n]]
-    AB[:, :, 2, :] = AB[:, ::-1, 2, :]
-    AB = np.moveaxis(AB, [2, 3], [1, 0]).reshape(len(i), 9, -1)
-
-    vectors = exchange.get_vectors()
-    exp_summand = np.exp( -2j*np.pi*vectors @ kpoints.T )
-    nAB = np.einsum('nik,ndk->nid', AB, exp_summand) / len(kpoints)
-    
-    ii = np.where(i == j)
-    i0 = np.where(np.linalg.norm(vectors, axis=-1) == 0.0)
-    J = np.linalg.solve(u, nAB).swapaxes(1, 2)
-    J = J[:, :, [0, 6, 5, 3, 1, 7, 8, 4, 2]].reshape(len(i), -1, 3, 3)
-    J *= -1
-    J[ii] *= 2
-    J[i0] *= 0
-
-    return J

TB2J/supercell.py

@@ -1,532 +0,0 @@
-"""
-A helper class for building supercells
-"""
-import numpy as np
-from collections import OrderedDict, defaultdict
-from itertools import product
-from functools import lru_cache
-from ase.build import make_supercell
-from ase.atoms import Atoms
-
-
-def close_to_int(x, tol=1e-4):
-    return np.allclose(x, np.round(x), atol=tol)
-
-
-class SupercellMaker(object):
-
-    def __init__(self, sc_matrix, center=False):
-        """
-        a helper class for making supercells.
-        sc_matrix, supercell matrix. sc_matrix .dot. unitcell = supercell
-        """
-        sc_matrix = np.array(sc_matrix, dtype=int)
-        if len(sc_matrix.flatten()) == 3:
-            sc_matrix = np.diag(sc_matrix)
-        elif sc_matrix.shape == (3, 3):
-            pass
-        else:
-            raise ValueError('sc_matrix should be 3 or 3*3 matrix')
-        self.sc_matrix = sc_matrix
-        self.center = center
-        if center:
-            self.shift = np.array([0.5, 0.5, 0.5])
-        else:
-            self.shift = np.zeros(3, dtype=float)
-        self.inv_scmat = np.linalg.inv(self.sc_matrix.T)
-        self.build_sc_vec()
-        self.ncell = int(round(abs(np.linalg.det(sc_matrix))))
-
-    def to_red_sc(self, x):
-        return np.dot(self.inv_scmat, x) + self.shift
-
-    def build_sc_vec(self):
-        eps_shift = np.sqrt(
-            2.0) * 1.0E-8  # shift of the grid, so to avoid double counting
-        #max_R = np.max(np.abs(self.sc_matrix)) * 3
-        if self.center:
-            minr = -0.5
-            maxr = 0.5
-        else:
-            minr = 0.0
-            maxr = 1.0
-        sc_vec = []
-        newcell = self.sc_matrix
-        scorners_newcell = np.array([[0., 0., 0.], [0., 0., 1.], [0., 1., 0.],
-                                     [0., 1., 1.], [1., 0., 0.], [1., 0., 1.],
-                                     [1., 1., 0.], [1., 1., 1.]])
-        corners = np.dot(scorners_newcell - self.shift, newcell)
-        scorners = corners
-        #rep = np.ceil(scorners.ptp(axis=0)).astype('int') + 1
-        minrep = np.ceil(np.min(scorners, axis=0)).astype('int')
-        maxrep = np.ceil(np.max(scorners, axis=0)).astype('int') + 1
-
-        # sc_vec: supercell vector (map atom from unit cell to supercell)
-        # for vec in product(range(rep[0]), range(rep[1]), range(rep[2])):
-        for vec in product(range(minrep[0], maxrep[0]),
-                           range(minrep[1], maxrep[1]),
-                           range(minrep[2], maxrep[2])):
-            # compute reduced coordinates of this candidate vector in the super-cell frame
-            tmp_red = self.to_red_sc(vec)
-            # check if in the interior
-            if (not (tmp_red <= -eps_shift).any()) and (
-                    not (tmp_red > 1.0 - eps_shift).any()):
-                sc_vec.append(np.array(vec))
-
-        # number of times unit cell is repeated in the super-cell
-        num_sc = len(sc_vec)
-
-        # check that found enough super-cell vectors
-        if int(round(np.abs(np.linalg.det(self.sc_matrix)))) != num_sc:
-            raise Exception(
-                "\n\nSuper-cell generation failed! Wrong number of super-cell vectors found."
-            )
-
-        sc_vec = np.array(sc_vec)
-        self.sc_vec = np.array(sc_vec)
-        svtuple = (tuple(s) for s in sc_vec)
-        self.sc_vec_dict = dict(zip(svtuple, range(sc_vec.shape[0])))
-
-    def get_R(self):
-        return self.sc_vec
-
-    @property
-    def R_sc(self):
-        return self.sc_vec
-
-    def sc_cell(self, cell):
-        cell = np.array(cell)
-        if len(cell.flatten()) == 3:
-            cell = np.diag(cell)
-        return np.dot(self.sc_matrix, cell)
-
-    def sc_pos(self, positions, return_R=False):
-        """
-        pos -> pos in supercell (reduced.)
-        """
-        sc_pos = []
-        sc_R = []
-        for cur_sc_vec in self.sc_vec:  # go over all super-cell vectors
-            for pos in positions:
-                # shift orbital and compute coordinates in
-                # reduced coordinates of super-cell
-                sc_pos.append(self.to_red_sc(pos + cur_sc_vec))
-                sc_R.append(cur_sc_vec)
-        if return_R:
-            return sc_pos, sc_R
-        else:
-            return sc_pos
-
-    def sc_trans_invariant(self, q, return_R=False):
-        """
-        translation invariant quantities. Like on-site energy of tight binding,
-        chemical symbols, magnetic moments of spin.
-        """
-        sc_q = []
-        sc_R = []  # supercell R
-        for cur_sc_vec in self.sc_vec:  # go over all super-cell vectors
-            for qitem in q:
-                sc_q.append(qitem)
-                sc_R.append(cur_sc_vec)
-        if return_R:
-            return sc_q, sc_R
-        else:
-            return sc_q
-
-    def sc_trans_kvector(self, x, kpt, phase=0.0, real=False):
-        """
-        x is a vector of quantities inside the primitive cell. 
-        qpoint is the wavevector
-        phase
-        x_sc= x * exp(i(qR + phase))
-
-        Note: if x is a 2D m*n array, the first m*n block is the primitive cell.
-        [block1, block2, block3, ... block_ncell]
-        """
-        factor = self.phase_factor(kpt, phase=phase)
-        ret = np.kron(factor, x)
-        if real:
-            ret = np.real(ret)
-        return ret
-
-    def Rvector_for_each_element(self, n_ind=1):
-        """
-        repeat the R_sc vectors.
-        """
-        return np.kron(self.sc_vec, np.ones((n_ind, 1)))
-
-    def sc_index(self, indices, n_ind=None):
-        """
-        Note that the number of indices could be inequal to the repeat period.
-        e.g. for n_orb of orbitals, the indices of atoms iatom for each orbital.
-        In that case, in the second unit cell (c=1 here), iatom-> iatom+n_ind,
-        where n_ind=natoms in primitive cell.
-        """
-        sc_ind = []
-        if n_ind is None:
-            n_ind = len(indices)
-        for c, cur_sc_vec in enumerate(
-                self.sc_vec):  # go over all super-cell vectors
-            for ind in indices:
-                sc_ind.append(ind + c * n_ind)
-        return sc_ind
-
-    @lru_cache(maxsize=5000)
-    def _sc_R_to_pair_ind(self, R_plus_Rv):
-        """
-        R: initial R vector (e.g. R in (i, jR) pair)
-        Rv: translation vector. (e.g. for Rv in self.sc_vec)
-
-        Returns:
-        sc_part: R in
-        pair_ind:
-        """
-        R_plus_Rv = np.asarray(R_plus_Rv)
-        sc_part = np.floor(self.to_red_sc(R_plus_Rv))  # round down!
-        sc_part = np.array(sc_part, dtype=int)
-        # find remaining vector in the original reduced coordinates
-        orig_part = R_plus_Rv - np.dot(sc_part, self.sc_matrix)
-        pair_ind1 = self.sc_vec_dict[tuple(orig_part)]
-        return sc_part, pair_ind1
-
-    def sc_jR_to_scjR(self, j, R, Rv, n_basis):
-        """
-        (j, R) in primitive cell to (j', R') in supercell.
-        """
-        Rprim, pair_ind = self._sc_R_to_pair_ind(
-            tuple(np.array(R) + np.array(Rv)))
-        return j + pair_ind * n_basis, tuple(Rprim)
-
-    def sc_i_to_sci(self, i, ind_Rv, n_basis):
-        return i + ind_Rv * n_basis
-
-    def sc_ijR_only(self, i, j, R, n_basis):
-        ret = []
-        for c, cur_sc_vec in enumerate(
-                self.sc_vec):  # go over all super-cell vectors
-            sc_part, pair_ind = self._sc_R_to_pair_ind(tuple(R + cur_sc_vec))
-            sc_i = i + c * n_basis
-            sc_j = j + pair_ind * n_basis
-            ret.append((sc_i, sc_j, tuple(sc_part)))
-        return ret
-
-    def sc_jR(self, jlist, Rjlist, n_basis):
-        sc_jlist = []
-        sc_Rjlist = []
-        for c, cur_sc_vec in enumerate(
-                self.sc_vec):  # go over all super-cell vectors
-            # for i , j, ind_R, val in
-            for j, Rj in zip(jlist, Rjlist):
-                sc_part, pair_ind = self._sc_R_to_pair_ind(
-                    tuple(Rj + cur_sc_vec))
-                sc_j = j + pair_ind * n_basis
-                sc_jlist.append(sc_j)
-                sc_Rjlist.append(tuple(sc_part))
-        return sc_jlist, sc_Rjlist
-
-    def sc_ijR(self, terms, n_basis):
-        """
-        # TODO very slow when supercell is large, should improve it.
-        map Val(i, j, R) which is a funciton of (R+rj-ri) to supercell.
-        e.g. hopping in Tight binding. exchange in heisenberg model,...
-        Args:
-        ========================
-        terms: either list of [i, j, R, val] or  dict{(i,j, R): val}
-        pos: reduced positions in the unit cell.
-        Returns:
-        =======================
-        """
-        ret_dict = OrderedDict()
-        for c, cur_sc_vec in enumerate(
-                self.sc_vec):  # go over all super-cell vectors
-            # for i , j, ind_R, val in
-            for (i, j, ind_R), val in terms.items():
-                sc_part, pair_ind = self._sc_R_to_pair_ind(
-                    tuple(ind_R + cur_sc_vec))
-                # index of "from" and "to" hopping indices
-                sc_i = i + c * n_basis
-                sc_j = j + pair_ind * n_basis
-
-                # hi = self._hoppings[h][1] + c * self._norb
-                # hj = self._hoppings[h][2] + pair_ind * self._norb
-                ret_dict[(sc_i, sc_j, tuple(sc_part))] = val
-        return ret_dict
-
-    def sc_Rlist_HR(self, Rlist, HR, n_basis):
-        """
-        terms: H[R][i,j] = val
-        ========================
-        terms: either list of [i, j, R, val] or  dict{(i,j, R): val}
-        pos: reduced positions in the unit cell.
-        Returns:
-        =======================
-        """
-        sc_Rlist = []
-        sc_HR = []
-        for c, cur_sc_vec in enumerate(
-                self.sc_vec):  # go over all super-cell vectors
-            # for i , j, ind_R, val in
-            for iR, R in enumerate(Rlist):
-                H = HR[iR]
-                sc_part, pair_ind = self._sc_R_to_pair_ind(
-                    tuple(R + cur_sc_vec))
-                sc_Rlist.append(sc_part)
-                sc_val = np.zeros((n_basis * self.ncell, n_basis * self.ncell),
-                                  dtype=HR.dtype)
-                for i in range(n_basis):
-                    for j in range(n_basis):
-                        sc_i = i + c * n_basis
-                        sc_j = j + pair_ind * n_basis
-                        sc_val[sc_i, sc_j] = H[i, j]
-                sc_HR.append(sc_val)
-        return np.array(sc_Rlist, dtype=int), np.array(sc_HR)
-
-    def sc_RHdict(self, RHdict, n_basis):
-        """
-        terms: H[R][i,j] = val
-        ========================
-        terms: either list of [i, j, R, val] or  dict{(i,j, R): val}
-        pos: reduced positions in the unit cell.
-        Returns:
-        =======================
-        """
-        sc_RHdict = defaultdict(lambda: np.zeros(
-            (n_basis * self.ncell, n_basis * self.ncell), dtype=H.dtype))
-        for c, cur_sc_vec in enumerate(
-                self.sc_vec):  # go over all super-cell vectors
-            for R, H in RHdict.items():
-                sc_part, pair_ind = self._sc_R_to_pair_ind(
-                    tuple(R + cur_sc_vec))
-                ii = c * n_basis
-                jj = pair_ind * n_basis
-                sc_RHdict[tuple(sc_part)][ii:ii + n_basis,
-                                          jj:jj + n_basis] += H
-        return sc_RHdict
-
-    def sc_RHdict_notrans(self, RHdict, n_basis, Rshift=(0, 0, 0)):
-        sc_RHdict = defaultdict(lambda: np.zeros(
-            (n_basis * self.ncell, n_basis * self.ncell), dtype=H.dtype))
-        cur_sc_vec = np.array(Rshift)
-        for R, H in RHdict.items():
-            sc_part, pair_ind = self._sc_R_to_pair_ind(
-                tuple(np.array(R) + cur_sc_vec))
-            c = self.sc_vec_dict[Rshift]
-            ii = c * n_basis
-            jj = pair_ind * n_basis
-            sc_RHdict[tuple(sc_part)][ii:ii + n_basis, jj:jj + n_basis] += H
-        return sc_RHdict
-
-    def sc_H_RpRk_notrans(self, Rplist, Rklist, n_basis, Rpprime, H):
-        """
-        For a given perturbation at Rp',
-        <Rm|Rp'=Rp+Rm|Rk+Rm>
-        =H(Rp,Rk)=<0|Rp|Rk> is a matrix of nbasis*nbasis
-        First: Rm = Rp'-Rp, Rk+Rm = Rp'-Rp+Rm
-        Input: Rplist, Rklist, H
-        H: [iRg, iRk, ibasis, ibasis]
-        """
-        sc_RHdict = defaultdict(lambda: np.zeros(
-            (n_basis * self.ncell, n_basis * self.ncell), dtype=H.dtype))
-        for iRp, Rp in enumerate(Rplist):
-            Rm = np.array(Rpprime) - np.array(Rp)
-
-            sc_part_i, pair_ind_i = self._sc_R_to_pair_ind(tuple(np.array(Rm)))
-            ii = pair_ind_i * n_basis
-            if tuple(sc_part_i) == (0, 0, 0):
-                for iRk, Rk in enumerate(Rklist):
-                    sc_part_j, pair_ind_j = self._sc_R_to_pair_ind(
-                        tuple(np.array(Rk) + np.array(Rm)))
-                    jj = pair_ind_j * n_basis
-                    sc_RHdict[tuple(sc_part_j)][ii:ii + n_basis, jj:jj +
-                                                n_basis] += H[iRp, iRk, :, :]
-                # elif tuple(sc_part_j) == (0, 0, 0):
-                #    sc_RHdict[tuple(-sc_part_j)][jj:jj + n_basis,
-                #                                 ii:ii + n_basis] += H[iRp, iRk, :, :].T.conj()
-
-        return sc_RHdict
-
-    def sc_atoms(self, atoms):
-        """
-        This function is compatible with ase.build.make_supercell.
-        They should produce the same result.
-        """
-        sc_cell = self.sc_cell(atoms.get_cell())
-        sc_pos = self.sc_pos(atoms.get_scaled_positions())
-        sc_numbers = self.sc_trans_invariant(atoms.get_atomic_numbers())
-        sc_magmoms = self.sc_trans_invariant(
-            atoms.get_initial_magnetic_moments())
-        return Atoms(cell=sc_cell,
-                     scaled_positions=sc_pos,
-                     numbers=sc_numbers,
-                     magmoms=sc_magmoms)
-
-    def phase_factor(self, qpoint, phase=0, real=True):
-        f = np.exp(2j * np.pi * np.einsum('i, ji -> j', qpoint, self.sc_vec) +
-                   1j * phase)
-        if real:
-            f = np.real(f)
-        return f
-
-    def modulation_function_R(self, func):
-        return [func(R) for R in self.R_sc]
-
-    def _make_translate_maps(positions, basis, sc_mat, tol_r=1e-4):
-        """
-        find the mapping between supercell and translated cell.
-        Returns:
-        ===============
-        A N * nbasis array.
-        index[i] is the mapping from supercell to translated supercell so that
-        T(r_i) psi = psi[indices[i]].
-
-        """
-        a1 = Atoms(symbols='H', positions=[(0, 0, 0)], cell=[1, 1, 1])
-        sc = make_supercell(a1, self._scmat)
-        rs = sc.get_scaled_positions()
-
-        indices = np.zeros([len(rs), len(positions)], dtype='int32')
-        for i, ri in enumerate(rs):
-            inds = []
-            Tpositions = positions + np.array(ri)
-            for i_basis, pos in enumerate(positions):
-                for j_basis, Tpos in enumerate(Tpositions):
-                    dpos = Tpos - pos
-                    if close_to_int(dpos, tol_r) and (self._basis[i_basis]
-                                                      == self._basis[j_basis]):
-                        indices[i, j_basis] = i_basis
-
-        self._trans_rs = rs
-        self._trans_indices = indices
-
-
-def smod(x):
-    x = np.mod(x, 1)
-    return x if x < 0.5 else x - 1
-
-
-smod = np.vectorize(smod)
-
-
-def map_to_primitive(atoms, primitive_atoms, offset=(0, 0, 0)):
-    """
-    Find the mapping of a supercell to a primitive cell.
-    :param atoms: the positions of atoms
-    :param primitive_atoms: 
-    :param offset: 
-    :param 0: 
-    :param 0): 
-
-    """
-    ilist = []
-    Rlist = []
-    offset = np.array(offset, dtype=float)
-    ppos = primitive_atoms.get_positions()
-    pos = atoms.get_positions()
-    cell = primitive_atoms.get_cell()
-    for p in pos:
-        found = False
-        for i, pp in enumerate(ppos):
-            res0 = np.linalg.solve(cell.T, p - pp)
-            res = smod(res0)
-            if np.linalg.norm(res) < 0.01:
-                found = True
-                R = res0 - res
-                ilist.append(i)
-                Rlist.append(R)
-                break
-        if not found:
-            print("Not found")
-            ilist.append(-1)
-            Rlist.append([-999, -999, -999])
-    return np.array(ilist, dtype=int), np.array(Rlist, dtype=int)
-
-
-def find_primitive_cell(atoms,
-                        sc_matrix,
-                        origin_atom_id=None,
-                        thr=1e-5,
-                        perfect=True):
-    """
-    Find a primitive cell atoms from the supercell atom structure.
-    :param atoms: the supercell structure.
-    :param sc_matrix: the matrix which maps the primitive cell to supercell.
-    :param origin: the origin of the primitive cell.
-    :param thr: the atoms which the reduced position is within -thr to 1.0+thr are considered as inside the primitive atoms
-    :params perfect: True|False, whether the primitive cell should contains the same number of atoms .
-    :returns: (patoms, selected)
-    patoms: the primitive cell atoms
-    selected: the selected indices of the atoms in the supercell.
-    """
-    scell = atoms.get_cell().array
-    inv_scmat = np.linalg.inv(sc_matrix)
-    pcell = scell@inv_scmat
-    print(f"{inv_scmat=}")
-
-    xcart = atoms.get_positions()
-    xred = atoms.get_scaled_positions()
-    print(xred)
-    if origin_atom_id is not None:
-        origin = xred[origin_atom_id]
-    else:
-        origin = np.zeros(3)
-    # check if some atom is exactly at the origin.
-    # if so, shift the positions by thr so that this atom is inside the cell
-    # if np.any(np.linalg.norm(xred - origin[None, :], axis=1) < thr):
-    #    xred += thr
-    #xred += 0.05
-
-    sc_xred = xred@sc_matrix
-    print(sc_xred)
-    #np.all(sc_xred<1 and sc_xred>=0.0)
-    # print(sc_xred<1)
-    x = np.logical_and(sc_xred < 1+thr, sc_xred >= -thr)
-    print(np.all(x, axis=1))
-    selected = np.where(np.all(x, axis=1))[0]
-    print(selected)
-    symbols = atoms.get_chemical_symbols()
-    psymbols = [symbols[i] for i in selected]
-    patoms = Atoms(symbols=psymbols, positions=xcart[selected], cell=pcell)
-    ncell = abs(np.linalg.det(sc_matrix))
-    natom = len(atoms)
-    if perfect:
-        assert len(symbols) == int(
-            natom/ncell), "The number of atoms in the found primitive cell does not equal to natom in the supercell divided by the size of the cell"
-    return patoms, selected
-
-
-def test_find_primitive_cell():
-    atoms = Atoms('HO', positions=[[0, 0, 0], [0, 0.2, 0]], cell=[1, 1, 1])
-    sc_matrix = np.diag([1, 1, 3])
-    atoms2 = make_supercell(atoms, sc_matrix)
-    patoms = find_primitive_cell(atoms2, sc_matrix)
-
-
-def test():
-    sc_mat = np.diag([1, 1, 3])
-    #sc_mat[0, 1] = 2
-    spm = SupercellMaker(sc_matrix=sc_mat, center=False)
-    print("sc_vec", spm.sc_vec)
-    print(spm.sc_cell([1, 1, 1]))
-    print(spm.sc_pos([[0.5, 1, 1]]))
-    print(spm.sc_pos([[0.5, 1, 0.5]]))
-    print(spm.sc_trans_invariant(['Fe']))
-    print(spm.sc_ijR({
-        (0, 0, (0, 0, 1)): 1.2,
-        (1, 1, (0, 0, 1)): 1.2,
-    }, 2))
-    print(spm.sc_index(indices=(1, 2)))
-    print(spm.sc_index(indices=(1, 2), n_ind=4))
-    from ase.atoms import Atoms
-    atoms = Atoms('HO', positions=[[0, 0, 0], [0, 0.2, 0]], cell=[1, 1, 1])
-    from ase.build import make_supercell
-    atoms2 = make_supercell(atoms, sc_mat)
-    atoms3 = spm.sc_atoms(atoms)
-    # print(atoms2.get_positions())
-    # print(atoms3.get_positions())
-    assert (atoms2 == atoms3)
-    assert (atoms2.get_positions() == atoms3.get_positions()).all()
-
-
-if __name__ == '__main__':
-    # test()
-    test_find_primitive_cell()