llgs-simulation 0.1.0__py3-none-any.whl

llgs/LLGS_simulation.py

@@ -0,0 +1,373 @@
+import numpy as np
+from pathlib import Path
+from typing import Literal, Optional, Sequence, Tuple, Union
+
+from numba import njit
+import h5py
+from scipy import sparse
+from tqdm import tqdm
+
+from .lattice import Lattice_2D
+from .spin_velocity import (
+    calculate_spin_velocities_csr_jit,
+    calculate_spin_velocities_jit,
+)
+
+Matrix = Union[np.ndarray, sparse.spmatrix]
+DMIField = Union[np.ndarray, Sequence[Matrix]]
+
+@njit
+def normalize(spins):
+    return spins/np.sqrt(np.sum(spins**2, axis=1)[:,None])
+    
+class LLGS_Simulation_2D:
+
+    def __init__(
+        self,
+        lattice: Lattice_2D,
+        H_E: Optional[Matrix] = None,
+        H_DMI: Optional[DMIField] = None,
+        H_ext: Optional[Sequence[float]] = None,
+        H_FL: Optional[Sequence[float]] = None,
+        H_DL: Optional[Sequence[float]] = None,
+        H_perp: float = 0,
+        H_para: float = 0,
+        phi_a: float = 0,
+        alpha: float = 0,
+        method: str = "RK4",
+        io_foldername: Union[str, Path] = "lattice",
+        io_filename: Optional[str] = None,
+        io_compress: bool = True,
+        io_screen: bool = True,
+        matrix_type: Literal["sparse", "dense", "auto"] = "auto",
+    ) -> None:
+        self.lattice = lattice
+        self.N = lattice.N
+        if H_E is None:
+            self.H_E = np.zeros((self.N, self.N))
+        elif sparse.issparse(H_E):
+            self.H_E = H_E
+        else:
+            self.H_E = np.asarray(H_E)
+        if self.H_E.shape != (self.N, self.N):
+            raise ValueError(
+                f"H_E must have shape ({self.N}, {self.N}), got {self.H_E.shape}"
+            )
+        self.H_DMI = self._validate_dmi(H_DMI)
+        if matrix_type not in ("sparse", "dense", "auto"):
+            raise ValueError("matrix_type must be 'sparse', 'dense', or 'auto'")
+        self.matrix_type = matrix_type
+        if matrix_type == "sparse":
+            self.H_E = sparse.csr_matrix(self.H_E)
+            self.H_DMI = tuple(
+                sparse.csr_matrix(component) for component in self.H_DMI
+            )
+        elif matrix_type == "dense":
+            self.H_E = (
+                self.H_E.toarray()
+                if sparse.issparse(self.H_E)
+                else np.asarray(self.H_E)
+            )
+            self.H_DMI = np.stack(
+                [
+                    component.toarray()
+                    if sparse.issparse(component)
+                    else np.asarray(component)
+                    for component in self.H_DMI
+                ]
+            )
+        self.H_ext = np.zeros(3) if H_ext is None else np.asarray(H_ext)
+        self.H_FL = np.zeros(3) if H_FL is None else np.asarray(H_FL)
+        self.H_DL = np.zeros(3) if H_DL is None else np.asarray(H_DL)
+        self.H_perp = H_perp
+        self.H_para = H_para
+        self.phi_a = phi_a
+        self.alpha = alpha
+        self.method = method
+        self.io_foldername = io_foldername
+        self.io_filename = f"results_{method}" if io_filename is None else io_filename
+        self.io_compress = io_compress
+        self.io_screen = io_screen
+
+    def _validate_dmi(self, H_DMI: Optional[DMIField]) -> DMIField:
+        if H_DMI is None:
+            return np.zeros((3, self.N, self.N))
+
+        if sparse.issparse(H_DMI):
+            raise ValueError("sparse H_DMI must be a sequence of three matrices")
+
+        if isinstance(H_DMI, (list, tuple)) and any(
+            sparse.issparse(component) for component in H_DMI
+        ):
+            if len(H_DMI) != 3:
+                raise ValueError("sparse H_DMI must contain three matrices")
+            for component in H_DMI:
+                if np.shape(component) != (self.N, self.N):
+                    raise ValueError(
+                        f"each H_DMI matrix must have shape ({self.N}, {self.N})"
+                    )
+            return tuple(H_DMI)
+
+        H_DMI = np.asarray(H_DMI)
+        if H_DMI.shape != (3, self.N, self.N):
+            raise ValueError(
+                f"H_DMI must have shape (3, {self.N}, {self.N}), got {H_DMI.shape}"
+            )
+        return H_DMI
+
+    def _prepare_fields(self) -> Tuple[bool, Matrix, Optional[Matrix]]:
+        dmi_is_sparse = isinstance(self.H_DMI, tuple)
+        use_sparse = sparse.issparse(self.H_E) or dmi_is_sparse
+
+        if not use_sparse:
+            H_E = np.asarray(self.H_E)
+            H_E = (H_E + H_E.T) / 2
+            H_DMI = np.asarray(self.H_DMI)
+            H_DMI = (H_DMI - H_DMI.transpose(0, 2, 1)) / 2
+            if np.all(H_DMI == 0):
+                H_DMI = None
+            return False, H_E, H_DMI
+
+        H_E = sparse.csr_matrix(self.H_E)
+        H_E = ((H_E + H_E.T) / 2).tocsr()
+        H_E.eliminate_zeros()
+        H_E.sort_indices()
+
+        components = self.H_DMI if dmi_is_sparse else self.H_DMI
+        normalized_dmi = []
+        for component in components:
+            component = sparse.csr_matrix(component)
+            component = ((component - component.T) / 2).tocsr()
+            component.eliminate_zeros()
+            component.sort_indices()
+            normalized_dmi.append(component)
+        H_DMI = sparse.vstack(normalized_dmi, format="csr")
+        return True, H_E, H_DMI
+    
+    def evolve(
+        self,
+        dt: float = 0.01,
+        max_iters: int = 1000,
+        restore_initial_state: bool = True,
+    ) -> np.ndarray:
+        """
+        param:
+        -----------------------------------------------
+        dt: float
+            time step per iter (ps)
+        max_iters: int
+            number of iteration
+        restore_initial_state: bool
+            If True, restore spins and velocities to their initial values after simulation
+
+        return:
+        -----------------------------------------------
+        record: (max_iters, N, 3)
+            1st dim: time
+            2nd dim: particle idx
+            3rd dim: spin (Sx,Sy,Sz)
+        """
+        if max_iters <= 0:
+            raise ValueError("max_iters must be positive")
+
+        if restore_initial_state:
+            initial_spins = np.copy(self.lattice.spins)
+            initial_svels = np.copy(self.lattice.spin_velocities)
+
+        use_sparse, H_E, H_DMI = self._prepare_fields()
+
+        method = self.method
+        if method=="Euler":
+            _get_next_spin = _get_next_spin_euler_csr if use_sparse else _get_next_spin_euler
+        elif method=="RK2":
+            _get_next_spin = _get_next_spin_rk2_csr if use_sparse else _get_next_spin_rk2
+        elif method=="RK4":
+            _get_next_spin = _get_next_spin_rk4_csr if use_sparse else _get_next_spin_rk4
+        else:
+            raise ValueError("method must be 'Euler','RK2','RK4'")
+        
+        Path(self.io_foldername).mkdir(parents=True, exist_ok=True)
+
+        record = np.zeros((max_iters, self.N, 3))
+        structure = self.lattice.structure
+
+        iters = tqdm(range(max_iters), desc='simulation') if self.io_screen else range(max_iters)
+        for n in iters:
+            
+            
+            spins = self.lattice.spins
+            svels = self.lattice.spin_velocities
+            if use_sparse:
+                next_spins, next_svels = _get_next_spin(
+                    H_E.data, H_E.indices, H_E.indptr,
+                    self.H_perp, self.H_para, self.phi_a,
+                    H_DMI.data, H_DMI.indices, H_DMI.indptr, H_DMI.nnz > 0,
+                    self.H_ext, self.H_FL, self.H_DL, self.alpha,
+                    spins, svels, dt,
+                )
+            else:
+                next_spins, next_svels = _get_next_spin(H_E = H_E,
+                                                        H_perp = self.H_perp,
+                                                        H_para = self.H_para,
+                                                        phi_a= self.phi_a,
+                                                        H_DMI = H_DMI,
+                                                        H_ext = self.H_ext,
+                                                        H_FL = self.H_FL,
+                                                        H_DL = self.H_DL,
+                                                        alpha = self.alpha,
+                                                        spins = spins,
+                                                        svels = svels,
+                                                        dt = dt
+                                                        )
+            record[n] = spins
+            self.lattice.spins = next_spins
+            self.lattice.spin_velocities = next_svels
+        
+        if self.io_screen:
+            print(f"saving data to {self.io_foldername}/{self.io_filename}.h5 ...")
+            
+        with h5py.File(f'{self.io_foldername}/{self.io_filename}.h5', 'w') as f:
+            dataset_options = {"chunks": (min(1000, max_iters), self.N, 3)}
+            if self.io_compress:
+                dataset_options["compression"] = "gzip"
+            f.create_dataset("spin data", data=record, **dataset_options)
+            f.create_dataset("structure", structure.shape, data = structure)
+            f.attrs['dt'] = dt
+        
+        if restore_initial_state:
+            self.lattice.spins = initial_spins
+            self.lattice.spin_velocities = initial_svels
+        
+        if self.io_screen:
+            print("simulation is done")
+
+        return record
+
+@njit
+def _get_next_spin_euler(H_E,H_perp,H_para,phi_a,H_DMI,H_ext,H_FL,H_DL,alpha,
+                       spins,svels, dt):
+
+    next_svels = calculate_spin_velocities_jit( H_E,H_perp,H_para,phi_a,H_DMI,H_ext,H_FL,H_DL,alpha,
+                                                spins,svels)
+    next_spins = spins + dt*svels
+    next_spins = normalize(next_spins)
+
+    return next_spins, next_svels
+
+@njit
+def _get_next_spin_rk2(H_E,H_perp,H_para,phi_a,H_DMI,H_ext,H_FL,H_DL,alpha,
+                    spins,svels, dt):
+
+
+    #k2
+    spin2 = spins + dt/2*svels
+    svel2 = calculate_spin_velocities_jit(H_E,H_perp,H_para,phi_a,H_DMI,H_ext,H_FL,H_DL,alpha,
+                                        spin2,svels)
+                                            
+    next_spins = spins + dt/2*(svels+svel2)
+    next_spins = normalize(next_spins)
+
+    next_svels = calculate_spin_velocities_jit(H_E,H_perp,H_para,phi_a,H_DMI,H_ext,H_FL,H_DL,alpha,
+                                        next_spins,svels)
+    
+    return next_spins, next_svels
+
+@njit
+def _get_next_spin_rk4(H_E,H_perp,H_para,phi_a,H_DMI,H_ext,H_FL,H_DL,alpha,
+                    spins,svels, dt):
+
+    spins_i = spins.copy()
+    #k2
+    spin2 = spins_i + dt/2*svels
+    svel2 = calculate_spin_velocities_jit(H_E,H_perp,H_para,phi_a,H_DMI,H_ext,H_FL,H_DL,alpha,
+                                        spin2,svels)
+    
+    #k3
+    spin3 = spins_i + dt/2*svel2
+    svel3 = calculate_spin_velocities_jit(H_E,H_perp,H_para,phi_a,H_DMI,H_ext,H_FL,H_DL,alpha,
+                                        spin3,svels)
+    
+    #k4
+    spin4 = spins_i + dt*svel3
+    svel4 = calculate_spin_velocities_jit(H_E,H_perp,H_para,phi_a,H_DMI,H_ext,H_FL,H_DL,alpha,
+                                        spin4,svels)
+                                            
+
+
+    next_spins = spins_i + dt/6*(svels+2*svel2+2*svel3+svel4)
+    next_spins = normalize(next_spins)
+
+    next_svels = calculate_spin_velocities_jit(H_E,H_perp,H_para,phi_a,H_DMI,H_ext,H_FL,H_DL,alpha,
+                                            next_spins,svels)
+
+    return next_spins, next_svels
+
+
+@njit
+def _get_next_spin_euler_csr(
+    H_E_data, H_E_indices, H_E_indptr, H_perp, H_para, phi_a,
+    H_DMI_data, H_DMI_indices, H_DMI_indptr, has_DMI,
+    H_ext, H_FL, H_DL, alpha, spins, svels, dt,
+):
+    next_svels = calculate_spin_velocities_csr_jit(
+        H_E_data, H_E_indices, H_E_indptr, H_perp, H_para, phi_a,
+        H_DMI_data, H_DMI_indices, H_DMI_indptr, has_DMI,
+        H_ext, H_FL, H_DL, alpha, spins, svels,
+    )
+    next_spins = normalize(spins + dt * svels)
+    return next_spins, next_svels
+
+
+@njit
+def _get_next_spin_rk2_csr(
+    H_E_data, H_E_indices, H_E_indptr, H_perp, H_para, phi_a,
+    H_DMI_data, H_DMI_indices, H_DMI_indptr, has_DMI,
+    H_ext, H_FL, H_DL, alpha, spins, svels, dt,
+):
+    spin2 = spins + dt / 2 * svels
+    svel2 = calculate_spin_velocities_csr_jit(
+        H_E_data, H_E_indices, H_E_indptr, H_perp, H_para, phi_a,
+        H_DMI_data, H_DMI_indices, H_DMI_indptr, has_DMI,
+        H_ext, H_FL, H_DL, alpha, spin2, svels,
+    )
+    next_spins = normalize(spins + dt / 2 * (svels + svel2))
+    next_svels = calculate_spin_velocities_csr_jit(
+        H_E_data, H_E_indices, H_E_indptr, H_perp, H_para, phi_a,
+        H_DMI_data, H_DMI_indices, H_DMI_indptr, has_DMI,
+        H_ext, H_FL, H_DL, alpha, next_spins, svels,
+    )
+    return next_spins, next_svels
+
+
+@njit
+def _get_next_spin_rk4_csr(
+    H_E_data, H_E_indices, H_E_indptr, H_perp, H_para, phi_a,
+    H_DMI_data, H_DMI_indices, H_DMI_indptr, has_DMI,
+    H_ext, H_FL, H_DL, alpha, spins, svels, dt,
+):
+    spins_i = spins.copy()
+    spin2 = spins_i + dt / 2 * svels
+    svel2 = calculate_spin_velocities_csr_jit(
+        H_E_data, H_E_indices, H_E_indptr, H_perp, H_para, phi_a,
+        H_DMI_data, H_DMI_indices, H_DMI_indptr, has_DMI,
+        H_ext, H_FL, H_DL, alpha, spin2, svels,
+    )
+    spin3 = spins_i + dt / 2 * svel2
+    svel3 = calculate_spin_velocities_csr_jit(
+        H_E_data, H_E_indices, H_E_indptr, H_perp, H_para, phi_a,
+        H_DMI_data, H_DMI_indices, H_DMI_indptr, has_DMI,
+        H_ext, H_FL, H_DL, alpha, spin3, svels,
+    )
+    spin4 = spins_i + dt * svel3
+    svel4 = calculate_spin_velocities_csr_jit(
+        H_E_data, H_E_indices, H_E_indptr, H_perp, H_para, phi_a,
+        H_DMI_data, H_DMI_indices, H_DMI_indptr, has_DMI,
+        H_ext, H_FL, H_DL, alpha, spin4, svels,
+    )
+    next_spins = normalize(spins_i + dt / 6 * (svels + 2 * svel2 + 2 * svel3 + svel4))
+    next_svels = calculate_spin_velocities_csr_jit(
+        H_E_data, H_E_indices, H_E_indptr, H_perp, H_para, phi_a,
+        H_DMI_data, H_DMI_indices, H_DMI_indptr, has_DMI,
+        H_ext, H_FL, H_DL, alpha, next_spins, svels,
+    )
+    return next_spins, next_svels

