TB2J 0.9.5rc0__py3-none-any.whl → 0.9.7rc0__py3-none-any.whl

TB2J/green.py

@@ -1,14 +1,19 @@
-import numpy as np
-from collections import defaultdict
-from ase.dft.kpoints import monkhorst_pack
-from shutil import rmtree
+import copy
 import os
+import pickle
+import sys
 import tempfile
+from collections import defaultdict
+from shutil import rmtree
+
+import numpy as np
+from HamiltonIO.model.occupations import Occupations
+from HamiltonIO.model.occupations import myfermi as fermi
 from pathos.multiprocessing import ProcessPool
-import sys
-import pickle
-import warnings
-from TB2J.mathutils.fermi import fermi
+
+from TB2J.kpoints import monkhorst_pack
+
+# from TB2J.mathutils.fermi import fermi
 
 MAX_EXP_ARGUMENT = np.log(sys.float_info.max)
 
@@ -22,9 +27,16 @@ def eigen_to_G(evals, evecs, efermi, energy):
     :returns: Green's function G,
     :rtype:  Matrix with same shape of the Hamiltonian (and eigenvector)
     """
-    return (
-        np.einsum("ij, j-> ij", evecs, 1.0 / (-evals + (energy + efermi)))
-        @ evecs.conj().T
+    # return (
+    #    np.einsum("ij, j-> ij", evecs, 1.0 / (-evals + (energy + efermi)))
+    #    @ evecs.conj().T
+    # )
+    return np.einsum(
+        "ib, b, jb-> ij",
+        evecs,
+        1.0 / (-evals + (energy + efermi)),
+        evecs.conj(),
+        optimize=True,
     )
 
 
@@ -46,8 +58,10 @@ class TBGreen:
     def __init__(
         self,
         tbmodel,
-        kmesh,  # [ikpt, 3]
-        efermi,  # efermi
+        kmesh=None,  # [ikpt, 3]
+        efermi=None,  # efermi
+        gamma=False,
+        kpts=None,
         k_sym=False,
         use_cache=False,
         cache_path=None,
@@ -67,12 +81,14 @@ class TBGreen:
         self.cache_path = cache_path
         if use_cache:
             self._prepare_cache()
-        if kmesh is not None:
-            self.kpts = monkhorst_pack(size=kmesh)
+        if kpts is not None:
+            self.kpts = kpts
+        elif kmesh is not None:
+            self.kpts = monkhorst_pack(kmesh, gamma_center=gamma)
         else:
             self.kpts = tbmodel.get_kpts()
         self.nkpts = len(self.kpts)
-        self.kweights = [1.0 / self.nkpts] * self.nkpts
+        self.kweights = np.array([1.0 / self.nkpts] * self.nkpts)
         self.norb = tbmodel.norb
         self.nbasis = tbmodel.nbasis
         self.k_sym = k_sym
@@ -145,9 +161,19 @@ class TBGreen:
         if not saveH:
             self.H = None
 
-        self.evals, self.evecs = self._reduce_eigens(
-            self.evals, self.evecs, emin=self.efermi - 10.0, emax=self.efermi + 10.1
-        )
+        # get efermi
+        if self.efermi is None:
+            print("Calculating Fermi energy from eigenvalues")
+            print(f"Number of electrons: {self.tbmodel.nel} ")
+            occ = Occupations(
+                nel=self.tbmodel.nel, width=0.1, wk=self.kweights, nspin=2
+            )
+            self.efermi = occ.efermi(copy.deepcopy(self.evals))
+            print(f"Fermi energy found: {self.efermi}")
+
+        # self.evals, self.evecs = self._reduce_eigens(
+        #    self.evals, self.evecs, emin=self.efermi - 15.0, emax=self.efermi + 10.1
+        # )
         if self._use_cache:
             evecs = self.evecs
             self.evecs_shape = self.evecs.shape
@@ -216,20 +242,22 @@ class TBGreen:
         rho = np.zeros((self.nbasis, self.nbasis), dtype=complex)
         if self.is_orthogonal:
             for ik, _ in enumerate(self.kpts):
+                evecs_k = self.get_evecs(ik)
+                # chekc if any of the evecs element is nan
                 rho += (
-                    (self.get_evecs(ik) * fermi(self.evals[ik], self.efermi))
-                    @ self.get_evecs(ik).T.conj()
+                    (evecs_k * fermi(self.evals[ik], self.efermi, nspin=2))
+                    @ evecs_k.T.conj()
                     * self.kweights[ik]
                 )
         else:
             for ik, _ in enumerate(self.kpts):
                 rho += (
-                    (self.get_evecs(ik) * fermi(self.evals[ik], self.efermi))
+                    (self.get_evecs(ik) * fermi(self.evals[ik], self.efermi, nspin=2))
                     @ self.get_evecs(ik).T.conj()
                     @ self.get_Sk(ik)
                     * self.kweights[ik]
                 )
-
+        # check if rho has nan values
         return rho
 
     def get_rho_R(self, Rlist):
@@ -238,7 +266,10 @@ class TBGreen:
         for ik, kpt in enumerate(self.kpts):
             evec = self.get_evecs(ik)
             rhok = np.einsum(
-                "ib,b, bj-> ij", evec, fermi(self.evals[ik], self.efermi), evec.conj().T
+                "ib,b, bj-> ij",
+                evec,
+                fermi(self.evals[ik], self.efermi, nspin=2),
+                evec.conj().T,
             )
             for iR, R in enumerate(Rlist):
                 rho_R[iR] += rhok * np.exp(self.k2Rfactor * kpt @ R) * self.kweights[ik]
@@ -252,16 +283,20 @@ class TBGreen:
     def get_density(self):
         return np.real(np.diag(self.get_density_matrix()))
 
-    def get_Gk(self, ik, energy):
+    def get_Gk(self, ik, energy, evals=None, evecs=None):
         """Green's function G(k) for one energy
         G(\epsilon)= (\epsilon I- H)^{-1}
         :param ik: indices for kpoint
         :returns: Gk
         :rtype:  a matrix of indices (nbasis, nbasis)
         """
+        if evals is None:
+            evals = self.get_evalue(ik)
+        if evecs is None:
+            evecs = self.get_evecs(ik)
         Gk = eigen_to_G(
-            evals=self.get_evalue(ik),
-            evecs=self.get_evecs(ik),
+            evals=evals,
+            evecs=evecs,
             efermi=self.efermi,
             energy=energy,
         )

TB2J/interfaces/__init__.py

@@ -0,0 +1,12 @@
+from .abacus import gen_exchange_abacus
+from .manager import Manager
+from .siesta_interface import gen_exchange_siesta
+from .wannier90_interface import WannierManager, gen_exchange
+
+__all__ = [
+    "Manager",
+    "gen_exchange_siesta",
+    "WannierManager",
+    "gen_exchange",
+    "gen_exchange_abacus",
+]

TB2J/interfaces/abacus/__init__.py

@@ -0,0 +1,4 @@
+from .abacus_wrapper import AbacusParser, AbacusWrapper
+from .gen_exchange_abacus import gen_exchange_abacus
+
+__all__ = ["AbacusWrapper", "AbacusParser", "gen_exchange_abacus"]

TB2J/{abacus → interfaces/abacus}/abacus_api.py

@@ -1,10 +1,10 @@
 # -*- coding: utf-8 -*-
-import numpy as np
-from scipy import sparse
-from scipy.sparse import csr_matrix
 import re
 import struct
 
+import numpy as np
+from scipy.sparse import csr_matrix
+
 
 class XR_matrix:
     def __init__(self, nspin, XR_fileName):

TB2J/{abacus → interfaces/abacus}/abacus_wrapper.py

@@ -3,17 +3,20 @@
 """
 The abacus wrapper
 """
-from pathlib import Path
+
 import os
+from pathlib import Path
+
 import numpy as np
 from scipy.linalg import eigh
-from copy import deepcopy
+
 from TB2J.mathutils.rotate_spin import rotate_Matrix_from_z_to_spherical
-from TB2J.utils import symbol_number_list
 from TB2J.myTB import AbstractTB
-from TB2J.abacus.abacus_api import read_HR_SR
-from TB2J.abacus.orbital_api import parse_abacus_orbital
-from TB2J.abacus.stru_api import read_abacus, read_abacus_out
+from TB2J.utils import symbol_number_list
+
+from .abacus_api import read_HR_SR
+from .orbital_api import parse_abacus_orbital
+from .stru_api import read_abacus
 
 
 class AbacusWrapper(AbstractTB):
@@ -36,7 +39,6 @@ class AbacusWrapper(AbstractTB):
             self.set_HR_soc(HR_soc=HR_soc, HR_nosoc=HR_nosoc, HR_full=HR)
         self.soc_rotation_angle = 0.0
 
-
     def set_HR_soc(self, HR_soc=None, HR_nosoc=None, HR_full=None):
         self.split_soc = True
         self.HR_soc = HR_soc
@@ -329,16 +331,17 @@ def test_abacus_wrapper_collinear():
     # print(H.diagonal().real)
     # print(model_up.get_HR0().diagonal().real)
     print(parser.efermi)
+    print(atoms)
 
 
 def test_abacus_wrapper_ncl():
     outpath = "/Users/hexu/projects/TB2J_abacus/abacus-tb2j-master/abacus_example/case_Fe/2_soc/OUT.Fe"
-
     parser = AbacusParser(outpath=outpath, spin=None, binary=False)
     atoms = parser.read_atoms()
     model = parser.get_models()
     H, S, E, V = model.HSE_k([0, 0, 0])
     print(parser.efermi)
+    print(atoms)
 
 
 if __name__ == "__main__":

TB2J/{abacus → interfaces/abacus}/gen_exchange_abacus.py

@@ -6,9 +6,11 @@ The main function to compute exchange interaction from abacus data
 
 import os
 from pathlib import Path
-#from TB2J.abacus.abacus_wrapper import AbacusParser
+
+# from TB2J.abacus.abacus_wrapper import AbacusParser
 from HamiltonIO.abacus import AbacusParser
-from TB2J.exchange import ExchangeNCL, ExchangeCL
+
+from TB2J.exchange import ExchangeNCL
 from TB2J.exchangeCL2 import ExchangeCL2
 
 
@@ -65,7 +67,7 @@ data directory: {outpath}
         )
         exchange.run(path=output_path)
         print("\n")
-        print(f"All calculation finsihed. The results are in {output_path} directory.")
+        print(f"All calculation finished. The results are in {output_path} directory.")
     else:
         tbmodel = parser.get_models()
         print("Starting to calculate exchange.")

TB2J/{abacus → interfaces/abacus}/orbital_api.py

@@ -3,11 +3,11 @@
 """
 Parser for the abacus orbital file
 """
-from pathlib import Path
-import numpy as np
+
 from dataclasses import dataclass
-from collections import namedtuple
-from TB2J.utils import symbol_number, symbol_number_list
+from pathlib import Path
+
+from TB2J.utils import symbol_number_list
 
 
 @dataclass

TB2J/{abacus → interfaces/abacus}/stru_api.py

@@ -8,17 +8,17 @@ Modified on Wed Aug 01 11:44:51 2022
 @author: Ji Yu-yang
 """
 
