llg3d 1.4.1__tar.gz → 2.0.1__tar.gz

{llg3d-1.4.1/src/llg3d.egg-info → llg3d-2.0.1}/PKG-INFO

@@ -1,36 +1,28 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: llg3d
-Version: 1.4.1
-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
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.6
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 License-File: AUTHORS
 Requires-Dist: numpy
-Requires-Dist: mpi4py
 Requires-Dist: matplotlib
 Requires-Dist: scipy
-Provides-Extra: test
-Requires-Dist: pytest; extra == "test"
-Requires-Dist: pytest-cov; extra == "test"
-Requires-Dist: pytest-mpi; extra == "test"
-Provides-Extra: doc
-Requires-Dist: Sphinx>=7.2.2; extra == "doc"
-Requires-Dist: myst-parser; extra == "doc"
-Requires-Dist: furo; extra == "doc"
-Requires-Dist: nbsphinx; extra == "doc"
-Requires-Dist: sphinx-copybutton; extra == "doc"
-Requires-Dist: sphinx-autobuild; extra == "doc"
-Requires-Dist: sphinx-prompt; extra == "doc"
-Requires-Dist: sphinx-last-updated-by-git; extra == "doc"
-Requires-Dist: sphinxcontrib-programoutput; extra == "doc"
-Requires-Dist: sphinxcontrib-bibtex; extra == "doc"
-Requires-Dist: ipython; extra == "doc"
+Provides-Extra: mpi
+Requires-Dist: mpi4py; extra == "mpi"
+Provides-Extra: opencl
+Requires-Dist: pyopencl; extra == "opencl"
+Requires-Dist: mako; extra == "opencl"
+Provides-Extra: jax
+Requires-Dist: jax[cuda]; sys_platform != "darwin" and extra == "jax"
+Requires-Dist: jax[cpu]; sys_platform == "darwin" and extra == "jax"
+Dynamic: license-file
 
 # LLG3D: A solver for the stochastic Landau-Lifshitz-Gilbert equation in 3D
 
