Enum RecorderSpec 

pub enum RecorderSpec {
    NodeDisp {
        node: u32,
        dof: u8,
    },
    NodeVel {
        node: u32,
        dof: u8,
    },
    NodeAccel {
        node: u32,
        dof: u8,
    },
    ElementForce {
        element_kind: ElementKind,
        element_index: u32,
        component: u8,
    },
    ElementLoad {
        element_kind: ElementKind,
        element_index: u32,
        component: u8,
    },
    ModeShape {
        mode: u32,
        node: u32,
        dof: u8,
    },
    Reaction {
        node: u32,
        dof: u8,
    },
    Fiber {
        element_kind: ElementKind,
        element_index: u32,
        point: u32,
        fiber: u32,
        quantity: FiberResponseKind,
    },
    GaussPoint {
        element_kind: ElementKind,
        element_index: u32,
        point: u32,
        quantity: GaussQuantity,
        component: u8,
    },
}

Variants

NodeDisp

node/dof index into NodeTable.

Fields

node: u32

dof: u8

NodeVel

Only meaningful during a Transient stage — analysis.domain()’s node velocity is otherwise always zero (a Static stage never touches it), so this recorder simply contributes no sample outside one.

Fields

node: u32

dof: u8

NodeAccel

See NodeVel’s doc comment — same restriction, for acceleration.

Fields

node: u32

dof: u8

ElementForce

element_index indexes into whichever per-kind table element_kind names (e.g. ForceBeamColumnTable), not a flat cross-kind element list. component indexes the element’s local nodal force vector (ElementOps::local_force — axial/shear/moment at each end, in the element’s own axis frame), width 2 * dofsPerNode (6 in 2D, 12 in 3D); a component past ElementOps::local_force_width is DecodeError::InvalidRecorderComponent.

Fields

element_kind: ElementKind

element_index: u32

component: u8

ElementLoad

The uniform load an element carries at the sample’s pseudo-time (every pattern’s load on it, scaled by its factor, summed — frozen patterns included): component 0 = wx, 1 = wy, 2 = wz (3D only), local axes; past the load’s width it is DecodeError::InvalidRecorderComponent. What a consumer needs to recover internal-force diagrams from ElementForce’s end forces. 0 for an unloaded element.

Fields

element_kind: ElementKind

element_index: u32

component: u8

ModeShape

Only meaningful during a Modal stage: mode indexes that stage’s computed Vec<Mode> (ascending frequency, 0 = lowest), node/ dof locate one entry of that mode’s free-DOF-indexed shape vector (core::Mode::shape) via Domain::equation_of — a fixed DOF has no equation number and reads as 0.0 (trivially true: a fixed DOF can’t participate in any mode shape). The recorded “time” component is the mode’s frequency (rad/time), not a pseudo-time or load factor — there’s no more natural scalar to pair a mode’s shape component with.

Fields

mode: u32

node: u32

dof: u8

Reaction

Support/equilibrium reaction at node/dof (core::Domain:: reaction’s doc comment) — most useful at a fixed DOF, but not restricted to one. Valid during Static and Transient stages (paired with the stage’s own load factor/time, same as NodeDisp); records nothing during a Modal stage, which has no applied-load state for reaction to evaluate against.

Fields

node: u32

dof: u8

Fiber

One fiber’s strain or stress, at one integration point, of one DispBeamColumn/ForceBeamColumn element (core::Domain:: element_fiber_responses’s doc comment) — element_kind/ element_index mirror ElementForce’s own disambiguation. point/fiber index into that element’s own integration-point/ fiber ordering, exactly as originally given to its constructor (point therefore also matches IntegrationSpec’s point count, and fiber matches FiberTable’s per-section fiber range). Records nothing for any other element kind (no fiber section to read) or an out-of-range point/fiber — the same “unresolved by runtime state, not a decode-time error” handling ModeShape uses, since neither can be checked before the analysis actually runs.

Fields

element_kind: ElementKind

element_index: u32

point: u32

fiber: u32

quantity: FiberResponseKind

GaussPoint

One component of the strain or stress at one Gauss point of a continuum element (tri3: 1 point, quad4: 4, in core’s Gauss-point order). component is 0..3 = x, y, xy (engineering shear for strain). Valid during Static and Transient stages; records nothing during Modal. point past the element’s Gauss-point count (or any point of a non-continuum kind) is DecodeError::InvalidGaussPoint; component past 2 is InvalidRecorderComponent.

Fields

element_kind: ElementKind

element_index: u32

point: u32

quantity: GaussQuantity

component: u8

Trait Implementations

impl Clone for RecorderSpec

fn clone(&self) -> RecorderSpec

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for RecorderSpec

impl Debug for RecorderSpec

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RecorderSpec

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for RecorderSpec

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for RecorderSpec

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 RecorderSpec

impl Tsify for RecorderSpec

const DECL: &'static str = "export type RecorderSpec = { response: \"nodeDisp\"; node: number; dof: number } | { response: \"nodeVel\"; node: number; dof: number } | { response: \"nodeAccel\"; node: number; dof: number } | { response: \"elementForce\"; elementKind: ElementKind; elementIndex: number; component: number } | { response: \"elementLoad\"; elementKind: ElementKind; elementIndex: number; component: number } | { response: \"modeShape\"; mode: number; node: number; dof: number } | { response: \"reaction\"; node: number; dof: number } | { response: \"fiber\"; elementKind: ElementKind; elementIndex: number; point: number; fiber: number; quantity: FiberResponseKind } | { response: \"gaussPoint\"; elementKind: ElementKind; elementIndex: number; point: number; quantity: GaussQuantity; component: number };"

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>.