-import re
-import warnings
-import numpy as np
 import os
+import re
 import shutil
+import warnings
 from pathlib import Path
 
+import numpy as np
 from ase import Atoms
-from ase.units import Bohr, Hartree, GPa, mol, _me, Rydberg
-from ase.utils import lazymethod, lazyproperty, reader, writer
 from ase.calculators.singlepoint import SinglePointDFTCalculator, arrays_to_kpoints
+from ase.units import Bohr, GPa, Hartree, Rydberg, _me, mol
+from ase.utils import lazymethod, lazyproperty, reader, writer
 
 _re_float = r"[-+]?\d+\.*\d*(?:[Ee][-+]\d+)?"
 AU_to_MASS = mol * _me * 1e3
@@ -697,7 +697,7 @@ def read_abacus(fd, latname=None, verbose=False):
     )
     symbols = specie_lines[:, 0]
     ntype = len(symbols)
-    mass = specie_lines[:, 1].astype(float)
+    # mass = specie_lines[:, 1].astype(float)
     try:
         atom_potential = dict(zip(symbols, specie_lines[:, 2].tolist()))
     except IndexError:
@@ -789,7 +789,7 @@ def read_abacus(fd, latname=None, verbose=False):
 
         # symbols, magnetism
         sym = [symbol] * number
