Struct StaticSystem2D 

pub struct StaticSystem2D {
    pub forces: Vec<Force2D>,
    pub moments: Vec<f64>,
}

A simple planar static system made of force vectors and scalar moments.

Fields

forces: Vec<Force2D>

The planar forces acting on the system.

moments: Vec<f64>

Free moments acting on the system.

Implementations

impl StaticSystem2D

pub fn new(forces: Vec<Force2D>, moments: Vec<f64>) -> Option<Self>

Creates a validated static system.

Examples found in repository

examples/basic_usage.rs (line 21)

fn main() {
    let Some(force_left) = Force2D::new(100.0, 0.0) else {
        panic!("valid force should construct");
    };
    let Some(force_right) = Force2D::new(-100.0, 0.0) else {
        panic!("valid force should construct");
    };

    let Some(system) = StaticSystem2D::new(vec![force_left, force_right], vec![0.0]) else {
        panic!("valid system should construct");
    };

    assert_eq!(system.is_equilibrium(0.0), Some(true));

    let Some((left, right)) = simply_supported_point_load_reactions(10.0, 100.0, 5.0) else {
        panic!("valid point load should produce reactions");
    };

    approx_eq(left, 50.0, 1.0e-12);
    approx_eq(right, 50.0, 1.0e-12);

    assert_eq!(
        cantilever_end_point_load_reaction(10.0, 100.0),
        Some(CantileverReaction {
            vertical_reaction: 100.0,
            fixed_end_moment: 1000.0,
        })
    );
}

pub fn net_force(&self) -> Option<(f64, f64)>

Returns the net force in the system.

pub fn net_moment(&self) -> Option<f64>

Returns the net free moment in the system.

pub fn is_equilibrium(&self, tolerance: f64) -> Option<bool>

Checks whether the system is in static equilibrium.

Examples

use use_statics::{Force2D, StaticSystem2D};

let Some(system) = StaticSystem2D::new(
    vec![
        Force2D::new(1.0, 2.0).unwrap(),
        Force2D::new(-1.0, -2.0).unwrap(),
    ],
    vec![10.0, -10.0],
) else {
    panic!("valid system should construct");
};

assert_eq!(system.is_equilibrium(0.0), Some(true));

Examples found in repository

examples/basic_usage.rs (line 25)

fn main() {
    let Some(force_left) = Force2D::new(100.0, 0.0) else {
        panic!("valid force should construct");
    };
    let Some(force_right) = Force2D::new(-100.0, 0.0) else {
        panic!("valid force should construct");
    };

    let Some(system) = StaticSystem2D::new(vec![force_left, force_right], vec![0.0]) else {
        panic!("valid system should construct");
    };

    assert_eq!(system.is_equilibrium(0.0), Some(true));

    let Some((left, right)) = simply_supported_point_load_reactions(10.0, 100.0, 5.0) else {
        panic!("valid point load should produce reactions");
    };

    approx_eq(left, 50.0, 1.0e-12);
    approx_eq(right, 50.0, 1.0e-12);

    assert_eq!(
        cantilever_end_point_load_reaction(10.0, 100.0),
        Some(CantileverReaction {
            vertical_reaction: 100.0,
            fixed_end_moment: 1000.0,
        })
    );
}

Trait Implementations

impl Clone for StaticSystem2D

fn clone(&self) -> StaticSystem2D

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for StaticSystem2D

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

Formats the value using the given formatter.

impl PartialEq for StaticSystem2D

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for StaticSystem2D