use crate::geometry::Point;
use crate::material::Material;
use crate::mesh::{Mesh, MeshParams};
use crate::section::Section;
use std::collections::HashMap;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ElementType {
Tri3,
Tri6,
Quad4,
Quad8,
}
#[derive(Debug, Clone, Copy)]
pub struct MaterialProps {
pub youngs_modulus: f64,
pub poissons_ratio: f64,
pub shear_modulus: f64,
pub density: f64,
pub plane_stress: bool,
pub shear_correction: f64,
}
impl MaterialProps {
pub fn from_material(material: &Material, plane_stress: bool) -> Self {
Self {
youngs_modulus: material.youngs_modulus,
poissons_ratio: material.poissons_ratio,
shear_modulus: material.shear_modulus,
density: material.density,
plane_stress,
shear_correction: 5.0 / 6.0,
}
}
pub fn plane_strain(material: &Material) -> Self {
Self::from_material(material, false)
}
pub fn plane_stress(material: &Material) -> Self {
Self::from_material(material, true)
}
pub fn d_matrix_plane_stress(&self) -> [[f64; 3]; 3] {
let e = self.youngs_modulus;
let nu = self.poissons_ratio;
let factor = e / (1.0 - nu * nu);
[
[factor, factor * nu, 0.0],
[factor * nu, factor, 0.0],
[0.0, 0.0, factor * (1.0 - nu) / 2.0],
]
}
pub fn d_matrix_plane_strain(&self) -> [[f64; 3]; 3] {
let e = self.youngs_modulus;
let nu = self.poissons_ratio;
let factor = e / ((1.0 + nu) * (1.0 - 2.0 * nu));
[
[factor * (1.0 - nu), factor * nu, 0.0],
[factor * nu, factor * (1.0 - nu), 0.0],
[0.0, 0.0, factor * (1.0 - 2.0 * nu) / 2.0],
]
}
pub fn d_matrix(&self) -> [[f64; 3]; 3] {
if self.plane_stress {
self.d_matrix_plane_stress()
} else {
self.d_matrix_plane_strain()
}
}
}
#[derive(Debug, Clone, Copy)]
pub struct StressResult {
pub sigma_x: f64,
pub sigma_y: f64,
pub tau_xy: f64,
pub epsilon_x: f64,
pub epsilon_y: f64,
pub gamma_xy: f64,
pub von_mises: f64,
pub sigma_1: f64,
pub sigma_2: f64,
pub principal_angle: f64,
}
impl StressResult {
pub fn from_stress(sigma_x: f64, sigma_y: f64, tau_xy: f64) -> Self {
let sigma_avg = (sigma_x + sigma_y) * 0.5;
let r = ((sigma_x - sigma_y) * 0.5).powi(2) + tau_xy * tau_xy;
let r = r.sqrt();
let sigma_1 = sigma_avg + r;
let sigma_2 = sigma_avg - r;
let principal_angle = 0.5 * (2.0 * tau_xy).atan2(sigma_x - sigma_y);
let von_mises =
(sigma_x * sigma_x - sigma_x * sigma_y + sigma_y * sigma_y + 3.0 * tau_xy * tau_xy)
.sqrt();
Self {
sigma_x,
sigma_y,
tau_xy,
epsilon_x: 0.0,
epsilon_y: 0.0,
gamma_xy: 0.0,
von_mises,
sigma_1,
sigma_2,
principal_angle,
}
}
pub fn from_strain(
epsilon_x: f64,
epsilon_y: f64,
gamma_xy: f64,
props: &MaterialProps,
) -> Self {
let d = props.d_matrix();
let sigma_x = d[0][0] * epsilon_x + d[0][1] * epsilon_y + d[0][2] * gamma_xy;
let sigma_y = d[1][0] * epsilon_x + d[1][1] * epsilon_y + d[1][2] * gamma_xy;
let tau_xy = d[2][0] * epsilon_x + d[2][1] * epsilon_y + d[2][2] * gamma_xy;
let mut result = Self::from_stress(sigma_x, sigma_y, tau_xy);
result.epsilon_x = epsilon_x;
result.epsilon_y = epsilon_y;
result.gamma_xy = gamma_xy;
result
}
}
#[derive(Debug, Clone)]
pub struct FemModel {
pub mesh: Mesh,
pub materials: Vec<MaterialProps>,
pub dirichlet_bcs: Vec<(usize, usize, f64)>,
pub nodal_forces: Vec<(usize, usize, f64)>,
pub element_loads: Vec<(usize, [f64; 3])>, pub problem_type: ProblemType,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ProblemType {
PlaneStress,
PlaneStrain,
Axisymmetric,
}
impl FemModel {
pub fn new(mesh: Mesh) -> Self {
Self {
mesh,
materials: Vec::new(),
dirichlet_bcs: Vec::new(),
nodal_forces: Vec::new(),
element_loads: Vec::new(),
problem_type: ProblemType::PlaneStress,
}
}
pub fn add_material(&mut self, props: MaterialProps) -> usize {
self.materials.push(props);
self.materials.len() - 1
}
pub fn add_dirichlet_bc(&mut self, node: usize, dof: usize, value: f64) {
self.dirichlet_bcs.push((node, dof, value));
}
pub fn fix_node(&mut self, node: usize) {
self.add_dirichlet_bc(node, 0, 0.0);
self.add_dirichlet_bc(node, 1, 0.0);
}
pub fn add_nodal_force(&mut self, node: usize, dof: usize, value: f64) {
self.nodal_forces.push((node, dof, value));
}
pub fn add_body_force(&mut self, fx: f64, fy: f64) {
for i in 0..self.mesh.n_elements() {
self.element_loads.push((i, [fx, fy, 0.0]));
}
}
pub fn set_problem_type(&mut self, ptype: ProblemType) {
self.problem_type = ptype;
}
}
#[derive(Debug)]
pub struct FemSolver {
pub k_global: SprsMatrix,
pub f_global: Vec<f64>,
pub u_global: Vec<f64>,
pub n_dof: usize,
pub dof_map: HashMap<(usize, usize), usize>,
pub fixed_dofs: Vec<bool>,
k_original: SprsMatrix,
}
impl FemSolver {
pub fn from_model(model: &FemModel) -> Result<Self, FemError> {
let n_nodes = model.mesh.n_nodes();
let n_dof = n_nodes * 2;
let mut dof_map = HashMap::new();
let mut dof_index = 0;
for node in 0..n_nodes {
for dof in 0..2 {
dof_map.insert((node, dof), dof_index);
dof_index += 1;
}
}
let mut fixed_dofs = vec![false; n_dof];
for (node, dof, _) in &model.dirichlet_bcs {
if let Some(&idx) = dof_map.get(&(*node, *dof)) {
fixed_dofs[idx] = true;
}
}
let mut k_global = SprsMatrix::new(n_dof);
for (elem_idx, element) in model.mesh.elements.iter().enumerate() {
let mat_idx = if elem_idx < model.mesh.element_materials.len() {
model.mesh.element_materials[elem_idx]
} else {
0
};
let props = &model.materials[mat_idx];
let ke = element_stiffness_tri3(&model.mesh, element, props);
let mut dof_indices = [0; 6];
for (i, &node) in element.iter().enumerate() {
dof_indices[2 * i] = dof_map[&(node, 0)];
dof_indices[2 * i + 1] = dof_map[&(node, 1)];
}
for i in 0..6 {
for j in 0..6 {
k_global.add(dof_indices[i], dof_indices[j], ke[i][j]);
}
}
}
let mut f_global = vec![0.0; n_dof];
for (node, dof, value) in &model.nodal_forces {
if let Some(&idx) = dof_map.get(&(*node, *dof)) {
f_global[idx] += value;
}
}
for (elem_idx, load) in &model.element_loads {
let element = model.mesh.elements[*elem_idx];
let fe = element_body_force_tri3(&model.mesh, &element, load);
let mut dof_indices = [0; 6];
for (i, &node) in element.iter().enumerate() {
dof_indices[2 * i] = dof_map[&(node, 0)];
dof_indices[2 * i + 1] = dof_map[&(node, 1)];
}
for i in 0..6 {
f_global[dof_indices[i]] += fe[i];
}
}
for (node, dof, value) in &model.dirichlet_bcs {
if let Some(&idx) = dof_map.get(&(*node, *dof)) {
f_global[idx] = *value;
}
}
let mut k_original = k_global.clone();
k_original.finalize();
Ok(Self {
k_global,
f_global,
u_global: vec![0.0; n_dof],
n_dof,
dof_map,
fixed_dofs,
k_original,
})
}
pub fn solve(&mut self) -> Result<&[f64], FemError> {
self.apply_boundary_conditions();
self.u_global = self
.k_global
.solve_cholesky(&self.f_global)
.ok_or(FemError::SingularMatrix)?;
Ok(&self.u_global)
}
fn apply_boundary_conditions(&mut self) {
for i in 0..self.n_dof {
if self.fixed_dofs[i] {
self.k_global.zero_row_col(i);
self.k_global.set(i, i, 1.0);
}
}
}
pub fn displacement(&self, node: usize) -> Point {
let ux = self.u_global[self.dof_map[&(node, 0)]];
let uy = self.u_global[self.dof_map[&(node, 1)]];
Point::new(ux, uy)
}
pub fn element_stress(&self, model: &FemModel, elem_idx: usize) -> StressResult {
let element = model.mesh.elements[elem_idx];
let props = &model.materials[model.mesh.element_materials[elem_idx]];
let mut u_elem = [0.0; 6];
for (i, &node) in element.iter().enumerate() {
u_elem[2 * i] = self.u_global[self.dof_map[&(node, 0)]];
u_elem[2 * i + 1] = self.u_global[self.dof_map[&(node, 1)]];
}
let b = strain_displacement_matrix_tri3(&model.mesh, &element);
let mut strain = [0.0; 3];
for i in 0..3 {
for j in 0..6 {
strain[i] += b[i][j] * u_elem[j];
}
}
let d = props.d_matrix();
let mut stress = [0.0; 3];
for i in 0..3 {
for j in 0..3 {
stress[i] += d[i][j] * strain[j];
}
}
StressResult::from_strain(strain[0], strain[1], strain[2], props)
}
pub fn all_element_stresses(&self, model: &FemModel) -> Vec<StressResult> {
(0..model.mesh.n_elements())
.map(|i| self.element_stress(model, i))
.collect()
}
pub fn nodal_stresses(&self, model: &FemModel) -> Vec<StressResult> {
let n_nodes = model.mesh.n_nodes();
let mut stress_sum = vec![StressResult::from_stress(0.0, 0.0, 0.0); n_nodes];
let mut stress_count = vec![0; n_nodes];
for elem_idx in 0..model.mesh.n_elements() {
let stress = self.element_stress(model, elem_idx);
let element = model.mesh.elements[elem_idx];
for &node in &element {
stress_sum[node].sigma_x += stress.sigma_x;
stress_sum[node].sigma_y += stress.sigma_y;
stress_sum[node].tau_xy += stress.tau_xy;
stress_sum[node].von_mises += stress.von_mises;
stress_sum[node].sigma_1 += stress.sigma_1;
stress_sum[node].sigma_2 += stress.sigma_2;
stress_count[node] += 1;
}
}
let mut nodal_stresses = Vec::with_capacity(n_nodes);
for i in 0..n_nodes {
if stress_count[i] > 0 {
let c = stress_count[i] as f64;
let mut s = stress_sum[i];
s.sigma_x /= c;
s.sigma_y /= c;
s.tau_xy /= c;
s.von_mises /= c;
s.sigma_1 /= c;
s.sigma_2 /= c;
nodal_stresses.push(s);
} else {
nodal_stresses.push(StressResult::from_stress(0.0, 0.0, 0.0));
}
}
nodal_stresses
}
pub fn reactions(&self, model: &FemModel) -> Vec<(usize, usize, f64)> {
let mut reactions = Vec::new();
for (node, dof, _) in &model.dirichlet_bcs {
if let Some(&idx) = self.dof_map.get(&(*node, *dof)) {
let mut reaction = 0.0;
for j in 0..self.n_dof {
reaction += self.k_original.get(idx, j) * self.u_global[j];
}
reactions.push((*node, *dof, reaction));
}
}
reactions
}
}
#[derive(Debug, Clone)]
pub struct SprsMatrix {
n: usize,
row_ptr: Vec<usize>,
col_idx: Vec<usize>,
values: Vec<f64>,
triplets: Vec<(usize, usize, f64)>,
finalized: bool,
}
impl SprsMatrix {
pub fn new(n: usize) -> Self {
Self {
n,
row_ptr: vec![0; n + 1],
col_idx: Vec::new(),
values: Vec::new(),
triplets: Vec::new(),
finalized: false,
}
}
pub fn add(&mut self, row: usize, col: usize, value: f64) {
if value.abs() < 1e-15 {
return;
}
self.triplets.push((row, col, value));
self.finalized = false;
}
pub fn set(&mut self, row: usize, col: usize, value: f64) {
self.finalize();
for i in self.row_ptr[row]..self.row_ptr[row + 1] {
if self.col_idx[i] == col {
self.values[i] = value;
return;
}
}
let pos = self.row_ptr[row + 1];
self.col_idx.insert(pos, col);
self.values.insert(pos, value);
for r in (row + 1)..=self.n {
self.row_ptr[r] += 1;
}
}
pub fn get(&self, row: usize, col: usize) -> f64 {
if !self.finalized {
return 0.0; }
for i in self.row_ptr[row]..self.row_ptr[row + 1] {
if self.col_idx[i] == col {
return self.values[i];
}
}
0.0
}
fn finalize(&mut self) {
if self.finalized {
return;
}
self.triplets.sort_by_key(|&(r, c, _)| (r, c));
let mut combined: Vec<(usize, usize, f64)> = Vec::new();
for (r, c, v) in self.triplets.drain(..) {
if let Some(last) = combined.last_mut() {
if last.0 == r && last.1 == c {
last.2 += v;
} else {
combined.push((r, c, v));
}
} else {
combined.push((r, c, v));
}
}
self.row_ptr.fill(0);
for (r, _, _) in &combined {
self.row_ptr[*r + 1] += 1;
}
for i in 1..=self.n {
self.row_ptr[i] += self.row_ptr[i - 1];
}
self.col_idx = Vec::with_capacity(combined.len());
self.values = Vec::with_capacity(combined.len());
for (_, c, v) in combined {
self.col_idx.push(c);
self.values.push(v);
}
self.finalized = true;
}
pub fn zero_row_col(&mut self, idx: usize) {
self.finalize();
let row_start = self.row_ptr[idx];
let row_end = self.row_ptr[idx + 1];
for i in row_start..row_end {
self.values[i] = 0.0;
}
for r in 0..self.n {
let rs = self.row_ptr[r];
let re = self.row_ptr[r + 1];
for i in rs..re {
if self.col_idx[i] == idx {
self.values[i] = 0.0;
}
}
}
}
pub fn solve_cholesky(&mut self, rhs: &[f64]) -> Option<Vec<f64>> {
self.finalize();
if self.n <= 500 {
let mut a = vec![vec![0.0; self.n]; self.n];
for i in 0..self.n {
for j_idx in self.row_ptr[i]..self.row_ptr[i + 1] {
let j = self.col_idx[j_idx];
a[i][j] = self.values[j_idx];
}
}
let mut l = vec![vec![0.0; self.n]; self.n];
for i in 0..self.n {
for j in 0..=i {
let mut sum = a[i][j];
for k in 0..j {
sum -= l[i][k] * l[j][k];
}
if i == j {
if sum <= 1e-12 {
return None; }
l[i][j] = sum.sqrt();
} else {
l[i][j] = sum / l[j][j];
}
}
}
let mut y = vec![0.0; self.n];
for i in 0..self.n {
let mut sum = rhs[i];
for k in 0..i {
sum -= l[i][k] * y[k];
}
y[i] = sum / l[i][i];
}
let mut x = vec![0.0; self.n];
for i in (0..self.n).rev() {
let mut sum = y[i];
for k in i + 1..self.n {
sum -= l[k][i] * x[k];
}
x[i] = sum / l[i][i];
}
Some(x)
} else {
None
}
}
}
pub fn element_stiffness_tri3(
mesh: &Mesh,
element: &[usize; 3],
props: &MaterialProps,
) -> [[f64; 6]; 6] {
let p1 = mesh.nodes[element[0]];
let p2 = mesh.nodes[element[1]];
let p3 = mesh.nodes[element[2]];
let area = 0.5 * ((p2.x - p1.x) * (p3.y - p1.y) - (p3.x - p1.x) * (p2.y - p1.y)).abs();
let b = strain_displacement_matrix_tri3(mesh, element);
let d = props.d_matrix();
let thickness = 1.0;
let mut ke = [[0.0; 6]; 6];
for i in 0..6 {
for j in 0..6 {
let mut sum = 0.0;
for k in 0..3 {
for l in 0..3 {
sum += b[k][i] * d[k][l] * b[l][j];
}
}
ke[i][j] = sum * area * thickness;
}
}
ke
}
pub fn strain_displacement_matrix_tri3(mesh: &Mesh, element: &[usize; 3]) -> [[f64; 6]; 3] {
let p1 = mesh.nodes[element[0]];
let p2 = mesh.nodes[element[1]];
let p3 = mesh.nodes[element[2]];
let area2 = (p2.x - p1.x) * (p3.y - p1.y) - (p3.x - p1.x) * (p2.y - p1.y);
let _area = 0.5 * area2.abs();
let b1 = (p2.y - p3.y) / area2;
let c1 = (p3.x - p2.x) / area2;
let b2 = (p3.y - p1.y) / area2;
let c2 = (p1.x - p3.x) / area2;
let b3 = (p1.y - p2.y) / area2;
let c3 = (p2.x - p1.x) / area2;
[
[b1, 0.0, b2, 0.0, b3, 0.0],
[0.0, c1, 0.0, c2, 0.0, c3],
[c1, b1, c2, b2, c3, b3],
]
}
pub fn element_body_force_tri3(
mesh: &Mesh,
element: &[usize; 3],
body_force: &[f64; 3], ) -> [f64; 6] {
let p1 = mesh.nodes[element[0]];
let p2 = mesh.nodes[element[1]];
let p3 = mesh.nodes[element[2]];
let area = 0.5 * ((p2.x - p1.x) * (p3.y - p1.y) - (p3.x - p1.x) * (p2.y - p1.y)).abs();
let thickness = 1.0;
let volume = area * thickness;
let factor = volume / 3.0;
[
body_force[0] * factor,
body_force[1] * factor,
body_force[0] * factor,
body_force[1] * factor,
body_force[0] * factor,
body_force[1] * factor,
]
}
pub fn analyze_section(
section: &Section,
material: &Material,
params: MeshParams,
loads: &[LoadCase],
) -> Result<AnalysisResults, FemError> {
let mesh = crate::mesh::mesh_section(section, params);
let mut model = FemModel::new(mesh);
let mat_props = MaterialProps::from_material(material, true); model.add_material(mat_props);
model.set_problem_type(ProblemType::PlaneStress);
for load in loads {
match load {
LoadCase::NodalForce { node, fx, fy } => {
model.add_nodal_force(*node, 0, *fx);
model.add_nodal_force(*node, 1, *fy);
}
LoadCase::BodyForce { fx, fy } => {
model.add_body_force(*fx, *fy);
}
LoadCase::FixedNode { node } => {
model.fix_node(*node);
}
LoadCase::RollerX { node } => {
model.add_dirichlet_bc(*node, 0, 0.0);
}
LoadCase::RollerY { node } => {
model.add_dirichlet_bc(*node, 1, 0.0);
}
}
}
let mut solver = FemSolver::from_model(&model)?;
solver.solve()?;
Ok(AnalysisResults {
displacements: (0..model.mesh.n_nodes())
.map(|i| solver.displacement(i))
.collect(),
element_stresses: solver.all_element_stresses(&model),
nodal_stresses: solver.nodal_stresses(&model),
reactions: solver.reactions(&model),
})
}
#[derive(Debug, Clone)]
pub enum LoadCase {
NodalForce { node: usize, fx: f64, fy: f64 },
BodyForce { fx: f64, fy: f64 },
FixedNode { node: usize },
RollerX { node: usize },
RollerY { node: usize },
}
#[derive(Debug, Clone)]
pub struct AnalysisResults {
pub displacements: Vec<Point>,
pub element_stresses: Vec<StressResult>,
pub nodal_stresses: Vec<StressResult>,
pub reactions: Vec<(usize, usize, f64)>,
}
#[derive(Debug, Clone, PartialEq)]
pub enum FemError {
SingularMatrix,
InvalidMesh,
MaterialNotFound,
ConvergenceFailed,
DegenerateElement,
InvalidElementOrientation,
}
impl std::fmt::Display for FemError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
FemError::SingularMatrix => write!(f, "Singular stiffness matrix"),
FemError::InvalidMesh => write!(f, "Invalid mesh"),
FemError::MaterialNotFound => write!(f, "Material not found"),
FemError::ConvergenceFailed => write!(f, "Solver did not converge"),
FemError::DegenerateElement => {
write!(f, "Degenerate element (zero or negative Jacobian)")
}
FemError::InvalidElementOrientation => write!(
f,
"Invalid element orientation (negative Jacobian, CW winding)"
),
}
}
}
impl std::error::Error for FemError {}
#[cfg(test)]
mod tests {
use super::*;
use crate::geometry::Point;
use crate::material::presets::STEEL_S355;
#[test]
fn material_props_d_matrix() {
let props = MaterialProps::plane_stress(&STEEL_S355);
let d = props.d_matrix();
assert!(d[0][0] > 0.0);
assert!(d[1][1] > 0.0);
assert!(d[2][2] > 0.0);
}
#[test]
fn stress_result_von_mises() {
let stress = StressResult::from_stress(100.0, 50.0, 30.0);
let expected =
(100.0_f64.powi(2) - 100.0 * 50.0 + 50.0_f64.powi(2) + 3.0 * 30.0_f64.powi(2)).sqrt();
assert!((stress.von_mises - expected).abs() < 1e-6);
}
#[test]
fn tri3_stiffness() {
let mut mesh = Mesh::new();
mesh.nodes = vec![
Point::new(0.0, 0.0),
Point::new(1.0, 0.0),
Point::new(0.0, 1.0),
];
mesh.elements = vec![[0, 1, 2]];
let props = MaterialProps::plane_stress(&STEEL_S355);
let ke = element_stiffness_tri3(&mesh, &[0, 1, 2], &props);
for i in 0..6 {
for j in 0..6 {
assert!((ke[i][j] - ke[j][i]).abs() < 1e-10);
}
}
for i in 0..6 {
assert!(ke[i][i] > 0.0);
}
}
#[test]
fn simple_cantilever() {
let mut mesh = Mesh::new();
mesh.nodes = vec![
Point::new(0.0, 0.0), Point::new(1.0, 0.0), Point::new(0.0, 0.1), Point::new(1.0, 0.1), ];
mesh.elements = vec![[0, 1, 2], [1, 3, 2]];
let mut model = FemModel::new(mesh);
let props = MaterialProps::plane_stress(&STEEL_S355);
model.add_material(props);
model.fix_node(0);
model.fix_node(2);
model.add_nodal_force(3, 1, -1000.0);
let mut solver = FemSolver::from_model(&model).unwrap();
solver.solve().unwrap();
let disp = solver.displacement(3);
assert!(disp.y < 0.0);
}
#[test]
fn reactions_balance_applied_load() {
let mut mesh = Mesh::new();
mesh.nodes = vec![
Point::new(0.0, 0.0), Point::new(1.0, 0.0), Point::new(0.0, 0.1), Point::new(1.0, 0.1), ];
mesh.elements = vec![[0, 1, 2], [1, 3, 2]];
let mut model = FemModel::new(mesh);
let props = MaterialProps::plane_stress(&STEEL_S355);
model.add_material(props);
model.fix_node(0);
model.fix_node(2);
model.add_nodal_force(3, 1, -1000.0);
let mut solver = FemSolver::from_model(&model).unwrap();
solver.solve().unwrap();
let reactions = solver.reactions(&model);
let mut vertical_reaction = 0.0;
for (node, dof, value) in &reactions {
assert!(node == &0 || node == &2, "reactions only at fixed nodes");
if *dof == 1 {
vertical_reaction += value;
}
}
assert!(
(vertical_reaction - 1000.0).abs() < 1e-6,
"vertical reactions should balance the applied load, got {vertical_reaction}"
);
}
}