Test report

Algorithm::KrylovNewton (stale Initial tangent + acceleration) converges to the same equilibrium as full Current-tangent Newton, while factoring far less often than once per iteration — the whole point of accelerating a stale tangent instead of re-forming it.

TangentStrategy::Current re-forms and factors the tangent every iteration. On a step that crosses yield (elastic-perfectly-plastic spring parallel to a truss) the answer matches the closed-form displacement, the factorization count equals the iteration count, and more than one iteration is needed.

LineSearch must not change the converged answer versus plain Newton — only how it gets there. Both variants checked against the same Current-tangent, no-line-search baseline.

TangentStrategy::ReuseAtStepStart: factors once per step() call (unlike Initial's once-ever), so a second step gets its own fresh factorization at the state that step started from — distinguishing this from tangent_strategy_initial_never_refactors_across_multiple_steps above is the whole point of these being two different enum variants.

TangentStrategy::Initial: forms the tangent once, from the model's very first (undeformed, elastic) state, and never re-factors again for the rest of the Analysis's lifetime — proven here across two separate step() calls, not just within one, since docs/algorithms.md §3.1 specifically calls out "once ever," not "once per step" (TangentStrategy::ReuseAtStepStart is the once-per-step variant). Converges to the same answer as Current (linear convergence rate, more iterations, but the same equilibrium point), while never paying for a second factorization.

With ArcScales::Auto the displacement scale is derived from the first tangent. Starting exactly at the peak of a softening spring the tangent is singular, so no scale can be derived and the first step fails with SingularSystem rather than continuing with a bad scale.

Stop criteria: a maximum chord length ends the phase after the expected number of steps, and reopening the phase with new criteria (a step cap of 3) keeps the direction and chord history and stops after exactly three more steps.

Mutating the domain between steps (here adding a constant load) discards the continuation history and re-validates the entry state; the broken equilibrium is reported as InitialStateNotInEquilibrium.

On a linear spring the arc-length path is the straight line lambda = k*u, so each step advances by the closed-form increment dlambda = s / sqrt((1/(k u*))^2 + (1/lambda*)^2), in both the increasing and decreasing directions. The predictor is already exact, so no corrector solves are needed, the determinant sign stays positive and no bifurcation is flagged.

3D (Domain3) counterpart of the planar elastic closed-form test: a linear ZeroLength3 spring continued by arc-length follows the exact straight path lambda = k*u.

The automatic displacement scale equals the hand-computed u* = lambda* p / K (0.01 here), and a run with ArcScales::Auto reproduces the path of the same run with that scale given explicitly.

A displacement stop target with exact: true on the softening spring lands exactly on the target (u = 0.02, load factor 6.0, zero overshoot), and further steps after the stop are refused without changing the state.

Two parallel degrading springs on nodes tied with equal_dof are equivalent to one spring of twice the strength on a single node: the two arc-length paths agree, so continuation works in the constraint-reduced coordinates.

Starting in equilibrium exactly at the peak of a softening spring (tangent exactly zero, closed-form peak force k*a/e), continuation needs a seed direction and then continues past the peak along the softening branch.

A perfectly straight corotational cantilever under axial compression: the primary (straight) path keeps loading through the Euler load, where one eigenvalue of K crosses zero. lambda never reverses, so the determinant sign change must be flagged as a suspected bifurcation.

Entry validation: a model that is not in equilibrium, an active Path load series, and a model with no continued load are each rejected with a structured error instead of producing results.

Gravity is applied under load control and frozen with hold_pattern_constant, then the lateral pattern is continued by arc-length. The frozen gravity displacement must stay constant while only the lateral load factor evolves.

Every invalid arc-length option (non-finite scales, bad radii or tolerances) and unsupported algorithm/convergence-test combination is reported as InvalidOption naming the offending field.

A step that fails after exhausting its cutbacks (an unreachable tolerance on the step that crosses the kink) restores the domain and leaves the continuation history untouched, so retrying with a valid tolerance reproduces the clean reference run.

On a smooth exponential-softening spring with only two corrector solves allowed per step, an oversized radius needs cutbacks. Every step still converges, the radius stays within its bounds, and each accepted point lies on the exact force-displacement curve.

Load-factor stop criteria on an elastic spring: an exact target (lambda = 1) is landed on, then reversing direction restarts the history at lambda = 1 and the zero-crossing criterion ends the phase.

The path is invariant to units and reference-load scaling: the same degrading spring in millimetres with a reference load of 4 and matching arc scales recovers the metre/unit-load path after rescaling.

A smooth softening spring in series with a stiffer linear one gives snap-back: displacement turns back while the tangent stays nonsingular. With both the secant and tangent predictors the path is traced through the turning points, with the load decreasing and then recovering.

Shallow two-bar (von Mises) truss of corotational elastic members, pinned at the supports and at the apex (two coincident apex nodes tied in translation by equal_dof, so each bar is pin-ended and carries no moment), apex x fixed as the symmetry constraint. Oracle: P(v) = 2 EA (L0 - L)/L0 * (h - v)/L, L = sqrt(b^2 + (h - v)^2).

Arc-length continuation traces a degrading-strength spring through its peak and down the softening branch. Every accepted point lies on the independent backbone curve (lambda = backbone(u)), the support reaction balances the applied load, and the load decreases after the peak.

Baseline for the arc-length tests: load control converges before the peak but fails to converge past it, and the failed step rolls the node displacement back exactly.

Starting arc-length in the decreasing direction follows the mirror-image negative backbone: displacement decreases monotonically and every point satisfies lambda = -backbone(-u).

The degrading spring in series with a stiff elastic spring produces a true snap-back (both load and displacement decrease after the peak). Arc-length continuation traces it, including the step that crosses the backbone kink.

A yielding ground spring in series with an elastic spring exercises both the controlled DOF and an unconstrained equilibrium correction. The post-yield load sensitivity differs from the initial one.

A nodal load on a DOF that no element stiffens (a moment on a truss-only node) is a model error, LoadOnInactiveDof, reported by validate and returned as a value by try_build.

Arc length needs a rotation scale only when the model has rotational unknowns; with the rotations inactive it must not demand one.

build panics on a model that fails validation (a moment applied to a truss-only node), since that is a model-construction error rather than a runtime failure.

A diaphragm's retained node typically has no element at all; the DOFs the constraint ties to must still be equations.

Explicit fixity wins: fixing a DOF that no element uses (a truss node's rotation) is legal, keeps the DOF active, and gives it no equation number.

A modal analysis of a 2D truss SDOF with its rotations left free works and gives the closed-form frequency sqrt(k/m), with k = EA/L and m = rho*A*L/2.

A nodal mass is inertia even with no stiffness, so it activates its DOF (a free mass is legal in a transient analysis); a mass on a stiffened DOF is unchanged.

A beam shares a node with a brace truss: the joint's rotation is an unknown (the beam stiffens it) while a truss-only node has none.

A 3D skew truss with no rotations fixed solves, with only the translational DOFs as unknowns.

A truss-only 2D model solves without fixing rotations: only the 3 translational DOFs become equations, and the displacements are identical to the same model with rotations fixed by hand.

Exercises Analysis::set_integrator driving a cyclic DisplacementControl protocol — many small legs on one Analysis (no rebuild) — the mechanism a real quasi-static cyclic-loading protocol (e.g. FEMA 461/ ATC-24-style excursions) is meant to use: ramp past yield, back through zero to a negative excursion, then back to zero — and check that the material remembers it yielded (nonzero residual force at zero net displacement — the hysteresis/permanent-set signature a path-independent material could never produce).

A LoadSeries::Path pattern driven by Integrator::LoadControl walking pseudo-time along the path's own control points — the load-controlled equivalent of Xara's dedicated Integrator::LoadPath (a StaticIntegrator that walks a prescribed load-factor vector one entry per step, see SRC/analysis/integrator/Static/LoadPath.h): no separate Integrator variant needed here, since a Path series already is a prescribed load-factor-vs-pseudo-time path, and LoadControl already knows how to step pseudo-time forward by a fixed amount each step.

A cantilever beam is loaded axially by a gravity pattern, which is then frozen, and a separate lateral pattern is applied in a second phase. The axial displacement from gravity must be nonzero after phase one and unchanged by the lateral phase, since the frozen pattern no longer ramps.

Same two-phase (frozen gravity → lateral) protocol, run once with GeomTransf::Linear and once with PDelta: with zero gravity the two must match exactly (no axial force means PDelta's geometric-stiffness correction vanishes), and with compressive gravity PDelta must soften the beam relative to Linear — the same physical checks elements/elastic_beam.rs makes within a single Analysis, but here driven by two genuinely separate analysis phases sharing one evolving Domain.

Integrator::DisplacementControl on the truss case: prescribing the same target displacement (rather than the equivalent load) should drive the analysis to the same load factor the linear truss test verifies directly (P=50).

Newton-Raphson resolves a step that crosses a regime change inside the step, where a one-shot linear solve cannot. An elastic truss in parallel with an elastic-perfectly-plastic spring, loaded past yield, must give the closed-form displacement u = (F - fy) / k_truss.

The displacement-increment and energy-increment convergence tests reach the same equilibrium as the unbalance-norm test on the yielding parallel system: the closed-form u = (F - fy) / k_truss.

Prescribed-displacement steps keep committed material history. An elastic-perfectly-plastic probe is driven past +yield, then past -yield, then back to -0.0005; the force must be +100, -100 and then +50 (the elastic unloading branch from the permanent set), where a path-independent material would give -50.

The uniaxial probe (a zero-length spring with one prescribed DOF and no free DOFs) follows a prescribed strain history on an elastic material: displacement equals the target and force equals E times strain, going through zero and negative strains.

Invalid prescribed targets (NaN, infinity, or a DOF that is free) are rejected with InvalidConstraint and leave the previous displacement untouched.

Support settlement: two equal-stiffness trusses in series with the end node displaced by 0.5. The free middle node moves half of that, 0.25.

Ent carries no tension: tangent and force are both zero at positive strain, which is exactly where DisplacementControl has nothing to divide by.

A fixed node shared by two elements (a two-span beam continuous over its middle support) sums each element's own contribution to that node's reaction — proves reaction iterates every element touching the node, not just the first (or last) one found, by checking the fixed end's reaction against simple statics: with a point load at the free tip of a cantilever built from two collinear elements in series, the root reaction moment must equal -load * total_length regardless of where the elements are split, and the root shear must equal -load — neither of which could be right if only one of the two elements were being summed.

Domain::reaction's simplest closed-form check: a fixed-free truss pulled at its free end (same case elements/truss.rs uses for displacement) must show a reaction at the fixed support exactly opposite the applied load — global equilibrium (sum(reactions) + sum(applied loads) == 0) for a single-DOF system with only one load and one support.

A correctness + scale check for the SparseSolver swap to faer . A single 2-node ElasticBeamColumn is exact for a simply-supported UDL case; this does the equivalent check for a chain of many elements, which exercises the sparse assembly/solve path at a non-trivial system size (150 free DOFs) with a real banded/sparse pattern, rather than the single- or few-element systems every other test uses. Chaining n identical prismatic Euler-Bernoulli elements under only a tip point load (no interior element loads) is exact against the classical cantilever closed form delta = P*L^3/(3*E*I) regardless of n — cubic Hermite elements reproduce a cubic deflection field exactly, so subdividing adds no discretization error.

ConstraintHandler::Plain can't resolve multi-point constraints — using it with a domain that has one is a model-construction error caught at build, not a silently-wrong solve.

equal_dof tying two otherwise-unconnected nodes' x DOF should make two separate ground-trusses act exactly like two springs in parallel on a single node (same closed form analysis/newton.rs's parallel-EPP/Truss case uses for a single shared node, but here the "sharing" is via constraint aliasing across two distinct NodeIds instead of two elements on one node) — the real thing under test is that Domain::number_dofs gives the constrained node's x DOF the same equation number as the retained node's, so both trusses' stiffness contributions land in the same row/ column of the assembled system.

rigid_diaphragm ties every constrained node's x DOF to the retained node's — same aliasing mechanism as equal_dof, exercised across more than one constrained node at once (the 2D-frame simplification: only x-translation is tied, not rotation/lever-arm kinematics — see Domain::rigid_diaphragm's doc comment).

A rigid diaphragm whose retained node is itself a slave of another rigid link (a chained diaphragm) used to panic.

u_slave = 2 * u_master: a ground spring k on the slave and a load P on the master give a master stiffness of 4k, so u_m = P / (4k).

Constraining the same slave DOF twice is rejected with DuplicateSlave.

A constraint whose slave DOF is also fixed is rejected by validate with SlaveIsFixed.

A master DOF fixed at a nonzero initial displacement is rejected with ConstraintOnPrescribedDof, since constrained slaves cannot follow a prescribed value.

Constraint cycles (A depends on B and B on A) and a slave that references itself are rejected with ConstraintCycle.

A slave whose initial displacement disagrees with its constraint equation is rejected with InconsistentInitialState.

Nodal mass on a slave DOF that is a combination of several unknowns (a rigid-diaphragm slave with a lever arm) cannot be lumped. validate and TransientAnalysis::new report MassOnConstrainedDof as an error instead of panicking.

2D: springs kx, ky on a slave offset (dx, dy) from a loaded master. Master stiffness is T^T K T with u_s = [ux - theta*dy, uy + theta*dx].

The same tie written as equal_dof and as a general constraint solves identically, and chains resolve whatever order the constraints were added in.

A constrained node's motion in a mode shape comes from value_at, not from the (absent) equation of the slave: a mass on a rigid-link master with a spring on the slave moves the slave by the lever-arm kinematics.

A single scaled unknown (u = c * q) can carry mass: c^2 m lands on q.

Repeated masters merge and zero coefficients vanish, so a term with a zero coefficient does not even activate its DOF.

A fixed DOF that is a constraint master cannot be prescribed (its slaves would not follow), including the first link of a chain, and a refused step leaves the domain untouched.

A rigid translation of the whole model satisfies every constraint, so the ground-motion influence vector must read back as exactly 1 on every translation of every node — including slaves — and 0 on rotations.

A slave left at the default zero takes the value its masters imply (in dependency order along a chain); a consistent nonzero value is accepted.

3D: translational springs on an offset slave, u_s = u_m + theta x d, so the master's 6x6 stiffness is T^T K T with T = [I | -[d]x].

rigid_diaphragm_about's explicit normal parameter, checked against Xara/OpenSees's own documented RigidDiaphragm constraint equations for their default perpDirn = 3 (z-normal, diaphragm plane x-y): Ux_c = Ux_r - Rz_r*(Yc-Yr), Uy_c = Uy_r + Rz_r*(Xc-Xr) — literally, not via this crate's general a/b/normal formula (Domain3:: rigid_diaphragm's doc comment shows the two agree, but this test doesn't rely on that derivation being right). Same kinematics-only approach as the vertical/rotation test above.

Rigid-rotation invariance: a diaphragm-constrained node's out-of-plane translation (uy, never tied by rigid_diaphragm — see its doc comment: "never vertical") and every one of its rotational DOFs (likewise never tied — "never rotational") must be completely unaffected by the master node's rotation, however large. Only the two in-plane translations respond to the lever arm. This is the direct acceptance check for the "translational constraint only, never rotational, never vertical" scope the constraint is deliberately limited to.

Documented limitation: nodal mass directly on a rigid-diaphragm-tied translation can't be represented by the lumped mass diagonal assemble_mass_diagonal returns — a real rigid diaphragm's tributary mass there would need an off-diagonal (rotational-inertia-at-the- master) term, which this crate's dynamics don't support yet. A clear panic, not a silently-wrong lumped mass, is the intended failure mode — same "loud, not silent" reasoning GeomTransf3::local_axes's degenerate-input asserts already use. (Models that go through validate, AnalysisBuilder, modal_analysis or TransientAnalysis get the same condition as a ModelError instead; see constraints/linear.rs.)

The classical "asymmetric rigid diaphragm" acceptance case: two lateral springs ("shear walls") at different offsets from the diaphragm's master (retained) node, tied to it via Domain3::rigid_diaphragm (default normal Axis3::Y, so the diaphragm plane is x-z — see Domain3::rigid_diaphragm's doc comment for the kinematics). A lateral load applied at the master node (the diaphragm's center) still induces rotation whenever the walls' combined stiffness isn't itself centered there — exactly the mechanism the lever-arm term exists for; an identity alias (what planar rigid_diaphragm/equal_dof do) could never produce this coupling.

ElementLoad values add and scale field by field (beam uniform, body force, edge traction, edge pressure), and expose a fixed 16-component layout via component(i), which is what element-load recorders index into.

Loads that do not fit their element (beam loads on continuum elements, continuum loads on a beam, edges out of range) are reported as model errors by validate, before any load is accumulated.

Body-force loads from several patterns on the same Quad4 add up with each pattern's load factor and scale: the displacement from split patterns equals that from one pattern carrying the summed load.

A column of n stacked quads, base fixed, self-weight as a body force: the base reaction is the total weight b t A, and the column compresses.

A patch test driven entirely by boundary edge loads (no prescribed boundary displacements) reproduces the exact constant stress field, for Quad4 (full and enhanced) and Tri3.

A mass-bearing element on a rigid-link slave cannot be lumped onto a diagonal mass vector; that is a ModelError, not a panic inside the mass assembly.

A rigid link between the end of a beam (master) and a Q4 corner (slave): every constrained mode shape reports the slave's motion through the constraint, equal to the master's plus the lever-arm term.

A Q4 panel with a frame element along its bottom edge sharing the panel's nodes: under a uniform axial stretch (nu = 0) the stiffness is E A_panel / L + E A_beam / L exactly. Proves activation and assembly across element kinds (the beam's rotation is an equation, the panel's is not).

A linear continuum model through every nonlinear path needs one corrector iteration (or none for the arc-length predictor): Newton in each tangent mode, with line search, and the arc-length integrator.

Cantilever strip: the fundamental frequency approaches Euler-Bernoulli theory from below (shear and rotary inertia lower it by about one percent at this slenderness), and the total mass is rho t A in each direction.

Undamped free vibration of a Q4 block under Newmark average acceleration conserves 1/2 v.M.v + 1/2 u.K.u.

Plane elements do not stiffen the rotation DOF, so a continuum model needs no rotational fixity, and a load on that rotation is a LoadOnInactiveDof error.

Constant-strain patch test: Tri3 elements on an irregular mesh with boundary displacements taken from a linear field must reproduce the field exactly at the interior nodes and a constant stress in every element, for plane stress, plane strain and orthotropic materials (tolerance 1e-12).

The same patch test for Quad4 on a distorted mesh, for both the full and enhanced formulations and for plane stress, plane strain and orthotropic materials: exact displacement field and constant stress (tolerance 1e-12).

Cantilever tip load against the Timoshenko tip deflection on a 10x2 mesh: the enhanced element is within 3% of the exact answer and at least 0.2 closer than the plain element.

Pure bending on a rectangular mesh: the enhanced Quad4 gives the exact beam-theory tip deflection for any mesh (1, 4 or 10 elements along the span), while the plain element is too stiff, and a single plain element locks (less than 70% of the exact answer).

Thick cylinder under internal pressure in plane strain with Poisson's ratio 0.4999 (nearly incompressible): the enhanced element stays within 1% of the Lame solution, while the plain element locks (more than 50% error).

MacNeal-Harder cantilever results, recorded (not asserted to be better than the plain element): rectangles are near beam theory, distorted meshes are not, for either formulation. The numbers are regression values and are compared with OpenSees' enhancedQuad in comparison/.

Thick-walled cylinder against the Lame closed-form radial and hoop stresses, for plane stress and plane strain. A coarse mesh is already within a few percent, and refining the mesh reduces the error by the expected factors.

The plain element locks in bending: with one element through the depth the tip deflection is far too small (documented, not hidden), and the ratio converges to the Timoshenko value at roughly second order under refinement.

Nearly incompressible plane strain (nu = 0.4999) on Cook's membrane. The plain element locks completely; the enhanced element, which is not a mixed formulation and carries no volumetric-locking guarantee, is observed to behave much better here and in the thick-cylinder test. Recorded as observations (the 64x64 enhanced result is the reference), not as a property of the formulation.

Same check for ElasticBeamColumn's axial mode (transverse bending DOFs are fixed here so this exercises the same k = E*A/L axial stiffness against the beam's form_mass, independent of the truss test above).

Zero damping (RayleighDamping::NONE) should match undamped SDOF free vibration u(t) = u0*cos(omega*t) exactly (to Newmark discretization error) — a sanity check that RayleighDamping::NONE really contributes nothing, isolated from the damped case above.

Spatial counterpart to dynamics/free_vibration.rs's truss_element_mass_matches_ sdof_closed_form_frequency — modal_analysis/TransientAnalysis generalized to the same <NDIM, NDOF, NId, E> profile as Domain/Analysis run through the real Domain3/Analysis3 stack rather than asserted by analogy. Every non-axial DOF at the free node is fixed, so this is a genuine SDOF (k = E*A/L, m = density*A*L/2, half the truss's total mass — the fixed node's half never enters the free-DOF mass diagonal) with the exact same closed form as the planar test.

Newmark + Rayleigh damping against the classical damped-SDOF free-vibration closed form. ZeroLength+Elastic (k=1) between a fixed ground and a node carrying Node::mass = 1 (m=1, so omega=1 rad/s), mass-proportional-only Rayleigh damping (alpha_m = 2*xi*omega, beta_k = 0) for an exact damping ratio xi = 5%, released from u0 = 1, v0 = 0.

Element-consistent lumped mass. A single Truss with a nonzero density, fixed at one end, has its total mass (density*area*length) split half to each node's translational DOFs (Element::form_mass) — since the fixed node's half never enters the free-DOF mass diagonal, the free node carries exactly half the truss's total mass. This is a genuine SDOF (stiffness k = E*A/L, mass m = density*A*L/2), so its fundamental frequency has an exact closed form: omega = sqrt(k/m).

Spatial Rayleigh-damped counterpart — same closed form and tolerance as dynamics/free_vibration.rs's newmark_rayleigh_damped_sdof_matches_closed_form_ free_vibration, run on a single spatial translational DOF (uy this time, not ux, so the two Newmark tests above don't both happen to exercise the same DOF index).

"3D ground motion": two independent GroundMotions active at once, one per translational direction (ux, uz), driving one spatial mass node whose spring stiffnesses differ per direction and which has no coupling between them (independent ZeroLength3 materials per DOF — see ZeroLength3's doc comment). Because the assembled system is diagonal, each direction's response must match the same single-direction step-response closed form dynamics/ground_motion.rs already verifies (u(t) = -(ag0/omega^2)*(1-cos(omega*t))), independently and simultaneously — the spatial generalization of "ground motion in more than one direction doesn't cross-talk between DOFs".

Spatial counterpart to dynamics/free_vibration.rs's newmark_undamped_sdof_ matches_closed_form_free_vibration — TransientAnalysis3 (Newmark stepping through Domain3) against the same undamped free-vibration closed form, u(t) = u0*cos(omega*t), released from rest at u0=1. Every DOF but ux at the mass node is fixed, isolating one spatial translational DOF exactly like the planar SDOF case.

Undamped SDOF (m=1, k=1, omega=1), at rest, under a constant ground acceleration ag0 starting at t=0 (LoadSeries::Constant — factor(t) = 1.0 for every t, so GroundMotion::acceleration is just ag0 throughout). Standard step-response closed form (e.g. Chopra): u(t) = -(ag0/omega^2) * (1 - cos(omega*t)). Same closed-form-vs-Newmark comparison style as dynamics/free_vibration.rs's newmark_undamped_sdof_matches_ closed_form_free_vibration, but forced (nonzero right-hand side) rather than free vibration — isolates that GroundMotion's effective force term (-M*ι*ag(t)) is wired correctly into both the initial- acceleration equilibrium and every Newmark step's f_eff.

GroundMotion's effective force (-M*ι*ag(t), mass-proportional) must be mathematically identical to applying an ordinary nodal LoadPattern whose reference load at the mass DOF is -m and whose series is ag(t) directly (load(t) = series.factor(t) * (-m) = -m*ag(t)) — the same physics, two different code paths (GroundMotion's direction_incidence vs. an ordinary pattern). Checked here with a LoadSeries::Path (piecewise-linear — an accelerogram shape), rather than re-deriving a closed form for a forced-vibration response to a nontrivial pulse: if both paths agree to near machine precision at every step, GroundMotion is correctly wired.

A cantilever's massless rotation must satisfy equilibrium through the Newmark effective stiffness, without adding artificial inertia. Compared step by step with the condensed SDOF (k = 3EI/L^3), under the same ground motion, to absolute tolerance 1e-10.

Rotations and axial DOFs with no assigned mass are statically condensed, not an error: a cantilever column with a lumped tip mass in the transverse direction only has omega = sqrt(3 E I / (m L^3)) exactly (the elastic beam-column's stiffness is the Euler-Bernoulli one).

Eigenvalues of a small known model match closed form. This is the classic 2-DOF "1-1-1-1" mass-spring chain (unit masses, unit spring stiffnesses in series): ground -k1- m1 -k2- m2, giving K = [[2,-1],[-1,1]], M = I. Its natural frequencies have an exact closed form in the golden ratio: omega = 1/phi and omega = phi, where phi = (1+sqrt(5))/2 — from the characteristic polynomial lambda^2 - 3*lambda + 1 = 0.

A node with a free DOF but no assigned mass makes the generalized eigenproblem singular (physically: a massless DOF has infinite natural frequency) — modal_analysis should report that, not silently divide by zero.

Asking for fewer modes than the model has free DOFs is the whole point of the Lanczos solver — a dense full-spectrum eigensolve can't do partial-spectrum extraction at all. A 5-mass chain (5 free DOFs) asking for just the lowest 2 modes should return exactly those 2, still matching this chain's true lowest frequencies (checked against a num_modes = 5 full solve of the same system).

The actual new capability: Algorithm::Linear forms its one effective tangent at step start — still fully elastic here, since the spring hasn't yielded yet at u_n — and never re-checks it for the rest of the step, even once the true (trial) state has crossed the ElasticPP spring's yield breakpoint. The resisting force element_local_force reads back is always evaluated through the material's own real law (Material::trial_stress_tangent, a pure function of committed history + current displacement, independent of which Algorithm chose that displacement) — so both runs report a force clamped to fy. What Algorithm::Linear actually gets wrong is the displacement itself: having solved against the stale elastic tangent for the whole step, its u doesn't satisfy the true (regime-updated) dynamic equilibrium the way the Newton corrector's converged u does — so the two algorithms must land on visibly different displacements once yielding is engaged mid-step, even though both "solve" without error.

docs/algorithms.md §6.1's load-bearing correctness check, run as an actual test rather than only hand-verified on paper: for a linear system, the new Newton-corrector arm (TangentStrategy::ReuseAtStepStart — form the effective operator once, at step start, same as the old closed form did implicitly) reproduces the old one-shot closed form's answer bit-for-bit — proving the restructure is a strict superset, not a behavior change, for the case that already worked. Same undamped SDOF free-vibration system dynamics/free_vibration.rs's newmark_undamped_sdof_ matches_closed_form_free_vibration already checks against the closed form; this test checks the two algorithms against each other instead.

Sanity check that the exact match above isn't an artifact of a specific point count or quadrature family — Lobatto (which includes the endpoints, unlike Legendre) must give the identical exact answer too, since the underlying integrand's polynomial degree doesn't care which family of points samples it.

DispBeamColumn3 (biaxial fiber-discretized, displacement-based) must exactly reproduce ElasticBeamColumn3's closed-form linear-elastic response in both bending planes plus axial and (decoupled) torsion — not approximately, exactly, to solver precision. Four corner fibers at (±hy, ±hz) reproduce EA, EIy, EIz exactly with zero product-of-inertia coupling (FiberSection3's four_corner_elastic_fibers_reproduce_ea_ eiy_eiz_with_zero_cross_coupling unit test checks this piece in isolation). DispBeamColumn3::strain_displacement's shape functions are the same cubic-Hermite/linear-axial fields ElasticBeamColumn3 is built from, so for constant EA/EIy/EIz any >=2-point Gauss rule integrates the (at most quadratic) integrand exactly.

DispBeamColumn (fiber-discretized, displacement-based) must exactly reproduce ElasticBeamColumn's closed-form linear-elastic response — not approximately, exactly, to solver precision. Two symmetric elastic fibers at y = ±sqrt(Iz/A), area A/2 each, reproduce EA = E*A and EI = E*Iz exactly (FiberSection's two_symmetric_elastic_fibers_reproduce_ea_ei_exactly unit test checks this piece in isolation). The element-level strain-displacement field (DispBeamColumn::strain_displacement) uses the same cubic-Hermite/ linear-axial shape functions as ElasticBeamColumn, so for constant EA/EI any >=2-point Gauss rule integrates the (at most quadratic) integrand exactly — the two elements' stiffness matrices must therefore be identical, not just close.

