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

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

TB2J/interfaces/siesta_interface.py

@@ -0,0 +1,174 @@
+import os
+
+import numpy as np
+
+from TB2J.exchange import ExchangeNCL
+from TB2J.exchangeCL2 import ExchangeCL2
+
+try:
+    from HamiltonIO.siesta import SislParser
+except ImportError:
+    print(
+        "Cannot import SislWrapper from HamiltonIO.siesta. Please install HamiltonIO first."
+    )
+
+np.seterr(all="raise", under="ignore")
+
+
+def gen_exchange_siesta(
+    fdf_fname,
+    read_H_soc=False,
+    magnetic_elements=[],
+    include_orbs=None,
+    kmesh=[5, 5, 5],
+    emin=-12.0,
+    emax=0.0,
+    nz=100,
+    exclude_orbs=[],
+    Rcut=None,
+    ne=None,
+    nproc=1,
+    use_cache=False,
+    output_path="TB2J_results",
+    orb_decomposition=False,
+    orth=False,
+    description="",
+):
+    try:
+        import sisl
+    except ImportError:
+        raise ImportError("sisl cannot be imported. Please install sisl first.")
+
+    from packaging import version
+
+    if version.parse(sisl.__version__) <= version.parse("0.10.0"):
+        raise ImportError(
+            f"sisl version is {sisl.__version__}, but should be larger than 0.10.0."
+        )
+
+    include_orbs = {}
+    if isinstance(magnetic_elements, str):
+        magnetic_elements = [magnetic_elements]
+    for element in magnetic_elements:
+        if "_" in element:
+            elem = element.split("_")[0]
+            orb = element.split("_")[1:]
+            include_orbs[elem] = orb
+        else:
+            include_orbs[element] = None
+    magnetic_elements = list(include_orbs.keys())
+
+    # fdf = sisl.get_sile(fdf_fname)
+    # geom = fdf.read_geometry()
+    # H = fdf.read_hamiltonian()
+    # geom = H.geometry
+    parser = SislParser(
+        fdf_fname=fdf_fname, ispin=None, read_H_soc=read_H_soc, orth=orth
+    )
+    if parser.spin.is_colinear:
+        print("Reading Siesta hamiltonian: colinear spin.")
+        # tbmodel_up = SislWrapper(fdf_fname=None, sisl_hamiltonian=H, spin=0, geom=geom)
+        # tbmodel_dn = SislWrapper(fdf_fname=None, sisl_hamiltonian=H, spin=1, geom=geom)
+        tbmodel_up, tbmodel_dn = parser.get_model()
+        basis = dict(zip(tbmodel_up.orbs, list(range(tbmodel_up.norb))))
+        print("Starting to calculate exchange.")
+        description = f""" Input from collinear Siesta data.
+ working directory: {os.getcwd()}
+ fdf_fname: {fdf_fname}.
+\n"""
+        exchange = ExchangeCL2(
+            tbmodels=(tbmodel_up, tbmodel_dn),
+            atoms=tbmodel_up.atoms,
+            basis=basis,
+            efermi=0.0,
+            magnetic_elements=magnetic_elements,
+            include_orbs=include_orbs,
+            kmesh=kmesh,
+            emin=emin,
+            emax=emax,
+            nz=nz,
+            exclude_orbs=exclude_orbs,
+            Rcut=Rcut,
+            ne=ne,
+            nproc=nproc,
+            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.")
+
+    elif parser.spin.is_spinorbit or parser.spin.is_noncolinear:
+        print("Reading Siesta hamiltonian: non-colinear spin.")
+        model = parser.get_model()
+        basis = dict(zip(model.orbs, list(range(model.nbasis))))
+        print("Starting to calculate exchange.")
+        description = f""" Input from non-collinear Siesta data.
+ working directory: {os.getcwd()}
+ fdf_fname: {fdf_fname}.
+Warning: 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"""
+        if not model.split_soc:
+            exchange = ExchangeNCL(
+                tbmodels=model,
+                atoms=model.atoms,
+                basis=basis,
+                efermi=0.0,
+                # FIXME:
+                # efermi=None,
+                magnetic_elements=magnetic_elements,
+                include_orbs=include_orbs,
+                kmesh=kmesh,
+                emin=emin,
+                emax=emax,
+                nz=nz,
+                exclude_orbs=exclude_orbs,
+                Rcut=Rcut,
+                ne=ne,
+                nproc=nproc,
+                use_cache=use_cache,
+                description=description,
+                output_path=output_path,
+                orb_decomposition=orb_decomposition,
+            )
+            exchange.run(path=output_path)
+            print("\n")
+            print(
+                f"All calculation finished. The results are in {output_path} directory."
+            )
+        else:
+            angle = {"x": (np.pi / 2, 0), "y": (np.pi / 2, np.pi / 2), "z": (0, 0)}
+            for key, val in angle.items():
+                # model = parser.get_model()
+                theta, phi = val
+                model.set_Hsoc_rotation_angle([theta, phi])
+                basis = dict(zip(model.orbs, list(range(model.nbasis))))
+                output_path_full = f"{output_path}_{key}"
+                exchange = ExchangeNCL(
+                    tbmodels=model,
+                    atoms=model.atoms,
+                    basis=basis,
+                    efermi=None,  # set to None, compute from efermi.
+                    magnetic_elements=magnetic_elements,
+                    include_orbs=include_orbs,
+                    kmesh=kmesh,
+                    emin=emin,
+                    emax=emax,
+                    nz=nz,
+                    exclude_orbs=exclude_orbs,
+                    Rcut=Rcut,
+                    ne=ne,
+                    nproc=nproc,
+                    use_cache=use_cache,
+                    description=description,
+                    output_path=output_path_full,
+                    orb_decomposition=orb_decomposition,
+                )
+                exchange.run(path=output_path_full)
+                print("\n")
+                print(
+                    f"All calculation finished. The results are in {output_path_full} directory."
+                )