Skip to main content

FrameModel

Struct FrameModel 

Source
pub struct FrameModel { /* private fields */ }
Expand description

A 2D frame: nodes, members, supports and loads.

Wraps the existing BeamModel and delegates all mechanics to it; supports arbitrary planar connectivity (not just a straight beam), per-DOF constraints and prescribed displacements.

Implementations§

Source§

impl FrameModel

Source

pub fn new() -> Self

Create an empty frame.

Examples found in repository?
examples/frame_portal.rs (line 20)
13fn main() -> Result<(), Box<dyn std::error::Error>> {
14    let (e, a, i) = (200e9, 5e-3, 2e-5);
15    let (h, w) = (3.0, 4.0);
16    let lateral = 20e3; // N, +X
17    let udl = -8e3; // N/m, downward in member-local +y
18
19    // --- model -----------------------------------------------------------------
20    let mut frame = FrameModel::new();
21    let base_left = frame.add_node(0.0, 0.0)?;
22    let top_left = frame.add_node(0.0, h)?;
23    let top_right = frame.add_node(w, h)?;
24    let base_right = frame.add_node(w, 0.0)?;
25
26    let section = BeamSection::new(a, i);
27    let mat = Material::new(e, 0.3, 7850.0, "Steel");
28    let col_left = frame.add_member(base_left, top_left, mat, section)?;
29    let beam = frame.add_member(top_left, top_right, mat, section)?;
30    let col_right = frame.add_member(top_right, base_right, mat, section)?;
31
32    frame.fix(base_left)?;
33    frame.fix(base_right)?;
34    frame.nodal_load(top_left, lateral, 0.0)?; // global
35    frame.member_udl(beam, 0.0, udl)?; // local
36
37    // --- solve -----------------------------------------------------------------
38    let result = frame.solve_with(SolverSelection::named("sparse_lu"))?;
39    println!("backend              : {:?}", result.solver_name());
40    println!(
41        "nodes / members      : {} / {}",
42        result.n_nodes(),
43        result.n_members()
44    );
45
46    // --- results ---------------------------------------------------------------
47    println!(
48        "roof sway (ux)       : {:+.6e} m",
49        result.displacement(top_left, Dof::Ux)?
50    );
51    println!(
52        "base reactions       : Rx={:+.6e}  Ry={:+.6e}  Mz={:+.6e}",
53        result.reaction(base_left, Dof::Ux)?,
54        result.reaction(base_left, Dof::Uy)?,
55        result.reaction(base_left, Dof::Rz)?
56    );
57    println!(
58        "right base reaction  : Rx={:+.6e}  Ry={:+.6e}",
59        result.reaction(base_right, Dof::Ux)?,
60        result.reaction(base_right, Dof::Uy)?
61    );
62
63    // Member end forces are element-on-node forces in LOCAL axes:
64    // [N_i, V_i, M_i, N_j, V_j, M_j] = f_equiv - K_e u_e.
65    println!(
66        "beam end forces (local)  : {:?}",
67        result.member_end_forces(beam)?
68    );
69    println!(
70        "left column global ends  : {:?}",
71        result.member_end_forces_global(col_left)?
72    );
73    println!(
74        "right column global ends : {:?}",
75        result.member_end_forces_global(col_right)?
76    );
77
78    // --- equilibrium -----------------------------------------------------------
79    let eq = result.equilibrium();
80    println!(
81        "equilibrium residual : sumFx={:+.3e}  sumFy={:+.3e}  sumMz={:+.3e}  (about the origin)",
82        eq.fx_residual, eq.fy_residual, eq.mz_residual
83    );
84    println!("balanced             : {}", eq.is_balanced());
85
86    Ok(())
87}
Source

pub fn n_nodes(&self) -> usize

Number of nodes.

Source

pub fn n_members(&self) -> usize

Number of members.

Source

pub fn add_node(&mut self, x: f64, y: f64) -> Result<NodeHandle, FemError>

Add a node at global (x, y) and return its handle.

§Errors

FemError::InvalidInput if either coordinate is not finite.

