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

nmesh/mesher/relaxation/seeding/sampling.py

@@ -0,0 +1,142 @@
+"""Density-weighted random sampling helpers for relaxation seed points."""
+
+from __future__ import annotations
+
+import math
+from typing import Any
+
+import numpy as np
+
+from .._constants import DENSITY_EPSILON
+from .._types import FloatArray
+from ..geometry import FemGeometry
+from .points import _dedupe_points, _filter_relevant_points, _point_key
+
+
+def _box_volume(geometry: FemGeometry) -> float:
+    return float(np.prod(np.maximum(geometry.bbox_max - geometry.bbox_min, 0.0)))
+
+
+def _random_point_in_box(geometry: FemGeometry, rng: np.random.Generator) -> FloatArray:
+    return geometry.bbox_min + rng.random(geometry.dim) * (geometry.bbox_max - geometry.bbox_min)
+
+
+def _sampling_density(geometry: FemGeometry, point: FloatArray) -> float:
+    if geometry.classify_points(np.asarray(point, dtype=float)[np.newaxis, :])[0] < 0:
+        return 0.0
+    return geometry.density_at(point)
+
+
+def _estimate_density_max_and_average(
+    geometry: FemGeometry,
+    nr_probes: int,
+    rng: np.random.Generator,
+    *,
+    conservative_factor: float = 1.12,
+) -> tuple[float, float]:
+    """Estimate the legacy random-sampling maximum and average density."""
+
+    if nr_probes <= 0:
+        return 0.0, 0.0
+    max_seen = _sampling_density(geometry, _random_point_in_box(geometry, rng))
+    density_sum = 0.0
+    for _ in range(1, nr_probes):
+        value = _sampling_density(geometry, _random_point_in_box(geometry, rng))
+        max_seen = max(max_seen, value)
+        density_sum += value
+    return max_seen * conservative_factor, density_sum / float(nr_probes)
+
+
+def _sphere_volume(dim: int) -> float:
+    return (math.pi ** (0.5 * dim)) / math.gamma(1.0 + 0.5 * dim)
+
+
+def _sphere_packing_ratio_lattice_type_d(dim: int) -> float:
+    if dim <= 1:
+        return 1.0
+    lattice_vectors = np.zeros((dim, dim), dtype=float)
+    for row in range(dim):
+        if row == dim - 1:
+            lattice_vectors[row, max(dim - 2, 0) :] = 1.0
+        else:
+            lattice_vectors[row, row] = 1.0
+            lattice_vectors[row, row + 1] = -1.0
+    lattice_cell_volume = abs(float(np.linalg.det(lattice_vectors)))
+    if lattice_cell_volume <= DENSITY_EPSILON:
+        return 1.0
+    return ((0.5 * math.sqrt(2.0)) ** dim) * _sphere_volume(dim) / lattice_cell_volume
+
+
+def _estimate_initial_point_count(
+    geometry: FemGeometry, a0: float, fixed_points: FloatArray, average_density: float
+) -> int:
+    _ = fixed_points
+    node_volume = (
+        _sphere_volume(geometry.dim)
+        * ((a0 * 0.5 * 0.7) ** geometry.dim)
+        / max(_sphere_packing_ratio_lattice_type_d(geometry.dim), DENSITY_EPSILON)
+    )
+    estimated_nodes = average_density * _box_volume(geometry) / max(node_volume, DENSITY_EPSILON)
+    return min(10_000, max(geometry.dim + 1 + 5, int(estimated_nodes)))
+
+
+def _distribute_points_randomly(
+    geometry: FemGeometry, nr_points: int, max_density: float, rng: np.random.Generator
+) -> FloatArray:
+    if nr_points <= 0 or max_density <= DENSITY_EPSILON:
+        return np.empty((0, geometry.dim), dtype=float)
+    _ = _random_point_in_box(geometry, rng)
+    result = np.empty((nr_points, geometry.dim), dtype=float)
+    accepted = 0
+    while accepted < nr_points:
+        point = _random_point_in_box(geometry, rng)
+        if rng.random() * max_density <= _sampling_density(geometry, point):
+            result[accepted] = point
+            accepted += 1
+    return result
+
+
+def _select_generated_points(
+    geometry: FemGeometry,
+    a0: float,
+    fixed_points: FloatArray,
+    mobile_points: FloatArray,
+    simply_points: FloatArray,
+    rng: np.random.Generator,
+    params: dict[str, Any],
+) -> FloatArray:
+    """Generate density-weighted random seed points like the legacy mesher."""
+
+    max_density, average_density = _estimate_density_max_and_average(
+        geometry, int(params.get("nr_probes_for_determining_volume", 100_000)), rng
+    )
+    candidates = _distribute_points_randomly(
+        geometry,
+        _estimate_initial_point_count(geometry, a0, fixed_points, average_density),
+        max_density,
+        rng,
+    )
+    candidate_keys = {_point_key(point) for point in fixed_points}
+    candidate_keys.update(_point_key(point) for point in mobile_points)
+    candidate_keys.update(_point_key(point) for point in simply_points)
+    selected: list[FloatArray] = []
+    for point in candidates:
+        key = _point_key(point)
+        if (
+            key not in candidate_keys
+            and geometry.classify_points(np.asarray(point, dtype=float)[np.newaxis, :])[0] >= 0
+        ):
+            selected.append(point)
+            candidate_keys.add(key)
+    return (
+        np.asarray(selected, dtype=float) if selected else np.empty((0, geometry.dim), dtype=float)
+    )
+
+
+def _collect_hint_points(geometry: FemGeometry) -> FloatArray:
+    """Merge, deduplicate, and filter hint points from all geometry pieces."""
+
+    hint_points = [points for points in geometry.piece_hints if len(points) > 0]
+    if not hint_points:
+        return np.empty((0, geometry.dim), dtype=float)
+    return _filter_relevant_points(geometry, _dedupe_points(np.vstack(hint_points)))

