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

nmag/simulation/anisotropy/materials.py

@@ -0,0 +1,138 @@
+"""Map material anisotropy models onto geometric mesh nodes."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+
+import numpy as np
+
+from anisotropy import AnisotropyModel, PredefinedAnisotropy, anisotropy_signature_values
+
+from ..support import _si_unit
+
+
+@dataclass(frozen=True, slots=True)
+class NodalAnisotropyGroup:
+    model: AnisotropyModel
+    order: int | None
+    nodes: np.ndarray
+    saturation_magnetisation: float
+
+
+class SimulationAnisotropyMaterialMixin:
+    if TYPE_CHECKING:
+        _nodal_anisotropy_groups_cache: tuple[int, tuple[NodalAnisotropyGroup, ...]] | None
+
+        def __getattr__(self, name: str) -> Any: ...
+
+    def _nodal_anisotropy_groups(self) -> tuple[NodalAnisotropyGroup, ...]:
+        token = self._mesh_geometry_token()
+        cached = self._nodal_anisotropy_groups_cache
+        if cached is not None and cached[0] == token:
+            return cached[1]
+
+        point_count = len(self._mesh_points())
+        simplices = np.asarray(self._require_mesh().simplices, dtype=np.int64)
+        regions = np.asarray(
+            self._require_mesh().regions or [1] * len(simplices),
+            dtype=np.int64,
+        )
+        assignments: list[tuple[np.ndarray, Any, float] | None] = [None] * point_count
+
+        if len(simplices) == 0:
+            if self.materials:
+                material = self.materials[0]
+                signature = anisotropy_signature_values(
+                    material.anisotropy,
+                    material.anisotropy_order,
+                )
+                ms = float(material.Ms.in_units_of(_si_unit("A/m")))
+                assignments = [(signature, material, ms)] * point_count
+        else:
+            if len(regions) != len(simplices):
+                raise ValueError("Mesh regions must contain one entry per simplex.")
+            for region in np.unique(regions):
+                material = self._simplex_material(int(region))
+                signature = anisotropy_signature_values(
+                    material.anisotropy,
+                    material.anisotropy_order,
+                )
+                ms = float(material.Ms.in_units_of(_si_unit("A/m")))
+                nodes = np.unique(simplices[regions == region].ravel())
+                for node in nodes:
+                    previous = assignments[int(node)]
+                    if previous is not None:
+                        previous_signature, _previous_material, previous_ms = previous
+                        if not self._anisotropy_materials_compatible(
+                            _previous_material,
+                            material,
+                            previous_signature,
+                            signature,
+                        ) or not np.isclose(previous_ms, ms, rtol=1.0e-12, atol=0.0):
+                            raise NotImplementedError(
+                                "A mesh node shared by materials with different anisotropy or Ms "
+                                "requires material-specific magnetisation DOFs; node "
+                                f"{int(node)} includes region {int(region)}."
+                            )
+                    else:
+                        assignments[int(node)] = (signature, material, ms)
+
+        if self.materials:
+            fallback = self.materials[0]
+            fallback_signature = anisotropy_signature_values(
+                fallback.anisotropy,
+                fallback.anisotropy_order,
+            )
+            fallback_ms = float(fallback.Ms.in_units_of(_si_unit("A/m")))
+            assignments = [
+                assignment or (fallback_signature, fallback, fallback_ms)
+                for assignment in assignments
+            ]
+
+        grouped_nodes: dict[bytes, list[int]] = {}
+        grouped_materials: dict[bytes, tuple[Any, float]] = {}
+        for node, assignment in enumerate(assignments):
+            if assignment is None:
+                continue
+            signature, material, ms = assignment
+            key = signature.tobytes() + np.float64(ms).tobytes()
+            grouped_nodes.setdefault(key, []).append(node)
+            grouped_materials[key] = (material, ms)
+
+        groups = tuple(
+            NodalAnisotropyGroup(
+                model=grouped_materials[key][0].anisotropy,
+                order=grouped_materials[key][0].anisotropy_order,
+                nodes=np.asarray(nodes, dtype=np.int64),
+                saturation_magnetisation=grouped_materials[key][1],
+            )
+            for key, nodes in grouped_nodes.items()
+        )
+        self._nodal_anisotropy_groups_cache = (token, groups)
+        return groups
+
+    @staticmethod
+    def _anisotropy_materials_compatible(
+        first: Any,
+        second: Any,
+        first_signature: np.ndarray,
+        second_signature: np.ndarray,
+    ) -> bool:
+        first_model = first.anisotropy
+        second_model = second.anisotropy
+        if first_model is None or second_model is None:
+            return first_model is second_model
+        if isinstance(first_model, PredefinedAnisotropy) and isinstance(
+            second_model,
+            PredefinedAnisotropy,
+        ):
+            return bool(
+                np.allclose(
+                    first_signature,
+                    second_signature,
+                    rtol=1.0e-12,
+                    atol=1.0e-12,
+                )
+            )
+        return first_model is second_model and first.anisotropy_order == second.anisotropy_order

nmag/simulation/demag/__init__.py

@@ -0,0 +1 @@
+"""Demagnetization solver, field, and geometry implementation modules."""

nmag/simulation/demag/bem/__init__.py

@@ -0,0 +1,11 @@
+"""BEM demagnetization compatibility façade composed from focused mixins."""
+
+from .dirichlet import SimulationDemagBemDirichletMixin
+from .operator import SimulationDemagBemOperatorMixin
+
+
+class SimulationDemagBemMixin(
+    SimulationDemagBemOperatorMixin,
+    SimulationDemagBemDirichletMixin,
+):
+    """Provide Lindholm BEM construction and Dirichlet extension."""

nmag/simulation/demag/bem/diagnostics.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+import numpy as np
+
+from ....demag.bem_operator import (
+    BemOperatorStats,
+    HierarchicalLindholmBemOperator,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def bem_operator_stats(
+    *,
+    requested_backend: str,
+    effective_backend: str,
+    fallback_reason: str | None,
+    operator: Any,
+    boundary_node_count: int,
+    boundary_faces: int,
+    setup_seconds: float,
+) -> BemOperatorStats:
+    dense_equivalent = boundary_node_count**2 * np.dtype(np.float64).itemsize
+    if isinstance(operator, HierarchicalLindholmBemOperator):
+        rust_operator = operator.rust_operator
+        dense_blocks = int(rust_operator.dense_blocks)
+        low_rank_blocks = int(rust_operator.low_rank_blocks)
+        maximum_rank = int(rust_operator.maximum_rank)
+        mean_rank = float(rust_operator.mean_rank)
+        sampled_error = float(rust_operator.sampled_relative_error)
+        storage_bytes = operator.storage_bytes
+    else:
+        dense_blocks = 1 if isinstance(operator, np.ndarray) and operator.size else 0
+        low_rank_blocks = 0
+        maximum_rank = 0
+        mean_rank = 0.0
+        sampled_error = 0.0
+        storage_bytes = (
+            int(operator.nbytes) if isinstance(operator, np.ndarray) else operator.storage_bytes
+        )
+    return BemOperatorStats(
+        requested_backend=requested_backend,
+        effective_backend=effective_backend,
+        fallback_reason=fallback_reason,
+        boundary_nodes=boundary_node_count,
+        boundary_faces=boundary_faces,
+        setup_seconds=setup_seconds,
+        storage_bytes=storage_bytes,
+        dense_equivalent_bytes=dense_equivalent,
+        dense_blocks=dense_blocks,
+        low_rank_blocks=low_rank_blocks,
+        maximum_rank=maximum_rank,
+        mean_rank=mean_rank,
+        sampled_relative_error=sampled_error,
+    )
+
+
+def log_bem_operator_selection(stats: BemOperatorStats, selected_backend: str) -> None:
+    fallback = (
+        f" after {selected_backend} fallback: {stats.fallback_reason}"
+        if stats.fallback_reason
+        else ""
+    )
+    logger.info(
+        "Lindholm BEM selected %s storage%s (%.3f MiB, %.3f dense ratio)",
+        stats.effective_backend,
+        fallback,
+        stats.storage_bytes / (1024 * 1024),
+        stats.compression_ratio,
+    )

nmag/simulation/demag/bem/dirichlet.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+import numpy as np
+
+from ....backends import _selected_demag_linear_solver_backend
+from ....demag import _solve_linear_system
+from ....demag.linear import _factorize_scipy, _is_sparse_matrix, _solve_sparse_linear_system
+
+
+class SimulationDemagBemDirichletMixin:
+    if TYPE_CHECKING:
+        _demag_dirichlet_factorization_cache: Any | None
+
+        def __getattr__(self, name: str) -> Any: ...
+
+    def _dirichlet_extension_from_boundary(
+        self,
+        stiffness: np.ndarray,
+        boundary_nodes: np.ndarray,
+        boundary_values: np.ndarray,
+    ) -> np.ndarray:
+        with self._record_active_subfield_array_timing_block(
+            "demag_auxiliary:dirichlet_extension:index",
+        ):
+            phi = np.zeros(stiffness.shape[0], dtype=float)
+            phi[boundary_nodes] = boundary_values
+            boundary_set = set(int(index) for index in boundary_nodes)
+            interior_nodes = np.asarray(
+                [index for index in range(stiffness.shape[0]) if index not in boundary_set],
+                dtype=int,
+            )
+        if len(interior_nodes) == 0:
+            self._record_active_subfield_array_timing(
+                "demag_auxiliary:dirichlet_extension:no_interior",
+                0.0,
+            )
+            return phi
+
+        with self._record_active_subfield_array_timing_block(
+            "demag_auxiliary:dirichlet_extension:slice",
+        ):
+            if _is_sparse_matrix(stiffness):
+                interior_stiffness = stiffness[interior_nodes][:, interior_nodes]
+                boundary_stiffness = stiffness[interior_nodes][:, boundary_nodes]
+            else:
+                interior_stiffness = stiffness[np.ix_(interior_nodes, interior_nodes)]
+                boundary_stiffness = stiffness[np.ix_(interior_nodes, boundary_nodes)]
+        with self._record_active_subfield_array_timing_block(
+            "demag_auxiliary:dirichlet_extension:rhs",
+        ):
+            interior_rhs = -boundary_stiffness @ boundary_values
+        if _is_sparse_matrix(interior_stiffness):
+            phi[interior_nodes] = _solve_sparse_linear_system(
+                interior_stiffness,
+                interior_rhs,
+                record_timing=self._record_active_subfield_array_timing,
+                timing_prefix="demag_auxiliary:dirichlet_extension",
+            )
+        elif _selected_demag_linear_solver_backend(stiffness.shape[0]) == "scipy":
+            cached = self._demag_dirichlet_factorization_cache
+            if cached is None:
+                factorization = _factorize_scipy(interior_stiffness)
+                self._demag_dirichlet_factorization_cache = (
+                    interior_nodes,
+                    boundary_nodes,
+                    factorization,
+                )
+            else:
+                cached_interior, cached_boundary, factorization = cached
+                if not (
+                    np.array_equal(cached_interior, interior_nodes)
+                    and np.array_equal(cached_boundary, boundary_nodes)
+                ):
+                    raise RuntimeError("Cached demag boundary partition does not match the mesh.")
+            phi[interior_nodes] = factorization.solve(interior_rhs)
+        else:
+            phi[interior_nodes] = _solve_linear_system(
+                interior_stiffness,
+                interior_rhs,
+                record_timing=self._record_active_subfield_array_timing,
+                timing_prefix="demag_auxiliary:dirichlet_extension",
+            )
+        return phi

nmag/simulation/demag/bem/hierarchical.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+import numpy as np
+
+from ....backends import _load_rust_accelerator, _selected_lindholm_bem_backend
+from ....demag.bem_operator import HierarchicalLindholmBemOperator
+from ....resources import available_memory_bytes
+from ...support import _simulation_compatibility_binding
+
+logger = logging.getLogger(__name__)
+
+
+def build_hierarchical_lindholm_operator(
+    simulation: Any,
+    points: np.ndarray,
+    simplices: np.ndarray,
+    boundary_faces: list[tuple[int, tuple[int, int, int]]],
+) -> tuple[np.ndarray, Any, str | None]:
+    config = simulation.config
+    if _selected_lindholm_bem_backend(config) != "rust":
+        boundary_nodes, operator = simulation._build_lindholm_bem_operator(
+            points,
+            simplices,
+            boundary_faces,
+        )
+        return boundary_nodes, operator, "Rust accelerator is unavailable or disabled"
+
+    rust_accelerator = _simulation_compatibility_binding(
+        "_load_rust_accelerator",
+        _load_rust_accelerator,
+    )()
+    if not hasattr(rust_accelerator, "build_lindholm_hmatrix"):
+        raise RuntimeError(
+            "The installed nmag_accel does not provide hierarchical Lindholm BEM; "
+            "rebuild it with ./scripts/build-accelerator.sh --release."
+        )
+    boundary_nodes, local_index_by_point, face_nodes = simulation._lindholm_bem_boundary_index(
+        points,
+        boundary_faces,
+    )
+    hierarchical = config.hierarchical_bem
+    available = available_memory_bytes()
+    memory_budget = (
+        int(available * hierarchical.memory_fraction)
+        if available is not None
+        else np.iinfo(np.uintp).max
+    )
+    try:
+        rust_operator = rust_accelerator.build_lindholm_hmatrix(
+            np.ascontiguousarray(points, dtype=np.float64),
+            np.ascontiguousarray(simplices, dtype=np.int64),
+            np.ascontiguousarray(face_nodes, dtype=np.int64),
+            np.ascontiguousarray(boundary_nodes, dtype=np.int64),
+            np.ascontiguousarray(local_index_by_point, dtype=np.int64),
+            relative_tolerance=hierarchical.relative_tolerance,
+            admissibility_eta=hierarchical.admissibility_eta,
+            leaf_size=hierarchical.leaf_size,
+            max_rank=hierarchical.max_rank,
+            validation_vectors=hierarchical.validation_vectors,
+            validation_rows=hierarchical.validation_rows,
+            memory_budget_bytes=memory_budget,
+        )
+    except (MemoryError, ValueError) as exc:
+        logger.info("Hierarchical Lindholm BEM rejected; using exact matrix-free BEM: %s", exc)
+        boundary_nodes, operator = simulation._build_lindholm_bem_operator(
+            points,
+            simplices,
+            boundary_faces,
+        )
+        return boundary_nodes, operator, str(exc)
+    return boundary_nodes, HierarchicalLindholmBemOperator(rust_operator), None

nmag/simulation/demag/bem/operator.py

@@ -0,0 +1,292 @@
+from __future__ import annotations
+
+import time
+from typing import TYPE_CHECKING, Any, cast
+
+import numpy as np
+
+from ....backends import (
+    _load_rust_accelerator,
+    _selected_demag_bem_storage_backend,
+    _selected_lindholm_bem_backend,
+)
+from ....demag import (
+    _boundary_node_solid_angles,
+    _build_lindholm_bem_matrix_fast,
+    _lindholm_triangle_contributions,
+    _precompute_lindholm_face_geometry,
+)
+from ....demag.bem_operator import MatrixFreeLindholmBemOperator
+from ...support import _simulation_compatibility_binding
+from .diagnostics import bem_operator_stats, log_bem_operator_selection
+from .hierarchical import build_hierarchical_lindholm_operator
+
+
+class SimulationDemagBemOperatorMixin:
+    if TYPE_CHECKING:
+        _demag_bem_cache: Any | None
+
+        def __getattr__(self, name: str) -> Any: ...
+
+    def _lindholm_bem_for_demag_mesh(
+        self,
+        points: np.ndarray,
+        simplices: np.ndarray,
+        boundary_faces: list[tuple[int, tuple[int, int, int]]],
+    ) -> tuple[np.ndarray, Any]:
+        cache_started = time.perf_counter()
+        token = self._mesh_geometry_token()
+        self._ensure_demag_geometry_cache_token(token)
+        boundary_node_count = len({node for _, face in boundary_faces for node in face})
+        config = getattr(self, "config", None)
+        storage_backend = _selected_demag_bem_storage_backend(boundary_node_count, config)
+        if self._demag_bem_cache is not None:
+            cached_backend, boundary_nodes, operator, stats = self._demag_bem_cache
+            if cached_backend == storage_backend:
+                cache_kind = "matrix" if storage_backend == "dense" else "operator"
+                self._last_bem_operator_stats = stats
+                self._record_active_subfield_array_timing(
+                    f"demag_auxiliary:bem_{cache_kind}_cache_hit",
+                    time.perf_counter() - cache_started,
+                )
+                return boundary_nodes, operator
+
+        fallback_reason: str | None = None
+        effective_backend = storage_backend
+        if storage_backend == "hierarchical":
+            boundary_nodes, bem, fallback_reason = build_hierarchical_lindholm_operator(
+                self,
+                points,
+                simplices,
+                boundary_faces,
+            )
+            if fallback_reason is not None:
+                effective_backend = "matrix-free"
+        elif storage_backend == "matrix-free":
+            boundary_nodes, bem = self._build_lindholm_bem_operator(
+                points,
+                simplices,
+                boundary_faces,
+            )
+        else:
+            boundary_nodes, bem = self._build_lindholm_bem_matrix(
+                points,
+                simplices,
+                boundary_faces,
+            )
+        elapsed = time.perf_counter() - cache_started
+        requested_backend = getattr(config, "demag_bem_storage", storage_backend)
+        stats = bem_operator_stats(
+            requested_backend=requested_backend,
+            effective_backend=effective_backend,
+            fallback_reason=fallback_reason,
+            operator=bem,
+            boundary_node_count=len(boundary_nodes),
+            boundary_faces=len(boundary_faces),
+            setup_seconds=elapsed,
+        )
+        log_bem_operator_selection(stats, storage_backend)
+        self._last_bem_operator_stats = stats
+        self._demag_boundary_faces_cache = boundary_faces
+        self._demag_bem_cache = (storage_backend, boundary_nodes, bem, stats)
+        return boundary_nodes, cast(Any, bem)
+
+    def _build_lindholm_bem_operator(
+        self,
+        points: np.ndarray,
+        simplices: np.ndarray,
+        boundary_faces: list[tuple[int, tuple[int, int, int]]],
+    ) -> tuple[np.ndarray, MatrixFreeLindholmBemOperator]:
+        boundary_nodes, local_index_by_point, face_nodes = self._lindholm_bem_boundary_index(
+            points,
+            boundary_faces,
+        )
+        (
+            face_points,
+            zeta_vectors,
+            eta_vectors,
+            edge_lengths,
+            corner_cosines,
+            denominator_factors,
+        ) = _precompute_lindholm_face_geometry(points, face_nodes)
+        rust_accelerator = None
+        if _selected_lindholm_bem_backend(getattr(self, "config", None)) == "rust":
+            rust_accelerator = _simulation_compatibility_binding(
+                "_load_rust_accelerator",
+                _load_rust_accelerator,
+            )()
+            if not hasattr(rust_accelerator, "apply_lindholm_bem_matrix_free"):
+                raise RuntimeError(
+                    "The installed nmag_accel does not provide matrix-free Lindholm BEM; "
+                    "rebuild it with ./scripts/build-accelerator.sh --release."
+                )
+        return boundary_nodes, MatrixFreeLindholmBemOperator(
+            points=np.ascontiguousarray(points, dtype=np.float64),
+            simplices=np.ascontiguousarray(simplices, dtype=np.int64),
+            boundary_faces=np.ascontiguousarray(face_nodes, dtype=np.int64),
+            face_points=np.ascontiguousarray(face_points, dtype=np.float64),
+            zeta_vectors=np.ascontiguousarray(zeta_vectors, dtype=np.float64),
+            eta_vectors=np.ascontiguousarray(eta_vectors, dtype=np.float64),
+            edge_lengths=np.ascontiguousarray(edge_lengths, dtype=np.float64),
+            corner_cosines=np.ascontiguousarray(corner_cosines, dtype=np.float64),
+            denominator_factors=np.ascontiguousarray(denominator_factors, dtype=np.float64),
+            boundary_nodes=np.ascontiguousarray(boundary_nodes, dtype=np.int64),
+            local_index_by_point=np.ascontiguousarray(local_index_by_point, dtype=np.int64),
+            solid_angles=np.ascontiguousarray(
+                _boundary_node_solid_angles(points, simplices),
+                dtype=np.float64,
+            ),
+            rust_accelerator=rust_accelerator,
+        )
+
+    def _build_lindholm_bem_matrix(
+        self,
+        points: np.ndarray,
+        simplices: np.ndarray,
+        boundary_faces: list[tuple[int, tuple[int, int, int]]],
+    ) -> tuple[np.ndarray, np.ndarray]:
+        backend = _selected_lindholm_bem_backend(getattr(self, "config", None))
+        if backend == "python":
+            return self._build_lindholm_bem_matrix_python(
+                points,
+                simplices,
+                boundary_faces,
+            )
+        if backend == "rust":
+            return self._build_lindholm_bem_matrix_rust(
+                points,
+                simplices,
+                boundary_faces,
+            )
+        return self._build_lindholm_bem_matrix_numba(
+            points,
+            simplices,
+            boundary_faces,
+        )
+
+    def _lindholm_bem_boundary_index(
+        self,
+        points: np.ndarray,
+        boundary_faces: list[tuple[int, tuple[int, int, int]]],
+    ) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+        boundary_nodes = np.asarray(
+            sorted({point_index for _, face in boundary_faces for point_index in face}),
+            dtype=np.int64,
+        )
+        local_index_by_point = np.full(len(points), -1, dtype=np.int64)
+        local_index_by_point[boundary_nodes] = np.arange(len(boundary_nodes), dtype=np.int64)
+        face_nodes = np.asarray([face for _, face in boundary_faces], dtype=np.int64)
+        return boundary_nodes, local_index_by_point, face_nodes
+
+    def _build_lindholm_bem_matrix_python(
+        self,
+        points: np.ndarray,
+        simplices: np.ndarray,
+        boundary_faces: list[tuple[int, tuple[int, int, int]]],
+    ) -> tuple[np.ndarray, np.ndarray]:
+        with self._record_active_subfield_array_timing_block(
+            "demag_auxiliary:lindholm_bem:index",
+        ):
+            boundary_nodes, local_index_by_point, _face_nodes = self._lindholm_bem_boundary_index(
+                points,
+                boundary_faces,
+            )
+
+        with self._record_active_subfield_array_timing_block(
+            "demag_auxiliary:lindholm_bem:python",
+        ):
+            bem = np.zeros((len(boundary_nodes), len(boundary_nodes)), dtype=float)
+            solid_angles = _boundary_node_solid_angles(points, simplices)
+
+            for row, observer_index in enumerate(boundary_nodes):
+                observer = points[int(observer_index)]
+                for _, face in boundary_faces:
+                    p0, p1, p2 = points[list(face)]
+                    normal = np.cross(p1 - p0, p2 - p0)
+                    normal_length = float(np.linalg.norm(normal))
+                    if normal_length == 0.0:
+                        continue
+                    contributions = _lindholm_triangle_contributions(
+                        observer,
+                        p0,
+                        p1,
+                        p2,
+                        normal / normal_length,
+                    )
+                    for point_index, contribution in zip(face, contributions):  # noqa: B905
+                        bem[row, int(local_index_by_point[int(point_index)])] += contribution
+                bem[row, row] += solid_angles[int(observer_index)] / (4.0 * np.pi) - 1.0
+        return boundary_nodes, bem
+
+    def _build_lindholm_bem_matrix_numba(
+        self,
+        points: np.ndarray,
+        simplices: np.ndarray,
+        boundary_faces: list[tuple[int, tuple[int, int, int]]],
+    ) -> tuple[np.ndarray, np.ndarray]:
+        with self._record_active_subfield_array_timing_block(
+            "demag_auxiliary:lindholm_bem:index",
+        ):
+            boundary_nodes, local_index_by_point, face_nodes = self._lindholm_bem_boundary_index(
+                points,
+                boundary_faces,
+            )
+
+        with self._record_active_subfield_array_timing_block(
+            "demag_auxiliary:lindholm_bem:numba",
+        ):
+            (
+                face_points,
+                zeta_vectors,
+                eta_vectors,
+                edge_lengths,
+                corner_cosines,
+                denominator_factors,
+            ) = _precompute_lindholm_face_geometry(np.asarray(points, dtype=np.float64), face_nodes)
+            bem = _build_lindholm_bem_matrix_fast(
+                np.asarray(points, dtype=np.float64),
+                np.asarray(simplices, dtype=np.int64),
+                face_nodes,
+                face_points,
+                zeta_vectors,
+                eta_vectors,
+                edge_lengths,
+                corner_cosines,
+                denominator_factors,
+                np.asarray(boundary_nodes, dtype=np.int64),
+                local_index_by_point,
+            )
+        return boundary_nodes, bem
+
+    def _build_lindholm_bem_matrix_rust(
+        self,
+        points: np.ndarray,
+        simplices: np.ndarray,
+        boundary_faces: list[tuple[int, tuple[int, int, int]]],
+    ) -> tuple[np.ndarray, np.ndarray]:
+        with self._record_active_subfield_array_timing_block(
+            "demag_auxiliary:lindholm_bem:index",
+        ):
+            boundary_nodes, local_index_by_point, face_nodes = self._lindholm_bem_boundary_index(
+                points,
+                boundary_faces,
+            )
+
+        with self._record_active_subfield_array_timing_block(
+            "demag_auxiliary:lindholm_bem:rust",
+        ):
+            rust_accel = _simulation_compatibility_binding(
+                "_load_rust_accelerator",
+                _load_rust_accelerator,
+            )()
+            bem = np.asarray(
+                rust_accel.build_lindholm_bem_matrix(
+                    np.asarray(points, dtype=np.float64),
+                    np.asarray(simplices, dtype=np.int64),
+                    face_nodes,
+                    np.asarray(boundary_nodes, dtype=np.int64),
+                    local_index_by_point,
+                ),
+                dtype=float,
+            )
+        return boundary_nodes, bem

nmag/simulation/demag/fem/__init__.py

@@ -0,0 +1,11 @@
+"""FEM demagnetization compatibility façade composed from focused mixins."""
+
+from .assembly import SimulationDemagFemAssemblyMixin
+from .geometry import SimulationDemagFemGeometryMixin
+
+
+class SimulationDemagFemMixin(
+    SimulationDemagFemAssemblyMixin,
+    SimulationDemagFemGeometryMixin,
+):
+    """Provide FEM assembly, geometry, and boundary-face operations."""