TB2J 0.9.9rc3__tar.gz → 0.9.9rc5__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: TB2J
-Version: 0.9.9rc3
+Version: 0.9.9rc5
 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.9rc3 → tb2j-0.9.9rc5}/TB2J/MAE.py

@@ -137,9 +137,9 @@ class MAEGreen(MAE):
         efermi = occ.efermi(evals)
         print(f"{efermi=}")
         self.G = TBGreen(model, kmesh, efermi=efermi, gamma=gamma, **kwargs)
-        self.emin = -12
+        self.emin = -52
         self.emax = 0
-        self.nz = 50
+        self.nz = 100
         self._prepare_elist()
 
     def _prepare_elist(self, method="legendre"):
@@ -186,7 +186,7 @@ class MAEGreen(MAE):
         for ie, e in enumerate(tqdm.tqdm(self.contour.path)):
             dE_angle = self.get_perturbed(e, thetas, phis)
             es += np.imag(dE_angle * self.contour.weights[ie])
-        return -es / np.pi
+        return -es / np.pi / 2
 
 
 def get_model_energy(model, kmesh, gamma=True):

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

@@ -3,7 +3,7 @@ from pathlib import Path
 import numpy as np
 import tqdm
 from HamiltonIO.abacus.abacus_wrapper import AbacusSplitSOCParser
-from HamiltonIO.model.occupations import Occupations
+from HamiltonIO.model.occupations import GaussOccupations
 from typing_extensions import DefaultDict
 
 from TB2J.exchange import ExchangeNCL
