TB2J 0.7.7.2__py3-none-any.whl → 0.8.0__py3-none-any.whl

TB2J/__init__.py

@@ -1 +1 @@
-__version__ = "0.7.7.2"
+__version__ = "0.8.0"

TB2J/abacus/__init__.py

@@ -0,0 +1 @@
+from .abacus_wrapper import AbacusWrapper, AbacusParser

TB2J/abacus/abacus_api.py

@@ -0,0 +1,191 @@
+# -*- coding: utf-8 -*-
+import numpy as np
+from scipy import sparse
+from scipy.sparse import csr_matrix
+import re
+import struct
+
+
+class XR_matrix:
+    def __init__(self, nspin, XR_fileName):
+        self.nspin = nspin
+        self.XR_fileName = XR_fileName
+
+    def read_file(self):
+        with open(self.XR_fileName, "r") as fread:
+            while True:
+                line = fread.readline().split()
+                if line[0] == "Matrix":
+                    break
+
+            self.basis_num = int(line[-1])
+            line = fread.readline()
+            self.R_num = int(line.split()[-1])
+            self.R_direct_coor = np.zeros([self.R_num, 3], dtype=int)
+            if self.nspin != 4:
+                self.XR = np.zeros(
+                    [self.R_num, self.basis_num, self.basis_num], dtype=float
+                )
+            else:
+                self.XR = np.zeros(
+                    [self.R_num, self.basis_num, self.basis_num], dtype=complex
+                )
+
+            for iR in range(self.R_num):
+                line = fread.readline().split()
+                self.R_direct_coor[iR, 0] = int(line[0])
+                self.R_direct_coor[iR, 1] = int(line[1])
+                self.R_direct_coor[iR, 2] = int(line[2])
+                data_size = int(line[3])
+
+                if self.nspin != 4:
+                    data = np.zeros((data_size,), dtype=float)
+                else:
+                    data = np.zeros((data_size,), dtype=complex)
+
+                indices = np.zeros((data_size,), dtype=int)
+                indptr = np.zeros((self.basis_num + 1,), dtype=int)
+
+                if data_size != 0:
+                    if self.nspin != 4:
+                        line = fread.readline().split()
+                        if len(line) != data_size:
+                            print("size = ", len(line), " data_size = ", data_size)
+                        for index in range(data_size):
+                            data[index] = float(line[index])
+                    else:
+                        line = re.findall("[(](.*?)[])]", fread.readline())
+                        for index in range(data_size):
+                            value = line[index].split(",")
+                            data[index] = complex(float(value[0]), float(value[1]))
+
+                    line = fread.readline().split()
+                    for index in range(data_size):
+                        indices[index] = int(line[index])
+
+                    line = fread.readline().split()
+                    for index in range(self.basis_num + 1):
+                        indptr[index] = int(line[index])
+
+                self.XR[iR] = csr_matrix(
+                    (data, indices, indptr), shape=(self.basis_num, self.basis_num)
+                ).toarray()
+
+    def read_file_binary(self):
+        with open(self.XR_fileName, "rb") as fread:
+            self.basis_num = struct.unpack("i", fread.read(4))[0]
+            self.R_num = struct.unpack("i", fread.read(4))[0]
+            self.R_direct_coor = np.zeros([self.R_num, 3], dtype=int)
+            if self.nspin != 4:
+                self.XR = np.zeros(
+                    [self.R_num, self.basis_num, self.basis_num], dtype=float
+                )
+            else:
+                self.XR = np.zeros(
+                    [self.R_num, self.basis_num, self.basis_num], dtype=complex
+                )
+
+            for iR in range(self.R_num):
+                self.R_direct_coor[iR, 0] = struct.unpack("i", fread.read(4))[0]
+                self.R_direct_coor[iR, 1] = struct.unpack("i", fread.read(4))[0]
+                self.R_direct_coor[iR, 2] = struct.unpack("i", fread.read(4))[0]
+                data_size = struct.unpack("i", fread.read(4))[0]
+
+                if self.nspin != 4:
+                    data = np.zeros((data_size,), dtype=float)
+                else:
+                    data = np.zeros((data_size,), dtype=complex)
+
+                indices = np.zeros((data_size,), dtype=int)
+                indptr = np.zeros((self.basis_num + 1,), dtype=int)
+
+                if data_size != 0:
+                    if self.nspin != 4:
+                        for index in range(data_size):
+                            data[index] = struct.unpack("d", fread.read(8))[0]
+                    else:
+                        for index in range(data_size):
+                            real = struct.unpack("d", fread.read(8))[0]
+                            imag = struct.unpack("d", fread.read(8))[0]
+                            data[index] = complex(real, imag)
+
+                    for index in range(data_size):
+                        indices[index] = struct.unpack("i", fread.read(4))[0]
+
+                    for index in range(self.basis_num + 1):
+                        indptr[index] = struct.unpack("i", fread.read(4))[0]
+
+                self.XR[iR] = csr_matrix(
+                    (data, indices, indptr), shape=(self.basis_num, self.basis_num)
+                ).toarray()
+
+
+def read_HR_SR(
+    nspin=4,
+    binary=False,
+    HR_fileName="data-HR-sparse_SPIN0.csr",
+    SR_fileName="data-SR-sparse_SPIN0.csr",
+):
+    """
+    IN:
+        nspin: int, different spins.
+        binary: bool, whether the HR and SR matrices are binary files.
+        HR_fileName: if nspin=1 or 4, str, HR file name;
+                     if nspin=2, list or tuple, size=2, [HR_up_fileName, HR_dn_fileName].
+        SR_fileName: str, SR file name.
+
+    OUT:
+        if nspin = 1 or 4:
+            return basis_num, R_direct_coor, HR, SR
+        elif nspin = 2:
+            return basis_num, R_direct_coor, HR_up, HR_dn, SR
+
+        basis_num: int, number of atomic orbital basis.
+        R_direct_coor: numpy ndarray, shape=[R_num, 3], fractional coordinates (x, y, z) of the R-th primitive cell.
+        HR or HR_up or HR_dn: numpy ndarray, shape=[R_num, basis_num, basis_num], HR matrix and unit is eV.
+        SR: numpy ndarray, shape=[R_num, basis_num, basis_num], SR matrix.
+    """
+    Ry_to_eV = 13.605698066
+
+    if nspin == 1 or nspin == 4:
+        if not isinstance(HR_fileName, str):
+            raise ValueError("The HR_fileName must be a str for nspin=1 or 4.")
+
+        HR = XR_matrix(nspin, HR_fileName)
+        SR = XR_matrix(nspin, SR_fileName)
+
+        if binary:
+            HR.read_file_binary()
+            SR.read_file_binary()
+        else:
+            HR.read_file()
+            SR.read_file()
+
+        return HR.basis_num, HR.R_direct_coor, HR.XR * Ry_to_eV, SR.XR
+    else:
+        if not isinstance(HR_fileName, (list, tuple)):
+            raise ValueError("The HR_fileName must be a list or a tuple for nspin=2.")
+
+        if len(HR_fileName) != 2:
+            raise ValueError("The size of the HR_fileName must be 2 for nspin=2.")
+
+        HR_up = XR_matrix(nspin, HR_fileName[0])
+        HR_dn = XR_matrix(nspin, HR_fileName[1])
+        SR = XR_matrix(nspin, SR_fileName)
+
+        if binary:
+            HR_up.read_file_binary()
+            HR_dn.read_file_binary()
+            SR.read_file_binary()
+        else:
+            HR_up.read_file()
+            HR_dn.read_file()
+            SR.read_file()
+
+        return (
+            HR_up.basis_num,
+            HR_up.R_direct_coor,
+            HR_up.XR * Ry_to_eV,
+            HR_dn.XR * Ry_to_eV,
+            SR.XR,
+        )

