Omar SobhandClaude Opus 5.5
312ea305c6
Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>
667 lines
25 KiB
Rust
667 lines
25 KiB
Rust
//! R8-b: the Turek–Hron flag as a 3-D Hex20 total-Lagrangian SVK solid
|
||
//! ([`rtx_fea::analysis::flag3d`]).
|
||
//!
|
||
//! Suite (fast, run by default):
|
||
//!
|
||
//! 1. `flag3d_mesh_mass_and_surface_forces` — node/element counts, the
|
||
//! consistent mass sums to `ρ V`, and the face integrator's totals
|
||
//! (uniform traction on the top face = `t · L · span`; a uniform
|
||
//! pressure on bottom + top cancels; a rigid translation of the
|
||
//! configuration changes nothing).
|
||
//! 2. `plane_strain_3d_reproduces_the_2d_csm1` — CSM1 (static, gravity)
|
||
//! with `u_z = 0` everywhere reproduces the 2-D 35×2 Quad8 plane-strain
|
||
//! model to rounding (same Newton, same banded LU).
|
||
//! 3. `plane_strain_3d_reproduces_the_2d_csm3_start` — the first 60
|
||
//! Newmark steps of CSM3 agree with the 2-D stepper to rounding.
|
||
//!
|
||
//! Instruments (`#[ignore]`, env-driven, write under `FLAG3D_OUT`):
|
||
//!
|
||
//! * `flag3d_csm1_table` — CSM1 tip displacement per configuration.
|
||
//! * `flag3d_csm3_march` — the full CSM3 oscillation, CSV of point A and
|
||
//! of the tip's lateral corners.
|
||
//! * `flag3d_modes_dump` — the linearised operators (TL tangent at u = 0,
|
||
//! consistent mass) on the free DOFs, for an outside eigen-solve.
|
||
|
||
use std::io::Write as _;
|
||
|
||
use nalgebra::{DVector, Vector3};
|
||
use rtx_fea::analysis::flag3d::{Flag3d, Flag3dSpec, FlagSide, LateralFaces};
|
||
use rtx_fea::analysis::{
|
||
ConvergenceCriteria, DynamicState, NonlinearDynamicAnalysis, NonlinearDynamicStepper,
|
||
};
|
||
use rtx_fea::assembly::dof_mapping::DofComponent;
|
||
use rtx_fea::boundary::dirichlet::{DirichletBC, DirichletType};
|
||
use rtx_fea::boundary::{BoundaryCondition, BoundaryConditionSet, SpatialFunction};
|
||
use rtx_fea::elements::total_lagrangian::{internal_force_and_tangent, saint_venant_kirchhoff};
|
||
use rtx_fea::elements::{ElementMatrixComputer, StandardFiniteElement};
|
||
use rtx_fea::materials::{LinearElastic, Material as _};
|
||
use rtx_fea::mesh::{Element, ElementType, MaterialId, Mesh, Node, NodeId};
|
||
|
||
const E_MOD: f64 = 1.4e6;
|
||
const NU: f64 = 0.4;
|
||
/// CSM1/CSM3 density and gravity (FSI2's structure is ρ_s = 1e4).
|
||
const RHO_CSM: f64 = 1000.0;
|
||
const G: f64 = 2.0;
|
||
|
||
fn env_str(name: &str, default: &str) -> String {
|
||
std::env::var(name).unwrap_or_else(|_| default.to_string())
|
||
}
|
||
|
||
fn env_num(name: &str, default: f64) -> f64 {
|
||
std::env::var(name)
|
||
.map(|v| v.parse().expect(name))
|
||
.unwrap_or(default)
|
||
}
|
||
|
||
/// The 2-D flag, exactly as the FSI2 harness builds it.
|
||
fn quad8_flag(nx: usize, ny: usize) -> Mesh {
|
||
let (x0, x1, y0, y1) = (0.25, 0.6, 0.19, 0.21);
|
||
let mut mesh = Mesh::new(2).unwrap();
|
||
let (lx, ly) = (2 * nx + 1, 2 * ny + 1);
|
||
let mut grid = vec![vec![None; ly]; lx];
|
||
for (i, column) in grid.iter_mut().enumerate() {
|
||
for (j, slot) in column.iter_mut().enumerate() {
|
||
if i % 2 == 1 && j % 2 == 1 {
|
||
continue;
|
||
}
|
||
let x = x0 + (x1 - x0) * i as f64 / (2 * nx) as f64;
|
||
let y = y0 + (y1 - y0) * j as f64 / (2 * ny) as f64;
|
||
*slot = Some(mesh.add_node(Node::new_2d(x, y)));
|
||
}
|
||
}
|
||
for i in 0..nx {
|
||
for j in 0..ny {
|
||
let (a, b) = (2 * i, 2 * j);
|
||
let nodes = vec![
|
||
grid[a][b].unwrap(),
|
||
grid[a + 2][b].unwrap(),
|
||
grid[a + 2][b + 2].unwrap(),
|
||
grid[a][b + 2].unwrap(),
|
||
grid[a + 1][b].unwrap(),
|
||
grid[a + 2][b + 1].unwrap(),
|
||
grid[a + 1][b + 2].unwrap(),
|
||
grid[a][b + 1].unwrap(),
|
||
];
|
||
mesh.add_element(Element::new(ElementType::Quad8, nodes, MaterialId(0)).unwrap())
|
||
.unwrap();
|
||
}
|
||
}
|
||
mesh
|
||
}
|
||
|
||
fn clamp_2d(mesh: &Mesh) -> BoundaryConditionSet {
|
||
let clamped: Vec<NodeId> = mesh
|
||
.nodes
|
||
.iter()
|
||
.filter(|(_, node)| (node.position().x - 0.25).abs() < 1e-12)
|
||
.map(|(&id, _)| id)
|
||
.collect();
|
||
let mut set = BoundaryConditionSet::new();
|
||
for component in [DofComponent::DisplacementX, DofComponent::DisplacementY] {
|
||
set.add_condition(BoundaryCondition::Dirichlet(DirichletBC {
|
||
nodes: clamped.clone(),
|
||
components: vec![component],
|
||
condition_type: DirichletType::Spatial(SpatialFunction(Box::new(|_| 0.0))),
|
||
time_range: None,
|
||
ramping_factor: 1.0,
|
||
gradual_enforcement: false,
|
||
}));
|
||
}
|
||
set
|
||
}
|
||
|
||
fn point_2d(mesh: &Mesh, x: f64, y: f64) -> NodeId {
|
||
mesh.nodes
|
||
.iter()
|
||
.find(|(_, n)| (n.position().x - x).abs() < 1e-12 && (n.position().y - y).abs() < 1e-12)
|
||
.map(|(&id, _)| id)
|
||
.unwrap()
|
||
}
|
||
|
||
/// Consistent gravity nodal forces `∫ N_a ρ g dV` (per unit depth in 2-D).
|
||
fn gravity_forces(mesh: &Mesh, rho: f64, g: f64) -> Vec<(NodeId, Vector3<f64>)> {
|
||
let dim = mesh.spatial_dimension;
|
||
let mut acc: std::collections::BTreeMap<NodeId, Vector3<f64>> = Default::default();
|
||
for element in mesh.elements.values() {
|
||
let coords: Vec<Vector3<f64>> = element
|
||
.nodes
|
||
.iter()
|
||
.map(|id| mesh.get_node(*id).unwrap().position())
|
||
.collect();
|
||
let fe = StandardFiniteElement::new(element.element_type, coords.clone());
|
||
let f = ElementMatrixComputer::compute_body_force_vector(
|
||
&fe,
|
||
&coords,
|
||
&|_| Vector3::new(0.0, -rho * g, 0.0),
|
||
None,
|
||
)
|
||
.unwrap();
|
||
for (a, id) in element.nodes.iter().enumerate() {
|
||
let e = acc.entry(*id).or_insert_with(Vector3::zeros);
|
||
for c in 0..dim {
|
||
e[c] += f[a * dim + c];
|
||
}
|
||
}
|
||
}
|
||
acc.into_iter().collect()
|
||
}
|
||
|
||
/// Newton to rounding: the static comparisons are otherwise limited by
|
||
/// the default 1e-6 stopping rule (whose force scale differs between the
|
||
/// 2-D per-unit-depth and the 3-D per-span loads).
|
||
fn static_criteria() -> ConvergenceCriteria {
|
||
ConvergenceCriteria {
|
||
force_tolerance: 1e-12,
|
||
displacement_tolerance: 1e-14,
|
||
max_iterations: 60,
|
||
..ConvergenceCriteria::default()
|
||
}
|
||
}
|
||
|
||
/// Static equilibrium through the dynamic stepper: one "Newmark step" of
|
||
/// `dt = 1e4 s` from `u = v = a = 0` is Newton on
|
||
/// `f_int(u) + M u/(β Δt²) = F` — the static problem up to a mass term
|
||
/// 1e-9 of the stiffness. `load_steps` ramps the load, each step starting
|
||
/// from the previous equilibrium with zero velocity and acceleration.
|
||
fn static_solve<'a>(
|
||
analysis: &'a NonlinearDynamicAnalysis,
|
||
forces: &[(NodeId, Vector3<f64>)],
|
||
load_steps: usize,
|
||
) -> (DVector<f64>, NonlinearDynamicStepper<'a>, usize) {
|
||
let mut stepper = analysis.stepper().unwrap();
|
||
let n = stepper.rest_state().unwrap().displacement.len();
|
||
let mut u = DVector::zeros(n);
|
||
let mut iterations = 0;
|
||
for s in 1..=load_steps {
|
||
let scale = s as f64 / load_steps as f64;
|
||
let scaled: Vec<_> = forces.iter().map(|(id, f)| (*id, f * scale)).collect();
|
||
stepper.set_nodal_forces(&scaled);
|
||
let state = DynamicState {
|
||
displacement: u.clone(),
|
||
velocity: DVector::zeros(n),
|
||
acceleration: DVector::zeros(n),
|
||
};
|
||
let (next, it) = stepper.step(&state).unwrap();
|
||
iterations += it;
|
||
u = next.displacement;
|
||
}
|
||
(u, stepper, iterations)
|
||
}
|
||
|
||
fn static_2d_csm1(nx: usize, ny: usize) -> (f64, f64, usize) {
|
||
let mesh = quad8_flag(nx, ny);
|
||
let a = point_2d(&mesh, 0.6, 0.2);
|
||
let forces = gravity_forces(&mesh, RHO_CSM, G);
|
||
let analysis = NonlinearDynamicAnalysis::new(
|
||
mesh.clone(),
|
||
Flag3d::materials(E_MOD, NU, RHO_CSM),
|
||
clamp_2d(&mesh),
|
||
1e4,
|
||
1,
|
||
Default::default(),
|
||
)
|
||
.with_total_lagrangian()
|
||
.with_convergence_criteria(static_criteria());
|
||
let (u, stepper, it) = static_solve(&analysis, &forces, 5);
|
||
let d = stepper.node_dofs(a);
|
||
(u[d[0]], u[d[1]], it)
|
||
}
|
||
|
||
struct Tip3d {
|
||
a: Vector3<f64>,
|
||
/// Point A's line at the two lateral faces (z0, z1).
|
||
side_low: Vector3<f64>,
|
||
side_high: Vector3<f64>,
|
||
iterations: usize,
|
||
dofs: usize,
|
||
}
|
||
|
||
fn static_3d_csm1(spec: Flag3dSpec, lateral: LateralFaces, load_steps: usize) -> Tip3d {
|
||
let flag = Flag3d::build(spec).unwrap();
|
||
let forces = gravity_forces(&flag.mesh, RHO_CSM, G);
|
||
let analysis = flag
|
||
.dynamic_analysis(E_MOD, NU, RHO_CSM, lateral, 1e4, 1, 0.5)
|
||
.with_convergence_criteria(static_criteria());
|
||
let (u, stepper, iterations) = static_solve(&analysis, &forces, load_steps);
|
||
let read = |id: NodeId| {
|
||
let d = stepper.node_dofs(id);
|
||
Vector3::new(u[d[0]], u[d[1]], u[d[2]])
|
||
};
|
||
let ym = 0.5 * (spec.y0 + spec.y1);
|
||
Tip3d {
|
||
a: read(flag.point_a()),
|
||
side_low: read(flag.nearest_node(Vector3::new(spec.x1, ym, spec.z0))),
|
||
side_high: read(flag.nearest_node(Vector3::new(spec.x1, ym, spec.z1))),
|
||
iterations,
|
||
dofs: u.len(),
|
||
}
|
||
}
|
||
|
||
fn rel(a: f64, b: f64) -> f64 {
|
||
((a - b) / b).abs()
|
||
}
|
||
|
||
#[test]
|
||
fn flag3d_mesh_mass_and_surface_forces() {
|
||
let spec = Flag3dSpec::turek_hron(0.1, -0.05, 7, 2, 3);
|
||
let flag = Flag3d::build(spec).unwrap();
|
||
// Serendipity lattice: points with at most one odd index.
|
||
let [di, dj, dk] = flag.lattice_dims();
|
||
let mut expected = 0;
|
||
for i in 0..di {
|
||
for j in 0..dj {
|
||
for k in 0..dk {
|
||
if (i % 2) + (j % 2) + (k % 2) <= 1 {
|
||
expected += 1;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
assert_eq!(flag.mesh.nodes.len(), expected);
|
||
assert_eq!(flag.mesh.elements.len(), 7 * 2 * 3);
|
||
// Consistent mass sums to ρ V; every Jacobian is positive.
|
||
let mut mass = 0.0;
|
||
for element in flag.mesh.elements.values() {
|
||
let coords: Vec<Vector3<f64>> = element
|
||
.nodes
|
||
.iter()
|
||
.map(|id| flag.mesh.get_node(*id).unwrap().position())
|
||
.collect();
|
||
let fe = StandardFiniteElement::new(element.element_type, coords.clone());
|
||
let m =
|
||
ElementMatrixComputer::compute_consistent_mass_matrix(&fe, &coords, 1e4, None).unwrap();
|
||
mass += m.matrix.sum();
|
||
}
|
||
let volume = 0.35 * 0.02 * 0.1;
|
||
assert!(
|
||
rel(mass, 1e4 * volume) < 1e-12,
|
||
"mass {mass} vs {}",
|
||
1e4 * volume
|
||
);
|
||
|
||
// Uniform traction on the top face: total = t · L · span.
|
||
let top = flag.surface_faces(&[FlagSide::Top]);
|
||
let t0 = Vector3::new(3.0, -2.0, 0.5);
|
||
let total: Vector3<f64> = flag
|
||
.face_nodal_forces(&top, None, &|_, _| t0)
|
||
.iter()
|
||
.map(|(_, f)| f)
|
||
.sum();
|
||
assert!((total - t0 * (0.35 * 0.1)).norm() < 1e-12, "{total:?}");
|
||
// Normals point out: a pressure p on the top pushes down, on the tip
|
||
// pushes −x, on the side faces pushes inward; bottom + top cancel.
|
||
let p = 7.0;
|
||
let pressure = |_: Vector3<f64>, n: Vector3<f64>| -p * n;
|
||
let sum = |sides: &[FlagSide]| -> Vector3<f64> {
|
||
flag.face_nodal_forces(&flag.surface_faces(sides), None, &pressure)
|
||
.iter()
|
||
.map(|(_, f)| f)
|
||
.sum()
|
||
};
|
||
assert!((sum(&[FlagSide::Top]) - Vector3::new(0.0, -p * 0.035, 0.0)).norm() < 1e-12);
|
||
assert!((sum(&[FlagSide::Tip]) - Vector3::new(-p * 0.002, 0.0, 0.0)).norm() < 1e-12);
|
||
assert!((sum(&[FlagSide::SideHigh]) - Vector3::new(0.0, 0.0, -p * 0.007)).norm() < 1e-12);
|
||
assert!((sum(&[FlagSide::SideLow]) - Vector3::new(0.0, 0.0, p * 0.007)).norm() < 1e-12);
|
||
assert!(sum(&[FlagSide::Bottom, FlagSide::Top]).norm() < 1e-12);
|
||
// All five wetted faces + the root would close; without the root the
|
||
// pressure resultant is the root's missing +x share.
|
||
let wetted: Vector3<f64> = flag
|
||
.face_nodal_forces(&flag.wetted_faces(), None, &pressure)
|
||
.iter()
|
||
.map(|(_, f)| f)
|
||
.sum();
|
||
assert!((wetted - Vector3::new(-p * 0.002, 0.0, 0.0)).norm() < 1e-12);
|
||
// A rigid translation of the configuration changes nothing.
|
||
let analysis = flag.dynamic_analysis(1.4e6, 0.4, 1e4, LateralFaces::Free, 1e-3, 1, 0.5);
|
||
let stepper = analysis.stepper().unwrap();
|
||
let mut u = DVector::zeros(3 * flag.mesh.nodes.len());
|
||
for id in flag.mesh.nodes.keys() {
|
||
let d = stepper.node_dofs(*id);
|
||
u[d[0]] = 0.01;
|
||
u[d[1]] = -0.03;
|
||
u[d[2]] = 0.02;
|
||
}
|
||
let dofs = |id: NodeId| stepper.node_dofs(id);
|
||
let moved = flag.face_nodal_forces(&top, Some((&u, &dofs)), &|_, n| -p * n);
|
||
let still = flag.face_nodal_forces(&top, None, &|_, n| -p * n);
|
||
for ((ia, fa), (ib, fb)) in moved.iter().zip(&still) {
|
||
assert_eq!(ia, ib);
|
||
assert!((fa - fb).norm() < 1e-14);
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn plane_strain_3d_reproduces_the_2d_csm1() {
|
||
let (ux2, uy2, it2) = static_2d_csm1(35, 2);
|
||
let tip = static_3d_csm1(
|
||
Flag3dSpec::turek_hron(0.05, 0.0, 35, 2, 1),
|
||
LateralFaces::PlaneStrain,
|
||
5,
|
||
);
|
||
println!(
|
||
" CSM1 35x2: 2-D Quad8 u(A) = ({ux2:.9e}, {uy2:.9e}) [{it2} Newton]; 3-D Hex20 \
|
||
35x2x1 plane strain u(A) = ({:.9e}, {:.9e}, {:.2e}) [{} Newton, {} DOFs]; \
|
||
reference (−7.18777e-3, −66.1029e-3)",
|
||
tip.a.x, tip.a.y, tip.a.z, tip.iterations, tip.dofs
|
||
);
|
||
assert!(rel(tip.a.x, ux2) < 1e-8, "ux {} vs 2-D {ux2}", tip.a.x);
|
||
assert!(rel(tip.a.y, uy2) < 1e-8, "uy {} vs 2-D {uy2}", tip.a.y);
|
||
assert!(tip.a.z.abs() < 1e-15);
|
||
// Span-uniform: both lateral faces carry the mid-span value.
|
||
assert!((tip.side_low - tip.a).norm() < 1e-9 * tip.a.norm());
|
||
assert!((tip.side_high - tip.a).norm() < 1e-9 * tip.a.norm());
|
||
// And the 2-D model is the one pinned against FEATFLOW (1% short in
|
||
// u_y at 35x2, total_lagrangian_svk.rs).
|
||
assert!(rel(uy2, -66.1029e-3) < 0.02 && rel(ux2, -7.18777e-3) < 0.04);
|
||
}
|
||
|
||
/// The free-lateral-face path, pinned: a narrow strip (span 0.02 = the
|
||
/// thickness) under CSM1 gravity. Measured with `flag3d_csm1_table`
|
||
/// (R8-b, 2026-09-25): u_y(A) = −76.340e-3 — softer than plane strain
|
||
/// (−65.141e-3) because the free faces relax the spanwise stress.
|
||
#[test]
|
||
fn free_lateral_faces_csm1_strip_pin() {
|
||
let tip = static_3d_csm1(
|
||
Flag3dSpec::turek_hron(0.02, -0.01, 35, 2, 1),
|
||
LateralFaces::Free,
|
||
5,
|
||
);
|
||
println!(
|
||
" CSM1 35x2x1 span 0.02 free faces: u(A) = ({:.6e}, {:.6e}, {:.2e})",
|
||
tip.a.x, tip.a.y, tip.a.z
|
||
);
|
||
assert!(rel(tip.a.y, -76.340_06e-3) < 1e-5, "uy {}", tip.a.y);
|
||
assert!(rel(tip.a.x, -9.680_464e-3) < 1e-5, "ux {}", tip.a.x);
|
||
assert!(
|
||
tip.a.z.abs() < 1e-12,
|
||
"mid-span must not move in z: {}",
|
||
tip.a.z
|
||
);
|
||
assert!(
|
||
(tip.side_low.y - tip.side_high.y).abs() < 1e-12,
|
||
"span symmetry"
|
||
);
|
||
}
|
||
|
||
fn csm3_2d(dt: f64) -> (NonlinearDynamicAnalysis, NodeId) {
|
||
let mesh = quad8_flag(35, 2);
|
||
let a = point_2d(&mesh, 0.6, 0.2);
|
||
let mut analysis = NonlinearDynamicAnalysis::new(
|
||
mesh.clone(),
|
||
Flag3d::materials(E_MOD, NU, RHO_CSM),
|
||
clamp_2d(&mesh),
|
||
dt,
|
||
1,
|
||
Default::default(),
|
||
)
|
||
.with_total_lagrangian();
|
||
analysis.set_body_force(|_| Vector3::new(0.0, -RHO_CSM * G, 0.0));
|
||
(analysis, a)
|
||
}
|
||
|
||
#[test]
|
||
fn plane_strain_3d_reproduces_the_2d_csm3_start() {
|
||
let dt = 0.005;
|
||
let steps = 60;
|
||
let (a2d, node2) = csm3_2d(dt);
|
||
let mut s2 = a2d.stepper().unwrap();
|
||
let flag = Flag3d::build(Flag3dSpec::turek_hron(0.05, 0.0, 35, 2, 1)).unwrap();
|
||
let mut a3d = flag.dynamic_analysis(E_MOD, NU, RHO_CSM, LateralFaces::PlaneStrain, dt, 1, 0.5);
|
||
a3d.set_body_force(|_| Vector3::new(0.0, -RHO_CSM * G, 0.0));
|
||
let mut s3 = a3d.stepper().unwrap();
|
||
let node3 = flag.point_a();
|
||
let (d2, d3) = (s2.node_dofs(node2), s3.node_dofs(node3));
|
||
let mut st2 = s2.rest_state().unwrap();
|
||
let mut st3 = s3.rest_state().unwrap();
|
||
let mut worst: f64 = 0.0;
|
||
let mut peak: f64 = 0.0;
|
||
for _ in 0..steps {
|
||
st2 = s2.step(&st2).unwrap().0;
|
||
st3 = s3.step(&st3).unwrap().0;
|
||
for c in 0..2 {
|
||
worst = worst.max((st2.displacement[d2[c]] - st3.displacement[d3[c]]).abs());
|
||
peak = peak.max(st2.displacement[d2[c]].abs());
|
||
}
|
||
}
|
||
println!(
|
||
" CSM3 first {steps} steps (t = {:.2} s): max |u_3D − u_2D| at A {worst:.3e} m, \
|
||
peak |u| {peak:.3e} m",
|
||
steps as f64 * dt
|
||
);
|
||
assert!(peak > 1e-2, "the flag must have moved: {peak}");
|
||
assert!(
|
||
worst < 1e-8 * peak,
|
||
"3-D plane strain departs from 2-D: {worst:.3e}"
|
||
);
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------
|
||
// Instruments
|
||
// ---------------------------------------------------------------------------
|
||
|
||
/// `NXxNYxNZ:span:free|ps` entries, comma-separated.
|
||
fn parse_configs(spec: &str) -> Vec<(usize, usize, usize, f64, LateralFaces)> {
|
||
spec.split(',')
|
||
.map(|entry| {
|
||
let mut parts = entry.trim().split(':');
|
||
let mesh = parts.next().unwrap();
|
||
let span: f64 = parts.next().unwrap().parse().unwrap();
|
||
let lateral = match parts.next().unwrap() {
|
||
"free" => LateralFaces::Free,
|
||
"ps" => LateralFaces::PlaneStrain,
|
||
other => panic!("lateral {other}"),
|
||
};
|
||
let n: Vec<usize> = mesh.split('x').map(|t| t.parse().unwrap()).collect();
|
||
(n[0], n[1], n[2], span, lateral)
|
||
})
|
||
.collect()
|
||
}
|
||
|
||
fn tag(nx: usize, ny: usize, nz: usize, span: f64, lateral: LateralFaces) -> String {
|
||
let l = if lateral == LateralFaces::Free {
|
||
"free"
|
||
} else {
|
||
"ps"
|
||
};
|
||
format!("{nx}x{ny}x{nz}_s{span}_{l}")
|
||
}
|
||
|
||
#[test]
|
||
#[ignore = "instrument: CSM1 tip displacement per configuration"]
|
||
fn flag3d_csm1_table() {
|
||
let out = env_str("FLAG3D_OUT", ".");
|
||
let configs = parse_configs(&env_str(
|
||
"FLAG3D_CONFIGS",
|
||
"35x2x1:0.05:ps,35x2x4:0.41:free",
|
||
));
|
||
let steps = env_num("FLAG3D_LOAD_STEPS", 5.0) as usize;
|
||
let mut table = std::fs::OpenOptions::new()
|
||
.create(true)
|
||
.append(true)
|
||
.open(format!("{out}/csm1_table.txt"))
|
||
.unwrap();
|
||
for (nx, ny, nz, span, lateral) in configs {
|
||
let start = std::time::Instant::now();
|
||
let tip = static_3d_csm1(
|
||
Flag3dSpec::turek_hron(span, -0.5 * span, nx, ny, nz),
|
||
lateral,
|
||
steps,
|
||
);
|
||
let line = format!(
|
||
"CSM1 {} dofs {} newton {} | A ux {:.6e} uy {:.6e} uz {:.3e} | side_low uy {:.6e} \
|
||
side_high uy {:.6e} | {:.1} s | ref ux -7.18777e-3 uy -66.1029e-3",
|
||
tag(nx, ny, nz, span, lateral),
|
||
tip.dofs,
|
||
tip.iterations,
|
||
tip.a.x,
|
||
tip.a.y,
|
||
tip.a.z,
|
||
tip.side_low.y,
|
||
tip.side_high.y,
|
||
start.elapsed().as_secs_f64()
|
||
);
|
||
println!("{line}");
|
||
writeln!(table, "{line}").unwrap();
|
||
}
|
||
if env_str("FLAG3D_2D", "1") == "1" {
|
||
for (nx, ny) in [(35, 2), (70, 4)] {
|
||
let (ux, uy, it) = static_2d_csm1(nx, ny);
|
||
let line =
|
||
format!("CSM1 2-D {nx}x{ny} Quad8 | A ux {ux:.6e} uy {uy:.6e} [{it} Newton]");
|
||
println!("{line}");
|
||
writeln!(table, "{line}").unwrap();
|
||
}
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
#[ignore = "instrument: the CSM3 oscillation on the 3-D flag"]
|
||
fn flag3d_csm3_march() {
|
||
let out = env_str("FLAG3D_OUT", ".");
|
||
let configs = parse_configs(&env_str("FLAG3D_CONFIGS", "35x2x1:0.05:ps"));
|
||
let dt = env_num("FLAG3D_DT", 0.005);
|
||
let steps = env_num("FLAG3D_STEPS", 2000.0) as usize;
|
||
for (nx, ny, nz, span, lateral) in configs {
|
||
let spec = Flag3dSpec::turek_hron(span, -0.5 * span, nx, ny, nz);
|
||
let flag = Flag3d::build(spec).unwrap();
|
||
let mut analysis = flag.dynamic_analysis(E_MOD, NU, RHO_CSM, lateral, dt, steps, 0.5);
|
||
analysis.set_body_force(|_| Vector3::new(0.0, -RHO_CSM * G, 0.0));
|
||
let mut stepper = analysis.stepper().unwrap();
|
||
let ym = 0.5 * (spec.y0 + spec.y1);
|
||
let probes = [
|
||
flag.point_a(),
|
||
flag.nearest_node(Vector3::new(spec.x1, ym, spec.z0)),
|
||
flag.nearest_node(Vector3::new(spec.x1, ym, spec.z1)),
|
||
];
|
||
let dofs: Vec<Vec<usize>> = probes.iter().map(|p| stepper.node_dofs(*p)).collect();
|
||
let name = tag(nx, ny, nz, span, lateral);
|
||
let path = format!("{out}/csm3_{name}_dt{dt}.csv");
|
||
let mut csv = std::fs::File::create(&path).unwrap();
|
||
writeln!(csv, "t,ax,ay,az,low_y,high_y,low_z,high_z,newton").unwrap();
|
||
let mut state = stepper.rest_state().unwrap();
|
||
let start = std::time::Instant::now();
|
||
let mut total = 0usize;
|
||
for k in 1..=steps {
|
||
let (next, it) = stepper.step(&state).unwrap();
|
||
state = next;
|
||
total += it;
|
||
let u = &state.displacement;
|
||
writeln!(
|
||
csv,
|
||
"{:.6e},{:.12e},{:.12e},{:.12e},{:.12e},{:.12e},{:.12e},{:.12e},{it}",
|
||
k as f64 * dt,
|
||
u[dofs[0][0]],
|
||
u[dofs[0][1]],
|
||
u[dofs[0][2]],
|
||
u[dofs[1][1]],
|
||
u[dofs[2][1]],
|
||
u[dofs[1][2]],
|
||
u[dofs[2][2]]
|
||
)
|
||
.unwrap();
|
||
}
|
||
println!(
|
||
"CSM3 {name} dt {dt}: {steps} steps, {total} Newton, rescues {:?}, {:.0} s → {path}",
|
||
stepper.rescue_counts(),
|
||
start.elapsed().as_secs_f64()
|
||
);
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
#[ignore = "instrument: the 3-D flag's K and M for an outside eigen-solve"]
|
||
fn flag3d_modes_dump() {
|
||
let out = env_str("FLAG3D_OUT", ".");
|
||
let configs = parse_configs(&env_str("FLAG3D_CONFIGS", "35x2x1:0.05:ps"));
|
||
let rho = env_num("FLAG3D_RHO", 1e4);
|
||
let (lambda, mu) = LinearElastic::new(E_MOD, NU)
|
||
.with_density(rho)
|
||
.properties()
|
||
.lame_parameters();
|
||
let constitutive = saint_venant_kirchhoff(lambda, mu, 3);
|
||
for (nx, ny, nz, span, lateral) in configs {
|
||
let spec = Flag3dSpec::turek_hron(span, -0.5 * span, nx, ny, nz);
|
||
let flag = Flag3d::build(spec).unwrap();
|
||
let mut ids: Vec<NodeId> = flag.mesh.nodes.keys().copied().collect();
|
||
ids.sort();
|
||
let mut free = std::collections::HashMap::new();
|
||
let mut dof_lines = Vec::new();
|
||
for id in &ids {
|
||
let p = flag.mesh.get_node(*id).unwrap().position();
|
||
if (p.x - spec.x0).abs() < 1e-12 {
|
||
continue;
|
||
}
|
||
let comps = if lateral == LateralFaces::PlaneStrain {
|
||
2
|
||
} else {
|
||
3
|
||
};
|
||
for c in 0..comps {
|
||
free.insert((*id, c), dof_lines.len());
|
||
dof_lines.push(format!(
|
||
"{} {} {:.12e} {:.12e} {:.12e} {c}",
|
||
dof_lines.len(),
|
||
id.0,
|
||
p.x,
|
||
p.y,
|
||
p.z
|
||
));
|
||
}
|
||
}
|
||
let mut k_trip: std::collections::BTreeMap<(usize, usize), f64> = Default::default();
|
||
let mut m_trip: std::collections::BTreeMap<(usize, usize), f64> = Default::default();
|
||
for element in flag.mesh.elements.values() {
|
||
let coords: Vec<Vector3<f64>> = element
|
||
.nodes
|
||
.iter()
|
||
.map(|id| flag.mesh.get_node(*id).unwrap().position())
|
||
.collect();
|
||
let fe = StandardFiniteElement::new(element.element_type, coords.clone());
|
||
let zero = DVector::zeros(3 * element.nodes.len());
|
||
let (_, k_e) =
|
||
internal_force_and_tangent(&fe, &coords, &zero, constitutive.as_ref(), None)
|
||
.unwrap();
|
||
let m_s =
|
||
ElementMatrixComputer::compute_consistent_mass_matrix(&fe, &coords, rho, None)
|
||
.unwrap();
|
||
let local: Vec<Option<usize>> = element
|
||
.nodes
|
||
.iter()
|
||
.flat_map(|n| (0..3).map(move |c| (*n, c)))
|
||
.map(|key| free.get(&key).copied())
|
||
.collect();
|
||
for (a, ga) in local.iter().enumerate() {
|
||
let Some(ga) = ga else { continue };
|
||
for (b, gb) in local.iter().enumerate() {
|
||
let Some(gb) = gb else { continue };
|
||
*k_trip.entry((*ga, *gb)).or_default() += k_e[(a, b)];
|
||
if a % 3 == b % 3 {
|
||
*m_trip.entry((*ga, *gb)).or_default() += m_s.matrix[(a / 3, b / 3)];
|
||
}
|
||
}
|
||
}
|
||
}
|
||
let name = tag(nx, ny, nz, span, lateral);
|
||
let write = |kind: &str, trip: &std::collections::BTreeMap<(usize, usize), f64>| {
|
||
let mut f = std::fs::File::create(format!("{out}/{kind}_{name}.coo")).unwrap();
|
||
for ((i, j), v) in trip {
|
||
if *v != 0.0 {
|
||
writeln!(f, "{i} {j} {v:.17e}").unwrap();
|
||
}
|
||
}
|
||
};
|
||
write("k", &k_trip);
|
||
write("m", &m_trip);
|
||
std::fs::write(
|
||
format!("{out}/dofs_{name}.txt"),
|
||
dof_lines.join("\n") + "\n",
|
||
)
|
||
.unwrap();
|
||
println!(
|
||
"modes dump {name}: {} free DOFs, K nnz {}",
|
||
dof_lines.len(),
|
||
k_trip.len()
|
||
);
|
||
}
|
||
}
|