Examples found in repository?
examples/frame_portal.rs (line 21)
13fn main() -> Result<(), Box<dyn std::error::Error>> {
14    let (e, a, i) = (200e9, 5e-3, 2e-5);
15    let (h, w) = (3.0, 4.0);
16    let lateral = 20e3; // N, +X
17    let udl = -8e3; // N/m, downward in member-local +y
18
19    // --- model -----------------------------------------------------------------
20    let mut frame = FrameModel::new();
21    let base_left = frame.add_node(0.0, 0.0)?;
22    let top_left = frame.add_node(0.0, h)?;
23    let top_right = frame.add_node(w, h)?;
24    let base_right = frame.add_node(w, 0.0)?;
25
26    let section = BeamSection::new(a, i);
27    let mat = Material::new(e, 0.3, 7850.0, "Steel");
28    let col_left = frame.add_member(base_left, top_left, mat, section)?;
29    let beam = frame.add_member(top_left, top_right, mat, section)?;
30    let col_right = frame.add_member(top_right, base_right, mat, section)?;
31
32    frame.fix(base_left)?;
33    frame.fix(base_right)?;
34    frame.nodal_load(top_left, lateral, 0.0)?; // global
35    frame.member_udl(beam, 0.0, udl)?; // local
36
37    // --- solve -----------------------------------------------------------------
38    let result = frame.solve_with(SolverSelection::named("sparse_lu"))?;
39    println!("backend              : {:?}", result.solver_name());
40    println!(
41        "nodes / members      : {} / {}",
42        result.n_nodes(),
43        result.n_members()
44    );
45
46    // --- results ---------------------------------------------------------------
47    println!(
48        "roof sway (ux)       : {:+.6e} m",
49        result.displacement(top_left, Dof::Ux)?
50    );
51    println!(
52        "base reactions       : Rx={:+.6e}  Ry={:+.6e}  Mz={:+.6e}",
53        result.reaction(base_left, Dof::Ux)?,
54        result.reaction(base_left, Dof::Uy)?,
55        result.reaction(base_left, Dof::Rz)?
56    );
57    println!(
58        "right base reaction  : Rx={:+.6e}  Ry={:+.6e}",
59        result.reaction(base_right, Dof::Ux)?,
60        result.reaction(base_right, Dof::Uy)?
61    );
62
63    // Member end forces are element-on-node forces in LOCAL axes:
64    // [N_i, V_i, M_i, N_j, V_j, M_j] = f_equiv - K_e u_e.
65    println!(
66        "beam end forces (local)  : {:?}",
67        result.member_end_forces(beam)?
68    );
69    println!(
70        "left column global ends  : {:?}",
71        result.member_end_forces_global(col_left)?
72    );
73    println!(
74        "right column global ends : {:?}",
75        result.member_end_forces_global(col_right)?
76    );
77
78    // --- equilibrium -----------------------------------------------------------
79    let eq = result.equilibrium();
80    println!(
81        "equilibrium residual : sumFx={:+.3e}  sumFy={:+.3e}  sumMz={:+.3e}  (about the origin)",
82        eq.fx_residual, eq.fy_residual, eq.mz_residual
83    );
84    println!("balanced             : {}", eq.is_balanced());
85
86    Ok(())
87}
Source

pub fn add_member( &mut self, a: NodeHandle, b: NodeHandle, material: Material, section: BeamSection, ) -> Result<MemberHandle, FemError>

Add a member between two existing nodes.

The member stiffness uses EA (axial) and EI (bending) from the given material and section, exactly as the Beam FEM core does.