A fiber disp beam with two symmetric elastic fibers reproduces E·A/E·I exactly, so under the same uniform load it must match ElasticBeamColumn: same nodal displacements and same member end forces (the latter only if the load's fixed-end effect is subtracted identically).

Spatial counterpart: four fibers at (±h, ±h) give Iy = Iz; wx, wy and wz all nonzero on a member along global x.

A yielding DispBeamColumn cantilever under a uniform load, run with 1 and 8 elements and 3 and 5 Lobatto points, matches OpenSeesPy's tip deflection and rotation to a relative tolerance of 1e-6. The reference values were produced with OpenSeesPy using the same fiber section, integration rule and 10 load steps.

Spatial counterpart to elements/elastic_beam.rs's simply_supported_beam_udl_ matches_closed_form_end_rotation — ElasticBeamColumn3's new local wy/wz uniform transverse load (ElementLoad3::uniform, the spatial generalization of planar ElementLoad::Uniform; see the 3D beam-load design), exercised through the full Domain3/Analysis3 stack with a member aligned along global x (vec_xz = [0,0,1] makes local [x,y,z] equal global [x,y,z] exactly, isolating the load formula itself from GeomTransf3's rotation — same isolation strategy as elastic_beam_column.rs's spatial_tests).

A 3D ElasticBeamColumn3 cantilever, run through the real Domain3/Analysis3 stack (not just the element-level checks in elastic_beam_column.rs), matching biaxial bending, axial, and torsion deflections against textbook closed forms simultaneously — the "axial, torsional, and both bending deflections of rotated cantilevers" acceptance criterion from the 3D design notes (member here is axis-aligned rather than rotated, since elastic_beam_column.rs's own tests already isolate the vec_xz transform on a skew member; this test's job is the Domain3 assembly path, not the transform).

Several loads on one element in one pattern sum rather than the last one winning (OpenSees semantics).

Axial + transverse UDL on a cantilever: tip ux = wx L² / 2EA, tip uy = wy L⁴ / 8EI, and the member end forces equal the statics result — the free end carries nothing, the fixed end carries the whole load.

A single ElasticBeamColumn spanning a simply-supported beam, under a uniform transverse element load, matches the classical closed-form end rotation theta = w*L^3 / (24*E*I).

Spatial counterpart: a member along global x with vec_xz = [0,0,1] has local axes equal to global, so wx is plain axial.

Zero load must still assemble (the wy == 0.0 && wz == 0.0 fast path in ElasticBeamColumn3::form_load_vector), and a pattern with no element load attached at all must behave identically to one whose load is exactly zero — the spatial counterpart of the implicit "no load" coverage every other element-load test gets for free by simply not calling add_element_load.

GeomTransf::PDelta sanity check: with zero axial force it must reduce exactly to Linear (the geometric-stiffness correction is a function of axial force, so it vanishes at N=0), and under a compressive axial force it must soften the bending stiffness relative to Linear (the intended P-Delta direction — see beam.rs's geometric_stiffness doc comment).

GeomTransf3::PDelta3 sanity check, the spatial analogue of elements/elastic_beam.rs's planar pdelta_matches_linear_at_zero_axial_force_and_ softens_under_compression (see its doc comment for why each case runs as two LoadControl increments rather than one): at zero axial force PDelta3 must reduce exactly to Linear3, and under compression it must soften the bending stiffness relative to Linear3.

DispBeamColumn::fiber_responses after a converged pure-axial-load step must reproduce, fiber by fiber, the exact closed-form strain/stress a two-symmetric-elastic-fiber section gives — cross-checked against fiber_section.rs's own two_symmetric_elastic_fibers_reproduce_ea_ei_ exactly, here read back through the element rather than the bare FiberSection: a symmetric section under pure axial extension has zero curvature, so every fiber (regardless of its y) should show identical strain == eps0 == axial_disp/length and stress == e*eps0.

ForceBeamColumn::fiber_responses after a converged nonlinear step: summing stress*area back up across every fiber (the same definition FiberSection::trial's N uses) at each integration point must reproduce that point's true axial force (~0 here — pure transverse tip load, no net axial anywhere along a straight cantilever) — a self- consistency check that fiber_responses reads the same e_commit state local_force/commit already rely on, not stale or mismatched data.

The two tests above both use doubly-symmetric fiber layouts with zero product of inertia (Iyz = 0), so neither exercises FiberSection3::trial's eiyz tangent term or the resulting cross-coupling between the two bending planes that a real, non-doubly-symmetric section has. This is the spatial analogue of elements/force_beam.rs's asymmetric_elastic_section_matches_hand_ derived_closed_form, generalized from a 2x2 to a 3x3 section flexibility.

ForceBeamColumn's basic-force/section coupling (the element flexibility's off-diagonal terms) must be exercised too, not just the symmetric-section case above where axial/bending decouple.

For a prismatic elastic member, ForceBeamColumn3 is exact regardless of point count — same property elements/force_beam.rs checks planarly, now exercising both bending planes plus axial and (decoupled) torsion. This is the actual verification for ForceBeamColumn3's basic system (v4/v5's rotation-coefficient sign flip relative to v2/v3) — see that type's doc comment for why this test, not inspection, is the source of truth.

ForceBeamColumn's state-determination Newton loop must actually engage material nonlinearity (not just reproduce the elastic case), and its q_commit/e_commit fields must correctly carry converged history across separate Analysis::step() calls, the same property materials/state.rs's permanent-set test checks for ZeroLength/ElasticPP.

For a prismatic elastic member, a force-based element is exact regardless of point count — the textbook property that motivates the whole force-based formulation. Same structure as elements/disp_beam.rs's equivalent check: build the identical cantilever both ways and require the tip deflection to match ElasticBeamColumn's closed form to solver precision, not just approximately.

ForceBeamColumn3's state-determination Newton loop must engage material nonlinearity in both bending planes independently (not just reproduce the elastic case, and not just one plane) — the spatial analogue of elements/force_beam.rs's elastic_pp_section_softens_past_yield_and_shows_permanent_set_on_ unload. A doubly-symmetric eight-fiber section (four fibers on each of the +y/-y/+z/-z faces) yields independently under a y-only or z-only tip load, each past its own p_yield.

A fiber force beam with two symmetric elastic fibers reproduces E·A/E·I exactly, so under the same uniform load it must match ElasticBeamColumn: same nodal displacements and same member end forces (the latter only if the load's fixed-end effect is subtracted identically).

Spatial counterpart: four fibers at (±h, ±h) give Iy = Iz; wx, wy and wz all nonzero on a member along global x.

Gravity UDL ramped on a yielding cantilever, frozen with hold_pattern_constant, then a tip load pushed under displacement control — the two-phase shape pysees models take. The frozen element load must stay in the elements' section forces through the second phase's fresh Analysis (whose pseudo-time restarts at 0) and the committed state carried across. References: OpenSeesPy forceBeamColumn, loadConst, DisplacementControl.

References are OpenSeesPy 3.8 forceBeamColumn (Lobatto, eleLoad -beamUniform) with the identical model.

DispBeamColumn (two-fiber elastic section) end forces for a horizontal cantilever with a tip load match the statically determinate result: shear equals the load and the fixed-end moment equals the load times the length.

Isolates the local-axis rotation itself (as opposed to the tests above, which use a horizontal member where local coincides with global and so never actually exercise the rotation). A global load applied exactly along a skew member's own axis must decompose to pure axial local force — ElasticBeamColumn's local stiffness has zero coupling between its axial row/column and its bending rows/columns, so any nonzero local shear/moment here means the rotation itself (not the element formula) has a sign or axis error.

ElasticBeamColumn local end forces for a horizontal cantilever with a tip load match nodal equilibrium: shear equals the load and the fixed-end moment equals the load times the length.

Spatial counterpart, exercising ForceBeamColumn3::local_force's cached value (including its decoupled torsion term) against full 3D nodal equilibrium — same technique as the planar cantilever checks above, extended to all six components at each end. Reuses the load case from elements/force_beam.rs's exactness test (axial, biaxial shear, torque all simultaneously) so this also implicitly cross-checks that test's already-verified tip displacements are consistent with these reactions, not just internally self-consistent.

The highest-risk case: ForceBeamColumn::local_force reads a value cached at commit time (to avoid re-running the Newton state determination), not recomputed fresh like every other element here — a caching bug (stale value, wrong sign in the cached expression) wouldn't be caught by anything that doesn't actually call commit.

Truss local forces for an axially loaded bar equal the applied load with opposite signs at the two nodes, [-N, 0, 0, N, 0, 0].

ZeroLength local forces for a spring loaded at one node equal the applied load with opposite signs at the two nodes, [-F, 0, 0, F, 0, 0].

Elements of different sizes share nodes in one assembly.

A four-node element's lumped mass lands mass / 4 on ux and uy of every node, and its equivalent load is scaled by the pattern factor and seen by reaction only at the nodes it touches.

Two springs in series, fixed at one end and loaded at the other: u1 = P/k, u2 = 2P/k. The element has three nodes and only a compact ux layout, and its recorded local force is its own three-entry vector.

Spatial counterpart to elements/truss.rs's acceptance case, run through the real Domain3/Node3/Element3::Truss3/Analysis3 architecture (the spatial instantiation of the now-generic Domain/Analysis — see their doc comments) — a symmetric tripod of three truss members meeting at one free apex node, each dropping to a fixed base support spaced 120 degrees apart — the standard space-truss case with a clean closed form, and genuinely exercises all three translational DOFs at once (unlike a single truss, which only stiffens the direction along its own axis and leaves a singular system in the other two — that's not a valid spatial model on its own).

A 2-node truss (L=100, A=2, E=30000, P=50) gives the closed-form displacement P*L/(A*E) = 0.0833333333 through Domain/Analysis.

A ZeroLength + Ent ("no tension") element under a compressive load. The whole step stays within Ent's single linear (engaged) regime, so Algorithm::Linear (no Newton iteration) is exact.

Domain's snapshot-and-restore: a step that fails to converge must leave the domain exactly as it was before the attempt, not partway through a discarded Newton iteration. NormDispIncr with a single permitted iteration can never converge here (the one correction is the full elastic displacement, far above tol), forcing FailedToConverge deterministically — after a correction was applied to the domain — without needing a contrived numerically-hard system. (A zero iteration budget is rejected outright as AnalysisError::InvalidOption.)

Material's trial/commit split (see its doc comment) and Domain's snapshot-and-restore-on-failure, needed by fiber sections and the full material catalog, which depend on real path-dependent state.

For each uniaxial material (except ElasticPP, see below), trial strain after a commit at the same strain must return the same stress and tangent as the committed trial did, along a long reversing strain path in both signs. OpenSees materials behave this way, and displacement control, element state determination and arc-length seeds all evaluate at the committed point.

OpenSees' ShellDKGT integrates its self-weight with w * xsj instead of 0.5 * w * xsj (the mass and stiffness use the latter), applying twice the weight. Carapace applies the correct weight, so the OpenSees run with -selfWeight 0 0 -9.81 equals Carapace with twice the body acceleration (0, 0, 2 * 9.81).

Displacements, clamp reactions and the first triangle's four Gauss-point resultants.

The first element's committed strain and resultants at its four Gauss points (OpenSees' eleResponse(1, 'stresses') order and sign convention).

