visualdynamics 0.1.0a45__tar.gz → 0.1.0a46__tar.gz

{visualdynamics-0.1.0a45/src/visualdynamics.egg-info → visualdynamics-0.1.0a46}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: visualdynamics
-Version: 0.1.0a45
+Version: 0.1.0a46
 Summary: Structural Dynamics Visualization: a units-aware structural dynamics analysis toolset
 Author-email: Brandon Zwink <bzwink@gmail.com>
 License-Expression: MIT

{visualdynamics-0.1.0a45 → visualdynamics-0.1.0a46}/src/visualdynamics/__init__.py

@@ -90,7 +90,7 @@ from .units import (
 #: alpha, said in the version itself so the dialog, the About text, the
 #: installers and latest.json all say the same thing, and the first
 #: non-alpha release is offered as an upgrade (Brandon, 2026-09-11)
-__version__ = '0.1.0a45'
+__version__ = '0.1.0a46'
 
 
 def launch_gui(*paths: str, in_process: bool | None = None) -> Any:

{visualdynamics-0.1.0a45 → visualdynamics-0.1.0a46}/src/visualdynamics/core/geometry.py

@@ -341,6 +341,83 @@ def face_corners(code: int) -> int:
     return 3 if name.startswith('tri') else 4
 
 
+#: the faces of a solid cell by its node count, as corner positions in
+#: the cell's own node order: the hexahedron's six, the wedge's two
+#: triangles and three quads, the tetrahedron's four. Bottom face then
+#: top, the same way round, as UFF 2412 and Nastran number them.
+_SOLID_FACES = {
+    8: ((0, 3, 2, 1), (4, 5, 6, 7), (0, 1, 5, 4), (1, 2, 6, 5),
+        (2, 3, 7, 6), (3, 0, 4, 7)),
+    6: ((0, 2, 1), (3, 4, 5), (0, 1, 4, 3), (1, 2, 5, 4), (2, 0, 3, 5)),
+    4: ((0, 2, 1), (0, 1, 3), (1, 2, 3), (2, 0, 3)),
+}
+
+
+def solid_faces(node_count: int) -> tuple[tuple[int, ...], ...]:
+    """The faces of a solid cell of this many corners, each as
+    positions into the cell's node list; a higher-order cell draws by
+    its corners, which come first.
+
+    Parameters
+    ----------
+    node_count : int
+        How many nodes the cell names.
+
+    Returns
+    -------
+    tuple of tuple of int
+    """
+    if node_count in (8, 20, 27):
+        return _SOLID_FACES[8]
+    if node_count in (6, 15, 24):
+        return _SOLID_FACES[6]
+    if node_count in (4, 10):
+        return _SOLID_FACES[4]
+    if node_count in (5, 13):                 # a pyramid: a quad and four
+        return ((0, 3, 2, 1), (0, 1, 4), (1, 2, 4), (2, 3, 4), (3, 0, 4))
+    return ()
+
+
+#: per corner of a solid, three corners it shares an edge with: the
+#: three edges whose triple product is that corner's share of the volume,
+#: whose sign says whether the cell is still the right way out
+_CORNER_EDGES = {
+    8: ((1, 3, 4), (2, 0, 5), (3, 1, 6), (0, 2, 7),
+        (7, 5, 0), (4, 6, 1), (5, 7, 2), (6, 4, 3)),
+    6: ((1, 2, 3), (2, 0, 4), (0, 1, 5), (5, 4, 0), (3, 5, 1), (4, 3, 2)),
+    4: ((1, 2, 3),),
+    5: ((1, 3, 4), (2, 0, 4), (3, 1, 4), (0, 2, 4)),
+}
+
+
+def _turned(code: int, before: NDArray, after: NDArray) -> bool:
+    """Whether moving an element's nodes from `before` to `after` turns
+    it inside out: a solid's corner volume, or a face's normal at a
+    corner, changing sign. A line has no inside: one drawn to nothing is
+    a link across the gap the move closes — the Frame-Wing's screw ties,
+    2026-10-11 — which the merge that follows removes
+    (`merge_collapses`)."""
+    family = element_family(code)
+    if family in SOLID_FAMILIES:
+        count = {'hexes': 8, 'wedges': 6, 'tetras': 4, 'pyramids': 5}[family]
+        for corner, (a, b, c) in enumerate(_CORNER_EDGES[count]):
+            then = np.linalg.det(before[[a, b, c]] - before[corner])
+            now = np.linalg.det(after[[a, b, c]] - after[corner])
+            if then * now <= 0.0:
+                return True
+        return False
+    if family in ('quads', 'triangles'):
+        corners = face_corners(code)
+        for i in range(corners):
+            j, k = (i + 1) % corners, (i - 1) % corners
+            then = np.cross(before[j] - before[i], before[k] - before[i])
+            now = np.cross(after[j] - after[i], after[k] - after[i])
+            if float(np.dot(then, now)) <= 0.0:
+                return True
+        return False
+    return False
+
+
 class View:
     """The way a geometry opens in 3-D: where the eye is, seen from the
     model's center, and which way is up on screen.
@@ -574,6 +651,10 @@ class Geometry:
         self.mass_properties: MassProperties | None = None
         #: how it opens in 3-D (`View`); None opens on `DEFAULT_VIEW`
         self.view: View | None = None
+        #: the shapes its parts are made of before they are meshed — blocks,
+        #: cylinders and booleans of them (`core.solids`, 2026-10-11); not
+        #: elements, and read by nothing that solves or draws a mesh
+        self.solids: list = []
         # one element group, one family (2026-09-30): a source that mixes them —
         # UNV 2412 and the sdynpy layout carry no element groups at all, so every
         # element arrives in one — is split on arrival rather than
@@ -779,6 +860,10 @@ class Geometry:
         raw_origins = (origins if self.length_unit is None
                        else from_si(origins, self.length_unit, 'length'))
         self.cs_matrix[:, 3, :] = raw_origins * scale
+        # the solids' lengths follow the coordinates (their angles do not)
+        raw_scale = (1.0 if self.length_unit is None
+                     else 1.0 / si_transform(self.length_unit, 'length')[0])
+        self.solids = [s.scaled(raw_scale * scale) for s in self.solids]
         self.length_unit = length_unit
         return self
 
@@ -789,6 +874,8 @@ class Geometry:
         self.node_xyz = from_si(self.node_xyz, self.length_unit, 'length')
         self.cs_matrix[:, 3, :] = from_si(self.cs_matrix[:, 3, :],
                                           self.length_unit, 'length')
+        self.solids = [s.scaled(1.0 / si_transform(self.length_unit, 'length')[0])
+                       for s in self.solids]
         self.length_unit = None
         return self
 
@@ -1644,6 +1731,10 @@ class Geometry:
         rows = (range(len(self.elem_conn)) if groups is None
                 else np.flatnonzero(np.isin(self.elem_group,
                                             [int(g) for g in groups])))
+        return self._spacing(rows)
+
+    def _spacing(self, rows) -> float | None:
+        """`node_spacing` over these element rows."""
         by_count: dict[int, list[np.ndarray]] = {}
         for k in rows:
             conn = self.elem_conn[k]
@@ -1830,6 +1921,302 @@ class Geometry:
         return {'merged': len(mapping), 'into': len(set(mapping.values())),
                 'duplicates': duplicates, 'links': len(links)}
 
+    # ---- Align Meshes (Brandon, 2026-10-11) -----------------------------
+
+    def _parts(self, groups: Ids | None) -> list[np.ndarray]:
+        """The element rows of `groups` (every element when None) as the
+        pieces their shared nodes join them into: two parts meshed apart
+        are two pieces whichever element groups they are in, and one
+        element group holding two loose pieces is two."""
+        rows = (np.arange(len(self.elem_conn)) if groups is None
+                else np.flatnonzero(np.isin(self.elem_group,
+                                            [int(g) for g in groups])))
+        parent: dict[int, int] = {}
+
+        def root(node: int) -> int:
+            while parent.setdefault(node, node) != node:
+                parent[node] = parent[parent[node]]
+                node = parent[node]
+            return node
+
+        for k in rows:
+            nodes = [int(n) for n in self.elem_conn[k]]
+            for node in nodes[1:]:
+                parent[root(node)] = root(nodes[0])
+        pieces: dict[int, list[int]] = {}
+        for k in rows:
+            pieces.setdefault(root(int(self.elem_conn[k][0])), []).append(int(k))
+        return [np.asarray(piece) for piece in pieces.values()]
+
+    def _skin(self, rows) -> set[int]:
+        """The nodes of these element rows that lie on their outside:
+        every node of a plate, a line or a point, and of a solid the
+        nodes of the faces no second solid among them shares."""
+        faces: dict[tuple[int, ...], tuple[int, ...]] = {}
+        skin: set[int] = set()
+        for k in rows:
+            conn = [int(n) for n in self.elem_conn[k]]
+            if element_family(int(self.elem_type[k])) not in SOLID_FAMILIES:
+                skin.update(conn)
+                continue
+            for face in solid_faces(len(conn)):
+                corners = tuple(conn[i] for i in face)
+                key = tuple(sorted(corners))
+                if key in faces:
+                    del faces[key]
+                else:
+                    faces[key] = corners
+        for corners in faces.values():
+            skin.update(corners)
+        return skin
+
+    def _typical_spacing(self, rows) -> float | None:
+        """A piece's mesh size, as Align Meshes reads it: the median over
+        its elements of a brick's middle edge — its size across, for a
+        layer one brick thin — and of any other element's shortest. Not
+        the finest edge anywhere (`node_spacing`): the bricks bent onto a
+        hole's circle have edges a fraction of the mesh's, and the
+        Frame-Wing's wing, meshed at an eighth of an inch, read finer
+        than its frame at a twelfth; and not a brick's shortest edge: the
+        washers under the wing, 0.028 in thick on an eighth-inch grid,
+        read finer than the frame and the frame moved onto them
+        (2026-10-11)."""
+        shortest = []
+        by_count: dict[int, list[np.ndarray]] = {}
+        for k in rows:
+            conn = self.elem_conn[k]
+            if len(conn) > 1:
+                by_count.setdefault(len(conn), []).append(conn)
+        for count, conns in by_count.items():
+            xyz = self.node_xyz[self.node_index(np.concatenate(conns))]
+            xyz = xyz.reshape(len(conns), count, 3)
+            if count == 8:
+                # a brick's three edges from its first corner, the middle
+                edges = np.linalg.norm(xyz[:, [1, 3, 4]] - xyz[:, [0]], axis=-1)
+                shortest.extend(np.sort(edges, axis=1)[:, 1].tolist())
+                continue
+            first, second = np.triu_indices(count, 1)
+            gaps = np.linalg.norm(xyz[:, first] - xyz[:, second], axis=-1)
+            gaps[gaps <= 0.0] = np.inf
+            shortest.extend(gaps.min(axis=1).tolist())
+        shortest = [g for g in shortest if np.isfinite(g) and g > 0.0]
+        return float(np.median(shortest)) if shortest else None
+
+    def align_reach(self, groups: Ids | None = None) -> float | None:
+        """How far Align Meshes reaches unless told: half the coarsest
+        piece's mesh size (`_typical_spacing`), so no node moves further
+        than half an element of the mesh it belongs to. Parts with a gap
+        between them want more: the gap as well.
+
+        Parameters
+        ----------
+        groups : sequence of int, optional
+            The element groups, by id; every element when omitted.
+
+        Returns
+        -------
+        float or None
+            As the coordinates are held; None with no spacing to read.
+        """
+        spacings = [self._typical_spacing(rows) for rows in self._parts(groups)]
+        spacings = [s for s in spacings if s]
+        return 0.5 * max(spacings) if spacings else None
+
+    def align_moves(self, reach: float, groups: Ids | None = None,
+                    exclude: Ids | None = None) -> list[list[int]]:
+        """The moves Align Meshes would make: each [node, onto], a node of
+        a coarser piece and the node of a finer piece it would move onto,
+        so the two are one point, ready for Merge Coincident Nodes.
+
+        Two pieces meshed at different sizes cannot be made to match
+        node for node, since their counts differ, but the coarser one's
+        nodes can each be put on the finer one's nearest: none moves more
+        than half the finer spacing in-plane, plus whatever gap lies
+        between them, and each becomes a place to merge (Brandon,
+        2026-10-11, for the Frame-Wing, whose wing is meshed at an eighth
+        of an inch on a frame meshed at a twelfth). Only nodes on the
+        pieces' outsides move or are moved onto, a node moves once and
+        onto a node no other takes, a node already on another is a place
+        to merge rather than a move, and the nearest pairs are taken
+        first — so a washer's underside goes onto the frame under it, and
+        its top, whose nearest frame node is the underside's, stays.
+        Pieces of equal spacing: the later piece moves.
+
+        Parameters
+        ----------
+        reach : float
+            How far a node may move, as the coordinates are held.
+        groups : sequence of int, optional
+            The element groups whose pieces are aligned, by id; every
+            element when omitted.
+        exclude : sequence of int, optional
+            Nodes left out, by id: neither moved nor moved onto — the
+            moves a person unpicked in the app.
+
+        Returns
+        -------
+        list of [int, int]
+            In the order of the node moved.
+        """
+        from scipy.spatial import cKDTree
+
+        parts = self._parts(groups)
+        if len(parts) < 2:
+            return []
+        left_out = {int(n) for n in exclude or ()}
+        skins = [sorted(self._skin(rows) - left_out) for rows in parts]
+        spacing = [self._typical_spacing(rows) or 0.0 for rows in parts]
+        low, high = self.extent if self.num_nodes else (np.zeros(3), np.zeros(3))
+        # already one point: a place to merge, not a move
+        touching = 1e-9 * float(np.linalg.norm(high - low) or 1.0)
+        found = []
+        for a, movers in enumerate(skins):
+            for b, targets in enumerate(skins):
+                finer = spacing[b] < spacing[a] or (spacing[b] == spacing[a]
+                                                    and b < a)
+                if a == b or not finer or not movers or not targets:
+                    continue
+                tree = cKDTree(self.node_xyz[self.node_index(targets)])
+                distance, nearest = tree.query(
+                    self.node_xyz[self.node_index(movers)],
+                    distance_upper_bound=float(reach))
+                for mover, d, j in zip(movers, distance, nearest):
+                    if touching < d <= reach:
+                        found.append((float(d), mover, targets[int(j)]))
+        moves, moving, onto = [], set(), set()
+        for _d, mover, target in sorted(found):
+            if (mover in moving or mover in onto or target in onto
+                    or target in moving):
+                continue
+            moves.append([mover, target])
+            moving.add(mover)
+            onto.add(target)
+        return sorted(self._unfolded(moves))
+
+    def _unfolded(self, moves: list[list[int]]) -> list[list[int]]:
+        """The moves, nearest first, each tried against those before it
+        and left out when it turns an element inside out — the rule Mesh
+        Solids rounds a hole by. A washer's rim, rounded onto its circle,
+        has bricks one move would fold (the Frame-Wing, 2026-10-11), and
+        a refusal of the whole Align over one of forty moves left a
+        person nothing to do but unpick it by hand."""
+        if not moves:
+            return moves
+        movers = [a for a, _b in moves]
+        touching: dict[int, list[int]] = {}
+        wanted = set(movers)
+        for k, conn in enumerate(self.elem_conn):
+            for n in conn:
+                if int(n) in wanted:
+                    touching.setdefault(int(n), []).append(k)
+        rows = dict(zip(movers, self.node_index(movers)))
+        targets = dict(zip(movers, self.node_index([b for _a, b in moves])))
+        grid = self.node_xyz.copy()
+        after = self.node_xyz.copy()
+        order = sorted(moves, key=lambda m: float(np.linalg.norm(
+            grid[targets[m[0]]] - grid[rows[m[0]]])))
+        kept = []
+        for mover, target in order:
+            after[rows[mover]] = grid[targets[mover]]
+            elements = touching.get(mover, [])
+            if any(_turned(int(self.elem_type[k]),
+                           grid[self.node_index(self.elem_conn[k])],
+                           after[self.node_index(self.elem_conn[k])])
+                   for k in elements):
+                after[rows[mover]] = grid[rows[mover]]
+            else:
+                kept.append([mover, target])
+        return kept
+
+    def align_folds(self, moves) -> str | None:
+        """Why these moves would be refused, or None: the sentence
+        `align_meshes` raises when one would turn an element inside out
+        — a solid's corner volume or a plate's facing changing sign —
+        asked ahead, so a pane can say it before its button is pressed.
+
+        Parameters
+        ----------
+        moves : sequence of [int, int]
+            As `align_moves` gives them.
+
+        Returns
+        -------
+        str or None
+        """
+        if not moves:
+            return None
+        moved = {int(a): int(b) for a, b in moves}
+        after = self.node_xyz.copy()
+        rows = self.node_index(list(moved))
+        after[rows] = self.node_xyz[self.node_index(list(moved.values()))]
+        # the elements a move touches, found a node count at a time: a
+        # loop over every element took a third of a second on the
+        # Frame-Wing, on every click in the pane
+        touched = []
+        by_count: dict[int, list[int]] = {}
+        for k, conn in enumerate(self.elem_conn):
+            by_count.setdefault(len(conn), []).append(k)
+        names = np.fromiter(moved, dtype=np.int64)
+        for count, ks in by_count.items():
+            conns = np.asarray([self.elem_conn[k] for k in ks]).reshape(len(ks), count)
+            hit = np.isin(conns, names).any(axis=1)
+            touched.extend(np.asarray(ks)[hit].tolist())
+        touched.sort()
+        # their rows in one lookup: `node_index` sorts every id each call
+        flat = self.node_index(np.concatenate(
+            [self.elem_conn[k] for k in touched])) if touched else []
+        starts = np.cumsum([0] + [len(self.elem_conn[k]) for k in touched])
+        for i, k in enumerate(touched):
+            conn = self.elem_conn[k]
+            index = flat[starts[i]:starts[i + 1]]
+            if _turned(int(self.elem_type[k]), self.node_xyz[index],
+                       after[index]):
+                return (f'moving node {next(int(n) for n in conn if int(n) in moved)}'
+                        f' turns element {int(self.elem_id[k])} inside out; '
+                        'leave that move out or use a smaller reach')
+        return None
+
+    def align_meshes(self, reach: float, groups: Ids | None = None,
+                     exclude: Ids | None = None) -> dict[str, float]:
+        """Move the coarser piece's nodes onto the finer's where they
+        meet (`align_moves`), so Merge Coincident Nodes can join them:
+        parts meshed apart at sizes that do not match, made coincident at
+        their mating faces or where they overlap. Nothing is merged, and
+        no node is removed. A move that would turn an element inside out
+        is not among the moves; refused, with the element named, only
+        when the moves a person left out make one of the rest fold
+        (`align_folds`).
+
+        Parameters
+        ----------
+        reach : float
+            How far a node may move, as the coordinates are held:
+            meters once units are defined.
+        groups : sequence of int, optional
+            The element groups whose pieces are aligned, by id; every
+            element of the geometry when omitted.
+        exclude : sequence of int, optional
+            Nodes left out, by id: neither moved nor moved onto.
+
+        Returns
+        -------
+        dict
+            'moved', how many nodes moved; 'farthest', the longest move,
+            as the coordinates are held.
+        """
+        moves = self.align_moves(reach, groups, exclude)
+        if not moves:
+            return {'moved': 0, 'farthest': 0.0}
+        refusal = self.align_folds(moves)
+        if refusal is not None:
+            raise ValueError(refusal)
+        rows = self.node_index([a for a, _b in moves])
+        targets = self.node_xyz[self.node_index([b for _a, b in moves])]
+        farthest = float(np.linalg.norm(targets - self.node_xyz[rows],
+                                        axis=1).max())
+        self.node_xyz[rows] = targets
+        return {'moved': len(moves), 'farthest': farthest}
+
     def delete_coordinate_systems(self, cs_ids: Ids) -> dict[str, int]:
         """Remove coordinate systems, reassigning any node that used them.
 

{visualdynamics-0.1.0a45 → visualdynamics-0.1.0a46}/src/visualdynamics/core/mesh.py

@@ -105,7 +105,7 @@ def block(corner: ArrayLike, edge_a: ArrayLike, edge_b: ArrayLike,
     """A rectangular block meshed into eight-node bricks, in one element
     group.
 
-    `plane` one dimension up (2026-09-30, for the four-unit frame
+    `plane` one dimension up (2026-09-30, for the Frame-Wing
     example): a corner and three perpendicular edges, each divided
     evenly into the whole number of elements nearest `size`, so the
     bricks come out close to cubes. Blocks that meet over a face divide
@@ -123,16 +123,21 @@ def block(corner: ArrayLike, edge_a: ArrayLike, edge_b: ArrayLike,
     no fifth item takes `hole_name`. Holes apply in order, a later one
     over an earlier: a through hole, then an insert named to the same
     radius part way down, then a void of the insert's bore, is a
-    threaded insert in a drilled hole. The nodes on a hole's rim — the
-    ones its bricks share with the bricks beside them — are then moved
-    radially onto the circle, a node on the block's own face sliding
-    along that face to where the circle meets it, so a hole is round to
-    within the polygon its rim nodes make rather than stair-stepped
-    (a hole centered on the block's edge is a round-over and keeps its
-    steps; its corner brick cannot follow an arc): a
-    stair-stepped hole in a member six bricks wide was anywhere from
-    three to four bricks across as its center fell, and the frame's
-    modes wandered by ten percent with it (2026-09-30).
+    threaded insert in a drilled hole. Every hole runs along the same
+    edge; one along another is refused, since the bricks are a grid
+    swept along it.
+
+    A hole is round, not stair-stepped — a stair-stepped hole in a
+    member six bricks wide was anywhere from three to four bricks across
+    as its center fell, and the frame's modes wandered by ten percent
+    with it (2026-09-30). Mesh Solids' mesher does it (`solids._mesh_grid`,
+    one rule for both, 2026-10-11): about a hole with room the grid is
+    replaced by a ring mesh, the circle's nodes on it and evenly spaced,
+    a core where an insert fills it; a hole without room has the grid's
+    nodes on its rim pulled onto the circle, sliding along the block's
+    face where it breaks out. A hole centered on the block's edge is a
+    round-over and keeps its steps: its corner brick cannot follow an
+    arc, and its area is within a few percent of the fillet's already.
 
     Parameters
     ----------
@@ -160,6 +165,7 @@ def block(corner: ArrayLike, edge_a: ArrayLike, edge_b: ArrayLike,
         name the holes put bricks in.
     """
     from ..units import si_transform
+    from .solids import _mesh_grid
 
     scale = 1.0 if unit is None else si_transform(unit, 'length')[0]
     corner = np.asarray(corner, dtype=float)
@@ -178,104 +184,55 @@ def block(corner: ArrayLike, edge_a: ArrayLike, edge_b: ArrayLike,
     counts = [max(1, round(length / size)) + 1 for length in lengths]
     grids = [np.linspace(0.0, length, count)
              for length, count in zip(lengths, counts)]
-    na, nb, _nc = counts
-    local = np.array([(a, b, c) for c in grids[2] for b in grids[1]
-                      for a in grids[0]])
-    xyz = corner + local @ np.array(axes)
-    node = np.arange(1, len(xyz) + 1)
-    conn, centers = [], []
-    for k in range(counts[2] - 1):
-        for j in range(nb - 1):
-            for i in range(na - 1):
-                first = k * na * nb + j * na + i
-                cell = [first, first + 1, first + na + 1, first + na]
-                conn.append(node[cell + [c + na * nb for c in cell]])
-                centers.append(local[cell].mean(axis=0)
-                               + 0.5 * (grids[2][k + 1] - grids[2][k])
-                               * np.array([0.0, 0.0, 1.0]))
-    centers = np.array(centers)
-    # 1 is the element group, 0 a brick removed, 2 and up the named element groups
-    groups = np.ones(len(conn), dtype=int)
+    along_axis = {int(hole[2]) for hole in holes}
+    if len(along_axis) > 1:
+        raise ValueError(f'{name or "a block"}: every hole must run along '
+                         'the same edge')
+    w = along_axis.pop() if along_axis else 2
+    order = [(w + 1) % 3, (w + 2) % 3, w]
+    # the holes in the block's own frame, the corner at the origin, each
+    # with the element group its bricks go to (0 for none)
     names = [name]
-    rims: list[tuple[np.ndarray, np.ndarray, float, int]] = []
-    conn_array = np.array(conn) - 1 if conn else np.empty((0, 8), int)
+    cut = []
     for hole in holes:
-        center, radius, axis = hole[0], float(hole[1]), int(hole[2])
+        center = np.asarray(hole[0], dtype=float) - corner
+        center = np.array([float(center @ unit_axis) for unit_axis in axes])
         depth = float(hole[3]) if len(hole) > 3 and hole[3] is not None else None
         target = hole[4] if len(hole) > 4 else hole_name
-        along = np.asarray(center, dtype=float) - corner
-        along = np.array([float(along @ unit_axis) for unit_axis in axes])
-        across = [d for d in range(3) if d != axis]
-        distance = np.linalg.norm(centers[:, across] - along[across], axis=1)
-        inside = distance <= radius
-        if depth is not None:
+        if target is not None and target not in names:
+            names.append(target)
+        group = 0 if target is None else names.index(target) + 1
+        if depth is None:
+            low, high = 0.0, lengths[w]
+        elif center[w] > lengths[w] / 2.0:
             # blind from the face the axis enters at: the corner's own
             # face when the center sits on it, the far face otherwise
-            far = along[axis] > lengths[axis] / 2.0
-            reach = (lengths[axis] - centers[:, axis] if far
-                     else centers[:, axis])
-            inside &= reach <= depth
-        # a hole whose axis lies inside the block gets a round rim; one
-        # centered on the block's own edge or corner is a round-over,
-        # and its rim stays stair-stepped: the corner brick a fillet
-        # keeps cannot be pulled onto the arc without folding, and its
-        # area is within a few percent of the fillet's already
-        within = all(0.0 < along[d] < lengths[d]
-                     for d in range(3) if d != axis)
-        beyond = distance > radius
-        if within and inside.any() and beyond.any():
-            # the rim: nodes the hole's bricks share with bricks beyond
-            # its radius — not with the bricks under a blind hole's
-            # floor, which lie inside the circle and must stay put
-            rim = np.intersect1d(np.unique(conn_array[inside]),
-                                 np.unique(conn_array[beyond]))
-            rims.append((rim, along, radius, axis))
-        if target is None:
-            groups[inside] = 0
+            low, high = lengths[w] - depth, lengths[w]
         else:
-            if target not in names:
-                names.append(target)
-            groups[inside] = names.index(target) + 1
-    for rim, along, radius, axis in rims:
-        across = [d for d in range(3) if d != axis]
-        for row in rim:
-            offset = local[row, across] - along[across]
-            distance = float(np.linalg.norm(offset))
-            if distance == 0.0:
-                continue
-            target = along[across] + offset * (radius / distance)
-            # a node on the block's face keeps to the face: it slides to
-            # where the circle meets it, or stays if the circle does not
-            on_face = [k for k, d in enumerate(across)
-                       if local[row, d] <= 1e-12 * lengths[d]
-                       or local[row, d] >= lengths[d] * (1 - 1e-12)]
-            if len(on_face) == 2:
-                continue
-            if on_face:
-                held, other = on_face[0], 1 - on_face[0]
-                reach = radius ** 2 - offset[held] ** 2
-                if reach < 0.0:
-                    continue
-                target = target.copy()
-                target[held] = local[row, across[held]]
-                target[other] = along[across[other]] + (
-                    np.sign(offset[other]) or 1.0) * np.sqrt(reach)
-            local[row, across] = target
-        xyz = corner + local @ np.array(axes)
-    if not (groups > 0).all():
-        keep = groups > 0
-        conn = [c for c, k in zip(conn, keep) if k]
-        groups = groups[keep]
-        used = np.unique(np.concatenate(conn)) if conn else np.array([], int)
-        renumber = {int(old): new for new, old in enumerate(used, 1)}
-        xyz = xyz[used - 1]
-        conn = [np.array([renumber[int(n)] for n in c]) for c in conn]
-        node = np.arange(1, len(xyz) + 1)
-    if not conn:
+            low, high = 0.0, depth
+        cut.append((center, float(hole[1]), low, high, group))
+    across = order[:2]
+
+    def held(points):
+        group = np.ones(len(points), dtype=int)
+        for center, radius, low, high, to in cut:
+            inside = ((np.linalg.norm(points[:, across] - center[across], axis=1)
+                       <= radius) & (points[:, w] >= low) & (points[:, w] <= high))
+            group[inside] = to
+        return group
+
+    # a hole centered on the block's edge or corner is a round-over and
+    # keeps its steps: no circle for it
+    circles = [(center, radius, low, high, True) for center, radius, low, high, _to in cut
+               if all(0.0 < center[d] < lengths[d] for d in across)]
+    local, conn, groups, _made = _mesh_grid([grids[k] for k in order], order, size,
+                                            held, circles)
+    if not len(conn):
         raise ValueError(f'{name or "a block"}: the holes leave nothing')
+    xyz = corner + local @ np.array(axes)
     present = [k for k in range(1, len(names) + 1) if (groups == k).any()]
-    return Geometry(node_id=node, node_xyz=xyz * scale, elem_conn=conn,
-                    elem_type=[115] * len(conn),
+    return Geometry(node_id=np.arange(1, len(xyz) + 1), node_xyz=xyz * scale,
+                    elem_conn=list(conn), elem_type=[115] * len(conn),
                     elem_group=[int(b) for b in groups],
                     group_id=present,
                     group_name=[names[k - 1] for k in present],