TB2J 0.9.9.13__tar.gz → 0.9.9.15__tar.gz

{tb2j-0.9.9.13 → tb2j-0.9.9.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: TB2J
-Version: 0.9.9.13
+Version: 0.9.9.15
 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.9.13 → tb2j-0.9.9.15}/TB2J/MAEGreen.py

@@ -94,12 +94,11 @@ class MAEGreen(ExchangeNCL):
                 self.thetas.append(i * np.pi / 180)
                 self.phis.append(j * np.pi / 180)
 
-    def set_angels_ztox(self, n=16):  
+    def set_angels_ztox(self, n=16):
         """Set angles for a scan from z to x"""
         self.thetas = np.linspace(0, np.pi, n)
         self.phis = np.zeros(n)
 
-
     def set_angles_random(self, n=16):
         # n random pairs of theta, phi
         self.thetas = np.random.random(n) * np.pi

tb2j-0.9.9.15/TB2J/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.9.9.14"

{tb2j-0.9.9.13 → tb2j-0.9.9.15}/TB2J/exchange.py

@@ -48,7 +48,7 @@ class Exchange(ExchangeParams):
         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.")
+        # print(f"A gap is found at {self.emin}, set emin to it.")
 
     def set_tbmodels(self, tbmodels):
         pass

{tb2j-0.9.9.13 → tb2j-0.9.9.15}/TB2J/interfaces/abacus/stru_api.py

@@ -7,21 +7,28 @@
 Modified on Wed Aug 01 11:44:51 2022
 @author: Ji Yu-yang
 """
-import warnings
-warnings.simplefilter(action='ignore', category=FutureWarning)
-
 
 import os
 import re
 import shutil
+import warnings
+from copy import deepcopy
+from math import sqrt
 from pathlib import Path
 
 import numpy as np
 from ase import Atoms
+from ase.calculators.calculator import kpts2ndarray, kpts2sizeandoffsets
 from ase.calculators.singlepoint import SinglePointDFTCalculator, arrays_to_kpoints
+from ase.constraints import FixAtoms, FixCartesian
+from ase.dft.kpoints import bandpath
+from ase.stress import full_3x3_to_voigt_6_stress
 from ase.units import Bohr, GPa, Hartree, Rydberg, _me, mol
 from ase.utils import lazymethod, lazyproperty, reader, writer
 
+warnings.simplefilter(action="ignore", category=FutureWarning)
+
+
 _re_float = r"[-+]?\d+\.*\d*(?:[Ee][-+]\d+)?"
 AU_to_MASS = mol * _me * 1e3
 UNIT_V = np.sqrt(Hartree / AU_to_MASS)
@@ -42,7 +49,6 @@ def write_input(fd, parameters=None):
     parameters: dict
         The dictionary of all paramters for the calculation.
     """