-        masses = [mass] * number
+        # masses = [mass] * number
         atom_mags = [float(sub_block.group(1))] * number
         for j in range(number):
             atom_symbol.append(sym[j])
@@ -1121,7 +1121,7 @@ class AbacusOutHeaderChunk(AbacusOutChunk):
         def str_to_kpoints(val_in):
             lines = (
                 re.search(
-                    rf"KPOINTS\s*DIRECT_X\s*DIRECT_Y\s*DIRECT_Z\s*WEIGHT([\s\S]+?)DONE",
+                    r"KPOINTS\s*DIRECT_X\s*DIRECT_Y\s*DIRECT_Z\s*WEIGHT([\s\S]+?)DONE",
                     val_in,
                 )
                 .group(1)
@@ -1349,7 +1349,7 @@ class AbacusOutCalcChunk(AbacusOutChunk):
     def _parse_ionic_block(self):
         """Parse the ionic block from the output file"""
         step_pattern = re.compile(
-            rf"(?:[NON]*SELF-|STEP OF|RELAX CELL)([\s\S]+?)charge density convergence is achieved"
+            r"(?:[NON]*SELF-|STEP OF|RELAX CELL)([\s\S]+?)charge density convergence is achieved"
         )
 
         return step_pattern.findall(self.contents)
@@ -1384,7 +1384,7 @@ class AbacusOutCalcChunk(AbacusOutChunk):
             == "Lattice relaxation is converged!"
         )
         res = np.zeros((self.ion_steps), dtype=bool)
