TB2J 0.9.9rc5__tar.gz → 0.9.9rc6__tar.gz

{tb2j-0.9.9rc5 → tb2j-0.9.9rc6}/PKG-INFO

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

{tb2j-0.9.9rc5 → tb2j-0.9.9rc6}/TB2J/MAEGreen.py

@@ -7,6 +7,7 @@ from HamiltonIO.model.occupations import GaussOccupations
 from typing_extensions import DefaultDict
 
 from TB2J.exchange import ExchangeNCL
+from TB2J.external import p_map
 
 # from HamiltonIO.model.rotate_spin import rotate_Matrix_from_z_to_axis, rotate_Matrix_from_z_to_sperical
 # from TB2J.abacus.abacus_wrapper import AbacusWrapper, AbacusParser
@@ -78,6 +79,17 @@ class MAEGreen(ExchangeNCL):
 
     def get_perturbed(self, e, thetas, phis):
         self.tbmodel.set_so_strength(0.0)
+        maxsoc = self.tbmodel.get_max_Hsoc_abs()
+        maxH0 = self.tbmodel.get_max_H0_spin_abs()
+        if maxsoc > maxH0 * 0.01:
+            print(f"""Warning: The SOC of the Hamiltonian has a maximum of {maxsoc} eV,
+                  comparing to the maximum of {maxH0} eV of the spin part of the Hamiltonian.
+                  The SOC is too strong, the perturbation theory may not be valid.""")
+
+        print(f"""Warning: The SOC of the Hamiltonian has a maximum of {maxsoc} eV,
+                  comparing to the maximum of {maxH0} eV of the spin part of the Hamiltonian.
+                  The SOC is too strong, the perturbation theory may not be valid.""")
+
         G0K = self.G.get_Gk_all(e)
         Hsoc_k = self.tbmodel.get_Hk_soc(self.G.kpts)
         na = len(thetas)
@@ -143,15 +155,33 @@ class MAEGreen(ExchangeNCL):
         if with_eigen:
             self.es2 = self.get_band_energy_vs_angles_from_eigen(thetas, phis)
 
-        for ie, e in enumerate(tqdm.tqdm(self.contour.path)):
-            dE_angle, dE_angle_atom, dE_angle_atom_orb = self.get_perturbed(
-                e, thetas, phis
-            )
-            self.es += dE_angle * self.contour.weights[ie]
-            self.es_atom += dE_angle_atom * self.contour.weights[ie]
+        # for ie, e in enumerate(tqdm.tqdm(self.contour.path)):
+        #    dE_angle, dE_angle_atom, dE_angle_atom_orb = self.get_perturbed(
+        #        e, thetas, phis
+        #    )
+        #    self.es += dE_angle * self.contour.weights[ie]
+        #    self.es_atom += dE_angle_atom * self.contour.weights[ie]
+        #    for key, value in dE_angle_atom_orb.items():
+        #        self.es_atom_orb[key] += (
+        #            dE_angle_atom_orb[key] * self.contour.weights[ie]
+        #        )
+
+        # rewrite the for loop above to use p_map
+        def func(e):
+            return self.get_perturbed(e, thetas, phis)
+
+        if self.nproc > 1:
+            results = p_map(func, self.contour.path, num_cpus=self.nproc)
+        else:
+            npole = len(self.contour.path)
+            results = map(func, tqdm.tqdm(self.contour.path, total=npole))
+        for i, result in enumerate(results):
+            dE_angle, dE_angle_atom, dE_angle_atom_orb = result
+            self.es += dE_angle * self.contour.weights[i]
+            self.es_atom += dE_angle_atom * self.contour.weights[i]
             for key, value in dE_angle_atom_orb.items():
                 self.es_atom_orb[key] += (
-                    dE_angle_atom_orb[key] * self.contour.weights[ie]
+                    dE_angle_atom_orb[key] * self.contour.weights[i]
                 )
 
         self.es = -np.imag(self.es) / (2 * np.pi)

