TB2J 0.9.9rc16__py3-none-any.whl → 0.9.9rc17__py3-none-any.whl

TB2J/io_exchange/__init__.py

@@ -1 +1,3 @@
 from .io_exchange import SpinIO
+
+__all__ = ["SpinIO"]

TB2J/magnon/__init__.py

@@ -0,0 +1,3 @@
+from .io_exchange2 import ExchangeIO, plot_tb2j_magnon_bands
+
+__all__ = ["ExchangeIO", "plot_tb2j_magnon_bands"]

TB2J/magnon/io_exchange2.py

@@ -0,0 +1,688 @@
+"""
+This module provides functionality for handling magnetic exchange interactions and computing magnon band structures.
+
+It includes classes and functions for:
+- Reading and writing exchange interaction data
+- Computing exchange tensors and magnon energies
+- Plotting magnon band structures
+- Converting between different magnetic structure representations
+"""
+
+import numpy as np
+from scipy.spatial.transform import Rotation
+
+from ..mathutils import generate_grid, get_rotation_arrays, round_to_precision, uz
+from .plot import BandsPlot
+from .structure import BaseMagneticStructure, get_attribute_array
+
+__all__ = [
+    "ExchangeIO",
+    "plot_tb2j_magnon_bands",
+]
+
+
+def branched_keys(tb2j_keys, npairs):
+    """
+    Organize TB2J keys into branches based on magnetic site pairs.
+
+    Parameters
+    ----------
+    tb2j_keys : list
+        List of TB2J dictionary keys containing interaction information
+    npairs : int
+        Number of magnetic site pairs
+
+    Returns
+    -------
+    list
+        List of branched keys organized by magnetic site pairs
+    """
+    msites = int((2 * npairs) ** 0.5)
+    branch_size = len(tb2j_keys) // msites**2
+    new_keys = sorted(tb2j_keys, key=lambda x: -x[1] + x[2])[
+        (npairs - msites) * branch_size :
+    ]
+    new_keys.sort(key=lambda x: x[1:])
+    bkeys = [
+        new_keys[i : i + branch_size] for i in range(0, len(new_keys), branch_size)
+    ]
+
+    return [sorted(branch, key=lambda x: np.linalg.norm(x[0])) for branch in bkeys]
+
+
+def correct_content(content, quadratic=False):
+    """
+    Ensure content dictionary has all required entries with proper initialization.
+
+    Parameters
+    ----------
+    content : dict
+        Dictionary containing exchange interaction data
+    quadratic : bool, optional
+        Whether to include biquadratic interactions, by default False
+    """
+    n = max(content["index_spin"]) + 1
+    data_shape = {"exchange_Jdict": ()}
+
+    if not content["colinear"]:
+        data_shape |= {"Jani_dict": (3, 3), "dmi_ddict": (3,)}
+    if quadratic:
+        data_shape["biquadratic_Jdict"] = (2,)
+
+    for label, shape in data_shape.items():
+        content[label] |= {((0, 0, 0), i, i): np.zeros(shape) for i in range(n)}
+
+
+def Hermitize(array):
+    """
+    Convert an array into its Hermitian form by constructing a Hermitian matrix.
+
+    A Hermitian matrix H has the property that H = H†, where H† is the conjugate transpose.
+    This means H[i,j] = conj(H[j,i]) for all indices i,j. The function takes an input array
+    representing the upper triangular part of the matrix and constructs the full Hermitian
+    matrix by:
+    1. Placing the input values in the upper triangular part
+    2. Computing the conjugate transpose of these values for the lower triangular part
+
+    This is commonly used in quantum mechanics and magnetic systems where Hamiltonians
+    must be Hermitian to ensure real eigenvalues.
+
+    Parameters
+    ----------
+    array : numpy.ndarray
+        Input array containing the upper triangular elements of the matrix.
+        Shape should be (n*(n+1)/2, ...) where n is the dimension of
+        the resulting square matrix.
+
+    Returns
+    -------
+    numpy.ndarray
+        Full Hermitian matrix with shape (n, n, ...), where n is computed
+        from the input array size. The result satisfies result[i,j] = conj(result[j,i])
+        for all indices i,j.
+
+    Example
+    -------
+    >>> arr = np.array([1+0j, 2+1j, 3+0j])  # Upper triangular elements for 2x2 matrix
+    >>> Hermitize(arr)
+    array([[1.+0.j, 2.+1.j],
+           [2.-1.j, 3.+0.j]])
+    """
+    n = int((2 * array.shape[0]) ** 0.5)
+    result = np.zeros((n, n) + array.shape[1:], dtype=complex)
+    u_indices = np.triu_indices(n)
+
+    result[*u_indices] = array
+    result.swapaxes(0, 1)[*u_indices] = array.swapaxes(-1, -2).conj()
+
+    return result
+
+
+class ExchangeIO(BaseMagneticStructure):
+    """
+    Class for handling magnetic exchange interactions and computing magnon properties.
+
+    This class provides functionality for:
+    - Managing magnetic structure information
+    - Computing exchange tensors
+    - Calculating magnon band structures
+    - Reading TB2J format files
+    - Visualizing magnon bands
+
+    Parameters
+    ----------
+    atoms : ase.Atoms, optional
+        ASE atoms object containing the structure
+    cell : array_like, optional
+        3x3 matrix defining the unit cell
+    elements : list, optional
+        List of chemical symbols for atoms
+    positions : array_like, optional
+        Atomic positions
+    magmoms : array_like, optional
+        Magnetic moments for each atom
+    pbc : tuple, optional
+        Periodic boundary conditions, default (True, True, True)
+    magnetic_elements : list, optional
+        List of magnetic elements in the structure
+    kmesh : list, optional
+        k-point mesh dimensions, default [1, 1, 1]
+    collinear : bool, optional
+        Whether the magnetic structure is collinear, default True
+    """
+
+    def __init__(
+        self,
+        atoms=None,
+        cell=None,
+        elements=None,
+        positions=None,
+        magmoms=None,
+        pbc=(True, True, True),
+        magnetic_elements=[],
+        kmesh=[1, 1, 1],
+        collinear=True,
+    ):
+        super().__init__(
+            atoms=atoms,
+            cell=cell,
+            elements=elements,
+            positions=positions,
+            pbc=pbc,
+            magmoms=magmoms,
+            collinear=collinear,
+        )
+
+        self.magnetic_elements = magnetic_elements
+        self.kmesh = kmesh
+
+        num_terms = 4 if collinear else 18
+        self._exchange_values = np.empty((0, 0, num_terms), dtype=float)
+
+    @property
+    def magnetic_elements(self):
+        """List of magnetic elements in the structure."""
+        return self._magnetic_elements
+
+    @magnetic_elements.setter
+    def magnetic_elements(self, value):
+        from .structure import validate_symbols
+
+        symbols = validate_symbols(value)
+        for symbol in symbols:
+            if symbol not in self.elements:
+                raise ValueError(f"Symbol '{symbol}' not in 'elements'.")
+
+        self._magnetic_elements = symbols
+        self._set_index_pairs()
+
+    @property
+    def interacting_pairs(self):
+        """List of pairs of interacting magnetic sites."""
+        return self._pairs
+
+    def _set_index_pairs(self):
+        from itertools import combinations_with_replacement
+
+        magnetic_elements = self.magnetic_elements
+        elements = self.elements
+        indices = [
+            i for i, symbol in enumerate(elements) if symbol in magnetic_elements
+        ]
+        index_pairs = list(combinations_with_replacement(indices, 2))
+        index_spin = np.sort(np.unique(index_pairs))
+
+        self._pairs = index_pairs
+        self._index_spin = index_spin
+
+    @property
+    def kmesh(self):
+        """K-point mesh dimensions for sampling the Brillouin zone."""
+        return self._kmesh
+
+    @kmesh.setter
+    def kmesh(self, values):
+        try:
+            the_kmesh = [int(k) for k in values]
+        except (ValueError, TypeError):
+            raise ValueError("Argument must be an iterable with 'int' elements.")
+        if len(the_kmesh) != 3:
+            raise ValueError("Argument must be of length 3.")
+        if any(k < 1 for k in the_kmesh):
+            raise ValueError("Argument must contain only positive numbers.")
+
+        self._kmesh = the_kmesh
+
+    @property
+    def vectors(self):
+        """Array of interaction vectors between magnetic sites."""
+        return self._exchange_values[:, :, :3]
+
+    def set_vectors(self, values=None, cartesian=False):
+        """
+        Set the interaction vectors between magnetic sites.
+
+        Parameters
+        ----------
+        values : array_like, optional
+            Array of interaction vectors
+        cartesian : bool, optional
+            Whether the vectors are in Cartesian coordinates, default False
+        """
+        try:
+            pairs = self._pairs
+        except AttributeError:
+            raise AttributeError("'magnetic_elements' attribute has not been set yet.")
+        else:
+            n_pairs = len(pairs)
+
+        if values is None:
+            i, j = zip(*pairs)
+            positions = self.positions
+            base_vectors = positions[i, :] - positions[j, :]
+            grid = generate_grid(self.kmesh)
+            vectors = base_vectors[:, None, :] + grid[None, :, :]
+            m_interactions = np.prod(self.kmesh)
+        else:
+            vectors = get_attribute_array(values, "vectors", dtype=float)
+            if vectors.ndim != 3 or vectors.shape[::2] != (n_pairs, 3):
+                raise ValueError(
+                    f"'vectors' must have the shape (n, m, ), where n={n_pairs} is the number of\n"
+                    "pairs of interacting species."
+                )
+            if cartesian:
+                vectors = np.linalg.solve(self.cell.T, vectors.swapaxes(1, -1))
+                vectors = vectors.swapaxes(-1, 1)
+            m_interactions = vectors.shape[1]
+
+        shape = (
+            (n_pairs, m_interactions, 4)
+            if self.collinear
+            else (n_pairs, m_interactions, 18)
+        )
+        exchange_values = np.zeros(shape, dtype=float)
+        exchange_values[:, :, :3] = vectors
+        self._exchange_values = exchange_values
+
+    def _get_neighbor_indices(self, neighbors, tol=1e-4):
+        """
+        Get indices of neighbor pairs based on distance.
+
+        Parameters
+        ----------
+        neighbors : list
+            List of neighbor shells to consider
+        tol : float, optional
+            Distance tolerance for neighbor shell assignment, default 1e-4
+
+        Returns
+        -------
+        tuple
+            Indices corresponding to the specified neighbor shells
+        """
+        distance = np.linalg.norm(self.vectors @ self.cell, axis=-1)
+        distance = round_to_precision(distance, tol)
+        neighbors_distance = np.unique(np.sort(distance))
+        indices = np.where(
+            distance[:, :, None] == neighbors_distance[neighbors][None, None, :]
+        )
+
+        return indices
+
+    def set_exchange_array(self, name, values, neighbors=None, tol=1e-4):
+        """
+        Set exchange interaction values for specified neighbors.
+
+        Parameters
+        ----------
+        name : str
+            Type of exchange interaction ('Jiso', 'Biquad', 'DMI', or 'Jani')
+        values : array_like
+            Exchange interaction values
+        neighbors : list, optional
+            List of neighbor shells to assign values to
+        tol : float, optional
+            Distance tolerance for neighbor shell assignment, default 1e-4
+        """
+        if self.vectors.size == 0:
+            raise AttributeError("The intraction vectors must be set first.")
+
+        array = get_attribute_array(values, name, dtype=float)
+
+        if neighbors is not None:
+            if len(array) != len(neighbors):
+                raise ValueError(
+                    "The number of neighbors and exchange values does not coincide."
+                )
+            *array_indices, value_indices = self._get_neighbor_indices(
+                list(neighbors), tol=tol
+            )
+        else:
+            if self._exchange_values.shape[:2] != array.shape[:2]:
+                raise ValueError(
+                    f"The shape of the array is incompatible with '{self.exchange_values.shape}'"
+                )
+            array_indices, value_indices = (
+                [slice(None), slice(None)],
+                (slice(None), slice(None)),
+            )
+
+        if name == "Jiso":
+            self._exchange_values[*array_indices, 3] = array[value_indices]
+        elif name == "Biquad":
+            self._exchange_values[*array_indices, 4:6] = array[value_indices]
+        elif name == "DMI":
+            self._exchange_values[*array_indices, 6:9] = array[value_indices]
+        elif name == "Jani":
+            self._exchange_values[*array_indices, 9:] = array[value_indices].reshape(
+                array.shape[:2] + (9,)
+            )
+        else:
+            raise ValueError(f"Unrecognized exchange array name: '{name}'.")
+
+    @property
+    def Jiso(self):
+        return self._exchange_values[:, :, 3]
+
+    @property
+    def Biquad(self):
+        return self._exchange_values[:, :, 4:6]
+
+    @property
+    def DMI(self):
+        return self._exchange_values[:, :, 6:9]
+
+    @property
+    def Jani(self):
+        matrix_shape = self._exchange_values.shape[:2] + (3, 3)
+        return self._exchange_values[:, :, 9:].reshape(matrix_shape)
+
+    def exchange_tensor(self, anisotropic=True):
+        """
+        Compute the exchange interaction tensor.
+
+        Parameters
+        ----------
+        anisotropic : bool, optional
+            Whether to include anisotropic interactions, default True
+
+        Returns
+        -------
+        numpy.ndarray
+            Exchange interaction tensor
+        """
+        shape = self._exchange_values.shape[:2] + (3, 3)
+        tensor = np.zeros(shape, dtype=float)
+
+        if anisotropic and not self.collinear:
+            tensor += self._exchange_values[:, :, 9:].reshape(shape)
+            pos_indices = ([1, 2, 0], [2, 0, 1])
+            neg_indices = ([2, 0, 1], [1, 2, 0])
+            tensor[:, :, *pos_indices] += self._exchange_values[:, :, 6:9]
+            tensor[:, :, *neg_indices] -= self._exchange_values[:, :, 6:9]
+        diag_indices = ([0, 1, 2], [0, 1, 2])
+        tensor[:, :, *diag_indices] += self._exchange_values[:, :, 3, None]
+
+        return tensor
+
+    def Jq(self, kpoints, anisotropic=True):
+        """
+        Compute the exchange interactions in reciprocal space.
+
+        Parameters
+        ----------
+        kpoints : array_like
+            k-points at which to evaluate the exchange interactions
+        anisotropic : bool, optional
+            Whether to include anisotropic interactions, default True
+
+        Returns
+        -------
+        numpy.ndarray
+            Exchange interactions in reciprocal space
+        """
+        vectors = self._exchange_values[:, :, :3].copy()
+        tensor = self.exchange_tensor(anisotropic=anisotropic)
+
+        if self._Q is not None:
+            phi = 2 * np.pi * vectors.round(3).astype(int) @ self._Q
+            rv = np.einsum("ij,k->ijk", phi, self._n)
+            R = (
+                Rotation.from_rotvec(rv.reshape(-1, 3))
+                .as_matrix()
+                .reshape(vectors.shape[:2] + (3, 3))
+            )
+            np.einsum("nmij,nmjk->nmik", tensor, R, out=tensor)
+
+        exp_summand = np.exp(2j * np.pi * vectors @ kpoints.T)
+        Jexp = exp_summand[:, :, :, None, None] * tensor[:, :, None]
+        Jq = np.sum(Jexp, axis=1)
+
+        pairs = np.array(self._pairs)
+        idx = np.where(pairs[:, 0] == pairs[:, 1])
+        Jq[idx] /= 2
+
+        return Jq
+
+    def Hq(self, kpoints, anisotropic=True, u=uz):
+        """
+        Compute the magnon Hamiltonian in reciprocal space.
+
+        Parameters
+        ----------
+        kpoints : array_like
+            k-points at which to evaluate the Hamiltonian
+        anisotropic : bool, optional
+            Whether to include anisotropic interactions, default True
+        u : array_like, optional
+            Reference direction for spin quantization axis
+
+        Returns
+        -------
+        numpy.ndarray
+            Magnon Hamiltonian matrix at each k-point
+        """
+        if self.collinear:
+            magmoms = np.zeros((self._index_spin.size, 3))
+            magmoms[:, 2] = self.magmoms[self._index_spin]
+        else:
+            magmoms = self.magmoms[self._index_spin]
+        magmoms /= np.linalg.norm(magmoms, axis=-1)[:, None]
+
+        U, V = get_rotation_arrays(magmoms, u=u)
+
+        J0 = self.Jq(np.zeros((1, 3)), anisotropic=anisotropic)
+        J0 = -Hermitize(J0)[:, :, 0]
+        Jq = -Hermitize(self.Jq(kpoints, anisotropic=anisotropic))
+
+        C = np.diag(np.einsum("ix,ijxy,jy->i", V, 2 * J0, V))
+        B = np.einsum("ix,ijkxy,jy->kij", U, Jq, U)
+        A1 = np.einsum("ix,ijkxy,jy->kij", U, Jq, U.conj())
+        A2 = np.einsum("ix,ijkxy,jy->kij", U.conj(), Jq, U)
+
+        return np.block([[A1 - C, B], [B.swapaxes(-1, -2).conj(), A2 - C]])
+
+    def _magnon_energies(self, kpoints, anisotropic=True, u=uz):
+        H = self.Hq(kpoints, anisotropic=anisotropic, u=u)
+        n = H.shape[-1] // 2
+        I = np.eye(n)
+
+        min_eig = 0.0
+        try:
+            K = np.linalg.cholesky(H)
+        except np.linalg.LinAlgError:
+            try:
+                K = np.linalg.cholesky(H + 1e-6 * np.eye(2 * n))
+            except np.linalg.LinAlgError:
+                from warnings import warn
+
+                min_eig = np.min(np.linalg.eigvalsh(H))
+                K = np.linalg.cholesky(H - (min_eig - 1e-6) * np.eye(2 * n))
+                warn(
+                    f"WARNING: The system may be far from the magnetic ground-state. Minimum eigenvalue: {min_eig}. The magnon energies might be unphysical."
+                )
+
+        g = np.block([[1 * I, 0 * I], [0 * I, -1 * I]])
+        KH = K.swapaxes(-1, -2).conj()
+
+        return np.linalg.eigvalsh(KH @ g @ K)[:, n:] + min_eig
+
+    def get_magnon_bands(
+        self,
+        kpoints: np.array = np.array([]),
+        path: str = None,
+        npoints: int = 300,
+        special_points: dict = None,
+        tol: float = 2e-4,
+        pbc: tuple = None,
+        cartesian: bool = False,
+        labels: list = None,
+        anisotropic: bool = True,
+        u: np.array = uz,
+    ):
+        pbc = self._pbc if pbc is None else pbc
+
+        if kpoints.size == 0:
+            from ase.cell import Cell
+
+            bandpath = Cell(self._cell).bandpath(
+                path=path,
+                npoints=npoints,
+                special_points=special_points,
+                eps=tol,
+                pbc=pbc,
+            )
+            kpoints = bandpath.kpts
+            spk = bandpath.special_points
+            spk[r"$\Gamma$"] = spk.pop("G", np.zeros(3))
+            labels = [
+                (i, symbol)
+                for symbol in spk
+                for i in np.where((kpoints == spk[symbol]).all(axis=1))[0]
+            ]
+        elif cartesian:
+            kpoints = np.linalg.solve(self._cell.T, kpoints.T).T
+
+        bands = self._magnon_energies(kpoints, anisotropic=anisotropic, u=u)
+
+        return labels, bands
+
+    def plot_magnon_bands(self, **kwargs):
+        """
+        Plot magnon band structure.
+
+        Parameters
+        ----------
+        **kwargs
+            Additional keyword arguments passed to get_magnon_bands and plotting functions
+        """
+        filename = kwargs.pop("filename", None)
+        kpath, bands = self.get_magnon_bands(**kwargs)
+        bands_plot = BandsPlot(bands, kpath)
+        bands_plot.plot(filename=filename)
+
+    @classmethod
+    def load_tb2j(
+        cls,
+        pickle_file: str = "TB2J.pickle",
+        pbc: tuple = (True, True, True),
+        anisotropic: bool = False,
+        quadratic: bool = False,
+    ):
+        from pickle import load
+
+        try:
+            with open(pickle_file, "rb") as File:
+                content = load(File)
+        except FileNotFoundError:
+            raise FileNotFoundError(
+                f"No such file or directory: '{pickle_file}'. Please provide a valid .pickle file."
+            )
+        else:
+            correct_content(content)
+
+        magmoms = content["magmoms"] if content["colinear"] else content["spinat"]
+        magnetic_elements = {
+            content["atoms"].numbers[i]
+            for i, j in enumerate(content["index_spin"])
+            if j > -1
+        }
+
+        exchange = cls(
+            atoms=content["atoms"],
+            magmoms=magmoms,
+            pbc=pbc,
+            collinear=content["colinear"],
+            magnetic_elements=magnetic_elements,
+        )
+
+        num_pairs = len(exchange.interacting_pairs)
+        bkeys = branched_keys(content["distance_dict"].keys(), num_pairs)
+
+        vectors = [
+            [content["distance_dict"][key][0] for key in branch] for branch in bkeys
+        ]
+        exchange.set_vectors(vectors, cartesian=True)
+        Jiso = [[content["exchange_Jdict"][key] for key in branch] for branch in bkeys]
+        exchange.set_exchange_array("Jiso", Jiso)
+
+        if not content["colinear"] and anisotropic:
+            Jani = [[content["Jani_dict"][key] for key in branch] for branch in bkeys]
+            exchange.set_exchange_array("Jani", Jani)
+            DMI = [[content["dmi_ddict"][key] for key in branch] for branch in bkeys]
+            exchange.set_exchange_array("DMI", DMI)
+        if quadratic:
+            Biquad = [
+                [content["biquadratic_Jdict"][key] for key in branch]
+                for branch in bkeys
+            ]
+            exchange.set_exchange_array("Biquad", Biquad)
+
+        return exchange
+
+
+def plot_tb2j_magnon_bands(
+    pickle_file: str = "TB2J.pickle",
+    path: str = None,
+    npoints: int = 300,
+    special_points: dict = None,
+    anisotropic: bool = False,
+    quadratic: bool = False,
+    pbc: tuple = (True, True, True),
+    filename: str = None,
+):
+    """
+    Load TB2J data and plot magnon band structure in one step.
+
+    This is a convenience function that combines loading TB2J data and plotting
+    magnon bands. It first loads the magnetic structure and exchange interactions
+    from a TB2J pickle file, then calculates and plots the magnon band structure.
+
+    Parameters
+    ----------
+    pickle_file : str, optional
+        Path to the TB2J pickle file, default "TB2J.pickle"
+    path : str, optional
+        High-symmetry k-point path for band structure plot
+        (e.g., "GXMG" for a square lattice)
+    npoints : int, optional
+        Number of k-points for band structure calculation, default 300
+    special_points : dict, optional
+        Dictionary of special k-points for custom paths
+    anisotropic : bool, optional
+        Whether to include anisotropic interactions, default False
+    quadratic : bool, optional
+        Whether to include biquadratic interactions, default False
+    pbc : tuple, optional
+        Periodic boundary conditions, default (True, True, True)
+    filename : str, optional
+        If provided, save the plot to this file
+
+    Returns
+    -------
+    exchange : ExchangeIO
+        The ExchangeIO instance containing the loaded data and plot
+
+    Example
+    -------
+    >>> # Basic usage with default parameters
+    >>> plot_tb2j_magnon_bands()
+
+    >>> # Custom path and saving to file
+    >>> plot_tb2j_magnon_bands(
+    ...     path="GXMG",
+    ...     anisotropic=True,
+    ...     filename="magnon_bands.png"
+    ... )
+    """
+    # Load the TB2J data
+    exchange = ExchangeIO.load_tb2j(
+        pickle_file=pickle_file, pbc=pbc, anisotropic=anisotropic, quadratic=quadratic
+    )
+
+    # Plot the magnon bands
+    exchange.plot_magnon_bands(
+        path=path, npoints=npoints, special_points=special_points, filename=filename
+    )
+
+    return exchange