§Errors
Examples found in repository?
examples/frame_portal.rs (line 28)
13fn main() -> Result<(), Box<dyn std::error::Error>> {
14    let (e, a, i) = (200e9, 5e-3, 2e-5);
15    let (h, w) = (3.0, 4.0);
16    let lateral = 20e3; // N, +X
17    let udl = -8e3; // N/m, downward in member-local +y
18
19    // --- model -----------------------------------------------------------------
20    let mut frame = FrameModel::new();
21    let base_left = frame.add_node(0.0, 0.0)?;
22    let top_left = frame.add_node(0.0, h)?;
23    let top_right = frame.add_node(w, h)?;
24    let base_right = frame.add_node(w, 0.0)?;
25
26    let section = BeamSection::new(a, i);
27    let mat = Material::new(e, 0.3, 7850.0, "Steel");
28    let col_left = frame.add_member(base_left, top_left, mat, section)?;
29    let beam = frame.add_member(top_left, top_right, mat, section)?;
30    let col_right = frame.add_member(top_right, base_right, mat, section)?;
31
32    frame.fix(base_left)?;
33    frame.fix(base_right)?;
34    frame.nodal_load(top_left, lateral, 0.0)?; // global
35    frame.member_udl(beam, 0.0, udl)?; // local
36
37    // --- solve -----------------------------------------------------------------
38    let result = frame.solve_with(SolverSelection::named("sparse_lu"))?;
39    println!("backend              : {:?}", result.solver_name());
40    println!(
41        "nodes / members      : {} / {}",
42        result.n_nodes(),
43        result.n_members()
44    );
45
46    // --- results ---------------------------------------------------------------
47    println!(
48        "roof sway (ux)       : {:+.6e} m",
49        result.displacement(top_left, Dof::Ux)?
50    );
51    println!(
52        "base reactions       : Rx={:+.6e}  Ry={:+.6e}  Mz={:+.6e}",
53        result.reaction(base_left, Dof::Ux)?,
54        result.reaction(base_left, Dof::Uy)?,
55        result.reaction(base_left, Dof::Rz)?
56    );
57    println!(
58        "right base reaction  : Rx={:+.6e}  Ry={:+.6e}",
59        result.reaction(base_right, Dof::Ux)?,
60        result.reaction(base_right, Dof::Uy)?
61    );
62
63    // Member end forces are element-on-node forces in LOCAL axes:
64    // [N_i, V_i, M_i, N_j, V_j, M_j] = f_equiv - K_e u_e.
65    println!(
66        "beam end forces (local)  : {:?}",
67        result.member_end_forces(beam)?
68    );
69    println!(
70        "left column global ends  : {:?}",
71        result.member_end_forces_global(col_left)?
72    );
73    println!(
74        "right column global ends : {:?}",
75        result.member_end_forces_global(col_right)?
76    );
77
78    // --- equilibrium -----------------------------------------------------------
79    let eq = result.equilibrium();
80    println!(
81        "equilibrium residual : sumFx={:+.3e}  sumFy={:+.3e}  sumMz={:+.3e}  (about the origin)",
82        eq.fx_residual, eq.fy_residual, eq.mz_residual
83    );
84    println!("balanced             : {}", eq.is_balanced());
85
86    Ok(())
87}
Source

pub fn fix(&mut self, node: NodeHandle) -> Result<(), FemError>

Fully fix a node (ux = uy = rz = 0).

§Errors

FemError::InvalidNode if the handle is not valid. FemError::ConflictingPrescribedDisplacement if any of the node’s DOFs already has a conflicting prescribed value.

Examples found in repository?
examples/frame_portal.rs (line 32)
13fn main() -> Result<(), Box<dyn std::error::Error>> {
14    let (e, a, i) = (200e9, 5e-3, 2e-5);
15    let (h, w) = (3.0, 4.0);
16    let lateral = 20e3; // N, +X
17    let udl = -8e3; // N/m, downward in member-local +y
18
19    // --- model -----------------------------------------------------------------
20    let mut frame = FrameModel::new();
21    let base_left = frame.add_node(0.0, 0.0)?;
22    let top_left = frame.add_node(0.0, h)?;
23    let top_right = frame.add_node(w, h)?;
24    let base_right = frame.add_node(w, 0.0)?;
25
26    let section = BeamSection::new(a, i);
27    let mat = Material::new(e, 0.3, 7850.0, "Steel");
28    let col_left = frame.add_member(base_left, top_left, mat, section)?;
29    let beam = frame.add_member(top_left, top_right, mat, section)?;
30    let col_right = frame.add_member(top_right, base_right, mat, section)?;
31
32    frame.fix(base_left)?;
33    frame.fix(base_right)?;
34    frame.nodal_load(top_left, lateral, 0.0)?; // global
35    frame.member_udl(beam, 0.0, udl)?; // local
36
37    // --- solve -----------------------------------------------------------------
38    let result = frame.solve_with(SolverSelection::named("sparse_lu"))?;
39    println!("backend              : {:?}", result.solver_name());
40    println!(
41        "nodes / members      : {} / {}",
42        result.n_nodes(),
43        result.n_members()
44    );
45
46    // --- results ---------------------------------------------------------------
47    println!(
48        "roof sway (ux)       : {:+.6e} m",
49        result.displacement(top_left, Dof::Ux)?
50    );
51    println!(
52        "base reactions       : Rx={:+.6e}  Ry={:+.6e}  Mz={:+.6e}",
53        result.reaction(base_left, Dof::Ux)?,
54        result.reaction(base_left, Dof::Uy)?,
55        result.reaction(base_left, Dof::Rz)?
56    );
57    println!(
58        "right base reaction  : Rx={:+.6e}  Ry={:+.6e}",
59        result.reaction(base_right, Dof::Ux)?,
60        result.reaction(base_right, Dof::Uy)?
61    );
62
63    // Member end forces are element-on-node forces in LOCAL axes:
64    // [N_i, V_i, M_i, N_j, V_j, M_j] = f_equiv - K_e u_e.
65    println!(
66        "beam end forces (local)  : {:?}",
67        result.member_end_forces(beam)?
68    );
69    println!(
70        "left column global ends  : {:?}",
71        result.member_end_forces_global(col_left)?
72    );
73    println!(
74        "right column global ends : {:?}",
75        result.member_end_forces_global(col_right)?
76    );
77
78    // --- equilibrium -----------------------------------------------------------
79    let eq = result.equilibrium();
80    println!(
81        "equilibrium residual : sumFx={:+.3e}  sumFy={:+.3e}  sumMz={:+.3e}  (about the origin)",
82        eq.fx_residual, eq.fy_residual, eq.mz_residual
83    );
84    println!("balanced             : {}", eq.is_balanced());
85
86    Ok(())
87}
Source

