- the tangent scatter runs per CSR entry over a transposed contribution
map, in the serial scatter's order (same bits), on rayon;
- large fronts' trailing gemms run per column block on rayon;
- forward solve multifrontal, backward top-down, subtrees on rayon;
- total_lagrangian::internal_force: the force of internal_force_and_tangent
alone (bit-identical, tested), used by modified-Newton iterations that
reuse the factor; the tangent is evaluated only when a refresh is due.
Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>
DeviceSdf gains `tip_corner: Option<f64>` (None = the capsule, as before;
Some(r_c) = a FLAT tip through the centreline's last point, normal to the
last segment, corners rounded to r_c): the last segment becomes a ray for
the lateral distance and the strip is cut by the tip plane with the span
cut's rounded intersection. Host twin (plate.rs: closest/tip_axial/
flat_cap, polyline and plate bodies) and the device φ and velocity
(e3_geom.cu geom_phi_at / body_velocity / plate_dist; GeomSdf flat_tip +
tip_corner) expression for expression.
Knobs: flag test RTX_E3_FLAG_TIP=flat + RTX_E3_FLAG_TIP_CORNER (default
0.00125 m; the tip inset defaults to 0 with the flat tip; the host φ is
the device form's); R8-a harness RTX_E3FSI_TIP=flat + RTX_E3FSI_TIP_CORNER
(the centreline gains node A as a 36th station).
New host test embedded3_flat_tip (G2 geometry: tip plane at the last
point, r_c = half = the capsule pulled back by half to 4e-17, cut volume
and wall area vs the analytic rounded rectangle at ny 62/124/248).
Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>
rtx_fea::solvers::SparseLdlt: nested-dissection ordering, etree,
fundamental supernodes, multifrontal numeric factorisation (blocked
LDLt, matrixmultiply gemm, rayon over subtrees, bit-deterministic at
any thread count), symbolic analysis reused while the pattern holds.
NonlinearDynamicStepper: TangentSolver::{BandedLu (default, unchanged
float for float), SparseLdlt { reuse }} via with_tangent_solver or
RTX_FEA_TANGENT=sparse[:K]; fixed-pattern CSR assembled from parallel
element evaluations (forces summed in the banded path's order);
optional modified Newton (factor reuse). The per-element kernel is
factored out of assemble() unchanged.
Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>
- tests/fsi2_embedded3_impulse.rs (new, ignored, cuda): the added-mass timing instrument — the R8-a fluid
with a prescribed centreline velocity step (a one-step acceleration delta), baseline and impulse passes
from one device snapshot, the load difference per step. Pitch shape on the slab ny 62: generalized added
mass 39.11 / 39.09 / 39.07 kg/m at dt x 1 / 0.75 / 0.5, the step after carries 1.7 / 1.3 / 0.9 % above
the steady tail — the cut-cell fluid answers in the same step (the lagged-added-mass hypothesis refuted).
- fsi2_embedded3.rs: `RTX_E3FSI_LINE_CSV` (per-step centreline + mid/bottom/top y per station) showed the
growing 2dt mode is a through-thickness mode — the edge nodes move against the mid-plane nodes (~4:1):
the fluid reads the mid-plane, the loads land on the edges, so the added mass acts on that mode with the
wrong sign (a negative effective added mass; the scalar Newmark model is unstable for it at omega dt
below ~1-2 with gamma 0.7, stable at larger dt or gamma 0.9 — R8-a's observed pattern).
`RTX_E3FSI_KIN=surface` (default off, byte-identical when unset): the fluid's centreline = the mean of
the bottom and top edge nodes (the nodes the loads land on) — dt x 0.75 / 0.5 / 0.25 stable at gamma 0.7.
Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>
e3_loads.cu evaluates every summand of Mask::cut_wall_force (cells' p W,
fluid faces' implicit wall shear) and cut_wall_exchange_parts (diffusive and
convective exchange with prescribed neighbours) on the device from the
predictor set of the device mask, in the host's expression order with FMA
off; the summands are appended as records, downloaded once per pass, sorted
into the host's loop order and summed sequentially on the host, so the
totals are the host route's to the bit. Records replay into the R8-a load
sink (exact zeros dropped; sum-invariant) and into R8-c's WallLoad shape.
DeviceStep::cut_wall_loads_device / cut_wall_force_device /
check_wall_loads (the G1 instrument, RTX_E3_LOADS_CHECK=1 in the flag test).
The flag test and the R8-a harness take the device route under the knob;
default paths untouched. cut.rs: E3CutPtrs and DeviceCut::ptrs pub(super).
Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>
embedded3::composite::MacProjection: staggered velocity on the coarse grid
and the patch; fine faces own the coarse-fine interface, coarse interface
and covered faces are slaved (flux = sum of the fine fluxes); the divergence
with the fine cut apertures (+ optional wall flux), the gradient with the
Dirichlet boundary and, on the interface, the fine row's own Quadratic-ghost
terms, so D G p = b - A p exactly. Composite records the interface faces'
terms and the fine cut (matrix unchanged: the phase-1 P1 CSV reproduces
digit for digit); solve_bicgstab_with takes a prepared preconditioner.
Gates (tests/embedded3_composite_projection.rs): P1 DG identity 4e-16,
div after/before <= 7e-14 in every cell class, idempotent 3e-13; P2 MMS
orders 1.96-2.02 (L2 and Linf) at the fine/coarse interface faces and the
interior; P3 cut sphere div 3e-12, translating body unchanged 4e-14,
interface L2 orders 1.96/2.01, cut faces first order as on the uniformly
fine grid (composite = uniform fine to 1.6 % of the error); P4 3.7x less
time, 4.3x fewer unknowns than uniform fine at the bump's accuracy.
Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>
- embedded3 DeviceStep::snapshot/restore (step/device/snapshot.rs): the start-of-step
device fields + the moving body's host records; a restore rebuilds the R6 persistent
geometry/classification, the predictor tables, the hierarchy and the guess basis.
Only called by the new harness (existing paths untouched).
- exchange::set_load_sink: every contribution of the operator load route (p W, wall
shear, diffusive/convective exchange) with position/component/part; None by default,
the routes' sums unchanged (slab ny 62 CSV byte-identical to r6_1/base_slab62.csv).
- rtx-fsi feature cuda (= rtx-cfd/cuda) and tests/fsi2_embedded3.rs: the 2D rtx-fea flag
(35x2 Quad8, TL, Newmark 0.7) drives the capsule's centreline per coupled step; the
route's contributions are distributed onto the wetted nodes per unit span; Aitken
subiterations each re-run the fluid step from the snapshot.
Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>
- embedded3/plate.rs: PlateSurface (mid-surface on span stations) and the
host evaluation of DeviceSdf (phi_host / velocity_host / is_flag_host),
expression for expression e3_geom.cu; a span-uniform plate is the
polyline capsule to the bit; first-order spanwise-slope correction.
- e3_geom.cu / device/geom.rs: plate branch of geom_phi_at and
body_velocity (nst = 0 keeps the polyline path unchanged).
- cutwall.rs / exchange.rs: the load loops observed through a sink (sums
unchanged); interface.rs: Mask::cut_wall_loads (every summand of
cut_wall_force with its foot), HexPlate (R8-b's Hex20 lattice numbering),
consistent point-force transfer conserving force and moment to round-off,
locate() for the transpose, mid_surface() for the fluid body.
- flag test: RTX_E3_FLAG_BODY=plate, _STATIONS, _TWIST, _TRANSFER(_EVERY,
_CSV, _NODAL); all default off.
Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>
New code only: Flag3d builds the Turek-Hron flag as a structured Hex20
plate (x-major serendipity lattice), the root clamp with free or
plane-strain (u_z = 0) lateral faces, the TL-SVK Newmark analysis with the
2-D harness's settings (beta = (gamma + 1/2)^2/4, 60 Newton), the wetted
Quad8 faces with outward orientation, and consistent nodal forces of a
traction field on the current faces. The dynamic stepper and the TL path
were already dimension-generic; nothing existing changes.
Gates (tests/flag3d_structure.rs): mass = rho V, face-force totals;
plane-strain 3-D reproduces the 2-D 35x2 Quad8 CSM1 to rounding and the
first 60 CSM3 steps to 9e-16 m. Instruments (#[ignore]): CSM1 table,
CSM3 march, modal K/M dump.
Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>
- tests/fsi2_b4_added_mass.rs: #[ignore] instrument fsi2_b4_prescribed_mode. The flag's wetted
surface moves as q(t) phi (phi from B4_MODE, M-orthonormal in-vacuo b4), q = q0 r(t) sin(w t);
per step the CSV records q, qd, qdd and the generalised fluid force sum_k f_k . phi_k from the
march's own nodal load (sample_load); optional per-node load CSV. B4_DT overrides the fluid step.
- fsi2_harness/overset.rs: RTX_FSI2O_STILL=1 turns the inflow off (still fluid) while keeping
u_mean for the CFL step and the solvers' reference flux. Unset = unchanged; gate: a short
prescribed replay (fsi2_overset_prescribed_motion, ny 62, 185 steps) byte-identical to main.
Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>
Both held their two-period 3D ny 62 gate on da2945f (default span, CSV
identical to round 3's two-period CSV; with the check: 1176 poisson and 118
hierarchy checks identical, 0 differ).
Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>
DeviceCg::new_device: level 0 by refresh_device, level 1's operator
coarsened on the device (Level::coarsen per coarse cell, children in
ascending index order) and brought down, levels 1.. by Hierarchy's loop
(Hierarchy::chain_below, export_levels), level 0's children lists on the
device. Falls back to DeviceCg::new when the hierarchy would stop at level 0.
RTX_E3_BAND_CHECK=1: every level against export_hierarchy, the fine
structures as refresh_device's check, the raw components' singular flag.
DeviceCg::new gains profile laps; DeviceVcycle::new split into upload_level +
from_levels, export_hierarchy into export_levels (same code).
Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>
The download waits until the step's rebuild route is known; with the device
mask and device imposition the host rebuild reads and writes only the
pressure (the fresh cells' refill), so u, v, w and the old velocities stay on
the device (their upload wrote back the values just downloaded). Not under
RTX_E3_BAND_CHECK (its references read the whole mirror).
Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>
The operator (poisson_operator + merge_small_cells), Level::new's activity,
masked couplings, z links and cell/colour lists, the link CSR, the
components' count and singular count (lock-free union-find), and the f32
fine export with its parent map, built on the device from DeviceCut's
projection tables into the CG's and V-cycle's persistent buffers
(e3_pset.cu, poisson/device_cg/setup.rs). RTX_E3_BAND_CHECK=1 compares every
structure against the host build bit for bit. Fallback to the host setup
(logged once) with gradient weights or a periodic z of <= 2 planes.
Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>
fsi2_flag_modes_dump writes the march's structure operators (TL SVK tangent
at u = 0, plane strain; consistent mass; root-clamped free DoFs) per mesh
for an outside eigen-solve; fsi2_flag_free_vibration releases the march's
NonlinearDynamicStepper from a mode shape at a given Newmark gamma and
records the probe's uy(t). Nothing in the march changes.
Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>
e3_geom_ub / e3_geom_impose / e3_geom_seam: the flag body's surface velocity
(DeviceSdf::vel, the centreline's velocity per point) at the foot from the
trilinear interpolant of the device corner phi, and at the face centre for the
band's solid faces of the uploaded field (a cut mask has no ghosts); the host
mirror of ub by a packed download. RTX_E3_BAND_CHECK=1 compares the device ub
with Mask::surface_velocity_at and the imposed u, v, w with impose_from, bit for
bit; check_against now compares ub on every band face (zeros included).
Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>
Each wetted node's (dx, dy, fx, fy) grouped bottom / tip / top (sidecar
<path>.nodes.csv: group, node, reference x, y, arc length) plus the
centreline uy at s = 1/4 (mean of the two straddling nodes) and 1/2.
Default off; gate on the R4-l line slice 6.0 -> 6.2 s (CPU V-cycle,
floor 7.5e-8, rtol 1e-3): main vs branch knob-off vs knob-on march CSV
and step CSV byte-identical (md5 70dcf484..., dd535386...); the node
sums equal the step CSV's fx_nodal / fy_nodal.
Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>
- e3_mask.cu: the changed set (touched by either build, dilated), the faces of
the changed cells, per changed cell the fluid flag / space-time activity /
GCL entry and the merging master, per face the kind, the step aperture and
open flag and the open-part centroid shift (compute_face_shifts' cv
geometry), the GCL table's wall cells / areas / table with the correction,
the merged cells' CSR (slave ranks from the master's distinct face
neighbours), the imposition band's faces; block scans for ascending stream
compaction and the CSR's exclusive scan. fp64, FMA contraction off.
- step/device/mask.rs DeviceMask: snapshots the previous apertures / volumes /
evaluated cells before the R6-1 geometry kernels, runs the classification
into DeviceCut's persistent tables (a, open, open_pred, active,
active_pred, owner, shift, wall_flux, fold_ptr/fold_idx) and returns the
compact values (MaskUpdate); the GCL sums in ascending order on the host.
DeviceCut::update_after_device_mask: only the band's surface velocities
remain (band list compacted on the device).
- maskupdate.rs: Mask::from_update — the host mirror from the old mask's step
arrays and merging map (moved) and the mask retired a step earlier
(instantaneous arrays, pooled), the compact values scattered; incremental
fluid count / anchor / side check; the fresh-cell refill over the changed set.
- RTX_E3_BAND_CHECK=1 with the knob: the host rebuild on copies (from_cut,
face shifts, step apertures, merging, GCL, refill) against the mirror, bit
for bit, and every device table against a full build.
- Knob off: the host path unchanged (Mask::from_parts, Solver::configure_mask
and retire_mask are the same statements); profile laps under
RTX_E3_MOVING_PROFILE only.
Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>
- e3_geom.cu: corner φ on the narrow band (the flag test's circle + capsule
around the step's centreline polyline + span cuts + fillet union), face
apertures / face-centre φ by the Kuhn triangles, cell volumes by the six
Kuhn tets and wall vectors by closure — CutGeometry::build_from in fp64,
host operation order, FMA contraction off.
- Body::with_device_sdf / DeviceSdf: the device form of φ (the host passes the
polyline per step); the flag wake test attaches it (same arithmetic as its
closure; the polylines factored out unchanged).
- step/device/geom.rs DeviceGeom: persistent φ / bound / volume / wall buffers;
the face tables written straight into DeviceCut's predictor apertures and
distances (update skips their scatters); the host mirror = the band's entries
gathered compactly onto recycled arrays of retired device generations
(GeomPool; band-list history) — Mask::from_cut classifies it.
- RTX_E3_BAND_CHECK=1 with the knob: mirror AND device tables against the host
build_from bit for bit on every refresh.
- Knob off: byte-identical (slab ny 62 one period CSV = main's); host suite 21/21.
Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>
