Skip to main content

beam_cantilever_udl/
beam_cantilever_udl.rs

1//! Cantilever with a uniform transverse load, modelled with several elements.
2//!
3//! Demonstrates a multi-element model with a distributed load and shows that
4//! the complete external load is represented exactly once in the reactions.
5//!
6//! Unit properties (`E = A = I = 1`), `L = 1`, `q = 100` (downward):
7//!
8//! ```text
9//! tip deflection  delta = -q L^4 / (8 E I) = -12.5
10//! tip rotation    theta = -q L^3 / (6 E I) = -16.666667
11//! reactions       Ry = q L = 100,  Rz = q L^2 / 2 = 50
12//! ```
13
14use section_properties::beam_fem::{
15    BeamElement, BeamModel, BeamNode, BeamSection, BeamSolver, Dof,
16};
17use section_properties::material::Material;
18
19fn main() -> Result<(), Box<dyn std::error::Error>> {
20    let (e, a, i, l, q) = (1.0, 1.0, 1.0, 1.0, 100.0);
21    let n_elem = 4;
22
23    // --- model ---------------------------------------------------------------
24    let mut model = BeamModel::new();
25    let dx = l / n_elem as f64;
26    for k in 0..=n_elem {
27        model.add_node(BeamNode::new(k, k as f64 * dx, 0.0));
28    }
29    for k in 0..n_elem {
30        model.add_element(BeamElement::new(
31            k,
32            k + 1,
33            Material::new(e, 0.3, 1.0, "unit"),
34            BeamSection::new(a, i),
35        )?);
36        // uniform downward load, local qy < 0, applied to every element
37        model.add_distributed_load(k, 0.0, -q)?;
38    }
39    model.fix_node(0);
40
41    // --- solve ---------------------------------------------------------------
42    let mut solver = BeamSolver::from_model(&model)?;
43    solver.solve_configured()?;
44    let res = solver.results();
45
46    // --- results -------------------------------------------------------------
47    // Typed DOF accessors on the solver (equivalent to the raw-index API).
48    let tip_uy = solver.displacement_dof(n_elem, Dof::Uy)?;
49    let tip_rz = solver.displacement_dof(n_elem, Dof::Rz)?;
50    let ry = solver.reaction_dof(0, Dof::Uy)?;
51    let rz = solver.reaction_dof(0, Dof::Rz)?;
52
53    println!("solver backend : {:?}", res.solver_name());
54    println!(
55        "tip uy         : {:+.6}   (analytical {:+.6})",
56        tip_uy,
57        -q * l.powi(4) / (8.0 * e * i)
58    );
59    println!(
60        "tip rz         : {:+.6}   (analytical {:+.6})",
61        tip_rz,
62        -q * l.powi(3) / (6.0 * e * i)
63    );
64    println!(
65        "reaction Ry    : {:+.6}   (analytical q L = {:+.6})",
66        ry,
67        q * l
68    );
69    println!(
70        "reaction Rz    : {:+.6}   (analytical q L^2 / 2 = {:+.6})",
71        rz,
72        q * l * l / 2.0
73    );
74
75    // Each element's end forces are element-on-node forces; the total transverse
76    // end-force resultant across the beam balances the applied load q·L.
77    let mut total_vy = 0.0;
78    for k in 0..n_elem {
79        let fe = res.element_end_forces(k)?;
80        total_vy += fe[1] + fe[4];
81    }
82    println!(
83        "Σ element end shear = {:+.6}; applied load = {:+.6} (counted once)",
84        total_vy,
85        -q * l
86    );
87
88    Ok(())
89}