llg3d 2.0.0__py3-none-any.whl → 2.0.1__py3-none-any.whl

llg3d/__init__.py

@@ -1,4 +1,6 @@
+"""Main llg3d package."""
+
 from .solver import LIB_AVAILABLE, rank, size, comm, status
 
-__version__ = "2.0.0"
+__version__ = "2.0.1"
 __all__ = ["LIB_AVAILABLE", "rank", "size", "comm", "status", "__version__"]

llg3d/__main__.py

@@ -1,6 +1,6 @@
-# Enable to use llg3d as a module
+"""Main entry point to execute the llg3d module."""
 
 from .main import main
 
 if __name__ == "__main__":
-    main()
+    main()

llg3d/element.py

@@ -1,6 +1,6 @@
-r"""
-Module containing the definition of the chemical elements
-"""
+"""Module containing the definition of the chemical elements."""
+
+from abc import ABC
 
 import numpy as np
 
@@ -11,8 +11,16 @@ mu_0 = 4 * np.pi * 1.0e-7  #: Vacuum permeability :math:`[H.m^{-1}]`
 gamma = 1.76e11  #: Gyromagnetic ratio :math:`[rad.s^{-1}.T^{-1}]`
 
 
-class Element:
-    """Abstract class for chemical elements"""
+class Element(ABC):
+    """
+    Abstract class for chemical elements.
+
+    Args:
+        T: Temperature in Kelvin
+        H_ext: External magnetic field strength
+        g: Grid object representing the simulation grid
+        dt: Time step for the simulation
+    """
 
     A = 0.0
     K = 0.0
@@ -22,14 +30,6 @@ class Element:
     anisotropy: str = ""
 
     def __init__(self, T: float, H_ext: float, g: Grid, dt: float) -> None:
-        """Initializes the Element class with given parameters
-
-        Args:
-            T: Temperature in Kelvin
-            H_ext: External magnetic field strength
-            g: Grid object representing the simulation grid
-            dt: Time step for the simulation
-        """
         self.H_ext = H_ext
         self.g = g
         self.dt = dt
@@ -52,16 +52,16 @@ class Element:
 
     def get_CFL(self) -> float:
         """
-        Returns the value of the CFL
+        Returns the value of the CFL.
 
         Returns:
-            float: The CFL value
+            The CFL value
         """
         return self.dt * self.coeff_1 / self.g.dx**2
 
     def to_dict(self) -> dict:
         """
-        Export element parameters to a dictionary for JAX JIT compatibility
+        Export element parameters to a dictionary for JAX JIT compatibility.
 
         Returns:
             Dictionary containing element parameters needed for computations
@@ -81,6 +81,8 @@ class Element:
 
 
 class Cobalt(Element):
+    """Cobalt element."""
+
     A = 30.0e-12  #: Exchange constant :math:`[J.m^{-1}]`
     K = 520.0e3  #: Anisotropy constant :math:`[J.m^{-3}]`
     lambda_G = 0.5  #: Damping parameter :math:`[1]`
@@ -90,6 +92,8 @@ class Cobalt(Element):
 
 
 class Iron(Element):
+    """Iron element."""
+
     A = 21.0e-12  #: Exchange constant :math:`[J.m^{-1}]`
     K = 48.0e3  #: Anisotropy constant :math:`[J.m^{-3}]`
     lambda_G = 0.5  #: Damping parameter :math:`[1]`
@@ -99,6 +103,8 @@ class Iron(Element):
 
 
 class Nickel(Element):
+    """Nickel element."""
+
     A = 9.0e-12  #: Exchange constant :math:`[J.m^{-1}]`
     K = -5.7e3  #: Anisotropy constant :math:`[J.m^{-3}]`
     lambda_G = 0.5  #: Damping parameter :math:`[1]`

llg3d/grid.py

@@ -1,6 +1,4 @@
-"""
-Module to define the grid for the simulation
-"""
+"""Module to define the grid for the simulation."""
 
 from dataclasses import dataclass
 import numpy as np
@@ -10,7 +8,7 @@ from .solver import rank, size
 
 @dataclass
 class Grid:
-    """Stores grid data"""
+    """Stores grid data."""
 
     # Parameter values correspond to the global grid
     Jx: int  #: number of points in x direction
@@ -19,7 +17,7 @@ class Grid:
     dx: float  #: grid spacing in x direction
 
     def __post_init__(self) -> None:
-        """Compute grid characteristics"""
+        """Compute grid characteristics."""
         self.dy = self.dz = self.dx  # Setting dx = dy = dz
         self.Lx = (self.Jx - 1) * self.dx
         self.Ly = (self.Jy - 1) * self.dy
@@ -35,8 +33,7 @@ class Grid:
         self.ncell = (self.Jx - 1) * (self.Jy - 1) * (self.Jz - 1)
 
     def __str__(self) -> str:
-        """Print grid information"""
-
+        """Print grid information."""
         header = "\t\t".join(("x", "y", "z"))
         s = f"""\
 \t{header}
@@ -55,7 +52,7 @@ ncell = {self.ncell:d}
         self, T: float, name: str = "m1_mean", extension: str = "txt"
     ) -> str:
         """
-        Returns the output file name for a given temperature
+        Returns the output file name for a given temperature.
 
         Args:
             T: temperature
@@ -97,7 +94,7 @@ ncell = {self.ncell:d}
 
     def to_dict(self) -> dict:
         """
-        Export grid parameters to a dictionary for JAX JIT compatibility
+        Export grid parameters to a dictionary for JAX JIT compatibility.
 
         Returns:
             Dictionary containing grid parameters needed for computations
@@ -114,7 +111,7 @@ ncell = {self.ncell:d}
 
     def get_laplacian_coeff(self) -> tuple[float, float, float, float]:
         """
-        Returns the coefficients for the laplacian computation
+        Returns the coefficients for the laplacian computation.
 
         Returns:
             Tuple of coefficients (dx2_inv, dy2_inv, dz2_inv, center_coeff)

llg3d/main.py

@@ -1,6 +1,4 @@
-"""
-Define a CLI for the llg3d package.
-"""
+"""Define a CLI for the llg3d package."""
 
 import argparse
 
@@ -20,6 +18,7 @@ else:
 def parse_args(args: list[str] | None) -> argparse.Namespace:
     """
     Argument parser for llg3d.
+
     Automatically adds arguments from the parameter dictionary.
 
     Returns:
