TB2J 0.9.0__py3-none-any.whl → 0.9.0.1__py3-none-any.whl

TB2J/__init__.py

@@ -1 +1 @@
-__version__ = "0.9.0"
+__version__ = "0.9.0.1"

TB2J/exchange.py

@@ -345,7 +345,7 @@ class ExchangeNCL(Exchange):
         self.norb = self.G.norb
         self.nbasis = self.G.nbasis
         # self.rho = np.zeros((self.nbasis, self.nbasis), dtype=complex)
-        self.rho = self.G.get_density_matrix().real
+        self.rho = self.G.get_density_matrix()
         self.A_ijR_list = defaultdict(lambda: [])
         self.A_ijR = defaultdict(lambda: np.zeros((4, 4), dtype=complex))
         self.A_ijR_orb = dict()

{TB2J-0.9.0.dist-info → TB2J-0.9.0.1.dist-info}/METADATA

@@ -1,12 +1,10 @@
 Metadata-Version: 2.1
 Name: TB2J
-Version: 0.9.0
+Version: 0.9.0.1
 Summary: TB2J: First principle to Heisenberg exchange J using tight-binding Green function method
-Home-page: UNKNOWN
 Author: Xu He
 Author-email: mailhexu@gmail.com
 License: BSD-2-clause
-Platform: UNKNOWN
 Classifier: Development Status :: 3 - Alpha
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: OS Independent
@@ -16,14 +14,13 @@ Classifier: Topic :: Scientific/Engineering :: Physics
 Classifier: License :: OSI Approved :: BSD License
 Requires-Python: >=3.6
 License-File: LICENSE
-Requires-Dist: ase (>=3.19)
+Requires-Dist: numpy >1.16.5
+Requires-Dist: scipy
 Requires-Dist: matplotlib
-Requires-Dist: numpy (>1.16.5)
-Requires-Dist: packaging (>=20.0)
+Requires-Dist: ase >=3.19
+Requires-Dist: tqdm
 Requires-Dist: pathos
+Requires-Dist: packaging >=20.0
 Requires-Dist: pre-commit
-Requires-Dist: scipy
-Requires-Dist: tqdm
 
 TB2J is a Python package aimed to compute automatically the magnetic interactions (superexchange  and Dzyaloshinskii-Moriya) between atoms of magnetic crystals from DFT Hamiltonian based on Wannier functions or Linear combination of atomic orbitals. It uses the Green's function method and take the local rigid spin rotation as a perturbation. The package can take the output from Wannier90, which is interfaced with many density functional theory codes or from codes based on localised orbitals. A minimal user input is needed, which allows for an easily integration into a high-throughput workflows. 
-

{TB2J-0.9.0.dist-info → TB2J-0.9.0.1.dist-info}/RECORD

@@ -2,14 +2,13 @@ TB2J/Jdownfolder.py,sha256=Nw2ixvn2Uq-o1wficz6rdaYHjfRN3U_kQCvrNJGNb68,6980
 TB2J/Jtensor.py,sha256=0fhfOcfVQGu75gytEnApKWTJZfg9ksKJ0anJgco5wRQ,3179
 TB2J/Oiju.py,sha256=cNGv8N5uH_swGq7cnAt2OyiDfqtjLlLrwseGu0E4iaM,3383
 TB2J/Oiju_epc.py,sha256=oytM3NYW7nWmklrGgNlqwIpI_JYv_hb7ZnR4o9nYNog,6809
-TB2J/__init__.py,sha256=H9NWRZb7NbeRRPLP_V1fARmLNXranorVM-OOY-8_2ug,22
+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=Xg2fuUZbj-Icpqc65Ictllxvdvct8Ec4KQPAmEyo0oM,29586
+TB2J/exchange.py,sha256=dsXQhlxXaBurxa7z3YkBjqmEFFtfEy1xaHf0VT3eKZE,29581
 TB2J/exchangeCL2.py,sha256=TIr-d2X56AiGe4qEhyXyZhRuwXvQG6clJMwDmjnTOaE,10985
 TB2J/exchange_pert.py,sha256=jmFMtQbYa_uczM4VAeS6TijkIHRFIqEzZJswzE9Wfuo,8523
 TB2J/exchange_qspace.py,sha256=ZL68qBGFUaQ9BsSPsJaaoWOr9RssPiqX34R_9I3nk_8,8436
@@ -28,7 +27,6 @@ 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=_ARYKAeWfP1p5w0mEl-d7KwNfXoqC85TveYl0iCBD3c,9880
@@ -46,7 +44,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
@@ -54,10 +51,8 @@ TB2J/io_exchange/io_vampire.py,sha256=UllC4twf06_q2vBCnAYFzEDGvS8mSefwQXDquBuyc0
 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