{tb2j-0.9.9rc5 → tb2j-0.9.9rc6}/TB2J/contour.py

@@ -1,5 +1,6 @@
 import numpy as np
 from scipy.special import roots_legendre
+
 from TB2J.utils import simpson_nonuniform_weight
 
 
@@ -15,6 +16,21 @@ class Contour:
             self._weights = simpson_nonuniform_weight(self.path)
         return self._weights
 
+    def integrate_func(self, func):
+        """
+        integrate f along the path
+        """
+        return np.dot(func(self.path), self.weights)
+
+    def integrate_values(self, values):
+        """
+        integrate f along the path
+        """
+        ret = 0
+        for i in range(len(values)):
+            ret += values[i] * self.weights[i]
+        return ret
+
     def build_path_semicircle(self, npoints, endpoint=True):
         R = (self.emax - self.emin) / 2.0
         R0 = (self.emin + self.emax) / 2.0

{tb2j-0.9.9rc5 → tb2j-0.9.9rc6}/TB2J/exchange.py

@@ -10,13 +10,12 @@ from TB2J.exchange_params import ExchangeParams
 from TB2J.external import p_map
 from TB2J.green import TBGreen
 from TB2J.io_exchange import SpinIO
+from TB2J.mycfr import CFR
 from TB2J.orbmap import map_orbs_matrix
 from TB2J.pauli import pauli_block_all, pauli_block_sigma_norm
 from TB2J.utils import (
     kmesh_to_R,
-    simpson_nonuniform,
     symbol_number,
-    trapezoidal_nonuniform,
 )
 
 
@@ -28,6 +27,7 @@ class Exchange(ExchangeParams):
         self._prepare_Rlist()
         self.set_tbmodels(tbmodels)
         self._adjust_emin()
+        # self._prepare_elist(method="CFR")
         self._prepare_elist(method="legendre")
         self._prepare_basis()
         self._prepare_orb_dict()
@@ -45,8 +45,9 @@ class Exchange(ExchangeParams):
         os.makedirs(self.orbpath, exist_ok=True)
 
     def _adjust_emin(self):
-        self.emin = self.G.find_energy_ingap(rbound=self.efermi - 10.0) - self.efermi
-        # self.emin = -22.0
+        self.emin = self.G.find_energy_ingap(rbound=self.efermi - 15.0) - self.efermi
+        # self.emin = self.G.find_energy_ingap(rbound=self.efermi - 15.0) - self.efermi
+        # self.emin = -42.0
         print(f"A gap is found at {self.emin}, set emin to it.")
 
     def set_tbmodels(self, tbmodels):
