llg3d 2.0.1__tar.gz → 3.0.0__tar.gz

{llg3d-2.0.1 → llg3d-3.0.0}/PKG-INFO

@@ -1,19 +1,20 @@
 Metadata-Version: 2.4
 Name: llg3d
-Version: 2.0.1
+Version: 3.0.0
 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.9
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 License-File: AUTHORS
 Requires-Dist: numpy
 Requires-Dist: matplotlib
 Requires-Dist: scipy
+Requires-Dist: tqdm
 Provides-Extra: mpi
 Requires-Dist: mpi4py; extra == "mpi"
 Provides-Extra: opencl
@@ -22,6 +23,8 @@ 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"
+Provides-Extra: git
+Requires-Dist: GitPython; extra == "git"
 Dynamic: license-file
 
 # LLG3D: A solver for the stochastic Landau-Lifshitz-Gilbert equation in 3D

{llg3d-2.0.1 → llg3d-3.0.0}/pyproject.toml

@@ -14,8 +14,8 @@ classifiers = [
     "License :: OSI Approved :: MIT License",
     "Operating System :: OS Independent",
 ]
-requires-python = ">=3.9"
-dependencies = ["numpy", "matplotlib", "scipy"]
+requires-python = ">=3.10"
+dependencies = ["numpy", "matplotlib", "scipy", "tqdm"]
 dynamic = ["version"]
 
 
@@ -28,8 +28,13 @@ 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"
+"llg3d.m1_vs_T" = "llg3d.post.m1_vs_T:main"
+"llg3d.m1_vs_time" = "llg3d.post.m1_vs_time:main"
+"llg3d.x_profiles" = "llg3d.post.x_profiles:main"
+"llg3d.info" = "llg3d.post.info:main"
+"llg3d.extract" = "llg3d.post.extract:main"
+"llg3d.bench.compare_commits" = "llg3d.benchmarks.compare_commits:main"
+"llg3d.bench.efficiency" = "llg3d.benchmarks.efficiency:main"
 
 [project.optional-dependencies]
 mpi = ["mpi4py"]
@@ -38,6 +43,7 @@ jax = [
     "jax[cuda] ; sys_platform != 'darwin'",
     "jax[cpu] ; sys_platform == 'darwin'",
 ]
+git = ["GitPython"]
 
 [tool.setuptools]
 include-package-data = true
@@ -55,6 +61,7 @@ attr = "llg3d.__version__"
 [tool.coverage.run]
 parallel = true
 source = ["src/"]