A pressure on a distorted quad is a consistent load: the clamp reactions sum to -p A e3, with e3 the normal given by the node order (here up the tilted plane).

A column framing into a shell corner: the shell stiffens all six DOFs, so the beam's rotations and the shell's share one node with no extra constraint.

Self-weight loads each node with rho h times its tributary area times the body vector. OpenSees' ShellMITC4 applies the opposite sign (-rho h b), so the reference run's -selfWeight 0 0 -9.81 is body(0, 0, 9.81) here.

Displacements and clamp reactions of two distorted, tilted quads under point loads.

A quad with one node lifted out of the plane: the shell is treated as flat in its mean frame, exactly as OpenSees does, so the two agree.

The Scordelis-Lo barrel vault roof (quarter model, 8x8 mesh) against OpenSees, and against the published vertical deflection of 0.3024 at the midpoint of the free edge: a mesh-converged value of about 0.30 (0.2965 at 12x12 in OpenSees).

A simply supported square plate under uniform pressure: the centre deflection is 0.004062 p a^4 / D (thin-plate Navier series).

The fundamental frequency of a simply supported square plate is 2 pi^2 / a^2 sqrt(D / (rho h)). Carapace lumps the shell mass (OpenSees uses the consistent mass), so this is a closed-form check, not an OpenSees match.

