TB2J 0.9.9rc2__tar.gz → 0.9.9rc4__tar.gz

{tb2j-0.9.9rc2 → tb2j-0.9.9rc4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: TB2J
-Version: 0.9.9rc2
+Version: 0.9.9rc4
 Summary: TB2J: First principle to Heisenberg exchange J using tight-binding Green function method
 Author: Xu He
 Author-email: mailhexu@gmail.com
@@ -21,7 +21,7 @@ Requires-Dist: ase>=3.19
 Requires-Dist: tqdm
 Requires-Dist: pathos
 Requires-Dist: packaging>=20.0
-Requires-Dist: HamiltonIO>=0.1.8
+Requires-Dist: HamiltonIO>=0.1.9
 Requires-Dist: pre-commit
 Requires-Dist: sympair>0.1.0
 

{tb2j-0.9.9rc2 → tb2j-0.9.9rc4}/TB2J/MAEGreen.py

@@ -2,9 +2,10 @@ from pathlib import Path
 
 import numpy as np
 import tqdm
+from HamiltonIO.abacus.abacus_wrapper import AbacusSplitSOCParser
+from HamiltonIO.model.occupations import Occupations
 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
@@ -14,14 +15,15 @@ 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)
+    return occ.occupy(evals)
+
+
 class MAEGreen(ExchangeNCL):
-    def __init__(self, angles=[], **kwargs):
+    def __init__(self, angles=None, **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":
@@ -30,10 +32,15 @@ class MAEGreen(ExchangeNCL):
             self.thetas = angles[0]
             self.phis = angles[1]
 
+        nangles = len(self.thetas)
+        self.es = np.zeros(nangles, dtype=complex)
+        self.es_atom = np.zeros((nangles, self.natoms), dtype=complex)
+        self.es_atom_orb = DefaultDict(lambda: 0)
+
     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]
+        self.thetas = [0, np.pi / 2, np.pi / 2, np.pi / 2, np.pi]
+        self.phis = [0, 0, np.pi / 2, np.pi / 4, 0]
 
     def set_angles_scan(self, step=15):
         self.thetas = []
@@ -43,6 +50,32 @@ class MAEGreen(ExchangeNCL):
                 self.thetas.append(i * np.pi / 180)
                 self.phis.append(j * np.pi / 180)
 
+    def get_band_energy_vs_angles_from_eigen(
+        self,
+        thetas,
+        phis,
+    ):
+        """
+        Calculate the band energy for a given set of angles by using the eigenvalues and eigenvectors of the Hamiltonian.
+        """
+        es = []
+        nangles = len(thetas)
+        self.tbmodel.set_so_strength(1.0)
+        for i in tqdm.trange(nangles):
+            theta = thetas[i]
+            phi = phis[i]
+            self.tbmodel.set_Hsoc_rotation_angle([theta, phi])
+            e = self.get_band_energy()
+            es.append(e)
+        return es
+
+    def get_band_energy(self):
+        self.width = 0.1
+        evals, _evecs = self.tbmodel.solve_all(self.G.kpts)
+        occ = get_occupation(evals, self.G.kweights, self.tbmodel.nel, width=self.width)
+        eband = np.sum(evals * occ * self.G.kweights[:, np.newaxis])
+        return eband
+
     def get_perturbed(self, e, thetas, phis):
         self.tbmodel.set_so_strength(0.0)
         G0K = self.G.get_Gk_all(e)
@@ -59,26 +92,38 @@ class MAEGreen(ExchangeNCL):
                 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)
+                dG2diag = np.diag(GdH @ GdH)
+                # dG2 = np.einsum("ij,ji->ij", GdH,   GdH)
                 dG2 = GdH * GdH.T
                 dG2sum = np.sum(dG2)
+                # print(f"dG2sum-sum: {dG2sum}")
+
+                # dG2sum = np.trace(GdH @ GdH)
+                # print(f"dG2sum-Tr: {dG2sum}")
+                # dG1sum = np.trace(GdH)
+                # print(f"dG1sum-Tr: {dG1sum}")
 
                 # 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] += 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]
