pub(crate) mod fem;
pub mod fem_analysis;
pub mod triangulation;
pub use fem_analysis::{
FemCompositeAnalysis, FemGeometricProperties, FemSectionAnalysis, FemWarpingProperties,
PropertyComparison, StressPlotData, StressPost,
};
pub use triangulation::{Triangle, Triangulation, triangulate_polygon, triangulate_section};
pub use crate::mesh::triangulation::MeshControl;
pub use crate::mesh::triangulation::mesh_params_from_control;
use crate::geometry::Point;
use crate::section::Section;
use crate::section_library::CompositeSection;
#[derive(Debug, Clone)]
pub struct Mesh {
pub nodes: Vec<Point>,
pub elements: Vec<[usize; 3]>,
pub element_materials: Vec<usize>,
pub boundary_nodes: Vec<usize>,
pub hole_boundary_nodes: Vec<Vec<usize>>,
}
impl Mesh {
pub fn new() -> Self {
Self {
nodes: Vec::new(),
elements: Vec::new(),
element_materials: Vec::new(),
boundary_nodes: Vec::new(),
hole_boundary_nodes: Vec::new(),
}
}
pub fn n_nodes(&self) -> usize {
self.nodes.len()
}
pub fn n_elements(&self) -> usize {
self.elements.len()
}
pub fn node(&self, index: usize) -> Point {
self.nodes[index]
}
pub fn element(&self, index: usize) -> [usize; 3] {
self.elements[index]
}
pub fn element_centroid(&self, index: usize) -> Point {
let elem = self.elements[index];
let p1 = self.nodes[elem[0]];
let p2 = self.nodes[elem[1]];
let p3 = self.nodes[elem[2]];
Point::new((p1.x + p2.x + p3.x) / 3.0, (p1.y + p2.y + p3.y) / 3.0)
}
pub fn element_area(&self, index: usize) -> f64 {
let elem = self.elements[index];
let p1 = self.nodes[elem[0]];
let p2 = self.nodes[elem[1]];
let p3 = self.nodes[elem[2]];
0.5 * ((p2.x - p1.x) * (p3.y - p1.y) - (p3.x - p1.x) * (p2.y - p1.y)).abs()
}
pub fn quality_metrics(&self) -> MeshQuality {
let mut min_angle = f64::MAX;
let mut max_angle = f64::MIN;
let mut min_area = f64::MAX;
let mut max_area = f64::MIN;
let mut aspect_ratios = Vec::new();
for i in 0..self.n_elements() {
let elem = self.elements[i];
let p1 = self.nodes[elem[0]];
let p2 = self.nodes[elem[1]];
let p3 = self.nodes[elem[2]];
let a = ((p2.x - p3.x).powi(2) + (p2.y - p3.y).powi(2)).sqrt();
let b = ((p3.x - p1.x).powi(2) + (p3.y - p1.y).powi(2)).sqrt();
let c = ((p1.x - p2.x).powi(2) + (p1.y - p2.y).powi(2)).sqrt();
let angles = [
((b * b + c * c - a * a) / (2.0 * b * c)).acos(),
((a * a + c * c - b * b) / (2.0 * a * c)).acos(),
((a * a + b * b - c * c) / (2.0 * a * b)).acos(),
];
for &angle in &angles {
min_angle = min_angle.min(angle);
max_angle = max_angle.max(angle);
}
let area = 0.5 * ((p2.x - p1.x) * (p3.y - p1.y) - (p3.x - p1.x) * (p2.y - p1.y)).abs();
min_area = min_area.min(area);
max_area = max_area.max(area);
let s = (a + b + c) / 2.0;
let area_heron = (s * (s - a) * (s - b) * (s - c)).max(0.0).sqrt();
let h_min = 2.0 * area_heron / a.max(b).max(c);
let aspect = a.max(b).max(c) / h_min;
aspect_ratios.push(aspect);
}
MeshQuality {
min_angle: min_angle.to_degrees(),
max_angle: max_angle.to_degrees(),
min_area,
max_area,
avg_aspect_ratio: aspect_ratios.iter().sum::<f64>() / aspect_ratios.len() as f64,
max_aspect_ratio: aspect_ratios.iter().fold(0.0, |a, &b| a.max(b)),
}
}
}
impl Default for Mesh {
fn default() -> Self {
Self::new()
}
}
#[derive(Debug, Clone, Copy)]
pub struct MeshQuality {
pub min_angle: f64,
pub max_angle: f64,
pub min_area: f64,
pub max_area: f64,
pub avg_aspect_ratio: f64,
pub max_aspect_ratio: f64,
}
#[derive(Debug, Clone, Copy)]
pub struct MeshParams {
pub target_size: f64,
pub max_size: f64,
pub min_size: f64,
pub quality_threshold: f64,
pub use_delaunay: bool,
pub max_iterations: usize,
pub max_nodes: usize,
}
impl Default for MeshParams {
fn default() -> Self {
Self {
target_size: 0.01,
max_size: 0.02,
min_size: 0.001,
quality_threshold: 0.3,
use_delaunay: true,
max_iterations: 10,
max_nodes: 20000,
}
}
}
pub fn mesh_section(section: &Section, params: MeshParams) -> Mesh {
triangulate_section(section, params)
}
pub fn mesh_composite_section(composite: &CompositeSection, params: MeshParams) -> Mesh {
let mut mesh = triangulate_section(
&Section::new(composite.outer.clone(), composite.holes.clone()),
params,
);
mesh.element_materials = vec![0; mesh.n_elements()];
mesh
}
#[cfg(test)]
mod tests {
use super::*;
use crate::geometry::Point;
#[test]
fn mesh_quality_metrics() {
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),
Point::new(1.0, 1.0),
];
mesh.elements = vec![[0, 1, 2], [1, 3, 2]];
let quality = mesh.quality_metrics();
assert!(quality.min_angle > 0.0);
assert!(quality.max_angle <= 180.0);
}
}