#![allow(non_snake_case)]
use crate::fea::{
SparseMatrix,
solver::{LinearSolver, SolverError, SolverRegistry, SolverSelection},
};
use crate::geometry::Point;
use crate::material::Material;
#[derive(Debug, Clone, Copy)]
pub struct BeamSection {
pub area: f64,
pub second_moment: f64,
}
impl BeamSection {
pub fn new(area: f64, second_moment: f64) -> Self {
Self {
area,
second_moment,
}
}
pub fn rectangle(width: f64, height: f64) -> Self {
let area = width * height;
let second_moment = width * height.powi(3) / 12.0;
Self {
area,
second_moment,
}
}
pub fn circle(radius: f64) -> Self {
let area = std::f64::consts::PI * radius * radius;
let second_moment = std::f64::consts::PI * radius.powi(4) / 4.0;
Self {
area,
second_moment,
}
}
pub fn circle_hollow(outer_radius: f64, inner_radius: f64) -> Self {
let area =
std::f64::consts::PI * (outer_radius * outer_radius - inner_radius * inner_radius);
let second_moment =
std::f64::consts::PI * (outer_radius.powi(4) - inner_radius.powi(4)) / 4.0;
Self {
area,
second_moment,
}
}
pub fn from_section_properties_x(props: &crate::section_properties::SectionProperties) -> Self {
Self {
area: props.area,
second_moment: props.ix,
}
}
pub fn from_section_properties_y(props: &crate::section_properties::SectionProperties) -> Self {
Self {
area: props.area,
second_moment: props.iy,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct SectionForces {
pub axial: f64,
pub shear: f64,
pub moment: f64,
}
impl SectionForces {
pub fn new(axial: f64, shear: f64, moment: f64) -> Self {
Self {
axial,
shear,
moment,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct BeamForceSample {
pub element_index: usize,
pub xi: f64,
pub x: f64,
pub section_forces: SectionForces,
}
#[derive(Debug, Clone)]
pub struct BeamForceDiagram {
pub samples: Vec<BeamForceSample>,
}
impl BeamForceDiagram {
pub fn new(samples: Vec<BeamForceSample>) -> Self {
Self { samples }
}
pub fn axial(&self) -> Vec<f64> {
self.samples
.iter()
.map(|s| s.section_forces.axial)
.collect()
}
pub fn shear(&self) -> Vec<f64> {
self.samples
.iter()
.map(|s| s.section_forces.shear)
.collect()
}
pub fn moment(&self) -> Vec<f64> {
self.samples
.iter()
.map(|s| s.section_forces.moment)
.collect()
}
pub fn x(&self) -> Vec<f64> {
self.samples.iter().map(|s| s.x).collect()
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct BeamNodalDisplacement {
pub ux: f64,
pub uy: f64,
pub rz: f64,
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct BeamReaction {
pub fx: f64,
pub fy: f64,
pub mz: f64,
}
#[derive(Clone)]
pub struct BeamAnalysisResult<'a> {
solver: &'a BeamSolver,
reactions: Vec<f64>,
}
impl std::fmt::Debug for BeamAnalysisResult<'_> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("BeamAnalysisResult")
.field("nodes", &self.solver.model.nodes.len())
.field("elements", &self.solver.model.elements.len())
.finish_non_exhaustive()
}
}
impl<'a> BeamAnalysisResult<'a> {
pub fn n_nodes(&self) -> usize {
self.solver.model.nodes.len()
}
pub fn n_elements(&self) -> usize {
self.solver.model.elements.len()
}
pub fn solver_name(&self) -> Option<&str> {
self.solver.solver_name()
}
pub fn displacements(&self) -> &[f64] {
&self.solver.u_global
}
pub fn displacement(&self, node_index: usize) -> Result<BeamNodalDisplacement, FemError> {
if node_index >= self.solver.model.nodes.len() {
return Err(FemError::InvalidInput(format!(
"Invalid node index: {} (max: {})",
node_index,
self.solver.model.nodes.len().saturating_sub(1)
)));
}
Ok(BeamNodalDisplacement {
ux: self.solver.displacement(node_index, 0)?,
uy: self.solver.displacement(node_index, 1)?,
rz: self.solver.displacement(node_index, 2)?,
})
}
pub fn reaction(&self, node_index: usize) -> Result<BeamReaction, FemError> {
if node_index >= self.solver.model.nodes.len() {
return Err(FemError::InvalidInput(format!(
"Invalid node index: {} (max: {})",
node_index,
self.solver.model.nodes.len().saturating_sub(1)
)));
}
let base = self.solver.model.dof_index(node_index, 0);
Ok(BeamReaction {
fx: self.reactions[base],
fy: self.reactions[base + 1],
mz: self.reactions[base + 2],
})
}
pub fn element_end_forces(&self, element_index: usize) -> Result<[f64; 6], FemError> {
self.solver.element_on_node_end_forces_local(element_index)
}
pub fn section_forces(&self, element_index: usize, xi: f64) -> Result<SectionForces, FemError> {
self.solver.element_section_forces(element_index, xi)
}
pub fn sample_forces(&self, n_per_element: usize) -> Result<Vec<BeamForceSample>, FemError> {
self.solver.sample_beam_forces(n_per_element)
}
pub fn diagram(&self, n_per_element: usize) -> Result<BeamForceDiagram, FemError> {
self.solver.beam_force_diagram(n_per_element)
}
}
#[derive(Debug, Clone)]
pub struct BeamElement {
pub node_i: usize,
pub node_j: usize,
pub material: Material,
pub section: BeamSection,
}
impl BeamElement {
pub fn new(
node_i: usize,
node_j: usize,
material: Material,
section: BeamSection,
) -> Result<Self, FemError> {
if node_i == node_j {
return Err(FemError::InvalidModel(
"Beam element cannot have same start and end node".to_string(),
));
}
Ok(Self {
node_i,
node_j,
material,
section,
})
}
pub fn length(&self, node_i: Point, node_j: Point) -> f64 {
let dx = node_j.x - node_i.x;
let dy = node_j.y - node_i.y;
(dx * dx + dy * dy).sqrt()
}
pub fn local_stiffness(&self, node_i: Point, node_j: Point) -> [[f64; 6]; 6] {
let L = self.length(node_i, node_j);
if L <= 0.0 {
return [[0.0; 6]; 6];
}
let E = self.material.youngs_modulus;
let A = self.section.area;
let I = self.section.second_moment;
let EA_L = E * A / L;
let EI_L3 = E * I / L.powi(3);
let EI_L2 = E * I / L.powi(2);
let EI_L = E * I / L;
let mut k = [[0.0; 6]; 6];
k[0][0] = EA_L;
k[0][3] = -EA_L;
k[3][0] = -EA_L;
k[3][3] = EA_L;
k[1][1] = 12.0 * EI_L3;
k[1][2] = 6.0 * EI_L2;
k[1][4] = -12.0 * EI_L3;
k[1][5] = 6.0 * EI_L2;
k[2][1] = 6.0 * EI_L2;
k[2][2] = 4.0 * EI_L;
k[2][4] = -6.0 * EI_L2;
k[2][5] = 2.0 * EI_L;
k[4][1] = -12.0 * EI_L3;
k[4][2] = -6.0 * EI_L2;
k[4][4] = 12.0 * EI_L3;
k[4][5] = -6.0 * EI_L2;
k[5][1] = 6.0 * EI_L2;
k[5][2] = 2.0 * EI_L;
k[5][4] = -6.0 * EI_L2;
k[5][5] = 4.0 * EI_L;
k
}
pub fn transformation_matrix(&self, node_i: Point, node_j: Point) -> [[f64; 6]; 6] {
let dx = node_j.x - node_i.x;
let dy = node_j.y - node_i.y;
let L = (dx * dx + dy * dy).sqrt();
if L <= 0.0 {
return [[0.0; 6]; 6];
}
let c = dx / L;
let s = dy / L;
let mut T = [[0.0; 6]; 6];
T[0][0] = c;
T[0][1] = s;
T[1][0] = -s;
T[1][1] = c;
T[2][2] = 1.0;
T[3][3] = c;
T[3][4] = s;
T[4][3] = -s;
T[4][4] = c;
T[5][5] = 1.0;
T
}
pub fn to_local_force(&self, node_i: Point, node_j: Point, gx: f64, gy: f64) -> (f64, f64) {
let t = self.transformation_matrix(node_i, node_j);
(t[0][0] * gx + t[0][1] * gy, t[1][0] * gx + t[1][1] * gy)
}
pub fn global_stiffness(&self, node_i: Point, node_j: Point) -> [[f64; 6]; 6] {
let k_local = self.local_stiffness(node_i, node_j);
let T = self.transformation_matrix(node_i, node_j);
let mut k_global = [[0.0; 6]; 6];
for i in 0..6 {
for j in 0..6 {
let mut sum = 0.0;
for k in 0..6 {
for l in 0..6 {
sum += T[k][i] * k_local[k][l] * T[l][j];
}
}
k_global[i][j] = sum;
}
}
k_global
}
pub fn consistent_nodal_load(
&self,
node_i: Point,
node_j: Point,
qx: f64,
qy: f64,
) -> Result<[f64; 6], FemError> {
let L = self.length(node_i, node_j);
if L <= 0.0 {
return Err(FemError::InvalidInput(
"Beam element has zero or negative length for distributed load".to_string(),
));
}
let qx_L2 = qx * L / 2.0;
let qy_L2 = qy * L / 2.0;
let qy_L2_12 = qy * L * L / 12.0;
Ok([
qx_L2, qy_L2, qy_L2_12, qx_L2, qy_L2, -qy_L2_12, ])
}
pub fn consistent_nodal_load_point(
&self,
node_i: Point,
node_j: Point,
position: f64,
fx: f64,
fy: f64,
mz: f64,
) -> Result<[f64; 6], FemError> {
let L = self.length(node_i, node_j);
if L <= 0.0 {
return Err(FemError::InvalidInput(
"Beam element has zero or negative length for point load".to_string(),
));
}
if !(0.0..=1.0).contains(&position) {
return Err(FemError::InvalidInput(format!(
"Point load position must be in [0, 1], got {}",
position
)));
}
let xi = position; let one_minus_xi = 1.0 - xi;
let f_u_i = fx * one_minus_xi;
let f_u_j = fx * xi;
let xi2 = xi * xi;
let xi3 = xi2 * xi;
let N1 = 1.0 - 3.0 * xi2 + 2.0 * xi3;
let N2 = L * (xi - 2.0 * xi2 + xi3);
let N3 = 3.0 * xi2 - 2.0 * xi3;
let N4 = L * (-xi2 + xi3);
let f_v_i = fy * N1;
let f_theta_i = fy * N2;
let f_v_j = fy * N3;
let f_theta_j = fy * N4;
let one_minus_xi = 1.0 - xi;
let f_v_i_moment = mz * (-6.0 * xi * one_minus_xi / L); let f_theta_i_moment = mz * (1.0 - 4.0 * xi + 3.0 * xi2); let f_v_j_moment = mz * (6.0 * xi * one_minus_xi / L); let f_theta_j_moment = mz * (-2.0 * xi + 3.0 * xi2);
Ok([
f_u_i, f_v_i + f_v_i_moment, f_theta_i + f_theta_i_moment, f_u_j, f_v_j + f_v_j_moment, f_theta_j + f_theta_j_moment, ])
}
}
#[derive(Debug, Clone, Copy)]
pub struct BeamNode {
pub id: usize,
pub x: f64,
pub y: f64,
}
impl BeamNode {
pub fn new(id: usize, x: f64, y: f64) -> Self {
Self { id, x, y }
}
pub fn point(&self) -> Point {
Point::new(self.x, self.y)
}
}
#[derive(Debug, Clone, Copy)]
pub struct DistributedLoad {
pub element_idx: usize,
pub qx: f64,
pub qy: f64,
}
impl DistributedLoad {
pub fn new(element_idx: usize, qx: f64, qy: f64) -> Self {
Self {
element_idx,
qx,
qy,
}
}
pub fn transverse(element_idx: usize, qy: f64) -> Self {
Self {
element_idx,
qx: 0.0,
qy,
}
}
pub fn axial(element_idx: usize, qx: f64) -> Self {
Self {
element_idx,
qx,
qy: 0.0,
}
}
}
#[derive(Debug, Clone, Copy)]
pub struct PointLoad {
pub element_idx: usize,
pub position: f64,
pub fx: f64,
pub fy: f64,
pub mz: f64,
}
impl PointLoad {
pub fn new(element_idx: usize, position: f64, fx: f64, fy: f64, mz: f64) -> Self {
Self {
element_idx,
position,
fx,
fy,
mz,
}
}
pub fn transverse_force(element_idx: usize, position: f64, fy: f64) -> Self {
Self {
element_idx,
position,
fx: 0.0,
fy,
mz: 0.0,
}
}
pub fn axial_force(element_idx: usize, position: f64, fx: f64) -> Self {
Self {
element_idx,
position,
fx,
fy: 0.0,
mz: 0.0,
}
}
pub fn moment(element_idx: usize, position: f64, mz: f64) -> Self {
Self {
element_idx,
position,
fx: 0.0,
fy: 0.0,
mz,
}
}
}
#[derive(Debug, Clone, Copy)]
pub struct AppliedMoment {
pub node_idx: usize,
pub value: f64,
}
impl AppliedMoment {
pub fn new(node_idx: usize, value: f64) -> Self {
Self { node_idx, value }
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum Dof {
Ux,
Uy,
Rz,
}
impl Dof {
pub const ALL: [Dof; 3] = [Dof::Ux, Dof::Uy, Dof::Rz];
pub const fn index(self) -> usize {
match self {
Self::Ux => 0,
Self::Uy => 1,
Self::Rz => 2,
}
}
pub const fn name(self) -> &'static str {
match self {
Self::Ux => "ux",
Self::Uy => "uy",
Self::Rz => "rz",
}
}
}
impl From<Dof> for usize {
fn from(dof: Dof) -> Self {
dof.index()
}
}
impl TryFrom<usize> for Dof {
type Error = FemError;
fn try_from(value: usize) -> Result<Self, FemError> {
match value {
0 => Ok(Self::Ux),
1 => Ok(Self::Uy),
2 => Ok(Self::Rz),
other => Err(FemError::InvalidInput(format!(
"Invalid DOF: {} (must be 0, 1, or 2)",
other
))),
}
}
}
#[derive(Debug, Clone)]
pub struct BeamModel {
pub nodes: Vec<BeamNode>,
pub elements: Vec<BeamElement>,
pub nodal_forces: Vec<(usize, usize, f64)>,
pub distributed_loads: Vec<DistributedLoad>,
pub point_loads: Vec<PointLoad>,
pub applied_moments: Vec<AppliedMoment>,
pub fixed_dofs: Vec<(usize, usize, f64)>,
}
impl Default for BeamModel {
fn default() -> Self {
Self::new()
}
}
impl BeamModel {
pub fn new() -> Self {
Self {
nodes: Vec::new(),
elements: Vec::new(),
nodal_forces: Vec::new(),
distributed_loads: Vec::new(),
point_loads: Vec::new(),
applied_moments: Vec::new(),
fixed_dofs: Vec::new(),
}
}
pub fn add_node(&mut self, node: BeamNode) {
self.nodes.push(node);
}
pub fn add_element(&mut self, element: BeamElement) {
self.elements.push(element);
}
pub fn add_nodal_force(&mut self, node_idx: usize, dof: usize, value: f64) {
self.try_add_nodal_force(node_idx, dof, value)
.unwrap_or_else(|e| panic!("{}", e));
}
pub fn try_add_nodal_force(
&mut self,
node_idx: usize,
dof: usize,
value: f64,
) -> Result<(), FemError> {
if node_idx >= self.nodes.len() {
return Err(FemError::InvalidInput(format!(
"Invalid node index: {} (max: {})",
node_idx,
self.nodes.len().saturating_sub(1)
)));
}
if dof >= 3 {
return Err(FemError::InvalidInput(format!(
"Invalid DOF: {} (must be 0, 1, or 2)",
dof
)));
}
if !value.is_finite() {
return Err(FemError::InvalidInput(format!(
"Nodal force must be finite, got {}",
value
)));
}
self.nodal_forces.push((node_idx, dof, value));
Ok(())
}
pub fn fix_dof(&mut self, node_idx: usize, dof: usize, value: f64) {
self.try_fix_dof(node_idx, dof, value)
.unwrap_or_else(|e| panic!("{}", e));
}
pub fn try_fix_dof(&mut self, node_idx: usize, dof: usize, value: f64) -> Result<(), FemError> {
if node_idx >= self.nodes.len() {
return Err(FemError::InvalidInput(format!(
"Invalid node index: {} (max: {})",
node_idx,
self.nodes.len().saturating_sub(1)
)));
}
if dof >= 3 {
return Err(FemError::InvalidInput(format!(
"Invalid DOF: {} (must be 0, 1, or 2)",
dof
)));
}
if !value.is_finite() {
return Err(FemError::InvalidInput(format!(
"Prescribed value must be finite, got {}",
value
)));
}
for &(n, d, v) in &self.fixed_dofs {
if n == node_idx && d == dof {
let scale = (v.abs() + value.abs()).max(1.0);
if (v - value).abs() > 1e-12 * scale {
return Err(FemError::ConflictingPrescribedDisplacement {
node_idx,
dof,
first_value: v,
conflicting_value: value,
});
}
return Ok(());
}
}
self.fixed_dofs.push((node_idx, dof, value));
Ok(())
}
pub fn try_override_dof(
&mut self,
node_idx: usize,
dof: usize,
value: f64,
) -> Result<(), FemError> {
if node_idx >= self.nodes.len() {
return Err(FemError::InvalidInput(format!(
"Invalid node index: {} (max: {})",
node_idx,
self.nodes.len().saturating_sub(1)
)));
}
if dof >= 3 {
return Err(FemError::InvalidInput(format!(
"Invalid DOF: {} (must be 0, 1, or 2)",
dof
)));
}
if !value.is_finite() {
return Err(FemError::InvalidInput(format!(
"Prescribed value must be finite, got {}",
value
)));
}
for entry in &mut self.fixed_dofs {
if entry.0 == node_idx && entry.1 == dof {
entry.2 = value;
return Ok(());
}
}
self.fixed_dofs.push((node_idx, dof, value));
Ok(())
}
pub fn fix_node(&mut self, node_idx: usize) {
self.try_fix_node(node_idx)
.unwrap_or_else(|e| panic!("{}", e));
}
pub fn try_fix_node(&mut self, node_idx: usize) -> Result<(), FemError> {
if node_idx >= self.nodes.len() {
return Err(FemError::InvalidInput(format!(
"Invalid node index: {} (max: {})",
node_idx,
self.nodes.len().saturating_sub(1)
)));
}
self.try_fix_dof(node_idx, 0, 0.0)?;
self.try_fix_dof(node_idx, 1, 0.0)?;
self.try_fix_dof(node_idx, 2, 0.0)?;
Ok(())
}
pub fn try_fix(&mut self, node_idx: usize, dof: Dof, value: f64) -> Result<(), FemError> {
self.try_fix_dof(node_idx, dof.index(), value)
}
pub fn try_override(&mut self, node_idx: usize, dof: Dof, value: f64) -> Result<(), FemError> {
self.try_override_dof(node_idx, dof.index(), value)
}
pub fn try_fix_node_with_values(
&mut self,
node_idx: usize,
ux: f64,
uy: f64,
rz: f64,
) -> Result<(), FemError> {
if node_idx >= self.nodes.len() {
return Err(FemError::InvalidInput(format!(
"Invalid node index: {} (max: {})",
node_idx,
self.nodes.len().saturating_sub(1)
)));
}
for (dof, value) in [(Dof::Ux, ux), (Dof::Uy, uy), (Dof::Rz, rz)] {
if !value.is_finite() {
return Err(FemError::InvalidInput(format!(
"Prescribed value for {} must be finite, got {}",
dof.name(),
value
)));
}
}
self.try_override_dof(node_idx, Dof::Ux.index(), ux)?;
self.try_override_dof(node_idx, Dof::Uy.index(), uy)?;
self.try_override_dof(node_idx, Dof::Rz.index(), rz)?;
Ok(())
}
pub fn add_distributed_load(
&mut self,
element_idx: usize,
qx: f64,
qy: f64,
) -> Result<(), FemError> {
if element_idx >= self.elements.len() {
return Err(FemError::InvalidInput(format!(
"Invalid element index: {} (max: {})",
element_idx,
self.elements.len().saturating_sub(1)
)));
}
if !qx.is_finite() || !qy.is_finite() {
return Err(FemError::InvalidInput(format!(
"Distributed load must be finite, got qx = {}, qy = {}",
qx, qy
)));
}
self.distributed_loads
.push(DistributedLoad::new(element_idx, qx, qy));
Ok(())
}
pub fn add_point_load(
&mut self,
element_idx: usize,
position: f64,
fx: f64,
fy: f64,
mz: f64,
) -> Result<(), FemError> {
if element_idx >= self.elements.len() {
return Err(FemError::InvalidInput(format!(
"Invalid element index: {} (max: {})",
element_idx,
self.elements.len().saturating_sub(1)
)));
}
if !(0.0..=1.0).contains(&position) {
return Err(FemError::InvalidInput(format!(
"Point load position must be in [0, 1], got {}",
position
)));
}
if !fx.is_finite() || !fy.is_finite() || !mz.is_finite() {
return Err(FemError::InvalidInput(format!(
"Point load must be finite, got fx = {}, fy = {}, mz = {}",
fx, fy, mz
)));
}
self.point_loads
.push(PointLoad::new(element_idx, position, fx, fy, mz));
Ok(())
}
pub fn add_point_force(
&mut self,
element_idx: usize,
position: f64,
fx: f64,
fy: f64,
) -> Result<(), FemError> {
self.add_point_load(element_idx, position, fx, fy, 0.0)
}
pub fn add_point_moment(
&mut self,
element_idx: usize,
position: f64,
mz: f64,
) -> Result<(), FemError> {
self.add_point_load(element_idx, position, 0.0, 0.0, mz)
}
pub fn add_applied_moment(&mut self, node_idx: usize, value: f64) -> Result<(), FemError> {
if node_idx >= self.nodes.len() {
return Err(FemError::InvalidInput(format!(
"Invalid node index: {} (max: {})",
node_idx,
self.nodes.len().saturating_sub(1)
)));
}
if !value.is_finite() {
return Err(FemError::InvalidInput(format!(
"Applied moment must be finite, got {}",
value
)));
}
self.applied_moments
.push(AppliedMoment::new(node_idx, value));
Ok(())
}
pub fn n_dof(&self) -> usize {
self.nodes.len() * 3
}
pub(crate) fn dof_index(&self, node_idx: usize, dof: usize) -> usize {
node_idx * 3 + dof
}
}
#[derive(Debug, Clone)]
pub(crate) struct ReducedSystem {
k_ff: SparseMatrix,
free_to_global: Vec<usize>,
}
impl ReducedSystem {
pub(crate) fn new(k_ff: SparseMatrix, free_to_global: Vec<usize>) -> Self {
Self {
k_ff,
free_to_global,
}
}
pub(crate) fn k_ff(&self) -> &SparseMatrix {
&self.k_ff
}
pub(crate) fn free_to_global(&self) -> &[usize] {
&self.free_to_global
}
}
pub struct BeamSolver {
k_global: SparseMatrix,
f_global: Vec<f64>,
u_global: Vec<f64>,
fixed_dofs: Vec<bool>,
prescribed_values: Vec<Option<f64>>,
k_original: SparseMatrix,
n_dof: usize,
model: BeamModel,
solver_selection: SolverSelection,
solver_name: Option<String>,
reduced: Option<ReducedSystem>,
}
impl BeamSolver {
pub fn from_model(model: &BeamModel) -> Result<Self, FemError> {
let n_dof = model.n_dof();
if n_dof == 0 {
return Err(FemError::InvalidModel("Model has no nodes".to_string()));
}
for (elem_idx, element) in model.elements.iter().enumerate() {
if element.node_i >= model.nodes.len() {
return Err(FemError::InvalidModel(format!(
"Element {}: node_i index {} out of bounds (max: {})",
elem_idx,
element.node_i,
model.nodes.len().saturating_sub(1)
)));
}
if element.node_j >= model.nodes.len() {
return Err(FemError::InvalidModel(format!(
"Element {}: node_j index {} out of bounds (max: {})",
elem_idx,
element.node_j,
model.nodes.len().saturating_sub(1)
)));
}
if element.node_i == element.node_j {
return Err(FemError::InvalidModel(format!(
"Element {}: node_i and node_j cannot be the same",
elem_idx
)));
}
}
for (idx, node) in model.nodes.iter().enumerate() {
if !node.x.is_finite() || !node.y.is_finite() {
return Err(FemError::InvalidModel(format!(
"Node {} has non-finite coordinates: ({}, {})",
idx, node.x, node.y
)));
}
}
for (elem_idx, element) in model.elements.iter().enumerate() {
let e = element.material.youngs_modulus;
let a = element.section.area;
let i = element.section.second_moment;
if !e.is_finite() || e <= 0.0 {
return Err(FemError::InvalidModel(format!(
"Element {}: Young's modulus must be finite and positive, got {}",
elem_idx, e
)));
}
if !a.is_finite() || a <= 0.0 {
return Err(FemError::InvalidModel(format!(
"Element {}: cross-section area must be finite and positive, got {}",
elem_idx, a
)));
}
if !i.is_finite() || i <= 0.0 {
return Err(FemError::InvalidModel(format!(
"Element {}: second moment of area must be finite and positive, got {}",
elem_idx, i
)));
}
}
for (node_id, dof, value) in &model.nodal_forces {
if !value.is_finite() {
return Err(FemError::InvalidModel(format!(
"Nodal force at node {} DOF {} is non-finite: {}",
node_id, dof, value
)));
}
}
for dl in &model.distributed_loads {
if !dl.qx.is_finite() || !dl.qy.is_finite() {
return Err(FemError::InvalidModel(format!(
"Distributed load on element {} is non-finite: qx = {}, qy = {}",
dl.element_idx, dl.qx, dl.qy
)));
}
}
for pl in &model.point_loads {
if !pl.fx.is_finite() || !pl.fy.is_finite() || !pl.mz.is_finite() {
return Err(FemError::InvalidModel(format!(
"Point load on element {} is non-finite: fx = {}, fy = {}, mz = {}",
pl.element_idx, pl.fx, pl.fy, pl.mz
)));
}
}
for am in &model.applied_moments {
if !am.value.is_finite() {
return Err(FemError::InvalidModel(format!(
"Applied moment at node {} is non-finite: {}",
am.node_idx, am.value
)));
}
}
for (node_id, dof, value) in &model.fixed_dofs {
if !value.is_finite() {
return Err(FemError::InvalidModel(format!(
"Prescribed value at node {} DOF {} is non-finite: {}",
node_id, dof, value
)));
}
}
let mut k_global = SparseMatrix::new(n_dof);
for element in &model.elements {
let node_i = model.nodes[element.node_i].point();
let node_j = model.nodes[element.node_j].point();
let dx = node_j.x - node_i.x;
let dy = node_j.y - node_i.y;
let L = (dx * dx + dy * dy).sqrt();
if L <= 0.0 {
return Err(FemError::InvalidModel(format!(
"Beam element has zero or negative length (nodes {} and {} at same position)",
element.node_i, element.node_j
)));
}
let k_global_elem = element.global_stiffness(node_i, node_j);
let dof_map = [
model.dof_index(element.node_i, 0), model.dof_index(element.node_i, 1), model.dof_index(element.node_i, 2), model.dof_index(element.node_j, 0), model.dof_index(element.node_j, 1), model.dof_index(element.node_j, 2), ];
for a in 0..6 {
for b in 0..6 {
let val = k_global_elem[a][b];
k_global.add(dof_map[a], dof_map[b], val);
}
}
}
let mut f_global = vec![0.0; n_dof];
for (node_id, dof, value) in &model.nodal_forces {
if *node_id >= model.nodes.len() {
return Err(FemError::InvalidModel(format!(
"Nodal force: node index {} out of bounds (max: {})",
node_id,
model.nodes.len().saturating_sub(1)
)));
}
if *dof >= 3 {
return Err(FemError::InvalidModel(format!(
"Nodal force: DOF {} invalid (must be 0, 1, or 2)",
dof
)));
}
let idx = model.dof_index(*node_id, *dof);
f_global[idx] += value;
}
for dl in &model.distributed_loads {
if dl.element_idx >= model.elements.len() {
return Err(FemError::InvalidModel(format!(
"Distributed load: element index {} out of bounds (max: {})",
dl.element_idx,
model.elements.len().saturating_sub(1)
)));
}
let element = &model.elements[dl.element_idx];
let node_i = model.nodes[element.node_i].point();
let node_j = model.nodes[element.node_j].point();
let dx = node_j.x - node_i.x;
let dy = node_j.y - node_i.y;
let L = (dx * dx + dy * dy).sqrt();
if L <= 0.0 {
return Err(FemError::InvalidModel(format!(
"Distributed load: beam element has zero or negative length (nodes {} and {} at same position)",
element.node_i, element.node_j
)));
}
let f_local = element.consistent_nodal_load(node_i, node_j, dl.qx, dl.qy)?;
let T = element.transformation_matrix(node_i, node_j);
let mut f_global_elem = [0.0; 6];
for i in 0..6 {
for j in 0..6 {
f_global_elem[i] += T[j][i] * f_local[j];
}
}
let dof_map = [
model.dof_index(element.node_i, 0), model.dof_index(element.node_i, 1), model.dof_index(element.node_i, 2), model.dof_index(element.node_j, 0), model.dof_index(element.node_j, 1), model.dof_index(element.node_j, 2), ];
for a in 0..6 {
f_global[dof_map[a]] += f_global_elem[a];
}
}
for pl in &model.point_loads {
if pl.element_idx >= model.elements.len() {
return Err(FemError::InvalidModel(format!(
"Point load: element index {} out of bounds (max: {})",
pl.element_idx,
model.elements.len().saturating_sub(1)
)));
}
let element = &model.elements[pl.element_idx];
let node_i = model.nodes[element.node_i].point();
let node_j = model.nodes[element.node_j].point();
let dx = node_j.x - node_i.x;
let dy = node_j.y - node_i.y;
let L = (dx * dx + dy * dy).sqrt();
if L <= 0.0 {
return Err(FemError::InvalidModel(format!(
"Point load: beam element has zero or negative length (nodes {} and {} at same position)",
element.node_i, element.node_j
)));
}
let f_local = element.consistent_nodal_load_point(
node_i,
node_j,
pl.position,
pl.fx,
pl.fy,
pl.mz,
)?;
let T = element.transformation_matrix(node_i, node_j);
let mut f_global_elem = [0.0; 6];
for i in 0..6 {
for j in 0..6 {
f_global_elem[i] += T[j][i] * f_local[j];
}
}
let dof_map = [
model.dof_index(element.node_i, 0), model.dof_index(element.node_i, 1), model.dof_index(element.node_i, 2), model.dof_index(element.node_j, 0), model.dof_index(element.node_j, 1), model.dof_index(element.node_j, 2), ];
for a in 0..6 {
f_global[dof_map[a]] += f_global_elem[a];
}
}
for am in &model.applied_moments {
if am.node_idx >= model.nodes.len() {
return Err(FemError::InvalidModel(format!(
"Applied moment: node index {} out of bounds (max: {})",
am.node_idx,
model.nodes.len().saturating_sub(1)
)));
}
let idx = model.dof_index(am.node_idx, 2);
f_global[idx] += am.value;
}
let mut fixed_dofs = vec![false; n_dof];
let mut prescribed_values = vec![None; n_dof];
for (node_id, dof, value) in &model.fixed_dofs {
if *node_id >= model.nodes.len() {
return Err(FemError::InvalidModel(format!(
"Fixed DOF: node index {} out of bounds (max: {})",
node_id,
model.nodes.len().saturating_sub(1)
)));
}
if *dof >= 3 {
return Err(FemError::InvalidModel(format!(
"Fixed DOF: DOF {} invalid (must be 0, 1, or 2)",
dof
)));
}
let idx = model.dof_index(*node_id, *dof);
fixed_dofs[idx] = true;
prescribed_values[idx] = Some(*value);
}
let k_original = k_global.clone();
Ok(Self {
k_global,
f_global,
u_global: vec![0.0; n_dof],
fixed_dofs,
prescribed_values,
k_original,
n_dof,
model: model.clone(),
solver_selection: SolverSelection::Auto,
solver_name: None,
reduced: None,
})
}
fn apply_boundary_conditions(&mut self) -> (Vec<f64>, Vec<usize>, Vec<f64>) {
let n = self.n_dof;
let fixed = &self.fixed_dofs;
let prescribed = &self.prescribed_values;
let mut free_dofs = Vec::new();
let mut constrained_dofs = Vec::new();
let mut constrained_values = Vec::new();
let mut free_to_global = Vec::new();
let mut global_to_free = vec![None; n];
for i in 0..n {
if !fixed[i] {
global_to_free[i] = Some(free_dofs.len());
free_dofs.push(i);
free_to_global.push(i);
} else {
let _constrained_idx = constrained_dofs.len();
constrained_dofs.push(i);
constrained_values.push(prescribed[i].unwrap_or(0.0));
}
}
let n_free = free_dofs.len();
if n_free == 0 {
self.reduced = Some(ReducedSystem::new(SparseMatrix::new(0), Vec::new()));
return (Vec::new(), constrained_dofs, constrained_values);
}
let mut k_ff = SparseMatrix::new(n_free);
let mut f_f = vec![0.0; n_free];
let mut k_orig = self.k_global.clone();
k_orig.compress();
let mut kfc_uc = vec![0.0; n_free];
for (free_idx, &global_i) in free_dofs.iter().enumerate() {
f_f[free_idx] = self.f_global[global_i];
let row_ptr = k_orig.row_ptr();
let csr_cols = k_orig.csr_cols();
let csr_vals = k_orig.csr_vals();
for idx in row_ptr[global_i]..row_ptr[global_i + 1] {
let global_j = csr_cols[idx];
let val = csr_vals[idx];
if let Some(free_j) = global_to_free[global_j] {
k_ff.add(free_idx, free_j, val);
} else if fixed[global_j] {
let constr_idx = constrained_dofs
.iter()
.position(|&x| x == global_j)
.unwrap();
kfc_uc[free_idx] += val * constrained_values[constr_idx];
}
}
}
k_ff.compress();
let mut f_reduced = f_f;
for free_idx in 0..n_free {
f_reduced[free_idx] -= kfc_uc[free_idx];
}
self.reduced = Some(ReducedSystem::new(k_ff, free_to_global));
(f_reduced, constrained_dofs, constrained_values)
}
pub(crate) fn reduced_system(&self) -> Option<&ReducedSystem> {
self.reduced.as_ref()
}
fn retained_system_copy(&self) -> (SparseMatrix, Vec<usize>) {
let retained = self
.reduced
.as_ref()
.expect("apply_boundary_conditions retains the condensed system");
(retained.k_ff().clone(), retained.free_to_global().to_vec())
}
pub(crate) fn condense(&mut self) -> &ReducedSystem {
if self.reduced.is_none() {
self.apply_boundary_conditions();
}
self.reduced
.as_ref()
.expect("apply_boundary_conditions always retains the condensed system")
}
#[allow(dead_code)]
fn find_diagonal_index(&self, matrix: &SparseMatrix, row: usize) -> Option<usize> {
let row_ptr = matrix.row_ptr();
let csr_cols = matrix.csr_cols();
for idx in row_ptr[row]..row_ptr[row + 1] {
if csr_cols[idx] == row {
return Some(idx);
}
}
None
}
pub fn set_solver(&mut self, selection: SolverSelection) {
self.solver_selection = selection;
}
pub fn solver_selection(&self) -> &SolverSelection {
&self.solver_selection
}
pub fn solver_name(&self) -> Option<&str> {
self.solver_name.as_deref()
}
fn factor_and_expand(
&mut self,
solver: &mut dyn LinearSolver,
mut k_ff: SparseMatrix,
f_reduced: Vec<f64>,
free_to_global: Vec<usize>,
constrained_dofs: Vec<usize>,
constrained_values: Vec<f64>,
) -> Result<(), FemError> {
if k_ff.n == 0 {
self.u_global = vec![0.0; self.n_dof];
for (i, &global_idx) in constrained_dofs.iter().enumerate() {
self.u_global[global_idx] = constrained_values[i];
}
return Ok(());
}
k_ff.compress();
solver.factor(&k_ff).map_err(FemError::from)?;
let u_free = solver.solve(&f_reduced).map_err(FemError::from)?;
self.u_global = vec![0.0; self.n_dof];
for (free_idx, &global_idx) in free_to_global.iter().enumerate() {
self.u_global[global_idx] = u_free[free_idx];
}
for (i, &global_idx) in constrained_dofs.iter().enumerate() {
self.u_global[global_idx] = constrained_values[i];
}
Ok(())
}
pub fn solve(&mut self, solver: &mut dyn LinearSolver) -> Result<(), FemError> {
self.solver_name = None;
let (f_reduced, constrained_dofs, constrained_values) = self.apply_boundary_conditions();
let (k_ff, free_to_global) = self.retained_system_copy();
self.factor_and_expand(
solver,
k_ff,
f_reduced,
free_to_global,
constrained_dofs,
constrained_values,
)?;
self.solver_name = Some(solver.name().to_string());
Ok(())
}
pub fn solve_configured(&mut self) -> Result<(), FemError> {
self.solver_name = None;
let (f_reduced, constrained_dofs, constrained_values) = self.apply_boundary_conditions();
let n_free = self.reduced.as_ref().map_or(0, |r| r.k_ff().n);
if n_free == 0 {
self.u_global = vec![0.0; self.n_dof];
for (i, &global_idx) in constrained_dofs.iter().enumerate() {
self.u_global[global_idx] = constrained_values[i];
}
return Ok(());
}
let (k_ff, free_to_global) = self.retained_system_copy();
let registry = SolverRegistry::default();
let mut solver = registry
.create_selected(&k_ff, &self.solver_selection)
.map_err(FemError::from)?;
let name = solver.name().to_string();
self.factor_and_expand(
&mut *solver,
k_ff,
f_reduced,
free_to_global,
constrained_dofs,
constrained_values,
)?;
self.solver_name = Some(name);
Ok(())
}
pub fn displacement(&self, node_idx: usize, dof: usize) -> Result<f64, FemError> {
if dof >= 3 {
return Err(FemError::InvalidInput(format!(
"Invalid DOF index: {} (must be 0=Ux, 1=Uy, 2=Rz)",
dof
)));
}
if node_idx >= self.model.nodes.len() {
return Err(FemError::InvalidInput(format!(
"Invalid node index: {} (max: {})",
node_idx,
self.model.nodes.len().saturating_sub(1)
)));
}
let idx = self.model.dof_index(node_idx, dof);
if idx < self.u_global.len() {
Ok(self.u_global[idx])
} else {
Ok(0.0)
}
}
pub fn displacement_dof(&self, node_idx: usize, dof: Dof) -> Result<f64, FemError> {
if node_idx >= self.model.nodes.len() {
return Err(FemError::InvalidInput(format!(
"Invalid node index: {} (max: {})",
node_idx,
self.model.nodes.len().saturating_sub(1)
)));
}
let idx = self.model.dof_index(node_idx, dof.index());
if idx < self.u_global.len() {
Ok(self.u_global[idx])
} else {
Ok(0.0)
}
}
pub fn displacements(&self) -> &[f64] {
&self.u_global
}
pub fn reactions(&self) -> Vec<f64> {
let mut reactions = vec![0.0; self.n_dof];
let mut k_orig = self.k_original.clone();
k_orig.compress();
for i in 0..self.n_dof {
let mut sum = 0.0;
let row_ptr = k_orig.row_ptr();
let csr_cols = k_orig.csr_cols();
let csr_vals = k_orig.csr_vals();
for idx in row_ptr[i]..row_ptr[i + 1] {
let j = csr_cols[idx];
sum += csr_vals[idx] * self.u_global[j];
}
reactions[i] = sum - self.f_global[i];
}
reactions
}
pub fn reaction(&self, node_idx: usize, dof: usize) -> Result<f64, FemError> {
if dof >= 3 {
return Err(FemError::InvalidInput(format!(
"Invalid DOF index: {} (must be 0=Ux, 1=Uy, 2=Rz)",
dof
)));
}
if node_idx >= self.model.nodes.len() {
return Err(FemError::InvalidInput(format!(
"Invalid node index: {} (max: {})",
node_idx,
self.model.nodes.len().saturating_sub(1)
)));
}
let idx = self.model.dof_index(node_idx, dof);
if idx < self.reactions().len() {
Ok(self.reactions()[idx])
} else {
Ok(0.0)
}
}
pub fn reaction_dof(&self, node_idx: usize, dof: Dof) -> Result<f64, FemError> {
if node_idx >= self.model.nodes.len() {
return Err(FemError::InvalidInput(format!(
"Invalid node index: {} (max: {})",
node_idx,
self.model.nodes.len().saturating_sub(1)
)));
}
let reactions = self.reactions();
let idx = self.model.dof_index(node_idx, dof.index());
if idx < reactions.len() {
Ok(reactions[idx])
} else {
Ok(0.0)
}
}
#[allow(dead_code)]
pub(crate) fn stiffness_matrix(&self) -> &SparseMatrix {
&self.k_original
}
pub fn element_end_forces(&self) -> Result<Vec<[f64; 6]>, FemError> {
let mut results = Vec::with_capacity(self.model.elements.len());
for elem_idx in 0..self.model.elements.len() {
results.push(self.element_on_node_end_forces_local(elem_idx)?);
}
Ok(results)
}
fn element_local_displacement(&self, element_idx: usize) -> Result<[f64; 6], FemError> {
let element = self.model.elements.get(element_idx).ok_or_else(|| {
FemError::InvalidInput(format!(
"Invalid element index: {} (max: {})",
element_idx,
self.model.elements.len().saturating_sub(1)
))
})?;
let node_i = self.model.nodes[element.node_i].point();
let node_j = self.model.nodes[element.node_j].point();
let dof_map = [
self.model.dof_index(element.node_i, 0), self.model.dof_index(element.node_i, 1), self.model.dof_index(element.node_i, 2), self.model.dof_index(element.node_j, 0), self.model.dof_index(element.node_j, 1), self.model.dof_index(element.node_j, 2), ];
let u_global_elem = [
self.u_global[dof_map[0]],
self.u_global[dof_map[1]],
self.u_global[dof_map[2]],
self.u_global[dof_map[3]],
self.u_global[dof_map[4]],
self.u_global[dof_map[5]],
];
let t = element.transformation_matrix(node_i, node_j);
let mut u_local = [0.0; 6];
for i in 0..6 {
for j in 0..6 {
u_local[i] += t[i][j] * u_global_elem[j];
}
}
Ok(u_local)
}
fn element_on_node_end_forces_local(&self, element_idx: usize) -> Result<[f64; 6], FemError> {
let element = self.model.elements.get(element_idx).ok_or_else(|| {
FemError::InvalidInput(format!(
"Invalid element index: {} (max: {})",
element_idx,
self.model.elements.len().saturating_sub(1)
))
})?;
let node_i = self.model.nodes[element.node_i].point();
let node_j = self.model.nodes[element.node_j].point();
let u_local = self.element_local_displacement(element_idx)?;
let k_local = element.local_stiffness(node_i, node_j);
let mut f_stiffness = [0.0; 6];
for i in 0..6 {
for j in 0..6 {
f_stiffness[i] += k_local[i][j] * u_local[j];
}
}
let f_equiv = Self::element_equivalent_nodal_forces(
&self.model,
element_idx,
element,
node_i,
node_j,
)?;
let mut end_forces = [0.0; 6];
for i in 0..6 {
end_forces[i] = f_equiv[i] - f_stiffness[i];
}
Ok(end_forces)
}
fn element_equivalent_nodal_forces(
model: &BeamModel,
elem_idx: usize,
element: &BeamElement,
node_i: Point,
node_j: Point,
) -> Result<[f64; 6], FemError> {
let mut f_equiv = [0.0; 6];
for dl in &model.distributed_loads {
if dl.element_idx == elem_idx {
let f_local = element.consistent_nodal_load(node_i, node_j, dl.qx, dl.qy)?;
for i in 0..6 {
f_equiv[i] += f_local[i];
}
}
}
for pl in &model.point_loads {
if pl.element_idx == elem_idx {
let f_local = element.consistent_nodal_load_point(
node_i,
node_j,
pl.position,
pl.fx,
pl.fy,
pl.mz,
)?;
for i in 0..6 {
f_equiv[i] += f_local[i];
}
}
}
Ok(f_equiv)
}
pub fn element_end_forces_global(&self) -> Result<Vec<[f64; 6]>, FemError> {
let local_forces = self.element_end_forces()?;
let mut results = Vec::new();
for (idx, forces) in local_forces.iter().enumerate() {
let element = &self.model.elements[idx];
let node_i = self.model.nodes[element.node_i].point();
let node_j = self.model.nodes[element.node_j].point();
let T = element.transformation_matrix(node_i, node_j);
let mut f_global_elem = [0.0; 6];
for i in 0..6 {
for j in 0..6 {
f_global_elem[i] += T[j][i] * forces[j];
}
}
results.push(f_global_elem);
}
Ok(results)
}
pub fn element_section_forces(
&self,
element_idx: usize,
xi: f64,
) -> Result<SectionForces, FemError> {
let element = self.model.elements.get(element_idx).ok_or_else(|| {
FemError::InvalidInput(format!(
"Invalid element index: {} (max: {})",
element_idx,
self.model.elements.len().saturating_sub(1)
))
})?;
if !(0.0..=1.0).contains(&xi) {
return Err(FemError::InvalidInput(format!(
"Section position xi must be in [0, 1], got {}",
xi
)));
}
let node_i = self.model.nodes[element.node_i].point();
let node_j = self.model.nodes[element.node_j].point();
let length = element.length(node_i, node_j);
if length <= 0.0 {
return Err(FemError::InvalidInput(
"Beam element has zero or negative length for section-force recovery".to_string(),
));
}
let x = xi * length;
let f_end = self.element_on_node_end_forces_local(element_idx)?;
let n_i = f_end[0];
let v_i = f_end[1];
let m_i = f_end[2];
let mut qx = 0.0;
let mut qy = 0.0;
for dl in &self.model.distributed_loads {
if dl.element_idx == element_idx {
qx += dl.qx;
qy += dl.qy;
}
}
let mut sum_fx = 0.0;
let mut sum_fy = 0.0;
let mut sum_moment = 0.0;
for pl in &self.model.point_loads {
if pl.element_idx != element_idx {
continue;
}
let x_p = pl.position * length;
if x_p < x {
sum_fx += pl.fx;
sum_fy += pl.fy;
sum_moment += (x_p - x) * pl.fy + pl.mz;
}
}
let axial = n_i - qx * x - sum_fx;
let shear = -v_i + qy * x + sum_fy;
let moment = m_i - x * v_i + 0.5 * qy * x * x - sum_moment;
Ok(SectionForces::new(axial, shear, moment))
}
fn element_start_distance(&self, element_index: usize) -> f64 {
self.model
.elements
.iter()
.take(element_index)
.map(|e| {
let ni = self.model.nodes[e.node_i].point();
let nj = self.model.nodes[e.node_j].point();
e.length(ni, nj)
})
.sum()
}
pub fn sample_element_forces(
&self,
element_index: usize,
n: usize,
) -> Result<Vec<BeamForceSample>, FemError> {
if n < 2 {
return Err(FemError::InvalidInput(format!(
"Number of samples n must be >= 2, got {}",
n
)));
}
if element_index >= self.model.elements.len() {
return Err(FemError::InvalidInput(format!(
"Invalid element index: {} (max: {})",
element_index,
self.model.elements.len().saturating_sub(1)
)));
}
let element = &self.model.elements[element_index];
let node_i = self.model.nodes[element.node_i].point();
let node_j = self.model.nodes[element.node_j].point();
let length = element.length(node_i, node_j);
let start = self.element_start_distance(element_index);
let mut samples = Vec::with_capacity(n);
for k in 0..n {
let xi = k as f64 / (n - 1) as f64;
let section_forces = self.element_section_forces(element_index, xi)?;
samples.push(BeamForceSample {
element_index,
xi,
x: start + xi * length,
section_forces,
});
}
Ok(samples)
}
pub fn sample_beam_forces(
&self,
n_per_element: usize,
) -> Result<Vec<BeamForceSample>, FemError> {
if n_per_element < 2 {
return Err(FemError::InvalidInput(format!(
"Number of samples per element must be >= 2, got {}",
n_per_element
)));
}
let mut samples = Vec::with_capacity(n_per_element * self.model.elements.len());
for element_index in 0..self.model.elements.len() {
samples.extend(self.sample_element_forces(element_index, n_per_element)?);
}
Ok(samples)
}
pub fn beam_force_diagram(&self, n_per_element: usize) -> Result<BeamForceDiagram, FemError> {
Ok(BeamForceDiagram::new(
self.sample_beam_forces(n_per_element)?,
))
}
pub fn results(&self) -> BeamAnalysisResult<'_> {
let mut reactions = self.reactions();
for (i, reaction) in reactions.iter_mut().enumerate() {
if !self.fixed_dofs[i] {
*reaction = 0.0;
}
}
BeamAnalysisResult {
solver: self,
reactions,
}
}
}
#[derive(Debug, Clone, thiserror::Error)]
pub enum FemError {
#[error("Invalid model: {0}")]
InvalidModel(String),
#[error("Solver error: {message}")]
SolverError {
source: SolverError,
message: String,
},
#[error("Invalid input: {0}")]
InvalidInput(String),
#[error("Invalid node: {0}")]
InvalidNode(String),
#[error("Invalid member: {0}")]
InvalidMember(String),
#[error("Zero-length member: {0}")]
ZeroLengthMember(String),
#[error("Duplicate member: {0}")]
DuplicateMember(String),
#[error("Orphan node: {0}")]
OrphanNode(String),
#[error("Disconnected structure: {0}")]
DisconnectedStructure(String),
#[error(
"Conflicting prescribed displacement at node {node_idx}, DOF {dof}: \
first value {first_value}, conflicting value {conflicting_value}"
)]
ConflictingPrescribedDisplacement {
node_idx: usize,
dof: usize,
first_value: f64,
conflicting_value: f64,
},
}
impl FemError {
pub fn solver_error(&self) -> Option<&SolverError> {
match self {
FemError::SolverError { source, .. } => Some(source),
_ => None,
}
}
}
impl From<SolverError> for FemError {
fn from(e: SolverError) -> Self {
FemError::SolverError {
message: e.to_string(),
source: e,
}
}
}
pub struct BeamAnalysis;
impl BeamAnalysis {
pub fn cantilever_tip_load(L: f64, E: f64, _A: f64, I: f64, P: f64) -> (f64, f64, f64) {
let u_tip = 0.0; let v_tip = P * L.powi(3) / (3.0 * E * I); let theta_tip = P * L.powi(2) / (2.0 * E * I);
(u_tip, v_tip, theta_tip)
}
pub fn simply_supported_central_load(L: f64, E: f64, I: f64, P: f64) -> (f64, f64) {
let v_mid = P * L.powi(3) / (48.0 * E * I);
let theta_support = P * L.powi(2) / (16.0 * E * I);
(v_mid, theta_support)
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::material::Material;
#[test]
fn test_beam_section_creation() {
let sec = BeamSection::new(1.0, 1.0);
assert_eq!(sec.area, 1.0);
assert_eq!(sec.second_moment, 1.0);
let rect = BeamSection::rectangle(0.1, 0.2);
assert!((rect.area - 0.02).abs() < 1e-10);
assert!((rect.second_moment - 0.1 * 0.2_f64.powi(3) / 12.0).abs() < 1e-10);
let circ = BeamSection::circle(0.05);
assert!((circ.area - std::f64::consts::PI * 0.0025).abs() < 1e-10);
}
#[test]
fn test_local_stiffness() {
let material = Material::new(200e9, 0.3, 7850.0, "Steel");
let section = BeamSection::new(0.01, 8.333e-6);
let element = BeamElement::new(0, 1, material, section).unwrap();
let node_i = Point::new(0.0, 0.0);
let node_j = Point::new(1.0, 0.0);
let k = element.local_stiffness(node_i, node_j);
for i in 0..6 {
for j in 0..6 {
assert!(
(k[i][j] - k[j][i]).abs() < 1e-10,
"Matrix not symmetric at ({},{})",
i,
j
);
}
}
let E: f64 = 200e9;
let A: f64 = 0.01;
let L: f64 = 1.0;
let EA_L = E * A / L;
assert!((k[0][0] - EA_L).abs() < 1e-6);
assert!((k[0][3] + EA_L).abs() < 1e-6);
assert!((k[3][3] - EA_L).abs() < 1e-6);
let I: f64 = 8.333e-6;
let EI_L3 = E * I / L.powi(3);
let EI_L2 = E * I / L.powi(2);
let EI_L = E * I / L;
assert!((k[1][1] - 12.0 * EI_L3).abs() < 1e-6);
assert!((k[1][2] - 6.0 * EI_L2).abs() < 1e-6);
assert!((k[2][2] - 4.0 * EI_L).abs() < 1e-6);
assert!((k[4][4] - 12.0 * EI_L3).abs() < 1e-6);
assert!((k[5][5] - 4.0 * EI_L).abs() < 1e-6);
}
#[test]
fn test_transformation_matrix() {
let material = Material::new(200e9, 0.3, 7850.0, "Steel");
let section = BeamSection::new(0.01, 8.333e-6);
let element = BeamElement::new(0, 1, material, section).unwrap();
let node_i = Point::new(0.0, 0.0);
let node_j = Point::new(1.0, 0.0);
let T = element.transformation_matrix(node_i, node_j);
assert!((T[0][0] - 1.0).abs() < 1e-10);
assert!((T[1][1] - 1.0).abs() < 1e-10);
assert!((T[2][2] - 1.0).abs() < 1e-10);
assert!((T[3][3] - 1.0).abs() < 1e-10);
assert!((T[4][4] - 1.0).abs() < 1e-10);
assert!((T[5][5] - 1.0).abs() < 1e-10);
let node_i = Point::new(0.0, 0.0);
let node_j = Point::new(0.0, 1.0);
let T = element.transformation_matrix(node_i, node_j);
assert!((T[0][0] - 0.0).abs() < 1e-10); assert!((T[0][1] - 1.0).abs() < 1e-10); assert!((T[1][0] - -1.0).abs() < 1e-10); assert!((T[1][1] - 0.0).abs() < 1e-10); }
#[test]
fn test_global_stiffness_horizontal() {
let material = Material::new(200e9, 0.3, 7850.0, "Steel");
let section = BeamSection::new(0.01, 8.333e-6);
let element = BeamElement::new(0, 1, material, section).unwrap();
let node_i = Point::new(0.0, 0.0);
let node_j = Point::new(1.0, 0.0);
let k_global = element.global_stiffness(node_i, node_j);
let k_local = element.local_stiffness(node_i, node_j);
for i in 0..6 {
for j in 0..6 {
assert!((k_global[i][j] - k_local[i][j]).abs() < 1e-10);
}
}
}
#[test]
fn test_global_stiffness_vertical() {
let material = Material::new(200e9, 0.3, 7850.0, "Steel");
let section = BeamSection::new(0.01, 8.333e-6);
let element = BeamElement::new(0, 1, material, section).unwrap();
let node_i = Point::new(0.0, 0.0);
let node_j = Point::new(0.0, 1.0);
let k_global = element.global_stiffness(node_i, node_j);
for i in 0..6 {
for j in 0..6 {
assert!((k_global[i][j] - k_global[j][i]).abs() < 1e-10);
}
}
}
#[test]
fn test_cantilever_analytical() {
let L = 1.0;
let E = 200e9;
let A = 0.01;
let I = 8.333e-6;
let P = 1000.0;
let (u_tip, v_tip, theta_tip) = BeamAnalysis::cantilever_tip_load(L, E, A, I, P);
let expected_v = P * L.powi(3) / (3.0 * E * I);
let expected_theta = P * L.powi(2) / (2.0 * E * I);
assert!((v_tip - expected_v).abs() < 1e-10);
assert!((theta_tip - expected_theta).abs() < 1e-10);
assert!(u_tip.abs() < 1e-10); }
#[test]
fn test_beam_model() {
let mut model = BeamModel::new();
model.add_node(BeamNode::new(0, 0.0, 0.0));
model.add_node(BeamNode::new(1, 1.0, 0.0));
let material = Material::new(200e9, 0.3, 7850.0, "Steel");
let section = BeamSection::new(0.01, 8.333e-6);
model.add_element(BeamElement::new(0, 1, material, section).unwrap());
model.fix_node(0);
model.add_nodal_force(1, 1, -1000.0);
assert_eq!(model.n_dof(), 6);
assert_eq!(model.dof_index(0, 0), 0);
assert_eq!(model.dof_index(0, 1), 1);
assert_eq!(model.dof_index(0, 2), 2);
assert_eq!(model.dof_index(1, 0), 3);
assert_eq!(model.dof_index(1, 1), 4);
assert_eq!(model.dof_index(1, 2), 5);
}
#[test]
fn p1_02_reproduce_conflicting_prescribed_displacement() {
let mut model = BeamModel::new();
model.add_node(BeamNode::new(0, 0.0, 0.0));
model.add_node(BeamNode::new(1, 1.0, 0.0));
model.try_fix_dof(0, 1, 0.0).unwrap();
let result = model.try_fix_dof(0, 1, 0.01);
match result {
Ok(()) => {
panic!("P1-02 NOT fixed: conflicting prescribed displacement silently accepted")
}
Err(e) => println!("P1-02 confirmed: got Err = {:?}", e),
}
}
#[test]
fn p1_02_same_prescribed_value_is_idempotent() {
let mut model = BeamModel::new();
model.add_node(BeamNode::new(0, 0.0, 0.0));
model.add_node(BeamNode::new(1, 1.0, 0.0));
model.try_fix_dof(0, 1, 0.005).unwrap();
model.try_fix_dof(0, 1, 0.005).unwrap();
assert_eq!(model.fixed_dofs.len(), 1);
}
#[test]
fn p1_02_different_dofs_are_independent() {
let mut model = BeamModel::new();
model.add_node(BeamNode::new(0, 0.0, 0.0));
model.add_node(BeamNode::new(1, 1.0, 0.0));
model.try_fix_dof(0, 0, 0.0).unwrap();
model.try_fix_dof(0, 1, 0.01).unwrap();
model.try_fix_dof(0, 2, 0.02).unwrap();
}
#[test]
fn p1_02_different_nodes_are_independent() {
let mut model = BeamModel::new();
model.add_node(BeamNode::new(0, 0.0, 0.0));
model.add_node(BeamNode::new(1, 1.0, 0.0));
model.try_fix_dof(0, 0, 0.0).unwrap();
model.try_fix_dof(1, 0, 0.01).unwrap();
}
#[test]
fn p1_02_override_after_fix_allows_settlement() {
let mut model = BeamModel::new();
model.add_node(BeamNode::new(0, 0.0, 0.0));
model.add_node(BeamNode::new(1, 1.0, 0.0));
model.try_fix_node(0).unwrap();
model.try_override_dof(0, 1, -0.005).unwrap();
assert_eq!(model.fixed_dofs.len(), 3);
let uy = model
.fixed_dofs
.iter()
.find(|&&(n, d, _)| n == 0 && d == 1)
.map(|&(_, _, v)| v)
.unwrap();
assert_eq!(uy, -0.005);
}
#[test]
fn p1_02_override_replaces_existing_value() {
let mut model = BeamModel::new();
model.add_node(BeamNode::new(0, 0.0, 0.0));
model.add_node(BeamNode::new(1, 1.0, 0.0));
model.try_override_dof(0, 1, 0.01).unwrap();
model.try_override_dof(0, 1, 0.02).unwrap();
assert_eq!(model.fixed_dofs.len(), 1);
assert_eq!(model.fixed_dofs[0].2, 0.02);
}
}