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
impl FrameModel
Sourcepub fn new() -> Self
pub fn new() -> Self
Create an empty frame.
Examples found in repository?
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}Sourcepub fn add_node(&mut self, x: f64, y: f64) -> Result<NodeHandle, FemError>
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?
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}Sourcepub fn add_member(
&mut self,
a: NodeHandle,
b: NodeHandle,
material: Material,
section: BeamSection,
) -> Result<MemberHandle, FemError>
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
FemError::InvalidNodeif either handle is not valid for this model;FemError::ZeroLengthMemberif the two nodes coincide;FemError::DuplicateMemberif a member already connects the same node pair (in either order) - parallel members are not supported;FemError::InvalidInputifE,AorIis non-finite or non-positive (the same predicate the solver applies at assembly time).
Examples found in repository?
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}Sourcepub fn fix(&mut self, node: NodeHandle) -> Result<(), FemError>
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?
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}Sourcepub fn pin(&mut self, node: NodeHandle) -> Result<(), FemError>
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.
Sourcepub fn roller_y(&mut self, node: NodeHandle) -> Result<(), FemError>
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.
Sourcepub fn roller_x(&mut self, node: NodeHandle) -> Result<(), FemError>
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.
Sourcepub fn restrain(
&mut self,
node: NodeHandle,
dof: Dof,
value: f64,
) -> Result<(), FemError>
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.
Sourcepub fn nodal_load(
&mut self,
node: NodeHandle,
fx: f64,
fy: f64,
) -> Result<(), FemError>
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?
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}Sourcepub fn nodal_moment(
&mut self,
node: NodeHandle,
mz: f64,
) -> Result<(), FemError>
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.
Sourcepub fn member_udl(
&mut self,
member: MemberHandle,
qx: f64,
qy: f64,
) -> Result<(), FemError>
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?
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}Sourcepub fn member_point_load(
&mut self,
member: MemberHandle,
xi: f64,
fx: f64,
fy: f64,
mz: f64,
) -> Result<(), FemError>
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.
Sourcepub fn solve(&self) -> Result<FrameAnalysisResult, FemError>
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.
Sourcepub fn solve_with(
&self,
selection: SolverSelection,
) -> Result<FrameAnalysisResult, FemError>
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:
SolverSelection::Auto— the registry inspects the matrix and selects a backend. The chosen solver is used exactly once; if it fails, the error is returned directly (no automatic retry with a different backend).SolverSelection::Named— the requested solver is used only; no silent fallback. If the solver is unavailable or fails, the error is returned directly. Use the convenience constructorsSolverSelection::dense,SolverSelection::skyline_ldlt,SolverSelection::sparse_lu,SolverSelection::cg,SolverSelection::iccgfor typed selection.
After solving, FrameAnalysisResult::solver_name reports which
backend was actually used.
Examples found in repository?
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}Sourcepub fn solver(&self) -> FrameSolver<'_>
pub fn solver(&self) -> FrameSolver<'_>
A solver builder for this frame (configure a backend, then solve).
Sourcepub fn validate(&self) -> Result<(), FemError>
pub fn validate(&self) -> Result<(), FemError>
Validate the structural model.
Checks, in order:
- the model is not empty (at least one node and one member);
- no orphan nodes - every node is used by at least one member;
- 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.
Sourcepub fn diagnostic(&self) -> Result<StructuralDiagnostic, FemError>
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).
Sourcepub fn node_handle(&self, index: usize) -> Result<NodeHandle, FemError>
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.
Sourcepub fn member_handle(&self, index: usize) -> Result<MemberHandle, FemError>
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.