Crate deep_causality_cfd

Expand description

§deep_causality_cfd

Computational fluid dynamics solvers and the CfdFlow DSL for DeepCausality.

This crate consolidates the fluid-dynamics theories and the DEC-native Navier–Stokes solver behind a composable, precision-generic interface, and lifts them into the CfdFlow domain-specific language

Physics errors (PhysicsError), physics quantities (the typed DEC forms and quantity newtypes), and the pointwise governing kernels stay consolidated in deep_causality_physics; this crate imports them rather than duplicating them.

Precision is a parameter: every theory and solver is generic over a real scalar (CfdScalar). Composition is static (no dyn), built on the deep_causality_haft HKT/algebra foundation.

CPU parallelism ships on: parallel sits in the crate’s default feature set and rides the MaybeParallel bound. Build with --no-default-features --features std for the serial operator loops, which are the faster choice below roughly 256² cells (see benches/PERFORMANCE.md).

Modules§

chronometric
condensed
dec_config: Owned configuration and type-state builder for the DEC incompressible Navier–Stokes solver.
dimensionless: Dimensionless scalars: Ratio, PhaseAngle, Probability. Dimensionless scalars: quantities that carry no SI unit and are used across multiple physics domains.
dynamics
em
fluids
hypersonic: Reacting / weakly-ionized-air quantity newtypes for the hypersonic Park-2T blackout slice (Gap 2, Tier-A). These complement the existing MHD plasma quantities (PlasmaFrequency, DebyeLength) in quantities/mhd/, which are reused — not duplicated — by the hypersonic kernels.
materials
mhd
nuclear
photonics
propulsion: Propulsion quantity types for the retropulsion kernel family: the mass-flow newtype, the nozzle-branch selector, and the composite exit-state and plume-geometry results. Scalar quantities from other domains (Force, Acceleration, Pressure, Temperature, Density, Speed, Length, Mass, Area) are reused — not duplicated — by the propulsion kernels.
read_rows: Typed-row loader as a lazy IoAction: read a delimited table into Vec<T> where T: FromTableRow. The file’s header names are matched to the row type’s SCHEMA, and each row’s cells are delivered to from_cells in schema order, so the file may carry its columns in any order (and extra columns) without breaking the reader. A required column absent from the file is an error naming that column.
read_table: Typed numeric-table loader as a lazy IoAction.
relativity
si_primitives: SI base and derived scalar quantities used across multiple domains. SI base and derived scalar quantities shared across multiple physics domains. Any type that belongs to the International System of Units and is used by more than one domain kernel lives here rather than in a domain-specific file.
thermodynamics
write_rows: Typed-row writer as a lazy IoAction: write a slice of TableRow where the column schema and precision come from the row type, so column names live once on the row struct rather than being repeated at the write site.
write_table: Result-table writer as a lazy IoAction, precision-generic over any TableScalar.

Structs§