-    from copy import deepcopy
 
     params = deepcopy(parameters)
     params["dft_functional"] = (
@@ -105,8 +111,6 @@ def write_kpt(fd=None, parameters=None, atoms=None):
         return
     elif kpts is not None:
         if isinstance(kpts, dict) and "path" not in kpts:
-            from ase.calculators.calculator import kpts2sizeandoffsets
-
             kgrid, shift = kpts2sizeandoffsets(atoms=atoms, **kpts)
             koffset = []
             for i, x in enumerate(shift):
@@ -121,8 +125,6 @@ def write_kpt(fd=None, parameters=None, atoms=None):
         koffset = [koffset] * 3
 
     if isinstance(kgrid, dict) or hasattr(kgrid, "kpts"):
-        from ase.calculators.calculator import kpts2ndarray
-
         kmode = "Direct"
         kgrid = kpts2ndarray(kgrid, atoms=atoms)
     elif isinstance(kgrid, str) and (kgrid == "gamma"):
@@ -272,8 +274,6 @@ def judge_exist_stru(stru=None):
 
 
 def read_ase_stru(stru=None, coordinates_type="Cartesian"):
-    from ase.constraints import FixAtoms, FixCartesian
-
     fix_cart = np.ones((len(stru), 3), dtype=int).tolist()
     for constr in stru.constraints:
         for i in constr.index:
@@ -567,8 +567,6 @@ def read_kpt(fd, cell=None):
         else:
             knumbers = klines[:, 3].astype(int)
             if cell is not None:
-                from ase.dft.kpoints import bandpath
-
                 return bandpath(kpts, cell, npoints=knumbers.sum())
             else:
                 return {
@@ -683,8 +681,6 @@ def read_abacus(fd, latname=None, verbose=False):
     If `verbose` is True, pseudo-potential, basis and other information along with the Atoms object will be output as a dict.
     """
 
-    from ase.constraints import FixCartesian
-
     contents = fd.read()
     title_str = r"(?:LATTICE_CONSTANT|NUMERICAL_DESCRIPTOR|NUMERICAL_ORBITAL|ABFS_ORBITAL|LATTICE_VECTORS|LATTICE_PARAMETERS|ATOMIC_POSITIONS)"
 
@@ -887,8 +883,6 @@ def read_abacus(fd, latname=None, verbose=False):
 
 
 def get_lattice_from_latname(lines, latname=None):
-    from math import sqrt
-
     if lines:
         lines = lines.group(1).split(" ")
 
@@ -1488,7 +1482,6 @@ class AbacusOutCalcChunk(AbacusOutChunk):
     @lazymethod
     def get_stress(self):
         """Get the stress from the output file according to index"""
-        from ase.stress import full_3x3_to_voigt_6_stress
 
         try:
             stress = (

{tb2j-0.9.9.13 → tb2j-0.9.9.15}/TB2J/interfaces/siesta_interface.py

@@ -165,7 +165,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.set_xyz_angles()
+            # MAE.set_xyz_angles()
             MAE.run(output_path=f"{output_path}_anisotropy", with_eigen=False)
             # print(
             #    f"MAE calculation finished. The results are in {output_path} directory."

{tb2j-0.9.9.13 → tb2j-0.9.9.15}/TB2J/io_exchange/io_exchange.py

@@ -340,20 +340,19 @@ Generation time: {now.strftime("%y/%m/%d %H:%M:%S")}
         """
         i = self.i_spin(i)
         j = self.i_spin(j)
-        J=D=Ja = None
+        J = D = Ja = None
         if Jiso:
-            J= self.get_Jiso(i, j, R)
+            J = self.get_Jiso(i, j, R)
         if DMI:
             D = self.get_DMI(i, j, R)
             if D is not None:
-                D*=1
+                D *= 1
         if Jani:
             Ja = self.get_Jani(i, j, R)
             if Ja is not None:
-                Ja*=1
+                Ja *= 1
         Jtensor = combine_J_tensor(Jiso=J, D=D, Jani=Ja)
 
-
         # if iso_only:
         #    J = self.get_Jiso(i, j, R)
         #    if J is not None:

{tb2j-0.9.9.13 → tb2j-0.9.9.15}/TB2J/io_exchange/io_vampire.py

@@ -60,7 +60,7 @@ def write_vampire_unitcell_file(cls, fname):
                     val = np.real(Jtensor[i, j] * 2.0 / J)
                     if np.abs(val) < 1e-30:
                         val = 0.0
-                    myfile.write(f"{val:<012.5e} ")
+                    myfile.write(f"{val:< 12.5e} ")
             myfile.write("\n")
 
 

{tb2j-0.9.9.13 → tb2j-0.9.9.15}/TB2J/io_merge.py

@@ -1,31 +1,35 @@
-import os
 import copy
+import os
 import warnings
+from itertools import combinations_with_replacement
+
 import numpy as np
-from itertools import combinations_with_replacement, product
+
 from TB2J.io_exchange import SpinIO
 
 u0 = np.zeros(3)
 uy = np.array([0.0, 1.0, 0.0])
 uz = np.array([0.0, 0.0, 1.0])
 
-def get_Jani_coefficients(a, R=np.eye(3)):
 
+def get_Jani_coefficients(a, R=np.eye(3)):
     if len(a) == 1:
         u = a
         v = a
     else:
         u = a[[0, 0, 1]]
         v = a[[0, 1, 1]]
-    
+
     ur = u @ R.T
     vr = v @ R.T
-    coefficients = np.hstack([ur*vr, np.roll(ur, -1, axis=-1)*vr + np.roll(vr, -1, axis=-1)*ur])
+    coefficients = np.hstack(
+        [ur * vr, np.roll(ur, -1, axis=-1) * vr + np.roll(vr, -1, axis=-1) * ur]
+    )
 
     return coefficients, u, v
 
-def get_projections(a, b, tol=1e-2):
 
+def get_projections(a, b, tol=1e-2):
     projections = np.empty((2, 3))
     if np.linalg.matrix_rank([a, b], tol=tol) == 1:
         if np.linalg.matrix_rank([a, uy], tol=tol) == 1:
@@ -41,13 +45,13 @@ def get_projections(a, b, tol=1e-2):
 
     return projections
 
+
 class SpinIO_merge(SpinIO):
     def __init__(self, *args, **kwargs):
         super(SpinIO_merge, self).__init__(*args, **kwargs)
         self.projv = None
 
     def _set_projection_vectors(self):
-
         norm = np.linalg.norm(self.spinat, axis=-1).reshape(-1, 1)
         spinat = self.spinat / norm
         idx = [self.ind_atoms[i] for i in self.index_spin if i >= 0]
@@ -60,27 +64,29 @@ class SpinIO_merge(SpinIO):
         self.projv = projv
 
     @classmethod
-    def load_pickle(cls, path='TB2J_results', fname='TB2J.pickle'):
+    def load_pickle(cls, path="TB2J_results", fname="TB2J.pickle"):
         obj = super(SpinIO_merge, cls).load_pickle(path=path, fname=fname)
         obj._set_projection_vectors()
 
         return obj
 
+
 def read_pickle(path):
-    p1 = os.path.join(path, 'TB2J_results', 'TB2J.pickle')
-    p2 = os.path.join(path, 'TB2J.pickle')
+    p1 = os.path.join(path, "TB2J_results", "TB2J.pickle")
+    p2 = os.path.join(path, "TB2J.pickle")
     if os.path.exists(p1) and os.path.exists(p2):
         print(f" WARNING!: Both file {p1} and {p2} exist. Use default {p1}.")
     if os.path.exists(p1):
-        ret = SpinIO_merge.load_pickle(os.path.join(path, 'TB2J_results'))
+        ret = SpinIO_merge.load_pickle(os.path.join(path, "TB2J_results"))
     elif os.path.exists(p2):
         ret = SpinIO_merge.load_pickle(path)
     else:
         raise FileNotFoundError(f"Cannot find either file {p1} or {p2}")
     return ret
 
-class Merger():
-    def __init__(self, *paths, main_path=None): 
+
+class Merger:
+    def __init__(self, *paths, main_path=None):
         self.dat = [read_pickle(path) for path in paths]
 
         if main_path is None:
@@ -90,32 +96,34 @@ class Merger():
             self.dat.append(copy.deepcopy(self.main_dat))
 
         self._set_projv()
-        
+
     def _set_projv(self):
         cell = self.main_dat.atoms.cell.array
-        rotated_cells = np.stack(
-            [obj.atoms.cell.array for obj in self.dat], axis=0
-        )
+        rotated_cells = np.stack([obj.atoms.cell.array for obj in self.dat], axis=0)
         R = np.linalg.solve(cell, rotated_cells)
         indices = range(len(self.dat))
 
-        proju = {}; projv = {}; coeff_matrix = {}; projectors = {};
+        proju = {}
+        projv = {}
+        coeff_matrix = {}
+        projectors = {}
         for key in self.main_dat.projv.keys():
             vectors = [obj.projv[key] for obj in self.dat]
-            coefficients, u, v = zip(*[get_Jani_coefficients(vectors[i], R=R[i]) for i in indices])
+            coefficients, u, v = zip(
+                *[get_Jani_coefficients(vectors[i], R=R[i]) for i in indices]
+            )
             projectors[key] = np.vstack([u[i] @ R[i].T for i in indices])
             coeff_matrix[key] = np.vstack(coefficients)
             proju[key] = np.stack(u)
             projv[key] = np.stack(v)
             if np.linalg.matrix_rank(coeff_matrix[key], tol=1e-2) < 6:
-                warnings.warn('''
+                warnings.warn("""
                     WARNING: The matrix of equations to reconstruct the exchange tensors is
                     close to being singular. This happens when the magnetic moments between
                     different configurations are cloes to being parallel. You need to consider 
                     more rotated spin configurations, otherwise the results might have a large 
-                    error.'''
-                )
-        
+                    error.""")
+
         self.proju = proju
         self.projv = projv
         self.coeff_matrix = coeff_matrix
@@ -123,71 +131,78 @@ class Merger():
 
     def merge_Jani(self):
         Jani_dict = {}
-        proju = self.proju; projv = self.projv; coeff_matrix = self.coeff_matrix;
+        proju = self.proju
+        projv = self.projv
+        coeff_matrix = self.coeff_matrix
         for key in self.main_dat.Jani_dict.keys():
             try:
                 R, i, j = key
                 u = proju[i, j]
                 v = projv[i, j]
                 Jani = np.stack([sio.Jani_dict[key] for sio in self.dat])
-                projections = np.einsum('nmi,nij,nmj->nm', u, Jani, v).flatten()
+                projections = np.einsum("nmi,nij,nmj->nm", u, Jani, v).flatten()
             except KeyError as err:
                 raise KeyError(
                     "Can not find key: %s, Please make sure the three calculations use the same k-mesh and same Rcut."
-                    % err)
+                    % err
+                )
             newJani = np.linalg.lstsq(coeff_matrix[i, j], projections, rcond=1e-2)[0]
-            Jani_dict[key] = np.array([
-                [newJani[0], newJani[3], newJani[5]],
-                [newJani[3], newJani[1], newJani[4]],
-                [newJani[5], newJani[4], newJani[2]]
-            ])
+            Jani_dict[key] = np.array(
+                [
+                    [newJani[0], newJani[3], newJani[5]],
+                    [newJani[3], newJani[1], newJani[4]],
+                    [newJani[5], newJani[4], newJani[2]],
+                ]
+            )
         self.main_dat.Jani_dict = Jani_dict
 
     def merge_Jiso(self):
-        Jdict={}
+        Jdict = {}
         for key in self.main_dat.exchange_Jdict.keys():
             try:
-               J = np.mean([obj.exchange_Jdict[key] for obj in self.dat])
+                J = np.mean([obj.exchange_Jdict[key] for obj in self.dat])
             except KeyError as err:
                 raise KeyError(
-                        "Can not find key: %s, Please make sure the three calculations use the same k-mesh and same Rcut."
-                        % err)
+                    "Can not find key: %s, Please make sure the three calculations use the same k-mesh and same Rcut."
+                    % err
+                )
             Jdict[key] = J
         self.main_dat.exchange_Jdict = Jdict
-               
 
     def merge_DMI(self):
         dmi_ddict = {}
         if all(obj.has_dmi for obj in self.dat):
-            projectors = self.projectors; proju = self.proju;
+            projectors = self.projectors
+            proju = self.proju
             for key in self.main_dat.dmi_ddict.keys():
                 try:
                     R, i, j = key
                     u = proju[i, j]
                     DMI = np.stack([sio.dmi_ddict[key] for sio in self.dat])
-                    projections = np.einsum('nmi,ni->nm', u, DMI).flatten()
+                    projections = np.einsum("nmi,ni->nm", u, DMI).flatten()
                 except KeyError as err:
                     raise KeyError(
                         "Can not find key: %s, Please make sure the three calculations use the same k-mesh and same Rcut."
-                        % err)
+                        % err
+                    )
                 newDMI = np.linalg.lstsq(projectors[i, j], projections, rcond=4e-1)[0]
                 dmi_ddict[key] = newDMI
             self.main_dat.dmi_ddict = dmi_ddict
 
     def standardize(self):
         # make sure that the Jani has the trace of zero
-        Jdict=self.main_dat.exchange_Jdict
-        Jani_dict=self.main_dat.Jani_dict
+        Jdict = self.main_dat.exchange_Jdict
+        Jani_dict = self.main_dat.Jani_dict
         for key in self.main_dat.Jani_dict.keys():
             Jani = self.main_dat.Jani_dict[key]
-            shift = np.trace(Jani)/3.0
-            Jani_dict[key]  -= shift * np.eye(3)
+            shift = np.trace(Jani) / 3.0
+            Jani_dict[key] -= shift * np.eye(3)
             Jdict[key] += shift
         self.main_dat.Jani_dict = Jani_dict
         self.main_dat.exchange_Jdict = Jdict
-        
 
-def merge(*paths, main_path=None, save=True, write_path='TB2J_results'):
+
+def merge(*paths, main_path=None, save=True, write_path="TB2J_results"):
     m = Merger(*paths, main_path=main_path)
     m.merge_Jiso()
     m.merge_DMI()

{tb2j-0.9.9.13 → tb2j-0.9.9.15}/TB2J/magnon/magnon3.py

@@ -2,12 +2,16 @@ from dataclasses import asdict, dataclass
 from pathlib import Path
 from typing import List, Optional, Tuple, Union
 
+import matplotlib.pyplot as plt
 import numpy as np
 import tomli
 import tomli_w
+from ase.dft.dos import DOS
+from ase.units import J, eV
 from scipy.spatial.transform import Rotation
 
 from TB2J.io_exchange import SpinIO
+from TB2J.kpoints import monkhorst_pack
 from TB2J.magnon.magnon_band import MagnonBand
 from TB2J.magnon.magnon_math import get_rotation_arrays
 from TB2J.mathutils.auto_kpath import auto_kpath
@@ -162,10 +166,10 @@ class Magnon:
                 phase = 2 * np.pi * R @ qpt
                 Jq[iqpt] += np.exp(1j * phase) * JRprime[iR]
 
-        #Jq_copy = Jq.copy()
-        #Jq.swapaxes(-1, -2)  # swap xyz
-        #Jq.swapaxes(-3, -4)  # swap ij
-        #Jq = (Jq.conj() + Jq_copy) / 2.0
+        # Jq_copy = Jq.copy()
+        # Jq.swapaxes(-1, -2)  # swap xyz
+        # Jq.swapaxes(-3, -4)  # swap ij
+        # Jq = (Jq.conj() + Jq_copy) / 2.0
         return Jq
 
     def Hq(self, kpoints):
@@ -187,7 +191,6 @@ class Magnon:
         magmoms = self.magmom.copy()
         magmoms /= np.linalg.norm(magmoms, axis=-1)[:, None]
 
-        
         U, V = get_rotation_arrays(magmoms, u=self._uz)
 
         J0 = -self.Jq(np.zeros((1, 3)))[0]
@@ -195,7 +198,6 @@ class Magnon:
         # Jq = -Hermitize(self.Jq(kpoints, anisotropic=anisotropic))
 
         Jq = -self.Jq(kpoints)
-        print(f"J0 shape: {J0.shape}")
 
         C = np.diag(np.einsum("ix,ijxy,jy->i", V, 2 * J0, V))
         B = np.einsum("ix,kijxy,jy->kij", U, Jq, U)
@@ -203,7 +205,6 @@ class Magnon:
         A2 = np.einsum("ix,kijxy,jy->kij", U.conj(), Jq, U)
 
         H = np.block([[A1 - C, B], [B.swapaxes(-1, -2).conj(), A2 - C]])
-        print(f"H shape: {H.shape}")
         return H
 
     def _magnon_energies(self, kpoints, u=None):
@@ -801,12 +802,11 @@ def main():
     )
 
     parser.add_argument(
-        "--show", 
+        "--show",
         action="store_true",
         default=False,
         help="show figure on screen.",
-        )
-
+    )
 
     args = parser.parse_args()
 
@@ -834,7 +834,7 @@ def main():
             Q=args.Q if args.Q is not None else None,
             uz_file=args.uz_file,
             n=args.n if args.n is not None else None,
-            show=args.show
+            show=args.show,
         )
 
     plot_magnon_bands_from_TB2J(params)
@@ -842,3 +842,97 @@ def main():
 
 if __name__ == "__main__":
     main()
+
+
+class MagnonASEWrapper:
+    def __init__(self, magnon: Magnon):
+        self.magnon = magnon
+        self.atoms = None
+        self.kpts = None
+        self.weights = None
+        self.dos_args = {}
+
+    def set(self, atoms=None, kmesh=[9, 9, 9], gamma=True, **kwargs):
+        self.atoms = atoms
+        self.dos_args = {
+            "kmesh": kmesh,
+            "gamma": gamma,
+        }
+        self.kpts = monkhorst_pack(
+            self.dos_args["kmesh"], gamma_center=self.dos_args["gamma"]
+        )
+        self.weights = np.ones(len(self.kpts)) / len(self.kpts)
+
+    def get_k_points_and_weights(self):
+        return self.kpts, self.weights
+
+    def get_k_point_weights(self):
+        return self.weights
+
+    def get_number_of_spins(self):
+        return 1
+
+    def get_eigenvalues(self, kpt, spin=0):
+        """
+        return the eigenvalues at a given k-point. The energy unit is eV
+        args:
+            kpt: k-point index.
+            spin: spin index.
+        """
+        kpoint = self.kpts[kpt]
+        # Magnon energies are already in eV, convert to meV for consistency with plot
+        evals = self.magnon._magnon_energies(np.array([kpoint]))[0]
+        evals = evals * J / eV  # Convert to eV
+        return evals
+
+    def get_fermi_level(self):
+        return 0.0
+
+    def get_bz_k_points(self):
+        return self.kpts
+
+    def get_dos(self, width=0.1, window=None, npts=401):
+        dos = DOS(self, width=width, window=window, npts=npts)
+        energies = dos.get_energies()
+        tdos = dos.get_dos()
+        return energies, tdos
+
+    def plot_dos(
+        self,
+        smearing_width=0.0001,
+        window=None,
+        npts=401,
+        output="magnon_dos.pdf",
+        ax=None,
+        show=True,
+        dos_filename="magnon_dos.txt",
+    ):
+        """
+        plot total DOS.
+        :param width: width of Gaussian smearing
+        :param window: energy window
+        :param npts: number of points
+        :param output: output filename
+        :param ax: matplotlib axis
+        :return: ax
+        """
+        if ax is None:
+            _fig, ax = plt.subplots()
+        energies, tdos = self.get_dos(width=smearing_width, window=window, npts=npts)
+        energies = energies * 1000  # Convert to meV
+        tdos = tdos / 1000  # Convert to states/meV
+        if dos_filename is not None:
+            np.savetxt(
+                dos_filename,
+                np.array([energies, tdos]).T,
+                header="Energy(meV) DOS(state/meV)",
+            )
+        ax.plot(energies, tdos)
+        ax.set_xlabel("Energy (meV)")
+        ax.set_ylabel("DOS (states/meV)")
+        ax.set_title("Total DOS")
+        if output is not None:
+            plt.savefig(output)
+        if show:
+            plt.show()
+        return ax

{tb2j-0.9.9.13 → tb2j-0.9.9.15}/TB2J/magnon/magnon_band.py

@@ -40,7 +40,7 @@ class MagnonBand:
         if self.xcoords is None:
             self.xcoords = np.arange(len(self.kpoints))
 
-    def plot(self, ax=None, filename=None, show=False, shift=0.0,**kwargs):
+    def plot(self, ax=None, filename=None, show=False, shift=0.0, **kwargs):
         """Plot the magnon band structure.
 
         Parameters
@@ -79,7 +79,7 @@ class MagnonBand:
                 for band in segment_bands:
                     ax.plot(
                         x,
-                        band[start_idx : start_idx + nbands]+shift,
+                        band[start_idx : start_idx + nbands] + shift,
                         linewidth=linewidth,
                         color=color,
                         linestyle=linestyle,
@@ -91,7 +91,7 @@ class MagnonBand:
             for band in self.energies.T:
                 ax.plot(
                     self.xcoords,
-                    band+shift,
+                    band + shift,
                     linewidth=linewidth,
                     color=color,
                     linestyle=linestyle,