pub fn pin(&mut self, node: NodeHandle) -> Result<(), FemError>

Pin a node: restrain ux and uy, leave the rotation free.

§Errors

FemError::InvalidNode if the handle is not valid. FemError::ConflictingPrescribedDisplacement if either ux or uy already has a conflicting prescribed value.

Source

pub fn roller_y(&mut self, node: NodeHandle) -> Result<(), FemError>

Roller restraining the vertical translation (uy = 0), horizontal free.

§Errors

FemError::InvalidNode if the handle is not valid. FemError::ConflictingPrescribedDisplacement if uy already has a conflicting prescribed value.

Source

pub fn roller_x(&mut self, node: NodeHandle) -> Result<(), FemError>

Roller restraining the horizontal translation (ux = 0), vertical free.

§Errors

FemError::InvalidNode if the handle is not valid. FemError::ConflictingPrescribedDisplacement if ux already has a conflicting prescribed value.

Source

pub fn restrain( &mut self, node: NodeHandle, dof: Dof, value: f64, ) -> Result<(), FemError>

Prescribe a DOF to an arbitrary finite value (e.g. a support settlement).

Applied through the existing static condensation (K_ff u_f = f_f - K_fc u_c); no penalty constraints are used.

If the DOF was previously constrained (e.g. by fix), the existing prescription is replaced — this allows the common workflow of fixing a support node and then applying a settlement.

§Errors

FemError::InvalidNode if the handle is not valid. FemError::InvalidInput if value is not finite.

Source

pub fn nodal_load( &mut self, node: NodeHandle, fx: f64, fy: f64, ) -> Result<(), FemError>

Apply a global nodal force (fx, fy).

§Errors

FemError::InvalidNode if the handle is not valid, or FemError::InvalidInput if either component is non-finite. Both components are validated before either is recorded, so a rejected call leaves the model unchanged (no half-applied load).