TB2J/magnon/plot.py

@@ -0,0 +1,58 @@
+import matplotlib.pyplot as plt
+import numpy as np
+
+
+class BandsPlot:
+    _UNITS = "meV"
+    _NSYSTEMS = 1
+
+    def __init__(self, bands, kpath, **kwargs):
+        self.bands = bands
+        self.kpath = kpath
+        self.bands *= 1000
+
+        plot_options = kwargs
+        self.linewidth = plot_options.pop("linewidth", 1.5)
+        self.color = plot_options.pop("color", "blue")
+        self.fontsize = plot_options.pop("fontsize", 12)
+        self.ticksize = plot_options.pop("ticksize", 10)
+        self.plot_options = plot_options
+
+    def plot(self, filename=None):
+        fig, axs = plt.subplots(1, self._NSYSTEMS, constrained_layout=True)
+
+        kdata = np.arange(self.bands.shape[0])
+        for band in self.bands.T:
+            axs.plot(
+                kdata,
+                band,
+                linewidth=self.linewidth,
+                color=self.color,
+                **self.plot_options,
+            )
+
+        bmin, bmax = self.bands.min(), self.bands.max()
+        ymin, ymax = (
+            bmin - 0.05 * np.abs(bmin - bmax),
+            bmax + 0.05 * np.abs(bmax - bmin),
+        )
+
+        axs.set_ylim([ymin, ymax])
+        axs.set_xlim([0, kdata[-1]])
+
+        kpoint_labels = list(zip(*self.kpath))
+        axs.set_xticks(*kpoint_labels, fontsize=self.ticksize)
+        axs.vlines(
+            x=kpoint_labels[0],
+            ymin=ymin,
+            ymax=ymax,
+            color="black",
+            linewidth=self.linewidth / 5,
+        )
+
+        axs.set_ylabel(f"Energy ({self._UNITS})", fontsize=self.fontsize)
+
+        if filename is None:
+            plt.show()
+        else:
+            fig.save(filename, dpi=300, bbox_inches="tight")

