Enum StageSpec 

pub enum StageSpec {
    Static {
        id: String,
        steps: u32,
        integrator: IntegratorSpec,
        algorithm: AlgorithmSpec,
        convergence: Option<ConvergenceSpec>,
        hold_patterns_after: Vec<u32>,
    },
    Modal {
        id: String,
        modes: u32,
    },
    Reset {
        id: String,
    },
    Transient {
        id: String,
        steps: u32,
        dt: f64,
        damping: DampingSpec,
        ground_motions: Vec<GroundMotionSpec>,
        algorithm: AlgorithmSpec,
        convergence: Option<ConvergenceSpec>,
    },
}

Variants

Static

Fields

id: String

steps: u32

integrator: IntegratorSpec

algorithm: AlgorithmSpec

convergence: Option<ConvergenceSpec>

hold_patterns_after: Vec<u32>

Indices into LoadPatternTable to freeze (via Domain::hold_pattern_constant) at this stage’s final load factor once it completes.

Modal

A single eigenvalue solve (core::modal_analysis) for the domain’s current state — not iterative like Static/Transient, so this stage always takes exactly one advance() step regardless of the caller’s step budget (decode.rs’s compile_stages hardcodes steps: 1 for it). modes is the number of lowest-frequency modes to compute (1..=free_dof_count).

Fields

id: String

modes: u32

Reset

Reverts the model to its initial state (OpenSees reset): displacements, velocities and every element/material history return to their as-built values and time to 0. Like OpenSees, it does not undo holdPatternsAfter freezes (loadConst): a held pattern stays applied at its frozen factor, so a later stage sees that load in full from its first step; patterns that were not held ramp again from 0. Load patterns and their loads stay defined. Takes no steps and records nothing.

Fields

id: String

Transient

Newmark-beta time-history analysis (core::TransientAnalysis, fixed at the unconditionally-stable “average acceleration” parameters — see its own doc comment). steps fixed-size dt increments; ground_motions (zero or more) each add a uniform inertial excitation along one axis, on top of whatever LoadPattern reference loads are already active (e.g. a preceding Static stage’s frozen gravity).

Fields

id: String

steps: u32

dt: f64

damping: DampingSpec

ground_motions: Vec<GroundMotionSpec>

algorithm: AlgorithmSpec

Omitted algorithms preserve the original linear Newmark solve.

convergence: Option<ConvergenceSpec>

Implementations

impl StageSpec

pub fn id(&self) -> &str

Trait Implementations

impl Clone for StageSpec

fn clone(&self) -> StageSpec

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for StageSpec

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for StageSpec

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for StageSpec

fn eq(&self, other: &StageSpec) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for StageSpec

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for StageSpec

impl Tsify for StageSpec

const DECL: &'static str = "export type StageSpec = { kind: \"static\"; id: string; steps: number; integrator: IntegratorSpec; algorithm: AlgorithmSpec; convergence?: ConvergenceSpec; holdPatternsAfter: number[] } | { kind: \"modal\"; id: string; modes: number } | { kind: \"reset\"; id: string } | { kind: \"transient\"; id: string; steps: number; dt: number; damping: DampingSpec; groundMotions: GroundMotionSpec[]; algorithm?: AlgorithmSpec; convergence?: ConvergenceSpec };"

const SERIALIZATION_CONFIG: SerializationConfig

type JsType = JsType

Must be a type imported through #[wasm_bindgen] extern "C" { .. }. [Ts<T>] is #[repr(transparent)] over this and passes it across the ABI as a plain JS handle, which any other representation would break.

fn into_js(&self) -> Result<Self::JsType, Error>

where Self: Serialize,

fn from_js<T>(js: T) -> Result<Self, Error>

where T: Into<JsValue>, Self: DeserializeOwned,

fn into_ts(&self) -> Result<Ts<Self>, Error>

where Self: Sized + Serialize,

Calls Ts::from_rust on self, returning a Result<Ts<Self>, crate::Error>.