Examples found in repository?
examples/frame_portal.rs (line 34)
13fn main() -> Result<(), Box<dyn std::error::Error>> {
14    let (e, a, i) = (200e9, 5e-3, 2e-5);
15    let (h, w) = (3.0, 4.0);
16    let lateral = 20e3; // N, +X
17    let udl = -8e3; // N/m, downward in member-local +y
18
19    // --- model -----------------------------------------------------------------
20    let mut frame = FrameModel::new();
21    let base_left = frame.add_node(0.0, 0.0)?;
22    let top_left = frame.add_node(0.0, h)?;
23    let top_right = frame.add_node(w, h)?;
24    let base_right = frame.add_node(w, 0.0)?;
25
26    let section = BeamSection::new(a, i);
27    let mat = Material::new(e, 0.3, 7850.0, "Steel");
28    let col_left = frame.add_member(base_left, top_left, mat, section)?;
29    let beam = frame.add_member(top_left, top_right, mat, section)?;
30    let col_right = frame.add_member(top_right, base_right, mat, section)?;
31
32    frame.fix(base_left)?;
33    frame.fix(base_right)?;
34    frame.nodal_load(top_left, lateral, 0.0)?; // global
35    frame.member_udl(beam, 0.0, udl)?; // local
36
37    // --- solve -----------------------------------------------------------------
38    let result = frame.solve_with(SolverSelection::named("sparse_lu"))?;
39    println!("backend              : {:?}", result.solver_name());
40    println!(
41        "nodes / members      : {} / {}",
42        result.n_nodes(),
43        result.n_members()
44    );
45
46    // --- results ---------------------------------------------------------------
47    println!(
48        "roof sway (ux)       : {:+.6e} m",
49        result.displacement(top_left, Dof::Ux)?
50    );
51    println!(
52        "base reactions       : Rx={:+.6e}  Ry={:+.6e}  Mz={:+.6e}",
53        result.reaction(base_left, Dof::Ux)?,
54        result.reaction(base_left, Dof::Uy)?,
55        result.reaction(base_left, Dof::Rz)?
56    );
57    println!(
58        "right base reaction  : Rx={:+.6e}  Ry={:+.6e}",
59        result.reaction(base_right, Dof::Ux)?,
60        result.reaction(base_right, Dof::Uy)?
61    );
62
63    // Member end forces are element-on-node forces in LOCAL axes:
64    // [N_i, V_i, M_i, N_j, V_j, M_j] = f_equiv - K_e u_e.
65    println!(
66        "beam end forces (local)  : {:?}",
67        result.member_end_forces(beam)?
68    );
69    println!(
70        "left column global ends  : {:?}",
71        result.member_end_forces_global(col_left)?
72    );
73    println!(
74        "right column global ends : {:?}",
75        result.member_end_forces_global(col_right)?
76    );
77
78    // --- equilibrium -----------------------------------------------------------
79    let eq = result.equilibrium();
80    println!(
81        "equilibrium residual : sumFx={:+.3e}  sumFy={:+.3e}  sumMz={:+.3e}  (about the origin)",
82        eq.fx_residual, eq.fy_residual, eq.mz_residual
83    );
84    println!("balanced             : {}", eq.is_balanced());
85
86    Ok(())
87}
Source

pub fn nodal_moment( &mut self, node: NodeHandle, mz: f64, ) -> Result<(), FemError>

Apply a global nodal moment mz (counter-clockwise positive).

§Errors

FemError::InvalidNode if the handle is not valid.

Source

pub fn member_udl( &mut self, member: MemberHandle, qx: f64, qy: f64, ) -> Result<(), FemError>

Apply a uniform distributed load in the member’s local axes.

qy > 0 is upward in local +y; qx > 0 is tensile (towards node_j). Repeated calls accumulate on the same member.

§Errors

FemError::InvalidMember if the handle is not valid.