TB2J/magnon/structure.py

@@ -0,0 +1,348 @@
+from warnings import warn
+
+import numpy as np
+
+valid_symbols = [
+    # 0
+    "Ae",
+    # 1
+    "H",
+    "He",
+    # 2
+    "Li",
+    "Be",
+    "B",
+    "C",
+    "N",
+    "O",
+    "F",
+    "Ne",
+    # 3
+    "Na",
+    "Mg",
+    "Al",
+    "Si",
+    "P",
+    "S",
+    "Cl",
+    "Ar",
+    # 4
+    "K",
+    "Ca",
+    "Sc",
+    "Ti",
+    "V",
+    "Cr",
+    "Mn",
+    "Fe",
+    "Co",
+    "Ni",
+    "Cu",
+    "Zn",
+    "Ga",
+    "Ge",
+    "As",
+    "Se",
+    "Br",
+    "Kr",
+    # 5
+    "Rb",
+    "Sr",
+    "Y",
+    "Zr",
+    "Nb",
+    "Mo",
+    "Tc",
+    "Ru",
+    "Rh",
+    "Pd",
+    "Ag",
+    "Cd",
+    "In",
+    "Sn",
+    "Sb",
+    "Te",
+    "I",
+    "Xe",
+    # 6
+    "Cs",
+    "Ba",
+    "La",
+    "Ce",
+    "Pr",
+    "Nd",
+    "Pm",
+    "Sm",
+    "Eu",
+    "Gd",
+    "Tb",
+    "Dy",
+    "Ho",
+    "Er",
+    "Tm",
+    "Yb",
+    "Lu",
+    "Hf",
+    "Ta",
+    "W",
+    "Re",
+    "Os",
+    "Ir",
+    "Pt",
+    "Au",
+    "Hg",
+    "Tl",
+    "Pb",
+    "Bi",
+    "Po",
+    "At",
+    "Rn",
+    # 7
+    "Fr",
+    "Ra",
+    "Ac",
+    "Th",
+    "Pa",
+    "U",
+    "Np",
+    "Pu",
+    "Am",
+    "Cm",
+    "Bk",
+    "Cf",
+    "Es",
+    "Fm",
+    "Md",
+    "No",
+    "Lr",
+    "Rf",
+    "Db",
+    "Sg",
+    "Bh",
+    "Hs",
+    "Mt",
+    "Ds",
+    "Rg",
+    "Cn",
+    "Nh",
+    "Fl",
+    "Mc",
+    "Lv",
+    "Ts",
+    "Og",
+]
+
+
+def get_attribute_array(array, attribute, dtype=float):
+    try:
+        the_array = np.array(array, dtype=dtype)
+    except (IndexError, ValueError, TypeError) as err:
+        typename = dtype.__name__
+        raise type(err)(
+            f"'{attribute}' must be an arraylike object of '{typename}' elements."
+        )
+
+    return the_array
+
+
+def validate_symbols(value):
+    try:
+        values_list = value.split()
+    except AttributeError:
+        try:
+            values_list = list(value)
+        except (ValueError, TypeError):
+            raise TypeError("'elements' must be an iterable of 'str' or 'int' entries.")
+
+    if all(isinstance(s, str) for s in values_list):
+        symbols = values_list
+        for symbol in symbols:
+            if symbol not in valid_symbols:
+                raise ValueError(f"Unrecognized element '{symbol}'.")
+    elif all(isinstance(i, (int, np.integer)) for i in values_list):
+        if any(i < 0 for i in values_list):
+            raise ValueError("Atomic numbers must be positive.")
+        try:
+            symbols = [valid_symbols[i] for i in values_list]
+        except IndexError:
+            raise ValueError("Atomic number exceeds 118.")
+    else:
+        raise ValueError("'elements' must be an iterable of 'str' or 'int' entries.")
+
+    return symbols
+
+
+class BaseMagneticStructure:
+    def __init__(
+        self,
+        atoms=None,
+        cell=None,
+        elements=None,
+        positions=None,
+        magmoms=None,
+        pbc=None,
+        collinear=True,
+    ):
+        if atoms is not None:
+            if any(arg is not None for arg in [cell, elements, positions]):
+                warn(
+                    "WARNING: 'atoms' overrides the 'cell', 'elements', and 'positions' arguments."
+                )
+            cell = atoms.cell.array
+            elements = atoms.numbers
+            positions = atoms.get_scaled_positions()
+            pbc = atoms.pbc if pbc is None else pbc
+        else:
+            if cell is None:
+                cell = np.zeros((3, 3))
+            if elements is None:
+                elements = ()
+            if positions is None:
+                positions = np.zeros((len(elements), 3))
+            if pbc is None:
+                pbc = (True, True, True)
+        if magmoms is None:
+            magmoms_shape = positions.shape[0] if collinear else positions.shape
+            magmoms = np.zeros(magmoms_shape)
+
+        self.cell = cell
+        self.elements = elements
+        self.positions = positions
+        self.collinear = collinear
+        self.magmoms = magmoms
+        self.pbc = pbc
+
+        self._Q = None
+        self._n = np.array([0, 0, 1])
+
+    @property
+    def cell(self):
+        return self._cell
+
+    @property
+    def reciprocal_cell(self):
+        return 2 * np.pi * np.linalg.inv(self._cell)
+
+    @cell.setter
+    def cell(self, value):
+        cell_array = get_attribute_array(value, "cell")
+        if cell_array.shape != (3, 3):
+            raise ValueError("'cell' must have a (3, 3) shape.")
+
+        self._cell = cell_array
+
+    @property
+    def elements(self):
+        return self._symbols
+
+    @elements.setter
+    def elements(self, value):
+        symbols = validate_symbols(value)
+        self._symbols = symbols
+
+    @property
+    def numbers(self):
+        return [valid_symbols.index(symbol) for symbol in self._symbols]
+
+    @property
+    def positions(self):
+        return self._positions
+
+    @property
+    def cartesian_positions(self):
+        return self._positions @ self._cell
+
+    @positions.setter
+    def positions(self, value):
+        natoms = len(self.elements)
+        posarray = get_attribute_array(value, "positions")
+        if posarray.shape != (natoms, 3):
+            raise ValueError(
+                "'positions' must have a (natoms, 3) shape, where natoms is the length of 'elements'. Make sure to set 'elements' first."
+            )
+
+        self._positions = posarray
+
+    @property
+    def magmoms(self):
+        return self._magmoms
+
+    @magmoms.setter
+    def magmoms(self, value):
+        magarray = get_attribute_array(value, "magmoms")
+        if self.collinear and magarray.shape != (len(self._positions),):
+            raise ValueError(
+                "'magmoms' must be a 1dim array with the same length as 'positions'. Make sure to set 'positions' first."
+            )
+        elif not self.collinear and magarray.shape != self._positions.shape:
+            raise ValueError(
+                "'magmoms' must have the same shape as 'positions'. Make sure to set 'positions' first."
+            )
+
+        self._magmoms = magarray
+
+    @property
+    def pbc(self):
+        return self._pbc
+
+    @pbc.setter
+    def pbc(self, value):
+        try:
+            periodic_boundary_conditions = tuple(bool(b) for b in value)
+        except (ValueError, TypeError):
+            raise TypeError("'pbc' must be an iterable of 'bool' entries.")
+
+        if len(periodic_boundary_conditions) != 3:
+            raise ValueError("'pbc' must be of length 3.")
+
+        self._pbc = periodic_boundary_conditions
+
+    @property
+    def propagation_vector(self):
+        return self._Q
+
+    @propagation_vector.setter
+    def propagation_vector(self, value):
+        Q = get_attribute_array(value, "propagation_vector")
+        if Q.shape != (3,):
+            raise ValueError(
+                "The 'propagation_vector' must be a vector with 3 numbers."
+            )
+
+        self._Q = Q
+
+    @property
+    def normal_vector(self):
+        return self._n
+
+    @normal_vector.setter
+    def normal_vector(self, value):
+        n = get_attribute_array(value, "normal_vector")
+        if n.shape != (3,):
+            raise ValueError("The 'normal_vector' must be a vector with 3 numbers.")
+
+        self._n = n
+
+    def to_ase(self):
+        from ase.atoms import Atoms
+
+        atoms = Atoms(
+            cell=self.cell,
+            positions=self.cartesian_positions,
+            numbers=[valid_symbols.index(symbol) for symbol in self.elements],
+            pbc=self.pbc,
+        )
+
+        return atoms
+
+    @classmethod
+    def from_structure_file(
+        cls, filename, magmoms=None, collinear=True, pbc=(True, True, True)
+    ):
+        from ase.io import read
+
+        atoms = read(filename)
+        atoms.pbc = pbc
+        obj = cls(atoms=atoms, magmoms=magmoms, collinear=collinear)
+
+        return obj

