R4-i + R5 design pass: RTX_FSI2O_REGEN_ONCE (one patch regeneration per coupled step; dies at step 0 — the registered test is void), the step CSV's subit/dres_y/dres_norm/fx_nodal/fy_nodal columns; the cut predictor's per-face term probe (enable_term_probe) and the curved instrument's exact side/wall viscous integrals — the static convex wall's flat residual is the viscous closure's first-order relative accuracy on O(1/h) fluxes

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

crates/specialized/rtx-fsi/tests/fsi2_harness/overset.rs

@@ -240,6 +240,15 @@ pub struct OversetFluid {
     /// The last fluid step's mass defects (patch acceptor ring, background
     /// fringe) and the patch's max divergence.
     pub last_defects: Cell<(f64, f64, f64)>,
+    /// R4-i `RTX_FSI2O_REGEN_ONCE`: one patch regeneration per coupled
+    /// step — the first pass's meshes (one per substep) are reused by every
+    /// later subiteration of the same step (the wall polygon and velocity
+    /// still follow the candidate). Active between `begin_coupled_step`
+    /// calls only; `restore` rewinds the cursor to the step's first substep.
+    pub regen_once: bool,
+    pub regen_hold: bool,
+    pub regen_cache: Vec<rtx_cfd::mesh::PatchMesh>,
+    pub regen_cursor: usize,
 }
 
 impl OversetFluid {
@@ -503,6 +512,10 @@ impl OversetFluid {
             correctors_total: Cell::new(0),
             last_d: zero_d,
             last_defects: Cell::new((0.0, 0.0, 0.0)),
+            regen_once: std::env::var("RTX_FSI2O_REGEN_ONCE").is_ok(),
+            regen_hold: false,
+            regen_cache: Vec::new(),
+            regen_cursor: 0,
             warm_base: None,
             warm_sweeps,
         })
@@ -918,6 +931,12 @@ impl OversetFluid {
             self.last_d = d.to_vec();
             return Ok(());
         }
+        if self.regen_once && self.regen_hold && self.regen_cursor < self.regen_cache.len() {
+            let mesh = self.regen_cache[self.regen_cursor].clone();
+            self.regen_cursor += 1;
+            self.last_d = d.to_vec();
+            return self.solver.set_patch_mesh(mesh);
+        }
         let mesh = match self.patch_for(d) {
             Ok(m) => m,
             Err(e) => {
@@ -925,10 +944,22 @@ impl OversetFluid {
                 return Err(e);
             }
         };
+        if self.regen_once && self.regen_hold {
+            self.regen_cache.push(mesh.clone());
+            self.regen_cursor += 1;
+        }
         self.last_d = d.to_vec();
         self.solver.set_patch_mesh(mesh)
     }
 
+    /// R4-i: a new coupled step begins — the first pass regenerates, the
+    /// later passes reuse (`RTX_FSI2O_REGEN_ONCE`; a no-op otherwise).
+    pub fn begin_coupled_step(&mut self) {
+        self.regen_hold = self.regen_once;
+        self.regen_cache.clear();
+        self.regen_cursor = 0;
+    }
+
     /// The last geometry, for the offline reproduction
     /// (`patch_cylinder_flag_deformed.rs`, `RTX_CF_EDGES_FILE`): one edge
     /// per block, `x y` per line, when `RTX_FSI2O_DUMP_DIR` is set.
@@ -1198,6 +1229,7 @@ impl OversetFluid {
         let t0 = std::time::Instant::now();
         self.solver.restore(&saved.0);
         self.field = saved.1.clone();
+        self.regen_cursor = 0;
         self.t_restore
             .set(self.t_restore.get() + t0.elapsed().as_secs_f64());
     }