@@ -44,9 +43,11 @@ def parse_args(args: list[str] | None) -> argparse.Namespace:
 
 def main(arg_list: list[str] = None):
     """
-    Evaluates the command line and runs the simulation
-    """
+    Evaluates the command line and runs the simulation.
 
+    Args:
+        arg_list: List of command line arguments
+    """
     args = parse_args(arg_list)
 
     if size > 1 and args.solver != "mpi":

llg3d/output.py

@@ -1,6 +1,4 @@
-"""
-Utility functions for LLG3D
-"""
+"""Utility functions for LLG3D."""
 
 import json
 import sys
@@ -10,9 +8,11 @@ from .solver import rank
 from .grid import Grid
 
 
-def progress_bar(it: Iterable, prefix: str = "", size: int = 60, out: TextIO = sys.stdout):
+def progress_bar(
+    it: Iterable, prefix: str = "", size: int = 60, out: TextIO = sys.stdout
+):
     """
-    Displays a progress bar
+    Displays a progress bar.
 
     (Source: https://stackoverflow.com/a/34482761/16593179)
 
@@ -22,14 +22,13 @@ def progress_bar(it: Iterable, prefix: str = "", size: int = 60, out: TextIO = s
         size: Size of the progress bar (number of characters)
         out: Output stream (default is sys.stdout)
     """
-
     count = len(it)
 
     def show(j):
         x = int(size * j / count)
         if rank == 0:
             print(
-                f"{prefix}[{u'█'*x}{('.'*(size-x))}] {j}/{count}",
+                f"{prefix}[{'█' * x}{('.' * (size - x))}] {j}/{count}",
                 end="\r",
                 file=out,
                 flush=True,
@@ -48,7 +47,7 @@ def progress_bar(it: Iterable, prefix: str = "", size: int = 60, out: TextIO = s
 
 def write_json(json_file: str, run: dict):
     """
-    Writes the run dictionary to a JSON file
+    Writes the run dictionary to a JSON file.
 
     Args:
         json_file: Name of the JSON file
@@ -60,7 +59,7 @@ def write_json(json_file: str, run: dict):
 
 def get_output_files(g: Grid, T: float, n_mean: int, n_profile: int) -> tuple:
     """
-    Open files and list them
+    Open files and list them.
 
     Args:
         g: Grid object
@@ -95,7 +94,7 @@ def get_output_files(g: Grid, T: float, n_mean: int, n_profile: int) -> tuple:
 
 def close_output_files(f_mean: TextIO, f_profiles: list[TextIO] = None):
     """
-    Close all output files
+    Close all output files.
 
     Args:
         f_mean: file handler for storing m space integral over time

llg3d/parameters.py

@@ -58,13 +58,13 @@ parameters: dict[str, Parameter] = {
 
 def get_parameter_list(parameters: dict) -> str:
     """
-    Returns parameter values as a string
+    Returns parameter values as a string.
 
     Args:
-        d: Dictionary of parameters parsed by argparse
+        parameters: Dictionary of parameters parsed by argparse
 
     Returns:
-        str: Formatted string of parameters
+        Formatted string of parameters
     """
     width = max([len(name) for name in parameters])
     s = ""

llg3d/post/__init__.py

@@ -1 +1 @@
-"""Post-processing tools for LLG3D."""
+"""Post-processing tools for LLG3D."""

llg3d/post/plot_results.py

@@ -1,5 +1,5 @@
 """
-Plot 1D curves from several files
+Plot 1D curves from several files.
 
 Usage:
 
@@ -25,7 +25,6 @@ def plot(*files: tuple[str], output_file: str = DEFAULT_OUTPUT_FILE):
         files (tuple[str]): Paths to the result files.
         output_file (str): Path to the output image file.
     """
-
     fig, ax = plt.subplots()
     for file in files:
         if not file.endswith(".txt"):
@@ -43,12 +42,9 @@ def plot(*files: tuple[str], output_file: str = DEFAULT_OUTPUT_FILE):
 
 
 def main():
-    parser = argparse.ArgumentParser(
-        description="Plot results from one or more files."
-    )
-    parser.add_argument(
-        "files", nargs="+", type=str, help="Path to the result files."
-    )
+    """Main function to parse arguments and call the plot function."""
+    parser = argparse.ArgumentParser(description="Plot results from one or more files.")
+    parser.add_argument("files", nargs="+", type=str, help="Path to the result files.")
     parser.add_argument(
         "--output",
         "-o",

llg3d/post/process.py

@@ -1,12 +1,14 @@
 #!/usr/bin/env python3
 """
-Post-processes a set of runs grouped into a `run.json` file or
-into a set of SLURM job arrays:
+Post-processes a set of runs.
+
+Runs are grouped into a `run.json` file or into a set of SLURM job arrays:
 
 1. Extracts result data,
 2. Plots the computed average magnetization against temperature,
 3. Interpolates the computed points using cubic splines,
-4. Determines the Curie temperature as the value corresponding to the minimal (negative) slope of the interpolated curve.
+4. Determines the Curie temperature as the value corresponding to the minimal (negative)
+    slope of the interpolated curve.
 """
 
 import json
@@ -17,14 +19,11 @@ from scipy.interpolate import interp1d
 
 
 class MagData:
-    """
-    Class to handle magnetization data and interpolation according to temperature
-    """
+    """Class to handle magnetization data and interpolation according to temperature."""
 
     n_interp = 200
 
     def __init__(self, job_dir: Path = None, run_file: Path = Path("run.json")) -> None:
-
         if job_dir:
             self.parentpath = job_dir
             data, self.run = self.process_slurm_jobs()
@@ -65,16 +64,18 @@ class MagData:
                     run = json.load(f)
                     # Adding temperature and averaging value to the data list
                     data.extend(
-                        [[float(T), res["m1_mean"]] for T, res in run["results"].items()]
+                        [
+                            [float(T), res["m1_mean"]]
+                            for T, res in run["results"].items()
+                        ]
                     )
             except FileNotFoundError:
-                print(f"Warning: {json_filename} file not found " f"in {jobdir.as_posix()}")
+                print(f"Warning: {json_filename} file not found in {jobdir.as_posix()}")
 
         data.sort()  # Sorting by increasing temperatures
 
         return np.array(data), run
 
-
     def process_json(json_filepath: Path) -> tuple[np.array, dict]:
         """
         Reads the run.json file and extracts result data.
@@ -98,8 +99,12 @@ class MagData:
     @property
     def T_Curie(self) -> float:
         """
-        Return the Curie temperature defined as the temperature at
-        which the magnetization is below 0.1
+        Return the Curie temperature.
+
+        It is defined as the temperature at which the magnetization is below 0.1.
+
+        Returns:
+            float: Curie temperature
         """
         i_max = np.where(0.1 - self.interp(self.T) > 0)[0].min()
-        return self.T[i_max]
+        return self.T[i_max]

llg3d/post/temperature.py

@@ -1,7 +1,5 @@
 #!/usr/bin/env python3
-"""
-Plot the magnetization vs temperature and determine the Curie temperature.
-"""
+"""Plot the magnetization vs temperature and determine the Curie temperature."""
 
 import argparse
 from pathlib import Path
@@ -13,17 +11,14 @@ from .process import MagData
 
 def plot_m_vs_T(m: MagData, show: bool):
     """
-    Plots the data (T, <m>), interpolates the values,
-    calculates the Curie temperature.
-    Exports to PNG.
+    Plots the data (T, <m>).
+
+    Interpolates the values, calculates the Curie temperature, exports to PNG.
 
     Args:
-        data: numpy array (T, <m>)
-        parentdir: path to the directory containing the runs
-        run: descriptive dictionary of the run
+        m: Magnetization data object
         show: display the graph in a graphical window
     """
-
     print(f"T_Curie = {m.T_Curie:.0f} K")
 
     fig, ax = plt.subplots()
@@ -56,9 +51,7 @@ def plot_m_vs_T(m: MagData, show: bool):
 
 
 def main():
-    """
-    Parses the command line to execute processing functions
-    """
+    """Parses the command line to execute processing functions."""
     parser = argparse.ArgumentParser(description=__doc__)
     parser.add_argument("--job_dir", type=Path, help="Slurm main job directory")
     parser.add_argument(

llg3d/simulation.py

@@ -23,17 +23,14 @@ from .output import write_json
 class Simulation:
     """
     Class to encapsulate the simulation logic.
+
+    Args:
+        params: Dictionary of simulation parameters.
     """
 
     json_file = "run.json"  #: JSON file to store the results
 
     def __init__(self, params: dict[str, Parameter]):
-        """
-        Initializes the simulation with parameters.
-
-        Args:
-            params: Dictionary of simulation parameters.
-        """
         self.params: dict[str, Parameter] = params.copy()  #: simulation parameters
         self.simulate: callable = self._get_simulate_function_from_name(
             self.params["solver"]
@@ -46,9 +43,7 @@ class Simulation:
         self.params["element_class"] = get_element_class(params["element"])
 
     def run(self):
-        """
-        Runs the simulation and store the results.
-        """
+        """Runs the simulation and store the results."""
         self.total_time, self.filenames, self.m1_mean = self.simulate(**self.params)
 
     def _get_simulate_function_from_name(self, name: str) -> callable:
@@ -62,19 +57,15 @@ class Simulation:
             callable: The simulation function
 
         Example:
-
             >>> simulate = self.get_simulate_function_from_name("mpi")
 
             Will return the `simulate` function from the `llg3d.solver.mpi` module.
         """
-
         module = __import__(f"llg3d.solver.{name}", fromlist=["simulate"])
         return inspect.getattr_static(module, "simulate")
 
     def save(self):
-        """
-        Saves the results of the simulation to a JSON file.
-        """
+        """Saves the results of the simulation to a JSON file."""
         params = self.params.copy()  # save the parameters
         del params["element_class"]  # remove class object before serialization
         if rank == 0:

llg3d/solver/__init__.py

@@ -1,5 +1,5 @@
 """
-Solver module for LLG3D
+Solver module for LLG3D.
 
 This module contains different solver implementations.
 """
@@ -42,4 +42,4 @@ else:
 
     status = DummyStatus()
 
-from . import numpy, solver
+from . import numpy, solver  # noqa: E402

llg3d/solver/jax.py

@@ -1,6 +1,4 @@
-"""
-LLG3D solver using XLA compilation
-"""
+"""LLG3D solver using XLA compilation."""
 
 import os
 import time
@@ -20,8 +18,8 @@ def compute_H_anisotropy(
     m: jnp.ndarray, coeff_2: float, anisotropy: int
 ) -> jnp.ndarray:
     """
-    Compute anisotropy field (JIT compiled)
-    
+    Compute anisotropy field (JIT compiled).
+
     Args:
         m: Magnetization array (shape (3, nx, ny, nz))
         coeff_2: Coefficient for anisotropy
@@ -30,7 +28,6 @@ def compute_H_anisotropy(
     Returns:
         Anisotropy field array (shape (3, nx, ny, nz))
     """
-
     m1, m2, m3 = m
 
     m1m1 = m1 * m1
@@ -69,11 +66,17 @@ def compute_H_anisotropy(
 
 @jax.jit
 def laplacian3D(
-    m_i: jnp.ndarray, dx2_inv: float, dy2_inv: float, dz2_inv: float, center_coeff: float
+    m_i: jnp.ndarray,
+    dx2_inv: float,
+    dy2_inv: float,
+    dz2_inv: float,
+    center_coeff: float,
 ) -> jnp.ndarray:
     """
-    Compute Laplacian for a single component with Neumann boundary conditions (JIT compiled)
-    
+    Compute Laplacian for a single component with Neumann boundary conditions.
+
+    (JIT compiled)
+
     Args:
         m_i: Single component of magnetization (shape (nx, ny, nz))
         dx2_inv: Inverse of squared grid spacing in x direction
@@ -94,12 +97,10 @@ def laplacian3D(
 
 
 @jax.jit
-def compute_laplacian(
-    m: jnp.ndarray, dx: float, dy: float, dz: float
-) -> jnp.ndarray:
+def compute_laplacian(m: jnp.ndarray, dx: float, dy: float, dz: float) -> jnp.ndarray:
     """
-    Compute 3D Laplacian with Neumann boundary conditions (JIT compiled)
-    
+    Compute 3D Laplacian with Neumann boundary conditions (JIT compiled).
+
     Args:
         m: Magnetization array (shape (3, nx, ny, nz))
         dx: Grid spacing in x direction
@@ -111,7 +112,7 @@ def compute_laplacian(
     """
     dx2_inv, dy2_inv, dz2_inv = 1 / dx**2, 1 / dy**2, 1 / dz**2
     center_coeff = -2 * (dx2_inv + dy2_inv + dz2_inv)
-    
+
     return jnp.stack(
         [
             laplacian3D(m[0], dx2_inv, dy2_inv, dz2_inv, center_coeff),
@@ -125,44 +126,44 @@ def compute_laplacian(
 @jax.jit
 def compute_space_average_jax(m1: jnp.ndarray) -> float:
     """
-    Compute space average using midpoint method on GPU (JIT compiled)
-    
+    Compute space average using midpoint method on GPU (JIT compiled).
+
     Args:
         m1: First component of magnetization (shape (nx, ny, nz))
-        
+
     Returns:
         Space average of m1
     """
     # Get dimensions directly from the array shape
     Jx, Jy, Jz = m1.shape
-    
+
     # Create 3D coordinate grids using the shape
     i_coords = jnp.arange(Jx)
-    j_coords = jnp.arange(Jy) 
+    j_coords = jnp.arange(Jy)
     k_coords = jnp.arange(Jz)
-    
+
     # Create 3D coordinate grids
-    ii, jj, kk = jnp.meshgrid(i_coords, j_coords, k_coords, indexing='ij')
-    
+    ii, jj, kk = jnp.meshgrid(i_coords, j_coords, k_coords, indexing="ij")
+
     # Apply midpoint weights (0.5 on edges, 1.0 elsewhere)
     weights = jnp.ones_like(m1)
-    weights = jnp.where((ii == 0) | (ii == Jx-1), weights * 0.5, weights)
-    weights = jnp.where((jj == 0) | (jj == Jy-1), weights * 0.5, weights)
-    weights = jnp.where((kk == 0) | (kk == Jz-1), weights * 0.5, weights)
-    
+    weights = jnp.where((ii == 0) | (ii == Jx - 1), weights * 0.5, weights)
+    weights = jnp.where((jj == 0) | (jj == Jy - 1), weights * 0.5, weights)
+    weights = jnp.where((kk == 0) | (kk == Jz - 1), weights * 0.5, weights)
+
     # Compute weighted sum and normalize
     weighted_sum = jnp.sum(weights * m1)
-    
+
     # Compute ncell from the weights (this is the effective cell count)
     ncell = jnp.sum(weights)
-    
+
     return weighted_sum / ncell
 
 
 @jax.jit
 def cross_product(a: jnp.ndarray, b: jnp.ndarray) -> jnp.ndarray:
     r"""
-    Compute cross product :math:`a \times b` (JIT compiled)
+    Compute cross product :math:`a \times b` (JIT compiled).
 
     Args:
         a: First vector (shape (3, nx, ny, nz))
@@ -181,11 +182,12 @@ def compute_slope(
     g_params: dict, e_params: dict, m: jnp.ndarray, R_random: jnp.ndarray
 ) -> jnp.ndarray:
     """
-    JIT-compiled version of compute_slope_jax using modular sub-functions
+    JIT-compiled version of compute_slope_jax using modular sub-functions.
 
     Args:
         g_params: Grid parameters dict (dx, dy, dz)
-        e_params: Element parameters dict (coeff_1, coeff_2, coeff_3, lambda_G, anisotropy)
+        e_params: Element parameters dict (coeff_1, coeff_2, coeff_3, lambda_G,
+            anisotropy)
         m: Magnetization array (shape (3, nx, ny, nz))
         R_random: Random field array (shape (3, nx, ny, nz))
 
@@ -234,7 +236,7 @@ def simulate(
     **_,
 ) -> tuple[float, str, float]:
     """
-    Simulates the system for N iterations using JAX
+    Simulates the system for N iterations using JAX.
 
     Args:
         N: Number of iterations
@@ -258,7 +260,6 @@ def simulate(
         - The output filenames
         - The average magnetization
     """
-
     # Configure JAX
     if device == "auto":
         # Let JAX choose the best available device
@@ -276,7 +277,10 @@ def simulate(
             os.environ["CUDA_VISIBLE_DEVICES"] = str(gpu_id)
             print(f"Set CUDA_VISIBLE_DEVICES={gpu_id}")
         else:
-            print(f"Using external CUDA_VISIBLE_DEVICES={os.environ['CUDA_VISIBLE_DEVICES']}")
+            cuda_visible_devices = os.environ["CUDA_VISIBLE_DEVICES"]
+            print(
+                f"Using external CUDA_VISIBLE_DEVICES={cuda_visible_devices}"
+            )
 
     # Set precision
     if precision == "double":
@@ -305,11 +309,11 @@ def simulate(
 
     # --- Initialization ---
     def theta_init(shape):
-        """Initialization of theta"""
+        """Initialization of theta."""
         return jnp.zeros(shape, dtype=jnp_float)
 
     def phi_init(t, shape):
-        """Initialization of phi"""
+        """Initialization of phi."""
         return jnp.zeros(shape, dtype=jnp_float) + e.gamma_0 * H_ext * t
 
     m_n = jnp.zeros((3,) + dims, dtype=jnp_float)
@@ -328,16 +332,16 @@ def simulate(
 
     # === JIT WARMUP: Pre-compile all functions to exclude compilation time ===
     print("Warming up JIT compilation...")
-    
+
     # Generate dummy random field for warmup
     warmup_key = random.PRNGKey(42)
     R_warmup = e.coeff_4 * random.normal(warmup_key, (3,) + dims, dtype=jnp_float)
-    
+
     # Warmup all JIT functions with actual data shapes
     _ = compute_slope(g_params, e_params, m_n, R_warmup)
     if n_mean != 0:
         _ = compute_space_average_jax(m_n[0])
-    
+
     # Force compilation and execution to complete
     jax.block_until_ready(m_n)
     print("JIT warmup completed.")

llg3d/solver/mpi.py

@@ -1,5 +1,5 @@
 """
-LLG3D Solver using MPI
+LLG3D Solver using MPI.
 
 The parallelization is done in the x direction.
 """
@@ -22,9 +22,9 @@ def get_boundaries_x(
     g: Grid, m: np.ndarray, blocking: bool = False
 ) -> tuple[np.ndarray, np.ndarray, MPI.Request, MPI.Request]:
     """
-    Returns the boundaries asynchronously:
-    allows overlapping communication time of boundaries
-    with calculations
+    Returns the boundaries asynchronously.
+
+    Allows overlapping communication time of boundaries with calculations.
 
     Args:
         g: Grid object
@@ -37,7 +37,6 @@ def get_boundaries_x(
         - request_start: Request for start boundary
         - request_end: Request for end boundary
     """
-
     # Extract slices for Neumann boundary conditions
 
     m_i_x_start = np.empty((1, g.Jy, g.Jz))
@@ -80,6 +79,7 @@ def laplacian3D(
 ) -> np.ndarray:
     """
     Returns the Laplacian of m_i in 3D.
+
     We start by calculating contributions in y and z, to wait
     for the end of communications in x.
 
@@ -97,7 +97,6 @@ def laplacian3D(
     Returns:
         Laplacian of m_i (shape (nx, ny, nz))
     """
-
     # Extract slices for Neumann boundary conditions
     m_i_y_start = m_i[:, 1:2, :]
     m_i_y_end = m_i[:, -2:-1, :]
@@ -143,7 +142,7 @@ def compute_laplacian(
     boundaries: tuple[np.ndarray, np.ndarray, MPI.Request, MPI.Request],
 ) -> np.ndarray:
     """
-    Compute the laplacian of m in 3D
+    Compute the laplacian of m in 3D.
 
     Args:
         g: Grid object
@@ -153,7 +152,6 @@ def compute_laplacian(
     Returns:
         Laplacian of m (shape (3, nx, ny, nz))
     """
-
     dx2_inv, dy2_inv, dz2_inv, center_coeff = g.get_laplacian_coeff()
 
     return np.stack(
@@ -174,7 +172,7 @@ def compute_slope(
     boundaries: tuple[np.ndarray, np.ndarray, MPI.Request, MPI.Request],
 ) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
     """
-    Compute the slope of the LLG equation
+    Compute the slope of the LLG equation.
 
     Args:
         g: Grid object
@@ -186,7 +184,6 @@ def compute_slope(
     Returns:
         Slope array (shape (3, nx, ny, nz))
     """
-
     # Precalculate terms used multiple times
 
     H_aniso = compute_H_anisotropy(e, m)
@@ -205,8 +202,8 @@ def compute_slope(
 
 def space_average(g: Grid, m: np.ndarray) -> float:
     """
-    Returns the spatial average of m with shape (g.dims)
-    using the midpoint method.
+    Returns the spatial average of m with shape (g.dims) using the midpoint method.
+
     Performs the local sum on each process and then reduces it to process 0.
 
     Args:
@@ -216,7 +213,6 @@ def space_average(g: Grid, m: np.ndarray) -> float:
     Returns:
         Spatial average of m
     """
-
     # Make a copy of m to avoid modifying its value
     mm = m.copy()
 
@@ -242,16 +238,14 @@ def space_average(g: Grid, m: np.ndarray) -> float:
 
 def integral_yz(m: np.ndarray) -> np.ndarray:
     """
-    Returns the spatial average of shape (g.dims[0],)
-    in y and z of m of shape (g.dims) using the midpoint method
+    Returns the spatial average of m using the midpoint method along y and z.
 
     Args:
         m: Array to be integrated
 
     Returns:
-        np.ndarray: Spatial average of m in y and z
+        np.ndarray: Spatial average of m in y and z of shape (g.dims[0],)
     """
-
     # Make a copy of m to avoid modifying its value
     mm = m.copy()
 
@@ -267,26 +261,25 @@ def integral_yz(m: np.ndarray) -> np.ndarray:
 
 def profile(m: np.ndarray, m_xprof: np.ndarray):
     """
-    Retrieves the x profile of the average of m in y and z
+    Retrieves the x profile of the average of m in y and z.
 
     Args:
         m: Array to be integrated
         m_xprof: Array to store the x profile
     """
-
     # Gather m in mglob
     m_mean_yz = integral_yz(m)
     comm.Gather(m_mean_yz, m_xprof)
 
 
 def theta_init(t: float, g: Grid) -> np.ndarray:
-    """Initialization of theta"""
+    """Initialization of theta."""
     x, y, z = g.get_mesh(local=True)
     return np.zeros(g.dims)
 
 
 def phi_init(t: float, g: Grid, e: Element) -> np.ndarray:
-    """Initialization of phi"""
+    """Initialization of phi."""
     # return np.zeros(shape) + e.coeff_3 * t
     return np.zeros(g.dims) + e.gamma_0 * e.H_ext * t
 
@@ -309,7 +302,7 @@ def simulate(
     **_,
 ) -> tuple[float, str, float]:
     """
-    Simulates the system for N iterations
+    Simulates the system for N iterations.
 
     Args:
         N: Number of iterations
@@ -332,7 +325,6 @@ def simulate(
         - The time taken for the simulation
         - The output filename
     """
-
     if Jx % size != 0:
         if rank == 0:
             print(
@@ -433,7 +425,7 @@ def simulate(
 
 
 class ArgumentParser(argparse.ArgumentParser):
-    """An argument parser compatible with MPI"""
+    """An argument parser compatible with MPI."""
 
     def _print_message(self, message, file=None):
         if rank == 0 and message:
@@ -442,6 +434,15 @@ class ArgumentParser(argparse.ArgumentParser):
             file.write(message)
 
     def exit(self, status=0, message=None):
+        """
+        Exit the program using MPI finalize.
+
+        Args:
+            status: Exit status code
+            message: Optional exit message
+            file: Output file (default: stderr)
+
+        """
         if message:
             self._print_message(message, sys.stderr)
         comm.barrier()

llg3d/solver/numpy.py

@@ -1,6 +1,4 @@
-"""
-LLG3D Solver using NumPy
-"""
+"""LLG3D Solver using NumPy."""
 
 import time
 
@@ -16,7 +14,7 @@ def laplacian3D(
     m_i: np.ndarray, dx2_inv: float, dy2_inv: float, dz2_inv: float, center_coeff: float
 ) -> np.ndarray:
     """
-    Returns the laplacian of m in 3D
+    Returns the laplacian of m in 3D.
 
     Args:
         m_i: Magnetization array (shape (nx, ny, nz))
@@ -28,7 +26,6 @@ def laplacian3D(
     Returns:
         Laplacian of m (shape (nx, ny, nz))
     """
-
     m_i_padded = np.pad(m_i, ((1, 1), (1, 1), (1, 1)), mode="reflect")
 
     laplacian = (
@@ -42,7 +39,7 @@ def laplacian3D(
 
 def compute_laplacian(g: Grid, m: np.ndarray) -> np.ndarray:
     """
-    Compute the laplacian of m in 3D
+    Compute the laplacian of m in 3D.
 
     Args:
         g: Grid object
@@ -51,7 +48,6 @@ def compute_laplacian(g: Grid, m: np.ndarray) -> np.ndarray:
     Returns:
         Laplacian of m (shape (3, nx, ny, nz))
     """
-
     dx2_inv, dy2_inv, dz2_inv, center_coeff = g.get_laplacian_coeff()
 
     return np.stack(
@@ -68,17 +64,17 @@ def compute_slope(
     g: Grid, e: Element, m: np.ndarray, R_random: np.ndarray
 ) -> np.ndarray:
     """
-    Compute the slope of the LLG equation
+    Compute the slope of the LLG equation.
+
     Args:
         g: Grid object
         e: Element object
         m: Magnetization array (shape (3, nx, ny, nz))
-        R_random: Random field array (shape (3, nx, ny, nz))
+        R_random: Random field array (shape (3, nx, ny, nz)).
 
     Returns:
         Slope array (shape (3, nx, ny, nz))
     """
-
     H_aniso = compute_H_anisotropy(e, m)
 
     laplacian_m = compute_laplacian(g, m)
@@ -111,13 +107,14 @@ def simulate(
     **_,
 ) -> tuple[float, str, float]:
     """
-    Simulates the system for N iterations
+    Simulates the system for N iterations.
 
     Args:
         N: Number of iterations
         Jx: Number of grid points in x direction
         Jy: Number of grid points in y direction
-        Jz: Number of grid points in z direction        dx: Grid spacing
+        Jz: Number of grid points in z direction
+        dx: Grid spacing
         T: Temperature in Kelvin
         H_ext: External magnetic field strength
         dt: Time step for the simulation
@@ -152,11 +149,11 @@ def simulate(
     # --- Initialization ---
 
     def theta_init(shape):
-        """Initialization of theta"""
+        """Initialization of theta."""
         return np.zeros(shape, dtype=np_float)
 
     def phi_init(t, shape):
-        """Initialization of phi"""
+        """Initialization of phi."""
         return np.zeros(shape, dtype=np_float) + e.gamma_0 * H_ext * t
 
     m_n = np.zeros((3,) + dims, dtype=np_float)

llg3d/solver/opencl.py

@@ -1,6 +1,4 @@
-"""
-LLG3D Solver using OpenCL
-"""
+"""LLG3D Solver using OpenCL."""
 
 import time
 from pathlib import Path
@@ -15,15 +13,17 @@ from ..grid import Grid
 from ..element import Element, Cobalt
 
 
-def get_context_and_device(device_selection: str = "auto") -> tuple[cl.Context, cl.Device]:
+def get_context_and_device(
+    device_selection: str = "auto",
+) -> tuple[cl.Context, cl.Device]:
     """
-    Get the OpenCL context and device
+    Get the OpenCL context and device.
 
     Args:
         device_selection:
-            
+
             - ``"auto"``: Let OpenCL choose automatically
-            - ``"cpu"``: Select CPU device  
+            - ``"cpu"``: Select CPU device
             - ``"gpu"``: Select first available GPU
             - ``"gpu:N"``: Select specific GPU by index (e.g., ``"gpu:0"``, ``"gpu:1"``)
 
@@ -35,17 +35,17 @@ def get_context_and_device(device_selection: str = "auto") -> tuple[cl.Context,
         context = cl.create_some_context(interactive=False)
         device = context.devices[0]
         return context, device
-    
+
     # Get all platforms and devices
     platforms = cl.get_platforms()
     all_devices = []
-    
+
     for platform in platforms:
         all_devices.extend(platform.get_devices())
-    
+
     if not all_devices:
         raise RuntimeError("No OpenCL devices found")
-    
+
     # Filter devices based on selection
     if device_selection == "cpu":
         cpu_devices = [d for d in all_devices if d.type & cl.device_type.CPU]
@@ -61,26 +61,29 @@ def get_context_and_device(device_selection: str = "auto") -> tuple[cl.Context,
         gpu_devices = [d for d in all_devices if d.type & cl.device_type.GPU]
         if not gpu_devices:
             raise RuntimeError("No GPU devices found")
-        
+
         gpu_index = int(device_selection.split(":")[1])
         if gpu_index >= len(gpu_devices):
-            raise RuntimeError(f"GPU index {gpu_index} not available. Found {len(gpu_devices)} GPU(s)")
+            raise RuntimeError(
+                f"GPU index {gpu_index} not available. Found {len(gpu_devices)} GPU(s)"
+            )
         selected_device = gpu_devices[gpu_index]
     else:
         raise ValueError(f"Invalid device selection: {device_selection}")
-    
+
     # Create context with selected device
     context = cl.Context([selected_device])
     print(f"Selected OpenCL device: {selected_device.name} ({selected_device.type})")
-    
+
     return context, selected_device
 
 
 def get_precision(device: cl.Device, precision: str) -> np.dtype:
     """
-    Get the numpy float type based on the precision
+    Get the numpy float type based on the precision.
 
     Args:
+        device: OpenCL device
         precision: Precision of the simulation (single or double)
 
     Returns:
@@ -97,9 +100,7 @@ def get_precision(device: cl.Device, precision: str) -> np.dtype:
 
 
 class Program:
-    """
-    Class to manage the OpenCL kernels for the LLG3D simulation
-    """
+    """Class to manage the OpenCL kernels for the LLG3D simulation."""
 
     def __init__(self, g: Grid, context: cl.Context, np_float: np.dtype):
         self.grid = g
@@ -109,12 +110,11 @@ class Program:
 
     def _get_built_program(self) -> cl.Program:
         """
-        Return the OpenCL program built from the source code
+        Return the OpenCL program built from the source code.
 
         Returns:
             The OpenCL program object
         """
-
         opencl_code = (Path(__file__).parent / "llg3d.cl").read_text()
         build_options = "-D USE_DOUBLE_PRECISION" if self.np_float == np.float64 else ""
         build_options += (
@@ -157,13 +157,13 @@ def simulate(
     **_,
 ) -> tuple[float, str, float]:
     """
-    Simulates the system over N iterations
+    Simulates the system over N iterations.
 
     Args:
         N: Number of iterations
         Jx: Number of grid points in x direction
         Jy: Number of grid points in y direction
-        Jz: Number of grid points in z direction        
+        Jz: Number of grid points in z direction
         dx: Grid spacing
         T: Temperature in Kelvin
         H_ext: External magnetic field strength
@@ -181,7 +181,6 @@ def simulate(
         - The time taken for the simulation
         - The output filename
     """
-
     context, opencl_device = get_context_and_device(device)
     np_float = get_precision(opencl_device, precision)
 
@@ -190,17 +189,19 @@ def simulate(
 
     e = element_class(T, H_ext, g, dt)
     if not isinstance(e, Cobalt):
-        raise NotImplementedError(f"Element is {type(e)} but only {Cobalt} is supported at the moment.")
+        raise NotImplementedError(
+            f"Element is {type(e)} but only {Cobalt} is supported at the moment."
+        )
     print(f"CFL = {e.get_CFL()}")
 
     # --- Initialization ---
 
     def theta_init(shape):
-        """Initialization of theta"""
+        """Initialization of theta."""
         return np.zeros(shape, dtype=np_float)
 
     def phi_init(t, shape):
-        """Initialization of phi"""
+        """Initialization of phi."""
         return np.zeros(shape, dtype=np_float) + e.gamma_0 * H_ext * t
 
     m_n = np.zeros((3,) + g.dims, dtype=np_float)
@@ -219,7 +220,7 @@ def simulate(
     update_1_kernel = program.get_kernel("update_1", [None] * 3 + [np_float])
     update_2_kernel = program.get_kernel("update_2", [None] * 4 + [np_float])
     normalize_kernel = program.get_kernel("normalize")
-    
+
     # Create a CL array for m1 component in order to compute averages
     d_m1 = clarray.empty(queue, g.ntot, np_float)
     copy_m1_kernel = program.get_kernel("copy_m1", [None, None])
@@ -309,11 +310,11 @@ def simulate(
             # Copy only the first component from d_m_n to d_m1 with weights applied
             # d_m_n contains [m1, m2, m3] interleaved, we want only m1
             copy_m1_kernel(queue, g.dims, None, d_m_n, d_m1.data)
-            
+
             # Use PyOpenCL array sum to compute the weighted sum
             weighted_sum = clarray.sum(d_m1).get()
             m1_mean = weighted_sum / g.ncell
-            
+
             if n >= start_averaging:
                 m1_average += m1_mean * n_mean
 

llg3d/solver/solver.py

@@ -1,6 +1,4 @@
-"""
-Common functions for the LLG3D solver
-"""
+"""Common functions for the LLG3D solver."""
 
 import numpy as np
 
@@ -21,7 +19,6 @@ def cross_product(a: np.ndarray, b: np.ndarray) -> np.ndarray:
     Returns:
         Cross product :math:`a \times b` (shape (3, nx, ny, nz))
     """
-
     return np.stack(
         [
             a[1] * b[2] - a[2] * b[1],  # x-component
@@ -34,14 +31,15 @@ def cross_product(a: np.ndarray, b: np.ndarray) -> np.ndarray:
 
 def compute_H_anisotropy(e: Element, m: np.ndarray) -> np.ndarray:
     """
-    Compute the anisotropy field
+    Compute the anisotropy field.
+
     Args:
         e: Element object
-        m: Magnetization array (shape (3, nx, ny, nz))
+        m: Magnetization array (shape (3, nx, ny, nz)).
+
     Returns:
         Anisotropy field array (shape (3, nx, ny, nz))
     """
-
     m1, m2, m3 = m
 
     m1m1 = m1 * m1
@@ -63,8 +61,7 @@ def compute_H_anisotropy(e: Element, m: np.ndarray) -> np.ndarray:
 
 def space_average(g: Grid, m: np.ndarray, copy: bool = True) -> float:
     """
-    Returns the spatial average of m with shape (g.dims)
-    using the midpoint method
+    Returns the spatial average of m with shape (g.dims) using the midpoint method.
 
     Args:
         g: Grid object
@@ -72,9 +69,8 @@ def space_average(g: Grid, m: np.ndarray, copy: bool = True) -> float:
         copy: If True, copy m to avoid modifying its value
 
     Returns:
-        float: Spatial average of m
+        Spatial average of m
     """
-
     # copy m to avoid modifying its value
     mm = m.copy() if copy else m
 

{llg3d-2.0.0.dist-info → llg3d-2.0.1.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: llg3d
-Version: 2.0.0
-Summary: Solveur pour l'équation de Landau-Lifshitz-Gilbert stochastique en 3D
+Version: 2.0.1
+Summary: A solver for the stochastic Landau-Lifshitz-Gilbert equation in 3D
 Author-email: Clémentine Courtès <clementine.courtes@math.unistra.fr>, Matthieu Boileau <matthieu.boileau@math.unistra.fr>
 Project-URL: Homepage, https://gitlab.math.unistra.fr/llg3d/llg3d
 Classifier: Programming Language :: Python :: 3

llg3d-2.0.1.dist-info/RECORD

@@ -0,0 +1,25 @@
+llg3d/__init__.py,sha256=YhFE4dB9NPWdcadzg14xMgOao1PqDgzxU2iFKEp7Vjs,187
+llg3d/__main__.py,sha256=3D1q7AG5vU6gr-V0iuo5oNYl-Og2SvJ4YaBTdqOVVaw,115
+llg3d/element.py,sha256=B2GDv5lTNTgvbIqSThEaA2o3hQRkhQdIgXg-MxzeSuc,4304
+llg3d/grid.py,sha256=goXO-sh9wJ2YDqe3IerqE6NlvUFacp328RfXHHW6bFY,3848
+llg3d/main.py,sha256=8ltKUT9jA3u1E0cEUjxemRfRPhERnIm_i5L6sP0_G0I,1888
+llg3d/output.py,sha256=HCL1V1oehbV2OERwbS0WCG00W1kNeNQpgcP33LIrGWU,2934
+llg3d/parameters.py,sha256=VoAkm8v6MiOkwRaHupWgHVTQaSDSGIKz5jWnRT8PBx0,2442
+llg3d/simulation.py,sha256=8RbAzLhlhCEZZCGxqNEczxGvfrLsnxKbRCkfpy1cCtU,3429
+llg3d/post/__init__.py,sha256=rX0jQIXGQYzFRoXSsPu2oEDB4YWK5IxFs0cJqXnQb8g,39
+llg3d/post/plot_results.py,sha256=fmCxeKmRfpHa_sNHMqczYNWQOCLJzxfRDQL22AeeJcM,1550
+llg3d/post/process.py,sha256=YKOUIgjAOD3q6_qoxzWVSC0WHBofRZJafwWzdMXWQXA,3569
+llg3d/post/temperature.py,sha256=SHf3s1LHIY0SBDKLoSMGSKo1e7EXcKeMXZdlEsChCBk,2150
+llg3d/solver/__init__.py,sha256=fqd1wZkIAi0sMiOQg0tbfLInMDjTCFkRF5NA_FV1wyU,901
+llg3d/solver/jax.py,sha256=VKn7YanidgXhpoIKEJy0sL0HZ1wV3a9F1uWmbAmWOi0,12026
+llg3d/solver/mpi.py,sha256=hJSXbZxpmi3z6PyMxyvuSBHFaqDv4S_C2FnAwAgI_r4,13041
+llg3d/solver/numpy.py,sha256=3trvsn2W-CjGdFF70oQZ6Jw8avX47OJ1DighschMcHE,6040
+llg3d/solver/opencl.py,sha256=EEExOmSUDs0UPt-E4XvPv4NA_S4SuIqw5Uo9p4KghcM,10222
+llg3d/solver/solver.py,sha256=MXscOjO0-RUIqOir1D23_8xCFw8ulDADTFQwQbMkBvc,2142
+llg3d-2.0.1.dist-info/licenses/AUTHORS,sha256=vhJ88HikYvOrGiB_l1xH2X6hyn9ZJafx6mpoMYNhh1I,297
+llg3d-2.0.1.dist-info/licenses/LICENSE,sha256=aFxTGAyyve8nM9T2jWTarJzQhdSSC3MbbN1heNAev9c,1062
+llg3d-2.0.1.dist-info/METADATA,sha256=J7kKUK6YL7cIKhHmEJLMud6rzr93AgCGozbmHIYVwPY,1948
+llg3d-2.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+llg3d-2.0.1.dist-info/entry_points.txt,sha256=kjuf09uDEuROnDeuHkVen3oAS4ThEPS084TpHmQAbJ8,133
+llg3d-2.0.1.dist-info/top_level.txt,sha256=cBZ0roaXt3CAXqYojuO84lGPCtWuLlXxLGLYRKmHZy0,6
+llg3d-2.0.1.dist-info/RECORD,,

llg3d-2.0.0.dist-info/RECORD

@@ -1,25 +0,0 @@
-llg3d/__init__.py,sha256=7Bcs0le_-tmgNMoIH8KaKJRqHjrzfNLu6RMP6c8T-Jo,160
-llg3d/__main__.py,sha256=wZ2BSBj_ZgnfGNmYZkeDVrfMPpzLOEmjmSnXrjnwfzo,96
-llg3d/element.py,sha256=3umDR1CxRjMfaBKjDPp35RxG24cSagONwzWkY5doxuI,4290
-llg3d/grid.py,sha256=Vkj0K9lkYZLlmSk6-S3BOupKh6JtxrWTABiK06GZHsk,3844
-llg3d/main.py,sha256=A4d1_6NfPNfHptPoitE772zZT4akeF0zFVXM5Gu1Tjo,1829
-llg3d/output.py,sha256=llPZ7lQ1bKwfe-A_hBYEn0QWf0A2aFjHneJAv-djVJk,2921
-llg3d/parameters.py,sha256=Jg1sDPWLaUeDMFFJBdb3YmN7ljgsQ-8qDXMpXUUqjGI,2437
-llg3d/simulation.py,sha256=XtmB8vYaQbFsx9sQPXqGQs1m-iGTPqRpis1Y67W5hO0,3551
-llg3d/post/__init__.py,sha256=PUQUkQURiZrnZmfGWJK5YCqk5Wv1iqo_IzczftqgJVQ,38
-llg3d/post/plot_results.py,sha256=NEhIEpVouQO0kf5Gsq5CLsDtnQtBuC0hxQ8IWII04Fg,1507
-llg3d/post/process.py,sha256=yIM4LuhqSckfXCBTToPSnRS7qSswJ8tk3DNzJ-wQerU,3422
-llg3d/post/temperature.py,sha256=Zz7za7Af3zQAxuSVznpCf5Ive9da4dvOK-2U2-Vwhuc,2271
-llg3d/solver/__init__.py,sha256=cAXNyd8XZrdkfutNI0vgyMG4YueJiRL3Mqbf8nI7jvo,886
-llg3d/solver/jax.py,sha256=o-c8Vs6T6hAxn0eFchHwBjry8QOWr3MK-d2Rs7XpRRA,11965
-llg3d/solver/mpi.py,sha256=HINbUbVxLvqrM0yKMdg8sz_28eZ3TXOScaSNYvSgovg,12850
-llg3d/solver/numpy.py,sha256=vqQIMatv84obDcNjoCmKRtuRmOBxRAjwfxmKPH1h5YM,6035
-llg3d/solver/opencl.py,sha256=ZkZrjzsQryrYDqoJbGLq2E7uJHaxAeXJUEebOLaNlWw,10221
-llg3d/solver/solver.py,sha256=7m5iU1JtZfdRW6l20tnRElU4sPsmm-gqgNujyqe1BuE,2152
-llg3d-2.0.0.dist-info/licenses/AUTHORS,sha256=vhJ88HikYvOrGiB_l1xH2X6hyn9ZJafx6mpoMYNhh1I,297
-llg3d-2.0.0.dist-info/licenses/LICENSE,sha256=aFxTGAyyve8nM9T2jWTarJzQhdSSC3MbbN1heNAev9c,1062
-llg3d-2.0.0.dist-info/METADATA,sha256=4wnGvwrqKOLrZcsb5XIPKWBhWt1-diU3-f9LSUdbRP4,1952
-llg3d-2.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-llg3d-2.0.0.dist-info/entry_points.txt,sha256=kjuf09uDEuROnDeuHkVen3oAS4ThEPS084TpHmQAbJ8,133
-llg3d-2.0.0.dist-info/top_level.txt,sha256=cBZ0roaXt3CAXqYojuO84lGPCtWuLlXxLGLYRKmHZy0,6
-llg3d-2.0.0.dist-info/RECORD,,