TB2J 0.9.8rc0__tar.gz → 0.9.9rc0__tar.gz

{tb2j-0.9.8rc0 → tb2j-0.9.9rc0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: TB2J
-Version: 0.9.8rc0
+Version: 0.9.9rc0
 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.9rc0/TB2J/MAEGreen.py

@@ -0,0 +1,197 @@
+from pathlib import Path
+
+import numpy as np
+import tqdm
+from typing_extensions import DefaultDict
+
+from HamiltonIO.abacus.abacus_wrapper import AbacusSplitSOCParser
+from TB2J.exchange import ExchangeNCL
+
+# 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
+from TB2J.mathutils.rotate_spin import (
+    rotate_spinor_matrix,
+)
+
+
+class MAEGreen(ExchangeNCL):
+    def __init__(self, angles=[], **kwargs):
+        super().__init__(**kwargs)
+        self.natoms = len(self.atoms)
+        nangles = len(angles[0])
+        self.es = np.zeros(nangles, dtype=complex)
+        self.es_atom = np.zeros((nangles, self.natoms), dtype=complex)
+        self.es_atom_orb = DefaultDict(lambda: 0)
+        if angles is None or angles == "axis":
+            self.set_angles_axis()
+        elif angles == "scan":
+            self.set_angles_scan()
+        else:
+            self.thetas = angles[0]
+            self.phis = angles[1]
+
+    def set_angles_axis(self):
+        """theta and phi are defined as the x, y, z, axis."""
+        self.thetas = [0, np.pi / 2, np.pi / 2, np.pi / 2]
+        self.phis = [0, 0, np.pi / 2, np.pi / 4]
+
+    def set_angles_scan(self, step=15):
+        self.thetas = []
+        self.phis = []
+        for i in range(0, 181, step):
+            for j in range(0, 181, step):
+                self.thetas.append(i * np.pi / 180)
+                self.phis.append(j * np.pi / 180)
+
+    def get_perturbed(self, e, thetas, phis):
+        self.tbmodel.set_so_strength(0.0)
+        G0K = self.G.get_Gk_all(e)
+        Hsoc_k = self.tbmodel.get_Hk_soc(self.G.kpts)
+        na = len(thetas)
+        dE_angle = np.zeros(na, dtype=complex)
+        dE_angle_atom = np.zeros((na, self.natoms), dtype=complex)
+        # dE_angle_orbitals = np.zeros((na, self.natoms, self.norb, self.norb), dtype=complex)
+        # dE_angle_orbitals = DefaultDict(lambda: 0)
+        dE_angle_atom_orb = DefaultDict(lambda: 0)
+        for iangle, (theta, phi) in enumerate(zip(thetas, phis)):
+            for ik, dHk in enumerate(Hsoc_k):
+                dHi = rotate_spinor_matrix(dHk, theta, phi)
+                GdH = G0K[ik] @ dHi
+                # dE += np.trace(GdH @ G0K[i].T.conj() @ dHi) * self.kweights[i]
+                # diagonal of second order perturbation.
+                # dG2diag = np.diag(GdH @ GdH)
+                #dG2 = np.einsum("ij,ji->ij", GdH,   GdH)
+                dG2 = GdH * GdH.T
+                dG2sum = np.sum(dG2)
+
+                # dG2diag = np.diag(GdH @G0K[i].T.conj() @ dHi)
+                #dE_angle[iangle] += np.trace(GdH@GdH) * self.G.kweights[ik]
+                #dE_angle[iangle] += np.trace(GdH@G0K[ik].T.conj()@dHi ) * self.G.kweights[ik]
+                dE_angle[iangle] += dG2sum * self.G.kweights[ik]
+                for iatom in range(self.natoms):
+                    iorb = self.iorb(iatom)
+                    #dG2= dG2[::2, ::2] + dG2[1::2, 1::2] + dG2[1::2, ::2] + dG2[::2, 1::2]
+                    dE_atom_orb = dG2[np.ix_(iorb, iorb)] * self.G.kweights[ik]
+                    dE_atom_orb = dE_atom_orb[::2, ::2] + dE_atom_orb[1::2, 1::2] + dE_atom_orb[1::2, ::2] + dE_atom_orb[::2, 1::2]
+                    mmat = self.mmats[iatom]
+                    dE_atom_orb =  mmat.T @ dE_atom_orb @ mmat
+
+                    dE_angle_atom_orb[(iangle, iatom)] += dE_atom_orb
+
+                    dE_atom = np.sum(dE_atom_orb)
+                    dE_angle_atom[iangle, iatom] += dE_atom
+        return dE_angle, dE_angle_atom, dE_angle_atom_orb
+
+    def get_perturbed_R(self, e, thetas, phis):
+        self.tbmodel.set_so_strength(0.0)
+        # Here only the first R vector is considered.
+        # TODO: consider all R vectors.
+        # Rlist = np.zeros((1, 3), dtype=float)
+        # G0K = self.G.get_Gk_all(e)
+        # G0R = k_to_R(self.G.kpts, Rlist, G0K, self.G.kweights)
+        # dE_angle = np.zeros(len(thetas), dtype=complex)
+        # dE_angle_atoms = np.zeros((len(thetas), self.natoms), dtype=complex)
+        pass
+
+    def get_band_energy_vs_angles(self, 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 key, value in dE_angle_atom_orb.items():
+                self.es_atom_orb[key] += dE_angle_atom_orb[key] * self.contour.weights[ie]
+
+        self.es = -np.imag(self.es) / np.pi
+        self.es_atom = -np.imag(self.es_atom) / np.pi
+        for key, value in self.es_atom_orb.items():
+            self.es_atom_orb[key] = -np.imag(value) / np.pi
+
+    def output(self, output_path="TB2J_anisotropy"):
+        Path(output_path).mkdir(exist_ok=True)
+        fname = f"{output_path}/MAE.dat"
+        fname_orb = f"{output_path}/MAE_orb.dat"
+        with open(fname, "w") as f:
+            f.write("# theta, phi, MAE(total), MAE(atom-wise) Unit: meV\n")
+            for i, (theta, phi, e, es) in enumerate(
+                zip(self.thetas, self.phis, self.es, self.es_atom)
+            ):
+                f.write(f"{theta:.5f} {phi:.5f} {e*1e3:.8f} ")
+                for ea in es:
+                    f.write(f"{ea*1e3:.8f} ")
+                f.write("\n")
+
+        with open(fname_orb, "w") as f:
+            f.write("=" * 80 + "\n")
+            f.write("Orbitals for each atom: \n")
+            f.write("=" * 80 + "\n")
+            f.write("Note: the energies are in meV\n")
+            for iatom in range(self.natoms):
+                f.write(f"Atom {iatom:03d}: ")
+                for orb in self.orbital_names[iatom]:
+                    f.write(f"{orb} ")
+                f.write("\n")
+            for i, (theta, phi, e, eatom) in enumerate(
+                zip(self.thetas, self.phis, self.es, self.es_atom)
+            ):
+                f.write("-" * 60 + "\n")
+                f.write(f"Angle {i:03d}:   theta={theta:.5f} phi={phi:.5f} \n ")
+                f.write(f"E: {e*1e3:.8f} \n")
+                for iatom, ea in enumerate(eatom):
+                    f.write(f"Atom {iatom:03d}: {ea*1e3:.8f} \n")
+                    f.write("Orbital: ")
+                    eorb = self.es_atom_orb[(i, iatom)] 
+
+                    # write numpy matrix to file
+                    f.write(
+                        np.array2string(
+                            eorb*1e3, precision=4, separator=",", suppress_small=True
+                        )
+                    )
+
+                    eorb_diff = eorb -  self.es_atom_orb[(0, iatom)]
+                    f.write("Diference to the first angle: ")
+                    f.write(
+                        np.array2string(
+                            eorb_diff*1e3, precision=4, separator=",", suppress_small=True
+                        )
+                    )
+                f.write("\n")
+
+    def run(self, output_path="TB2J_anisotropy"):
+        self.get_band_energy_vs_angles(self.thetas, self.phis)
+        self.output(output_path=output_path)
+
+
+def abacus_get_MAE(
+    path_nosoc,
+    path_soc,
+    kmesh,
+    thetas,
+    phis,
+    gamma=True,
+    output_path="TB2J_anisotropy",
+    magnetic_elements=None,
+    nel=None,
+    width=0.1,
+    **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."""
+    parser = AbacusSplitSOCParser(
+        outpath_nosoc=path_nosoc, outpath_soc=path_soc, binary=False
+    )
+    model = parser.parse()
+    if nel is not None:
+        model.nel = nel
+    mae = MAEGreen(tbmodels=model, atoms = model.atoms, kmesh=kmesh, efermi=None,  basis=model.basis, angles=[thetas, phis], magnetic_elements=magnetic_elements, **kwargs)
+    mae.run(output_path=output_path)
+    #es = mae.get_band_energy_vs_angles(thetas, phis)
+    #if outfile:
+    #    with open(outfile, "w") as f:
+    #        f.write("#theta, phi, energy\n")
+    #        for theta, phi, e in zip(thetas, phis, es):
+    #            f.write(f"{theta:5.3f}, {phi:5.3f}, {e:10.9f}\n")
+    #return es
+
+

{tb2j-0.9.8rc0 → tb2j-0.9.9rc0}/TB2J/exchange.py

@@ -50,7 +50,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 - 5.0) - self.efermi
+        #self.emin = self.G.find_energy_ingap(rbound=self.efermi - 10.0) - self.efermi
+        self.emin = -12.0
         print(f"A gap is found at {self.emin}, set emin to it.")
 
     def set_tbmodels(self, tbmodels):
@@ -114,14 +115,19 @@ class Exchange(ExchangeParams):
                 # e.g. Fe2, dxy, _, _
                 if isinstance(base, str):
                     atom_sym, orb_sym = base.split("|")[:2]
+                    iatom = sdict[atom_sym]
                 else:
-                    atom_sym, orb_sym = base[:2]
+                    try:
+                        atom_sym, orb_sym = base[:2]
+                    except Exception as e:
+                        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]
-                iatom = sdict[atom_sym]
                 if iatom not in self.orb_dict:
                     self.orb_dict[iatom] = [i]
                     self.labels[iatom] = [orb_sym]
@@ -144,8 +150,9 @@ class Exchange(ExchangeParams):
                 )
         if not self._is_collinear:
             for iatom, orb in self.orb_dict.items():
+                print(f"iatom: {iatom}, orb: {orb}")
                 nsorb = len(self.orb_dict[iatom])
-                if nsorb % 2 != 0:
+                if nsorb % 2 != 0 and False:
                     raise ValueError(
                         f"""The number of spin-orbitals for atom {iatom} is not even,
 {nsorb} spin-orbitals are found near this atom.
@@ -166,7 +173,10 @@ or badly localized. Please check the Wannier centers in the Wannier90 output fil
         self.mmats = {}
         self.orbital_names = {}
         self.norb_reduced = {}
-        if self.backend_name.upper() == "SIESTA":
+        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}")
             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:
@@ -176,6 +186,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}")
                     mmat, reduced_orbs = map_orbs_matrix(
                         orbs, spinor=not (self._is_collinear), include_only=None
                     )
@@ -231,7 +242,7 @@ or badly localized. Please check the Wannier centers in the Wannier90 output fil
         """
         sum up the contribution of all the orbitals with same (n,l,m)
         """
-        if self.backend_name.upper() == "SIESTA":
+        if self.backend_name.upper() in ["SIESTA", "ABACUS", "LCAOHAMILTONIAN"]:
             mmat_i = self.mmats[iatom]
             mmat_j = self.mmats[jatom]
             Jorbij = mmat_i.T @ Jorbij @ mmat_j

{tb2j-0.9.8rc0 → tb2j-0.9.9rc0}/TB2J/exchange_params.py

@@ -56,8 +56,11 @@ class ExchangeParams:
     ):
         self.efermi = efermi
         self.basis = basis