AbcdMatrix: ABCD Matrix. $2 \times 2$ Ray Transfer Matrix.
Acceleration: Linear acceleration (m/s²).
AccelerationVector: Acceleration vector (m/s²). Return type of momentum-equation RHS evaluators.
AcousticCoreInverse: Closed-form inverse of the constant-coefficient acoustic core A₀ = I − β·∂² on a periodic grid, applied to a right-hand side without any iterative solve. See the module docs for the construction.
AcousticCoreInverse2d: Closed-form inverse of the 2-D constant-coefficient acoustic core A₀ = I − β·∇² on a periodic 2^lx × 2^ly grid, via ADI dimensional splitting: A₀⁻¹ ≈ (I − β·∂ₓ²)⁻¹·(I − β·∂ᵧ²)⁻¹, each factor the 1-D closed-form inverse acting along one axis. The splitting error is the O(β²·∂ₓ²∂ᵧ²) cross term; free-stream exactness is preserved exactly (each 1-D factor maps a uniform field to itself). The per-axis stiffness is s = β/Δx², β/Δy².
AcousticCoreInverse3d: Closed-form inverse of the 3-D constant-coefficient acoustic core A₀ = I − β·∇² on a periodic 2^lx × 2^ly × 2^lz grid, via ADI dimensional splitting: A₀⁻¹ ≈ (I−β∂ₓ²)⁻¹·(I−β∂ᵧ²)⁻¹·(I−β∂_z²)⁻¹. The splitting error is the O(β²) cross terms; free-stream exactness is preserved exactly (each 1-D factor maps a uniform field to itself).
AcousticImex1d: A 1-D IMEX integrator for u_t = −a·u_x + κ·c²(x)·u_xx (fixed Δt), with the stiff acoustic/diffusion term advanced by the D10 split: constant-coefficient core implicit (closed-form inverse), variable remainder lagged.
Activity: Radioactivity (Becquerels).
AeroBlackoutStub: A stub producer for the ④ blackout-coupling contract, standing in for the real Stage-1 marcher so downstream stages (trajectory, classifier, correction) can be built and validated before it lands. Each step it publishes a constant mock aero drag [−drag, 0, 0] into the field’s aero-force channel and writes a single-cell "n_e" scalar that is ne_blackout inside the scheduled step window [start, end) and ne_ambient outside it — so a downstream BlackoutTrigger sees the denial window. Swapping this stub for the real marcher stage changes no consumer.
AeroForceCoupling: The real ④ aero-force producer (Stage 1.3): the marcher→trajectory adapter that closes the physics→navigation coupling with flow-derived data, replacing AeroBlackoutStub’s constant mock. It reads the per-cell "speed" field the marcher publishes each step, forms the peak dynamic pressure q = ½·ρ_ref·U_max², and writes the aero acceleration a = −(C_d·A/m)·q into the aero-force channel the trajectory kick reads. The electron density / blackout side of ④ is produced upstream by the reacting stages (IonizationStage writing "n_e"), so the real ④ producer stack is RecoveryTemperature → Ionization → AeroForceCoupling. A no-op if "speed" is absent.
AlfvenSpeed: Alfven Speed ($v_A$). Characteristic speed of magnetic waves in plasma. Unit: m/s. Constraint: >= 0.
Alternated: One world per case, each alternated from the baseline, plus the ensemble draw multiplicity. Produced by alternate; verbs ensemble and couple.
Ambient: The per-step ambient a marcher reads each step: kinematic viscosity, the freestream inflow speed, and an optional body force. Coupling stages and dynamic-law counterfactuals write into it between steps (e.g. ν(T) feedback or a thrust-driven freestream); the marching rate only reads it. When no coupling is present the ambient is constant and the march reproduces the construction-fixed behaviour.
AmountOfSubstance: Amount of Substance (Moles).
Area: Area (m²).
AtmosphereRow: One row of the descent atmosphere table: the freestream at one altitude.
BandDrudeWeight: Band Drude Weight ($D$).
BankSteeredLift: The 3-DOF bank-steered ④ aero producer: point-mass drag and lift, so the clamped guidance command actually steers the trajectory instead of only reshaping the carrier world.
BeamWaist: Beam Waist ($w_0$). Minimum radius of Gaussian beam. Unit: Meters. Constraint: > 0.
BerryCurvature: Berry Curvature component ($Ω_{ij}$).
BlackoutState: The blackout classification at a point: the (angular) plasma frequency and whether the link is denied (plasma frequency above the configured comms band).
BlackoutTrigger: Maps an electron density to a blackout decision: n_e → ω_p (the plasma-frequency kernel) → compare to the configured comms band → GNSS/comms-denied flag. The canonical causal-monad seam: classify returns a PropagatingEffect (matching the crate’s other PropagatingEffect wrappers). The comparison threshold is config; the plasma frequency it compares is computed from state.
BlendedMap: A continuous blend between the Cartesian-capture rectangle (λ = 0) and the body-fitted polar fan (λ = 1) over a 2^Lx × 2^Ly (ξ, η) lattice, exposing the same low-rank inverse-Jacobian metric a compressible marcher consumes through MetricProvider.
BlendedMapConfig: Geometry + blend parameters for BlendedMap: the 2^lx × 2^ly lattice, the polar fan r ∈ [r0, r0+dr], θ ∈ [theta0, theta0+dtheta], and the blend lambda ∈ [0, 1].
BlendedMapConfigBuilder: Fluent builder for a BlendedMapConfig. Every section is required; build names the first missing one, then validates the geometry — before any metric field is assembled.
Body: An immersed cut-cell body. The mesh clips the lattice against this primitive (exact clipped volumes + wetted-face apertures) and merges sliver cut cells whose fluid fraction falls below merge_floor (stabilization). Coordinates are in the mesh’s spacing units.
BodyFittedCoordinate: A body-fitted polar (annular) coordinate over a 2^Lx × 2^Ly computational lattice (ξ × η), carrying the low-rank inverse-Jacobian metric and the chain-rule gradient machinery.
BodyFittedCoordinate3d: A spherical-shell body-fitted coordinate over a 2^Lx × 2^Ly × 2^Lz lattice.
BodyForceDensity: Body force per unit volume (N/m³).
BodyForceOneForm: A body-force-per-unit-mass field as an edge 1-form on a cubical lattice. A forcing input, not a marching state: no arithmetic is provided.
BodyForceZone: A body force on the velocity edges: the edge-integral cochain g♭ (e.g. a streamwise pressure gradient G·h on the x-edges) added to the rate source. The carried tensor is the grade-1 edge cochain; the solver validates and wraps it as a BodyForceOneForm when assembling.
BranchAccumulator: A predict-only reducer for one bank-angle branch: fold each rolled-out step’s instantaneous heat flux, comms-denial flag, and dt with observe, then close with the terminal miss distance in finish. The alternate-world rollout driver (Stage 4’s run_coupled over an alternated context) feeds this; keeping the fold here makes the branch scoring a small, exhaustively-tested unit independent of the march machinery.
BranchOutcome: The outcome of one counterfactual bank-angle branch — the four scores the corridor compares across candidate bank schedules: peak heat flux, integrated thermal load, terminal miss distance, and total comms-blackout dwell.
Branched: One branch world per case at the fork, awaiting the continued march. Produced by branch; its only verb is continue_for.
BurnEnvelope: The optional powered-descent axes of a SafetyEnvelope (change plasma-retropulsion-cfd-contracts, capability powered-descent-envelope). Present only for a burn-phase world; absent (SafetyEnvelope::burn == None) for the corridor, where the gate behaves exactly as before. Carries the throttle floor/ceiling, the maximum thrust coefficient max_ct (the dynamic throttle cap — the admissible ceiling is the static ceiling min’d with the throttle at which C_T = T/(q∞·S_ref) reaches max_ct), the ignition dynamic-pressure window [q_min, q_max] (stored for M4’s ignition-corridor commit, not enforced by the gate), the propellant floor, and the maximum descent rate.
CartesianIdentity: The Cartesian identity coordinate over a 2^Lx × 2^Ly lattice with physical spacing (dx, dy).
CartesianIdentity3d: The Cartesian identity coordinate over a 2^Lx × 2^Ly × 2^Lz lattice with physical spacing (dx, dy, dz).
CaseRun: What a reduction reads for one case: the case, its config, and its report.
Cases: The typed case axis: the study’s cases, awaiting a binder or a sweep.
CauchyStress: Cauchy stress tensor (Pa). Symmetric, positive-in-tension sign convention.
CentralBody: Parameters describing a central gravitating body for weak-field GM recovery.
CfdConfigBuilder: The configuration entry point. Each method starts a dedicated, validated config builder for one solver (and, later, one parameterized coupling) or a marching-case container.
CfdFlow: The CfdFlow DSL entry point.
ChemicalPotentialGradient: Chemical Potential Gradient $\nabla μ$.
ComplexBeamParameter: Complex Beam Parameter ($q(z) = z + i z_R$). Constraint: $\text{Im}(q) > 0$.
CompressibleEuler1d: The 1-D conservative compressible Euler marcher (ideal gas + global Lax–Friedrichs flux) in QTT form.
CompressibleMarchConfig: The owned configuration container for a compressible coupled marching case. Holds only owned specs; the same config can be run repeatedly (factual + counterfactual).
CompressibleMarchConfigBuilder: A fluent builder for CompressibleMarchConfig. Started by CfdConfigBuilder::compressible_march, which takes the case name.
CompressibleMarchRun: A runnable compressible marching pipeline: the same config→run split, coupled loop, and counterfactual vocabulary as the QTT host, over the evolved-state carrier.
CompressibleMarcher2d: A 2-D compressible Euler marcher over a structured coordinate (M: MetricProvider).
CompressibleMarcher3d: A 3-D compressible Euler marcher on a periodic Cartesian lattice.
CompressibleMarcher3dFitted: A body-fitted 3-D compressible Euler marcher, generic over the curvilinear coordinate M.
Concentration: Concentration field $c(\mathbf{r})$.
Conductance: Electrical Conductance ($G$).
Conductivity: Electrical Conductivity ($\sigma$). Unit: Siemens/m (S/m). Constraint: > 0.
Configured: One case bound to a solver config, awaiting the march.
Counterfactual: The cases plus the declared baseline world. Produced by baseline; its only verb is alternate.
CoupledCampaign: The alternated campaign with its coupling stack factory attached. Produced by couple; its only verb is march_for.
CoupledField: The owned auxiliary state threaded through the coupling between steps: named scalar fields (e.g. a temperature field over cells) and the per-step Ambient a stage writes back to the solver (e.g. ν(T)).
CoupledMarch: The coupled march with its stack attached, awaiting the initial field. Opened by CompressibleMarchRun::couple.
Coupling: A fluent builder for a between-step coupling — a static cons-tuple of PhysicsStages.
CyberneticCorrect: The bounded-correction gate ([6]) as a between-step PhysicsStage. It senses the coupled state (peak "heat_flux", "g_load"), runs one CyberneticLoop::control_step against the SafetyEnvelope, and either writes the clamped bank angle into the field’s control channel or — on an unrecoverable breach — logs it and returns Err, short-circuiting the coupling (the design’s “return Entropy E, emit no unsafe action”). The desired bank is the field’s current control action (a prior guidance stage’s raw command) or 0 if none; the gate only ever bounds it.
DebyeLength: Debye Length ($\lambda_D$). Screening length in plasma. Unit: Meters (m). Constraint: > 0.
DecIncompressible: The DEC-native incompressible Navier–Stokes regime as a FluidTheory.
DecNsConfig: An owned, validated DEC NS solver configuration carrying no manifold borrow. Materialize it against a manifold and a boundary-zone set to obtain the marcher.
DecNsConfigNeedsTimeStep: Type-state: viscosity set, awaiting the time step.
DecNsConfigNeedsViscosity: Type-state: awaiting the kinematic viscosity.
DecNsConfigReady: Type-state: required knobs set; optional knobs may be tuned before build.
DecNsRate: The rate field u♭ ↦ −½[i_u(du♭) − G*_ω u] − ν Δ_dR u♭ + g♭ on a metric-bearing periodic lattice manifold. The convective term is the skew-symmetrized conv' = ½[G_ω u − G*_ω u] (the dec-ns-stability fix; see the module doc), not the raw Lamb gather i_u(du♭).
DecNsSolver: The DEC Navier–Stokes solver on a periodic lattice manifold.
DecScalarRate: Passive scalar advection–diffusion on a metric-bearing lattice manifold.
Density: Density (kg/m^3).
DescentSchedule: The descent schedule: a standard-atmosphere table evaluated at the truth vehicle’s state each step, closing the navigation→flow direction of the corridor’s two-way coupling.
Diffusivity: Magnetic Diffusivity ($\eta$). Unit: $m^2/s$. Constraint: >= 0.
Displacement: Displacement field $\mathbf{u}(\mathbf{r})$.
DissociationFraction: Dissociation fraction of a diatomic pool: the share of a species’ nuclei bound in atoms rather than the parent molecule. Constraint: finite, in $[0, 1]$.
DuctConfig: The owned configuration for a quasi-one-dimensional duct march: the case name, geometry, inlet stagnation state, back pressure, resolution, and the stop condition. Holds only owned specs; the same config can be run repeatedly. Built by DuctConfigBuilder, started by CfdConfigBuilder::duct.
DuctConfigBuilder: Fluent builder for a DuctConfig. The area profile, the inlet stagnation state, the ratio of specific heats, the back pressure, the cell count, and the stop condition are all required; build reports the first missing section and then validates the values.
DuctMarchRun: The runnable duct march composed by CfdFlow::march. Borrows the owned DuctConfig; run returns the owned Report and the borrow never escapes it.
Efficiency: Thermodynamic efficiency (0.0 to 1.0).
ElectricPotential: Electric Potential (Volts or J/C).
ElectronDensity: Electron number density $n_e$. Unit: $m^{-3}$. Constraint: finite, $\geq 0$.
ElectronTemperature: Free-electron translational temperature $T_e$. Unit: K. Constraint: finite, $\geq 0$.
Energy: Energy (Joules) — SI-derived unit. Can be negative (potential wells).
EnergyBudget: Per-term M-inner products of a state against the marched rate’s terms; see the module doc for the sign convention.
EnergyDensity: Energy Density (Joules per cubic meter).
EnsembleMarched: One report per case and draw (flat, case-major), awaiting the ensemble reduction. Produced by march_for; verbs reduce_ensemble and inspect.
Entropy: Entropy (J/K).
EosStage: A single-temperature ideal-gas pressure closure p = n·k_B·T_tr at the configured number density, written into a per-cell "pressure" scalar. Despite sitting in the two-temperature stack, the closure reads only the translational temperature T_tr; the vibrational temperature T_ve does not enter, so this is not a two-temperature pressure.
EquilibriumConstant: Concentration-basis equilibrium constant of a reversible reaction, K_eq = k_f / k_b (RP-1232 eq. 5a). Unit: model-dependent (dimensionless for two-body/two-body reactions; a concentration for dissociation). Constraint: finite, $\geq 0$.
FiniteRateIonizationStage: The finite-rate ionization network stage. Reads the translational temperature (default "T_tr"; rename with driven_by), the vibrational-electron temperature (default "T_ve", falling back to the translational value), and the heavy-particle density (per-cell via with_density_field, else the configured constant); each channel’s controlling temperature is computed internally. Carries "alpha" and the two lagged atom-pool fractions ("atom_frac_n", "atom_frac_o"); writes "n_e".
FittedNormalShock: A fitted normal shock on the stagnation streamline: the exact Rankine–Hugoniot interface (task 4.1).
FlightSensors: Publishes the two powered-descent sensor scalars the safety envelope reads but nothing else produces: freestream dynamic pressure and descent rate.
FocalLength: Focal Length ($f$). Unit: Meters. Constraint: None (can be negative for diverging lens).
Force: Force (N).
ForcingRegion: A masked forcing region over the 2-D compressible conservative state: a smoothed volume fraction mask, the target conserved state [ρ, ρu, ρv, ρE] the interior is driven toward, and the penalization strength η (time units of the solver step; η ≤ Δt enforces hard).
ForkEconomics: What a counterfactual branch’s fork actually cost, recorded by the carrier at the moment the branch was set up.
ForkStudy: The cases plus the shared fork point — a paused trajectory this study’s branches continue from. Produced by fork; its only verb is branch.
FourMomentum: Lorentz 4-momentum (E, px, py, pz) in natural units (c = 1).
Frequency: Frequency (Hz).
GateOutcome: One gate’s outcome within a verdict.
GateSeq: A named, ordered sequence of gate checks over a study’s Row type.
Hadron: A produced hadron from string fragmentation.
HalfLife: Half-Life (Seconds).
IgnitionCorridor: The four-condition ignition corridor a ThrottleGuidance commits through.
ImuModel: A strapdown-IMU model: a constant accelerometer + gyro bias and the process noise its grade implies.
IndexOfRefraction: Index of refraction for a medium (ratio of c to phase velocity in the medium). Typically > 1; negative values are physically possible in metamaterials but zero is rejected to prevent division errors in downstream calculations.
Inflow: An inflow boundary: the face perpendicular to wall_axis (the max_side face when true, the zero face otherwise) carries a prescribed wall-normal velocity speed. It contributes the face’s normal edges as the prescribed (inflow) set — held at their lifted value with their flux counted in the open-boundary projection — and the lift that sets that value. Requires a matching Outflow reference to balance the net flux.
InflowContext: Immutable march context (design D10): the zone configuration and the per-step sensor stream.
InflowMarchState: Mutable march state (design D10): the stateless solver, the current divergence-free field, the last-good inflow value, the step index, and whether the previous step was a dropout (for transition logging).
InsErrorState: The 17-element strapdown-INS error state carried through the filter.
IonizationFraction: Ionization fraction $\alpha = n_e / n_{tot}$. Unit: dimensionless. Constraint: finite, $\in [0, 1]$.
IonizationStage: Relaxes the carried ionization fraction α toward the Park-2T Saha surrogate α_eq(T_tr) with τ_ion = 1/(k_f·[M]) (the dominant associative-ionization rate, computed from state), via the closed-form LER exponential, then writes the electron density n_e = α · n_tot. Reads "T_tr" by default (see driven_by), carries "alpha", writes "n_e".
JonesVector: Jones Vector. Polarized Electric Field. Rank 1, Dim 2 Complex Tensor.
Judged: The rows plus the accumulated gate verdict, awaiting more gates or the terminal verdict.
KeyedInterpolation: The result of a value-bracketed table interpolation: the interpolated columns at the query key, the indices of the bracketing rows (equal when the query clamped to a single end row), and whether the query fell outside the tabulated range (the marker the flight side stamps into provenance).
KeyedTable: A table of numeric rows keyed by an ascending scalar, supporting value-bracketed linear interpolation with end clamping. Rows are sorted ascending by key at construction; duplicate keys and ragged column counts are rejected.
KinematicViscosity: Kinematic Viscosity (m^2/s). Equals dynamic viscosity divided by density.
LarmorRadius: Larmor Radius ($r_L$). Gyroradius of a charged particle. Unit: Meters (m). Constraint: > 0.
Length: Length (m).
LundParameters: Configuration parameters for Lund String Fragmentation.
MagneticFlux: Magnetic Flux (Webers).
MagneticPressure: Magnetic Pressure ($P_B$). Energy density of the magnetic field. Unit: Pascals (Pa). Constraint: >= 0.
ManufacturedSample: The pointwise inputs an MMS kernel residual needs at a sample point, plus the exact reference.
MarchConfig: The owned configuration container for a marching case. Holds only owned specs; the same config can be materialized and run repeatedly (factual + counterfactual). The boundary-zone tuple Z and the coupling C compose statically (each () by default).
MarchConfigBuilder: Fluent builder for a MarchConfig. The boundary-zone tuple Z (default ()) is set via MarchConfigBuilder::zones and the between-step coupling C (default ()) via MarchConfigBuilder::couple; each transitions the builder type.
MarchPipeline: The injected pipeline before a geometry is bound. .on(&manifold) lends the caller-owned geometry and yields the runnable MarchRun.
MarchRun: A geometry-bound, runnable marching pipeline. The no-arg stages resolve their sub-config from the container; the *_with_config variants override one sub-config (counterfactuals).
MarchState: A resumable coupled-march state: the CoupledField to resume from, and the step reached.
Marched: One report per case, awaiting the reduction to rows.
Mass: Mass (kg).
MassFlowRate: Propellant mass-flow rate $\dot m$. Unit: $kg \cdot s^{-1}$. Constraint: finite, $\geq 0$.
MassFraction: Species mass fraction $Y_s = \rho_s / \rho$. Unit: dimensionless. Constraint: finite, $\in [0, 1]$.
Mesh: An owned mesh specification — lattice shape, per-axis periodicity, and uniform spacing. It carries no borrow; materialize builds the manifold inside run.
MmsBuilder: Fluent builder for an MMS-verification case.
Mobility: Charge Carrier Mobility ($μ$).
MomentOfInertia: Moment of Inertia (kg·m²).
Momentum: Momentum vector $\mathbf{k}$.
MovingWall: A moving wall: the wall perpendicular to wall_axis (the max_side face when true, the zero face otherwise) carries the tangential velocity. It contributes the prescribed lift (edge integral velocity[a]·edge length) on that wall’s tangential edges; those edges are already in the wall’s auto-derived no-slip set, so the projection holds the value exactly each step.
NavFilter: A 17-state error-state Kalman filter: the error-state estimate + its covariance.
NozzleExitState: The isentropically expanded nozzle exit state: exit Mach number and the static exit quantities, as composed by nozzle_exit_state_kernel. Each component is a validated quantity; the struct only groups them.
NumericTable: A typed numeric table: columns with semantics plus rectangular numeric rows in the working scalar R. Construction validates rectangularity once, so a NumericTable in hand is always well-shaped.
NumericalAperture: Numerical Aperture ($NA = n \sin \theta$). Unit: Dimensionless. Constraint: > 0.
Observe: The set of diagnostics a march collects into its Report. Built fluently; the scalar diagnostics (kinetic_energy, divergence, max_speed) sample one value per step, while the immersed-body diagnostics (drag/lift, the wake probe for Strouhal, and the final-state centerline profile) require an immersed body / a chosen sample geometry and are opt-in by reference speed or point.
OperatorStudyBuilder: Fluent builder for an operator-accuracy study.
OpticalPower: Optical Power ($D = 1/f$). Unit: Diopters ($m^{-1}$). Constraint: None.
OrbitalAngularMomentum: Orbital Angular Momentum ($L$).
OrderParameter: Superconducting Order Parameter ($ψ$).
Outflow: An outflow boundary: the face perpendicular to wall_axis (the max_side face when true, the zero face otherwise) is the open-boundary pressure reference. Its vertices pin φ = 0 in the projection, so the outflow velocity is free and adjusts to balance the inflow flux (mass conservation). It carries no prescribed velocity: the outflow velocity is whatever the projection produces, with the face’s tangential edges left free.
Park2tClosure: Park two-temperature ionization closure — the gas-property inputs that turn the translational post-shock state into the lagging vibrational-electron controller that actually governs ionization.
PhaseAngle: Phase angle (radians) — dimensionless angle used in wave and quantum physics.
PhysicalField: Wrapper for CausalMultiVector representing a physical field (E, B, etc.). Implements Default to return a zero vector.
PhysicsError
PlasmaBeta: Plasma Beta ($\beta$). Ratio of thermal to magnetic pressure. Unit: Dimensionless. Constraint: >= 0.
PlasmaFrequency: Plasma Frequency ($\omega_{pe}$). Natural oscillation frequency. Unit: Rad/s. Constraint: > 0.
PlumeGeometry: The analytic plume-as-effective-obstruction geometry the SRP plume kernel returns: the maximum plume radius, the upstream penetration length of the plume from the nozzle exit, and the terminal-shock (Mach-disk) standoff. All lengths; shaping any discrete forcing region from them is the CFD stage’s job — kernels do not discretize space.
PlumeImprint: The opt-in plume re-imprint spec (change add-retropulsion-coupled-stages, capability plume-obstruction-stage): it lets a world’s marched forcing region follow a varying throttle.
PlumeNozzle: The nozzle + freestream description the analytic plume boundary needs (cordell_braun_plume_boundary_kernel). The chamber pressure at full throttle scales linearly with the commanded throttle, and the remaining values are the fixed nozzle and freestream constants. Supplying it to PlumeObstruction::with_plume_geometry opts a world into publishing the plume geometry each step.
PlumeObstruction: The production plume stage (change add-retropulsion-coupled-stages, capability plume-obstruction-stage) — the drag half of the M2 PropulsionStub, productionized.
PostShockState: The post-shock state from the exact Rankine–Hugoniot normal-shock jump.
Prepared: The cases plus a shared apparatus built once (a fitted shock, a calibration), awaiting a rig-sharing sweep.
Pressure: Pressure (Pascals).
PressureZeroForm: A pressure field as a vertex 0-form on a cubical lattice. Diagnostic carrier (the Leray-form solver removes pressure from the time loop); no arithmetic is provided.
Probability: Probability — a dimensionless scalar constrained to [0, 1].
PropulsionStub: An inert-safe A0 propulsion stub satisfying the powered-descent coupling contract.
QttImmersed2d: Marches the periodic 2-D incompressible Navier–Stokes equations with an immersed body enforced by Brinkman volume penalization. Wraps a QttIncompressible2d (convection + diffusion + projection) and adds the penalization forcing each step. State is the (u, v) velocity train pair.
QttIncompressible2d: Marches the periodic 2-D incompressible Navier–Stokes equations with the velocity pair (u, v) held as tensor trains. Each step forms the nonlinear convection u·∇u (via the fused Hadamard product, so the r² intermediate is never materialized) plus viscous diffusion, advances by explicit Euler, recompresses, and applies the Leray projection — so the field stays divergence-free and low-rank. Implements Marcher directly (the tensor-train stages must round between operations).
QttLinear1d: Marches the periodic linear advection–diffusion equation ∂u/∂t = −c·∂ₓu + ν·∂²ₓu on a 2^L grid in compressed tensor-train form.
QttMarchConfig: The owned configuration container for a QTT 2-D incompressible marching case. Holds only owned specs; the same config can be run repeatedly (factual + counterfactual).
QttMarchConfigBuilder: Fluent builder for a QttMarchConfig. Started by CfdConfigBuilder::qtt_march, which takes the case name. Set the grid and solver, supply a seed (a closure over the grid or pre-built fields), then build. The seed is materialized at build-supply time into owned fields, so build validates the grid is 2^Lx × 2^Ly and the seed matches it.
QttMarchRun: A geometry-free, runnable QTT marching pipeline. The overrides (seed_with / march_with / observe_with) swap one spec for a counterfactual while reusing the borrowed container.
QttObserve: The set of tensor-train-native diagnostics a QTT march collects into its Report. Built fluently; each is a one-value-per-step series. No immersed-body / probe / centerline options — those need a body the periodic QTT solver does not yet encode.
QttProjector2d: Periodic 2-D Leray projector: holds the gradient MPOs and the grid metadata, and exposes divergence, the spectral solve_poisson, and the divergence-free project.
QttStepView: A cheap, read-only view of one completed QTT step, passed to a QttMarchRun::run_with hook. Exposes the step index/time, the (u, v) velocity trains, and the tensor-train-native diagnostics computed off them.
QuantumEigenvector: Quantum Eigenvector $|u_n➢$.
QuantumMetric: Quantum Metric component ($g_{ij}$).
QuantumVelocity: Quantum Velocity vector $\partial_i H |u_n➢$.
Quaternion
Ratio: A generic dimensionless ratio (no physical unit).
RayAngle: Ray Angle ($\theta$). Angle relative to optical axis. Unit: Radians.
RayHeight: Ray Height ($y$). Distance from optical axis. Unit: Meters.
ReactionRate: Reaction rate (forward or backward rate coefficient evaluated at a rate-controlling temperature). Unit: model-dependent (e.g. $m^3 mol^{-1} s^{-1}$). Constraint: finite, $\geq 0$.
ReadyMarch: A coupled march ready to run: stack and initial field attached. Terminal stages produce a CompressiblePause (until) or an owned Report (run / run_for).
RecoveryTemperatureStage: Rebuilds T_tr each step from the flow state: T_tr = T_post − ½|u|²/c_p, with T_post from a Rankine–Hugoniot normal-shock jump on the configured flight Mach. Reads the per-cell "speed" field (the state-derived |u|) and writes "T_tr".
ReentryNavEngine: The onboard reentry trajectory + navigation engine.
ReferenceScales: The fixed dimensional anchors the nondimensional marched state is rescaled by when publishing physical projections (T_tr = T̂·t_ref, n_tot = ρ̂·n_ref, speed = |û|·u_ref). Chosen once per corridor (the peak-station post-shock values are the natural pick) and never varied, so the marched numbers stay O(1) across the whole descent.
RefineBranched: The refinement round’s branch worlds, prior rounds carried. Its only verb is continue_for.
RefineMarched: The refinement round’s continued reports, prior rounds carried. Its only verb is reduce_all, which lands on Swept with rounds populated.
Refining: After refine: the next round’s cases, the shared fork point re-attached, and the prior round’s rows carried across the (possible) case-type change. Its only verb is branch.
RegimeClass: The classifier’s decision at a step: the selected GoverningModel, the Knudsen number it was selected from, the plasma/comms state (angular plasma frequency + whether GNSS is denied), and the powered-descent flight phase (Mach band, thrust state, touchdown).
RegimeClassify: The governing-model selector ([2]/[3]). Reads the peak mean free path from a "mean_free_path" field and forms Kn = λ / L against the configured characteristic length, reads the peak electron density from "n_e" and maps it through a BlackoutTrigger to the GNSS-denial flag, then records the RegimeClass on the field, logging a provenance entry whenever the regime changes. A regime here is the full tuple (governing model, comms-denial, Mach band, thrust state, touchdown), not only the first two: a change in any component logs a transition. The last three stay neutral unless Self::with_flight_axes is attached, which is why a corridor without flight axes only ever logs model and comms-denial changes. The transition count is also published as a typed field (REGIME_TRANSITIONS_FIELD). A no-op if "mean_free_path" is absent.
RegimeSwitch: A hysteresis (Schmitt-trigger) integrator switch: it flips to IntegratorRegime::Direct when the g-load ε rises above enter_direct, and back to IntegratorRegime::PerturbedConformal only when ε falls below the lower exit_direct — the dead band prevents chatter around ε_switch.
Report: The owned result of a CfdFlow solver run: labeled observation series. The borrows that produced it (manifold, solver) never escape run; only this owned Report does (design D2). Shared by all three solver kinds (march, MMS-verify, operator-study).
RetroThrust: The production retro-thrust stage (change add-retropulsion-coupled-stages, capability retro-thrust-stage) — the thrust half of the M2 PropulsionStub, productionized.
ReynoldsStress: Reynolds stress tensor R_ij = ⟨u'_i u'_j⟩ (Pa, after multiplication by ρ in caller; here a kinematic Reynolds stress in m²/s² is also acceptable). Symmetric. Diagonal entries are non-negative (variances) — not enforced by the newtype to keep the constructor cheap; callers passing a tensor that violates the diagonal-positivity property are responsible for downstream interpretation.
RotationRateTensor: Rate-of-rotation (spin) tensor Ω = 0.5·(∇u − ∇uᵀ). Antisymmetric: Ω_ji = −Ω_ij, with Ω_ii = 0. new checks the antisymmetry invariant by exact equality.
RunOutput: The result of a multi-step run: the final state, how many steps ran, and whether the stop predicate was satisfied (always true for a completed fixed-horizon run).
SafetyEnvelope: The verified safety envelope — the cybernetic loop’s Context C. A bank-angle correction is admissible only inside it; the gate clamps into [−max_bank, max_bank] and refuses (yields BankCorrection::NoSafeAction) once the sensed heat flux or g-load exceeds its ceiling.
SlipWall: A free-slip (far-field) wall on the face perpendicular to wall_axis (the max_side face when true, the zero face otherwise): no penetration (zero wall-normal flux — already the projection’s Neumann condition at a closed face) with a free tangential velocity (zero shear). It un-pins the face’s wall-tangential edges from the auto-derived no-slip set, so the boundary-clipped viscous operator gives the zero-shear condition. It is the lateral boundary an isolated body needs (a confining no-slip wall would impose a spurious boundary layer).
SnapshotPackage: A snapshot package in memory: what the saver serializes and the loader returns.
SnapshotSection: One named section: an opaque byte blob with its own version byte, so a single section’s layout can evolve without bumping the container format.
SolenoidalField: A divergence-free velocity 1-form: constructible only by projection.
SpaceTimeCoordinate: Represents a point in 4D Space-Time with associated kinematic and clock data.
SpacetimeInterval: Spacetime Interval ($s^2$).
SpacetimeVector: Wrapper for CausalMultiVector representing a vector in Spacetime.
SpecificEnthalpy: Specific Enthalpy (J/kg). Reference-state dependent; may be negative.
Speed: Speed — scalar magnitude of velocity (m/s).
StagnationOutcome: The stagnation-line blackout outcome at the post-shock equilibrium (the peak).
StepContext: The immutable per-step read-view a coupling stage consults: the time step and step index (universal), plus a DEC-only manifold/velocity for stages that sample the primary field. The backing sum type (design D8) lets the same PhysicsStage run under both the DEC and QTT marchers with no change to the stage trait.
StepOutput: The result of one projected march step: the new divergence-free state together with the diagnostics the step already computed — callers do not recompute them.
StepView: A cheap, read-only view of one completed step, passed to a MarchRun::run_with hook. Exposes the step index/time, the raw edge cochain (for an edge-indexed probe), and convenience diagnostics off the manifold.
Stiffness: Scalar stiffness (Young’s Modulus, etc.) (Pascals).
StiffnessTensor: Stiffness tensor $C_{ijkl}$ (Rank 4) used in generalized Hooke’s law.
StokesVector: Stokes Vector. Intensity vector $(S_0, S_1, S_2, S_3)$. Rank 1, Dim 4 Tensor. Constraint: $S_0^2 \ge S_1^2 + S_2^2 + S_3^2$.
Strain: Strain tensor field $\boldsymbol{\epsilon}$ (Rank 2).
StrainRateTensor: Strain-rate tensor S = 0.5·(∇u + ∇uᵀ). Symmetric: S_ij = S_ji. new checks the symmetry invariant by exact equality, matching what natural construction 0.5·(G + Gᵀ) produces in IEEE 754. Use new_unchecked to bypass the check in hot kernels where symmetry is guaranteed by the algebra.
Stress: Scalar stress (Pascals), used for simple 1D cases or invariants (Von Mises).
StressTensor: Cauchy stress tensor $\boldsymbol{\sigma}$ (Rank 2).
StudyDef: The study entry: a titled campaign awaiting its case axis. Opened by CfdFlow::study.
StudyEffect: A phase value inside the study effect: either the carried value or the first (verb-tagged) error, plus the accumulated non-fatal warnings.
StudyEffectWitness: A witness type that fixes the error E and warning-log WLog for StudyEffect, carrying the type-level function Type<T> = StudyEffect<T>. The lawful Functor / Applicative / Monad instances live in the sibling modules; no consumer ever names this type.
StudyError: A study failure: its cause plus the verb (stage) it arose in. A bare From conversion leaves the stage empty; the campaign’s verbs re-tag with their own name via in_stage.
StudyView: A read-only view of a study at judgment time.
StudyWarningLog: The accumulated study warnings, in the order they were recorded.
Swept: The reduced result rows (with any prior refinement rounds), awaiting record / gates.
TableColumn: One column’s semantics: its name and its unit (empty string when the table carries none).
TaylorGreen: The Taylor–Green vortex (2D embedded in 3D, w = 0), an exact solution of the incompressible Navier–Stokes equations and the canonical MMS benchmark:
Temperature: Absolute Temperature (Kelvin) — SI base unit.
ThermalRelax: A first-order conduction relaxation of a named scalar field toward a wall temperature: T ← T + rate·dt·(T_wall − T) per cell. A stand-in for Solid::conduction() — enough to drive the ν(T) feedback through ViscosityArrhenius. A no-op if the field is absent.
ThrottleGuidance: The production terminal-guidance stage: commands the throttle from the stopping-distance closed form, behind a latched ignition-corridor commit.
Time: Time (seconds) — SI base unit.
Torque: Torque (N·m).
TrajectoryNav: The trajectory/navigation stage ([4]): one ReentryNavEngine step per coupling step — KS predict with the ④ aero-force channel as the perturbation kick, then the ESKF measurement fold.
TwistAngle: Moiré Twist Angle ($θ$).
UncertainBoundarySource: Supplies the time-varying scalar value of a boundary (or, in principle, any parameter) from a MaybeUncertain<R> stream — the cross-domain generalization of the Stage-4 uncertain-inflow mechanism (CFD add-boundary-zone-abstraction D4).
UncertainInflowZone: A sensor-fed inflow boundary patch (CFD Stage-4 — the first MaybeUncertain data zone).
UncertainMarchConfig: An owned uncertain-inflow march configuration. The dimension is fixed by the geometry at .on(&manifold), not here.
UncertainMarchConfigBuilder: Fluent builder for an UncertainMarchConfig. Required: solver, inflow_zone, sensor_stream, march_for. The seed defaults to Seed::Rest.
UncertainMarchPipeline: The injected uncertain-march pipeline before a geometry is bound.
UncertainMarchRun: A geometry-bound, runnable uncertain-inflow march.
UncertainStepView: A read-only view of one completed uncertain-inflow step, passed to a UncertainMarchRun::run_with hook. Exposes the step index, the raw edge cochain (for an edge-indexed wake probe), whether this step was a sensor dropout, and convenience diagnostics.
VectorPotential: Electromagnetic Vector Potential $\mathbf{A}$.
Velocity3: Fluid velocity vector (m/s).
VelocityGradient: Velocity gradient tensor ∇u. Pinned to the Jacobian convention: value[i][j] = ∂u_i / ∂x_j. Construction-time check is finiteness only — any finite 3×3 matrix is a valid velocity gradient.
VelocityOneForm: A velocity field as an edge 1-form (grade-1 cochain) on a cubical lattice.
Verdict: The resolved outcome of a study: the gate outcomes and the accumulated non-fatal warnings.
VerifyConfig: An owned MMS-verification configuration: a Manufactured solution M, the sample point/time, and an optional kernel-in-the-loop amplitude march. Built by CfdConfigBuilder::verify; run by CfdFlow::verify.
VerifyConfigBuilder: Fluent builder for a VerifyConfig.
VerifyRun: A runnable MMS-verification workflow.
VibrationalLagStage: The Park two-temperature vibrational lag: turns the per-cell translational T_tr into the rate-controlling temperature Tₐ = √(T_tr·T_ve) that actually governs ionization.
VibrationalTemperature: Vibrational (vibrational–electronic) temperature $T_{ve}$. Unit: K. Constraint: finite, $\geq 0$.
Viscosity: Dynamic Viscosity (Pa·s).
ViscosityArrhenius: A temperature-dependent viscosity closure (Arrhenius form) that writes ν(T) into the ambient — the stage that closes the thermo → fluid loop. ν(T) = ν_ref · exp(β·(T_ref/T − 1)), so ν = ν_ref at T = T_ref. Reads the mean of the "temperature" field (the wall-driven bulk temperature); with no temperature field it leaves ν unchanged.
ViscousStress: Viscous (deviatoric) stress tensor τ (Pa). Symmetric. Distinct from the full Cauchy stress σ = −p I + τ — only the viscous part appears in the dissipation Φ = τ:∇u ≥ 0 and entropy-production guarantees.
Volume: Volume (m³).
VorticityTwoForm: A vorticity field as a face 2-form on a cubical lattice. Closedness (dω = 0) is automatic for any ω = d u♭ by d² = 0 and therefore not a runtime invariant of this carrier (design open question 3 of add-dec-solver-foundations: plain typed wrapper, no type-state).
VorticityVector: Vorticity vector ω = ∇ × u (1/s). Pseudovector under spatial reflection.
WallShearStress: Wall Shear Stress magnitude (Pa). Stored as magnitude; sign convention is carried by the calling context, not by this type.
Wavelength: Wavelength ($\lambda$). Unit: Meters. Constraint: > 0.