-        if lat_arr[-1] == True:
+        if lat_arr[-1]:
             res[-1] = 1
 
         return res.astype(bool)
@@ -1805,7 +1805,7 @@ class AbacusOutCalcChunk(AbacusOutChunk):
     @lazyproperty
     def n_iter(self):
         """The number of SCF iterations needed to converge the SCF cycle for the chunk"""
-        step_pattern = re.compile(rf"ELEC\s*=\s*[+]?(\d+)")
+        step_pattern = re.compile(r"ELEC\s*=\s*[+]?(\d+)")
 
         try:
             return int(step_pattern.findall(self._ionic_block)[-1])

TB2J/{abacus → interfaces/abacus}/test_read_HRSR.py

@@ -1,5 +1,4 @@
 from abacus_api import read_HR_SR
-import numpy as np
 
 
 def main():

TB2J/{abacus → interfaces/abacus}/test_read_stru.py

@@ -3,15 +3,17 @@
 """
 @File    :   test_read_stru.py
 @Time    :   2024/02/02 09:52:23
-@Author  :   Shen Zhen-Xiong 
+@Author  :   Shen Zhen-Xiong
 @Email   :   shenzx@iai.ustc.edu.cn
 """
+
 import os
-from stru_api import read_abacus, write_abacus, read_input
+
+from stru_api import read_abacus, read_input, write_abacus
 
 
 def main():