Examples found in repository?
examples/frame_portal.rs (line 35)
13fn main() -> Result<(), Box<dyn std::error::Error>> {
14    let (e, a, i) = (200e9, 5e-3, 2e-5);
15    let (h, w) = (3.0, 4.0);
16    let lateral = 20e3; // N, +X
17    let udl = -8e3; // N/m, downward in member-local +y
18
19    // --- model -----------------------------------------------------------------
20    let mut frame = FrameModel::new();
21    let base_left = frame.add_node(0.0, 0.0)?;
22    let top_left = frame.add_node(0.0, h)?;
23    let top_right = frame.add_node(w, h)?;
24    let base_right = frame.add_node(w, 0.0)?;
25
26    let section = BeamSection::new(a, i);
27    let mat = Material::new(e, 0.3, 7850.0, "Steel");
28    let col_left = frame.add_member(base_left, top_left, mat, section)?;
29    let beam = frame.add_member(top_left, top_right, mat, section)?;
30    let col_right = frame.add_member(top_right, base_right, mat, section)?;
31
32    frame.fix(base_left)?;
33    frame.fix(base_right)?;
34    frame.nodal_load(top_left, lateral, 0.0)?; // global
35    frame.member_udl(beam, 0.0, udl)?; // local
36
37    // --- solve -----------------------------------------------------------------
38    let result = frame.solve_with(SolverSelection::named("sparse_lu"))?;
39    println!("backend              : {:?}", result.solver_name());
40    println!(
41        "nodes / members      : {} / {}",
42        result.n_nodes(),
43        result.n_members()
44    );
45
46    // --- results ---------------------------------------------------------------
47    println!(
48        "roof sway (ux)       : {:+.6e} m",
49        result.displacement(top_left, Dof::Ux)?
50    );
51    println!(
52        "base reactions       : Rx={:+.6e}  Ry={:+.6e}  Mz={:+.6e}",
53        result.reaction(base_left, Dof::Ux)?,
54        result.reaction(base_left, Dof::Uy)?,
55        result.reaction(base_left, Dof::Rz)?
56    );
57    println!(
58        "right base reaction  : Rx={:+.6e}  Ry={:+.6e}",
59        result.reaction(base_right, Dof::Ux)?,
60        result.reaction(base_right, Dof::Uy)?
61    );
62
63    // Member end forces are element-on-node forces in LOCAL axes:
64    // [N_i, V_i, M_i, N_j, V_j, M_j] = f_equiv - K_e u_e.
65    println!(
66        "beam end forces (local)  : {:?}",
67        result.member_end_forces(beam)?
68    );
69    println!(
70        "left column global ends  : {:?}",
71        result.member_end_forces_global(col_left)?
72    );
73    println!(
74        "right column global ends : {:?}",
75        result.member_end_forces_global(col_right)?
76    );
77
78    // --- equilibrium -----------------------------------------------------------
79    let eq = result.equilibrium();
80    println!(
81        "equilibrium residual : sumFx={:+.3e}  sumFy={:+.3e}  sumMz={:+.3e}  (about the origin)",
82        eq.fx_residual, eq.fy_residual, eq.mz_residual
83    );
84    println!("balanced             : {}", eq.is_balanced());
85
86    Ok(())
87}
Source

pub fn member_point_load( &mut self, member: MemberHandle, xi: f64, fx: f64, fy: f64, mz: f64, ) -> Result<(), FemError>

Apply a point load in the member’s local axes at normalised position xi in [0, 1].

xi = 0 / xi = 1 places the load at a node; it is applied exactly once (no double counting).

§Errors

FemError::InvalidMember if the handle is not valid.

Source

pub fn solve(&self) -> Result<FrameAnalysisResult, FemError>

Solve with automatic solver selection.

Equivalent to self.solve_with(SolverSelection::Auto). The registry inspects the condensed stiffness matrix and picks a backend (dense for small systems, skyline LDLᵀ for symmetric positive-definite, sparse LU otherwise). The selected solver is used exactly once; if it fails the error is returned directly — there is no automatic retry with a different backend.

Source

pub fn solve_with( &self, selection: SolverSelection, ) -> Result<FrameAnalysisResult, FemError>

Solve with an explicit backend selection.

Validates the model (see Self::validate) before assembling, so structural modelling errors are reported as targeted diagnostics rather than as a matrix singularity.

Solver semantics:

After solving, FrameAnalysisResult::solver_name reports which backend was actually used.