TB2J/mathutils/__init__.py

@@ -1 +1,2 @@
 from .lowdin import Lowdin
+from .magnons import *

TB2J/mathutils/magnons.py

@@ -0,0 +1,45 @@
+import numpy as np
+
+__all__ = ["generate_grid", "get_rotation_arrays", "round_to_precision", "uz", "I"]
+
+I = np.eye(3)
+uz = np.array([[0.0, 0.0, 1.0]])
+
+
+def generate_grid(kmesh, sort=True):
+    half_grid = [int(n / 2) for n in kmesh]
+    grid = np.stack(
+        np.meshgrid(*[np.arange(-n, n + 1) for n in half_grid]), axis=-1
+    ).reshape(-1, 3)
+
+    if sort:
+        idx = np.linalg.norm(grid, axis=-1).argsort()
+        grid = grid[idx]
+
+    return grid
+
+
+def get_rotation_arrays(magmoms, u=uz):
+    dim = magmoms.shape[0]
+    v = magmoms
+    n = np.cross(u, v)
+    n /= np.linalg.norm(n, axis=-1).reshape(dim, 1)
+    z = np.repeat(u, dim, axis=0)
+    A = np.stack([z, np.cross(n, z), n], axis=1)
+    B = np.stack([v, np.cross(n, v), n], axis=1)
+    R = np.einsum("nki,nkj->nij", A, B)
+
+    Rnan = np.isnan(R)
+    if Rnan.any():
+        nanidx = np.where(Rnan)[0]
+        R[nanidx] = I
+        R[nanidx, 2] = v[nanidx]
+
+    U = R[:, 0] + 1j * R[:, 1]
+    V = R[:, 2]
+
+    return U, V
+
+
+def round_to_precision(array, precision):
+    return precision * np.round(array / precision)