llgs/__init__.py

@@ -0,0 +1,4 @@
+from .lattice import Lattice_2D
+from .LLGS_simulation import LLGS_Simulation_2D
+from .read_results import ReadResult
+from .interactions import build_dmi, build_exchange

llgs/interactions.py

@@ -0,0 +1,144 @@
+"""Sparse interaction-matrix builders for periodic lattice topologies."""
+
+from typing import Iterable, Sequence, Tuple, Union
+
+import numpy as np
+from scipy import sparse
+
+from .lattice import Lattice_2D
+
+
+CellOffset = Tuple[int, int]
+ExchangeBond = Tuple[int, int, CellOffset, float]
+DMIBond = Tuple[int, int, CellOffset, Sequence[float]]
+Periodic = Union[bool, Tuple[bool, bool]]
+
+
+def _periodic_axes(periodic: Periodic) -> Tuple[bool, bool]:
+    if isinstance(periodic, (bool, np.bool_)):
+        return bool(periodic), bool(periodic)
+    if len(periodic) != 2:
+        raise ValueError("periodic must be a bool or a pair of bools")
+    return bool(periodic[0]), bool(periodic[1])
+
+
+def _validate_bond(
+    lattice: Lattice_2D,
+    source_site: int,
+    target_site: int,
+    offset: CellOffset,
+) -> Tuple[int, int]:
+    if not 0 <= source_site < lattice.n_site:
+        raise ValueError(f"source site {source_site} is outside the unit cell")
+    if not 0 <= target_site < lattice.n_site:
+        raise ValueError(f"target site {target_site} is outside the unit cell")
+    if len(offset) != 2 or any(int(value) != value for value in offset):
+        raise ValueError("bond cell offsets must contain two integers")
+    if source_site == target_site and tuple(offset) == (0, 0):
+        raise ValueError("a bond cannot connect a site to itself in the same cell")
+    return int(offset[0]), int(offset[1])
+
+
+def _particle_index(lattice: Lattice_2D, a: int, b: int, site: int) -> int:
+    return (a * lattice.n_b + b) * lattice.n_site + site
+
+
+def _bond_indices(
+    lattice: Lattice_2D,
+    source_site: int,
+    target_site: int,
+    offset: CellOffset,
+    periodic: Tuple[bool, bool],
+):
+    delta_a, delta_b = _validate_bond(
+        lattice, source_site, target_site, offset
+    )
+    for a in range(lattice.n_a):
+        for b in range(lattice.n_b):
+            target_a = a + delta_a
+            target_b = b + delta_b
+
+            if periodic[0]:
+                target_a %= lattice.n_a
+            elif not 0 <= target_a < lattice.n_a:
+                continue
+
+            if periodic[1]:
+                target_b %= lattice.n_b
+            elif not 0 <= target_b < lattice.n_b:
+                continue
+
+            yield (
+                _particle_index(lattice, a, b, source_site),
+                _particle_index(lattice, target_a, target_b, target_site),
+            )
+
+
+def build_exchange(
+    lattice: Lattice_2D,
+    bonds: Iterable[ExchangeBond],
+    periodic: Periodic = False,
+) -> sparse.csr_matrix:
+    """Build a symmetric CSR exchange matrix from unit-cell bond templates.
+
+    Each bond is ``(source_site, target_site, (delta_a, delta_b), coupling)``.
+    A template is repeated from every unit cell and its reverse matrix entry is
+    added automatically. With open boundaries, bonds leaving the lattice are
+    omitted. ``periodic`` may be one bool or ``(periodic_a, periodic_b)``.
+    """
+    periodic_axes = _periodic_axes(periodic)
+    rows = []
+    columns = []
+    values = []
+
+    for source_site, target_site, offset, coupling in bonds:
+        for source, target in _bond_indices(
+            lattice, source_site, target_site, offset, periodic_axes
+        ):
+            rows.extend((source, target))
+            columns.extend((target, source))
+            values.extend((coupling, coupling))
+
+    matrix = sparse.coo_matrix(
+        (values, (rows, columns)), shape=(lattice.N, lattice.N), dtype=float
+    ).tocsr()
+    matrix.eliminate_zeros()
+    return matrix
+
+
+def build_dmi(
+    lattice: Lattice_2D,
+    bonds: Iterable[DMIBond],
+    periodic: Periodic = False,
+) -> Tuple[sparse.csr_matrix, sparse.csr_matrix, sparse.csr_matrix]:
+    """Build three antisymmetric CSR DMI matrices from bond templates.
+
+    Each bond is ``(source_site, target_site, (delta_a, delta_b), (Dx, Dy,
+    Dz))``. The reverse bond is assigned the negated DMI vector. Boundary
+    behavior matches :func:`build_exchange`.
+    """
+    periodic_axes = _periodic_axes(periodic)
+    rows = []
+    columns = []
+    component_values = ([], [], [])
+
+    for source_site, target_site, offset, dmi_vector in bonds:
+        dmi_vector = np.asarray(dmi_vector, dtype=float)
+        if dmi_vector.shape != (3,):
+            raise ValueError("each DMI vector must have shape (3,)")
+        for source, target in _bond_indices(
+            lattice, source_site, target_site, offset, periodic_axes
+        ):
+            rows.extend((source, target))
+            columns.extend((target, source))
+            for component, values in enumerate(component_values):
+                values.extend((dmi_vector[component], -dmi_vector[component]))
+
+    matrices = []
+    for values in component_values:
+        matrix = sparse.coo_matrix(
+            (values, (rows, columns)), shape=(lattice.N, lattice.N), dtype=float
+        ).tocsr()
+        matrix.eliminate_zeros()
+        matrices.append(matrix)
+    return tuple(matrices)