@@ -66,18 +61,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.data/scripts/TB2J_downfold.py,sha256=F9oImXFysejCMP7eIBjbCX2jdHFOCvDW5beF1sG-UM8,1854
-TB2J-0.9.0.data/scripts/TB2J_eigen.py,sha256=Qs9v2hnMm2Tpfoa4h53muUKty2dZjwx8948MBoQooNg,1128
-TB2J-0.9.0.data/scripts/TB2J_magnon.py,sha256=q7UwAmorRcFNk4tfE7gl_ny05l6p7pbD9Wm_LkIpKEw,3101
-TB2J-0.9.0.data/scripts/TB2J_magnon_dos.py,sha256=TMXQvD2dIbO5FZ4tUMmxJgCgH2O2hDAPUNfEKO4z-x4,110
-TB2J-0.9.0.data/scripts/TB2J_merge.py,sha256=y834SF4rIRn1L1ptkhczvavQpC-8Px6DTmDOOSaq_DE,1854
-TB2J-0.9.0.data/scripts/TB2J_rotate.py,sha256=zgiDFuYZNmzKK0rwDmTaYD2OpRlmKA_VGeBx83w2Xwc,873
-TB2J-0.9.0.data/scripts/TB2J_rotateDM.py,sha256=kCvF7gotuqAX1VnJ06cwfVm7RrhrdtiV5v7d9P2Pn_E,567
-TB2J-0.9.0.data/scripts/abacus2J.py,sha256=M4B07lvTCDczTPTqvnDh_PERzCARAd09TLKv4aIdSQM,4408
-TB2J-0.9.0.data/scripts/siesta2J.py,sha256=hBzS7ZgoHM3oXlTCQd-xVA07Ks2FiIwyRpQWUFITRPE,4303
-TB2J-0.9.0.data/scripts/wann2J.py,sha256=2t2hWwyELskYCwkGDziCgiIAnfr6odLLJ6cQBJ2RQwQ,5714
-TB2J-0.9.0.dist-info/LICENSE,sha256=CbZI-jyRTjiqIcWa244cRSHJdjjtUNqGR4HeJkgEwJw,1332
-TB2J-0.9.0.dist-info/METADATA,sha256=4ooTIlcMyCl-axTuL5PI9qfK4i7k5zFEoHFl-CiYXOc,1462
-TB2J-0.9.0.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
-TB2J-0.9.0.dist-info/top_level.txt,sha256=whYa5ByLYhl5XnTPBHSWr-IGD6VWmr5Ql2bye2qwV_s,5
-TB2J-0.9.0.dist-info/RECORD,,
+TB2J-0.9.0.1.data/scripts/TB2J_downfold.py,sha256=F9oImXFysejCMP7eIBjbCX2jdHFOCvDW5beF1sG-UM8,1854
+TB2J-0.9.0.1.data/scripts/TB2J_eigen.py,sha256=Qs9v2hnMm2Tpfoa4h53muUKty2dZjwx8948MBoQooNg,1128
+TB2J-0.9.0.1.data/scripts/TB2J_magnon.py,sha256=q7UwAmorRcFNk4tfE7gl_ny05l6p7pbD9Wm_LkIpKEw,3101
+TB2J-0.9.0.1.data/scripts/TB2J_magnon_dos.py,sha256=TMXQvD2dIbO5FZ4tUMmxJgCgH2O2hDAPUNfEKO4z-x4,110
+TB2J-0.9.0.1.data/scripts/TB2J_merge.py,sha256=y834SF4rIRn1L1ptkhczvavQpC-8Px6DTmDOOSaq_DE,1854
+TB2J-0.9.0.1.data/scripts/TB2J_rotate.py,sha256=zgiDFuYZNmzKK0rwDmTaYD2OpRlmKA_VGeBx83w2Xwc,873
+TB2J-0.9.0.1.data/scripts/TB2J_rotateDM.py,sha256=kCvF7gotuqAX1VnJ06cwfVm7RrhrdtiV5v7d9P2Pn_E,567
+TB2J-0.9.0.1.data/scripts/abacus2J.py,sha256=M4B07lvTCDczTPTqvnDh_PERzCARAd09TLKv4aIdSQM,4408
+TB2J-0.9.0.1.data/scripts/siesta2J.py,sha256=hBzS7ZgoHM3oXlTCQd-xVA07Ks2FiIwyRpQWUFITRPE,4303
+TB2J-0.9.0.1.data/scripts/wann2J.py,sha256=2t2hWwyELskYCwkGDziCgiIAnfr6odLLJ6cQBJ2RQwQ,5714
+TB2J-0.9.0.1.dist-info/LICENSE,sha256=CbZI-jyRTjiqIcWa244cRSHJdjjtUNqGR4HeJkgEwJw,1332
+TB2J-0.9.0.1.dist-info/METADATA,sha256=ky_ng24tVY8IC_GQn9420M7jzPnCpUiNcp-QtFkUbsk,1420
+TB2J-0.9.0.1.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+TB2J-0.9.0.1.dist-info/top_level.txt,sha256=whYa5ByLYhl5XnTPBHSWr-IGD6VWmr5Ql2bye2qwV_s,5
+TB2J-0.9.0.1.dist-info/RECORD,,

{TB2J-0.9.0.dist-info → TB2J-0.9.0.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.37.1)
+Generator: bdist_wheel (0.42.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

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