TB2J 0.9.9rc12__tar.gz → 0.9.9rc14__tar.gz

{tb2j-0.9.9rc12 → tb2j-0.9.9rc14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: TB2J
-Version: 0.9.9rc12
+Version: 0.9.9rc14
 Summary: TB2J: First principle to Heisenberg exchange J using tight-binding Green function method
 Author: Xu He
 Author-email: mailhexu@gmail.com
@@ -21,10 +21,9 @@ Requires-Dist: ase>=3.19
 Requires-Dist: tqdm
 Requires-Dist: pathos
 Requires-Dist: packaging>=20.0
-Requires-Dist: HamiltonIO>=0.1.10
+Requires-Dist: HamiltonIO>=0.2.1
 Requires-Dist: pre-commit
 Requires-Dist: sympair>0.1.0
-Requires-Dist: sisl>=0.9.0
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

{tb2j-0.9.9rc12 → tb2j-0.9.9rc14}/TB2J/exchange.py

@@ -1,6 +1,6 @@
 import os
 import pickle
-from collections import defaultdict
+from collections import OrderedDict, defaultdict
 
 import numpy as np
 from tqdm import tqdm
@@ -96,96 +96,78 @@ class Exchange(ExchangeParams):
 
     def _prepare_orb_dict(self):
         """
-        Generate orbital and magnetic atom mappings needed for exchange calculations.
-
-        Creates:
-        - self.orb_dict: Maps atom indices to their orbital indices
-        - self.labels: Maps atom indices to their orbital labels
-        - self.ind_mag_atoms: List of indices of magnetic atoms
-        - self._spin_dict: Maps atom indices to spin indices
-        - self._atom_dict: Maps spin indices back to atom indices
-        """
-        self._create_orbital_mappings()
-        self._identify_magnetic_atoms()
-        self._validate_orbital_assignments()
-        self._create_spin_mappings()
-        self._prepare_orb_mmat()
-
-    def _create_orbital_mappings(self):
-        """Create mappings between atoms and their orbitals."""
-        self.orb_dict = {}  # {atom_index: [orbital_indices]}
-        self.labels = {}  # {atom_index: [orbital_labels]}
-        atom_symbols = symbol_number(self.atoms)
-
-        for orb_idx, base in enumerate(self.basis):
-            if orb_idx in self.exclude_orbs:
-                continue
+        generate self.ind_mag_atoms and self.orb_dict
+        """
+        # adict: dictionary of {'Fe': ['dxy', 'dyz', ...], ...}
+        adict = OrderedDict()
+        # orb_dict: {ind_atom:[ind_orb,1,2], ...}
+        self.orb_dict = {}
+        # labels: {0:{dxy, ...}}
+        self.labels = {}
+        # magnetic atoms index
+        self.ind_mag_atoms = []
+
+        sdict = symbol_number(self.atoms)
+
+        for i, base in enumerate(self.basis):
+            if i not in self.exclude_orbs:
+                # e.g. Fe2, dxy, _, _
+                if isinstance(base, str):
+                    atom_sym, orb_sym = base.split("|")[:2]
+                    iatom = sdict[atom_sym]
+                else:
+                    try:
+                        atom_sym, orb_sym = base[:2]
+                        iatom = sdict[atom_sym]
+                    except Exception:
+                        iatom = base.iatom
+                        atom_sym = base.iatom
+                        orb_sym = base.sym
+
+                if atom_sym in adict:
+                    adict[atom_sym].append(orb_sym)
+                else:
+                    adict[atom_sym] = [orb_sym]
+                if iatom not in self.orb_dict:
+                    self.orb_dict[iatom] = [i]
+                    self.labels[iatom] = [orb_sym]
+                else:
+                    self.orb_dict[iatom] += [i]
+                    self.labels[iatom] += [orb_sym]
 
-            # Extract atom and orbital info
-            if isinstance(base, str):
-                atom_sym, orb_sym = base.split("|")[:2]
-                atom_idx = atom_symbols[atom_sym]
-            else:
-                try:
-                    atom_sym, orb_sym = base[:2]
-                    atom_idx = atom_symbols[atom_sym]
-                except Exception:
-                    atom_idx = base.iatom
-                    atom_sym = base.iatom
-                    orb_sym = base.sym
-
-            # Update orbital mappings
-            if atom_idx not in self.orb_dict:
-                self.orb_dict[atom_idx] = [orb_idx]
-                self.labels[atom_idx] = [orb_sym]
-            else:
-                self.orb_dict[atom_idx].append(orb_idx)
-                self.labels[atom_idx].append(orb_sym)
+        # index of magnetic atoms
+        symbols = self.atoms.get_chemical_symbols()
+        tags = self.atoms.get_tags()
+        for i, (sym, tag) in enumerate(zip(symbols, tags)):
+            if sym in self.magnetic_elements or f"{sym}{tag}" in self.magnetic_elements:
+                self.ind_mag_atoms.append(i)
 
-    def _identify_magnetic_atoms(self):
-        """Identify which atoms are magnetic based on elements/tags."""
-        if self.index_magnetic_atoms is not None:
-            self.ind_mag_atoms = self.index_magnetic_atoms
-        else:
-            self.ind_mag_atoms = []
-            symbols = self.atoms.get_chemical_symbols()
-            tags = self.atoms.get_tags()
-
-            for atom_idx, (sym, tag) in enumerate(zip(symbols, tags)):
-                if (
-                    sym in self.magnetic_elements
-                    or f"{sym}{tag}" in self.magnetic_elements
-                ):
-                    self.ind_mag_atoms.append(atom_idx)
-        print(f"Magnetic atoms: {self.ind_mag_atoms}")
-
-    def _validate_orbital_assignments(self):
-        """Validate that magnetic atoms have proper orbital assignments."""
-        # Check all magnetic atoms have orbitals
-        for atom_idx in self.ind_mag_atoms:
-            if atom_idx not in self.orb_dict:
+        # sanity check to see if some magnetic atom has no orbital.
+        for iatom in self.ind_mag_atoms:
+            if iatom not in self.orb_dict:
                 raise ValueError(
-                    f"Atom {atom_idx} is magnetic but has no orbitals assigned. "
-                    "Check Wannier function definitions."
+                    f"""Cannot find any orbital for atom {iatom}, which is supposed to be magnetic. Please check the Wannier functions."""
                 )
-
-        # For non-collinear case, check spin-orbital pairing
         if not self._is_collinear:
-            for atom_idx, orbitals in self.orb_dict.items():
-                if len(orbitals) % 2 != 0:
+            for iatom, orb in self.orb_dict.items():
+                # print(f"iatom: {iatom}, orb: {orb}")
+                nsorb = len(self.orb_dict[iatom])
+                if nsorb % 2 != 0 and False:
                     raise ValueError(
-                        f"Atom {atom_idx} has {len(orbitals)} spin-orbitals "
-                        "(should be even). Check Wannier function localization."
+                        f"""The number of spin-orbitals for atom {iatom} is not even,
+{nsorb} spin-orbitals are found near this atom.
+which means the spin up/down does not have same number of orbitals.
+This is often because the Wannier functions are wrongly defined,
+or badly localized. Please check the Wannier centers in the Wannier90 output file.
+"""
                     )
+        self._spin_dict = {}
+        self._atom_dict = {}
+        for ispin, iatom in enumerate(self.ind_mag_atoms):
+            self._spin_dict[iatom] = ispin
+            self._atom_dict[ispin] = iatom
 
-    def _create_spin_mappings(self):
-        """Create mappings between atom indices and spin indices."""
-        self._spin_dict = {}  # {atom_index: spin_index}
-        self._atom_dict = {}  # {spin_index: atom_index}
-
-        for spin_idx, atom_idx in enumerate(self.ind_mag_atoms):
-            self._spin_dict[atom_idx] = spin_idx
-            self._atom_dict[spin_idx] = atom_idx
+        self._prepare_orb_mmat()
 
     def _prepare_orb_mmat(self):
         self.mmats = {}

{tb2j-0.9.9rc12 → tb2j-0.9.9rc14}/TB2J/exchange_params.py

@@ -15,7 +15,6 @@ class ExchangeParams:
     efermi: float
     basis = []
     magnetic_elements = []
-    index_magnetic_atoms = None
     include_orbs = {}
     _kmesh = [4, 4, 4]
     emin: float = -15
@@ -56,7 +55,6 @@ class ExchangeParams:
         mae_angles=None,
         orth=False,
         ibz=False,
-        index_magnetic_atoms=None,
     ):
         self.efermi = efermi
         self.basis = basis
@@ -81,7 +79,6 @@ class ExchangeParams:
         self.mae_angles = mae_angles
         self.orth = orth
         self.ibz = ibz
-        self.index_magnetic_atoms = index_magnetic_atoms
 
     def set_params(self, **kwargs):
         for key, val in kwargs.items():
@@ -232,21 +229,6 @@ def add_exchange_args_to_parser(parser: argparse.ArgumentParser):
         default=False,
     )
 
-    parser.add_argument(
-        "--mae_angles",
-        help="angles for computing MAE, default is 0 0 0",
-        type=float,
-        nargs="*",
-        default=[0.0, 0.0, 0.0],
-    )
-    parser.add_argument(
-        "--index_magnetic_atoms",
-        help="index of magnetic atoms in the unit cell, default is None. If specified, this will be used to determine the atoms to be considered as magnetic atoms, instead of determined from magnetic elements. Note that the index starts from 1 ",
-        type=int,
-        nargs="*",
-        default=None,
-    )
-
     return parser
 
 
@@ -268,5 +250,4 @@ def parser_argument_to_dict(args) -> dict:
         "orb_decomposition": args.orb_decomposition,
         "output_path": args.output_path,
         "orth": args.orth,
-        "index_magnetic_atoms": args.index_magnetic_atoms,
     }

{tb2j-0.9.9rc12 → tb2j-0.9.9rc14}/TB2J/io_exchange/io_exchange.py

@@ -8,16 +8,13 @@ write not only xml output.
 - tom's asd inputs.
 """
 
+# matplotlib.use("Agg")
+import gc
 import os
 import pickle
 from collections.abc import Iterable
 from datetime import datetime
 
-import matplotlib
-
-matplotlib.use("Agg")
-import gc
-
 import matplotlib.pyplot as plt
 import numpy as np
 

{tb2j-0.9.9rc12 → tb2j-0.9.9rc14}/TB2J/rotate_atoms.py

@@ -15,7 +15,6 @@ def rotate_atom_xyz(atoms, noncollinear=False):
     will be generated.
     """
 
-    yield atoms
     rotation_axes = [(1, 0, 0), (0, 1, 0)]
     if noncollinear:
         rotation_axes += [(1, 1, 0), (1, 0, 1), (0, 1, 1)]
@@ -24,7 +23,6 @@ def rotate_atom_xyz(atoms, noncollinear=False):
         rotated_atoms = copy.deepcopy(atoms)
         rotated_atoms.rotate(90, axis, rotate_cell=True)
         yield rotated_atoms
-    yield atoms 
 
 
 def rotate_atom_spin_one_rotation(atoms, Rotation):
@@ -111,5 +109,7 @@ def rotate_xyz(fname, ftype="xyz", noncollinear=False):
     rotated = rotate_atom_xyz(atoms, noncollinear=noncollinear)
 
     for i, rotated_atoms in enumerate(rotated):
-        write(f"atoms_{i}.{ftype}", rotated_atoms)
+        write(f"atoms_{i+1}.{ftype}", rotated_atoms)
+    write(f"atoms_0.{ftype}", atoms)
+
     print(f"The output has been written to the atoms_i.{ftype} files. atoms_0.{ftype} contains the reference structure.")

{tb2j-0.9.9rc12 → tb2j-0.9.9rc14}/TB2J/rotate_siestaDM.py

@@ -1,28 +1,28 @@
 import sisl
 
-
 def rotate_siesta_DM(DM, noncollinear=False):
-    angles_list = [[0.0, 90.0, 0.0], [0.0, 90.0, 90.0]]
+    
+    angles_list = [ [0.0, 90.0, 0.0], [0.0, 90.0, 90.0] ]
     if noncollinear:
         angles_list += [[0.0, 45.0, 0.0], [0.0, 90.0, 45.0], [0.0, 45.0, 90.0]]
 
     for angles in angles_list:
         yield DM.spin_rotate(angles)
 
-
 def read_label(fdf_fname):
-    label = "siesta"
-    with open(fdf_fname, "r") as File:
+
+    label = 'siesta'
+    with open(fdf_fname, 'r') as File:
         for line in File:
-            corrected_line = line.lower().replace(".", "").replace("-", "")
-            if "systemlabel" in corrected_line:
+            corrected_line = line.lower().replace('.', '').replace('-', '')
+            if 'systemlabel' in corrected_line:
                 label = line.split()[1]
                 break
 
     return label
 
-
 def rotate_DM(fdf_fname, noncollinear=False):
+
     fdf = sisl.get_sile(fdf_fname)
     DM = fdf.read_density_matrix()
     label = read_label(fdf_fname)
@@ -33,6 +33,4 @@ def rotate_DM(fdf_fname, noncollinear=False):
         rotated_DM.write(f"{label}_{i+1}.DM")
     DM.write(f"{label}_0.DM")
 
-    print(
-        f"The output has been written to the {label}_i.DM files. {label}_0.DM contains the reference density matrix."
-    )
+    print(f"The output has been written to the {label}_i.DM files. {label}_0.DM contains the reference density matrix.")

{tb2j-0.9.9rc12 → tb2j-0.9.9rc14}/TB2J.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: TB2J
-Version: 0.9.9rc12
+Version: 0.9.9rc14
 Summary: TB2J: First principle to Heisenberg exchange J using tight-binding Green function method
 Author: Xu He
 Author-email: mailhexu@gmail.com
@@ -21,10 +21,9 @@ Requires-Dist: ase>=3.19
 Requires-Dist: tqdm
 Requires-Dist: pathos
 Requires-Dist: packaging>=20.0
-Requires-Dist: HamiltonIO>=0.1.10
+Requires-Dist: HamiltonIO>=0.2.1
 Requires-Dist: pre-commit
 Requires-Dist: sympair>0.1.0
-Requires-Dist: sisl>=0.9.0
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

{tb2j-0.9.9rc12 → tb2j-0.9.9rc14}/TB2J.egg-info/SOURCES.txt

@@ -106,8 +106,6 @@ docs/conf.py
 docs/index.rst
 docs/make.bat
 docs/requirements.txt
-docs/_static/Logo-ULG.png
-docs/_static/logo_TB2J_horizon.png
 docs/src/BFOvarT.png
 docs/src/Contributors.rst
 docs/src/ReleaseNotes.md

{tb2j-0.9.9rc12 → tb2j-0.9.9rc14}/TB2J.egg-info/requires.txt

@@ -5,7 +5,6 @@ ase>=3.19
 tqdm
 pathos
 packaging>=20.0
-HamiltonIO>=0.1.10
+HamiltonIO>=0.2.1
 pre-commit
 sympair>0.1.0
-sisl>=0.9.0

{tb2j-0.9.9rc12 → tb2j-0.9.9rc14}/docs/conf.py

@@ -59,9 +59,3 @@ html_theme = "sphinx_rtd_theme"
 # relative to this directory. They are copied after the builtin static files,
 # so a file named "default.css" will overwrite the builtin "default.css".
 html_static_path = ["_static"]
-
-html_logo = "_static/TB2J_logo_horizon.png"
-html_theme_options = {
-    "logo_only": True,
-    "display_version": False,
-}

{tb2j-0.9.9rc12 → tb2j-0.9.9rc14}/docs/src/Contributors.rst

@@ -1,7 +1,7 @@
 Contributors
 ============
 
-The TB2J package is initially developed:
+The TB2J package is initially developped:
 
 * Xu He (mailhexu@gmail.com)
 

{tb2j-0.9.9rc12 → tb2j-0.9.9rc14}/docs/src/ReleaseNotes.md

@@ -11,9 +11,7 @@ This currently requires an non-official SIESTA branch which can seperate the spi
 
 - An improved method of the downfolding method which implements the ligand correction to the exchange based on the Wannier function method. This requires the updated version of LaWaF (https://github.com/mailhexu/lawaf) and the updated version of the TB2J\_downfold.py script.
 
-- Added a new parameter (--index_magnetic_atoms) to the wann2J.py, siesta2J.py, and abacus2J.py scripts, so that a more detailed selection of the magnetic atoms than the one in --element is possible. This is useful when we need to select a subset of a specific element in a system.
-
-- There is a major refactoring of the interface to the DFT codes. The parsing of the electron Hamiltonian from the DFT codes are now in a separate python package called HamiltonIO (github.com/mailhexu/HamiltonIO). This package is used by TB2J but is made general to be used with other packages too.
+- There is a major refractoring of the interface to the DFT codes. The parsing of the electron Hamiltonian from the DFT codes are now in a separate python package called HamiltonIO (github.com/mailhexu/HamiltonIO). This package is used by TB2J but is made general to be used with other packages too.
 
 
 #### v0.11.0 October 10, 2024

tb2j-0.9.9rc14/docs/src/parameters.rst

@@ -0,0 +1,28 @@
+Parameters in calculation of magnetic interaction parameters
+=============================================================
+
+List of parameters:
+-------------------------------
+The list of parameter can be found using:
+
+::
+
+   wann2J.py --help
+
+or
+
+::
+
+   siesta2J.py --help
+
+The parameter will be explained in the following text.
+
+* kmesh: Three integers to specify the size of a Monkhorst-Pack mesh. This is the mesh of k-points used to calculate the Green's functions. The real space supercell in which the magnetic interactions are calculated, has the same size as the k-mesh. For example, a :math:`7 \times 7 \times` k-mesh is linked with a :math:`7 \times 7 \times` supercell, the atom :math:`i` resides in the center cell, whereas the :math:`j` atom can be in all the cells in the supercell. 
+
+* efermi: The Fermi energy in eV. For insulators, it can be inside the gap. For metals, it should be the same as in the DFT calculation. Due to the different algorithms in the integration of the density, the Fermi energy could be slightly shifted from the DFT value. 
+
+* emin, emax, and nz: During the calculation, there  is a integration :math:`\int_{emin}^{emax} d\epsilon` calculation. The emin and emax are relative values to the Fermi energy. The emax should be 0.   The emin should be low enough so that all the electronic states that affect the magnetic interactions are integrated. This can be checked with the local density of the states. Below the emin, the spin up and down density of states should be almost identical.  The nz is the number of steps in this integration.  The emax can be used to adjust the integration if we want to simulate the effect of the charge doping. This is with the approximation that there is only a rigid shift of the band structure. However, it is recommended to dope charge within the DFT then this approximation is not needed. The emax parameter will thus be deprecated soon.
+
+* rcut: rcut is the cutoff distance between two ion pairs between which the magnetic interaction parameters are calculated. By default, all the pairs inside the supercell defined by the kmesh 
+
+* exclude_orbs: the indeces of orbitals, whose contribution will not be counted in the magnetic interaction. It is a list of integers. The indices are zero based.

{tb2j-0.9.9rc12 → tb2j-0.9.9rc14}/requirements.txt

@@ -7,5 +7,4 @@ tqdm>=4.42.0
 pathos
 packaging>=20.0
 sympair>=0.1.0
-sisl>=0.9.0
 pre-commit

tb2j-0.9.9rc14/scripts/abacus2J.py

@@ -0,0 +1,146 @@
+#!/usr/bin/env python3
+import argparse
+import sys
+
+from TB2J.interfaces import gen_exchange_abacus
+from TB2J.versioninfo import print_license
+
+
+def run_abacus2J():
+    print_license()
+    parser = argparse.ArgumentParser(
+        description="abacus2J: Using magnetic force theorem to calculate exchange parameter J from abacus Hamiltonian in the LCAO mode"
+    )
+
+    parser.add_argument(
+        "--path", help="the path of the abacus calculation", default="./", type=str
+    )
+
+    parser.add_argument(
+        "--suffix",
+        help="the label of the abacus calculation. There should be an output directory called OUT.suffix",
+        default="abacus",
+        type=str,
+    )
+
+    parser.add_argument(
+        "--elements",
+        help="list of elements to be considered in Heisenberg model.",
+        # ,  For each element, a postfixes can be used to specify the orbitals(Only with Siesta backend), eg. Fe_3d, or Fe_3d_4s ",
+        default=None,
+        type=str,
+        nargs="*",
+    )
+    parser.add_argument(
+        "--rcut",
+        help="range of R. The default is all the commesurate R to the kmesh",
+        default=None,
+        type=float,
+    )
+    parser.add_argument(
+        "--efermi", help="Fermi energy in eV. For test only. ", default=None, type=float
+    )
+    parser.add_argument(
+        "--kmesh",
+        help="kmesh in the format of kx ky kz. Monkhorst pack. If all the numbers are odd, it is Gamma cenetered. (strongly recommended), Default: 5 5 5",
+        type=int,
+        nargs="*",
+        default=[5, 5, 5],
+    )
+    parser.add_argument(
+        "--emin",
+        help="energy minimum below efermi, default -14 eV",
+        type=float,
+        default=-14.0,
+    )
+
+    parser.add_argument(
+        "--use_cache",
+        help="whether to use disk file for temporary storing wavefunctions and hamiltonian to reduce memory usage. Default: False",
+        action="store_true",
+        default=False,
+    )
+
+    parser.add_argument(
+        "--nz", help="number of integration steps. Default: 50", default=50, type=int
+    )
+
+    parser.add_argument(
+        "--cutoff",
+        help="The minimum of J amplitude to write, (in eV). Default: 1e-7 eV",
+        default=1e-7,
+        type=float,
+    )
+
+    parser.add_argument(
+        "--exclude_orbs",
+        help="the indices of wannier functions to be excluded from magnetic site. counting start from 0. Default is none.",
+        default=[],
+        type=int,
+        nargs="+",
+    )
+
+    parser.add_argument(
+        "--nproc",
+        "--np",
+        help="number of cpu cores to use in parallel, default: 1",
+        default=1,
+        type=int,
+    )
+
+    parser.add_argument(
+        "--description",
+        help="add description of the calculatiion to the xml file. Essential information, like the xc functional, U values, magnetic state should be given.",
+        type=str,
+        default="Calculated with TB2J.",
+    )
+
+    parser.add_argument(
+        "--orb_decomposition",
+        default=False,
+        action="store_true",
+        help="whether to do orbital decomposition in the non-collinear mode. Default: False.",
+    )
+
+    parser.add_argument(
+        "--fname",
+        default="exchange.xml",
+        type=str,
+        help="exchange xml file name. default: exchange.xml",
+    )
+
+    parser.add_argument(
+        "--output_path",
+        help="The path of the output directory, default is TB2J_results",
+        type=str,
+        default="TB2J_results",
+    )
+
+    args = parser.parse_args()
+
+    if args.elements is None:
+        print("Please input the magnetic elements, e.g. --elements Fe Ni")
+        sys.exit()
+
+    # include_orbs = {}
+
+    gen_exchange_abacus(
+        path=args.path,
+        suffix=args.suffix,
+        kmesh=args.kmesh,
+        magnetic_elements=args.elements,
+        include_orbs={},
+        Rcut=args.rcut,
+        emin=args.emin,
+        nz=args.nz,
+        description=args.description,
+        output_path=args.output_path,
+        use_cache=args.use_cache,
+        nproc=args.nproc,
+        exclude_orbs=args.exclude_orbs,
+        orb_decomposition=args.orb_decomposition,
+    )
+
+
+if __name__ == "__main__":
+    run_abacus2J()