@@ -16,7 +16,7 @@ from TB2J.mathutils.rotate_spin import (
 
 
 def get_occupation(evals, kweights, nel, width=0.1):
-    occ = Occupations(nel=nel, width=width, wk=kweights, nspin=2)
+    occ = GaussOccupations(nel=nel, width=width, wk=kweights, nspin=2)
     return occ.occupy(evals)
 
 
@@ -97,6 +97,7 @@ class MAEGreen(ExchangeNCL):
                 dG2 = GdH * GdH.T
                 dG2sum = np.sum(dG2)
                 # print(f"dG2sum-sum: {dG2sum}")
+                dG2sum = np.sum(dG2diag)
 
                 # dG2sum = np.trace(GdH @ GdH)
                 # print(f"dG2sum-Tr: {dG2sum}")
@@ -158,7 +159,7 @@ class MAEGreen(ExchangeNCL):
         for key, value in self.es_atom_orb.items():
             self.es_atom_orb[key] = -np.imag(value) / (2 * np.pi)
 
-    def output(self, output_path="TB2J_anisotropy", with_eigen=False):
+    def output(self, output_path="TB2J_anisotropy", with_eigen=True):
         Path(output_path).mkdir(exist_ok=True)
         fname = f"{output_path}/MAE.dat"
         fname_orb = f"{output_path}/MAE_orb.dat"
@@ -242,6 +243,7 @@ def abacus_get_MAE(
     magnetic_elements=None,
     nel=None,
     width=0.1,
+    with_eigen=False,
     **kwargs,
 ):
     """Get MAE from Abacus with magnetic force theorem. Two calculations are needed. First we do an calculation with SOC but the soc_lambda is set to 0. Save the density. The next calculatin we start with the density from the first calculation and set the SOC prefactor to 1. With the information from the two calcualtions, we can get the band energy with magnetic moments in the direction, specified in two list, thetas, and phis."""
@@ -262,4 +264,4 @@ def abacus_get_MAE(
         magnetic_elements=magnetic_elements,
         **kwargs,
     )
-    mae.run(output_path=output_path)
+    mae.run(output_path=output_path, with_eigen=with_eigen)

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

@@ -21,12 +21,7 @@ from TB2J.utils import (
 
 
 class Exchange(ExchangeParams):
-    def __init__(
-        self,
-        tbmodels,
-        atoms,
-        **params: ExchangeParams,
-    ):
+    def __init__(self, tbmodels, atoms, **params):
         self.atoms = atoms
         super().__init__(**params)
         self._prepare_kmesh(self._kmesh)
@@ -50,8 +45,8 @@ 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 - 10.0) - self.efermi
+        # self.emin = -22.0
         print(f"A gap is found at {self.emin}, set emin to it.")
 
     def set_tbmodels(self, tbmodels):
@@ -62,7 +57,7 @@ class Exchange(ExchangeParams):
         # del self.G.tbmodel
         pass
 
-    def _prepare_kmesh(self, kmesh):
+    def _prepare_kmesh(self, kmesh, ibz=False):
         for k in kmesh:
             self.kmesh = list(map(lambda x: x // 2 * 2 + 1, kmesh))
 
@@ -150,7 +145,7 @@ class Exchange(ExchangeParams):
                 )
         if not self._is_collinear:
             for iatom, orb in self.orb_dict.items():
-                print(f"iatom: {iatom}, orb: {orb}")
+                # print(f"iatom: {iatom}, orb: {orb}")
                 nsorb = len(self.orb_dict[iatom])
                 if nsorb % 2 != 0 and False:
                     raise ValueError(
@@ -175,8 +170,8 @@ or badly localized. Please check the Wannier centers in the Wannier90 output fil
         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}")
+            # print(f"magntic_elements: {self.magnetic_elements}")
+            # print(f"include_orbs: {self.include_orbs}")
             syms = self.atoms.get_chemical_symbols()
             for iatom, orbs in self.labels.items():
                 if (self.include_orbs is not None) and syms[iatom] in self.include_orbs:
@@ -186,7 +181,7 @@ or badly localized. Please check the Wannier centers in the Wannier90 output fil
                         include_only=self.include_orbs[syms[iatom]],
                     )
                 else:
-                    print(f"orbs: {orbs}")
+                    # print(f"orbs: {orbs}")
                     mmat, reduced_orbs = map_orbs_matrix(
                         orbs, spinor=not (self._is_collinear), include_only=None
                     )
@@ -271,10 +266,10 @@ class ExchangeNCL(Exchange):
         """
         self.tbmodel = tbmodels
         self.backend_name = self.tbmodel.name
-        print(self.kmesh)
         self.G = TBGreen(
             tbmodel=self.tbmodel,
             kmesh=self.kmesh,
+            ibz=self.ibz,
             gamma=True,
             efermi=self.efermi,
             use_cache=self._use_cache,

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

@@ -31,6 +31,7 @@ class ExchangeParams:
     output_path: str = "TB2J_results"
     mae_angles = None
     orth = False
+    ibz = False
 
     def __init__(
         self,
@@ -53,6 +54,7 @@ class ExchangeParams:
         exclude_orbs=[],
         mae_angles=None,
         orth=False,
+        ibz=False,
     ):
         self.efermi = efermi
         self.basis = basis
@@ -76,6 +78,7 @@ class ExchangeParams:
         self.output_path = output_path
         self.mae_angles = mae_angles
         self.orth = orth
+        self.ibz = ibz
 
     def set_params(self, **kwargs):
         for key, val in kwargs.items():
@@ -92,8 +95,6 @@ class ExchangeParams:
             include_orbs = {}
         if isinstance(magnetic_elements, str):
             magnetic_elements = [magnetic_elements]
-        print(f"magnetic_elements: {magnetic_elements}")
-        print(f"include_orbs: {include_orbs}")
         for element in magnetic_elements:
             if "_" in element:
                 elem = element.split("_")[0]
@@ -102,8 +103,6 @@ class ExchangeParams:
             else:
                 include_orbs[element] = None
 
-        print(f"magnetic_elements: {magnetic_elements}")
-        print(f"include_orbs: {include_orbs}")
         magnetic_elements = list(include_orbs.keys())
         return magnetic_elements, include_orbs
 
@@ -214,6 +213,14 @@ def add_exchange_args_to_parser(parser: argparse.ArgumentParser):
         action="store_true",
         default=False,
     )
+
+    parser.add_argument(
+        "--ibz",
+        help=" use irreducible k-points in the Brillouin zone. (Note: only for computing total MAE).",
+        action="store_true",
+        default=False,
+    )
+
     return parser
 
 

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

@@ -7,11 +7,11 @@ from collections import defaultdict
 from shutil import rmtree
 
 import numpy as np
-from HamiltonIO.model.occupations import Occupations
+from HamiltonIO.model.occupations import GaussOccupations
 from HamiltonIO.model.occupations import myfermi as fermi
 from pathos.multiprocessing import ProcessPool
 
-from TB2J.kpoints import monkhorst_pack
+from TB2J.kpoints import ir_kpts, monkhorst_pack
 
 # from TB2J.mathutils.fermi import fermi
 
@@ -40,7 +40,7 @@ def eigen_to_G(evals, evecs, efermi, energy):
     )
 
 
-def find_energy_ingap(evals, rbound, gap=4.0):
+def find_energy_ingap(evals, rbound, gap=2.0):
     """
     find a energy inside a gap below rbound (right bound),
     return the energy gap top - 0.5.
@@ -59,9 +59,11 @@ class TBGreen:
         self,
         tbmodel,
         kmesh=None,  # [ikpt, 3]
+        ibz=False,  # if True, will interpolate the Green's function at Ir-kpoints
         efermi=None,  # efermi
         gamma=False,
         kpts=None,
+        kweights=None,
         k_sym=False,
         use_cache=False,
         cache_path=None,
@@ -81,20 +83,61 @@ class TBGreen:
         self.cache_path = cache_path
         if use_cache:
             self._prepare_cache()
-        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 = np.array([1.0 / self.nkpts] * self.nkpts)
+        self.prepare_kpts(
+            kmesh=kmesh,
+            ibz=ibz,
+            gamma=gamma,
+            kpts=kpts,
+            kweights=kweights,
+            tbmodel=tbmodel,
+        )
+
         self.norb = tbmodel.norb
         self.nbasis = tbmodel.nbasis
         self.k_sym = k_sym
         self.nproc = nproc
         self._prepare_eigen()
 
+    def prepare_kpts(
+        self, kmesh=None, gamma=True, ibz=False, kpts=None, kweights=None, tbmodel=None
+    ):
+        """
+        Prepare the k-points for the calculation.
+
+        Parameters:
+        - kmesh (tuple): The k-mesh used to generate k-points.
+        - gamma (bool): Whether to include the gamma point in the k-points.
+        - ibz (bool): Whether to use the irreducible Brillouin zone.
+        - kpts (list): List of user-defined k-points.
+        - kweights (list): List of weights for each k-point.
+
+        Returns:
+        None
+        """
+        if kpts is not None:
+            self.kpts = kpts
+            self.nkpts = len(self.kpts)
+            self.kweights = kweights
+        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
+                )
+                self.nkpts = len(self.kpts)
+                print(f"Using IBZ of kmesh of {kmesh}")
+                print(f"Number of kpts: {self.nkpts}")
+                for kpt, weight in zip(self.kpts, self.kweights):
+                    # format the kpt and weight, use 5 digits
+                    print(f"{kpt[0]:8.5f} {kpt[1]:8.5f} {kpt[2]:8.5f} {weight:8.5f}")
+            else:
+                self.kpts = monkhorst_pack(kmesh, gamma_center=gamma)
+                self.nkpts = len(self.kpts)
+                self.kweights = np.array([1.0 / self.nkpts] * self.nkpts)
+        else:
+            self.kpts = tbmodel.get_kpts()
+            self.nkpts = len(self.kpts)
+            self.kweights = np.array([1.0 / self.nkpts] * self.nkpts)
+
     def _reduce_eigens(self, evals, evecs, emin, emax):
         ts = np.logical_and(evals >= emin, evals < emax)
         ts = np.any(ts, axis=0)