@@ -40,6 +32,6 @@ Requires-Dist: ipython; extra == "doc"
 [![Doc](https://img.shields.io/badge/doc-sphinx-blue)](https://llg3d.pages.math.unistra.fr/llg3d/)
 [![SWH](https://archive.softwareheritage.org/badge/origin/https://gitlab.math.unistra.fr/llg3d/llg3d/)](https://archive.softwareheritage.org/browse/origin/?origin_url=https://gitlab.math.unistra.fr/llg3d/llg3d)
 
-LLG3D is written in Python and utilizes the MPI library for parallelizing computations.
+LLG3D is written in Python and may run in parallel using MPI, OpenCL or JAX.
 
 See the [documentation](https://llg3d.pages.math.unistra.fr/llg3d/).

{llg3d-1.4.1 → llg3d-2.0.1}/README.md

@@ -6,6 +6,6 @@
 [![Doc](https://img.shields.io/badge/doc-sphinx-blue)](https://llg3d.pages.math.unistra.fr/llg3d/)
 [![SWH](https://archive.softwareheritage.org/badge/origin/https://gitlab.math.unistra.fr/llg3d/llg3d/)](https://archive.softwareheritage.org/browse/origin/?origin_url=https://gitlab.math.unistra.fr/llg3d/llg3d)
 
-LLG3D is written in Python and utilizes the MPI library for parallelizing computations.
+LLG3D is written in Python and may run in parallel using MPI, OpenCL or JAX.
 
 See the [documentation](https://llg3d.pages.math.unistra.fr/llg3d/).

llg3d-2.0.1/pyproject.toml

@@ -0,0 +1,113 @@
+[build-system]
+requires = ["setuptools>=61.2"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "llg3d"
+authors = [
+    { name = "Clémentine Courtès", email = "clementine.courtes@math.unistra.fr" },
+    { name = "Matthieu Boileau", email = "matthieu.boileau@math.unistra.fr" },
+]
+description = "A solver for the stochastic Landau-Lifshitz-Gilbert equation in 3D"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+requires-python = ">=3.9"
+dependencies = ["numpy", "matplotlib", "scipy"]
+dynamic = ["version"]
+
+
+[project.readme]
+file = "README.md"
+content-type = "text/markdown"
+
+[project.urls]
+Homepage = "https://gitlab.math.unistra.fr/llg3d/llg3d"
+
+[project.scripts]
+llg3d = "llg3d.main:main"
+"llg3d.post" = "llg3d.post.temperature:main"
+"llg3d.plot_results" = "llg3d.post.plot_results:main"
+
+[project.optional-dependencies]
+mpi = ["mpi4py"]
+opencl = ["pyopencl", "mako"]
+jax = [
+    "jax[cuda] ; sys_platform != 'darwin'",
+    "jax[cpu] ; sys_platform == 'darwin'",
+]
+
+[tool.setuptools]
+include-package-data = true
+
+[tool.setuptools.package-dir]
+"" = "src"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+namespaces = false
+
+[tool.setuptools.dynamic.version]
+attr = "llg3d.__version__"
+
+[tool.coverage.run]
+parallel = true
+source = ["src/"]
+
+[dependency-groups]
+dev = [
+    { include-group = "lint" },
+    { include-group = "test" },
+    { include-group = "doc" },
+]
+test = ["pytest", "pytest-cov", "pytest-mpi"]
+lint = ["ruff"]
+doc = [
+    "Sphinx >= 7.2.2",
+    "sphinx-design",
+    "myst-parser",
+    "furo",
+    "nbsphinx",
+    "sphinx-copybutton",
+    "sphinx-autobuild",
+    "sphinx-prompt",
+    "sphinx-last-updated-by-git",
+    "sphinxcontrib-programoutput",
+    "sphinxcontrib-bibtex",
+    "ipython",
+]
+
+[tool.ruff]
+# Set line length to 88 (compatible with Black)
+line-length = 88
+exclude = ["src/llg3d/process_tmp/"]
+
+[tool.ruff.lint.per-file-ignores]
+# Ignore all directories named `tests`.
+"tests/**" = ["D"]
+
+[tool.ruff.lint]
+# Enable pydocstyle (D) rules along with existing rules
+select = ["E", "F", "W", "D"]
+extend-select = ["D213"]
+ignore = [
+    "D107", # Missing docstring in __init__()
+    # Style preferences - ignore D212 to enable D213 (Google convention)
+    "D212", # Multi-line docstring summary should start at the first line (we prefer D213)
+]
+
+[tool.ruff.lint.pydocstyle]
+# Use Google convention for docstrings
+convention = "google"
+
+[tool.ruff.format]
+# Use double quotes for strings (compatible with Black)
+quote-style = "double"
+# Use 4 spaces for indentation (compatible with Black)
+indent-style = "space"
+# Respect magic trailing comma (compatible with Black)
+skip-magic-trailing-comma = false
+# Line length compatible with Black
+line-ending = "auto"

llg3d-2.0.1/src/llg3d/__init__.py

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

llg3d-2.0.1/src/llg3d/__main__.py

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

llg3d-2.0.1/src/llg3d/element.py

@@ -0,0 +1,134 @@
+"""Module containing the definition of the chemical elements."""
+
+from abc import ABC
+
+import numpy as np
+
+from .grid import Grid
+
+k_B = 1.38e-23  #: Boltzmann constant :math:`[J.K^{-1}]`
+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(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
+    lambda_G = 0.0
+    M_s = 0.0
+    a_eff = 0.0
+    anisotropy: str = ""
+
+    def __init__(self, T: float, H_ext: float, g: Grid, dt: float) -> None:
+        self.H_ext = H_ext
+        self.g = g
+        self.dt = dt
+        self.gamma_0 = gamma * mu_0  #: Rescaled gyromagnetic ratio [mA^-1.s^-1]
+
+        # --- Characteristic Scales ---
+        self.coeff_1 = self.gamma_0 * 2.0 * self.A / (mu_0 * self.M_s)
+        self.coeff_2 = self.gamma_0 * 2.0 * self.K / (mu_0 * self.M_s)
+        self.coeff_3 = self.gamma_0 * H_ext
+
+        # corresponds to the temperature actually put into the random field
+        T_simu = T * self.g.dx / self.a_eff
+        # calculation of the random field related to temperature
+        # (we only take the volume over one mesh)
+        h_alea = np.sqrt(
+            2 * self.lambda_G * k_B / (self.gamma_0 * mu_0 * self.M_s * self.g.dV)
+        )
+        H_alea = h_alea * np.sqrt(T_simu) * np.sqrt(1.0 / self.dt)
+        self.coeff_4 = H_alea * self.gamma_0
+
+    def get_CFL(self) -> float:
+        """
+        Returns the value of the CFL.
+
+        Returns:
+            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.
+
+        Returns:
+            Dictionary containing element parameters needed for computations
+        """
+        # Map anisotropy string to integer for JIT compatibility
+        aniso_map = {"uniaxial": 0, "cubic": 1}
+
+        return {
+            "coeff_1": self.coeff_1,
+            "coeff_2": self.coeff_2,
+            "coeff_3": self.coeff_3,
+            "coeff_4": self.coeff_4,
+            "lambda_G": self.lambda_G,
+            "anisotropy": aniso_map[self.anisotropy],
+            "gamma_0": self.gamma_0,
+        }
+
+
+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]`
+    M_s = 1400.0e3  #: Saturation magnetization :math:`[A.m^{-1}]`
+    a_eff = 0.25e-9  #: Effective lattice constant :math:`[m]`
+    anisotropy = "uniaxial"  #: Type of anisotropy (e.g., "uniaxial", "cubic")
+
+
+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]`
+    M_s = 1700.0e3  #: Saturation magnetization :math:`[A.m^{-1}]`
+    a_eff = 0.286e-9  #: Effective lattice constant :math:`[m]`
+    anisotropy = "cubic"  #: Type of anisotropy (e.g., "uniaxial", "cubic")
+
+
+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]`
+    M_s = 490.0e3  #: Saturation magnetization :math:`[A.m^{-1}]`
+    a_eff = 0.345e-9  #: Effective lattice constant :math:`[m]`
+    anisotropy = "cubic"  #: Type of anisotropy (e.g., "uniaxial", "cubic")
+
+
+def get_element_class(element_name: str | type[Element]) -> type[Element]:
+    """
+    Get the class of the chemical element by its name.
+
+    Args:
+        element_name: The name of the element or its class
+
+    Returns:
+        The class of the element
+
+    Raises:
+        ValueError: If the element is not found
+    """
+    if isinstance(element_name, type):
+        return element_name
+    for cls in Element.__subclasses__():
+        if cls.__name__ == element_name:
+            return cls
+    raise ValueError(f"Element '{element_name}' not found in {__file__}.")

llg3d-2.0.1/src/llg3d/grid.py

@@ -0,0 +1,123 @@
+"""Module to define the grid for the simulation."""
+
+from dataclasses import dataclass
+import numpy as np
+
+from .solver import rank, size
+
+
+@dataclass
+class Grid:
+    """Stores grid data."""
+
+    # Parameter values correspond to the global grid
+    Jx: int  #: number of points in x direction
+    Jy: int  #: number of points in y direction
+    Jz: int  #: number of points in z direction
+    dx: float  #: grid spacing in x direction
+
+    def __post_init__(self) -> None:
+        """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
+        self.Lz = (self.Jz - 1) * self.dz
+        # shape of the local array to the process
+        self.dims = self.Jx // size, self.Jy, self.Jz
+        # elemental volume of a cell
+        self.dV = self.dx * self.dy * self.dz
+        # total volume
+        self.V = self.Lx * self.Ly * self.Lz
+        # total number of points
+        self.ntot = self.Jx * self.Jy * self.Jz
+        self.ncell = (self.Jx - 1) * (self.Jy - 1) * (self.Jz - 1)
+
+    def __str__(self) -> str:
+        """Print grid information."""
+        header = "\t\t".join(("x", "y", "z"))
+        s = f"""\
+\t{header}
+J\t{self.Jx}\t\t{self.Jy}\t\t{self.Jz}
+L\t{self.Lx:.08e}\t{self.Ly:.08e}\t{self.Lz:.08e}
+d\t{self.dx:.08e}\t{self.dy:.08e}\t{self.dz:.08e}
+
+dV    = {self.dV:.08e}
+V     = {self.V:.08e}
+ntot  = {self.ntot:d}
+ncell = {self.ncell:d}
+"""
+        return s
+
+    def get_filename(
+        self, T: float, name: str = "m1_mean", extension: str = "txt"
+    ) -> str:
+        """
+        Returns the output file name for a given temperature.
+
+        Args:
+            T: temperature
+            name: file name
+            extension: file extension
+
+        Returns:
+            file name
+
+        >>> g = Grid(Jx=300, Jy=21, Jz=21, dx=1.e-9)
+        >>> g.get_filename(1100)
+        'm1_mean_T1100_300x21x21.txt'
+        """
+        suffix = f"T{int(T)}_{self.Jx}x{self.Jy}x{self.Jz}"
+        return f"{name}_{suffix}.{extension}"
+
+    def get_mesh(
+        self, local: bool = True, dtype=np.float64
+    ) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+        """
+        Returns a meshgrid of the coordinates.
+
+        Args:
+            local: if True, returns the local coordinates,
+                   otherwise the global coordinates
+            dtype: data type of the coordinates)
+
+        Returns:
+            tuple of 3D arrays with the coordinates
+        """
+        x_global = np.linspace(0, self.Lx, self.Jx, dtype=dtype)  # global coordinates
+        y = np.linspace(0, self.Ly, self.Jy, dtype=dtype)
+        z = np.linspace(0, self.Lz, self.Jz, dtype=dtype)
+        if local:
+            x_local = np.split(x_global, size)[rank]  # local coordinates
+            return np.meshgrid(x_local, y, z, indexing="ij")
+        else:
+            return np.meshgrid(x_global, y, z, indexing="ij")
+
+    def to_dict(self) -> dict:
+        """
+        Export grid parameters to a dictionary for JAX JIT compatibility.
+
+        Returns:
+            Dictionary containing grid parameters needed for computations
+        """
+        return {
+            "dx": self.dx,
+            "dy": self.dy,
+            "dz": self.dz,
+            "Jx": self.Jx,
+            "Jy": self.Jy,
+            "Jz": self.Jz,
+            "dV": self.dV,
+        }
+
+    def get_laplacian_coeff(self) -> tuple[float, float, float, float]:
+        """
+        Returns the coefficients for the laplacian computation.
+
+        Returns:
+            Tuple of coefficients (dx2_inv, dy2_inv, dz2_inv, center_coeff)
+        """
+        dx2_inv = 1 / self.dx**2
+        dy2_inv = 1 / self.dy**2
+        dz2_inv = 1 / self.dz**2
+        center_coeff = -2 * (dx2_inv + dy2_inv + dz2_inv)
+        return dx2_inv, dy2_inv, dz2_inv, center_coeff

llg3d-2.0.1/src/llg3d/main.py

@@ -0,0 +1,67 @@
+"""Define a CLI for the llg3d package."""
+
+import argparse
+
+
+from . import rank, size, LIB_AVAILABLE
+from .parameters import parameters, get_parameter_list
+from .simulation import Simulation
+
+if LIB_AVAILABLE["mpi4py"]:
+    # Use the MPI version of the ArgumentParser
+    from .solver.mpi import ArgumentParser
+else:
+    # Use the original version of the ArgumentParser
+    from argparse import ArgumentParser
+
+
+def parse_args(args: list[str] | None) -> argparse.Namespace:
+    """
+    Argument parser for llg3d.
+
+    Automatically adds arguments from the parameter dictionary.
+
+    Returns:
+        argparse.Namespace: Parsed arguments
+    """
+    parser = ArgumentParser(
+        description=__doc__,
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+
+    if size > 1:
+        parameters["solver"]["default"] = "mpi"
+
+    # Automatically add arguments from the parameter dictionary
+    for name, parameter in parameters.items():
+        if "action" not in parameter:
+            parameter["type"] = type(parameter["default"])
+        parser.add_argument(f"--{name}", **parameter)
+
+    return parser.parse_args(args)
+
+
+def main(arg_list: list[str] = None):
+    """
+    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":
+        raise ValueError(f"Solver method {args.solver} is not compatible with MPI.")
+    if args.solver == "mpi" and not LIB_AVAILABLE["mpi4py"]:
+        raise ValueError(
+            "The MPI solver method requires to install the mpi4py package, "
+            "for example using pip: pip install mpi4py"
+        )
+
+    if rank == 0:
+        # Display parameters as a list
+        print(get_parameter_list(vars(args)))
+
+    simulation = Simulation(vars(args))
+    simulation.run()
+    simulation.save()

llg3d-2.0.1/src/llg3d/output.py

@@ -0,0 +1,107 @@
+"""Utility functions for LLG3D."""
+
+import json
+import sys
+from typing import Iterable, TextIO
+
+from .solver import rank
+from .grid import Grid
+
+
+def progress_bar(
+    it: Iterable, prefix: str = "", size: int = 60, out: TextIO = sys.stdout
+):
+    """
+    Displays a progress bar.
+
+    (Source: https://stackoverflow.com/a/34482761/16593179)
+
+    Args:
+        it: Iterable object to iterate over
+        prefix: Prefix string for the progress bar
+        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}[{'█' * x}{('.' * (size - x))}] {j}/{count}",
+                end="\r",
+                file=out,
+                flush=True,
+            )
+
+    show(0)
+    for i, item in enumerate(it):
+        yield item
+        # To avoid slowing down the computation, we do not display at every iteration
+        if i % 5 == 0:
+            show(i + 1)
+    show(i + 1)
+    if rank == 0:
+        print("\n", flush=True, file=out)
+
+
+def write_json(json_file: str, run: dict):
+    """
+    Writes the run dictionary to a JSON file.
+
+    Args:
+        json_file: Name of the JSON file
+        run: Dictionary containing the run information
+    """
+    with open(json_file, "w") as f:
+        json.dump(run, f, indent=4)
+
+
+def get_output_files(g: Grid, T: float, n_mean: int, n_profile: int) -> tuple:
+    """
+    Open files and list them.
+
+    Args:
+        g: Grid object
+        T: temperature
+        n_mean: Number of iterations for integral output
+        n_profile: Number of iterations for profile output
+
+    Returns:
+        - a file handler for storing m space integral over time
+        - a file handler for storing x-profiles of m_i
+        - a list of output filenames
+    """
+    f_mean = None
+    f_profiles = None
+    output_filenames = []
+    if n_mean != 0:
+        output_filenames.append(g.get_filename(T, extension="txt"))
+    if n_profile != 0:
+        output_filenames.extend(
+            [g.get_filename(T, name=f"m{i + 1}", extension="npy") for i in range(3)]
+        )
+    if rank == 0:
+        if n_mean != 0:
+            f_mean = open(output_filenames[0], "w")  # integral of m1
+        if n_profile != 0:
+            f_profiles = [
+                open(output_filename, "wb") for output_filename in output_filenames[1:]
+            ]  # x profiles of m_i
+
+    return f_mean, f_profiles, output_filenames
+
+
+def close_output_files(f_mean: TextIO, f_profiles: list[TextIO] = None):
+    """
+    Close all output files.
+
+    Args:
+        f_mean: file handler for storing m space integral over time
+        f_profiles: file handlers for storing x-profiles of m_i
+    """
+    if f_mean is not None:
+        f_mean.close()
+    if f_profiles is not None:
+        for f_profile in f_profiles:
+            f_profile.close()