-        self.magnetic_elements = magnetic_elements
-        self.include_orbs = include_orbs
+        # self.magnetic_elements = magnetic_elements
+        # self.include_orbs = include_orbs
+        self.magnetic_elements, self.include_orbs = self.set_magnetic_elements(
+            magnetic_elements, include_orbs
+        )
         self._kmesh = kmesh
         self.emin = emin
         self.emax = emax
@@ -82,6 +85,28 @@ class ExchangeParams:
         with open(fname, "w") as myfile:
             yaml.dump(self.__dict__, myfile)
 
+    def set_magnetic_elements(self, magnetic_elements, include_orbs):
+        # magnetic_elements = exargs.pop("magnetic_elements")
+        # include_orbs = exargs.pop("include_orbs")
+        if include_orbs is None:
+            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]
+                orb = element.split("_")[1:]
+                include_orbs[elem] = orb
+            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
+
 
 def add_exchange_args_to_parser(parser: argparse.ArgumentParser):
     parser.add_argument(

{tb2j-0.9.8rc0 → tb2j-0.9.9rc0}/TB2J/interfaces/abacus/abacus_wrapper.py

@@ -192,6 +192,7 @@ class AbacusParser:
     def read_basis(self):
         fname = str(Path(self.outpath) / "Orbital")
         self.basis = parse_abacus_orbital(fname)
+        print(self.basis)
         return self.basis
 
     def read_HSR_collinear(self, binary=None):

{tb2j-0.9.8rc0 → tb2j-0.9.9rc0}/TB2J/interfaces/abacus/gen_exchange_abacus.py

@@ -27,7 +27,7 @@ def gen_exchange_abacus(
     exclude_orbs=[],
     Rcut=None,
     use_cache=False,
-    np=1,
+    nproc=1,
     output_path="TB2J_results",
     orb_decomposition=False,
     description=None,
@@ -60,9 +60,10 @@ data directory: {outpath}
             nz=nz,
             exclude_orbs=exclude_orbs,
             Rcut=Rcut,
-            np=np,
+            nproc=nproc,
             use_cache=use_cache,
             output_path=output_path,
+            orb_decomposition=orb_decomposition,
             description=description,
         )
         exchange.run(path=output_path)
@@ -86,8 +87,9 @@ data directory: {outpath}
             nz=nz,
             exclude_orbs=exclude_orbs,
             Rcut=Rcut,
-            np=np,
+            nproc=nproc,
             use_cache=use_cache,
+            orb_decomposition=orb_decomposition,
             description=description,
         )
         exchange.run()