Problems only detectable at run time reach the session as structured detail. With no reference load, decoding succeeds and the first advance finishes with ZeroLoadSensitivity in outcome.error.

Invalid arc-length settings in the wire format (radius bounds, scales, tolerances and so on) are rejected at decode time with InvalidAnalysisOption naming the offending field.

The 3D profile decodes arc-length settings too: a linear ZeroLength3 spring continued by arc-length stops exactly on the requested load-factor target.

A snap-back run through the wire format. Load factors rise and then fall (they are not monotonic), samples are stored in sample-index order regardless, and the displacement stop criterion ends the stage before its step cap.

A stage that ends on a displacement target reports the stop reason and that it landed exactly. The default convergence test works, and an explicit combined convergence test decodes and runs as well.

The step budget of advance is only a scheduling knob: running one step at a time produces exactly the same accepted samples as running the whole stage in one call.

core::Domain3::rigid_diaphragm_about through the spatial path (RigidDiaphragmTable): reuses the skew-truss closed form from decodes_a_skew_truss3_and_matches_the_closed_form_axial_elongation to give the retained node a known, nonzero translation in both in-plane axes (x/z, perpendicular to normal = Y) while its rotation about normal stays fixed at zero — so the lever-arm term in Domain3::rigid_diaphragm_about's affine tie vanishes and the constrained node (which carries no element of its own) must reproduce the retained node's ux/uz exactly.