Examples found in repository?
examples/frame_portal.rs (line 38)
13fn main() -> Result<(), Box<dyn std::error::Error>> {
14    let (e, a, i) = (200e9, 5e-3, 2e-5);
15    let (h, w) = (3.0, 4.0);
16    let lateral = 20e3; // N, +X
17    let udl = -8e3; // N/m, downward in member-local +y
18
19    // --- model -----------------------------------------------------------------
20    let mut frame = FrameModel::new();
21    let base_left = frame.add_node(0.0, 0.0)?;
22    let top_left = frame.add_node(0.0, h)?;
23    let top_right = frame.add_node(w, h)?;
24    let base_right = frame.add_node(w, 0.0)?;
25
26    let section = BeamSection::new(a, i);
27    let mat = Material::new(e, 0.3, 7850.0, "Steel");
28    let col_left = frame.add_member(base_left, top_left, mat, section)?;
29    let beam = frame.add_member(top_left, top_right, mat, section)?;
30    let col_right = frame.add_member(top_right, base_right, mat, section)?;
31
32    frame.fix(base_left)?;
33    frame.fix(base_right)?;
34    frame.nodal_load(top_left, lateral, 0.0)?; // global
35    frame.member_udl(beam, 0.0, udl)?; // local
36
37    // --- solve -----------------------------------------------------------------
38    let result = frame.solve_with(SolverSelection::named("sparse_lu"))?;
39    println!("backend              : {:?}", result.solver_name());
40    println!(
41        "nodes / members      : {} / {}",
42        result.n_nodes(),
43        result.n_members()
44    );
45
46    // --- results ---------------------------------------------------------------
47    println!(
48        "roof sway (ux)       : {:+.6e} m",
49        result.displacement(top_left, Dof::Ux)?
50    );
51    println!(
52        "base reactions       : Rx={:+.6e}  Ry={:+.6e}  Mz={:+.6e}",
53        result.reaction(base_left, Dof::Ux)?,
54        result.reaction(base_left, Dof::Uy)?,
55        result.reaction(base_left, Dof::Rz)?
56    );
57    println!(
58        "right base reaction  : Rx={:+.6e}  Ry={:+.6e}",
59        result.reaction(base_right, Dof::Ux)?,
60        result.reaction(base_right, Dof::Uy)?
61    );
62
63    // Member end forces are element-on-node forces in LOCAL axes:
64    // [N_i, V_i, M_i, N_j, V_j, M_j] = f_equiv - K_e u_e.
65    println!(
66        "beam end forces (local)  : {:?}",
67        result.member_end_forces(beam)?
68    );
69    println!(
70        "left column global ends  : {:?}",
71        result.member_end_forces_global(col_left)?
72    );
73    println!(
74        "right column global ends : {:?}",
75        result.member_end_forces_global(col_right)?
76    );
77
78    // --- equilibrium -----------------------------------------------------------
79    let eq = result.equilibrium();
80    println!(
81        "equilibrium residual : sumFx={:+.3e}  sumFy={:+.3e}  sumMz={:+.3e}  (about the origin)",
82        eq.fx_residual, eq.fy_residual, eq.mz_residual
83    );
84    println!("balanced             : {}", eq.is_balanced());
85
86    Ok(())
87}
Source

pub fn solver(&self) -> FrameSolver<'_>

A solver builder for this frame (configure a backend, then solve).

Source

pub fn validate(&self) -> Result<(), FemError>

Validate the structural model.

Checks, in order:

  1. the model is not empty (at least one node and one member);
  2. no orphan nodes - every node is used by at least one member;
  3. the members form a single connected component.

Per-element checks (zero length, duplicate connectivity, invalid material/section) are enforced when the member is added.

Insufficient restraint is not diagnosed here: Self::diagnostic classifies the boundary-conditioned system separately, without rejecting the model, and FrameSolver::solve attaches that classification to the solver error when the solve fails.

Source

pub fn diagnostic(&self) -> Result<StructuralDiagnostic, FemError>

Diagnose the boundary-conditioned (reduced) system without solving it: is this structure stable, under-restrained (rigid-body mechanism), internally rank deficient (mechanism), or merely numerically ill-conditioned?

The diagnosis reads the reduced free-free stiffness block K_ff that the actual solve path condenses (BeamSolver::condense) — the exact matrix a solve factorises, not a second assembly — and classifies it with relative, scale-invariant probes (see crate::fea::mechanism for the criterion and its limits). It never assembles with penalties, never perturbs the matrix and never fabricates displacements, and it does not run as part of a successful Self::solve.

The verdict is a property of the structure, not of the loads: the load vector is not consulted, so scaling or omitting the loads cannot change the result.

§Errors

The same model errors as Self::solve: Self::validate plus the construction checks BeamSolver::from_model performs (its error surface is slightly wider than validate alone).

Source

pub fn node_handle(&self, index: usize) -> Result<NodeHandle, FemError>

Handle of the node with the given index.

§Errors

FemError::InvalidNode if the index is out of range.

Source

pub fn member_handle(&self, index: usize) -> Result<MemberHandle, FemError>

Handle of the member with the given index.

§Errors

FemError::InvalidMember if the index is out of range.

Trait Implementations§

Source§

impl Clone for FrameModel

Source§

fn clone(&self) -> Self

Returns a duplicate of the value. Read more
1.0.0 (const: unstable) · Source§

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

Performs copy-assignment from source. Read more
Source§

impl Debug for FrameModel

Source§

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

Formats the value using the given formatter. Read more
Source§

impl Default for FrameModel

Source§

fn default() -> Self

Returns the “default value” for a type. Read more

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> CloneToUninit for T
where T: Clone,

Source§

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dest. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> ToOwned for T
where T: Clone,

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = !

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, !>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.