nmag-python-3 0.0.2__py3-none-any.whl

nmag/simulation/demag/fields/recovery.py

@@ -0,0 +1,207 @@
+from __future__ import annotations
+
+import time
+from typing import TYPE_CHECKING, Any
+
+import numpy as np
+
+from ....backends import (
+    _load_rust_accelerator,
+    _selected_demag_cell_average_backend,
+    _selected_demag_nodal_recovery_backend,
+)
+from ...support import _simulation_compatibility_binding
+
+
+class SimulationDemagRecoveryMixin:
+    if TYPE_CHECKING:
+        _demag_nodal_cache: np.ndarray | None
+        _demag_cell_field_cache: tuple[np.ndarray, np.ndarray] | None
+
+        def __getattr__(self, name: str) -> Any: ...
+
+    def _get_demag_nodal_field(self) -> np.ndarray:
+        token = self._demag_token()
+        if self._demag_cache_token == token and self._demag_nodal_cache is not None:
+            return self._demag_nodal_cache
+
+        points = self._mesh_points()
+        simplices = np.asarray(self._require_mesh().simplices, dtype=int)
+        if simplices.size == 0:
+            self._demag_cache_token = token
+            self._demag_nodal_cache = np.zeros((len(points), 3), dtype=float)
+            return self._demag_nodal_cache
+        if simplices.ndim != 2 or simplices.shape[1] != 4:
+            raise NotImplementedError("The demag MVP currently supports tetrahedral 3D meshes.")
+
+        cell_h, volumes = self._get_demag_cell_field()
+        with self._record_active_subfield_array_timing_block(
+            "H_demag_detail:nodal_recovery",
+        ):
+            weights = self._incident_cell_volume_sums(points, simplices, volumes)
+            backend = _selected_demag_nodal_recovery_backend(
+                len(simplices), getattr(self, "config", None)
+            )
+            with self._record_active_subfield_array_timing_block(
+                f"H_demag_detail:nodal_recovery:{backend}",
+            ):
+                if backend == "rust":
+                    nodal_h = self._recover_demag_nodal_field_rust(
+                        simplices,
+                        volumes,
+                        cell_h,
+                        weights,
+                        len(points),
+                    )
+                else:
+                    nodal_h = self._recover_demag_nodal_field_python(
+                        simplices,
+                        volumes,
+                        cell_h,
+                        weights,
+                        len(points),
+                    )
+        self._demag_cache_token = token
+        self._demag_nodal_cache = nodal_h
+        return nodal_h
+
+    def _get_demag_cell_field(self) -> tuple[np.ndarray, np.ndarray]:
+        cache_started = time.perf_counter()
+        token = self._demag_token()
+        if self._demag_cell_cache_token == token and self._demag_cell_field_cache is not None:
+            self._record_active_subfield_array_timing(
+                "H_demag_detail:cell_field_cache_hit",
+                time.perf_counter() - cache_started,
+            )
+            return self._demag_cell_field_cache
+
+        points = self._mesh_points()
+        simplices = np.asarray(self._require_mesh().simplices, dtype=int)
+        if simplices.size == 0:
+            cell_h = np.zeros((0, 3), dtype=float)
+            volumes = np.zeros(0, dtype=float)
+            self._demag_cell_cache_token = token
+            self._demag_cell_field_cache = (cell_h, volumes)
+            return self._demag_cell_field_cache
+        if simplices.ndim != 2 or simplices.shape[1] != 4:
+            raise NotImplementedError("The demag MVP currently supports tetrahedral 3D meshes.")
+
+        with self._record_active_subfield_array_timing_block(
+            "H_demag_detail:auxiliary_fields",
+        ):
+            phi, _rho, volumes = self._get_demag_auxiliary_fields()
+        with self._record_active_subfield_array_timing_block(
+            "H_demag_detail:cell_gradient",
+        ):
+            cell_h = self._cell_demag_from_potential(points, simplices, phi)
+        self._demag_cell_cache_token = token
+        self._demag_cell_field_cache = (cell_h, volumes)
+        return self._demag_cell_field_cache
+
+    def _demag_cell_field_average(self) -> np.ndarray:
+        cell_h, volumes = self._get_demag_cell_field()
+        backend = _selected_demag_cell_average_backend(
+            len(volumes), getattr(self, "config", None)
+        )
+        with self._record_active_subfield_array_timing_block(
+            "H_demag_detail:cell_average",
+        ):
+            with self._record_active_subfield_array_timing_block(
+                f"H_demag_detail:cell_average:{backend}",
+            ):
+                if backend == "rust":
+                    return self._demag_cell_field_average_rust(cell_h, volumes)
+                return self._demag_cell_field_average_python(cell_h, volumes)
+
+    def _demag_cell_field_average_python(
+        self,
+        cell_h: np.ndarray,
+        volumes: np.ndarray,
+    ) -> np.ndarray:
+        if cell_h.size == 0 or volumes.size == 0:
+            return np.zeros(3, dtype=float)
+        positive = volumes > 0.0
+        if not np.any(positive):
+            return np.zeros(3, dtype=float)
+
+        if np.all(positive):
+            total_volume = float(np.sum(volumes))
+            if total_volume <= 0.0:
+                return np.zeros(3, dtype=float)
+            return np.dot(volumes, cell_h) / total_volume
+
+        total_volume = float(np.sum(volumes[positive]))
+        if total_volume <= 0.0:
+            return np.zeros(3, dtype=float)
+        return np.sum(cell_h[positive] * volumes[positive, np.newaxis], axis=0) / total_volume
+
+    def _demag_cell_field_average_rust(
+        self,
+        cell_h: np.ndarray,
+        volumes: np.ndarray,
+    ) -> np.ndarray:
+        rust_accel = _simulation_compatibility_binding(
+            "_load_rust_accelerator",
+            _load_rust_accelerator,
+        )("NmagConfig.accelerator['cell_average']")
+        try:
+            demag_cell_field_average = rust_accel.demag_cell_field_average
+        except AttributeError as exc:
+            raise RuntimeError(
+                "NmagConfig.accelerator['cell_average']='rust' requires a nmag_accel build "
+                "with demag_cell_field_average support."
+            ) from exc
+        return np.asarray(
+            demag_cell_field_average(
+                np.asarray(cell_h, dtype=np.float64),
+                np.asarray(volumes, dtype=np.float64),
+            ),
+            dtype=float,
+        )
+
+    def _recover_demag_nodal_field_python(
+        self,
+        simplices: np.ndarray,
+        volumes: np.ndarray,
+        cell_h: np.ndarray,
+        weights: np.ndarray,
+        point_count: int,
+    ) -> np.ndarray:
+        nodal_h = np.zeros((point_count, 3), dtype=float)
+        positive = volumes > 0.0
+        if np.any(positive):
+            positive_simplices = simplices[positive]
+            weighted_cell_h = cell_h[positive] * volumes[positive, np.newaxis]
+            for local_index in range(4):
+                np.add.at(
+                    nodal_h,
+                    positive_simplices[:, local_index],
+                    weighted_cell_h,
+                )
+
+        present = weights > 0.0
+        nodal_h[present] /= weights[present, np.newaxis]
+        return nodal_h
+
+    def _recover_demag_nodal_field_rust(
+        self,
+        simplices: np.ndarray,
+        volumes: np.ndarray,
+        cell_h: np.ndarray,
+        weights: np.ndarray,
+        point_count: int,
+    ) -> np.ndarray:
+        rust_accel = _simulation_compatibility_binding(
+            "_load_rust_accelerator",
+            _load_rust_accelerator,
+        )("NmagConfig.accelerator['nodal_recovery']")
+        return np.asarray(
+            rust_accel.recover_demag_nodal_field(
+                np.asarray(simplices, dtype=np.int64),
+                np.asarray(volumes, dtype=np.float64),
+                np.asarray(cell_h, dtype=np.float64),
+                np.asarray(weights, dtype=np.float64),
+                int(point_count),
+            ),
+            dtype=float,
+        )