-    stru_fe = read_abacus(os.path.join(os.getcwd(), "input/Fe.STRU"))
+    # stru_fe = read_abacus(os.path.join(os.getcwd(), "input/Fe.STRU"))
     stru_sr2mn2o6 = read_abacus(
         os.path.join(os.getcwd(), "input/Sr2Mn2O6.STRU"), verbose=True
     )

TB2J/interfaces/gpaw_interface.py

@@ -0,0 +1,54 @@
+import os
+
+import numpy as np
+
+from TB2J.exchange import ExchangeNCL
+from TB2J.gpaw_wrapper import GPAWWrapper
+from TB2J.utils import auto_assign_basis_name
+
+
+def gen_exchange_gpaw(
+    gpw_fname,
+    magnetic_elements=[],
+    kmesh=[3, 3, 3],
+    emin=-12.0,
+    emax=0.0,
+    nz=50,
+    exclude_orbs=[],
+    Rcut=None,
+    use_cache=False,
+    output_path="TB2J_results",
+    description="",
+):
+    print("Reading from GPAW data and calculate electronic structure.")
+    model = GPAWWrapper(gpw_fname=gpw_fname)
+    efermi = model.calc.get_fermi_level()
+    print(f"Fermi Energy: {efermi}")
+    poses = np.vstack([model.positions, model.positions])
+    basis, _ = auto_assign_basis_name(
+        poses,
+        model.atoms,
+        write_basis_file=os.path.join(output_path, "assigned_basis.txt"),
+    )
+
+    if model.calc.get_spin_polarized():
+        print("Starting to calculate exchange.")
+        exchange = ExchangeNCL(
+            tbmodels=model,
+            atoms=model.atoms,
+            efermi=efermi,
+            basis=basis,
+            magnetic_elements=magnetic_elements,
+            kmesh=kmesh,
+            emin=emin,
+            emax=emax,
+            nz=nz,
+            exclude_orbs=exclude_orbs,
+            Rcut=Rcut,
+            use_cache=use_cache,
+            output_path=output_path,
+            description=description,
+        )
+        exchange.run(path=output_path)
+        print("\n")
+        print(f"All calculation finished. The results are in {output_path} directory.")

TB2J/interfaces/lawaf_interface.py