core::Domain::rigid_diaphragm (RigidDiaphragmTable) — same setup as the equal_dof test above, but tying two otherwise-elementless nodes' ux to the retained node in one call, proving the table's sparse per-row constrained list decodes correctly.

core::Domain::equal_dof through the spatial path (EqualDofTable) — same shape as wire/elements.rs's own equal_dof test, just against Node3Ids: node 2 carries no element of its own and is free only in ux, tied to node 1's ux.

core::Domain::equal_dof (EqualDofTable, ConstraintHandler:: Transformation picked automatically by session::start_current_stage once Domain::has_mp_constraints() is true): node 2 carries no element of its own and is free only in ux, tied via equal_dof to node 1's ux — so its recorded displacement must exactly equal node 1's, which itself matches the plain closed-form truss elongation.

A small panel (two Quad4 and a Tri3) decoded from the wire format and run through a session gives the same nodal displacements and Gauss-point strains and stresses as the same model built directly with carapace-core.

Malformed continuum tables are structured decode errors: unknown material or node indices, rows with the wrong number of nodes, and other shape problems, each reported with the table and row.

Continuum tables (quads, triangles, planeMaterials) and continuum recorders are rejected in a 3D input with TableNotInProfile, since those elements are 2D only.

Gauss-point recorders are checked against the element: Quad4 has 4 points and Tri3 has 1, and an out-of-range point or component is InvalidGaussPoint or an invalid-component error rather than a silent empty recording.