nmag/simulation/demag/solver.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from ..exchange import SimulationExchangeMixin
+from .bem import SimulationDemagBemMixin
+from .fem import SimulationDemagFemMixin
+from .fields import SimulationDemagFieldsMixin
+from .fields.probe import SimulationDemagProbeMixin
+
+
+class SimulationDemagMixin(
+    SimulationExchangeMixin,
+    SimulationDemagFieldsMixin,
+    SimulationDemagFemMixin,
+    SimulationDemagBemMixin,
+    SimulationDemagProbeMixin,
+):
+    """Compose the exchange, demag field, FEM, BEM, and probe implementations."""

nmag/simulation/dynamics/__init__.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+import time
+from typing import TYPE_CHECKING, Any, cast
+
+from simulation import hysteresis as hysteresis_module
+
+from ...backends import _selected_integrator_backend
+from ..implicit_dynamics import relax_with_diffsol
+from ..support import _simulation_compatibility_binding
+from .integrator import (
+    SimulationIntegratorMixin,
+)
+from .integrator import (
+    _dop853_class as _dop853_class,  # noqa: F401
+)
+
+
+class SimulationDynamicsMixin(SimulationIntegratorMixin):
+    if TYPE_CHECKING:
+
+        def __getattr__(self, name: str) -> Any: ...
+
+    def do_next_stage(self, stage: int | None = None) -> None:
+        self.max_dm_dt = None
+        self.convergence.reset()
+        self.clock.inc_stage(stage=stage)
+        self._stage_wall_started = time.perf_counter()
+        self._invalidate_integrator()
+
+    def is_converged(self) -> bool:
+        if self.max_dm_dt is None:
+            self.clock.convergence = False
+            return False
+        converged = self.convergence.check(self.step, self.max_dm_dt, self.stopping_dm_dt)
+        self.clock.convergence = converged
+        return converged
+
+    @staticmethod
+    def hysteresis_next_stage(sim: Any) -> None:
+        sim.clock.stage_end = True
+
+    @staticmethod
+    def hysteresis_exit(sim: Any) -> None:
+        sim.clock.exit_hysteresis = True
+        sim.clock.stage_end = True
+
+    simulation_relax = hysteresis_module.simulation_relax
+
+    def relax(
+        self,
+        H_applied: Any = None,
+        save: list[tuple[object, ...]] | None = None,
+        do: list[tuple[object, ...]] | None = None,
+        convergence_check: Any = None,
+    ) -> None:
+        """Relax magnetization until the convergence schedule completes.
+
+        Args:
+            H_applied: Optional applied-field value for compatibility with the
+                staged relaxation runner.
+            save: Scheduled save tuples such as
+                ``[("averages", every("step", 10))]``. Omit for averages and
+                fields at stage end.
+            do: Scheduled action tuples. Omit for the default stage lifecycle.
+            convergence_check: Custom :class:`when.When` condition. Omit for
+                the accepted-step convergence cadence.
+
+        Raises:
+            NotImplementedError: If a custom schedule is requested with the
+                experimental Diffsol backend.
+        """
+        backend = _simulation_compatibility_binding(
+            "_selected_integrator_backend", _selected_integrator_backend
+        )(getattr(self, "config", None))
+        if backend == "scipy":
+            hysteresis_module.simulation_relax(
+                cast(Any, self),
+                H_applied=H_applied,
+                save=save,
+                do=do,
+                convergence_check=convergence_check,
+            )
+            return
+        if save is not None or do not in (None, []) or convergence_check is not None:
+            raise NotImplementedError(
+                "The experimental Diffsol backend currently supports only the default "
+                "relaxation save and convergence schedule."
+            )
+        relax_with_diffsol(self, H_applied=H_applied)
+
+    simulation_hysteresis = hysteresis_module.simulation_hysteresis

