Struct DispBeamColumn 

pub struct DispBeamColumn {
    pub node_i: NodeId,
    pub node_j: NodeId,
    pub density: f64,
    /* private fields */
}

A 2-node, displacement-based, fiber-discretized 2D beam-column: nodal displacements directly give the strain/curvature field along the length (cubic Hermite transverse + linear axial shape functions, same as ElasticBeamColumn’s), each BeamIntegration point’s FiberSection converts that to stress-resultants, and one length-integral gives the element’s resisting force/tangent — a single, direct evaluation, unlike ForceBeamColumn, which needs its own internal equilibrium iteration per element.

Prismatic-member assumption: every integration point starts from the same fiber layout (fibers, replicated points times) but evolves independently thereafter, since each point’s material history depends on that point’s own strain path. A tapered/non-prismatic member (a different section per point) is a natural extension, not built until needed.

Small-displacement by default, with an opt-in GeomTransf::Corotational formulation that integrates fiber response from the three objective basic deformations. PDelta remains unsupported for this element (a fiber section’s force state does not reduce to the scalar axial force used by ElasticBeamColumn’s closed-form correction). Uniform element loads use the same consistent equivalent nodal load as ElasticBeamColumn (form_load_vector), which is independent of the section model and integration rule. Note the field is still the Hermite-interpolated linear curvature: a distributed load’s parabolic moment is only approximated within one element, so nonlinear response under distributed load wants the member subdivided.

Fields

node_i: NodeId

node_j: NodeId

density: f64

Mass per unit volume, applied uniformly over the section’s total fiber area. Zero (the default) means massless.

Implementations

impl DispBeamColumn

pub fn new( node_i: NodeId, node_j: NodeId, fibers: Vec<Fiber>, integration: BeamIntegration, ) -> Self

pub fn with_density(self, density: f64) -> Self

pub fn with_corotational(self) -> Self

Use finite-rotation, chord-following kinematics for this member.

pub fn fiber_responses( &self, node_i: &Node, node_j: &Node, ) -> Vec<Vec<(f64, f64)>>

Every integration point’s per-fiber (strain, stress), freshly recomputed from node_i/node_j’s current committed displacement — same “recompute, don’t cache” reasoning as local_force (this element has no Newton loop between a target and the committed answer, unlike ForceBeamColumn). Outer Vec is one entry per integration point (BeamIntegration::points() order), inner Vec one entry per fiber (the order originally passed to new).

Trait Implementations

impl Clone for DispBeamColumn

fn clone(&self) -> DispBeamColumn

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DispBeamColumn

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

Formats the value using the given formatter.