Wire-format version of the body-force summation: several body loads on one Quad4 across patterns with different series and scale factors sum to the same displacement as one pattern with the total load.

The continuum tables, loads and Gauss-point recorders survive a serialize/deserialize round trip unchanged, with the expected camelCase JSON shape (planeStress, edgePressure, gaussPoint), and still decode.

Element loads of the wrong kind for their element (a beam load on a continuum element, continuum loads on a beam) and out-of-range edge indices are decode errors, and nothing is accumulated.

A cantilever ElasticBeamColumn under a local-axis uniform load (wx axial + wy transverse) driven through the wire tables: tip displacements match the closed forms, and the element-force recorders report the member end forces (statics: the fixed end carries the whole load, the free end none), which only holds if recorders account for the element load.

elementKind: "dispBeamColumn" accepts a uniform element load: a two-fiber elastic section reproduces E·A/E·I, so the tip deflection is the closed form and the recorded member end forces are plain statics (fixed end carries the load, free end nothing).

elementKind: "forceBeamColumn" accepts a uniform element load: a two-fiber elastic section reproduces E·A/E·I, so the tip deflection is the closed form and the recorded member end forces are plain statics (fixed end carries the load, free end nothing).

Element loads on a kind core doesn't apply them to are rejected up front rather than silently dropped.