@@ -106,7 +149,7 @@ class TBGreen:
         istart, iend = ts[0], ts[-1] + 1
         return evals[:, istart:iend], evecs[:, :, istart:iend]
 
-    def find_energy_ingap(self, rbound, gap=4.0):
+    def find_energy_ingap(self, rbound, gap=2.0):
         return find_energy_ingap(self.evals, rbound, gap)
 
     def _prepare_cache(self):
@@ -165,7 +208,14 @@ class TBGreen:
         if self.efermi is None:
             print("Calculating Fermi energy from eigenvalues")
             print(f"Number of electrons: {self.tbmodel.nel} ")
-            occ = Occupations(
+
+            # 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}")
+
+            occ = GaussOccupations(
                 nel=self.tbmodel.nel, width=0.1, wk=self.kweights, nspin=2
             )
             self.efermi = occ.efermi(copy.deepcopy(self.evals))
@@ -360,7 +410,6 @@ class TBGreen:
             for iR, R in enumerate(Rpts):
                 phase = np.exp(self.k2Rfactor * np.dot(R, kpt))
                 GR[R] += Gkw * (phase * self.kweights[ik])
-
                 dHRdx = dHdx.get_hamR(R)
                 dGRdx[R] += Gkw @ dHRdx @ Gk
                 # dGRdx[R] += Gk.dot(dHRdx).dot(Gkp)

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

@@ -74,6 +74,7 @@ def gen_exchange_siesta(fdf_fname, read_H_soc=False, **kwargs):
         output_path="TB2J_results",
         orb_decomposition=False,
         orth=False,
+        ibz=False,
         description="",
     )
     exargs.update(kwargs)