tb2j-0.9.9rc17.data/scripts/TB2J_magnon2.py

@@ -0,0 +1,77 @@
+from TB2J.magnon import plot_tb2j_magnon_bands
+
+
+def plot_tb2j_magnon_bands_cli():
+    """Command line interface for plotting magnon band structures from TB2J data."""
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        description="Plot magnon band structure from TB2J data",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+
+    parser.add_argument(
+        "-f", "--file", default="TB2J.pickle", help="Path to TB2J pickle file"
+    )
+
+    parser.add_argument(
+        "-p",
+        "--path",
+        help="High-symmetry k-point path (e.g., 'GXMG' for square lattice)",
+    )
+
+    parser.add_argument(
+        "-n",
+        "--npoints",
+        type=int,
+        default=300,
+        help="Number of k-points for band structure calculation",
+    )
+
+    parser.add_argument(
+        "-a",
+        "--anisotropic",
+        action="store_true",
+        help="Include anisotropic interactions",
+    )
+
+    parser.add_argument(
+        "-q",
+        "--quadratic",
+        action="store_true",
+        help="Include biquadratic interactions",
+    )
+
+    parser.add_argument("-o", "--output", help="Output filename for the plot")
+
+    parser.add_argument(
+        "--no-pbc",
+        nargs="+",
+        type=int,
+        choices=[0, 1, 2],
+        help="Disable periodic boundary conditions in specified directions (0=x, 1=y, 2=z)",
+    )
+
+    args = parser.parse_args()
+
+    # Set up periodic boundary conditions
+    pbc = [True, True, True]
+    if args.no_pbc:
+        for direction in args.no_pbc:
+            pbc[direction] = False
+    pbc = tuple(pbc)
+
+    # Plot the bands
+    plot_tb2j_magnon_bands(
+        pickle_file=args.file,
+        path=args.path,
+        npoints=args.npoints,
+        anisotropic=args.anisotropic,
+        quadratic=args.quadratic,
+        pbc=pbc,
+        filename=args.output,
+    )
+
+
+if __name__ == "__main__":
+    plot_tb2j_magnon_bands_cli()

