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

llg3d/post/plot_results.py

@@ -1,61 +0,0 @@
-"""
-Plot 1D curves from several files.
-
-Usage:
-
-python plot_results.py file1.txt
-or
-python plot_results.py file1.txt file2.txt file3.txt
-
-"""
-
-import argparse
-from matplotlib import pyplot as plt
-import numpy as np
-
-
-DEFAULT_OUTPUT_FILE = "results.png"
-
-
-def plot(*files: tuple[str], output_file: str = DEFAULT_OUTPUT_FILE):
-    """
-    Plot the results from the given files.
-
-    Args:
-        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"):
-            raise ValueError(f"File {file} does not end with .txt")
-        data = np.loadtxt(file)
-        ax.plot(data[:, 0], data[:, 1], label=file)
-
-    ax.set_xlabel("time")
-    ax.set_ylabel(r"$<m_1>$")
-    ax.legend()
-    ax.set_title(r"Space average of $m_1$ according to time")
-    fig.savefig(output_file)
-    print(f"Written to {output_file}")
-    plt.show()
-
-
-def main():
-    """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",
-        type=str,
-        default=DEFAULT_OUTPUT_FILE,
-        help=f"Path to the output image file (default: {DEFAULT_OUTPUT_FILE}).",
-    )
-    args = parser.parse_args()
-
-    plot(*args.files, output_file=args.output)
-
-
-if __name__ == "__main__":
-    main()

llg3d/post/temperature.py

@@ -1,76 +0,0 @@
-#!/usr/bin/env python3
-"""Plot the magnetization vs temperature and determine the Curie temperature."""
-
-import argparse
-from pathlib import Path
-
-import matplotlib.pyplot as plt
-
-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.
-
-    Args:
-        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()
-    fig.suptitle("Average magnetization vs Temperature")
-    params = m.run["params"]
-    ax.set_title(
-        params["element"]
-        + rf", ${params['Jx']}\times{params['Jy']}\times{params['Jz']}$"
-        rf" ($dx = ${params['dx']})",
-        fontdict={"size": 10},
-    )
-    ax.plot(m.temperature, m.m1_mean, "o", label="computed")
-    ax.plot(m.T, m.interp(m.T), label="interpolated (cubic)")
-    ax.annotate(
-        "$T_{{Curie}} = {:.0f} K$".format(m.T_Curie),
-        xy=(m.T_Curie, m.interp(m.T_Curie)),
-        xytext=(m.T_Curie + 20, m.interp(m.T_Curie) + 0.01),
-    )
-    ax.axvline(x=m.T_Curie, color="k")
-    ax.set_xlabel("Temperature [K]")
-    ax.set_ylabel("Magnetization")
-    ax.legend()
-
-    if show:
-        plt.show()
-
-    image_filename = m.parentpath / "m1_mean.png"
-    fig.savefig(image_filename)
-    print(f"Image saved in {image_filename}")
-
-
-def main():
-    """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(
-        "--run_file", type=Path, default="run.json", help="Path to the run.json file"
-    )
-    parser.add_argument(
-        "-s",
-        "--show",
-        action="store_true",
-        default=False,
-        help="Display the graph in a graphical window",
-    )
-    args = parser.parse_args()
-    if args.job_dir:
-        m = MagData(job_dir=args.job_dir)
-    else:
-        m = MagData(run_file=args.run_file)
-    plot_m_vs_T(m, args.show)
-
-
-if __name__ == "__main__":
-    main()

llg3d/simulation.py

@@ -1,95 +0,0 @@
-"""
-Define the Simulation class.
-
-Example usage:
-
-    >>> from llg3d.main import Simulation
-    >>> from llg3d.parameters import parameters
-    >>> run_parameters = {name: value["default"] for name, value in parameters.items()}
-    >>> sim = Simulation(run_parameters)
-    >>> sim.run()
-    >>> sim.save()
-
-"""
-
-import inspect
-
-from . import rank, size
-from .element import get_element_class
-from .parameters import Parameter
-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]):
-        self.params: dict[str, Parameter] = params.copy()  #: simulation parameters
-        self.simulate: callable = self._get_simulate_function_from_name(
-            self.params["solver"]
-        )  #: simulation function imported from the solver module
-        self.total_time: None | float = None  #: total simulation time
-        self.filenames: list[str] = []  #: list of output filenames
-        self.m1_mean: None | float = None  #: space and time average of m1
-        self.params["np"] = size  # Add a parameter for the number of processes
-        # Reference the element class from the element string
-        self.params["element_class"] = get_element_class(params["element"])
-
-    def run(self):
-        """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:
-        """
-        Retrieves the simulation function for a given solver name.
-
-        Args:
-            name: Name of the solver
-
-        Returns:
-            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."""
-        params = self.params.copy()  # save the parameters
-        del params["element_class"]  # remove class object before serialization
-        if rank == 0:
-            results = {"total_time": self.total_time}
-            # Export the integral of m1
-            if len(self.filenames) > 0:
-                results["integral_file"] = self.filenames[0]
-                print(f"Integral of m1 in {self.filenames[0]}")
-            # Export the x-profiles of m1, m2 and m3
-            for i, filename in enumerate(self.filenames[1:]):
-                results[f"xprofile_m{i}"] = filename
-                print(f"x-profile of m{i} in {filename}")
-
-            print(
-                f"""\
-N iterations      = {params["N"]}
-total_time [s]    = {self.total_time:.03f}
-time/ite [s/iter] = {self.total_time / params["N"]:.03e}\
-"""
-            )
-            # Export the mean of m1
-            if params["N"] > params["start_averaging"]:
-                print(f"m1_mean           = {self.m1_mean:e}")
-                results["m1_mean"] = float(self.m1_mean)
-
-            write_json(self.json_file, {"params": params, "results": results})
-            print(f"Summary in {self.json_file}")

llg3d/solver/__init__.py

@@ -1,45 +0,0 @@
-"""
-Solver module for LLG3D.
-
-This module contains different solver implementations.
-"""
-
-import importlib.util
-
-
-__all__ = ["numpy", "solver", "rank", "size", "comm", "status"]
-
-LIB_AVAILABLE: dict[str, bool] = {}
-
-# Check for other solver availability
-for lib in "opencl", "jax", "mpi4py":
-    if importlib.util.find_spec(lib, package=__package__) is not None:
-        LIB_AVAILABLE[lib] = True
-        __all__.append(lib)
-    else:
-        LIB_AVAILABLE[lib] = False
-
-
-# MPI utilities
-if LIB_AVAILABLE["mpi4py"]:
-    from mpi4py import MPI
-
-    comm = MPI.COMM_WORLD
-    rank = comm.Get_rank()
-    size = comm.Get_size()
-    status = MPI.Status()
-else:
-    # MPI library is not available: use dummy values
-    class DummyComm:
-        pass
-
-    comm = DummyComm()
-    rank = 0
-    size = 1
-
-    class DummyStatus:
-        pass
-
-    status = DummyStatus()
-
-from . import numpy, solver  # noqa: E402