@@ -61,21 +62,24 @@ class Exchange(ExchangeParams):
         for k in kmesh:
             self.kmesh = list(map(lambda x: x // 2 * 2 + 1, kmesh))
 
-    def _prepare_elist(self, method="legendre"):
+    def _prepare_elist(self, method="CFR"):
         """
         prepare list of energy for integration.
         The path has three segments:
          emin --1-> emin + 1j*height --2-> emax+1j*height --3-> emax
         """
-        self.contour = Contour(self.emin, self.emax)
         # if method.lower() == "rectangle":
         #    self.contour.build_path_rectangle(
         #        height=self.height, nz1=self.nz1, nz2=self.nz2, nz3=self.nz3
         #    )
         if method.lower() == "semicircle":
+            self.contour = Contour(self.emin, self.emax)
             self.contour.build_path_semicircle(npoints=self.nz, endpoint=True)
         elif method.lower() == "legendre":
+            self.contour = Contour(self.emin, self.emax)
             self.contour.build_path_legendre(npoints=self.nz, endpoint=True)
+        elif method.lower() == "cfr":
+            self.contour = CFR(nz=self.nz, T=600)
         else:
             raise ValueError(f"The path cannot be of type {method}.")
 
@@ -114,6 +118,7 @@ class Exchange(ExchangeParams):
                 else:
                     try:
                         atom_sym, orb_sym = base[:2]
+                        iatom = sdict[atom_sym]
                     except Exception:
                         iatom = base.iatom
                         atom_sym = base.iatom
@@ -168,7 +173,6 @@ or badly localized. Please check the Wannier centers in the Wannier90 output fil
         self.mmats = {}
         self.orbital_names = {}
         self.norb_reduced = {}
-        print(f"self.backend_name: {self.backend_name}")
         if self.backend_name.upper() in ["SIESTA", "ABACUS", "LCAOHAMILTONIAN"]:
             # print(f"magntic_elements: {self.magnetic_elements}")
             # print(f"include_orbs: {self.include_orbs}")
@@ -562,20 +566,24 @@ class ExchangeNCL(Exchange):
         AijRs: a list of AijR,
         wherer AijR: array of ((nR, n, n, 4,4), dtype=complex)
         """
-        if method == "trapezoidal":
-            integrate = trapezoidal_nonuniform
-        elif method == "simpson":
-            integrate = simpson_nonuniform
+        # if method == "trapezoidal":
+        #    integrate = trapezoidal_nonuniform
+        # elif method == "simpson":
+        #    integrate = simpson_nonuniform
+        #
 
         # self.rho = integrate(self.contour.path, rhoRs)
         for iR, R in enumerate(self.R_ijatom_dict):
             for iatom, jatom in self.R_ijatom_dict[R]:
                 f = AijRs[(R, iatom, jatom)]
-                self.A_ijR[(R, iatom, jatom)] = integrate(self.contour.path, f)
+                # self.A_ijR[(R, iatom, jatom)] = integrate(self.contour.path, f)
+                self.A_ijR[(R, iatom, jatom)] = self.contour.integrate_values(f)
+
                 if self.orb_decomposition:
-                    self.A_ijR_orb[(R, iatom, jatom)] = integrate(
-                        self.contour.path, AijRs_orb[(R, iatom, jatom)]
-                    )
+                    # self.A_ijR_orb[(R, iatom, jatom)] = integrate(
+                    #    self.contour.path, AijRs_orb[(R, iatom, jatom)]
+                    # )
+                    self.contour.integrate_values(AijRs_orb[(R, iatom, jatom)])
 
     def get_quantities_per_e(self, e):
         Gk_all = self.G.get_Gk_all(e)

{tb2j-0.9.9rc5 → tb2j-0.9.9rc6}/TB2J/exchangeCL2.py

@@ -1,15 +1,18 @@
 """
 Exchange from Green's function
 """
+
 import os
 from collections import defaultdict
+
 import numpy as np
-from TB2J.green import TBGreen
-from TB2J.io_exchange import SpinIO
 from tqdm import tqdm
+
 from TB2J.external import p_map
+from TB2J.green import TBGreen
+from TB2J.io_exchange import SpinIO
+
 from .exchange import ExchangeCL
-from .utils import simpson_nonuniform, trapezoidal_nonuniform
 
 
 class ExchangeCL2(ExchangeCL):
@@ -221,17 +224,23 @@ class ExchangeCL2(ExchangeCL):
         #    shutil.rmtree(path)
 
     def integrate(self, method="simpson"):
-        if method == "trapezoidal":
-            integrate = trapezoidal_nonuniform
-        elif method == "simpson":
-            integrate = simpson_nonuniform
+        # if method == "trapezoidal":
+        #    integrate = trapezoidal_nonuniform
+        # elif method == "simpson":
+        #    integrate = simpson_nonuniform
         for R, ijpairs in self.R_ijatom_dict.items():
             for iatom, jatom in ijpairs:
-                self.Jorb[(R, iatom, jatom)] = integrate(
-                    self.contour.path, self.Jorb_list[(R, iatom, jatom)]
+                # self.Jorb[(R, iatom, jatom)] = integrate(
+                #    self.contour.path, self.Jorb_list[(R, iatom, jatom)]
+                # )
+                # self.JJ[(R, iatom, jatom)] = integrate(
+                #    self.contour.path, self.JJ_list[(R, iatom, jatom)]
+                # )
+                self.Jorb[(R, iatom, jatom)] = self.contour.integrate_values(
+                    self.Jorb_list[(R, iatom, jatom)]
                 )
-                self.JJ[(R, iatom, jatom)] = integrate(
-                    self.contour.path, self.JJ_list[(R, iatom, jatom)]
+                self.JJ[(R, iatom, jatom)] = self.contour.integrate_values(
+                    self.JJ_list[(R, iatom, jatom)]
                 )
 
     def get_quantities_per_e(self, e):

{tb2j-0.9.9rc5 → tb2j-0.9.9rc6}/TB2J/exchange_params.py

@@ -115,6 +115,14 @@ def add_exchange_args_to_parser(parser: argparse.ArgumentParser):
         type=str,
         nargs="*",
     )
+
+    parser.add_argument(
+        "--spinor",
+        help="whether the Wannier functions are spinor. Default: False",
+        action="store_true",
+        default=False,
+    )
+
     parser.add_argument(
         "--rcut",
         help="cutoff of spin pair distance. The default is to calculate all commensurate R point to the k mesh.",

{tb2j-0.9.9rc5 → tb2j-0.9.9rc6}/TB2J/green.py

@@ -18,6 +18,17 @@ from TB2J.kpoints import ir_kpts, monkhorst_pack
 MAX_EXP_ARGUMENT = np.log(sys.float_info.max)
 
 
+def eigen_to_G2(H, S, efermi, energy):
+    """calculate green's function from eigenvalue/eigenvector for energy(e-ef): G(e-ef).
+    :param H: Hamiltonian matrix in eigenbasis
+    :param S: Overlap matrix in eigenbasis
+    :param efermi: fermi energy
+    :param energy: energy level e - efermi
+    """
+    # G = ((E+Ef) S - H)^-1
+    return np.linalg.inv((energy + efermi) * S - H)
+
+
 def eigen_to_G(evals, evecs, efermi, energy):
     """calculate green's function from eigenvalue/eigenvector for energy(e-ef): G(e-ef).
     :param evals:  eigen values
@@ -121,7 +132,10 @@ class TBGreen:
         elif kmesh is not None:
             if ibz:
                 self.kpts, self.kweights = ir_kpts(
-                    atoms=tbmodel.atoms, mp_grid=kmesh, ir=True, is_time_reversal=False
+                    atoms=tbmodel.atoms,
+                    mp_grid=kmesh,
+                    ir=True,
+                    is_time_reversal=False,
                 )
                 self.nkpts = len(self.kpts)
                 print(f"Using IBZ of kmesh of {kmesh}")

{tb2j-0.9.9rc5 → tb2j-0.9.9rc6}/TB2J/interfaces/siesta_interface.py

@@ -163,7 +163,7 @@ Warning: The DMI component parallel to the spin orientation, the Jani which has
             # thetas = [0, np.pi / 2, np.pi, 3 * np.pi / 2]
             # phis = [0, 0, 0, 0]
             # MAE.set_angles(thetas=thetas, phis=phis)
-            MAE.run(output_path=f"{output_path}_anisotropy")
+            MAE.run(output_path=f"{output_path}_anisotropy", with_eigen=True)
             print(
                 f"MAE calculation finished. The results are in {output_path} directory."
             )

{tb2j-0.9.9rc5 → tb2j-0.9.9rc6}/TB2J/kpoints.py

@@ -70,7 +70,21 @@ def ir_kpts(
     # Irreducible k-points
     # print("Number of ir-kpoints: %d" % len(np.unique(mapping)))
     # print(grid[np.unique(mapping)] / np.array(mesh, dtype=float))
-    return ird_kpts, weight
+
+    new_ir_kpts = []
+    new_weight = []
+    for ik, k in enumerate(ird_kpts):
+        # add k and -k to ird_kpts if -k is not in ird_kpts
+        if not any([np.allclose(-1.0 * k, kpt) for kpt in new_ir_kpts]):
+            new_ir_kpts.append(k)
+            new_ir_kpts.append(-1.0 * k)
+            new_weight.append(weight[ik] / 2)
+            new_weight.append(weight[ik] / 2)
+        else:
+            new_ir_kpts.append(k)
+            new_weight.append(weight[ik])
+    # return ird_kpts, weight
+    return np.array(new_ir_kpts), np.array(new_weight)
 
 
 def test_ir_kpts():

tb2j-0.9.9rc6/TB2J/mycfr.py

@@ -0,0 +1,114 @@
+# -*- coding: utf-8 -*-
+# File: mycfr.py
+# Time: 2017/12/10 19:29:43
+"""
+Continued fraction representation.
+"""
+
+import numpy as np
+from scipy.linalg import eig
+
+kb = 8.61733e-5  # Boltzmann constant in eV
+
+
+class CFR:
+    """
+    Integration with the continued fraction representation.
+    """
+
+    def __init__(self, nz=50, T=60):
+        self.nz = nz
+        self.T = 600
+        self.beta = 1 / (kb * self.T)
+        self.Rinf = 1e10
+        if nz <= 0:
+            raise ValueError("nz should be larger than 0.")
+        else:
+            self.prepare_poles()
+
+    def prepare_poles(self):
+        ##b_mat = [1 / (2.0 * np.sqrt((2 * (j + 1) - 1) * (2 * (j + 1) + 1)) / (kb * self.#T)) for j in range(0, self.nz- 1)]
+        jmat = np.arange(0, self.nz - 1)
+        b_mat = 1 / (2.0 * np.sqrt((2 * (jmat + 1) - 1) * (2 * (jmat + 1) + 1)))
+        b_mat = np.diag(b_mat, -1) + np.diag(b_mat, 1)
+        self.poles, residules = eig(b_mat)
+
+        residules = 0.25 * np.abs(residules[0, :]) ** 2 / self.poles**2
+        # residules = 0.25 * np.diag(residules) ** 2 / self.poles**2
+
+        # self.weights = np.where(
+        #        #np.real(self.poles) > 0, 4.0j / self.beta * residules, 0.0
+        #        #np.real(self.poles) > 0, 2.0j / self.beta * residules, 2.0j / self.beta * residules
+        #    np.real(self.poles) > 0, 2.0j / self.beta * residules, 0.0
+        # )
+
+        # self.path = 1j / self.poles * kb * self.T
+
+        self.path = []
+        self.weights = []
+        for p, r in zip(self.poles, residules):
+            if p > 0:
+                self.path.append(1j / p * kb * self.T)
+                w = 2.0j / self.beta * r
+                self.weights.append(w)
+                self.path.append(-1j / p * kb * self.T)
+                self.weights.append(w)
+
+        self.path = np.array(self.path)
+        self.weights = np.array(self.weights)
+
+        # from J. Phys. Soc. Jpn. 88, 114706 (2019)
+        # A_mat =  -1/2 *np.diag(1, -1) + np.diag(1, 1)
+        # B_mat = np.diag([2*i-1 for i in range(1, self.nz)])
+        # eigp, eigv = eig(A_mat, B_mat)
+        # zp = 1j / eigp * kb * self.T
+        # Rp = 0.25 * np.diag(eigv)**2 * zp **2
+
+        # add a point to the poles: 1e10j
+        self.path = np.concatenate((self.path, [self.Rinf * 1j]))
+        # self.path = np.concatenate((self.path, [0.0]))
+        self.npoles = len(self.poles)
+
+        # add weights for the point 1e10j
+        # self.weights = np.concatenate((self.weights, [-self.Rinf]))
+        self.weights = np.concatenate((self.weights, [00.0]))
+        # zeros moment is 1j * R * test_gf(1j * R), but the real part of it will be taken. In contrast to the other part, where the imaginary part is taken.
+
+    def integrate_values(self, gf_vals, imag=False):
+        ret = 0
+        for i in range(self.npoles + 1):
+            ret += self.weights[i] * gf_vals[i]
+        ret *= (
+            -np.pi / 2
+        )  # This is to be compatible with the integration of contour, where /-np.pi is used after the integration. And the factor of 2 is because the Fermi function here is 2-fold degenerate.
+        if imag:
+            return np.imag(ret)
+        return ret
+
+    def integrate_func(self, gf, ef=0):
+        """
+        Integration with the continued fraction representation.
+
+        :param gf: Green's function
+        :param ef: Fermi energy
+        :return: integration result
+        """
+        path = self.path
+        gf_vals = gf(path, ef=ef)
+        return self.integrate_values(gf_vals)
+
+
+def test_cfr():
+    cfr = CFR(nz=100)
+
+    def test_gf(z, ef=0.1):
+        return 1 / (z - 3 + ef)
+
+    r = cfr.integrate_func(test_gf, ef=2)
+    r = -np.imag(r) / np.pi * 2
+    print(r)
+    return r
+
+
+if __name__ == "__main__":
+    test_cfr()

{tb2j-0.9.9rc5 → tb2j-0.9.9rc6}/TB2J/orbmap.py

@@ -28,14 +28,14 @@ def map_orbs_matrix(orblist, spinor=False, include_only=None):
 
     norb = len(orblist)
 
-    print("orblist: ", orblist)
+    # print("orblist: ", orblist)
     ss = [split_orb_name(orb) for orb in orblist]
     orbdict = dict(zip(ss, range(norb)))
 
     reduced_orbdict = defaultdict(lambda: [])
 
-    print(f"Orbital dictionary: {orbdict}")
-    print("include_only: ", include_only)
+    # print(f"Orbital dictionary: {orbdict}")
+    # print("include_only: ", include_only)
 
     if include_only is None:
         for key, val in orbdict.items():
@@ -46,7 +46,7 @@ def map_orbs_matrix(orblist, spinor=False, include_only=None):
                 # [:2] for 3d, 4d, 5d, etc. and [:1] for s, p, d, etc
                 reduced_orbdict[key[0]].append(val)
 
-    print(f"reduced_orbdict: {reduced_orbdict}")
+    # print(f"reduced_orbdict: {reduced_orbdict}")
     reduced_orbs = tuple(reduced_orbdict.keys())
     ngroup = len(reduced_orbdict)
     mmat = np.zeros((norb, ngroup), dtype=int)

{tb2j-0.9.9rc5 → tb2j-0.9.9rc6}/TB2J/symmetrize_J.py

@@ -14,6 +14,7 @@ class TB2JSymmetrizer:
         ijRs = exc.ijR_list_index_atom()
         finder = SymmetryPairFinder(atoms=exc.atoms, pairs=ijRs, symprec=symprec)
         self.verbose = verbose
+        self.Jonly = Jonly
 
         if verbose:
             print("=" * 30)
@@ -124,9 +125,10 @@ def symmetrize_J_cli():
     )
 
     parser.add_argument(
-        "-Jonly",
+        "--Jonly",
         action="store_true",
-        help="Symmetrize only the exchange parameters. Do not output DMI and anisotropic exchange.",
+        help="symmetrize only the exchange parameters and discard the DMI and anisotropic exchange",
+        default=False,
     )
 
     args = parser.parse_args()

{tb2j-0.9.9rc5 → tb2j-0.9.9rc6}/TB2J.egg-info/PKG-INFO

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

{tb2j-0.9.9rc5 → tb2j-0.9.9rc6}/TB2J.egg-info/SOURCES.txt

@@ -25,6 +25,7 @@ TB2J/greentest.py
 TB2J/io_merge.py
 TB2J/kpoints.py
 TB2J/myTB.py
+TB2J/mycfr.py
 TB2J/orbmap.py
 TB2J/pauli.py
 TB2J/pert.py

{tb2j-0.9.9rc5 → tb2j-0.9.9rc6}/setup.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 from setuptools import find_packages, setup
 
-__version__ = "0.9.9_rc5"
+__version__ = "0.9.9_rc6"
 
 long_description = """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. """