Enums§

BankCorrection: The bounded bank-angle correction — the loop’s Action A.
DropoutVerbosity: Verbosity policy for the BC-fallback record an UncertainInflowZone writes when a sensor sample fails its presence gate (CFD Stage-4 design D6, open question 3).
DuctAreaProfile: The duct’s cross-sectional area as a function of axial position.
EvidenceClass: The provenance of a gate’s numeric bound.
FlowBranch: The isentropic branch of the area–Mach relation: for every area ratio $A/A^* > 1$ the relation has one subsonic and one supersonic root, and the caller must say which flow regime it is asking about.
GoverningModel: The governing continuum/rarefaction model selected from the Knudsen number. The classic bands: continuum Navier–Stokes below Kn ≈ 0.01, slip-corrected continuum to ≈ 0.1, transitional to ≈ 10, free-molecular above. (Thresholds are configurable on RegimeClassify.)
Grading: A smooth metric grading on one axis: a PerEdge CubicalReggeGeometry whose edge lengths vary along axis, leaving d, the discrete Stokes theorem, and divergence-freeness exact (they are combinatorial) while resolving walls cheaply. The structure is unchanged; only accuracy order is at stake.
IntegratorRegime: Which trajectory integrator the regime detector has selected.
LadderOutcome: The verdict on a refinement ladder.
MachRegime: The compressibility band of the flight phase (change add-retropulsion-coupled-stages, capability flight-regime-classifier), read from the carrier-published "flight_mach". Unknown is the neutral value a world that publishes no Mach carries, so the corridor’s classification is unchanged.
MarchStop: When the march stops.
Operator: A DEC operator whose discretization accuracy is studied.
Regime: A Navier–Stokes regime — the FluidTheory selector for MMS verification.
ScalarTypeTag: The working scalar a snapshot’s values were encoded at. The tag is authoritative: loading a package into a program whose scalar differs is refused with no override, because a wrong scalar cannot be reinterpreted, only refused.
Seed: A named initial condition. Static (no boxed closures) so a Mesh/case stays Clone. The seed builds the vertex vector field and seeds it through the solver’s divergence-free projection.
SnapshotTier: The two snapshot tiers: a field snapshot (tensor fields plus grid metadata, the area-of-interest artifact) and a full resume package (the field snapshot plus the state’s passengers: carried scalars, navigation engine, provenance log, step index).
StudyWarning: One non-fatal study diagnostic, classified by where it arose.
ThrustState: The propulsion state of the flight phase, read from the "ignited" flag. Unknown is the neutral value for a world that carries no propulsion state.