tb2j-0.9.9rc5/TB2J/kpoints.py

@@ -0,0 +1,87 @@
+from collections import Counter
+
+import numpy as np
+import spglib
+
+
+def monkhorst_pack(size, gamma_center=False):
+    """Construct a uniform sampling of k-space of given size.
+    Modified from ase.dft.kpoints with gamma_center option added"""
+    if np.less_equal(size, 0).any():
+        raise ValueError("Illegal size: %s" % list(size))
+    kpts = np.indices(size).transpose((1, 2, 3, 0)).reshape((-1, 3))
+    asize = np.array(size)
+    shift = 0.5 * ((asize + 1) % 2) / asize
+    mkpts = (kpts + 0.5) / size - 0.5
+    if gamma_center:
+        mkpts += shift
+    return mkpts
+
+
+def get_ir_kpts(atoms, mesh):
+    """
+    Gamma-centered IR kpoints. mesh : [nk1,nk2,nk3].
+    """
+    lattice = atoms.get_cell()
+    positions = atoms.get_scaled_positions()
+    numbers = atoms.get_atomic_numbers()
+
+    cell = (lattice, positions, numbers)
+    mapping, grid = spglib.get_ir_reciprocal_mesh(mesh, cell, is_shift=[0, 0, 0])
+    return grid[np.unique(mapping)] / np.array(mesh, dtype=float)
+
+
+def ir_kpts(
+    atoms, mp_grid, is_shift=[0, 0, 0], verbose=True, ir=True, is_time_reversal=False
+):
+    """
+    generate kpoints for structure
+    Parameters:
+    ------------------
+    atoms: ase.Atoms
+      structure
+    mp_grid: [nk1,nk2,nk3]
+    is_shift: shift of k points. default is Gamma centered.
+    ir: bool
+    Irreducible or not.
+    """
+    cell = (atoms.get_cell(), atoms.get_scaled_positions(), atoms.get_atomic_numbers())
+    # print(spglib.get_spacegroup(cell, symprec=1e-5))
+    mesh = mp_grid
+    # Gamma centre mesh
+    mapping, grid = spglib.get_ir_reciprocal_mesh(
+        mesh, cell, is_shift=is_shift, is_time_reversal=is_time_reversal, symprec=1e-4
+    )
+    if not ir:
+        return (np.array(grid).astype(float) + np.asarray(is_shift) / 2.0) / mesh, [
+            1.0 / len(mapping)
+        ] * len(mapping)
+    # All k-points and mapping to ir-grid points
+    # for i, (ir_gp_id, gp) in enumerate(zip(mapping, grid)):
+    #    print("%3d ->%3d %s" % (i, ir_gp_id, gp.astype(float) / mesh))
+    cnt = Counter(mapping)
+    ids = list(cnt.keys())
+    weight = list(cnt.values())
+    weight = np.array(weight) * 1.0 / sum(weight)
+    ird_kpts = [
+        (grid[id].astype(float) + np.asarray(is_shift) / 2.0) / mesh for id in ids
+    ]
+
+    # 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
+
+
+def test_ir_kpts():
+    from ase.build import bulk
+
+    atoms = bulk("Si")
+    mesh = [14, 14, 14]
+    kpts = get_ir_kpts(atoms, mesh)
+    print(kpts)
+    print(len(kpts))
+
+
+if __name__ == "__main__":
+    test_ir_kpts()

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

@@ -1,12 +1,15 @@
-from sympair import SymmetryPairFinder, SymmetryPairGroupDict
-import numpy as np
+import copy
 from pathlib import Path
+
+import numpy as np
+from sympair import SymmetryPairFinder
+
+from TB2J.io_exchange import SpinIO
 from TB2J.versioninfo import print_license
-import copy
 
 
 class TB2JSymmetrizer:
-    def __init__(self, exc, symprec=1e-8, verbose=True):
+    def __init__(self, exc, symprec=1e-8, verbose=True, Jonly=False):
         # list of pairs with the index of atoms
         ijRs = exc.ijR_list_index_atom()
         finder = SymmetryPairFinder(atoms=exc.atoms, pairs=ijRs, symprec=symprec)