@@ -0,0 +1,129 @@
+import argparse
+import os
+import sys
+
+from HamiltonIO.lawaf import LawafHamiltonian as Ham
+
+from TB2J.exchange_params import add_exchange_args_to_parser, parser_argument_to_dict
+from TB2J.versioninfo import print_license
+
+from .manager import Manager
+
+
+class LaWaFManager(Manager):
+    def __init__(
+        self,
+        path,
+        prefix_up,
+        prefix_dn,
+        prefix_SOC,
+        colinear=True,
+        wannier_type="LaWaF",
+        **kwargs,
+    ):
+        # models and basis
+        if colinear:
+            tbmodels, basis, atoms = self.prepare_model_colinear(
+                path, prefix_up, prefix_dn
+            )
+        else:
+            tbmodels, basis, atoms = self.prepare_model_ncl(path, prefix_SOC)
+
+        description = self.description(path, prefix_up, prefix_dn, prefix_SOC, colinear)
+        kwargs["description"] = description
+
+        super().__init__(atoms, tbmodels, basis, colinear=colinear, **kwargs)
+
+    def prepare_model_colinear(self, path, prefix_up, prefix_dn):
+        print("Reading LawaF hamiltonian: spin up.")
+        tbmodel_up = Ham.load_pickle(os.path.join(path, f"{prefix_up}.pickle"))
+        print("Reading LaWaF hamiltonian: spin down.")
+        tbmodel_dn = Ham.load_pickle(os.path.join(path, f"{prefix_dn}.pickle"))
+        tbmodels = (tbmodel_up, tbmodel_dn)
+        basis = tbmodel_up.wann_names
+        atoms = tbmodel_up.atoms
+        return tbmodels, basis, atoms
+
+    def prepare_model_ncl(self, path, prefix_SOC):
+        print("Reading LaWaF hamiltonian: non-colinear spin.")
+        tbmodel = Ham.load_pickle(os.path.join(path, f"{prefix_SOC}.pickle"))
+        basis = tbmodel.wann_names
+        atoms = tbmodel.atoms
+        return tbmodel, basis, atoms
+
+    def description(self, path, prefix_up, prefix_dn, prefix_SOC, colinear=True):
+        if colinear:
+            description = f""" Input from collinear LaWaF data.
+ Tight binding data from {path}.
+ Prefix of wannier function files:{prefix_up} and {prefix_dn}.
+Warning: Please check if the noise level of Wannier function Hamiltonian to make sure it is much smaller than the exchange values.
+\n"""
+
+        else:
+            description = f""" Input from non-collinear LaWaF data.
+Tight binding data from {path}.
+Prefix of wannier function files:{prefix_SOC}.
+Warning: Please check if the noise level of Wannier function Hamiltonian to make sure it is much smaller than the exchange values.
+The DMI component parallel to the spin orientation, the Jani which has the component of that orientation should be disregarded
+e.g. if the spins are along z, the xz, yz, zz, zx, zy components and the z component of DMI.
+If you need these component, try to do three calculations with spin along x, y, z,  or use structure with z rotated to x, y and z. And then use TB2J_merge.py to get the full set of parameters.\n"""
+
+        return description
+
+
+def lawaf2J_cli():
+    print_license()
+    parser = argparse.ArgumentParser(
+        description="lawaf2J: Using magnetic force theorem to calculate exchange parameter J from wannier functions in LaWaF"
+    )
+    parser.add_argument(
+        "--path", help="path to the wannier files", default="./", type=str
+    )
+
+    parser.add_argument(
+        "--spinor",
+        help="if the calculation is spinor, default is False",
+        default=False,
+        action="store_true",
+    )
+
+    parser.add_argument(
+        "--prefix_spinor",
+        help="prefix to the spinor wannier files",
+        default="lawaf_spinor.pickle",
+        type=str,
+    )
+    parser.add_argument(
+        "--prefix_up",
+        help="prefix to the spin up wannier files",
+        default="lawaf_up",
+        type=str,
+    )
+    parser.add_argument(
+        "--prefix_down",
+        help="prefix to the spin down wannier files",
+        default="lawaf_dn",
+        type=str,
+    )
+    add_exchange_args_to_parser(parser)
+
+    args = parser.parse_args()
+
+    if args.efermi is None:
+        print("Please input fermi energy using --efermi ")
+        sys.exit()
+    if args.elements is None:
+        print("Please input the magnetic elements, e.g. --elements Fe Ni")
+        sys.exit()
+
+    kwargs = parser_argument_to_dict(args)
+
+    manager = LaWaFManager(
+        path=args.path,
+        prefix_up=args.prefix_up,
+        prefix_dn=args.prefix_down,
+        prefix_SOC=args.prefix_spinor,
+        colinear=not args.spinor,
+        **kwargs,
+    )
+    return manager

TB2J/interfaces/manager.py

@@ -0,0 +1,23 @@
+from TB2J.exchange import ExchangeNCL
+from TB2J.exchange_qspace import ExchangeCLQspace
+from TB2J.exchangeCL2 import ExchangeCL2
+
+
+class Manager:
+    def __init__(self, atoms, models, basis, colinear, **kwargs):
+        # computing exchange
+        print("Starting to calculate exchange.")
+        ExchangeClass = self.select_exchange(colinear)
+        exchange = ExchangeClass(tbmodels=models, atoms=atoms, basis=basis, **kwargs)
+        output_path = kwargs.get("output_path", "TB2J_results")
+        exchange.run(path=output_path)
+        print(f"All calculation finished. The results are in {output_path} directory.")
+
+    def select_exchange(self, colinear, qspace=False):
+        if colinear:
+            if qspace:
+                return ExchangeCLQspace
+            else:
+                return ExchangeCL2
+        else:
+            return ExchangeNCL