+omit = ["src/llg3d/benchmarks/*", "src/llg3d/solvers/jax/*"]
 
 [dependency-groups]
 dev = [
@@ -63,7 +70,7 @@ dev = [
     { include-group = "doc" },
 ]
 test = ["pytest", "pytest-cov", "pytest-mpi"]
-lint = ["ruff"]
+lint = ["ruff", "mypy", "pydoclint", "scipy-stubs", "types-tqdm"]
 doc = [
     "Sphinx >= 7.2.2",
     "sphinx-design",
@@ -77,6 +84,9 @@ doc = [
     "sphinxcontrib-programoutput",
     "sphinxcontrib-bibtex",
     "ipython",
+    "ipykernel",
+    "tabulate",
+    "types-tabulate",
 ]
 
 [tool.ruff]
@@ -111,3 +121,11 @@ indent-style = "space"
 skip-magic-trailing-comma = false
 # Line length compatible with Black
 line-ending = "auto"
+
+[tool.pydoclint]
+style = "google"
+arg-type-hints-in-docstring = false
+check-return-types = false
+
+[tool.coverage.report]
+omit = ["jax.py"]

llg3d-3.0.0/src/llg3d/__init__.py

@@ -0,0 +1,4 @@
+"""Main llg3d package."""
+
+__version__ = "3.0.0"
+__all__ = ["__version__"]

llg3d-3.0.0/src/llg3d/benchmarks/__init__.py

@@ -0,0 +1 @@
+"""Benchmarks package."""

llg3d-3.0.0/src/llg3d/benchmarks/compare_commits.py

@@ -0,0 +1,321 @@
+#!/usr/bin/env python3
+"""
+Compare simple benchmark timings between commits using GitPython.
+
+This script keeps repository objects local to `main()` so it fails fast when
+not run from the llg3d repository.
+"""
+
+import argparse
+import os
+import re
+import shlex
+import subprocess
+import sys
+import logging
+from pathlib import Path
+
+
+from .utils import ChdirTemporaryDirectory
+from git import Repo
+
+
+def get_llg3d_repo() -> Repo:
+    """Return the llg3d GitPython Repo object."""
+    repo = Repo(Path(__file__).resolve(), search_parent_directories=True)
+    if repo.working_tree_dir is None:
+        raise RuntimeError("Could not determine repository working tree")
+    root = Path(repo.working_tree_dir)
+
+    if (root / "src" / "llg3d").exists():
+        return repo
+
+    py = root / "pyproject.toml"
+    if py.exists():
+        try:
+            import tomllib
+
+            with py.open("rb") as fh:
+                data = tomllib.load(fh)
+                if data.get("project", {}).get("name") == "llg3d":
+                    return repo
+        except Exception:
+            pass
+
+    try:
+        for remote in repo.remotes:
+            try:
+                url = remote.url
+            except Exception:
+                url = repo.git.config(f"--get remote.{remote.name}.url")
+            if url and "llg3d" in str(url):
+                return repo
+    except Exception:
+        pass
+
+    logging.error("This script must be run inside the llg3d repository.")
+    logging.error(f"Detected repo root: {root}")
+    sys.exit(2)
+
+
+def get_current_commit(repo: Repo) -> str:
+    """Return the current commit hexsha for `repo`."""
+    return repo.head.commit.hexsha
+
+
+def get_current_ref(repo: Repo) -> str:
+    """Return the current branch name, or the commit if HEAD is detached."""
+    if repo.head.is_detached:
+        return get_current_commit(repo)
+    return repo.active_branch.name
+
+
+def ensure_clean_worktree(repo: Repo) -> None:
+    """Exit if the worktree contains changes or untracked files."""
+    if repo.is_dirty(untracked_files=True):
+        logging.error("Working tree is not clean. Stash or commit changes first.")
+        logging.error("Hint: git stash -u")
+        sys.exit(1)
+
+
+def checkout_commit(repo: Repo, commit: str) -> None:
+    """Checkout the given `commit` in `repo`."""
+    repo.git.checkout(commit)
+
+
+def run_single_benchmark(
+    solver: str,
+    Jx: int,
+    Jy: int,
+    Jz: int,
+    n_mean: int,
+    N: int,
+    launcher: str | None = None,
+    np_procs: int = 1,
+    precision: str = "single",
+    repo_root: Path | None = None,
+) -> dict:
+    """Run a single benchmark and return a dict with timing results."""
+    if repo_root is None:
+        raise RuntimeError("repo_root must be provided")
+
+    arg_new = (
+        f"--element Cobalt --N {N} --dt 1.0e-14 --Jx {Jx} --Jy {Jy} --Jz {Jz} "
+        f"--dx 1.0e-9 --T 1100.0 --H_ext 0.0 --solver {solver} --precision {precision} "
+        f"--n_mean {n_mean} --n_profile 0 --seed 42"
+    )
+    arg_old = (
+        f"-element Cobalt -N {N} -dt 1.0e-14 -Jx {Jx} -Jy {Jy} -Jz {Jz} "
+        f"-dx 1.0e-9 -T 1100.0 -H_ext 0.0 -n_average {n_mean} -n_profile 0"
+    )
+
+    candidates = [
+        ["python", "-m", "llg3d"],
+        ["python", "-m", "llg3d.__main__"],
+        ["python", "-m", "llg3d.main"],
+        ["python", "-m", "llg3d.llg3d"],
+    ]
+
+    effective_launcher = launcher
+    if solver == "mpi" and not effective_launcher:
+        effective_launcher = f"mpirun -np {np_procs}"
+
+    env = os.environ.copy()
+    env["PYTHONPATH"] = f"{repo_root / 'src'}" + (":" + env.get("PYTHONPATH", ""))
+
+    last_err = None
+    output = ""
+
+    with ChdirTemporaryDirectory() as tmpdir:
+        for arg_str in (arg_new, arg_old):
+            arg_list = shlex.split(arg_str)
+            for cli in candidates:
+                cmd = cli + arg_list
+                if effective_launcher:
+                    cmd = shlex.split(effective_launcher) + cmd
+                proc = subprocess.run(
+                    cmd,
+                    cwd=tmpdir,
+                    capture_output=True,
+                    text=True,
+                    env=env,
+                    check=False,
+                )
+                if proc.returncode == 0:
+                    output = proc.stdout
+                    break
+                last_err = (
+                    "Cmd: "
+                    + " ".join(cmd)
+                    + "\n"
+                    + "Stdout:\n"
+                    + proc.stdout
+                    + "\n"
+                    + "Stderr:\n"
+                    + proc.stderr
+                )
+                # log the last failing command at DEBUG level; it can be
+                # unrelated to the solver implementation/version
+                logging.debug(last_err)
+            if output:
+                break
+
+    if not output:
+        raise RuntimeError("Benchmark failed for all CLI variants\n" + (last_err or ""))
+
+    total_time = None
+    for line in output.splitlines():
+        if "total_time [s]" in line:
+            m = re.search(r"total_time \[s\]\s*=\s*([0-9.]+)", line)
+            if m:
+                total_time = float(m.group(1))
+                break
+
+    if total_time is None:
+        raise RuntimeError("Failed to extract total_time from output.\n" + output)
+
+    return {"total_time": total_time, "time_per_ite": total_time / N if N else 0.0}
+
+
+def print_separator(char: str = "=", length: int = 80) -> None:
+    """Print a simple separator line to stdout."""
+    logging.info(char * length)
+
+
+def main() -> None:
+    """Command-line entry point: compare benchmark timings between commits."""
+    # configure logging for the CLI; keep message format minimal
+    logging.basicConfig(level=logging.INFO, format="%(message)s")
+
+    repo = get_llg3d_repo()
+    assert repo.working_tree_dir is not None
+    repo_root = Path(repo.working_tree_dir)
+
+    parser = argparse.ArgumentParser(
+        description="Compare simple benchmark timings between two commits",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    parser.add_argument("--reference-commit", default="HEAD~1")
+    parser.add_argument(
+        "--solver",
+        default="numpy",
+        choices=["numpy", "mpi", "opencl"],
+    )
+    parser.add_argument(
+        "--debug",
+        action="store_true",
+        help="Enable debug logging output",
+    )
+    parser.add_argument(
+        "--np", type=int, default=1, help="Number of processes for MPI solver"
+    )
+    parser.add_argument(
+        "--launcher", default="", help="Launcher command for MPI solver"
+    )
+    parser.add_argument(
+        "--Jx", type=int, default=300, help="Number of grid points in x"
+    )
+    parser.add_argument("--Jy", type=int, default=21, help="Number of grid points in y")
+    parser.add_argument("--Jz", type=int, default=21, help="Number of grid points in z")
+    parser.add_argument(
+        "--n_mean",
+        type=int,
+        default=0,
+        help="Spatial average frequency (number of iterations)",
+    )
+    parser.add_argument(
+        "--precision",
+        choices=["single", "double"],
+        default="single",
+        help="Precision of the simulation",
+    )
+    parser.add_argument("--N", type=int, default=100, help="Number of iterations")
+    parser.add_argument("--skip-reference", action="store_true")
+
+    args = parser.parse_args()
+
+    if args.debug:
+        logging.getLogger().setLevel(logging.DEBUG)
+
+    current_ref = get_current_ref(repo)
+    current_commit = get_current_commit(repo)
+    reference_commit = args.reference_commit
+
+    if current_ref == current_commit:
+        logging.error("detached HEAD — checkout a branch first")
+        sys.exit(1)
+
+    print_separator()
+    logging.info("SIMPLE COMPARISON BENCHMARK")
+    print_separator()
+    logging.info(f"Current ref  : {current_ref}")
+    logging.info(f"Current hash : {current_commit[:8]}")
+    logging.info(f"Reference    : {reference_commit}")
+    logging.info(f"Solver       : {args.solver}")
+    print_separator()
+
+    reference_result = None
+    if not args.skip_reference:
+        stash = False
+        if repo.is_dirty(untracked_files=True):
+            try:
+                repo.git.stash("save", "-u")
+                stash = True
+            except Exception:
+                stash = False
+
+        try:
+            checkout_commit(repo, reference_commit)
+            reference_result = run_single_benchmark(
+                args.solver,
+                args.Jx,
+                args.Jy,
+                args.Jz,
+                args.n_mean,
+                args.N,
+                args.launcher or None,
+                args.np,
+                args.precision,
+                repo_root=repo_root,
+            )
+        finally:
+            checkout_commit(repo, current_ref)
+            if stash:
+                try:
+                    repo.git.stash("pop")
+                except Exception:
+                    pass
+
+    current_result = run_single_benchmark(
+        args.solver,
+        args.Jx,
+        args.Jy,
+        args.Jz,
+        args.n_mean,
+        args.N,
+        args.launcher or None,
+        args.np,
+        args.precision,
+        repo_root=repo_root,
+    )
+
+    if reference_result:
+        speedup = reference_result["total_time"] / current_result["total_time"]
+        diff_pct = (
+            100
+            * (current_result["total_time"] - reference_result["total_time"])
+            / reference_result["total_time"]
+        )
+        logging.info(f"Reference : {reference_result['total_time']:.3f} s")
+        logging.info(f"Current   : {current_result['total_time']:.3f} s")
+        logging.info(f"Speedup   : {speedup:.3f}x")
+        logging.info(f"Diff      : {diff_pct:+.1f}%")
+    else:
+        logging.info(f"Current   : {current_result['total_time']:.3f} s")
+
+    print_separator()
+    logging.info("✓ Benchmark completed!")
+
+
+if __name__ == "__main__":
+    main()