nmesh/mesher/relaxation/topology/__init__.py

@@ -0,0 +1,297 @@
+"""Topology extraction and RawMesh assembly helpers."""
+
+from __future__ import annotations
+
+import math
+from itertools import combinations
+from typing import Any
+
+import numpy as np
+from scipy.spatial import Delaunay, QhullError
+
+from ....backend import RawMesh
+from ....utils.types import IntArray
+from ...periodic import build_periodic_groups
+from .._constants import BOUNDARY_FUZZ, STATE_BOUNDARY, STATE_MOBILE
+from .._types import FloatArray
+from ..geometry import FemGeometry
+
+
+def _simplex_measures(points: FloatArray, simplices: np.ndarray, dim: int) -> FloatArray:
+    """Compute 1D lengths or higher-dimensional simplex volumes."""
+
+    if len(simplices) == 0:
+        return np.empty(0, dtype=float)
+
+    if dim == 1:
+        return np.abs(points[simplices[:, 1], 0] - points[simplices[:, 0], 0])
+
+    matrices = points[simplices[:, 1:]] - points[simplices[:, [0]]]
+    determinants = np.linalg.det(matrices)
+    return np.abs(determinants) / math.factorial(dim)
+
+
+def _surface_faces(simplices: np.ndarray, regions: np.ndarray, dim: int) -> list[list[int]]:
+    """Extract boundary faces by counting face ownership across simplices."""
+
+    if len(simplices) == 0:
+        return []
+
+    face_map: dict[tuple[int, ...], set[int]] = {}
+    face_size = dim
+    for simplex, region in zip(simplices, regions, strict=True):
+        for face in combinations(simplex.tolist(), face_size):
+            key = tuple(sorted(face))
+            face_map.setdefault(key, set()).add(int(region))
+
+    counts: dict[tuple[int, ...], int] = {}
+    for simplex in simplices:
+        for face in combinations(simplex.tolist(), face_size):
+            key = tuple(sorted(face))
+            counts[key] = counts.get(key, 0) + 1
+
+    surfaces: list[list[int]] = []
+    for face, count in counts.items():
+        if count == 1 or len(face_map.get(face, set())) > 1:
+            surfaces.append(list(face))
+    return surfaces
+
+
+def _unique_links(simplices: np.ndarray) -> list[tuple[int, int]]:
+    """Return the sorted unique undirected edges induced by the simplices."""
+
+    links: set[tuple[int, int]] = set()
+    for simplex in simplices:
+        for edge_start, edge_end in combinations(simplex.tolist(), 2):
+            start = int(edge_start)
+            end = int(edge_end)
+            if start <= end:
+                links.add((start, end))
+            else:
+                links.add((end, start))
+    return sorted(links)
+
+
+def _point_regions(point_count: int, simplices: np.ndarray, regions: np.ndarray) -> list[list[int]]:
+    """Build the region-membership list for each mesh point."""
+
+    memberships: list[set[int]] = [set() for _ in range(point_count)]
+    for simplex, region in zip(simplices, regions, strict=True):
+        for point_index in simplex:
+            memberships[int(point_index)].add(int(region))
+    return [sorted(group) for group in memberships]
+
+
+def _region_volumes(region_ids: np.ndarray, measures: FloatArray) -> list[float]:
+    """Aggregate simplex measures into per-region total volumes."""
+
+    if len(region_ids) == 0:
+        return []
+
+    order = sorted({int(region) for region in region_ids})
+    totals = {region: 0.0 for region in order}
+    for region, measure in zip(region_ids, measures, strict=True):
+        totals[int(region)] += float(measure)
+    return [totals[region] for region in order]
+
+
+def _regular_boundary_ratio(dim: int) -> float:
+    """Return the normalized volume-order ratio of an ideal regular simplex."""
+
+    if dim <= 0:
+        return 1.0
+    return ((dim + 1) ** ((dim + 1) / 2.0)) / (math.factorial(dim) * (dim ** (dim / 2.0)))
+
+
+def _simplex_volume_order_ratio(points: FloatArray, simplices: np.ndarray, dim: int) -> FloatArray:
+    """Return simplex volume divided by the local length scale raised to ``dim``."""
+
+    if len(simplices) == 0:
+        return np.empty(0, dtype=float)
+
+    centroids = np.mean(points[simplices], axis=1)
+    offsets = points[simplices] - centroids[:, None, :]
+    max_radius = np.max(np.linalg.norm(offsets, axis=2), axis=1)
+    measures = _simplex_measures(points, simplices, dim)
+    order_scale = np.maximum(max_radius, BOUNDARY_FUZZ) ** dim
+    return measures / order_scale
+
+
+def _classify_simplices_with_probes(
+    points: FloatArray,
+    simplices: np.ndarray,
+    geometry: FemGeometry,
+) -> tuple[np.ndarray, np.ndarray]:
+    """Classify simplices using centroid and near-vertex probe points."""
+
+    if len(simplices) == 0:
+        return np.empty(0, dtype=int), np.empty(0, dtype=bool)
+
+    centroids = np.mean(points[simplices], axis=1)
+    region_ids = geometry.classify_points(centroids)
+    offsets = points[simplices] - centroids[:, None, :]
+    probes = (centroids[:, None, :] + 0.9 * offsets).reshape(-1, geometry.dim)
+    flat_probe_regions = geometry.classify_points(probes)
+    probe_regions = np.asarray(
+        [
+            flat_probe_regions[index : index + geometry.dim + 1]
+            for index in range(0, len(flat_probe_regions), geometry.dim + 1)
+        ],
+        dtype=int,
+    )
+    single_region = (not geometry.mesh_exterior) and (len(set(geometry.region_ids)) <= 1)
+    if single_region:
+        consistent = (region_ids >= 0) & np.all(probe_regions == region_ids[:, None], axis=1)
+    else:
+        consistent = (region_ids >= 0) & np.all(probe_regions >= 0, axis=1)
+    return region_ids, consistent
+
+
+def _triangulate_points(
+    points: FloatArray, dim: int, states: np.ndarray | None = None
+) -> np.ndarray:
+    """Triangulate the point cloud, retrying with light jitter for degenerate inputs."""
+
+    if len(points) < dim + 1:
+        return np.empty((0, dim + 1), dtype=int)
+
+    if dim == 1:
+        order = np.argsort(points[:, 0], kind="mergesort")
+        return np.column_stack((order[:-1], order[1:])).astype(int)
+
+    try:
+        return Delaunay(points).simplices.astype(int, copy=False)
+    except QhullError:
+        jittered = np.array(points, copy=True)
+        movable = (
+            np.ones(len(points), dtype=bool)
+            if states is None
+            else np.isin(states, [STATE_MOBILE, STATE_BOUNDARY])
+        )
+        if np.any(movable):
+            amplitudes = np.linspace(1.0e-9, 1.0e-8, np.count_nonzero(movable))
+            offsets = np.column_stack(
+                [
+                    amplitudes * np.sin(np.arange(1, len(amplitudes) + 1) * (axis + 1))
+                    for axis in range(dim)
+                ]
+            )
+            jittered[movable] += offsets
+        try:
+            return Delaunay(jittered).simplices.astype(int, copy=False)
+        except QhullError:
+            return np.empty((0, dim + 1), dtype=int)
+
+
+def _orient_simplices_positive(points: FloatArray, simplices: np.ndarray, dim: int) -> np.ndarray:
+    """Return simplices ordered with positive legacy simplex orientation."""
+
+    if dim <= 1 or len(simplices) == 0:
+        return simplices
+
+    oriented = np.array(simplices, copy=True)
+    matrices = points[oriented[:, 1:]] - points[oriented[:, [0]]]
+    determinants = np.linalg.det(matrices)
+    negative = np.flatnonzero(determinants < 0.0)
+    if len(negative) > 0:
+        first_nodes: IntArray = np.array(oriented[negative, 0], dtype=np.int_, copy=True)
+        oriented[negative, 0] = oriented[negative, 1]
+        oriented[negative, 1] = first_nodes
+    return oriented
+
+
+def assemble_raw_mesh(
+    points: FloatArray,
+    geometry: FemGeometry,
+    periodic: list[float] | list[bool],
+    *,
+    states: np.ndarray | None = None,
+    params: dict[str, Any] | None = None,
+) -> RawMesh:
+    """Assemble a ``RawMesh`` from relaxed points and geometry classification."""
+
+    coords = np.asarray(points, dtype=float)
+    dim = geometry.dim
+    simplices = _triangulate_points(coords, dim, states)
+    simplices = _orient_simplices_positive(coords, simplices, dim)
+
+    if len(simplices) > 0:
+        region_ids, probe_consistent = _classify_simplices_with_probes(coords, simplices, geometry)
+        measures = _simplex_measures(coords, simplices, dim)
+        boundary_mask = _boundary_state_mask(
+            coords,
+            states,
+            geometry,
+        )
+        all_boundary = np.all(boundary_mask[simplices], axis=1)
+        boundary_ratio = _simplex_volume_order_ratio(coords, simplices, dim)
+        smallest_allowed_ratio = float(
+            (params or {}).get("controller_smallest_allowed_volume_ratio", 1.0)
+        )
+        flat_boundary = all_boundary & (boundary_ratio < smallest_allowed_ratio)
+        keep = probe_consistent & (measures > BOUNDARY_FUZZ) & ~flat_boundary
+        simplices = simplices[keep]
+        region_ids = region_ids[keep]
+        measures = measures[keep]
+    else:
+        region_ids = np.empty(0, dtype=int)
+        measures = np.empty(0, dtype=float)
+
+    surfaces = _surface_faces(simplices, region_ids, dim)
+    links = _unique_links(simplices)
+    point_regions = _point_regions(len(coords), simplices, region_ids)
+    region_volumes = _region_volumes(region_ids, measures)
+    periodic_groups = build_periodic_groups(
+        coords,
+        geometry.bbox_min,
+        geometry.bbox_max,
+        periodic,
+        tolerance=BOUNDARY_FUZZ,
+    )
+
+    return RawMesh(
+        points=coords.tolist(),
+        simplices=simplices.tolist(),
+        regions=region_ids.astype(int).tolist(),
+        point_regions=point_regions,
+        surfaces=surfaces,
+        links=links,
+        region_volumes=region_volumes,
+        periodic_point_indices=periodic_groups,
+        permutation=list(range(len(coords))),
+        dim=dim,
+    )
+
+
+def _boundary_state_mask(
+    coords: FloatArray,
+    states: np.ndarray | None,
+    geometry: FemGeometry,
+) -> np.ndarray:
+    """Return the point mask used for legacy flat-boundary simplex rejection."""
+
+    if states is not None and len(states) == len(coords):
+        return np.asarray(states, dtype=int) == STATE_BOUNDARY
+    return geometry.boundary_mask(
+        coords,
+        tolerance=max(BOUNDARY_FUZZ * 10.0, 1.0e-5),
+    )
+
+
+def _callback_mesh_info(raw_mesh: RawMesh) -> list[list[Any]]:
+    """Build the legacy-style callback payload expected by old consumers."""
+
+    simplices: list[list[Any]] = [
+        [simplex, (([], 0.0), ([], 0.0), region)]
+        for simplex, region in zip(raw_mesh.simplices, raw_mesh.regions, strict=True)
+    ]
+    surfaces: list[list[Any]] = [
+        [surface, (([], 0.0), ([], 0.0), 1)] for surface in raw_mesh.surfaces
+    ]
+    return [
+        ["COORDS", "Node coordinates", raw_mesh.points],
+        ["LINKS", "Mesh links", raw_mesh.links],
+        ["POINT-BODIES", "Point region memberships", raw_mesh.point_regions],
+        ["SIMPLICES", "Simplex connectivity", simplices],
+        ["SURFACES", "Surface connectivity", surfaces],
+    ]

