TB2J 0.9.10.1__py3-none-any.whl → 0.9.12.17__py3-none-any.whl

TB2J/magnon/magnon3.py

@@ -31,6 +31,7 @@ class MagnonParameters:
     Q: Optional[List[float]] = None
     uz_file: Optional[str] = None
     n: Optional[List[float]] = None
+    spin_conf_file: Optional[str] = None
     show: bool = False
 
     @classmethod
@@ -57,6 +58,8 @@ class MagnonParameters:
         # Convert path to absolute path if uz_file is relative to it
         if self.uz_file and not Path(self.uz_file).is_absolute():
             self.uz_file = str(Path(self.path) / self.uz_file)
+        if self.spin_conf_file and not Path(self.spin_conf_file).is_absolute():
+            self.spin_conf_file = str(Path(self.path) / self.spin_conf_file)
 
 
 @dataclass
@@ -76,7 +79,7 @@ class Magnon:
     _n: np.ndarray
     pbc: tuple = (True, True, True)
 
-    def set_reference(self, Q, uz, n):
+    def set_reference(self, Q, uz, n, magmoms=None):
         """
         Set reference propagation vector and quantization axis
 
@@ -92,6 +95,8 @@ class Magnon:
         self.set_propagation_vector(Q)
         self._uz = np.array(uz, dtype=float)
         self._n = np.array(n, dtype=float)
+        if magmoms is not None:
+            self.magmom = np.array(magmoms, dtype=float)
 
     def set_propagation_vector(self, Q):
         """Set propagation vector"""
@@ -653,26 +658,40 @@ def plot_magnon_bands_from_TB2J(
     )
 
     # Set reference vectors if provided
-    if any(x is not None for x in [params.Q, params.uz_file, params.n]):
-        Q = [0, 0, 0] if params.Q is None else params.Q
-        n = [0, 0, 1] if params.n is None else params.n
-
-        # Handle quantization axes
-        if params.uz_file is not None:
-            uz = np.loadtxt(params.uz_file)
-            if uz.shape[1] != 3:
-                raise ValueError(
-                    f"Quantization axes file should contain a natom×3 array. Got shape {uz.shape}"
-                )
-            if uz.shape[0] != magnon.nspin:
-                raise ValueError(
-                    f"Number of spins in uz file ({uz.shape[0]}) does not match the system ({magnon.nspin})"
-                )
-        else:
-            # Default: [0, 0, 1] for all spins
-            uz = np.array([[0.0, 0.0, 1.0] for _ in range(magnon.nspin)])
+    Q = [0, 0, 0] if params.Q is None else params.Q
+    n = [0, 0, 1] if params.n is None else params.n
+
+    # Handle quantization axes
+    if params.uz_file is not None:
+        uz = np.loadtxt(params.uz_file)
+        if uz.shape[1] != 3:
+            raise ValueError(
+                f"Quantization axes file should contain a natom×3 array. Got shape {uz.shape}"
+            )
+        if uz.shape[0] != magnon.nspin:
+            raise ValueError(
+                f"Number of spins in uz file ({uz.shape[0]}) does not match the system ({magnon.nspin})"
+            )
+    else:
+        # Default: [0, 0, 1] for all spins
+        # uz = np.array([[0.0, 0.0, 1.0] for _ in range(magnon.nspin)])
+        uz = np.array([[0, 0, 1]], dtype=float)
+
+    print(params)
+    if params.spin_conf_file is not None:
+        magmoms = np.loadtxt(params.spin_conf_file)
+        if magmoms.shape[1] != 3:
+            raise ValueError(
+                f"Spin configuration file should contain a nspin×3 array. Got shape {magmoms.shape}"
+            )
+        if magmoms.shape[0] != magnon.nspin:
+            raise ValueError(
+                f"Number of spins in spin configuration file ({magmoms.shape[0]}) does not match the system ({magnon.nspin})"
+            )
+    else:
+        magmoms = None
 
-        magnon.set_reference(Q, uz, n)
+    magnon.set_reference(Q, uz, n, magmoms)
 
     # Get band structure data
     print(f"\nCalculating bands along path {params.kpath}...")
@@ -714,10 +733,25 @@ def plot_magnon_bands_from_TB2J(
     return magnon
 
 
-def main():
-    """Command line interface for plotting magnon bands from TB2J results."""
+def plot_magnon_bands_cli():
     import argparse
-
+    import warnings
+
+    warnings.warn(
+        """ 
+        # !!!!!!!!!!!!!!!!!! WARNING: =============================
+        # 
+        # This functionality is under development and should not be used in production.
+        # It is provided for testing and development purposes only.
+        # Please use with caution and report any issues to the developers.
+        #
+        # This warning will be removed in future releases.
+        # =====================================
+
+        """,
+        UserWarning,
+        stacklevel=2,
+    )
     parser = argparse.ArgumentParser(
         description="Plot magnon band structure from TB2J results"
     )
@@ -737,27 +771,32 @@ def main():
 
     # Command line arguments (used if no config file is provided)
     parser.add_argument(
+        "-p",
         "--path",
         default="TB2J_results",
         help="Path to TB2J results directory (default: TB2J_results)",
     )
     parser.add_argument(
+        "-k",
         "--kpath",
         default=None,
         help="k-path specification (default: auto-detected from type of cell)",
     )
     parser.add_argument(
+        "-n",
         "--npoints",
         type=int,
         default=300,
         help="Number of k-points along the path (default: 300)",
     )
     parser.add_argument(
+        "-o",
         "--output",
         default="magnon_bands.png",
         help="Output file name (default: magnon_bands.png)",
     )
     parser.add_argument(
+        "-j",
         "--Jiso",
         action="store_true",
         default=True,
@@ -770,18 +809,21 @@ def main():
         help="Exclude isotropic exchange interactions",
     )
     parser.add_argument(
+        "-a",
         "--Jani",
         action="store_true",
         default=False,
         help="Include anisotropic exchange interactions (default: False)",
     )
     parser.add_argument(
+        "-d",
         "--DMI",
         action="store_true",
         default=False,
         help="Include Dzyaloshinskii-Moriya interactions (default: False)",
     )
     parser.add_argument(
+        "-q",
         "--Q",
         nargs=3,
         type=float,
@@ -789,11 +831,19 @@ def main():
         help="Propagation vector [Qx, Qy, Qz] (default: [0, 0, 0])",
     )
     parser.add_argument(
+        "-u",
         "--uz-file",
         type=str,
-        help="Path to file containing quantization axes for each spin (natom×3 array)",
+        help="Path to file containing quantization axes for each spin (nspin×3 array)",
+    )
+    parser.add_argument(
+        "-c",
+        "--spin-conf-file",
+        type=str,
+        help="Path to file containing magnetic moments for each spin (nspin×3 array)",
     )
     parser.add_argument(
+        "-v",
         "--n",
         nargs=3,
         type=float,
@@ -802,6 +852,7 @@ def main():
     )
 
     parser.add_argument(
+        "-s",
         "--show",
         action="store_true",
         default=False,
@@ -833,6 +884,7 @@ def main():
             DMI=args.DMI,
             Q=args.Q if args.Q is not None else None,
             uz_file=args.uz_file,
+            spin_conf_file=args.spin_conf_file,
             n=args.n if args.n is not None else None,
             show=args.show,
         )
@@ -840,10 +892,6 @@ def main():
     plot_magnon_bands_from_TB2J(params)
 
 
-if __name__ == "__main__":
-    main()
-
-
 class MagnonASEWrapper:
     def __init__(self, magnon: Magnon):
         self.magnon = magnon

TB2J/magnon/plot_magnon_dos_cli.py

@@ -4,6 +4,8 @@
 import argparse
 from pathlib import Path
 
+import numpy as np
+
 from TB2J.magnon.magnon3 import Magnon
 from TB2J.magnon.magnon_dos import plot_magnon_dos
 
@@ -13,6 +15,7 @@ def main():
         description="Calculate and plot magnon DOS from TB2J results"
     )
     parser.add_argument(
+        "-p",
         "--path",
         default="TB2J_results",
         help="Path to TB2J results directory (default: TB2J_results)",
@@ -51,26 +54,135 @@ def main():
         help="Number of energy points (default: 401)",
     )
     parser.add_argument(
+        "-o",
         "--output",
         default="magnon_dos.png",
         help="Output filename for plot (default: magnon_dos.png)",
     )
     parser.add_argument(
-        "-show",
+        "-s",
+        "--show",
         action="store_true",
         dest="show",
         help="Show plot window",
     )
 
+    # Exchange interaction options (same as in magnon bands)
+    parser.add_argument(
+        "-j",
+        "--Jiso",
+        action="store_true",
+        default=True,
+        help="Include isotropic exchange interactions (default: True)",
+    )
+    parser.add_argument(
+        "--no-Jiso",
+        action="store_false",
+        dest="Jiso",
+        help="Exclude isotropic exchange interactions",
+    )
+    parser.add_argument(
+        "-a",
+        "--Jani",
+        action="store_true",
+        default=False,
+        help="Include anisotropic exchange interactions (default: False)",
+    )
+    parser.add_argument(
+        "-d",
+        "--DMI",
+        action="store_true",
+        default=False,
+        help="Include Dzyaloshinskii-Moriya interactions (default: False)",
+    )
+
+    # Reference vector options (same as in magnon bands)
+    parser.add_argument(
+        "-q",
+        "--Q",
+        nargs=3,
+        type=float,
+        metavar=("Qx", "Qy", "Qz"),
+        help="Propagation vector [Qx, Qy, Qz] (default: [0, 0, 0])",
+    )
+    parser.add_argument(
+        "-u",
+        "--uz-file",
+        type=str,
+        help="Path to file containing quantization axes for each spin (nspin×3 array)",
+    )
+    parser.add_argument(
+        "-c",
+        "--spin-conf-file",
+        type=str,
+        help="Path to file containing magnetic moments for each spin (nspin×3 array)",
+    )
+    parser.add_argument(
+        "-v",
+        "--n",
+        nargs=3,
+        type=float,
+        metavar=("nx", "ny", "nz"),
+        help="Normal vector for rotation [nx, ny, nz] (default: [0, 0, 1])",
+    )
+
     args = parser.parse_args()
 
     # Check if TB2J results exist
     if not Path(args.path).exists():
         raise FileNotFoundError(f"TB2J results not found at {args.path}")
 
-    # Load magnon calculator
+    # Load magnon calculator with exchange interaction options
     print(f"Loading exchange parameters from {args.path}...")
-    magnon = Magnon.from_TB2J_results(path=args.path)
+    magnon = Magnon.from_TB2J_results(
+        path=args.path, Jiso=args.Jiso, Jani=args.Jani, DMI=args.DMI
+    )
+
+    # Set reference vectors if provided (same logic as in magnon bands)
+    Q = [0, 0, 0] if args.Q is None else args.Q
+    n = [0, 0, 1] if args.n is None else args.n
+
+    # Handle quantization axes
+    if args.uz_file is not None:
+        # Make path relative to TB2J results if not absolute
+        uz_file = args.uz_file
+        if not Path(uz_file).is_absolute():
+            uz_file = str(Path(args.path) / uz_file)
+
+        uz = np.loadtxt(uz_file)
+        if uz.shape[1] != 3:
+            raise ValueError(
+                f"Quantization axes file should contain a nspin×3 array. Got shape {uz.shape}"
+            )
+        if uz.shape[0] != magnon.nspin:
+            raise ValueError(
+                f"Number of spins in uz file ({uz.shape[0]}) does not match the system ({magnon.nspin})"
+            )
+    else:
+        # Default: [0, 0, 1] for all spins
+        uz = np.array([[0, 0, 1]], dtype=float)
+
+    # Handle spin configuration
+    if args.spin_conf_file is not None:
+        # Make path relative to TB2J results if not absolute
+        spin_conf_file = args.spin_conf_file
+        if not Path(spin_conf_file).is_absolute():
+            spin_conf_file = str(Path(args.path) / spin_conf_file)
+
+        magmoms = np.loadtxt(spin_conf_file)
+        if magmoms.shape[1] != 3:
+            raise ValueError(
+                f"Spin configuration file should contain a nspin×3 array. Got shape {magmoms.shape}"
+            )
+        if magmoms.shape[0] != magnon.nspin:
+            raise ValueError(
+                f"Number of spins in spin configuration file ({magmoms.shape[0]}) does not match the system ({magnon.nspin})"
+            )
+    else:
+        magmoms = None
+
+    # Set reference configuration
+    magnon.set_reference(Q, uz, n, magmoms)
 
     # Convert window from meV to eV if provided
     window = None

TB2J/myTB.py

@@ -1,15 +1,17 @@
-import os
-import numpy as np
 import copy
-from scipy.linalg import eigh
-from scipy.sparse import csr_matrix
-from scipy.io import netcdf_file
+import os
 from collections import defaultdict
 
+import numpy as np
+
 # from tbmodels import Model
 from ase.atoms import Atoms
+from scipy.io import netcdf_file
+from scipy.linalg import eigh
+from scipy.sparse import csr_matrix
+
 from TB2J.utils import auto_assign_basis_name
-from TB2J.wannier import parse_ham, parse_xyz, parse_atoms, parse_tb
+from TB2J.wannier import parse_atoms, parse_ham, parse_tb, parse_xyz
 
 
 class AbstractTB:
@@ -187,9 +189,7 @@ class MyTB(AbstractTB):
         if os.path.exists(tb_fname):
             xcart, nbasis, data, R_degens = parse_tb(fname=tb_fname)
         else:
-            nbasis, data, R_degens = parse_ham(
-                fname=os.path.join(path, prefix + "_hr.dat")
-            )
+            nbasis, data, R_degens = parse_ham(fname=hr_fname)
             xcart, _, _ = parse_xyz(fname=os.path.join(path, prefix + "_centres.xyz"))
 
         if atoms is None:
@@ -237,7 +237,7 @@ class MyTB(AbstractTB):
         return m
 
     def gen_ham(self, k, convention=2):
-        """
+        r"""
         generate hamiltonian matrix at k point.
         H_k( i, j)=\sum_R H_R(i, j)^phase.
         There are two conventions,
@@ -451,7 +451,7 @@ class MyTB(AbstractTB):
         nbasis = root.dimensions["nbasis"]
         nspin = root.dimensions["nspin"]
         ndim = root.dimensions["ndim"]
-        natom = root.dimensions["natom"]
+        _natom = root.dimensions["natom"]
         Rlist = root.variables["R"][:]
         mdata_real = root.variables["data_real"][:]
         mdata_imag = root.variables["data_imag"][:]

TB2J/pauli.py

@@ -59,7 +59,7 @@ def pauli_decomp2(M):
     )
 
 
-def pauli_sigma_norm(M):
+def pauli_sigma_norm_old(M):
     MI, Mx, My, Mz = pauli_decomp2(M)
     return np.linalg.norm([Mx, My, Mz])
 
@@ -134,7 +134,7 @@ def pauli_block(M, idim):
     return tmp
 
 
-def pauli_block_all(M):
+def pauli_block_all_old(M):
     MI = (M[::2, ::2] + M[1::2, 1::2]) / 2.0
     Mx = (M[::2, 1::2] + M[1::2, ::2]) / 2.0
     # Note that this is not element wise product with sigma_y but dot product
@@ -143,6 +143,28 @@ def pauli_block_all(M):
     return MI, Mx, My, Mz
 
 
+def pauli_block_all(array):
+    A00 = array[..., ::2, ::2]
+    A01 = array[..., ::2, 1::2]
+    A10 = array[..., 1::2, ::2]
+    A11 = array[..., 1::2, 1::2]
+    n2 = array.shape[-1] // 2
+
+    out_dtype = np.result_type(array.dtype, np.complex64)
+    block = np.empty((*array.shape[:-2], 4, n2, n2), dtype=out_dtype)
+
+    np.add(A00, A11, out=block[..., 0, :, :])
+    block[..., 0, :, :] *= 0.5
+    np.add(A01, A10, out=block[..., 1, :, :])
+    block[..., 1, :, :] *= 0.5
+    np.subtract(A01, A10, out=block[..., 2, :, :])
+    block[..., 2, :, :] *= 0.5j
+    np.subtract(A00, A11, out=block[..., 3, :, :])
+    block[..., 3, :, :] *= 0.5
+
+    return block
+
+
 def gather_pauli_blocks(MI, Mx, My, Mz, coeffs=[1.0, 1.0, 1.0, 1.0]):
     """
     Gather the I, x, y, z component of a matrix.
