embedded3: cut predictor convection carries ρ (host + e3_cut.cu; density-scaling pin); operator load route includes the wall exchange (exchange.rs); reconstructed_parts, probe aperture floor knob; dfg_split diagnostic test

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

crates/specialized/rtx-cfd/src/solvers/incompressible/embedded3/exchange.rs

@@ -0,0 +1,143 @@
+//! The wall-exchange part of the operator load route (S2-1 remedy, second
+//! form). A fluid face control volume next to a prescribed (ghost or
+//! solid) face still exchanges momentum with it: the diffusive flux
+//! `μ g A (U_b − u_f)/h` through the half-aperture face at the cell
+//! centre and the convective flux `ρ m (u_face − u_f)` on the same face.
+//! Both are forces the wall exerts on the fluid that the closure polygon's
+//! shear `μ A_w (u_f − U_b)/d_f` does not carry, so the operator route
+//! read short of the box route by exactly this exchange (a conservation
+//! gap that did not shrink with h). Summed here with the predictor's own
+//! flux formulas, the operator route closes the discrete momentum balance.
+use super::body::Body;
+use super::field::Field;
+use super::wall::{FaceKind, Mask};
+use crate::solvers::incompressible::ConvectionScheme;
+
+impl Mask {
+    /// The momentum the fluid's face control volumes exchange with the
+    /// prescribed faces beside them, as a force on the body (the negative
+    /// of the force on the fluid), over the z planes `planes` (all when
+    /// `None`). `None` without a cut geometry.
+    pub fn cut_wall_exchange_force(
+        &self,
+        body: &Body,
+        f: &Field,
+        mu: f64,
+        rho: f64,
+        t: f64,
+        planes: Option<(usize, usize)>,
+    ) -> Option<[f64; 3]> {
+        let _ = body;
+        let _ = t;
+        self.cut.as_ref()?;
+        let g = self.grid;
+        let lat = self.lattice();
+        let h = [g.dx, g.dy, g.dz];
+        let area = [g.dy * g.dz, g.dx * g.dz, g.dx * g.dy];
+        let (nx, ny, nz) = (g.nx, g.ny, g.nz);
+        let (k0, k1) = planes.unwrap_or((0, nz));
+        let w_range = if self.periodic_z { 0..nz } else { 1..nz };
+        let vals: [&[f64]; 3] = [&f.u, &f.v, &f.w];
+        let scheme = self.scheme;
+        let kind = |cc: usize, idx: usize| match cc {
+            0 => self.u_kind[idx],
+            1 => self.v_kind[idx],
+            _ => self.w_kind[idx],
+        };
+        let val = |cc: usize, q: [i64; 3]| lat.face(cc, q).map(|i| vals[cc][i]);
+        let ap = |cc: usize, q: [i64; 3]| self.aperture(cc, q);
+        let e = |d: usize| {
+            let mut v = [0i64; 3];
+            v[d] = 1;
+            v
+        };
+        let add =
+            |a: [i64; 3], b: [i64; 3], s: i64| [a[0] + s * b[0], a[1] + s * b[1], a[2] + s * b[2]];
+        let upwind = |m: f64, up: f64, dn: f64| if m >= 0.0 { up } else { dn };
+        let mut force = [0.0; 3];
+        for c in 0..3 {
+            let (ir, jr, kr) = match c {
+                0 => (1..nx, 0..ny, k0..k1),
+                1 => (0..nx, 1..ny, k0..k1),
+                _ => (0..nx, 0..ny, w_range.start.max(k0)..w_range.end.min(k1)),
+            };
+            let ec = e(c);
+            for k in kr {
+                for j in jr.clone() {
+                    for i in ir.clone() {
+                        let p = [i as i64, j as i64, k as i64];
+                        let idx = lat.face(c, p).expect("face");
+                        if kind(c, idx) != FaceKind::Fluid {
+                            continue;
+                        }
+                        let cv = self.cv_geometry(c, p);
+                        let u0 = vals[c][idx];
+                        let cell_minus = add(p, ec, -1);
+                        let cell_plus = p;
+                        for d in 0..3 {
+                            let ed = e(d);
+                            let a_d = area[d];
+                            let up1 = val(c, add(p, ed, 1));
+                            let up2 = val(c, add(p, ed, 2));
+                            let dn1 = val(c, add(p, ed, -1));
+                            let dn2 = val(c, add(p, ed, -2));
+                            let (m_plus, m_minus) = if d == c {
+                                let f_up =
+                                    ap(c, add(p, ec, 1)).unwrap_or(cv.alpha) * up1.unwrap_or(u0);
+                                let f_dn =
+                                    ap(c, add(p, ec, -1)).unwrap_or(cv.alpha) * dn1.unwrap_or(u0);
+                                let f0 = cv.alpha * u0;
+                                (0.5 * (f0 + f_up) * a_d, 0.5 * (f_dn + f0) * a_d)
+                            } else {
+                                let flux = |q: [i64; 3]| {
+                                    ap(d, q).unwrap_or(1.0) * val(d, q).unwrap_or(0.0)
+                                };
+                                (
+                                    0.5 * (flux(add(cell_minus, ed, 1))
+                                        + flux(add(cell_plus, ed, 1)))
+                                        * a_d,
+                                    0.5 * (flux(cell_minus) + flux(cell_plus)) * a_d,
+                                )
+                            };
+                            // Plus side: a prescribed neighbour face.
+                            if let Some(fp) = lat.face(c, add(p, ed, 1)) {
+                                if kind(c, fp) != FaceKind::Fluid {
+                                    let un = vals[c][fp];
+                                    let delta = if scheme == ConvectionScheme::Upwind {
+                                        0.0
+                                    } else if m_plus >= 0.0 {
+                                        scheme.face_correction(dn1, u0, un)
+                                    } else {
+                                        scheme.face_correction(up2, un, u0)
+                                    };
+                                    let u_face = upwind(m_plus, u0, un) + delta;
+                                    let on_fluid = -rho * m_plus * (u_face - u0)
+                                        + mu * cv.ap[d][1] * a_d * (un - u0) / h[d];
+                                    force[c] -= on_fluid;
+                                }
+                            }
+                            // Minus side.
+                            if let Some(fm) = lat.face(c, add(p, ed, -1)) {
+                                if kind(c, fm) != FaceKind::Fluid {
+                                    let ud = vals[c][fm];
+                                    let delta = if scheme == ConvectionScheme::Upwind {
+                                        0.0
+                                    } else if m_minus >= 0.0 {
+                                        scheme.face_correction(dn2, ud, u0)
+                                    } else {
+                                        scheme.face_correction(up1, u0, ud)
+                                    };
+                                    let u_face = upwind(m_minus, ud, u0) + delta;
+                                    let on_fluid = rho * m_minus * (u_face - u0)
+                                        + mu * cv.ap[d][0] * a_d * (ud - u0) / h[d];
+                                    force[c] -= on_fluid;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        Some(force)
+    }
+}