nmag/simulation/dynamics/advance.py

@@ -0,0 +1,199 @@
+from __future__ import annotations
+
+import time
+from typing import TYPE_CHECKING, Any
+
+import numpy as np
+from numpy.typing import NDArray
+
+from si.physical import SI
+
+from ...dynamics import IntegratorStats
+from ..support import _si_unit
+
+FloatArray = NDArray[np.float64]
+
+
+class SimulationTimeAdvanceMixin:
+    if TYPE_CHECKING:
+        _integrator: Any
+        _integrator_is_stale: bool
+        _integrator_rhs_evaluations: int
+        _last_integrator_stats: IntegratorStats
+
+        def __getattr__(self, name: str) -> Any: ...
+
+    def advance_time(
+        self,
+        target_time: SI,
+        max_it: int = -1,
+        exact_tstop: bool | None = None,
+    ) -> SI:
+        """Advance adaptive LLG integration toward a physical target time.
+
+        Args:
+            target_time: Absolute stage time to reach.
+            max_it: Maximum accepted steps, or ``-1`` for no explicit cap.
+            exact_tstop: Override whether a step crossing the target is
+                reconstructed at exactly the requested time.
+
+        Returns:
+            The physical time reached. It can precede ``target_time`` when
+            ``max_it`` limits the operation.
+
+        Raises:
+            ValueError: If the target precedes the current time or ``max_it``
+                is invalid.
+            RuntimeError: If the numerical integrator fails.
+        """
+        target_seconds, current_seconds = self._advance_request(target_time, max_it)
+        if target_seconds == current_seconds or max_it == 0:
+            return SI(current_seconds, "s")
+        integrator = self._active_integrator(current_seconds)
+        state_before: FloatArray = np.array(integrator.y, dtype=np.float64, copy=True)
+        time_before = float(integrator.t)
+        rhs_before = self._integrator_rhs_evaluations
+        accepted_steps, last_step_seconds = 0, 0.0
+        failed = False
+        status = "running"
+        started = time.perf_counter()
+        try:
+            integrator, accepted_steps, last_step_seconds = self._advance_integrator(
+                integrator,
+                target_seconds,
+                max_it,
+                self._integrator_config.exact_tstop if exact_tstop is None else exact_tstop,
+                time_before,
+            )
+            reached_seconds = self._accept_integrated_state(
+                integrator,
+                state_before,
+                time_before,
+                accepted_steps,
+                last_step_seconds,
+                started,
+            )
+            status = str(integrator.status)
+            return SI(reached_seconds, "s")
+        except Exception:
+            failed = True
+            status = "failed"
+            raise
+        finally:
+            self._last_integrator_stats = IntegratorStats(
+                accepted_steps=accepted_steps,
+                rhs_evaluations=self._integrator_rhs_evaluations - rhs_before,
+                rejected_steps=None,
+                failed=failed,
+                status=status,
+                last_step_seconds=last_step_seconds,
+                simulated_seconds=max(
+                    0.0, float(getattr(integrator, "t", time_before)) - time_before
+                ),
+                wall_seconds=time.perf_counter() - started,
+            )
+
+    def _advance_request(self, target_time: SI, max_it: int) -> tuple[float, float]:
+        target_seconds = target_time.in_units_of(_si_unit("s"))
+        current_seconds = self.clock.time_reached_si.in_units_of(_si_unit("s"))
+        if target_seconds < current_seconds:
+            raise ValueError("target_time cannot be earlier than the current stage time.")
+        if max_it < -1:
+            raise ValueError("max_it must be -1 or a non-negative integer.")
+        return target_seconds, current_seconds
+
+    def _active_integrator(self, current_seconds: float) -> Any:
+        if self._integrator is None or self._integrator_is_stale:
+            self.reinitialise(initial_time=current_seconds)
+        if self._integrator is None:
+            raise RuntimeError("The time integrator was not initialised.")
+        return self._integrator
+
+    def _advance_integrator(
+        self,
+        integrator: Any,
+        target_seconds: float,
+        max_it: int,
+        exact: bool,
+        time_before: float,
+    ) -> tuple[Any, int, float]:
+        accepted_steps, last_step_seconds = 0, 0.0
+        while self._can_continue_advancing(integrator, target_seconds, max_it, accepted_steps):
+            previous_time = float(integrator.t)
+            message = integrator.step()
+            if integrator.status == "failed":
+                raise RuntimeError(message or "DOP853 failed to advance the LLG state.")
+            accepted_steps += 1
+            last_step_seconds = float(integrator.t) - previous_time
+            if exact and float(integrator.t) > target_seconds:
+                integrator = self._restart_at_exact_target(
+                    integrator,
+                    target_seconds,
+                    time_before,
+                )
+                last_step_seconds = target_seconds - previous_time
+                break
+        return integrator, accepted_steps, last_step_seconds
+
+    @staticmethod
+    def _can_continue_advancing(
+        integrator: Any,
+        target_seconds: float,
+        max_it: int,
+        accepted_steps: int,
+    ) -> bool:
+        return float(integrator.t) < target_seconds and (max_it < 0 or accepted_steps < max_it)
+
+    def _restart_at_exact_target(
+        self,
+        integrator: Any,
+        target_seconds: float,
+        time_before: float,
+    ) -> Any:
+        accepted_state = np.asarray(integrator.dense_output()(target_seconds), dtype=np.float64)
+        self._fields["m"] = np.array(np.reshape(accepted_state, (-1, 3)), copy=True)
+        self._invalidate_demag()
+        self._integrator_is_stale = True
+        self.reinitialise(initial_time=target_seconds)
+        if self._integrator is None:
+            raise RuntimeError("The time integrator could not be reinitialised.")
+        # Reinitialisation positions the solver at the target. Keep the clock at
+        # the start of this advance until record_advance accounts for the delta.
+        self.clock.stage_time = SI(time_before, "s")
+        return self._integrator
+
+    def _accept_integrated_state(
+        self,
+        integrator: Any,
+        state_before: FloatArray,
+        time_before: float,
+        accepted_steps: int,
+        last_step_seconds: float,
+        started: float,
+    ) -> float:
+        accepted_state = np.asarray(integrator.y, dtype=np.float64)
+        if not np.all(np.isfinite(accepted_state)):
+            raise FloatingPointError("The integrator accepted a non-finite magnetisation state.")
+        reached_seconds = float(integrator.t)
+        self._fields["m"] = np.array(np.reshape(accepted_state, (-1, 3)), copy=True)
+        self._invalidate_demag()
+        elapsed_seconds = reached_seconds - time_before
+        self.clock.record_advance(
+            stage_time_seconds=reached_seconds,
+            accepted_steps=accepted_steps,
+            last_step_seconds=last_step_seconds,
+            wall_seconds=time.perf_counter() - started,
+        )
+        self._record_max_dm_dt(accepted_state, state_before, elapsed_seconds)
+        return reached_seconds
+
+    def _record_max_dm_dt(
+        self,
+        accepted_state: FloatArray,
+        state_before: FloatArray,
+        elapsed_seconds: float,
+    ) -> None:
+        if elapsed_seconds <= 0.0:
+            return
+        displacement: FloatArray = np.reshape(accepted_state - state_before, (-1, 3))
+        self.max_dm_dt = float(np.max(np.linalg.norm(displacement, axis=1)) / elapsed_seconds)