+                    # 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]
+                    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_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_atom = np.sum(dG2diag[iorb]) * self.G.kweights[ik]
+                    # dE_atom = np.sum(dE_atom_orb)
                     dE_angle_atom[iangle, iatom] += dE_atom
         return dE_angle, dE_angle_atom, dE_angle_atom_orb
 
@@ -93,7 +138,10 @@ class MAEGreen(ExchangeNCL):
         # dE_angle_atoms = np.zeros((len(thetas), self.natoms), dtype=complex)
         pass
 
-    def get_band_energy_vs_angles(self, thetas, phis):
+    def get_band_energy_vs_angles(self, thetas, phis, with_eigen=False):
+        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
@@ -101,17 +149,33 @@ class MAEGreen(ExchangeNCL):
             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_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
+        self.es = -np.imag(self.es) / (2 * np.pi)
+        self.es_atom = -np.imag(self.es_atom) / (2 * np.pi)
         for key, value in self.es_atom_orb.items():
-            self.es_atom_orb[key] = -np.imag(value) / np.pi
+            self.es_atom_orb[key] = -np.imag(value) / (2 * np.pi)
 
-    def output(self, output_path="TB2J_anisotropy"):
+    def output(self, output_path="TB2J_anisotropy", with_eigen=False):
         Path(output_path).mkdir(exist_ok=True)
         fname = f"{output_path}/MAE.dat"
         fname_orb = f"{output_path}/MAE_orb.dat"
+
+        # ouput with eigenvalues.
+        if with_eigen:
+            fname_eigen = f"{output_path}/MAE_eigen.dat"
+            with open(fname_eigen, "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.es2, 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, "w") as f:
             f.write("# theta, phi, MAE(total), MAE(atom-wise) Unit: meV\n")
             for i, (theta, phi, e, es) in enumerate(
@@ -141,27 +205,30 @@ class MAEGreen(ExchangeNCL):
                 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)] 
+                    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 * 1e3, precision=4, separator=",", suppress_small=True
                         )
                     )
 
-                    eorb_diff = eorb -  self.es_atom_orb[(0, iatom)]
+                    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
+                            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 run(self, output_path="TB2J_anisotropy", with_eigen=False):
+        self.get_band_energy_vs_angles(self.thetas, self.phis, with_eigen=with_eigen)
+        self.output(output_path=output_path, with_eigen=with_eigen)
 
 
 def abacus_get_MAE(
@@ -175,23 +242,24 @@ def abacus_get_MAE(
     magnetic_elements=None,
     nel=None,
     width=0.1,
-    **kwargs
+    **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()
+    model.set_so_strength(0.0)
     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 = 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.9rc2 → tb2j-0.9.9rc4}/TB2J/exchange.py

@@ -50,8 +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 - 10.0) - self.efermi
-        self.emin = -12.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):
@@ -119,7 +119,7 @@ class Exchange(ExchangeParams):
                 else:
                     try:
                         atom_sym, orb_sym = base[:2]
-                    except Exception as e:
+                    except Exception:
                         iatom = base.iatom
                         atom_sym = base.iatom
                         orb_sym = base.sym

{tb2j-0.9.9rc2 → tb2j-0.9.9rc4}/TB2J/exchange_params.py

@@ -40,7 +40,7 @@ class ExchangeParams:
         include_orbs=None,
         kmesh=[4, 4, 4],
         emin=-15,
-        emax=0.05,
+        emax=0.00,
         nz=100,
         ne=None,
         Rcut=None,

{tb2j-0.9.9rc2 → tb2j-0.9.9rc4}/TB2J/interfaces/siesta_interface.py

@@ -171,6 +171,7 @@ Warning: The DMI component parallel to the spin orientation, the Jani which has
             for key, val in angle.items():
                 # model = parser.get_model()
                 theta, phi = val
+                model.set_so_strength(1.0)
                 model.set_Hsoc_rotation_angle([theta, phi])
                 basis = dict(zip(model.orbs, list(range(model.nbasis))))
                 output_path_full = f"{output_path}_{key}"

{tb2j-0.9.9rc2 → tb2j-0.9.9rc4}/TB2J/mathutils/rotate_spin.py