{tb2j-0.9.8rc0 → tb2j-0.9.9rc0}/TB2J/interfaces/abacus/orbital_api.py

@@ -16,13 +16,14 @@ class AbacusOrbital:
     Orbital class
     """
 
-    iatom: int
-    sym: str
-    spin: int
-    element: str
-    l: int
-    m: int
-    z: int
+    iatom: int = 0
+    sym: str = ""
+    spin: int = 0
+    element: str = ""
+    n: int = 0
+    l: int = 0
+    m: int = 0
+    z: int = 0
 
 
 def parse_abacus_orbital(fname):
@@ -38,10 +39,11 @@ def parse_abacus_orbital(fname):
             iatom, element, l, m, z, sym = seg
             iatom = int(iatom)
             ispin = 0
+            n = 0
             l = int(l)
             m = int(m)
             z = int(z)
-            orbs.append(AbacusOrbital(iatom, sym, ispin, element, l, m, z))
+            orbs.append(AbacusOrbital(iatom, sym, ispin, element, n, l, m, z))
             line = myfile.readline()
     return orbs
 

{tb2j-0.9.8rc0 → tb2j-0.9.9rc0}/TB2J/interfaces/siesta_interface.py

@@ -89,18 +89,6 @@ def gen_exchange_siesta(fdf_fname, read_H_soc=False, **kwargs):
             f"sisl version is {sisl.__version__}, but should be larger than 0.10.0."
         )
 
-    magnetic_elements = exargs.pop("magnetic_elements")
-    include_orbs = exargs.pop("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())
     output_path = exargs.pop("output_path")
 
     parser = SislParser(
@@ -122,8 +110,8 @@ def gen_exchange_siesta(fdf_fname, read_H_soc=False, **kwargs):
             atoms=tbmodel_up.atoms,
             basis=basis,
             efermi=0.0,
-            magnetic_elements=magnetic_elements,
-            include_orbs=include_orbs,
+            # magnetic_elements=exargs['magnetic_elements'],
+            # include_orbs=ex
             **exargs,
         )
         exchange.run(path=output_path)
@@ -149,8 +137,8 @@ Warning: The DMI component parallel to the spin orientation, the Jani which has
                 atoms=model.atoms,
                 basis=basis,
                 efermi=0.0,
-                magnetic_elements=magnetic_elements,
-                include_orbs=include_orbs,
+                # magnetic_elements=magnetic_elements,
+                # include_orbs=include_orbs,
                 output_path=output_path,
                 **exargs,
             )
@@ -167,8 +155,8 @@ Warning: The DMI component parallel to the spin orientation, the Jani which has
                 atoms=model.atoms,
                 basis=basis,
                 efermi=None,
-                magnetic_elements=magnetic_elements,
-                include_orbs=include_orbs,
+                # magnetic_elements=magnetic_elements,
+                # include_orbs=include_orbs,
                 **exargs,
             )
             # thetas = [0, np.pi / 2, np.pi, 3 * np.pi / 2]
@@ -191,8 +179,8 @@ Warning: The DMI component parallel to the spin orientation, the Jani which has
                     atoms=model.atoms,
                     basis=basis,
                     efermi=None,  # set to None, compute from efermi.
-                    magnetic_elements=magnetic_elements,
-                    include_orbs=include_orbs,
+                    # magnetic_elements=magnetic_elements,
+                    # include_orbs=include_orbs,
                     **exargs,
                 )
                 exchange.run(path=output_path_full)

{tb2j-0.9.8rc0 → tb2j-0.9.9rc0}/TB2J/orbmap.py

@@ -1,5 +1,6 @@
 import re
 from collections import defaultdict
+
 import numpy as np
 
 
@@ -7,30 +8,45 @@ def split_orb_name(name):
     """
     split name to : n, l, label
     """
-    m = re.findall(r"(\d[a-z\d\-]*)(.*)", name)
+    m = re.findall(r"([a-z\d\-\^\*]*)(.*)", name)
     m = m[0]
     return m[0], m[1]
 
 
 def map_orbs_matrix(orblist, spinor=False, include_only=None):
+    """
+    map the orbitals to a matrix
+    Method:
+    1. split the orbital name to n, l, label
+    2. group the orbitals by n, l
+    3. create a matrix with 1 for each orbital in the group
+    4. return the matrix and the group names
+    """
+
     if spinor:
         orblist = orblist[::2]
 
     norb = len(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)
+
     if include_only is None:
         for key, val in orbdict.items():
             reduced_orbdict[key[0]].append(val)
     else:
         for key, val in orbdict.items():
-            if key[0][:2] in include_only:
+            if key[0][:2] in include_only or key[0][:1] in include_only:
+                # [: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}")
     reduced_orbs = tuple(reduced_orbdict.keys())
     ngroup = len(reduced_orbdict)
     mmat = np.zeros((norb, ngroup), dtype=int)

{tb2j-0.9.8rc0 → tb2j-0.9.9rc0}/TB2J.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: TB2J
-Version: 0.9.8rc0
+Version: 0.9.9rc0
 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.8rc0 → tb2j-0.9.9rc0}/scripts/abacus2J.py

@@ -81,6 +81,7 @@ def run_abacus2J():
     )
 
     parser.add_argument(
+        "--nproc",
         "--np",
         help="number of cpu cores to use in parallel, default: 1",
         default=1,
@@ -121,28 +122,21 @@ def run_abacus2J():
         print("Please input the magnetic elements, e.g. --elements Fe Ni")
         sys.exit()
 
-    include_orbs = {}
-    for element in args.elements:
-        if "_" in element:
-            elem = element.split("_")[0]
-            orb = element.split("_")[1:]
-            include_orbs[elem] = orb
-        else:
-            include_orbs[element] = None
+    # include_orbs = {}
 
     gen_exchange_abacus(
         path=args.path,
         suffix=args.suffix,
         kmesh=args.kmesh,
-        magnetic_elements=list(include_orbs.keys()),
-        include_orbs=include_orbs,
+        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.np,
+        nproc=args.nproc,
         exclude_orbs=args.exclude_orbs,
         orb_decomposition=args.orb_decomposition,
     )

{tb2j-0.9.8rc0 → tb2j-0.9.9rc0}/scripts/siesta2J.py

@@ -128,20 +128,22 @@ def run_siesta2J():
         print("Please input the magnetic elements, e.g. --elements Fe Ni")
         sys.exit()
 
-    include_orbs = {}
-    for element in args.elements:
-        if "_" in element:
-            elem = element.split("_")[0]
-            orb = element.split("_")[1:]
-            include_orbs[elem] = orb
-        else:
-            include_orbs[element] = None
+    # include_orbs = {}
+    # for element in args.elements:
+    #    if "_" in element:
+    #        elem = element.split("_")[0]
+    #        orb = element.split("_")[1:]
+    #        include_orbs[elem] = orb
+    #    else:
+    #        include_orbs[element] = None
 
     gen_exchange_siesta(
         fdf_fname=args.fdf_fname,
         kmesh=args.kmesh,
-        magnetic_elements=list(include_orbs.keys()),
-        include_orbs=include_orbs,
+        # magnetic_elements=list(include_orbs.keys()),
+        # include_orbs=include_orbs,
+        magnetic_elements=args.elements,
+        include_orbs={},
         Rcut=args.rcut,
         emin=args.emin,
         emax=args.emax,

{tb2j-0.9.8rc0 → tb2j-0.9.9rc0}/setup.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 from setuptools import find_packages, setup
 
-__version__ = "0.9.8_pre"
+__version__ = "0.9.9_pre"
 
 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.8rc0/TB2J/MAEGreen.py

@@ -1,84 +0,0 @@
-from pathlib import Path
-
-import numpy as np
-import tqdm
-
-# from TB2J.abacus.abacus_wrapper import AbacusSplitSOCParser
-from TB2J.exchange import ExchangeNCL
-
-# 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
-from TB2J.mathutils.rotate_spin import (
-    rotate_spinor_matrix,
-)
-
-
-class MAEGreen(ExchangeNCL):
-    def __init__(self, angles=None, **kwargs):
-        super().__init__(**kwargs)
-        self.es = None
-        self.natoms = len(self.atoms)
-        if angles is None or angles == "axis":
-            self.set_angles_axis()
-        elif angles == "scan":
-            self.set_angles_scan()
-
-    def set_angles_axis(self):
-        """theta and phi are defined as the x, y, z, axis."""
-        self.thetas = [0, np.pi / 2, np.pi / 2, np.pi / 2]
-        self.phis = [0, 0, np.pi / 2, np.pi / 4]
-
-    def set_angles_scan(self, step=15):
-        self.thetas = []
-        self.phis = []
-        for i in range(0, 181, step):
-            for j in range(0, 181, step):
-                self.thetas.append(i * np.pi / 180)
-                self.phis.append(j * np.pi / 180)
-
-    def get_perturbed(self, e, thetas, phis):
-        self.tbmodel.set_so_strength(0.0)
-        G0K = self.G.get_Gk_all(e)
-        Hsoc_k = self.tbmodel.get_Hk_soc(self.G.kpts)
-        na = len(thetas)
-        dE_angle = np.zeros(na, dtype=complex)
-        dE_angle_atoms = np.zeros((na, self.natoms), dtype=complex)
-        for iangle, (theta, phi) in enumerate(zip(thetas, phis)):
-            for ik, dHk in enumerate(Hsoc_k):
-                dHi = rotate_spinor_matrix(dHk, theta, phi)
-                GdH = G0K[ik] @ dHi
-                # dE += np.trace(GdH @ G0K[i].T.conj() @ dHi) * self.kweights[i]
-                # diagonal of second order perturbation.
-                dG2diag = np.diag(GdH @ GdH)
-                # dG2diag = np.diag(GdH @G0K[i].T.conj() @ dHi)
-                dE_angle[iangle] += np.sum(dG2diag) * self.G.kweights[ik]
-                for iatom in range(self.natoms):
-                    dE_atom = np.sum(dG2diag[self.iorb(iatom)]) * self.G.kweights[ik]
-                    dE_angle_atoms[iangle, iatom] += dE_atom
-        return dE_angle, dE_angle_atoms
-
-    def get_band_energy_vs_angles(self, thetas, phis):
-        nangles = len(thetas)
-        self.es = np.zeros(nangles, dtype=float)
-        self.es_atoms = np.zeros((nangles, self.natoms), dtype=float)
-        for ie, e in enumerate(tqdm.tqdm(self.contour.path)):
-            dE_angle, dE_angle_atoms = self.get_perturbed(e, thetas, phis)
-            self.es -= np.imag(dE_angle * self.contour.weights[ie]) / np.pi
-            self.es_atoms -= np.imag(dE_angle_atoms * self.contour.weights[ie]) / np.pi
-
-    def output(self, output_path="TB2J_anisotropy"):
-        Path(output_path).mkdir(exist_ok=True)
-        fname = f"{output_path}/MAE.dat"
-        with open(fname, "w") as f:
-            f.write("# theta phi MAE, MAEatom1, atom2, ...\n")
-            for i, (theta, phi, e, es) in enumerate(
-                zip(self.thetas, self.phis, self.es, self.es_atoms)
-            ):
-                f.write(f"{theta:.5f} {phi:.5f} {e:.8f} ")
-                for ea in es:
-                    f.write(f"{ea:.8f} ")
-                f.write("\n")
-
-    def run(self, output_path="TB2J_anisotropy"):
-        self.get_band_energy_vs_angles(self.thetas, self.phis)
-        self.output(output_path=output_path)