llgs/lattice.py

@@ -0,0 +1,177 @@
+from typing import Literal, Union
+
+import numpy as np
+
+
+def normalize(spins):
+    return spins / np.linalg.norm(spins, axis=1, keepdims=True)
+
+
+class Lattice_2D:
+    def __init__(self, n_a, n_b, n_site, r_a=None, r_b=None, r_site=None):
+        """Create a two-dimensional spin lattice.
+
+        Parameters
+        ----------
+        n_a, n_b : int
+            Number of unit cells along the two lattice vectors.
+        n_site : int
+            Number of sites in each unit cell.
+        r_a, r_b : array-like of shape (2,), optional
+            Cartesian lattice vectors. Geometry is omitted when these and
+            ``r_site`` are all ``None``.
+        r_site : array-like of shape (n_site, 2), optional
+            Fractional site coordinates within a unit cell. A row ``(u, v)``
+            places that site at ``u * r_a + v * r_b`` relative to the cell
+            origin. It must be supplied together with ``r_a`` and ``r_b``.
+
+        Notes
+        -----
+        The public arrays ``tags``, ``positions``, ``spins``,
+        ``spin_velocities``, and ``structure`` contain the lattice state.
+        ``structure`` has columns ``a, b, site`` and, when geometry is
+        provided, the Cartesian columns ``x, y``.
+        """
+        geometry = (r_a, r_b, r_site)
+        if any(value is not None for value in geometry) and not all(
+            value is not None for value in geometry
+        ):
+            raise ValueError("r_a, r_b, and r_site must be provided together")
+
+        self.n_site = n_site
+        self.n_a = n_a
+        self.n_b = n_b
+        self.N = n_site * n_a * n_b
+
+        a, b, site = np.meshgrid(
+            np.arange(n_a),
+            np.arange(n_b),
+            np.arange(n_site),
+            indexing="ij",
+        )
+        self.tags = np.stack(
+            (a.ravel(), b.ravel(), site.ravel()), axis=1
+        ).astype(int)
+        self.positions = np.zeros((self.N, 2))
+        self.spins = np.zeros((self.N, 3))
+        self.spin_velocities = np.zeros((self.N, 3))
+
+        self.r_a = None
+        self.r_b = None
+        self.r_site = None
+        self.has_geometry = all(value is not None for value in geometry)
+
+        if self.has_geometry:
+            self.r_a = np.asarray(r_a)
+            self.r_b = np.asarray(r_b)
+            self.r_site = np.asarray(r_site)
+            if self.r_a.shape != (2,):
+                raise ValueError(
+                    f"r_a must be a (2,) array, but got shape {self.r_a.shape}."
+                )
+            if self.r_b.shape != (2,):
+                raise ValueError(
+                    f"r_b must be a (2,) array, but got shape {self.r_b.shape}."
+                )
+            if self.r_site.shape != (self.n_site, 2):
+                raise ValueError(
+                    f"r_site must be a ({self.n_site}, 2) array, "
+                    f"but got shape {self.r_site.shape}."
+                )
+
+            a, b, site = self.tags.T
+            site_coordinates = self.r_site[site]
+            self.positions = (
+                a[:, None] * self.r_a
+                + b[:, None] * self.r_b
+                + site_coordinates[:, 0, None] * self.r_a
+                + site_coordinates[:, 1, None] * self.r_b
+            )
+            self.structure = np.column_stack((self.tags, self.positions))
+        else:
+            self.structure = self.tags.copy()
+
+    def output_lattice_structure(self, fn):
+        """Write lattice data to a CSV file."""
+        output = np.column_stack((np.arange(self.N), self.structure))
+        columns = ["particle idx", "a", "b", "site"]
+        formats = ["%d"] * 4
+        if self.has_geometry:
+            columns.extend(("x", "y"))
+            formats.extend(("%.18e", "%.18e"))
+        np.savetxt(
+            fn,
+            output,
+            delimiter=",",
+            header=",".join(columns),
+            comments="",
+            fmt=formats,
+        )
+
+    def initialize_spin(self, condition_dict, perturb=0.0):
+        """Initialize spins from NumPy expressions over lattice coordinates."""
+        condition_values = {
+            "a": self.tags[:, 0],
+            "b": self.tags[:, 1],
+            "site": self.tags[:, 2],
+        }
+        if self.has_geometry:
+            condition_values.update(
+                {
+                    "x": self.positions[:, 0],
+                    "y": self.positions[:, 1],
+                }
+            )
+
+        for cond_str, spin in condition_dict.items():
+            cond = np.asarray(
+                eval(cond_str, {"__builtins__": {}}, condition_values),
+                dtype=bool,
+            )
+            if cond.shape != (self.N,):
+                raise ValueError(
+                    f"condition must produce shape ({self.N},), got {cond.shape}"
+                )
+            self.spins[cond] = spin
+
+        self.spins += perturb * np.random.normal(0, 1, (self.N, 3))
+        self.spins = normalize(self.spins)
+
+    def plot(
+        self,
+        arrowscale=0.3,
+        annotate_idx=False,
+        draw_unitcell=False,
+        display=True,
+        theme: Union[Literal["light", "dark"], dict] = "dark",
+    ):
+        """Plot this lattice and its current spin configuration.
+
+        Parameters
+        ----------
+        arrowscale : float, default 0.3
+            Scale applied to in-plane spin arrows.
+        annotate_idx : bool, default False
+            Label each lattice site with its particle index.
+        draw_unitcell : bool, default False
+            Draw the unit-cell boundary. Geometry must be available.
+        display : bool, default True
+            Show the figure with Matplotlib when true.
+        theme : {"light", "dark"} or dict, default "dark"
+            Built-in theme name or custom values overriding ``DARK_THEME``.
+
+        Returns
+        -------
+        tuple
+            Matplotlib ``(figure, axes)`` objects.
+        """
+        from .plotting import _plot_lattice
+
+        return _plot_lattice(
+            self,
+            arrowscale=arrowscale,
+            annotate_idx=annotate_idx,
+            draw_unitcell=draw_unitcell,
+            display=display,
+            theme=theme,
+        )

