simplify: joining in modelcraft-mesh::join, shared label helper, run_script returns step outputs

Weld and face-to-face check move from the mesh.block command to
modelcraft_mesh::join (bounding-box-limited weld, grid-binned hanging-node
test), for node merging and imports to reuse. mesh.block and
mesh.tet.generate share fresh_labels. The block map evaluates each edge
curve once per lattice parameter; vector helpers come from vec3; tet10 and
hex20 mid-side nodes follow ElementKind::edges. Session::run_script returns
each step's output, which the oracle reads instead of its own loop.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01NmAttHhUZTokgPeEJia8sm

crates/mesh/src/join.rs

@@ -0,0 +1,195 @@
+//! Joining new elements to the mesh already in a model: which new points coincide with existing
+//! nodes ([`weld`]), and whether the new elements then meet the mesh face to face
+//! ([`check_conforming`]). Mesh generators that add to a model (`mesh.block`) use both; node
+//! merging and orphan-mesh import will too.
+
+use std::collections::{BTreeMap, BTreeSet, HashMap};
+
+use modelcraft_model::{ElementKind, Model};
+
+use crate::vec3::{P, dot, sub};
+use crate::{Error, Result};
+
+/// A uniform grid of cells of side `size` over items with a bounding box.
+struct Grid<T> {
+    size: f64,
+    cells: HashMap<[i64; 3], Vec<T>>,
+}
+
+impl<T: Copy> Grid<T> {
+    fn new(size: f64) -> Grid<T> {
+        Grid { size, cells: HashMap::new() }
+    }
+
+    fn cell(&self, p: P) -> [i64; 3] {
+        p.map(|x| (x / self.size).floor() as i64)
+    }
+
+    /// Put `item` in every cell its box `[lo, hi]` overlaps.
+    fn insert(&mut self, lo: P, hi: P, item: T) {
+        let (a, b) = (self.cell(lo), self.cell(hi));
+        for i in a[0]..=b[0] {
+            for j in a[1]..=b[1] {
+                for k in a[2]..=b[2] {
+                    self.cells.entry([i, j, k]).or_default().push(item);
+                }
+            }
+        }
+    }
+
+    /// The items of the cell holding `p` and of the 26 around it.
+    fn near(&self, p: P) -> impl Iterator<Item = T> + '_ {
+        let c = self.cell(p);
+        (-1..=1_i64).flat_map(move |dx| {
+            (-1..=1_i64).flat_map(move |dy| {
+                (-1..=1_i64).flat_map(move |dz| {
+                    let key = [c[0].saturating_add(dx), c[1].saturating_add(dy), c[2].saturating_add(dz)];
+                    self.cells.get(&key).into_iter().flatten().copied()
+                })
+            })
+        })
+    }
+}
+
+fn bounds(points: impl Iterator<Item = P>) -> Option<(P, P)> {
+    points.fold(None, |b, p| match b {
+        None => Some((p, p)),
+        Some((lo, hi)) => Some(([0, 1, 2].map(|k| lo[k].min(p[k])), [0, 1, 2].map(|k| hi[k].max(p[k])))),
+    })
+}
+
+/// For each point, the model node within `tol` of it: the nearest, the lowest label on a tie.
+/// Two points may not weld to the same node. `tol` = 0 welds nothing.
+pub fn weld(model: &Model, points: &[P], tol: f64) -> Result<Vec<Option<u32>>> {
+    if !(tol.is_finite() && tol >= 0.0) {
+        return Err(Error::Invalid(format!("the weld distance must be finite and not negative, not {tol}")));
+    }
+    let Some((lo, hi)) = bounds(points.iter().copied()).filter(|_| tol > 0.0) else { return Ok(vec![None; points.len()]) };
+    let inside = |p: P| (0..3).all(|k| p[k] >= lo[k] - tol && p[k] <= hi[k] + tol);
+    let mut grid = Grid::new(tol);
+    for (&label, node) in model.nodes().iter().filter(|(_, n)| inside(n.xyz)) {
+        grid.insert(node.xyz, node.xyz, (label, node.xyz));
+    }
+    let mut taken: HashMap<u32, usize> = HashMap::new();
+    points
+        .iter()
+        .enumerate()
+        .map(|(i, &p)| {
+            let best = grid
+                .near(p)
+                .map(|(label, xyz)| (dot(sub(xyz, p), sub(xyz, p)), label))
+                .filter(|(d2, _)| *d2 <= tol * tol)
+                .min_by(|a, b| a.0.total_cmp(&b.0).then(a.1.cmp(&b.1)))
+                .map(|(_, label)| label);
+            if let Some(label) = best
+                && let Some(other) = taken.insert(label, i)
+            {
+                return Err(Error::Invalid(format!("points {other} and {i} both lie within {tol} of node {label}: lower the distance or refine")));
+            }
+            Ok(best)
+        })
+        .collect()
+}
+
+/// A face or edge by its sorted node labels.
+fn key(nodes: impl Iterator<Item = u32>) -> Vec<u32> {
+    let mut k: Vec<u32> = nodes.collect();
+    k.sort_unstable();
+    k
+}
+
+/// The faces (by sorted corners, with their sorted nodes) and the corner edges of elements.
+struct Skin {
+    faces: BTreeMap<Vec<u32>, Vec<u32>>,
+    edges: BTreeSet<[u32; 2]>,
+}
+
+impl Skin {
+    /// Every face and corner edge of the elements; with `boundary`, only the faces that occur
+    /// once, and the edges of those.
+    fn of<'a>(elements: impl Iterator<Item = (ElementKind, &'a [u32])>, boundary: bool) -> Skin {
+        let mut count: BTreeMap<Vec<u32>, (usize, Vec<u32>, Vec<u32>)> = BTreeMap::new();
+        let mut all_edges = BTreeSet::new();
+        for (kind, nodes) in elements {
+            let corners = kind.corner_count();
+            for local in kind.faces() {
+                let cs: Vec<u32> = local.iter().filter(|&&i| i < corners).filter_map(|&i| nodes.get(i).copied()).collect();
+                let entry = count.entry(key(cs.iter().copied())).or_insert_with(|| (0, key(local.iter().filter_map(|&i| nodes.get(i).copied())), cs));
+                entry.0 += 1;
+            }
+            if !boundary {
+                for local in kind.edges() {
+                    if let (Some(&a), Some(&b)) = (local.first().and_then(|&i| nodes.get(i)), local.get(1).and_then(|&i| nodes.get(i))) {
+                        all_edges.insert([a.min(b), a.max(b)]);
+                    }
+                }
+            }
+        }
+        let mut faces = BTreeMap::new();
+        let mut edges = all_edges;
+        for (corners, (n, nodes, cycle)) in count {
+            if boundary && n != 1 {
+                continue;
+            }
+            if boundary {
+                for (i, &a) in cycle.iter().enumerate() {
+                    let b = cycle.get((i + 1) % cycle.len()).copied().unwrap_or(a);
+                    edges.insert([a.min(b), a.max(b)]);
+                }
+            }
+            faces.insert(corners, nodes);
+        }
+        Skin { faces, edges }
+    }
+}
+
+/// Whether new elements (their nodes already in the model) meet the model's elements face to
+/// face where they share the nodes in `joined`: an element face of either side whose corners are
+/// all shared must be a face of the other side with the same nodes (no mixed linear and
+/// quadratic sides), and no node of the new boundary may lie on an edge of the old elements
+/// within `tol`, nor the other way round (no hanging nodes where divisions differ). Edges are
+/// tested as straight segments, so along a curved shared edge only the face test applies.
+pub fn check_conforming(model: &Model, new: &[(ElementKind, Vec<u32>)], joined: &BTreeSet<u32>, tol: f64) -> Result<()> {
+    if joined.is_empty() {
+        return Ok(());
+    }
+    let refuse =
+        |what: String| Err(Error::Invalid(format!("{what}: new elements must meet the mesh face to face, with the same divisions and element kind")));
+    let new_skin = Skin::of(new.iter().map(|(k, n)| (*k, n.as_slice())), true);
+    let touching = model.elements().values().filter(|e| e.nodes.iter().any(|n| joined.contains(n)));
+    let old_skin = Skin::of(touching.map(|e| (e.kind, e.nodes.as_slice())), false);
+    for (mine, theirs, what) in [(&new_skin, &old_skin, "a new face"), (&old_skin, &new_skin, "an element face")] {
+        for (corners, nodes) in &mine.faces {
+            if corners.iter().all(|n| joined.contains(n)) && theirs.faces.get(corners) != Some(nodes) {
+                return refuse(format!("{what} on nodes {corners:?} lies on shared nodes but the other side has no such face"));
+            }
+        }
+    }
+    let xyz = |label: u32| model.node(label).map(|n| n.xyz);
+    for (nodes, edges) in [(&new_skin, &old_skin), (&old_skin, &new_skin)] {
+        let segments: Vec<([u32; 2], P, P)> = edges.edges.iter().filter_map(|&[a, b]| Some(([a, b], xyz(a)?, xyz(b)?))).collect();
+        let Some(longest) = segments.iter().map(|(_, a, b)| dot(sub(*b, *a), sub(*b, *a)).sqrt()).reduce(f64::max).filter(|l| *l > 0.0) else {
+            continue;
+        };
+        let mut grid = Grid::new(longest + 2.0 * tol);
+        for (i, (_, a, b)) in segments.iter().enumerate() {
+            grid.insert([0, 1, 2].map(|k| a[k].min(b[k]) - tol), [0, 1, 2].map(|k| a[k].max(b[k]) + tol), i);
+        }
+        let candidates: BTreeSet<u32> = nodes.faces.values().flatten().copied().filter(|n| !joined.contains(n)).collect();
+        for n in candidates {
+            let Some(p) = xyz(n) else { continue };
+            for i in grid.near(p) {
+                let Some(&([a, b], xa, xb)) = segments.get(i) else { continue };
+                let (ab, ap) = (sub(xb, xa), sub(p, xa));
+                let len2 = dot(ab, ab);
+                let t = dot(ap, ab) / len2;
+                let d = sub(ap, ab.map(|x| t * x));
+                let margin = tol / len2.sqrt();
+                if t > margin && t < 1.0 - margin && dot(d, d) <= tol * tol {
+                    return refuse(format!("node {n} at {p:?} lies on the edge between nodes {a} and {b}"));
+                }
+            }
+        }
+    }
+    Ok(())
+}