Smoke test for the whole node/material/element/pattern/sequence pipeline: the truss case (core/tests/elements/truss.rs's closed form), built entirely from wire-format tables instead of direct core calls.

The closed-form axial-stiffness case (core/tests/m17's skew-truss analogue, core/tests/elements/truss.rs's straight-bar analogue), decoded entirely from 3D wire tables: a 3-4-5 skew truss should reproduce the same axial elongation a hand computation gives, exercising Truss3's direction-cosine geometry through the decoder rather than just core directly.

ZeroLength3's friction coupling (ZeroLengthTable::friction), the spatial counterpart of wire/elements.rs's decodes_a_zero_length_with_friction_coupling: one normal DOF (ux) and two independent shear DOFs (uy, uz — Friction3::shear_dofs), each run through the Coulomb return map independently against the shared normal force (core/src/model/elements/zero_length.rs's friction3_shear_axes_slide_independently_against_shared_normal_force unit test covers the same physics directly against core).

ZeroLengthSection3 (core::ZeroLengthSection3, wired via ZeroLengthSectionTable): reproduces closed-form axial stiffness from a four-corner symmetric fiber section, the spatial counterpart of wire/elements.rs's own zero-length-section test.

ZeroLengthSection (core::ZeroLengthSection, wired via ZeroLengthSectionTable): reproduces the same closed-form axial/moment stiffness core's own zero_length_section_reproduces_symmetric_ea_ei unit test checks directly against FiberSection, here decoded entirely from wire tables with a two-fiber symmetric section and no independent uy spring.

ZeroLength's friction coupling (ZeroLengthTable::friction), driven through the decoder rather than directly against core::Friction (see core/src/model/elements/zero_length.rs's own friction_sticks_below_yield_surface/friction_slides_past_yield_surface unit tests, which this exercises end to end from wire tables): a normal spring in compression plus a friction-coupled shear DOF, checked both below and past the Coulomb yield surface.

ZeroLengthSectionTable::orient: local x = global Z (yp = global X), so the section's axial stiffness answers a uz load.

ZeroLengthSectionTable::orient: the section's axial direction turned onto global y (OpenSees -orient 0 1 0), so a uy load meets the same closed-form axial stiffness the unoriented test above gets in ux.

Material::Hysteretic/Material::Pinching4 (materials.rs's newly added arena entries): both decode without error and, for the symmetric-envelope well-within-elastic-range case checked here, behave like a plain elastic spring — a decode-plumbing smoke test, not a re-check of either material's own hysteresis logic (that lives in core/src/model/materials/{hysteretic,pinching4}.rs's unit tests).

Bad orient rows are decode errors, not silent global axes: a zero vector, a 2D vector leaving the xy plane (x3 != 0), and a row past the table.

DOF activation through the wire: a model that leaves a truss's rotations unfixed (the compiler no longer has to fix them) solves, and a nodal load on a DOF nothing resists comes back as a structured error from advance, not a panic.

Composite materials refer to arena entries by index; the probed material may be any of them, and a Gap anywhere in the arena is still rejected.

A Concrete01 probe has no tension capacity (zero stress at positive strain), goes into compression with softening past the peak, and unloads to zero stress at zero strain.

An elastic probe follows a prescribed strain history through zero, positive and negative strains: stress equals E times strain.

An elastic-perfectly-plastic probe keeps its committed plastic strain across targets: strains of +0.002, -0.002 and -0.0005 give stresses of +100, -100 and +50 (elastic unloading from the permanent set).

Probe errors are structured: an unsupported material (Gap) is UnsupportedMaterial, a NaN target is invalidTarget, and a rejected target leaves the committed state unchanged.

Applying the same target strain repeatedly does not advance material state: the elastic-perfectly-plastic probe returns the same stress each time.

reset discards the history, and the configured initial strain is applied: with an initial strain of 0.5, a target of 1.0 and later 0.5 give stresses 10 and 5 for E = 10.

Steel02 and Concrete02 are probe-able now.

An out-of-range ModeShape.mode records nothing this call, rather than erroring — decode can't validate it upfront (a mode index isn't a table row; it's only meaningful once modal_analysis has actually run and produced however many modes it was asked for).

The spatial SDOF-truss closed form (core/tests/dynamics/free_vibration.rs's spatial_truss_mass_matches_sdof_closed_form_frequency_via_modal_analysis3), decoded entirely from 3D wire tables — proves Modal/ModeShape work through the 3D decode path, not just the 2D one already checked in wire/elements.rs.

The golden-ratio closed form (core/tests/dynamics/modal.rs), decoded entirely from wire tables: a Modal stage's mode frequencies come back via ModeShape recorders, whose "time" component (StepOutcome:: load_factor's doc comment) is the mode's own frequency rather than a pseudo-time or load factor.

Session::modal_results returns frequencies, full-node shapes and participation for a finished Modal stage — no recorders needed. For the 2-mass chain every mode's effective mass sums to the total x mass (all modes requested), shapes are M-normalized and sign-fixed.

A rigid-diaphragm slave has no equation of its own, so its mode-shape components must come from its constraint: reading them through equation_of (as the session used to) reported a slave that never moves. Mass and a rotational spring sit on the retained node; the translational springs sit on the slave, so every mode moves it.

The general linearConstraints table, written as the three equations of a 2D rigid link, matches the same constraints added natively with add_constraint, and agrees with the rigid link to rounding.

The rigidLinks table decodes to the same model as a native 2D rigid_link: identical results from the same loads, and the slave node really moves with the master (including the rotation lever-arm term).

The rigidLinks table decodes to the same 3D model as a native rigid_link: six springs on the slave node and a general load on the master give identical results, including rotation-translation coupling through the offset.

A table that belongs to the other profile is rejected: 3D beam-column tables in a 2D input, and 2D beam-column tables in a 3D input, give TableNotInProfile.

Element loads and recorders that refer to an element kind of the other profile (a 3D beam in a 2D input, or the reverse) are rejected with ElementKindNotInProfile.

Element force and element load recorder components are bounded by the profile: the last valid component decodes, and one past it is InvalidRecorderComponent (2D forces have 6 components and 3D have 12).

Omitted tables decode as empty: a header-only input is a valid empty model in both profiles, and a truss model written with only the shared tables (every other table left out of the JSON) decodes and solves.

Rows whose shape depends on the profile are validated: friction takes one shear DOF in 2D and two in 3D, and orientation and other per-row data are checked, each failure reported as InvalidRow with the table and reason.

Recorder DOFs are bounded by the profile: DOF 3 does not exist in 2D (InvalidDof), while DOF 5 is valid in 3D.

An ndm other than 2 or 3 is rejected with UnsupportedNdm before any session is built.

A populated 2D and 3D CarapaceInputV1 survives serialization to JSON and back unchanged, covering friction, orientation, constraints and the rest of the tables.

ndm values 0, 1, 4 and 255 are each rejected with UnsupportedNdm.

An out-of-range Fiber.point/fiber records nothing this call, and a Fiber recorder aimed at a non-fiber element kind (Truss, here) records nothing either — both unresolved-by-runtime-state cases, same graceful-skip handling ModeShape's out-of-range mode gets, since neither can be checked before the analysis actually runs.

The ElementLoad recorder reports the load an element carries at each sample's pseudo-time: ramped by its pattern's factor during the stage that ramps it, then constant once the pattern is held — what a consumer needs to recover member internal-force diagrams from the recorded end forces.

The DispBeamColumn pure-axial closed form (core/tests/ elements/fiber_responses.rs's own disp_beam_column_fiber_responses_match_hand_ computed_strain_and_stress), decoded entirely from wire tables: a Fiber recorder on each of a symmetric section's two fibers must read identical strain/stress (pure axial extension, zero curvature).

The fixed-free truss closed form (core/tests/analysis/reaction.rs's own fixed_free_truss_reaction_exactly_opposes_the_applied_load), decoded entirely from wire tables: a Reaction recorder at the fixed support must read exactly the negative of the applied tip load.

A 3D ElasticBeamColumn3 cantilever with a tip load, decoded from the wire format, reports local end forces through an element force recorder that match nodal equilibrium (shear equals the load and the fixed-end moment equals the load times the length).

The second recorder kind (results-storage-indexeddb.md's "several more types of recorders" plan): an ElementForce recorder alongside a NodeDisp one, on a horizontal cantilever ElasticBeamColumn — a statically determinate case, so the expected local force at both recorded components is plain nodal-equilibrium statics (the same technique core/tests/elements/local_force.rs uses), independent of the element's own stiffness formulation. Also proves node and element batches coexist correctly in one advance() call's recorder_batches, each keyed by its own recorder_index.

Shells are 3D only; a shell load targets shells only; bad sections, indices and recorder components are structured errors.

The tilted patch decoded from the wire reproduces OpenSees' displacements, with and without self-weight, and the first element's Gauss-point resultants.

The tables serialize with the expected camelCase shapes and round-trip.

A shell3s table in a 2D model is rejected, and its section index is checked.

A pressure through the wire is the same load as the native engine's: the clamp reactions of a fully clamped quad sum to p A along the normal.

A triangle patch decoded from the wire format reproduces OpenSees' ShellDKGT displacements and the first triangle's resultants, and the table survives serde.

Algorithms use tagged objects; Newton settings default to the current tangent.

The first required case: a 2D fiber-section cantilever runs gravity (LoadControl), freezes it, then a displacement-controlled lateral pushover — built the same way core/tests/elements/force_beam.rs builds and checks a ForceBeamColumn cantilever, but assembled entirely from decoded wire tables. Elastic-range and post-yield behavior must agree with that native acceptance test, and gravity's frozen axial displacement must survive the pushover stage untouched (core/tests/analysis/load_patterns.rs's same check, here across a decoded multi-stage AnalysisSequence).

header.recordInitial adds each static stage's initial conditions as its first sample: load factor 0 and the state the stage inherits (zero for the first, the first stage's end for the second). Without it a stage's samples are only its steps.

Malformed accelerograms are decode errors, never interpolation panics.

Without a hold, the same pattern ramps again from zero after a Reset.

A Reset stage reverts displacements to the as-built state (a later stage starts from zero, not from where the previous one ended). Like OpenSees' reset, a pattern frozen by holdPatternsAfter stays frozen at its final factor: the next stage applies it in full from its first step.

Nonlinear equilibrium must be the same across each configurable solver.

Rayleigh-damped free vibration (core/tests/dynamics/free_vibration.rs's SDOF case), decoded from a Transient stage: matches the closed-form damped free-vibration displacement after a known number of Newmark steps.

docs/arclength.md §5/§10 step 2: bordered fill and factor time on a representative frame, against the n-DOF supernodal LU the other integrators use. Not a pass/fail test — run with cargo test --release -p carapace-core bordered_fill -- --ignored --nocapture.

Equation numbers are assigned to free, unconstrained DOFs in node insertion order; an identity-tied DOF shares its retained DOF's equation; a fixed retained DOF leaves its tied DOF without one.

A 3D rigid diaphragm: the slave's in-plane translations are affine in the master's translation and rotation about the normal, with the lever-arm coefficients, and the slave has no equation of its own.

A skew 3D truss cantilever: end load projected onto the bar axis should reproduce simple axial-bar elongation, exercised through the full Domain3 assembly/equation-numbering path (not just Truss3 in isolation, which truss.rs's own tests already cover).

A cantilever along global x with vec_xz = [0, 0, 1] (global z), which makes local [x, y, z] = global [x, y, z] exactly (R is the identity) — isolates the local stiffness formula itself from the GeomTransf3 rotation, which transform.rs's and truss.rs's own tests already cover for the transform-only case. With node_i fully fixed, the free-DOF system reduces to local_elastic_stiffness's [6..12, 6..12] block applied directly (no rotation needed), so tip displacements can be checked against textbook cantilever closed forms for axial, biaxial bending, and torsion simultaneously (all four modes are decoupled in a prismatic doubly-symmetric section).

The same cantilever driven through the full form_tangent_and_ resistance (transform included, not just the local block) with a skew member and a non-trivial orientation, checked by round-tripping: applying the closed-form local displacement (rotated into global coordinates) must reproduce the applied global load exactly, proving GeomTransf3/the local stiffness compose correctly rather than being separately-plausible but inconsistent.

Out of compression (tension, per this codebase's sign convention), yield_force clamps to 0: any nonzero shear displacement slides immediately, with only the post-slip hardening term surviving.

ZeroLength3 with one normal DOF and two independent shear DOFs — each slides/sticks independently against the same normal force with no cross-talk between the two shear axes (the absence of coupling that distinguishes this from the deferred, circular- interaction-surface model).

Mirrors elastic_pp_remembers_permanent_set_after_commit (elastic_like.rs): slide past the yield surface, commit, partially unload — the response must be elastic from the new committed slip, not from zero.

Past the yield surface, V follows the bilinear-kinematic-hardening return map (Friction::evaluate's doc comment): V = b*trial + (1-b)*yield_force*sign(trial), tangent == b*k0.

Below the yield surface, friction is a plain elastic spring: V == k0 * shear_rel, tangent == k0.

The same shear displacement against two different normal-direction states: shear resistance depends on axial load level, not just a generic plasticity check — a lighter normal force slides at the same shear displacement a heavier one still sticks at.

local x = global Z, local y = global X, local z = global Y: so local rx is global rz — rotations ride the same frame as translations.

45 degrees: a unit global ux is cos 45 of local x, so the force splits equally between global x and y, and K stays consistent with the resistance (linear material: r = K u).

local x = global y (a 90 degree turn about z): a spring on dof 0 must resist relative uy, and nothing along global ux.

The most important test here, and the easiest place to get a sign or chain-rule factor wrong: perturb the normal DOF's relative displacement by a small h and confirm the analytical k[shear_dof, normal_dof] block matches dV/d(normal_rel) by finite difference while sliding — validates Friction::evaluate's d_force_d_normal (and the chain rule through the normal material's own tangent in form_tangent_and_resistance) directly, rather than trusting the derivation by inspection.

Proves the Material enum's dispatch generalizes to ZeroLength across every material variant and regime (elastic, plastic plateau, open gap, closed gap, tension, compression) by driving the element directly off manually-set node displacements — independent of Analysis/Algorithm, which is linear-only here (no Newton iteration) and so can't itself resolve equilibrium across a material's nonlinear regimes in one step.

ZeroLength3's spatial counterpart, exercising a rotational DOF (index 3, SpatialDof::Rx) in addition to a translational one — the planar ZeroLength test above only ever touches dof 0.

ZeroLengthSection3 analogue: an rx torsion spring alongside the section's biaxial axial-moment response — the only way this element gets torsional stiffness at all (see the type's doc comment).

ZeroLengthSection3: four corner elastic fibers reproduce EA, EIy, EIz (see fiber_section.rs's four_corner_elastic_fibers_reproduce_ea_eiy_eiz_with_zero_cross_coupling) routed through the element's B-matrix mapping onto [ux, ry, rz]; uy/uz/rx — DOFs the section has no resultant for — stay zero.

A uy spring alongside the section is additive and uncoupled: it contributes independently to k/r on top of (not instead of) the section's coupled axial-moment response.

An off-centroid single fiber couples axial and moment response (k_section[0][1] != 0) — something ZeroLength's independent per-DOF materials can never produce, since each of its directions is evaluated against its own material in isolation.

A section commit propagates into the element's subsequent trial response, the same commit/trial split Material and ZeroLength already rely on — proves ZeroLengthSection::commit actually drives FiberSection::commit (not just recomputing eps0/kappa and discarding them).

ZeroLengthSection: two symmetric elastic fibers reproduce the closed-form EA/EI (already validated directly against FiberSection::trial in fiber_section.rs's two_symmetric_elastic_fibers_reproduce_ea_ei_exactly), now routed through the element's B-matrix mapping onto [ux, rz].

FiberSection3 biaxial analogue of two_symmetric_elastic_fibers_ reproduce_ea_ei_exactly: four corner fibers at (±hy, ±hz) reproduce EA, EIy, EIz exactly and give zero product-of-inertia coupling (dMz/dky / dMy/dkz = 0) by symmetry — verifying the eps0 - y*kappa_z + z*kappa_y strain field and the N/Mz/My sums independently of any element that will later drive this section.

Nonlinear composite check: a real reinforced-concrete-style section — one Steel01 rebar layer plus two Concrete01 layers — pushed past first yield/cracking and then partially unloaded. No closed form exists for a nonlinear composite section (unlike the elastic case above), so each state is checked against a hand computation: evaluate every fiber's Material directly at that fiber's own strain and sum N = sum(stress*area), M = -sum(stress*area*y) — the same definition FiberSection::trial uses, but computed independently, fiber by fiber, outside it.

OpenSees-style accelerogram bounds, interpolation and useLast; exact arithmetic.

Test 2: state 1 rides the 6-point positive envelope. Checks every real breakpoint (1-4), a midpoint of every real segment, and the extrapolated point-5 segment beyond strain4p.

Test 4: the same reversal, but with pinching parameters chosen to drive one of get_state3's degenerate-geometry fallbacks — the "linear unload-reload path expected" branch, taken when the constructed segment from point 1 to point 2 is stiffer than kmax (the greater of the unload stiffness and the damaged negative elastic stiffness, both 1000 here).

Test 1: state 0 (NearOrigin) gives the synthesized near-origin point's slope exactly. SetEnvelope puts that point at u = 1e-4*strain1p with stress u*k, k = max(stress1p/strain1p, stress1n/strain1n) = 1000, so the state-0 tangent is exactly 1000 — the same slope as the first real backbone segment, but arrived at through an entirely different code path.

The Trilinear3 -> Trilinear4 transition, i.e. reversing again mid-reload. Exercises the one getstate branch that both refreshes the positive damaged envelope and rebuilds the bracket from the committed point, and confirms the resulting state-4 path is anchored at that reversal point.

Test 3: a full reversal off the positive envelope into state 3, checked against a hand-walked get_state3 trace that takes the clean trilinear path — no degenerate-geometry fallback fires.