Constants§

IGNITION_COMMIT_AIDED_FIELD: Whether the navigation was aided at the commit (1 aided, 0 dead-reckoning).
IGNITION_COMMIT_MACH_FIELD: The flight Mach the corridor sensed at the commit.
IGNITION_COMMIT_Q_FIELD: The freestream dynamic pressure (Pa) the corridor sensed at the commit.
IGNITION_COMMIT_SIGMA_FIELD: The navigated position uncertainty (m, one sigma) at the commit.
IGNITION_COMMIT_STEP_FIELD: The step the ignition corridor committed on, published at the latching step.
IGNITION_LATCH_FIELD: The field scalar carrying the one-way ignition latch across steps and leg boundaries.
LEG_RE_SEEDS_FIELD: The field scalar counting leg re-seeds, incremented every time a march resumes from a MarchState. Cumulative across legs, because the coupled field carries it.
NAV_STATES: The error-state dimension (17 = INS 15-state + clock bias/drift).
PRESERVED_DRAG_FRACTION_FIELD: The preserved-drag fraction the A0 correlation applied this step.
REDUCED_MASS_AMU: Millikan–White reduced mass μ_sr of the dominant relaxing collision pair, in amu.
REGIME_TRANSITIONS_FIELD: The field scalar counting logged regime transitions, incremented once per genuine regime change. Cumulative across legs, because the coupled field carries it.
STOPPING_BURN_ALTITUDE_FIELD: The altitude (m) the stopping burn lit at, published when it latches.
STOPPING_BURN_FIELD: The field scalar latching the start of a stopping burn, published by a guidance configured with with_stopping_burn. Absent or zero while coasting.
STOPPING_BURN_SPEED_FIELD: The flight speed (m/s) at which the stopping burn lit.