nmesh/mesher/relaxation/topology/finalize.py

@@ -0,0 +1,78 @@
+"""Final mesh cleanup helpers for the relaxation meshing pipeline."""
+
+from __future__ import annotations
+
+import itertools
+from typing import Any
+
+import numpy as np
+
+from .._constants import BOUNDARY_FUZZ, STATE_BOUNDARY, STATE_FIXED, STATE_MOBILE, STATE_SIMPLE
+from .._types import FloatArray
+from ..geometry import FemGeometry
+from . import _triangulate_points
+
+
+def snap_final_boundary_points(
+    points: FloatArray,
+    states: np.ndarray,
+    geometry: FemGeometry,
+    a0: float,
+    params: dict[str, Any],
+) -> tuple[FloatArray, np.ndarray]:
+    """Snap final points near fixed/boundary neighbors onto implicit boundaries."""
+
+    if len(points) < geometry.dim + 1:
+        return points, states
+
+    simplices = _triangulate_points(points, geometry.dim, states)
+    if len(simplices) == 0:
+        return points, states
+
+    neighbor_map = _build_neighbor_map(len(points), simplices)
+    cleaned_points = np.array(points, copy=True)
+    cleaned_states = np.array(states, copy=True)
+    acceptable_fuzz = float(params.get("boundary_condition_acceptable_fuzz", BOUNDARY_FUZZ))
+    max_steps = int(params.get("boundary_condition_max_nr_correction_steps", 200))
+
+    for point_index, neighbors in enumerate(neighbor_map):
+        if not neighbors or not _has_boundary_like_neighbor(cleaned_states, neighbors):
+            continue
+
+        original = cleaned_points[point_index]
+        snapped = geometry.project_point_to_boundary_from_inside(
+            original,
+            acceptable_fuzz=acceptable_fuzz,
+            max_steps=max_steps,
+        )
+        if geometry.boundary_distance(snapped) > max(acceptable_fuzz, BOUNDARY_FUZZ):
+            continue
+        if geometry.classify_points(snapped[np.newaxis, :])[0] < 0:
+            continue
+        local_rod = a0 / (geometry.density_at(original) ** (1.0 / max(geometry.dim, 1)))
+        if float(np.linalg.norm(snapped - original)) < 0.2 * local_rod:
+            cleaned_points[point_index] = snapped
+            if cleaned_states[point_index] in (STATE_MOBILE, STATE_BOUNDARY):
+                cleaned_states[point_index] = STATE_BOUNDARY
+
+    return cleaned_points, cleaned_states
+
+
+def _build_neighbor_map(point_count: int, simplices: np.ndarray) -> list[list[int]]:
+    """Build undirected point adjacency from simplices."""
+
+    neighbors: list[set[int]] = [set() for _ in range(point_count)]
+    for simplex in simplices:
+        for left, right in itertools.combinations(simplex.tolist(), 2):
+            left_index = int(left)
+            right_index = int(right)
+            neighbors[left_index].add(right_index)
+            neighbors[right_index].add(left_index)
+    return [sorted(group) for group in neighbors]
+
+
+def _has_boundary_like_neighbor(states: np.ndarray, neighbors: list[int]) -> bool:
+    """Return whether any neighbor should trigger final boundary snapping."""
+
+    boundary_like_states = {STATE_FIXED, STATE_BOUNDARY, STATE_SIMPLE}
+    return any(int(states[neighbor]) in boundary_like_states for neighbor in neighbors)