@@ -28,10 +31,11 @@ class TB2JSymmetrizer:
             print(f"Finding crystal symmetry with symprec of {symprec} Angstrom.")
             print("Symmetry found:")
             print(finder.spacegroup)
-            print(f"-" * 30)
+            print("-" * 30)
         self.pgdict = finder.get_symmetry_pair_group_dict()
         self.exc = exc
         self.new_exc = copy.deepcopy(exc)
+        self.Jonly = Jonly
 
     def print_license(self):
         print_license()
@@ -41,8 +45,8 @@ class TB2JSymmetrizer:
         Symmetrize the exchange parameters J.
         """
         symJdict = {}
-        Jdict = self.exc.exchange_Jdict
-        ngroup = self.pgdict
+        # Jdict = self.exc.exchange_Jdict
+        # ngroup = self.pgdict
         for pairgroup in self.pgdict.groups:
             ijRs = pairgroup.get_all_ijR()
             ijRs_spin = [self.exc.ijR_index_atom_to_spin(*ijR) for ijR in ijRs]
@@ -51,6 +55,14 @@ class TB2JSymmetrizer:
             for i, j, R in ijRs_spin:
                 symJdict[(R, i, j)] = Javg
         self.new_exc.exchange_Jdict = symJdict
+        if self.Jonly:
+            self.new_exc.has_dmi = False
+            self.new_exc.dmi_ddict = None
+            self.new_exc.has_bilinear = False
+            self.new_exc.Jani_dict = None
+            self.has_uniaxial_anisotropy = False
+            self.k1 = None
+            self.k1dir = None
 
     def output(self, path="TB2J_symmetrized"):
         if path is None:
@@ -72,6 +84,7 @@ def symmetrize_J(
     fname="TB2J.pickle",
     symprec=1e-5,
     output_path="TB2J_symmetrized",
+    Jonly=False,
 ):
     """
     symmetrize the exchange parameters
@@ -80,7 +93,7 @@ def symmetrize_J(
     """
     if exc is None:
         exc = SpinIO.load_pickle(path=path, fname=fname)
-    symmetrizer = TB2JSymmetrizer(exc, symprec=symprec)
+    symmetrizer = TB2JSymmetrizer(exc, symprec=symprec, Jonly=Jonly)
     symmetrizer.run(path=output_path)
 
 
@@ -109,11 +122,23 @@ def symmetrize_J_cli():
         default=1e-5,
         help="precision for symmetry detection. default is 1e-5 Angstrom",
     )
+
+    parser.add_argument(
+        "-Jonly",
+        action="store_true",
+        help="Symmetrize only the exchange parameters. Do not output DMI and anisotropic exchange.",
+    )
+
     args = parser.parse_args()
     if args.inpath is None:
         parser.print_help()
         raise ValueError("Please provide the input path to the exchange.")
-    symmetrize_J(path=args.inpath, output_path=args.outpath, symprec=args.symprec)
+    symmetrize_J(
+        path=args.inpath,
+        output_path=args.outpath,
+        symprec=args.symprec,
+        Jonly=args.Jonly,
+    )
 
 
 if __name__ == "__main__":

{tb2j-0.9.9rc3 → tb2j-0.9.9rc5}/TB2J/versioninfo.py

@@ -1,6 +1,7 @@
-import TB2J
 from datetime import datetime
 
+import TB2J
+
 
 def print_license():
     print(

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: TB2J
-Version: 0.9.9rc3
+Version: 0.9.9rc5
 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.9rc3 → tb2j-0.9.9rc5}/setup.py

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

tb2j-0.9.9rc3/TB2J/kpoints.py

@@ -1,16 +0,0 @@
-import numpy as np
-
-
-def monkhorst_pack(size, gamma_center=False):
-    """Construct a uniform sampling of k-space of given size.
-    Modified from ase.dft.kpoints with gamma_center option added"""
-    if np.less_equal(size, 0).any():
-        raise ValueError("Illegal size: %s" % list(size))
-    kpts = np.indices(size).transpose((1, 2, 3, 0)).reshape((-1, 3))
-    asize = np.array(size)
-    shift = 0.5 * ((asize + 1) % 2) / asize
-    mkpts = (kpts + 0.5) / size - 0.5
-    if gamma_center:
-        mkpts += shift
-
-    return mkpts