Traits§

BitCodec: Bit-exact encoding of a working scalar into a section payload. Values are raw IEEE bit patterns, little-endian, so encoding and decoding change no bits at any precision.
BoundaryZone: A composable boundary condition for the DEC Navier–Stokes solver.
CfdScalar: Scalar bound for every CFD theory and solver: precision as a parameter (f32, f64, Float106), plus the MaybeParallel thread-safety marker that lets the inner topology operator loops fan out under --features parallel. Blanket- implemented for every qualifying type, so it is invisible to serial consumers and is exactly the Rayon requirement under the parallel feature.
DecNsScalar: The composed bound set of the DEC solver stack: the topology operators require RealField + Default + PartialEq + Debug (+ FromPrimitive), the typed-form constructors add Display, Rk4’s Scalar is satisfied by RealField + FromPrimitive through the blanket impl, and MaybeParallel carries the topology crate’s parallel-feature thread-safety requirement (vacuous on serial builds; Send + Sync under --features parallel — every workspace scalar qualifies).
FluidTheory: A Navier–Stokes regime expressed as a field-level marching rate, abstracted above both the DEC-native rate and the pointwise regime evaluators (the latter realized by sampling the state and calling the classical kernels for MMS / analytic verification).
FromTableRow: The read-side inverse of TableRow: reconstruct a row from cells delivered in schema order.
IoAction: A deferred description of an input/output computation.
Manufactured: A manufactured analytic solution: the MMS seam. A corpus solution (e.g. TaylorGreen) or a caller-supplied field both implement it; the verification workflow consumes it.
MarchDispatch: A configuration CfdFlow::march accepts: it opens the family’s runnable pipeline, hidden behind the facade by the GAT, so one march verb serves every solver family (the DEC, QTT, duct, compressible, and uncertain marches) instead of five family-specific entries.
Marchable: A configuration that marches itself to a Report in one shot.
Marcher: One projected step of a CFD solver: the theory’s integration (RK4) followed by the Leray projection back into the divergence-free type-state and the CFL guard, reading the crate::Ambient for that step.
MetricProvider: A structured curvilinear coordinate over a 2^Lx × 2^Ly computational lattice, supplying the pieces a compressible marcher needs: field sampling, the chain-rule physical gradient, and the Jacobian volume factor — all carried as low-rank tensor trains. Static dispatch only (used as a generic bound).
MetricProvider3d: A structured curvilinear coordinate over a 2^Lx × 2^Ly × 2^Lz computational lattice, supplying the pieces a 3-D compressible marcher needs: field sampling, the chain-rule physical gradient, and the Jacobian volume factor — all carried as low-rank tensor trains.
PhysicsStage: One between-step physics transform. Implemented for () (identity) and (Head, Tail) (sequential composition) so couplings compose statically; a concrete physics is a small impl.
Solver: The shared seam of the three CfdFlow solver kinds — the marching solver, the MMS-verification solver, and the operator-accuracy solver. Each consumes its fully-owned case (materializing any borrows as locals) and yields a common Report. Adding a fourth kind is an implementation of this trait, not a change to the DSL core (design D2).
TableRow: A typed table row: its column schema and its cells, in the working precision Scalar.
TableScalar: A scalar that round-trips through a table cell exactly. Both the typed table reader and the result-table writer bound on this, so a written table reads back with identical bits at the written precision. Copy because the supported cell scalars (f64, f32, Float106) are all small Copy values.