{tb2j-0.9.9rc16.data → tb2j-0.9.9rc17.data}/scripts/abacus2J.py

@@ -29,8 +29,8 @@ def run_abacus2J():
     args = parser.parse_args()
 
     index_magnetic_atoms = args.index_magnetic_atoms
-    if not index_magnetic_atoms is None:
-        index_magnetic_atoms = [i-1 for i in index_magnetic_atoms]
+    if index_magnetic_atoms is not None:
+        index_magnetic_atoms = [i - 1 for i in index_magnetic_atoms]
 
     if args.elements is None and index_magnetic_atoms is None:
         print("Please input the magnetic elements, e.g. --elements Fe Ni")

{tb2j-0.9.9rc16.dist-info → tb2j-0.9.9rc17.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: TB2J
-Version: 0.9.9rc16
+Version: 0.9.9rc17
 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.9rc16.dist-info → tb2j-0.9.9rc17.dist-info}/RECORD

@@ -54,18 +54,23 @@ TB2J/interfaces/abacus/stru_api.py,sha256=Ac03ikHRsZRXqTul4IUge7D2iG_xLh4_oyYfeP
 TB2J/interfaces/abacus/test_density_matrix.py,sha256=bMWWJYtDS57SpPZ-eZXZ9Hr_UK4mv8ZHM7SzItG3IVA,774
 TB2J/interfaces/abacus/test_read_HRSR.py,sha256=W1oO_yigT50Yb5_u-KB_IfTpM7kArGkBuMSMs0H4CTs,1235
 TB2J/interfaces/abacus/test_read_stru.py,sha256=hoKPHVco8vwzC7Gao4bOPCdAPhh29x-9DTJJqRr7AYM,788