@@ -92,15 +92,17 @@ def rotate_spinor_matrix_einsum(M, theta, phi):
     """
     Rotate the spinor matrix M by theta and phi,
     """
-    N = M.shape[0] // 2
-    Mnew = np.reshape(M, (N, 2, N, 2))  # .swapaxes(1, 2)
+    shape = M.shape
+    n1 = np.product(shape[:-1]) // 2
+    n2 = M.shape[-1] // 2
+    Mnew = np.reshape(M, (n1, 2, n2, 2))  # .swapaxes(1, 2)
     # print("Mnew:", Mnew)
     U = rotation_matrix(theta, phi)
     UT = U.conj().T
     Mnew = np.einsum(
         "ij, rjsk, kl -> risl", UT, Mnew, U, optimize=True, dtype=np.complex128
     )
-    Mnew = Mnew.reshape(2 * N, 2 * N)
+    Mnew = Mnew.reshape(shape)
     return Mnew
 
 
@@ -111,7 +113,6 @@ def rotate_spinor_matrix_einsum_R(M, theta, phi):
     nR = M.shape[0]
     N = M.shape[1] // 2
     Mnew = np.reshape(M, (nR, N, 2, N, 2))  # .swapaxes(1, 2)
-    # print("Mnew:", Mnew)
     U = rotation_matrix(theta, phi)
     UT = U.conj().T
     Mnew = np.einsum(

{tb2j-0.9.9rc2 → tb2j-0.9.9rc4}/TB2J/symmetrize_J.py

@@ -1,16 +1,19 @@
-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.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)
         self.verbose = verbose
+        self.Jonly = Jonly
 
         if verbose:
             print("=" * 30)
@@ -28,7 +31,7 @@ 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)
@@ -51,6 +54,11 @@ 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_dict = {}
+            self.new_exc.has_uniaxial_anistropy = False
+            self.new_exc.k1_dict = {}
 
     def output(self, path="TB2J_symmetrized"):
         if path is None:
@@ -72,6 +80,7 @@ def symmetrize_J(
     fname="TB2J.pickle",
     symprec=1e-5,
     output_path="TB2J_symmetrized",
+    Jonly=False,
 ):
     """
     symmetrize the exchange parameters
@@ -109,6 +118,14 @@ 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 and discard the DMI and anisotropic exchange",
+        default=False,
+    )
+
     args = parser.parse_args()
     if args.inpath is None:
         parser.print_help()

{tb2j-0.9.9rc2 → tb2j-0.9.9rc4}/TB2J.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: TB2J
-Version: 0.9.9rc2
+Version: 0.9.9rc4
 Summary: TB2J: First principle to Heisenberg exchange J using tight-binding Green function method
 Author: Xu He
 Author-email: mailhexu@gmail.com
@@ -21,7 +21,7 @@ Requires-Dist: ase>=3.19
 Requires-Dist: tqdm
 Requires-Dist: pathos
 Requires-Dist: packaging>=20.0
-Requires-Dist: HamiltonIO>=0.1.8
+Requires-Dist: HamiltonIO>=0.1.9
 Requires-Dist: pre-commit
 Requires-Dist: sympair>0.1.0
 

{tb2j-0.9.9rc2 → tb2j-0.9.9rc4}/TB2J.egg-info/requires.txt

@@ -5,6 +5,6 @@ ase>=3.19
 tqdm
 pathos
 packaging>=20.0
-HamiltonIO>=0.1.8
+HamiltonIO>=0.1.9
 pre-commit
 sympair>0.1.0

{tb2j-0.9.9rc2 → tb2j-0.9.9rc4}/setup.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 from setuptools import find_packages, setup
 
-__version__ = "0.9.9_rc2"
+__version__ = "0.9.9_rc4"
 
 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. """
 
@@ -40,7 +40,7 @@ setup(
         "tqdm",
         "pathos",
         "packaging>=20.0",
-        "HamiltonIO>=0.1.8",
+        "HamiltonIO>=0.1.9",
         "pre-commit",
         "sympair>0.1.0",
     ],