Functions§

aero_gravity_ratio: The regime indicator ε = a_aero / a_grav = |a_aero| / (GM/r²) — the g-load, computed from state.
body_mask_2d: A smoothed cylinder volume-fraction mask: χ = ½(1 − tanh(d/δ)) over the signed distance d = ‖(x, y) − (cx, cy)‖ − radius to the cylinder surface, smeared over smoothing (= δ). Inside the body (d < 0) χ → 1; outside χ → 0; on the surface χ = ½. Larger smoothing → lower bond.
compressible_ns_continuity_rhs: Continuity equation RHS: ∂ρ/∂t = − u·∇ρ − ρ ∇·u.
compressible_ns_continuity_rhs_effect: Causal wrapper for compressible_ns::compressible_ns_continuity_rhs.
compressible_ns_energy_rhs: Total-energy equation RHS in conservative form:
compressible_ns_energy_rhs_effect: Causal wrapper for compressible_ns::compressible_ns_energy_rhs.
compressible_ns_momentum_rhs: Momentum equation RHS in primitive velocity form: ∂u/∂t = − (u·∇)u − (1/ρ) ∇p + (1/ρ) ∇·τ + g.
compressible_ns_momentum_rhs_effect: Causal wrapper for compressible_ns::compressible_ns_momentum_rhs.
conservation_round: Conservation-preserving rounding (design D4): round minimizes Frobenius error, not the integral, and the implicit solve carries its own residual, so a marched conservative field drifts its total. Carry the conserved target total (the invariant from t = 0) and, after rounding, restore it with a rank-1 uniform fixup (δ = (target − ∫after)/N added as a constant field), which projects out both the rounding error and the solver residual each step.
dec_divergence_residual: Post-projection divergence residual ‖δu♭‖_∞ — the projection- exactness witness.
dec_enstrophy: Enstrophy Z = ½ Σ_f ω_f (⋆ω)_f with ω = d u♭.
dec_helicity: Helicity H = Σ_c (u♭ ∧ du♭)_c — the top-form cochain of the wedge, whose coefficients are already cell integrals. Three-dimensional flows only: in any other dimension the quantity is meaningless and the call is rejected.
dec_kinetic_energy: Kinetic energy E = ½ Σ_e u_e (⋆u)_e — the discrete ½ ∫ u♭ ∧ ⋆u♭ through the diagonal Hodge star.
dec_max_speed: Maximum pointwise speed: sharp recovers vertex vectors (layout vertex * D + axis), the maximum Euclidean norm is returned.
dec_ns_step: Causal wrapper for DecNsSolver::step: one projected march step, carrying the divergence-free edge cochain of the new state.
dec_sample_velocity: The velocity vector at the physical point p (in spacing units), by sharp- reconstructing the vertex vector field and multilinearly interpolating. Used by the CfdFlow wake-probe (Strouhal signal) and centerline (Ghia profile) observations; a read-only point query, not on the step hot path. Corners outside the domain contribute zero (the wall / no-slip value at a boundary line).
dequantize: Recovers the dense length-2^L field from its quantized tensor train (inverse of quantize).
dequantize_2d: Recovers the dense [2^Lx, 2^Ly] field from its quantized tensor train (inverse of quantize_2d). lx/ly give the per-axis mode split.
dequantize_3d: Recovers the dense [2^Lx, 2^Ly, 2^Lz] field from its QTT (inverse of quantize_3d). lx/ly/lz give the per-axis mode split.
divergence_3d: Divergence ∇·F = ∂ₓFₓ + ∂ᵧFᵧ + ∂_zF_z of a 3-D vector field given as three component trains and the three pre-built gradient operators (built once, reused each step by the marcher), recompressed.
divergence_residual: The divergence residual ‖∇·(u, v)‖ (Frobenius/L2 over the grid) — the projector forms the divergence train, then its norm is taken. No dequantize.
dominant_frequency: The dominant frequency of an evenly-sampled signal by mean-crossing counting: each pair of consecutive crossings of the signal mean spans one half-period, so f = (crossings / 2) / T with T = (n − 1)·dt the record length. Returns 0 when fewer than two crossings are seen (no detectable oscillation over the record).
drag_lift: Drag and lift coefficients on the immersed body, from the penalization-force contraction: the force the fluid exerts on the body is the penalization momentum integral F = (1/η) ∫ χ_body ⊙ (u − u_body) dV per component, nondimensionalized as C_d = F_x / (½ ρ U² D) (ρ = 1). A pure tensor-train contraction — no cut-cell surface or boundary fiber.
euler_momentum_rhs: Pointwise RHS of the Euler momentum equation (inviscid).
euler_momentum_rhs_effect: Causal wrapper for euler::euler_momentum_rhs.
fingerprint64: Digest caller-supplied world-description bytes into the fingerprint a snapshot stores. The input is a seam: today an example hashes its own constants; when the canonical config serialization lands, that serialization becomes the input without changing the container.
force_coefficient: A nondimensional force coefficient C = F / (½ ρ U² A) at ρ = 1 (drag with the streamwise component, lift with the transverse, given the reference speed u_ref and frontal area/length reference_area).
force_load_snapshot: Describe (but do not perform) a force load of a snapshot from path.
fragment_area_vector: The net outward area vector ∮ n dA of a body’s fragments — zero for a closed surface (a consistency check on the fragment normals, independent of any field).
gradient: Centered first-difference operator ∂ₓ ≈ (u[k+1] − u[k−1])/(2Δx) on a periodic 2^L grid.
gradient_x: ∂ₓ on a 2^Lx × 2^Ly field (serial x-then-y mode layout): gradient_1d(x) ⊗ I_y.
gradient_x_3d: ∂ₓ on a 2^Lx × 2^Ly × 2^Lz field: gradient_1d(x) ⊗ I_{y,z}.
gradient_y: ∂ᵧ on a 2^Lx × 2^Ly field: I_x ⊗ gradient_1d(y).
gradient_y_3d: ∂ᵧ on a 2^Lx × 2^Ly × 2^Lz field: I_x ⊗ gradient_1d(y) ⊗ I_z (the middle block).
gradient_z_3d: ∂_z on a 2^Lx × 2^Ly × 2^Lz field: I_{x,y} ⊗ gradient_1d(z).
ideal_gas_pressure: Ideal-gas pressure p = (γ−1)(E − ½ρu²) = (γ−1)(E − ½m²/ρ) from the conservative state.
ideal_gas_pressure_2d: Ideal-gas pressure p = (γ−1)(E − ½(ρu²+ρv²)/ρ) from the 2-D conservative state (ρ, ρu, ρv, ρE).
incompressible_ns_rhs: Pointwise RHS of the incompressible Newtonian momentum equation.
incompressible_ns_rhs_effect: Causal wrapper for incompressible_ns::incompressible_ns_rhs.
inflow_march_step: One uncertain-inflow march step (the CausalFlow bind stage). See the module docs.
kinetic_energy: Kinetic energy ½(‖u‖² + ‖v‖²) from the train norms — the ‖·‖ is the Frobenius/L2 norm over the 2^Lx · 2^Ly grid coefficients, so this is the (unweighted) discrete kinetic energy. No dequantize.
laplacian: Second-difference (Laplacian) operator ∂²ₓ ≈ (S₊ + S₋ − 2·I)/Δx² on a periodic 2^L grid.
laplacian_2d: 2-D periodic Laplacian ∂²ₓ + ∂²ᵧ on a 2^Lx × 2^Ly field (the five-point stencil), recompressed.
laplacian_3d: 3-D periodic Laplacian ∂²ₓ + ∂²ᵧ + ∂²_z on a 2^Lx × 2^Ly × 2^Lz field (the seven-point stencil), recompressed.
ler_relax_scalar: Relax a named CoupledField scalar toward per-cell targets with per-cell timescales, in place, by the closed-form ler_step. A no-op if the field is absent; the targets/taus slices must match the field length.
ler_step: The closed-form Lagging-Equilibrium Relaxation step: x(t+Δt) = x_eq − (x_eq − x)·exp(−Δt/τ).
load_resume_state: Load and strictly verify a resume package from path in one call: checksum, scalar, and world fingerprint are all validated before the state is rebuilt. This is the entry point a different workflow uses days later; the returned field goes wherever an initial field would.
load_snapshot: Describe (but do not perform) a strict snapshot load. expected_scalar is the program’s working scalar; current_fingerprint is the digest of the current world description (pass None to skip world validation, e.g. for inspection tools).
march_inflow: Runs the uncertain-inflow march for steps steps and returns the final process — its EffectLog holds every recorded dropout, its State the final field and last-good value.
mask_from_fn: Samples a scalar field f(x, y) over the 2^Lx × 2^Ly grid of spacings dx/dy (node (i, j) at (i·dx, j·dy), row-major [Nx, Ny]) and quantizes it to a rounded tensor train — the generic mask constructor (any smoothed indicator).
max_bond: The maximum bond dimension across both velocity trains — the compression / rank metric. Each rank-3 core [r_left, phys, r_right] contributes its right bond shape()[2].
max_speed: The maximum speed max √(u² + v²) over the dequantized 2^Lx × 2^Ly grid.
nav_transition_matrix: The linearised 17-state error-state transition matrix F for one step of dt under specific force f. Reproduces InsErrorState::propagate exactly (F·x == propagate(x)), so the covariance and the state advance under one consistent linearisation.
pack_resume: Pack a coupled field and its step index into a full resume package.
pack_tt_fields: Pack named tensor-train fields and their grid shape into a field-tier package.
penalization_heat_integral: The penalization heat integral over the immersed body: Q = (1/η) ∫ χ_body ⊙ (T_w − T) dV, the volumetric rate at which the penalization term exchanges heat with the fluid to hold the body at t_wall. The same contraction shape as drag_lift, with temperature in place of velocity.
plume_mask_2d: A smoothed plume-region volume-fraction mask: an axis-aligned ellipse with semi-axes half_length (along x, the retro-jet axis) and max_radius (along y), centered at (cx, cy), smoothed with the same χ = ½(1 − tanh(d/δ)) skirt as body_mask_2d. The distance proxy is the normalized-ellipse level set rescaled to length units by the smaller semi-axis, d ≈ (‖((x−cx)/a, (y−cy)/b)‖ − 1)·min(a, b) — not a true signed distance, but monotone through the boundary, which is all the smoothed skirt needs.
positivity_floor: Positivity limiter (task 3.3): clamp a field to a small positive floor (dequantize → max(·, floor) → requantize). A pragmatic guard keeping ρ, p > 0 through a strong rarefaction; the structural upgrade is entropy / log-variable evolution (deferred).
preserved_drag_fraction: The preserved-drag fraction: the powered (plume-imprinted) run’s contracted forebody force over the unpowered baseline’s, from the same configuration — the dimensionless quantity the Jarvinen–Adams correlation tabulates (C_A,F / C_A0). A same-configuration ratio, so the harness’s common geometry biases cancel.
pressure_surface_force: The pressure surface force on an immersed cut body: F_p = −∮ p n dA, summed over every cut cell’s fragments with the cell pressure from cell_pressure (keyed by the cell’s iter_cells(D) index — the registry’s CellId).
quantize: Encodes a length-2^L periodic 1-D field as an L-mode quantized tensor train (QTT).
quantize_2d: Encodes a 2^Lx × 2^Ly periodic field (shape [Nx, Ny]) as an (Lx + Ly)-mode QTT: the leading Lx modes are the x-bits, the trailing Ly the y-bits (MSB-first per axis, the natural row-major reshape). Axis operators built by lifting (see gradient_x/gradient_y) act on the matching block.
quantize_3d: Encodes a 2^Lx × 2^Ly × 2^Lz periodic field (shape [Nx, Ny, Nz]) as an (Lx + Ly + Lz)-mode QTT: the leading Lx modes are the x-bits, the middle Ly the y-bits, the trailing Lz the z-bits (MSB-first per axis, the natural row-major reshape). Axis operators built by block lifting (see gradient_x_3d/gradient_y_3d/gradient_z_3d) act on the matching block. The 3-D extension of quantize_2d, the prerequisite codec for the Tier-B compressible marcher.
read_rows: Describe (but do not perform) reading typed rows T from path.
read_table: Describe (but do not perform) reading a typed numeric table from path.
reduced_mass_amu: The Millikan–White reduced mass μ_sr = m_s·m_r / (m_s + m_r) (amu) for a named collision pair. This is the checked constructor behind REDUCED_MASS_AMU.
save_resume_state: Save a full resume package to path in one call: pack the field and step, checksum, write.
save_snapshot: Describe (but do not perform) saving package to path.
shift_minus: S₋ (cyclic −1) — the transpose (hence inverse) of shift_plus.
shift_plus: The periodic grid-shift operator S₊ (cyclic +1) on a 2^L grid, as a bond-2 MPO built by hand.
stokes_momentum_rhs: Pointwise RHS of the Stokes momentum equation (creeping flow).
stokes_momentum_rhs_effect: Causal wrapper for stokes::stokes_momentum_rhs.
strip_pressure_force: The forebody-strip pressure contraction of an evolved compressible state: the pressure is recovered pointwise from the conserved components (p = (γ−1)(E − ½|m|²/ρ), the ideal-gas closure), re-quantized, and contracted against the strip mask via the train inner product and the cell area — ∫ χ_strip · p dA, no cut-cell surface or boundary-fiber reconstruction. This is the compressible sibling of the incompressible penalization-force contraction: the integrand is the field’s own pressure (the preserved aerodynamic drag the Jarvinen–Adams dataset measured), not the forcing deficit.
strouhal_number: The Strouhal number St = f·L / U of a wake-probe signal sampled every dt, with characteristic length length (the body diameter) and free-stream speed u_ref. Returns 0 when no oscillation is detected (see dominant_frequency).
sweep: Map f over items in input order, collecting into one Result. The first error in input order wins; under the parallel feature every body still runs (there is no cancellation), but the returned error is the earliest failing case’s.
unpack_resume: Unpack a full resume package into the coupled field and the suspended step index.
unpack_tt_fields: Unpack a field-tier package into its named tensor trains and grid shape.
viscous_surface_force: The viscous (friction) surface force on an immersed cut body: F_μ = ∮_S μ(∇u + ∇uᵀ)·n dA, summed over every cut cell’s fragments.
wall_heat_flux: The Fourier-law wall heat flux on an immersed cut body: q = −k ∮_S ∇T·n dA, summed over every cut cell’s fragments.
write_rows: Describe (but do not perform) writing typed rows to path.
write_table: Describe (but do not perform) writing table to path, at the table’s precision R.