@@ -212,3 +234,11 @@ def pauli_block_sigma_norm(M):
     evec = np.array((ex, ey, ez))
     evec = evec / np.linalg.norm(evec)
     return Mx * evec[0] + My * evec[1] + Mz * evec[2]
+
+
+def pauli_sigma_norm(array):
+    block = pauli_block_all(array)[..., 1:, :, :]
+    E = np.trace(block, axis1=-2, axis2=-1)
+    E /= np.linalg.norm(E, axis=-1, keepdims=True)
+    np.multiply(block, E[..., None, None], out=block)
+    return block.sum(axis=-3)

TB2J/plot.py

@@ -1,11 +1,12 @@
+import argparse
+import os
+
 import matplotlib.pyplot as plt
-from TB2J.spinham.spin_api import SpinModel
-from TB2J.io_exchange.io_exchange import SpinIO
 import numpy as np
-from TB2J import __version__
+
+from TB2J.io_exchange.io_exchange import SpinIO
 from TB2J.spinham.qsolver import QSolverASEWrapper
-import argparse
-import os
+from TB2J.spinham.spin_api import SpinModel
 
 
 def write_eigen(qmesh, gamma=True, path="./", output_fname="EigenJq.txt", **kwargs):
@@ -25,7 +26,7 @@ def plot_magnon_band(
     Jq=False,
     kpath_fname="exchange_kpth.txt",
     ax=None,
-    **kwargs
+    **kwargs,
 ):
     m = SpinModel(fname=fname, sc_matrix=None)
     m.set_ham(**kwargs)