-TB2J/io_exchange/__init__.py,sha256=KfGHum7B8E4G_KKfillqw0lErtoyKEuFUUttHLs-mg4,32
+TB2J/io_exchange/__init__.py,sha256=LqEnG67qDVKt4hCUywDEQvUIJ7jsQjmtueOW_J16NOE,54
 TB2J/io_exchange/io_exchange.py,sha256=6fefcfYAyRojkCJA5bFwAa2Hjwx6epysfyX8Snj9DWc,20102
 TB2J/io_exchange/io_multibinit.py,sha256=8PDmWxzGuv-GwJosj2ZTmiyNY_duFVWJ4ekCuSqGdd8,6739
 TB2J/io_exchange/io_tomsasd.py,sha256=NqkAC1Fl-CUnFA21eBzSy_S5F_oeQFJysw4UukQbN8o,4173
 TB2J/io_exchange/io_txt.py,sha256=BMr1eSILlKpgtjvDx7uw2VMAkEKSvGEPNxpaT_zev0I,10547
 TB2J/io_exchange/io_uppasd.py,sha256=bI4iPEgnK4TvCZNvb6x2xYXgjW7pEehCqmcizy2pqFU,3301
 TB2J/io_exchange/io_vampire.py,sha256=UllC4twf06_q2vBCnAYFzEDGvS8mSefwQXDquBuyc0M,5583
-TB2J/mathutils/__init__.py,sha256=tQLBfHkZqdVfVxPOahy42qMUkFYnFFFhM-uc4QsYFxI,27
+TB2J/magnon/__init__.py,sha256=jdUFkOlhrpHRmKavAXVcFdZgtY7lKZVzMPFlLmmCErM,113
+TB2J/magnon/io_exchange2.py,sha256=vKKQXhPSvoeKNIc0Kh0GaTFph36jSW0Z46nAAbSEcAg,22993
+TB2J/magnon/plot.py,sha256=kwq9LL0FRVo-SLYNkE-ghlyjz8DZD-c4LAWg8si5GJo,1674
+TB2J/magnon/structure.py,sha256=rKefzXgQlEjVvV-A7E2IogVDWwf5egZr3Wxxu6HuJU4,7685
+TB2J/mathutils/__init__.py,sha256=u3QCXBUmKOtJc5PWMFS65e1WhP43UpSf48S7aJZCohc,50
 TB2J/mathutils/fermi.py,sha256=72tZ5CptGmYaBUD0xLWltuH7LBXcrMUwODyW6-WqlzI,638
 TB2J/mathutils/fibonacci_sphere.py,sha256=l0USn25ZCAWF6l4UleyWaeLthsj9TThV9iWmfi6DbaM,2344
 TB2J/mathutils/kR_convert.py,sha256=p_9XWJVNanTzTK2rI6KRjTkbSq42la6N448-zJOsMwY,2671
 TB2J/mathutils/lowdin.py,sha256=RYbm9OcnFnjcZFdC5YcNUsI9cOJmoDLsWSSCaP0GqKQ,499
+TB2J/mathutils/magnons.py,sha256=o9O7OR39RK1cl46MtiUO9Kd1IZYDOR3ANe82FZ7laY8,1085
 TB2J/mathutils/rotate_spin.py,sha256=lbGzve_36FyNjanXqdxYDb102kA4_5OycRlBcm-tH-g,8360
 TB2J/spinham/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 TB2J/spinham/base_parser.py,sha256=oQRHvFE_BlUtTaTZykKgvicu40oXcbICB-D1aAt-qlA,2196
@@ -80,19 +85,20 @@ TB2J/spinham/supercell.py,sha256=y17uUC6r3gQb278FhxIW4CABihfLTvKFj6flyXrCPR8,122
 TB2J/wannier/__init__.py,sha256=7ojCbM84PYv1X1Tbo4NHI-d3gWmQsZB_xiYqbfxVV1E,80
 TB2J/wannier/w90_parser.py,sha256=dbd63LuKyv2DVUzqRINGsbDzEsOxsQyE8_Ear_LQIRg,4620
 TB2J/wannier/w90_tb_parser.py,sha256=qt8pnuprmPp9iIAYwPkPbmEzk6ZPgMq2xognoQp7vwc,4610