Type Aliases§

CompressibleFork: One counterfactual branch forked from a CompressiblePause.
CompressiblePause: A compressible coupled march paused mid-flight (the shared branch state of a counterfactual study). Produced by CompressibleMarchRun::run_until.
EulerState: One conservative state as three dense component buffers (ρ, ρu, ρE).
EulerState2d: One 2-D conservative state as four dense buffers (ρ, ρu, ρv, ρE), row-major 2^Lx × 2^Ly.
EulerState3d: One 3-D conservative state as five dense buffers (ρ, ρu, ρv, ρw, ρE), row-major 2^Lx × 2^Ly × 2^Lz.
EulerStateTt2d: One 2-D conservative state as four tensor trains (ρ, ρu, ρv, ρE) — the Marcher state.
EulerStateTt3d: One 3-D conservative state as five tensor trains (ρ, ρu, ρv, ρw, ρE) — the Marcher state.
GateFn: A gate check: reads a study view of any lifetime, returns (passed, detail).
InflowProcess: The stateful process the uncertain-inflow march threads: value R (the step’s inflow), InflowMarchState, InflowContext.
MarchFork: One counterfactual branch forked from a MarchPause: alternate its world or state, then continue_march. Alternation uses the verbatim core vocabulary; the error channel is never alternated.
MarchPause: A coupled QTT march paused mid-flight: the shared branch state every counterfactual fork resumes from. Produced by QttMarchRun::run_until.
NamedTtFields: Named tensor-train fields, as a field-tier snapshot stores them.
PhysicalGradient3d: The physical gradient triple (∂/∂x, ∂/∂y, ∂/∂z) a 3-D metric returns.