@@ -57,7 +58,7 @@ def plot_magnon_dos(
     txt_filename="magnon_dos.txt",
     Jq=False,
     ax=None,
-    **kwargs
+    **kwargs,
 ):
     ffname = os.path.join(path, "exchange.xml")
     if not (os.path.exists(ffname) and os.path.isfile(ffname)):

TB2J/rotate_atoms.py

@@ -1,8 +1,9 @@
 #!/usr/bin/env python3
 import copy
-from ase.io import read, write
+
 import numpy as np
-from TB2J.tensor_rotate import Rxx, Rxy, Rxz, Ryx, Ryy, Ryz, Rzx, Rzy, Rzz
+from ase.io import read, write
+from TB2J.tensor_rotate import Rzx, Rzy, Rzz
 
 
 def rotate_atom_xyz(atoms, noncollinear=False):
@@ -15,14 +16,16 @@ 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)]
-    
+
     for axis in rotation_axes:
         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):
@@ -109,7 +112,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+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.")
+        write(f"atoms_{i}.{ftype}", rotated_atoms)
+    print(
+        f"The output has been written to the atoms_i.{ftype} files. atoms_0.{ftype} contains the reference structure."
+    )

TB2J/scripts/TB2J_downfold.py

@@ -0,0 +1,97 @@
+#!/usr/bin/env python3
+import argparse
+
+from TB2J.Jdownfolder import JDownfolder_pickle
+from TB2J.versioninfo import print_license
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="TB2J_downfold: Downfold the exchange parameter with ligand spin as independent variable to that only with metal site spin as independent variables."
+    )
+    parser.add_argument(
+        "--inpath",
+        "-i",
+        type=str,
+        help="The path of the input TB2J results before the downfolding.",
+        default="TB2J_results",
+    )
+
+    parser.add_argument(
+        "--outpath",
+        "-o",
+        type=str,
+        help="The path of the output TB2J results path after the downfolding",
+        default="TB2J_results_downfolded",
+    )
+
+    parser.add_argument(
+        "--metals",
+        "-m",
+        type=str,
+        help="List of magnetic cation elements",
+        nargs="+",
+        default=[],
+    )
+
+    parser.add_argument(
+        "--ligands",
+        "-l",
+        type=str,
+        help="List of ligand elements",
+        nargs="+",
+        default=[],
+    )
+
+    parser.add_argument(
+        "--qmesh",
+        help="kmesh in the format of kx ky kz",
+        type=int,
+        nargs="*",
+        default=[5, 5, 5],
+    )
+
+    parser.add_argument(
+        "--iso_only",
+        help="whether to downfold only the isotropic part. The other parts will be neglected.",
+        action="store_true",
+        default=False,
+    )
+
+    parser.add_argument(
+        "--method",
+        help="The method to downfold the exchange parameter. Options are Lowdin and PWF (projected Wannier function). ",
+        type=str,
+        default="Lowdin",
+    )
+
+    args = parser.parse_args()
+
+    if len(args.metals) == []:
+        print("List of magnetic cation elements cannot be empty")
+
+    if len(args.ligands) == []:
+        print("List of ligand elements cannot be empty")
+
+    print_license()
+    print("Input path:", args.inpath)
+    print("Output path:", args.outpath)
+    print("Magnetic cation elements:", args.metals)
+    print("Ligand elements:", args.ligands)
+    print("k-mesh:", args.qmesh)
+    print("Downfolding method:", args.method)
+    print("Downfolding only isotropic part:", args.iso_only)
+    print("Begining downfolding the exchange parameters:")
+    JDownfolder_pickle(
+        inpath=args.inpath,
+        metals=args.metals,
+        ligands=args.ligands,
+        outpath=args.outpath,
+        qmesh=args.qmesh,
+        iso_only=args.iso_only,
+        method=args.method,
+    )
+    print("Downfolding finished. Results are saved in:", args.outpath)
+
+
+main()