embedded3 S2-2a/S2-3: moving bodies on the device (phased tables, host rebuild per step, impose kernel; gate test), the per-span cut wall route, the flag-wake driver and its geometry pre-flight

Co-Authored-By: Claude Fable 5.1 <[email protected]>

crates/specialized/rtx-cfd/tests/embedded3_flag_geometry.rs

@@ -0,0 +1,75 @@
+//! S2-3 pre-flight (host): the flag + cylinder body at ny 62 — the mask
+//! builds, its cut geometry closes, the counts and the build time (the
+//! moving body's per-step host rebuild cost) are recorded.
+use rtx_cfd::solvers::incompressible::embedded3::{Body, Boundaries, Grid, Mask, Side};
+
+const H: f64 = 0.41;
+const FLAG_X0: f64 = 0.6;
+const FLAG_LEN: f64 = 0.35;
+const FLAG_HALF: f64 = 0.01;
+const FLAG_SPAN: f64 = 0.2;
+const AMP: f64 = 0.084;
+const BETA_L: f64 = 1.875_104_069;
+
+fn mode(s: f64) -> f64 {
+    let b = BETA_L;
+    let sigma = (b.sinh() - b.sin()) / (b.cosh() + b.cos());
+    let phi = |s: f64| (b * s).cosh() - (b * s).cos() - sigma * ((b * s).sinh() - (b * s).sin());
+    phi(s) / phi(1.0)
+}
+
+fn flag_2d(x: f64, y: f64, phase: f64) -> f64 {
+    let n = 40;
+    let mut best = f64::INFINITY;
+    let point = |m: usize| {
+        let s = m as f64 / n as f64;
+        (FLAG_X0 + s * FLAG_LEN, 0.2 + AMP * mode(s) * phase)
+    };
+    for m in 0..n {
+        let (ax, ay) = point(m);
+        let (bx, by) = point(m + 1);
+        let (ex, ey) = (bx - ax, by - ay);
+        let u = (((x - ax) * ex + (y - ay) * ey) / (ex * ex + ey * ey)).clamp(0.0, 1.0);
+        let d = ((x - ax - u * ex).powi(2) + (y - ay - u * ey).powi(2)).sqrt();
+        best = best.min(d);
+    }
+    best - FLAG_HALF
+}
+
+fn flag_3d(x: f64, y: f64, z: f64, phase: f64, r: f64) -> f64 {
+    let d2 = flag_2d(x, y, phase);
+    let q1 = d2 + r;
+    let q2 = (z - 0.5 * H).abs() - 0.5 * FLAG_SPAN + r;
+    (q1.max(0.0).powi(2) + q2.max(0.0).powi(2)).sqrt() + q1.max(q2).min(0.0) - r
+}
+
+#[test]
+fn flag_body_builds_at_ny_62() {
+    let ny = 62;
+    let h = H / ny as f64;
+    let nx = (2.5 / h).round() as usize;
+    let g = Grid::cubic(nx, ny, ny, h);
+    let cyl = |x: f64, y: f64| ((x - 0.2_f64).powi(2) + (y - 0.2_f64).powi(2)).sqrt() - 0.05;
+    for phase in [0.0, 1.0] {
+        let body = Body::from_sdf(move |x, y, z, _t| cyl(x, y).min(flag_3d(x, y, z, phase, h)));
+        let b = Boundaries {
+            x1: Side::PressureOutlet,
+            ..Boundaries::default()
+        };
+        let start = std::time::Instant::now();
+        let mask = Mask::build_cut(&body, g, 0.0, b).expect("mask");
+        let build = start.elapsed().as_secs_f64();
+        let cut = mask.cut().unwrap();
+        let (area, closure) = cut.wall_area_and_closure();
+        let solid = g.cells() - mask.fluid_cells();
+        println!(
+            "  phase {phase}: {} cells, {} fluid, {solid} solid, {} merged; wall area {area:.4} m² (cylinder 0.129 + flag ~0.156), closure {:.2e}; build {build:.2} s",
+            g.cells(),
+            mask.fluid_cells(),
+            mask.merged_cells(),
+            (closure[0].powi(2) + closure[1].powi(2) + closure[2].powi(2)).sqrt()
+        );
+        assert!(solid > 1000 && mask.fluid_cells() > g.cells() / 2);
+        assert!((closure[0].powi(2) + closure[1].powi(2) + closure[2].powi(2)).sqrt() < 1e-9);
+    }
+}