-tb2j-0.9.9rc16.data/scripts/TB2J_downfold.py,sha256=i4BVqnpDdgrX_amookVWeLGefGBn-qeAutWiwuY9SfQ,2099
-tb2j-0.9.9rc16.data/scripts/TB2J_eigen.py,sha256=Qs9v2hnMm2Tpfoa4h53muUKty2dZjwx8948MBoQooNg,1128
-tb2j-0.9.9rc16.data/scripts/TB2J_magnon.py,sha256=q7UwAmorRcFNk4tfE7gl_ny05l6p7pbD9Wm_LkIpKEw,3101
-tb2j-0.9.9rc16.data/scripts/TB2J_magnon_dos.py,sha256=TMXQvD2dIbO5FZ4tUMmxJgCgH2O2hDAPUNfEKO4z-x4,110
-tb2j-0.9.9rc16.data/scripts/TB2J_merge.py,sha256=y834SF4rIRn1L1ptkhczvavQpC-8Px6DTmDOOSaq_DE,1854
-tb2j-0.9.9rc16.data/scripts/TB2J_rotate.py,sha256=zgiDFuYZNmzKK0rwDmTaYD2OpRlmKA_VGeBx83w2Xwc,873
-tb2j-0.9.9rc16.data/scripts/TB2J_rotateDM.py,sha256=kCvF7gotuqAX1VnJ06cwfVm7RrhrdtiV5v7d9P2Pn_E,567
-tb2j-0.9.9rc16.data/scripts/abacus2J.py,sha256=d84wBYkZJn6BfIFi2QorCLLdW32HB00cuZKM5RHrO-g,1824
-tb2j-0.9.9rc16.data/scripts/siesta2J.py,sha256=QJ6c0DbqxaqYEesxiL5R9nK9-flNLrr7hajKfCwirYc,2318
-tb2j-0.9.9rc16.data/scripts/wann2J.py,sha256=OA31VHEXbQMD-JozoLUHDF6vB9Sr62d804OApSKtSnU,3240
-tb2j-0.9.9rc16.dist-info/licenses/LICENSE,sha256=CbZI-jyRTjiqIcWa244cRSHJdjjtUNqGR4HeJkgEwJw,1332
-tb2j-0.9.9rc16.dist-info/METADATA,sha256=xNYF0Ciw882g-_mqBsHoZ7r3wrKNDy8dWN_0s1HFiII,1688
-tb2j-0.9.9rc16.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
-tb2j-0.9.9rc16.dist-info/entry_points.txt,sha256=Hdz1WC9waUzyFVmowKnbbZ6j-J4adHh_Ko6JpxGYAtE,131
-tb2j-0.9.9rc16.dist-info/top_level.txt,sha256=whYa5ByLYhl5XnTPBHSWr-IGD6VWmr5Ql2bye2qwV_s,5
-tb2j-0.9.9rc16.dist-info/RECORD,,
+tb2j-0.9.9rc17.data/scripts/TB2J_downfold.py,sha256=i4BVqnpDdgrX_amookVWeLGefGBn-qeAutWiwuY9SfQ,2099
+tb2j-0.9.9rc17.data/scripts/TB2J_eigen.py,sha256=Qs9v2hnMm2Tpfoa4h53muUKty2dZjwx8948MBoQooNg,1128
+tb2j-0.9.9rc17.data/scripts/TB2J_magnon.py,sha256=q7UwAmorRcFNk4tfE7gl_ny05l6p7pbD9Wm_LkIpKEw,3101
+tb2j-0.9.9rc17.data/scripts/TB2J_magnon2.py,sha256=9HKNXwPlwaEnAlJXVLrbQFhWj3fGLlBAp-nMXWDTbE0,1911
+tb2j-0.9.9rc17.data/scripts/TB2J_magnon_dos.py,sha256=TMXQvD2dIbO5FZ4tUMmxJgCgH2O2hDAPUNfEKO4z-x4,110
+tb2j-0.9.9rc17.data/scripts/TB2J_merge.py,sha256=y834SF4rIRn1L1ptkhczvavQpC-8Px6DTmDOOSaq_DE,1854
+tb2j-0.9.9rc17.data/scripts/TB2J_rotate.py,sha256=zgiDFuYZNmzKK0rwDmTaYD2OpRlmKA_VGeBx83w2Xwc,873
+tb2j-0.9.9rc17.data/scripts/TB2J_rotateDM.py,sha256=kCvF7gotuqAX1VnJ06cwfVm7RrhrdtiV5v7d9P2Pn_E,567
+tb2j-0.9.9rc17.data/scripts/abacus2J.py,sha256=VD1ldQP-PIMyxo3Rzzwk_06fJEbbU7oiU3aRXNHK0a0,1826
+tb2j-0.9.9rc17.data/scripts/siesta2J.py,sha256=QJ6c0DbqxaqYEesxiL5R9nK9-flNLrr7hajKfCwirYc,2318
+tb2j-0.9.9rc17.data/scripts/wann2J.py,sha256=OA31VHEXbQMD-JozoLUHDF6vB9Sr62d804OApSKtSnU,3240
+tb2j-0.9.9rc17.dist-info/licenses/LICENSE,sha256=CbZI-jyRTjiqIcWa244cRSHJdjjtUNqGR4HeJkgEwJw,1332
+tb2j-0.9.9rc17.dist-info/METADATA,sha256=r-lDBhH1xqc2V1ekn53vtmh6yUSfXzjEW0vJ8B7BDGA,1688
+tb2j-0.9.9rc17.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+tb2j-0.9.9rc17.dist-info/entry_points.txt,sha256=Hdz1WC9waUzyFVmowKnbbZ6j-J4adHh_Ko6JpxGYAtE,131
+tb2j-0.9.9rc17.dist-info/top_level.txt,sha256=whYa5ByLYhl5XnTPBHSWr-IGD6VWmr5Ql2bye2qwV_s,5
+tb2j-0.9.9rc17.dist-info/RECORD,,

{tb2j-0.9.9rc16.dist-info → tb2j-0.9.9rc17.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.8.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any