TB2J/abacus/abacus_wrapper.py

@@ -0,0 +1,223 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+The abacus wrapper
+"""
+from pathlib import Path
+import numpy as np
+from scipy.linalg import eigh
+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
+
+
+class AbacusWrapper(AbstractTB):
+    def __init__(self, HR, SR, Rlist, nbasis, nspin=1):
+        self.R2kfactor = -2j * np.pi
+        self.is_orthogonal = False
+        self.is_siesta = False
+        self._name = "Abacus"
+        self.HR = HR
+        self.SR = SR
+        self.Rlist = Rlist
+        self.nbasis = nbasis
+        self.nspin = nspin
+        self.norb = nbasis * nspin
+        self._build_Rdict()
+
+    def _build_Rdict(self):
+        if hasattr(self, "Rdict"):
+            pass
+        else:
+            self.Rdict = {}
+            for iR, R in enumerate(self.Rlist):
+                self.Rdict[tuple(R)] = iR
+
+    def get_hamR(self, R):
+        return self.HR[self.Rdict[tuple(R)]]
+
+    def gen_ham(self, k, convention=2):
+        """
+        generate hamiltonian matrix at k point.
+        H_k( i, j)=\sum_R H_R(i, j)^phase.
+        There are two conventions,
+        first:
+        phase =e^{ik(R+rj-ri)}. often better used for berry phase.
+        second:
+        phase= e^{ikR}. We use the first convention here.
+
+        :param k: kpoint
+        :param convention: 1 or 2.
+        """
+        Hk = np.zeros((self.nbasis, self.nbasis), dtype="complex")
+        Sk = np.zeros((self.nbasis, self.nbasis), dtype="complex")
+        if convention == 2:
+            for iR, R in enumerate(self.Rlist):
+                phase = np.exp(self.R2kfactor * np.dot(k, R))
+                H = self.HR[iR] * phase
+                # Hk += H + H.conjugate().T
+                Hk += H
+                S = self.SR[iR] * phase
+                # Sk += S + S.conjugate().T
+                Sk += S
+        elif convention == 1:
+            # TODO: implement the first convention (the r convention)
+            raise NotImplementedError("convention 1 is not implemented yet.")
+            pass
+        else:
+            raise ValueError("convention should be either 1 or 2.")
+        return Hk, Sk
+
+    def solve(self, k, convention=2):
+        Hk, Sk = self.gen_ham(k, convention=convention)
+        return eigh(Hk, Sk)
+
+    def HSE_k(self, kpt, convention=2):
+        H, S = self.gen_ham(tuple(kpt), convention=convention)
+        evals, evecs = eigh(H, S)
+        return H, S, evals, evecs
+
+    def HS_and_eigen(self, kpts, convention=2):
+        """
+        calculate eigens for all kpoints.
+        :param kpts: list of k points.
+        """
+        nk = len(kpts)
+        hams = np.zeros((nk, self.nbasis, self.nbasis), dtype=complex)
+        evals = np.zeros((nk, self.nbasis), dtype=float)
+        evecs = np.zeros((nk, self.nbasis, self.nbasis), dtype=complex)
+        for ik, k in enumerate(kpts):
+            hams[ik], S, evals[ik], evecs[ik] = self.HSE_k(
+                tuple(k), convention=convention
+            )
+        return hams, None, evals, evecs
+
+
+class AbacusParser:
+    def __init__(self, spin=None, outpath=None, binary=False):
+        self.outpath = outpath
+        if spin is None:
+            self.spin = self.read_spin()
+        else:
+            self.spin = spin
+        self.binary = binary
+        # read the information
+        self.read_atoms()
+        self.efermi = self.read_efermi()
+        self.read_basis()
+
+    def read_spin(self):
+        with open(str(Path(self.outpath) / "running_scf.log")) as myfile:
+            for line in myfile:
+                if line.strip().startswith("nspin"):
+                    nspin = int(line.strip().split()[-1])
+                    if nspin == 1:
+                        return "non-polarized"
+                    elif nspin == 2:
+                        return "collinear"
+                    elif nspin == 2:
+                        return "noncollinear"
+                    else:
+                        raise ValueError("nspin should be either 1 or 4.")
+
+    def read_atoms(self):
+        self.atoms = read_abacus(str(Path(self.outpath) / "../Stru"))
+        return self.atoms
+
+    def read_basis(self):
+        fname = str(Path(self.outpath) / "Orbital")
+        self.basis = parse_abacus_orbital(fname)
+        return self.basis
+
+    def read_HSR_collinear(self, binary=None):
+        p = Path(self.outpath)
+        SR_filename = p / "data-SR-sparse_SPIN0.csr"
+        HR_filename = [p / "data-HR-sparse_SPIN0.csr", p / "data-HR-sparse_SPIN1.csr"]
+        nbasis, Rlist, HR_up, HR_dn, SR = read_HR_SR(
+            nspin=2,
+            binary=self.binary,
+            HR_fileName=HR_filename,
+            SR_fileName=SR_filename,
+        )
+        return nbasis, Rlist, HR_up, HR_dn, SR
+
+    def Read_HSR_noncollinear(self, binary=None):
+        p = Path(self.outpath)
+        SR_filename = (p / "data-SR-sparse_SPIN0.csr").as_posix()
+        HR_filename = p / "data-HR-sparse_SPIN0.csr".as_posix()
+        self.nbasis, self.Rlist, self.HR, self.SR = read_HR_SR(
+            nspin=4,
+            binary=self.binary,
+            HR_fileName=HR_filename,
+            SR_fileName=SR_filename,
+        )
+
+    def get_models(self):
+        if self.spin == "collinear":
+            nbasis, Rlist, HR_up, HR_dn, SR = self.read_HSR_collinear()
+            model_up = AbacusWrapper(HR_up, SR, Rlist, nbasis, nspin=1)
+            model_dn = AbacusWrapper(HR_dn, SR, Rlist, nbasis, nspin=1)
+            model_up.efermi = self.efermi
+            model_dn.efermi = self.efermi
+            model_up.basis, model_dn.basis = self.get_basis()
+            model_up.atoms = self.atoms
+            model_dn.atoms = self.atoms
+            return model_up, model_dn
+        elif self.spin == "noncollinear":
+            nbasis, Rlist, HR, SR = self.Read_HSR_noncollinear()
+            model = AbacusWrapper(HR, SR, Rlist, nbasis, nspin=2)
+            model.efermi = self.efermi
+            model.basis = self.get_basis()
+            model.atoms = self.atoms
+            return model
+
+    def read_efermi(self):
+        """
+        Reading the efermi from the scf log file.
+        Search for the line EFERMI = xxxxx eV
+        """
+        fname = str(Path(self.outpath) / "running_scf.log")
+        efermi = None
+        with open(fname, "r") as myfile:
+            for line in myfile:
+                if "EFERMI" in line:
+                    efermi = float(line.split()[2])
+        if efermi is None:
+            raise ValueError(f"EFERMI not found in the {str(fname)}  file.")
+        return efermi
+
+    def get_basis(self):
+        slist = symbol_number_list(self.atoms)
+        if self.spin == "collinear":
+            basis_up = []
+            basis_dn = []
+            for b in self.basis:
+                basis_up.append((slist[b.iatom], b.sym, "up"))
+                basis_dn.append((slist[b.iatom], b.sym, "down"))
+            return basis_up, basis_dn
+        elif self.spin == "noncollinear":
+            basis = []
+            for b in self.basis:
+                basis.append((slist[b.iatom], b.sym, "up"))
+                basis.append((slist[b.iatom], b.sym, "down"))
+            return basis
+
+
+def test_abacus_wrapper():
+    outpath = "/Users/hexu/projects/TB2J_abacus/abacus-tb2j-master/abacus_example/case_Fe/1_no_soc/OUT.Fe"
+    parser = AbacusParser(outpath=outpath, spin=None, binary=False)
+    atoms = parser.read_atoms()
+    # atoms=parser.read_atoms_out()
+    # parser.read_HSR_collinear()
+    model_up, model_dn = parser.get_models()
+    H, S, E, V = model_up.HSE_k([0, 0, 0])
+    # print(H.shape)
+    # print(H.diagonal().real)
+    # print(model_up.get_HR0().diagonal().real)
+    print(parser.get_efermi())
+
+
+if __name__ == "__main__":
+    test_abacus_wrapper()

TB2J/abacus/gen_exchange_abacus.py

@@ -0,0 +1,102 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+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.exchange import ExchangeNCL, ExchangeCL
+from TB2J.exchangeCL2 import ExchangeCL2
+
+
+def gen_exchange_abacus(
+    path,
+    suffix="Abacus",
+    binary=False,
+    magnetic_elements=[],
+    include_orbs=[],
+    kmesh=[7, 7, 7],
+    emin=-13.0,
+    emax=0.00,
+    nz=100,
+    exclude_orbs=[],
+    Rcut=None,
+    use_cache=False,
+    np=1,
+    output_path="TB2J_results",
+    orb_decomposition=False,
+    description=None,
+):
+    outpath = Path(path) / f"OUT.{suffix}"
+
+    if not os.path.exists(outpath):
+        raise ValueError(
+            f"The path {outpath} does not exist. Please check if the path and the suffix is correct"
+        )
+    parser = AbacusParser(outpath=outpath, spin=None, binary=binary)
+    spin = parser.read_spin()
+    if spin == "collinear":
+        tbmodel_up, tbmodel_dn = parser.get_models()
+        efermi = parser.read_efermi()
+        print("Starting to calculate exchange.")
+        description = f""" Input from collinear Abacus data.
+data directory: {outpath}
+\n"""
+        exchange = ExchangeCL2(
+            tbmodels=(tbmodel_up, tbmodel_dn),
+            atoms=tbmodel_up.atoms,
+            basis=tbmodel_up.basis,
+            efermi=efermi,
+            magnetic_elements=magnetic_elements,
+            include_orbs=include_orbs,
+            kmesh=kmesh,
+            emin=emin,
+            emax=emax,
+            nz=nz,
+            exclude_orbs=exclude_orbs,
+            Rcut=Rcut,
+            np=np,
+            use_cache=use_cache,
+            output_path=output_path,
+            description=description,
+        )
+        exchange.run(path=output_path)
+        print("\n")
+        print(f"All calculation finsihed. The results are in {output_path} directory.")
+    else:
+        tbmodel = parser.get_models()
+        print("Starting to calculate exchange.")
+        description = f""" Input from collinear Abacus data.
+data directory: {outpath}
+\n"""
+        exchange = ExchangeNCL(
+            tbmodels=tbmodel,
+            atoms=tbmodel.atoms,
+            basis=tbmodel.basis,
+            efermi=tbmodel.efermi,
+            magnetic_elements=magnetic_elements,
+            kmesh=kmesh,
+            emin=emin,
+            emax=emax,
+            nz=nz,
+            exclude_orbs=exclude_orbs,
+            Rcut=Rcut,
+            use_cache=use_cache,
+            description=description,
+        )
+        exchange.run()
+        print("\n")
+        print("All calculation finsihed. The results are in TB2J_results directory.")
+
+
+if __name__ == "__main__":
+    gen_exchange_abacus(
+        path="/Users/hexu/projects/TB2J_abacus/abacus-tb2j-master/abacus_example/case_Fe/1_no_soc",
+        label="Fe",
+        magnetic_elements=["Fe"],
+        nz=50,
+        Rcut=8,
+        kmesh=[7, 7, 7],
+    )

TB2J/abacus/orbital_api.py

@@ -0,0 +1,70 @@
+#!/usr/vin/env python3
+# -*- coding: utf-8 -*-
+"""
+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
+
+
+@dataclass
+class AbacusOrbital:
+    """
+    Orbital class
+    """
+
+    iatom: int
+    sym: str
+    spin: int
+    element: str
+    l: int
+    m: int
+    z: int
+
+
+def parse_abacus_orbital(fname):
+    """
+    parse the abacus orbital file
+    """
+    orbs = []
+    with open(fname, "r") as myfile:
+        line = myfile.readline()
+        line = myfile.readline()
+        while line.strip() != "":
+            seg = line.split()
+            iatom, element, l, m, z, sym = seg
+            iatom = int(iatom)
+            ispin = 0
+            l = int(l)
+            m = int(m)
+            z = int(z)
+            orbs.append(AbacusOrbital(iatom, sym, ispin, element, l, m, z))
+            line = myfile.readline()
+    return orbs
+
+
+def bset_to_symnum_type(bset, atoms):
+    """
+    convert the basis set to symbol number type
+    """
+    slist = symbol_number_list(atoms)
+    result = []
+    for b in bset:
+        result.append((slist[b.iatom], b.sym, b.spin))
+    return result
+
+
+def test_parse_abacus_orbital():
+    """
+    test the parser
+    """
+    outpath = "/Users/hexu/projects/TB2J_abacus/abacus-tb2j-master/abacus_example/case_Sr2Mn2O6/1_no_soc/OUT.Sr2Mn2O6"
+    orbs = parse_abacus_orbital(Path(outpath) / "Orbital")
+    print(orbs)
+
+
+if __name__ == "__main__":
+    test_parse_abacus_orbital()