llgs/plotting.py

@@ -0,0 +1,165 @@
+"""Visualization helpers for lattices and simulation results."""
+
+from pathlib import Path
+from typing import TYPE_CHECKING, Literal, Tuple, Union
+
+import matplotlib.animation as animation
+import matplotlib.colors as colors
+import matplotlib.pyplot as plt
+import numpy as np
+from matplotlib.axes import Axes
+from matplotlib.figure import Figure
+from matplotlib.patches import Polygon
+
+if TYPE_CHECKING:
+    from .lattice import Lattice_2D
+    from .read_results import ReadResult
+
+DARK_THEME = {
+    "style": "dark_background",
+    "spin_cmap": "bwr",
+    "lattice_color": "yellow",
+    "unit_cell_edge_color": "blue",
+    "unit_cell_face_color": "lightblue",
+}
+
+LIGHT_THEME = {
+    "style": "default",
+    "spin_cmap": colors.LinearSegmentedColormap.from_list(
+        "light_spin",
+        ["#2563eb", "#1f2937", "#dc2626"],
+    ),
+    "lattice_color": "black",
+    "unit_cell_edge_color": "navy",
+    "unit_cell_face_color": "lightblue",
+}
+
+Theme = Union[Literal["light", "dark"], dict]
+
+
+def _resolve_theme(theme: Theme) -> dict:
+    if theme == "dark":
+        return DARK_THEME
+    if theme == "light":
+        return LIGHT_THEME
+    if isinstance(theme, dict):
+        return {**DARK_THEME, **theme}
+    raise ValueError("theme must be 'light', 'dark', or a theme dictionary")
+
+
+def _resolve_cmap(cmap):
+    return cmap if isinstance(cmap, colors.Colormap) else plt.get_cmap(cmap)
+
+
+def _plot_lattice(
+    lattice: "Lattice_2D",
+    arrowscale: float = 0.3,
+    annotate_idx: bool = False,
+    draw_unitcell: bool = False,
+    display: bool = True,
+    theme: Theme = "dark",
+) -> Tuple[Figure, Axes]:
+    """Plot lattice positions and the current spin configuration."""
+    x = lattice.positions[:, 0]
+    y = lattice.positions[:, 1]
+    sx = lattice.spins[:, 0]
+    sy = lattice.spins[:, 1]
+    sz = lattice.spins[:, 2]
+    theme = _resolve_theme(theme)
+
+    with plt.style.context(theme["style"]):
+        fig, ax = plt.subplots()
+        cmap = _resolve_cmap(theme["spin_cmap"])
+        norm = colors.Normalize(vmin=-1, vmax=1)
+        sm = plt.cm.ScalarMappable(cmap=cmap, norm=norm)
+        fig.colorbar(sm, ax=ax)
+        ax.scatter(x, y, c=theme["lattice_color"], s=2)
+        if np.linalg.norm(sx) == np.linalg.norm(sy) == 0 and np.linalg.norm(sz) != 0:
+            ax.scatter(x, y, c=sz, s=2, norm=norm, cmap=cmap)
+        elif np.linalg.norm(sx) != 0 or np.linalg.norm(sy) != 0:
+            ax.quiver(
+                x, y, sx * arrowscale, sy * arrowscale, sz, norm=norm, cmap=cmap
+            )
+        if annotate_idx:
+            for index, (x_position, y_position) in enumerate(zip(x, y)):
+                ax.annotate(
+                    str(index),
+                    (x_position, y_position),
+                    xycoords="data",
+                    xytext=(1.5, 1.5),
+                    textcoords="offset points",
+                )
+
+        if draw_unitcell:
+            if not lattice.has_geometry:
+                raise ValueError("geometry is required to draw the unit cell")
+            origin = np.zeros(2)
+            opposite_corner = lattice.r_a + lattice.r_b
+            unit_cell = Polygon(
+                [origin, lattice.r_a, opposite_corner, lattice.r_b],
+                closed=True,
+                edgecolor=theme["unit_cell_edge_color"],
+                facecolor=theme["unit_cell_face_color"],
+                alpha=0.5,
+            )
+            ax.add_patch(unit_cell)
+
+        ax.set_aspect("equal")
+        ax.axis("off")
+    if display:
+        plt.show()
+    return fig, ax
+
+
+def _animate(
+    result: "ReadResult",
+    period: int,
+    save_fn: Union[str, Path],
+    fps: int = 10,
+    display: bool = True,
+    theme: Theme = "dark",
+) -> animation.FuncAnimation:
+    """Animate saved spin data and write it to a GIF or video file."""
+    if result.structure.shape[1] < 5:
+        raise ValueError("structure must include x and y coordinates")
+    if period <= 0:
+        raise ValueError("period must be positive")
+    theme = _resolve_theme(theme)
+
+    with plt.style.context(theme["style"]):
+        fig, ax = plt.subplots()
+        line = ax.plot([], [])
+        cmap = _resolve_cmap(theme["spin_cmap"])
+        norm = colors.Normalize(vmin=-1, vmax=1)
+        sm = plt.cm.ScalarMappable(cmap=cmap, norm=norm)
+        fig.colorbar(sm, ax=ax)
+
+    def initialize():
+        return line
+
+    def update_lattice(frame):
+        frame = min(frame * period, len(result.spin_datas) - 1)
+        x, y = result.structure[:, 3], result.structure[:, 4]
+        sx, sy, sz = result.spin_datas[frame].T
+
+        with plt.style.context(theme["style"]):
+            ax.clear()
+            ax.scatter(x, y, c=theme["lattice_color"], s=1)
+            ax.quiver(x, y, sx * 0.3, sy * 0.3, sz, norm=norm, cmap=cmap)
+            ax.set_aspect("equal")
+            ax.axis("off")
+            ax.set_title(f"time = {result.times[frame]:0.2f} ps")
+        return line
+
+    frame_count = max(1, len(result.times) // period)
+    output = animation.FuncAnimation(
+        fig,
+        update_lattice,
+        frames=frame_count,
+        init_func=initialize,
+        blit=True,
+    )
+    output.save(save_fn, fps=fps)
+    if display:
+        plt.show()
+    return output

llgs/read_results.py

@@ -0,0 +1,61 @@
+from typing import Literal, Union
+
+import h5py
+import numpy as np
+
+class ReadResult:
+
+    def __init__(self,fn):
+        '''
+        param:
+        -----------------------------
+        fn: hdf5 file name
+        
+        attr:
+        -----------------------------
+        times: (T)
+        spin_datas: (T,N,3)
+        '''
+        with h5py.File(fn,'r') as f:
+            self.spin_datas = f['spin data'][()] # (T,N,3)
+            self.structure = f['structure'][()] # (N,5) a,b,site,x,y
+            self.times = np.arange(self.spin_datas.shape[0])*f.attrs['dt'] # (T)
+
+    def animate(
+        self,
+        period,
+        save_fn,
+        fps=10,
+        display=True,
+        theme: Union[Literal["light", "dark"], dict] = "dark",
+    ):
+        """Animate this result and save it to a GIF or video file.
+
+        Parameters
+        ----------
+        period : int
+            Number of simulation steps between animation frames.
+        save_fn : path-like
+            Output GIF or video filename.
+        fps : int, default 10
+            Saved animation frame rate.
+        display : bool, default True
+            Show the animation figure with Matplotlib when true.
+        theme : {"light", "dark"} or dict, default "dark"
+            Built-in theme name or custom values overriding ``DARK_THEME``.
+
+        Returns
+        -------
+        matplotlib.animation.FuncAnimation
+            The generated animation.
+        """
+        from .plotting import _animate
+
+        return _animate(
+            self,
+            period=period,
+            save_fn=save_fn,
+            fps=fps,
+            display=display,
+            theme=theme,
+        )

llgs/spin_velocity.py

@@ -0,0 +1,99 @@
+import numpy as np
+from numba import njit
+
+
+@njit
+def calculate_spin_velocities_jit(H_E,H_perp,H_para,phi_a,H_DMI,H_ext,H_FL,H_DL,alpha
+                                  ,spins,svels):
+    # spins: (N,3) svels: (N,3)
+    gyro_magnetic_ratio = - 1.76085963023e-1
+    H_eff = H_eff_no_DMI(H_E,H_perp,H_para,phi_a,H_ext,H_FL,spins)
+
+    if not H_DMI is None:
+        H_eff += H_eff_DMI_term(H_DMI, spins)
+    
+    next_svels = gyro_magnetic_ratio * (
+                    np.cross(H_eff, spins)
+                    + np.cross(np.cross(H_DL, spins), spins)
+                    + alpha * np.cross(spins, svels)
+                )
+
+    return next_svels
+
+@njit
+def H_eff_no_DMI(H_E,H_perp,H_para,phi_a,H_ext,H_FL,spins):
+    H_eff = ( H_ext # applied field
+            + H_FL # Field-like SOT
+            + spins * np.array([2*H_para*np.cos(phi_a), 2*H_para*np.sin(phi_a), -2*H_perp]) # anisotropy
+            - H_E @ spins) # exchange 
+    return H_eff
+
+@njit
+def H_eff_DMI_term(H_DMI, spins):
+    epsilon = np.zeros((3, 3, 3))
+    epsilon[0, 1, 2] = epsilon[1, 2, 0] = epsilon[2, 0, 1] = 1
+    epsilon[0, 2, 1] = epsilon[1, 0, 2] = epsilon[2, 1, 0] = -1
+    return (- H_DMI[0] @ spins @ epsilon[0]
+            - H_DMI[1] @ spins @ epsilon[1]
+            - H_DMI[2] @ spins @ epsilon[2]
+            )
+
+
+@njit
+def csr_matmul_spins(data, indices, indptr, spins):
+    """Multiply a CSR matrix by an (N, 3) spin array."""
+    result = np.zeros((indptr.size - 1, 3), dtype=spins.dtype)
+    for row in range(indptr.size - 1):
+        for index in range(indptr[row], indptr[row + 1]):
+            result[row] += data[index] * spins[indices[index]]
+    return result
+
+
+@njit
+def calculate_spin_velocities_csr_jit(
+    H_E_data,
+    H_E_indices,
+    H_E_indptr,
+    H_perp,
+    H_para,
+    phi_a,
+    H_DMI_data,
+    H_DMI_indices,
+    H_DMI_indptr,
+    has_DMI,
+    H_ext,
+    H_FL,
+    H_DL,
+    alpha,
+    spins,
+    svels,
+):
+    """CSR equivalent of calculate_spin_velocities_jit."""
+    gyro_magnetic_ratio = -1.76085963023e-1
+    H_eff = (
+        H_ext
+        + H_FL
+        + spins
+        * np.array(
+            [2 * H_para * np.cos(phi_a), 2 * H_para * np.sin(phi_a), -2 * H_perp]
+        )
+        - csr_matmul_spins(H_E_data, H_E_indices, H_E_indptr, spins)
+    )
+
+    if has_DMI:
+        dmi_products = csr_matmul_spins(
+            H_DMI_data, H_DMI_indices, H_DMI_indptr, spins
+        )
+        n_spins = spins.shape[0]
+        epsilon = np.zeros((3, 3, 3))
+        epsilon[0, 1, 2] = epsilon[1, 2, 0] = epsilon[2, 0, 1] = 1
+        epsilon[0, 2, 1] = epsilon[1, 0, 2] = epsilon[2, 1, 0] = -1
+        for component in range(3):
+            start = component * n_spins
+            H_eff -= dmi_products[start : start + n_spins] @ epsilon[component]
+
+    return gyro_magnetic_ratio * (
+        np.cross(H_eff, spins)
+        + np.cross(np.cross(H_DL, spins), spins)
+        + alpha * np.cross(spins, svels)
+    )

llgs_simulation-0.1.0.dist-info/METADATA

@@ -0,0 +1,196 @@
+Metadata-Version: 2.4
+Name: llgs-simulation
+Version: 0.1.0
+Summary: Spin-dynamics simulations using the Landau-Lifshitz-Gilbert-Slonczewski equation
+Author: Ian Chang
+License: MIT License
+        
+        Copyright (c) 2026 Ian Chang
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/ianchung621/LLGS-simulation
+Project-URL: Repository, https://github.com/ianchung621/LLGS-simulation.git
+Project-URL: Issues, https://github.com/ianchung621/LLGS-simulation/issues
+Keywords: spintronics,LLGS,magnetism,spin dynamics,simulation
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: h5py
+Requires-Dist: matplotlib
+Requires-Dist: numba
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: tqdm
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Dynamic: license-file
+
+# LLGS Simulation
+
+[![Tests](https://github.com/ianchung621/LLGS-simulation/actions/workflows/test.yml/badge.svg)](https://github.com/ianchung621/LLGS-simulation/actions/workflows/test.yml)
+[![Coverage](https://codecov.io/gh/ianchung621/LLGS-simulation/branch/main/graph/badge.svg)](https://codecov.io/gh/ianchung621/LLGS-simulation)
+![Python](https://img.shields.io/badge/python-3.9--3.13-blue)
+![OS](https://img.shields.io/badge/OS-Linux%20%7C%20macOS%20%7C%20Windows-lightgrey)
+
+This package provides tools for simulating and analyzing spin dynamics using
+the Landau-Lifshitz-Gilbert-Slonczewski (LLGS) equation on two-dimensional
+lattices. It supports antiferromagnetic exchange, DMI, anisotropy, external
+fields, and spin-orbit torque.
+
+## Install
+
+LLGS Simulation requires Python 3.9 or newer:
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+python -m pip install llgs-simulation
+```
+
+## Example Usage
+
+Below is a step-by-step demonstration of how to use the repository to simulate spin dynamics and visualize the results.
+
+### 1. Creating a Lattice Object
+
+The `lattice.py` module allows you to define a spin lattice. Here's an example of creating a hexagonal lattice:
+
+```python
+import numpy as np
+
+from llgs import Lattice_2D
+
+honeycomb = Lattice_2D(
+    n_a=10,
+    n_b=8,
+    n_site=2,
+    r_a=[np.sqrt(3), 0],
+    r_b=[0.5 * np.sqrt(3), 1.5],
+    r_site=[
+        [1 / 3, 1 / 3],
+        [2 / 3, 2 / 3],
+    ],
+)
+honeycomb.plot(draw_unitcell=True)
+```
+
+![Honeycomb lattice](https://raw.githubusercontent.com/ianchung621/LLGS-simulation/main/doc/lattice.png)
+
+### 2. Initializing Spins
+
+Initialize the spins on the lattice to a desired configuration:
+
+```python
+zigzag_config = {
+    "b % 2 == 0": np.array([1, 0, 0]),
+    "b % 2 == 1": np.array([-1, 0, 0]),
+}
+honeycomb.initialize_spin(zigzag_config)
+honeycomb.plot()
+```
+
+![Initialized spins](https://raw.githubusercontent.com/ianchung621/LLGS-simulation/main/doc/spin_initialized.png)
+
+### 3. Setting Up Parameters for Simulation
+
+Build the exchange matrix from exact lattice bonds, then configure the
+simulation. Each bond is `(source_site, target_site, cell_offset, coupling)`;
+the reverse bond is added automatically.
+
+```python
+from llgs import LLGS_Simulation_2D, build_exchange
+
+J1 = -11.2  # exchange-matrix coefficient, Tesla
+exchange_bonds = [
+    (0, 1, (0, 0), J1),
+    (1, 0, (0, 1), J1),
+    (1, 0, (1, 0), J1),
+]
+H_E = build_exchange(honeycomb, exchange_bonds)
+H_ext = np.array([5.0, 5.0, 0.0])
+
+sim = LLGS_Simulation_2D(
+    honeycomb,
+    H_E=H_E,
+    H_ext=H_ext,
+    alpha=0.1,
+    H_para=0.086,
+    H_perp=1.812,
+    io_foldername="Data",
+    io_filename="results_RK4",
+    method="RK4",
+)
+```
+
+`H_E` may be a dense `(N, N)` array or a SciPy sparse matrix. For sparse DMI,
+pass `H_DMI` as a sequence of three sparse `(N, N)` matrices, one for each
+Cartesian component. Dense DMI remains a `(3, N, N)` array. Use
+`matrix_type="sparse"` to convert both fields to CSR matrices,
+`matrix_type="dense"` to convert them to NumPy arrays, or the default
+`matrix_type="auto"` to preserve the supplied representation.
+
+### 4. Running the Simulation
+
+Run the simulation for a specified number of steps and save the results:
+
+```python
+sim.evolve(dt=2e-4, max_iters=1000)
+```
+
+### 5. Visualizing Spin Dynamics
+
+The `read_result.py` module reads the simulation results and creates visualizations. Here is how you can animate the spin dynamics:
+
+```python
+from llgs import ReadResult
+
+results = ReadResult("Data/results_RK4.h5")
+
+results.animate(period=50, save_fn="Data/movie.gif")
+```
+
+### Example Output
+
+Here is an example of how the animation might look:
+
+![Spin dynamics animation](https://raw.githubusercontent.com/ianchung621/LLGS-simulation/main/doc/spin_animation.gif)
+
+### Additional Details
+
+For a comprehensive explanation of the methods, equations, and parameters,
+see the [example notebook](https://github.com/ianchung621/LLGS-simulation/blob/main/example.ipynb).
+
+This notebook includes:
+- Detailed descriptions of lattice construction.
+- Explanation of the exchange field matrix and LLGS simulation.
+- Mathematical derivations and parameter setups.

llgs_simulation-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+llgs/LLGS_simulation.py,sha256=lXgFWoqvueRX85MsalzArGRT27O9WT--2_WM9-J-y0Y,14110
+llgs/__init__.py,sha256=ZXaGJ0-5GBxfFFZ2KaIZfG9gFO0JbFKXYG95LVxPmd0,169
+llgs/interactions.py,sha256=1gKLyVRgtEAymq88BDjLsF6ER5l5YBMl_OLfhAoyeSI,4931
+llgs/lattice.py,sha256=jGV6wghJKzE6xmHQg4imXEnXbsC1qJwi4jVN03LFCQ0,6126
+llgs/plotting.py,sha256=ouVE9Aw54R6a2fJ-wtMfErVqeNSUtAgGRcnAmzIkZ4g,5206
+llgs/read_results.py,sha256=Vu6NJ2sAjOAUu8Q82ifTPf1qIYhRbswH8frgb1Rk1Rs,1661
+llgs/spin_velocity.py,sha256=xuc1HkLPNQg7uWPKmjMCVbvoeqeM-55NzY-jhggYXdk,2914
+llgs_simulation-0.1.0.dist-info/licenses/LICENSE,sha256=_fb8CcHtiob0C7tAYxiXmIw5rjS2-utwjsvmJW-su5Q,1066
+llgs_simulation-0.1.0.dist-info/METADATA,sha256=GQAeF2cGWHCVg0NoxSPSGGTntS0nAhDluBNvUauIyR0,6781
+llgs_simulation-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+llgs_simulation-0.1.0.dist-info/top_level.txt,sha256=ptJ0VXO0PUFXolrbCo5lTxRNzKNxCj5d5qxTfnlmTTE,5
+llgs_simulation-0.1.0.dist-info/RECORD,,

llgs_simulation-0.1.0.dist-info/WHEEL

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

llgs_simulation-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ian Chang
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

llgs_simulation-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+llgs