Enum ElementLoadSpec 

pub enum ElementLoadSpec {
    Uniform {
        wx: f64,
        wy: f64,
        wz: Option<f64>,
    },
    Body {
        bx: f64,
        by: f64,
    },
    EdgeTraction {
        edge: u8,
        tx: f64,
        ty: f64,
    },
    EdgePressure {
        edge: u8,
        pressure: f64,
    },
    ShellPressure {
        pressure: f64,
    },
    ShellBody {
        bx: f64,
        by: f64,
        bz: f64,
    },
}

Variants

Uniform

Uniform load (force/length) in the element’s local axes: wx along the member axis, wy transverse in local +y, and in 3D wz transverse in local +z (vec_xz defines y/z). wz is absent in a 2D model and defaults to 0 in a 3D one.

Only the beam-column kinds currently honor this (core’s Element::form_load_vector falls through to zero for every other kind) — decode rejects any other element_kind explicitly rather than silently accepting a load that will never apply. Several loads on one element in one pattern sum.

Fields

wx: f64

wy: f64

wz: Option<f64>

Body

Body force per unit volume in global axes (continuum elements, 2D).

Fields

bx: f64

by: f64

EdgeTraction

Traction per unit length of edge edge in global axes; edge k joins local node k to k + 1 (continuum elements, 2D).

Fields

edge: u8

tx: f64

ty: f64

EdgePressure

Pressure on edge edge, positive into the element along the inward normal (continuum elements, 2D).

Fields

edge: u8

pressure: f64

ShellPressure

Pressure per unit area on a shell, positive along its local normal e3 (right-hand rule from the node order). Applied as consistent nodal forces.

Fields

pressure: f64

ShellBody

Body acceleration on a shell in global axes (a gravity vector g points down); the force per unit area is rho h b. Note OpenSees’ ShellMITC4 -selfWeight has the opposite sign.

Fields

bx: f64

by: f64

bz: f64

Trait Implementations

impl Clone for ElementLoadSpec

fn clone(&self) -> ElementLoadSpec

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ElementLoadSpec

impl Debug for ElementLoadSpec

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ElementLoadSpec

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ElementLoadSpec

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for ElementLoadSpec

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 ElementLoadSpec

impl Tsify for ElementLoadSpec

const DECL: &'static str = "export type ElementLoadSpec = { kind: \"uniform\"; wx: number; wy: number; wz?: number } | { kind: \"body\"; bx: number; by: number } | { kind: \"edgeTraction\"; edge: number; tx: number; ty: number } | { kind: \"edgePressure\"; edge: number; pressure: number } | { kind: \"shellPressure\"; pressure: number } | { kind: \"shellBody\"; bx: number; by: number; bz: 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>.