#![allow(clippy::needless_range_loop)]
#[cfg(not(target_arch = "wasm32"))]
use super::gpu_solve::GpuSolver;
use crate::math::Vector3;
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub enum Solver {
#[default]
Cpu,
Gpu,
}
#[cfg(not(target_arch = "wasm32"))]
fn shared_gpu() -> Option<&'static GpuSolver> {
static GPU: std::sync::OnceLock<Option<GpuSolver>> = std::sync::OnceLock::new();
GPU.get_or_init(GpuSolver::new).as_ref()
}
#[derive(Clone, Copy, Debug)]
pub struct SolidMaterial {
pub modulus: f64,
pub poisson: f64,
}
impl Default for SolidMaterial {
fn default() -> Self {
Self {
modulus: 1.0,
poisson: 0.3,
}
}
}
#[derive(Clone, Copy, Debug)]
pub struct Stiffness {
pub c: [[f64; 6]; 6],
pub relative_density: f64,
pub solver: Solver,
pub voxels: usize,
}
impl Stiffness {
pub fn compliance(&self) -> [[f64; 6]; 6] {
invert6(&self.c).unwrap_or([[0.0; 6]; 6])
}
pub fn youngs_moduli(&self) -> [f64; 3] {
let s = self.compliance();
[0, 1, 2].map(|i| if s[i][i].abs() > 1e-30 { 1.0 / s[i][i] } else { 0.0 })
}
pub fn shear_moduli(&self) -> [f64; 3] {
let s = self.compliance();
[3, 4, 5].map(|i| if s[i][i].abs() > 1e-30 { 1.0 / s[i][i] } else { 0.0 })
}
pub fn poisson_ratios(&self) -> [f64; 3] {
let s = self.compliance();
let ratio = |along: usize, across: usize| {
if s[along][along].abs() > 1e-30 {
-s[across][along] / s[along][along]
} else {
0.0
}
};
[ratio(1, 2), ratio(0, 2), ratio(0, 1)]
}
pub fn directional_modulus(&self, direction: Vector3) -> f64 {
let n = direction.normalize();
let n = [n.x as f64, n.y as f64, n.z as f64];
let s = self.compliance();
let mut sum = 0.0;
for i in 0..3 {
for j in 0..3 {
for k in 0..3 {
for l in 0..3 {
sum += n[i] * n[j] * n[k] * n[l] * tensor(&s, i, j, k, l);
}
}
}
}
if sum.abs() > 1e-30 {
1.0 / sum
} else {
0.0
}
}
pub fn anisotropy(&self) -> f64 {
let (mut lo, mut hi) = (f64::INFINITY, 0.0f64);
let count = 256;
for i in 0..count {
let z = (i as f64 + 0.5) / count as f64;
let r = (1.0 - z * z).max(0.0).sqrt();
let theta = std::f64::consts::PI * (1.0 + 5.0f64.sqrt()) * i as f64;
let e = self.directional_modulus(Vector3::new(
(r * theta.cos()) as f32,
(r * theta.sin()) as f32,
z as f32,
));
lo = lo.min(e);
hi = hi.max(e);
}
if lo > 1e-30 {
hi / lo
} else {
f64::INFINITY
}
}
}
#[derive(Clone, Copy, Debug)]
pub struct Conductivity {
pub k: [[f64; 3]; 3],
pub relative_density: f64,
pub voxels: usize,
pub solver: Solver,
}
impl Conductivity {
pub fn axes(&self) -> [f64; 3] {
[self.k[0][0], self.k[1][1], self.k[2][2]]
}
pub fn directional(&self, direction: Vector3) -> f64 {
let n = direction.normalize();
let n = [n.x as f64, n.y as f64, n.z as f64];
let mut sum = 0.0;
for i in 0..3 {
for j in 0..3 {
sum += n[i] * self.k[i][j] * n[j];
}
}
sum
}
pub fn principal(&self) -> [f64; 3] {
symmetric_eigenvalues(&self.k)
}
pub fn anisotropy(&self) -> f64 {
let p = self.principal();
if p[2].abs() > 1e-30 {
p[0] / p[2]
} else {
f64::INFINITY
}
}
pub fn tortuosity_factor(&self, solid: f64) -> f64 {
let bar = solid * self.relative_density;
if bar.abs() > 1e-30 {
self.principal()[0] / bar
} else {
0.0
}
}
}
pub fn homogenize(
occupancy: impl Fn(Vector3) -> bool + Sync + Send,
origin: Vector3,
cell: Vector3,
resolution: usize,
material: SolidMaterial,
solver: Solver,
) -> Stiffness {
let n = resolution.clamp(2, 48);
let h = spacing(cell, n);
let elements = n * n * n;
let stiff = voxelize(occupancy, origin, h, n);
let relative_density = stiff.iter().sum::<f64>() / elements as f64;
let ke = element_stiffness(h, material.poisson);
let u0 = unit_strain_displacements(h);
let dof_map: Vec<[usize; 24]> = (0..elements).map(|e| element_map(e, n)).collect();
let (c, _, ran) = effective::<24, 6>(
&ke,
&u0,
&stiff,
&dof_map,
elements,
volume(cell),
material.modulus,
solver,
);
Stiffness {
c,
relative_density,
voxels: n,
solver: ran,
}
}
#[derive(Clone, Copy, Debug)]
pub struct Strength {
pub stiffness: Stiffness,
pub concentration: [f64; 6],
pub peak_concentration: [f64; 6],
pub sampled: usize,
pub solid_floor: f64,
pub material: SolidMaterial,
}
impl Strength {
pub fn yield_strength(&self, solid_yield: f64) -> [f64; 6] {
let mut out = [0.0f64; 6];
for (i, v) in out.iter_mut().enumerate() {
*v = if self.concentration[i] > 1e-30 {
solid_yield / self.concentration[i]
} else {
0.0
};
}
out
}
pub fn uniaxial(&self, solid_yield: f64) -> [f64; 3] {
let all = self.yield_strength(solid_yield);
[all[0], all[1], all[2]]
}
pub fn efficiency(&self) -> [f64; 3] {
let mut out = [0.0f64; 3];
for (i, v) in out.iter_mut().enumerate() {
let ideal = self.stiffness.relative_density;
*v = if self.concentration[i] > 1e-30 && ideal > 1e-30 {
1.0 / (self.concentration[i] * ideal)
} else {
0.0
};
}
out
}
pub fn resolved(&self) -> bool {
if self.efficiency().iter().any(|&v| v > 1.01) {
return false;
}
let solid = self.stiffness.relative_density
* (self.stiffness.voxels * self.stiffness.voxels * self.stiffness.voxels) as f64;
self.solid_floor >= 0.9 && self.sampled as f64 >= 0.5 * solid
}
pub fn collapse_strain(&self, solid_yield: f64) -> [f64; 3] {
let e = self.stiffness.youngs_moduli();
let strength = self.uniaxial(solid_yield);
let mut out = [0.0f64; 3];
for (i, v) in out.iter_mut().enumerate() {
*v = if e[i] > 1e-30 { strength[i] / e[i] } else { 0.0 };
}
out
}
}
#[allow(clippy::too_many_arguments)]
pub fn homogenize_strength(
occupancy: impl Fn(Vector3) -> bool + Sync + Send,
origin: Vector3,
cell: Vector3,
resolution: usize,
material: SolidMaterial,
solver: Solver,
) -> Strength {
let n = resolution.clamp(2, 48);
let h = spacing(cell, n);
let elements = n * n * n;
let stiff = voxelize(occupancy, origin, h, n);
let relative_density = stiff.iter().sum::<f64>() / elements as f64;
let ke = element_stiffness(h, material.poisson);
let u0 = unit_strain_displacements(h);
let dof_map: Vec<[usize; 24]> = (0..elements).map(|e| element_map(e, n)).collect();
let (c, chi, ran) = effective::<24, 6>(
&ke,
&u0,
&stiff,
&dof_map,
elements,
volume(cell),
material.modulus,
solver,
);
let stiffness = Stiffness {
c,
relative_density,
voxels: n,
solver: ran,
};
let mut floor = 0.9;
while floor > 0.2 && !stiff.iter().any(|&s| s >= floor) {
floor -= 0.1;
}
let compliance = stiffness.compliance();
let b = strain_matrix(h);
let d = constitutive(material.poisson);
let mut concentration = [0.0f64; 6];
let mut peak_concentration = [0.0f64; 6];
let mut sampled = 0usize;
for case in 0..6 {
let mut macro_strain = [0.0f64; 6];
for (j, v) in macro_strain.iter_mut().enumerate() {
*v = compliance[j][case];
}
let mut mises: Vec<f64> = Vec::new();
let mut worst = 0.0f64;
for e in 0..elements {
if stiff[e] < floor {
continue;
}
let map = &dof_map[e];
let mut local = [0.0f64; 24];
for a in 0..24 {
let mut acc = 0.0;
for (j, &weight) in macro_strain.iter().enumerate() {
if weight != 0.0 {
acc += weight * (u0[j][a] - chi[j][map[a]]);
}
}
local[a] = acc;
}
let mut strain = [0.0f64; 6];
for i in 0..6 {
let mut acc = 0.0;
for a in 0..24 {
acc += b[i][a] * local[a];
}
strain[i] = acc;
}
let mut stress = [0.0f64; 6];
for i in 0..6 {
let mut acc = 0.0;
for j in 0..6 {
acc += d[i][j] * strain[j];
}
stress[i] = acc * material.modulus;
}
let vm = von_mises(&stress);
worst = worst.max(vm);
mises.push(vm);
}
peak_concentration[case] = worst;
sampled = mises.len();
concentration[case] = percentile(&mut mises, 0.99);
}
Strength {
stiffness,
concentration,
peak_concentration,
sampled,
solid_floor: floor,
material,
}
}
fn von_mises(s: &[f64; 6]) -> f64 {
let deviatoric = 0.5
* ((s[0] - s[1]).powi(2) + (s[1] - s[2]).powi(2) + (s[2] - s[0]).powi(2));
let shear = 3.0 * (s[3] * s[3] + s[4] * s[4] + s[5] * s[5]);
(deviatoric + shear).max(0.0).sqrt()
}
fn percentile(values: &mut [f64], fraction: f64) -> f64 {
if values.is_empty() {
return f64::INFINITY;
}
values.sort_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal));
let at = ((values.len() - 1) as f64 * fraction.clamp(0.0, 1.0)).round() as usize;
values[at]
}
pub fn homogenize_conduction(
occupancy: impl Fn(Vector3) -> bool + Sync + Send,
origin: Vector3,
cell: Vector3,
resolution: usize,
solid: f64,
solver: Solver,
) -> Conductivity {
let n = resolution.clamp(2, 48);
let h = spacing(cell, n);
let elements = n * n * n;
let stiff = voxelize(occupancy, origin, h, n);
let relative_density = stiff.iter().sum::<f64>() / elements as f64;
let ke = conduction_element(h);
let u0 = unit_gradient_potentials(h);
let dof_map: Vec<[usize; 8]> = (0..elements).map(|e| element_map(e, n)).collect();
let (k, _, ran) = effective::<8, 3>(
&ke,
&u0,
&stiff,
&dof_map,
elements,
volume(cell),
solid,
solver,
);
Conductivity {
k,
relative_density,
voxels: n,
solver: ran,
}
}
fn spacing(cell: Vector3, n: usize) -> [f64; 3] {
[
(cell.x as f64 / n as f64).abs().max(1e-12),
(cell.y as f64 / n as f64).abs().max(1e-12),
(cell.z as f64 / n as f64).abs().max(1e-12),
]
}
fn volume(cell: Vector3) -> f64 {
(cell.x as f64 * cell.y as f64 * cell.z as f64)
.abs()
.max(1e-30)
}
fn voxelize(
occupancy: impl Fn(Vector3) -> bool + Sync + Send,
origin: Vector3,
h: [f64; 3],
n: usize,
) -> Vec<f64> {
const VOID: f64 = 1e-5;
const SUB: usize = 3;
crate::utils::parallel::par_map_range(n * n * n, |e| {
let i = e % n;
let j = (e / n) % n;
let k = e / (n * n);
let mut filled = 0usize;
for c in 0..SUB * SUB * SUB {
let at = |index: usize| (index as f64 + 0.5) / SUB as f64;
let p = Vector3::new(
origin.x + ((i as f64 + at(c % SUB)) * h[0]) as f32,
origin.y + ((j as f64 + at((c / SUB) % SUB)) * h[1]) as f32,
origin.z + ((k as f64 + at(c / (SUB * SUB))) * h[2]) as f32,
);
if occupancy(p) {
filled += 1;
}
}
(filled as f64 / (SUB * SUB * SUB) as f64).max(VOID)
})
}
#[allow(clippy::too_many_arguments)]
fn effective<const N: usize, const CASES: usize>(
ke: &[[f64; N]; N],
u0: &[[f64; N]; CASES],
stiff: &[f64],
dof_map: &[[usize; N]],
elements: usize,
volume: f64,
scale: f64,
solver: Solver,
) -> ([[f64; CASES]; CASES], Vec<Vec<f64>>, Solver) {
let per_node = (N / 8).max(1);
let dofs = elements * per_node;
let loads: Vec<Vec<f64>> = (0..CASES)
.map(|case| {
let mut f = vec![0.0f64; dofs];
for e in 0..elements {
let map = &dof_map[e];
let s = stiff[e];
for a in 0..N {
let mut acc = 0.0;
for b in 0..N {
acc += ke[a][b] * u0[case][b];
}
f[map[a]] += s * acc;
}
}
for (d, v) in f.iter_mut().enumerate() {
if d < per_node {
*v = 0.0;
}
}
f
})
.collect();
let diag = diagonal(ke, stiff, dof_map, elements, per_node, dofs);
let (chi, ran) = match solver {
Solver::Gpu => gpu_solve(&loads, ke, stiff, &diag, elements, per_node, scale)
.map(|chi| (chi, Solver::Gpu))
.unwrap_or_else(|| (cpu_solve(&loads, ke, stiff, dof_map, &diag, elements, per_node, scale), Solver::Cpu)),
Solver::Cpu => (
cpu_solve(&loads, ke, stiff, dof_map, &diag, elements, per_node, scale),
Solver::Cpu,
),
};
let mut out = [[0.0f64; CASES]; CASES];
let mut diff = [[0.0f64; N]; CASES];
let mut k_diff = [[0.0f64; N]; CASES];
for e in 0..elements {
let map = &dof_map[e];
for case in 0..CASES {
for a in 0..N {
diff[case][a] = u0[case][a] - chi[case][map[a]];
}
}
for case in 0..CASES {
for a in 0..N {
let mut acc = 0.0;
for b in 0..N {
acc += ke[a][b] * diff[case][b];
}
k_diff[case][a] = acc;
}
}
for i in 0..CASES {
for j in i..CASES {
let mut acc = 0.0;
for a in 0..N {
acc += diff[i][a] * k_diff[j][a];
}
out[i][j] += stiff[e] * acc;
}
}
}
for i in 0..CASES {
for j in i..CASES {
let v = out[i][j] / volume * scale;
out[i][j] = v;
out[j][i] = v;
}
}
(out, chi, ran)
}
#[allow(clippy::too_many_arguments)]
fn cpu_solve<const N: usize>(
loads: &[Vec<f64>],
ke: &[[f64; N]; N],
stiff: &[f64],
dof_map: &[[usize; N]],
diag: &[f64],
elements: usize,
per_node: usize,
scale: f64,
) -> Vec<Vec<f64>> {
loads
.iter()
.map(|f| solve(f, ke, stiff, dof_map, diag, elements, per_node, scale))
.collect()
}
#[cfg(not(target_arch = "wasm32"))]
fn gpu_solve<const N: usize>(
loads: &[Vec<f64>],
ke: &[[f64; N]; N],
stiff: &[f64],
diag: &[f64],
elements: usize,
per_node: usize,
scale: f64,
) -> Option<Vec<Vec<f64>>> {
let device = shared_gpu()?;
let dofs = 8 * per_node;
let mut flat = Vec::with_capacity(dofs * dofs);
for row in ke.iter().take(dofs) {
flat.extend_from_slice(&row[..dofs]);
}
let problem = device.problem(cbrt(elements), per_node, &flat, stiff, diag);
let mut out = Vec::with_capacity(loads.len());
for f in loads {
let norm: f64 = f.iter().map(|v| v * v).sum::<f64>().sqrt();
let target = (norm * 1e-4).max(1e-9 * scale.abs().max(1.0));
out.push(problem.solve(f, target, 4000)?);
}
Some(out)
}
#[cfg(target_arch = "wasm32")]
fn gpu_solve<const N: usize>(
_loads: &[Vec<f64>],
_ke: &[[f64; N]; N],
_stiff: &[f64],
_diag: &[f64],
_elements: usize,
_per_node: usize,
_scale: f64,
) -> Option<Vec<Vec<f64>>> {
None
}
#[cfg(not(target_arch = "wasm32"))]
fn cbrt(elements: usize) -> usize {
let mut n = (elements as f64).cbrt().round() as usize;
while n * n * n > elements {
n -= 1;
}
while (n + 1) * (n + 1) * (n + 1) <= elements {
n += 1;
}
n
}
fn diagonal<const N: usize>(
ke: &[[f64; N]; N],
stiff: &[f64],
dof_map: &[[usize; N]],
elements: usize,
per_node: usize,
dofs: usize,
) -> Vec<f64> {
let mut diag = vec![0.0f64; dofs];
for e in 0..elements {
let map = &dof_map[e];
for a in 0..N {
diag[map[a]] += stiff[e] * ke[a][a];
}
}
for (d, v) in diag.iter_mut().enumerate() {
if d < per_node || *v <= 0.0 {
*v = 1.0;
}
}
diag
}
#[allow(clippy::too_many_arguments)]
fn solve<const N: usize>(
f: &[f64],
ke: &[[f64; N]; N],
stiff: &[f64],
dof_map: &[[usize; N]],
diag: &[f64],
elements: usize,
per_node: usize,
scale: f64,
) -> Vec<f64> {
let dofs = f.len();
let fixed = |d: usize| d < per_node;
let apply = |x: &[f64], out: &mut [f64]| {
out.iter_mut().for_each(|v| *v = 0.0);
let mut local = [0.0f64; N];
for e in 0..elements {
let map = &dof_map[e];
for a in 0..N {
local[a] = x[map[a]];
}
let s = stiff[e];
for a in 0..N {
let mut acc = 0.0;
let row = &ke[a];
for b in 0..N {
acc += row[b] * local[b];
}
out[map[a]] += s * acc;
}
}
for d in 0..dofs {
if fixed(d) {
out[d] = 0.0;
}
}
};
let mut x = vec![0.0f64; dofs];
let mut r: Vec<f64> = f.to_vec();
for d in 0..dofs {
if fixed(d) {
r[d] = 0.0;
}
}
let mut z: Vec<f64> = r.iter().zip(diag.iter()).map(|(r, d)| r / d).collect();
let mut p = z.clone();
let mut rz: f64 = r.iter().zip(&z).map(|(a, b)| a * b).sum();
let target = {
let norm: f64 = f.iter().map(|v| v * v).sum::<f64>().sqrt();
(norm * 1e-6).max(1e-12 * scale.abs().max(1.0))
};
let mut q = vec![0.0f64; dofs];
for _ in 0..4000 {
let residual: f64 = r.iter().map(|v| v * v).sum::<f64>().sqrt();
if residual <= target || rz.abs() < 1e-300 {
break;
}
apply(&p, &mut q);
let pq: f64 = p.iter().zip(&q).map(|(a, b)| a * b).sum();
if pq.abs() < 1e-300 {
break;
}
let alpha = rz / pq;
for d in 0..dofs {
x[d] += alpha * p[d];
r[d] -= alpha * q[d];
}
for d in 0..dofs {
z[d] = r[d] / diag[d];
}
let rz_next: f64 = r.iter().zip(&z).map(|(a, b)| a * b).sum();
let beta = rz_next / rz;
for d in 0..dofs {
p[d] = z[d] + beta * p[d];
}
rz = rz_next;
}
x
}
fn element_map<const N: usize>(e: usize, n: usize) -> [usize; N] {
let per_node = (N / 8).max(1);
let i = e % n;
let j = (e / n) % n;
let k = e / (n * n);
let mut out = [0usize; N];
for c in 0..8 {
let ni = (i + (c & 1)) % n;
let nj = (j + ((c >> 1) & 1)) % n;
let nk = (k + ((c >> 2) & 1)) % n;
let node = (nk * n + nj) * n + ni;
for d in 0..per_node {
out[c * per_node + d] = node * per_node + d;
}
}
out
}
fn unit_gradient_potentials(h: [f64; 3]) -> [[f64; 8]; 3] {
let mut out = [[0.0f64; 8]; 3];
for (axis, row) in out.iter_mut().enumerate() {
for c in 0..8 {
row[c] = ((c >> axis) & 1) as f64 * h[axis];
}
}
out
}
fn conduction_element(h: [f64; 3]) -> [[f64; 8]; 8] {
let g = 1.0 / 3.0f64.sqrt();
let det = h[0] * h[1] * h[2] / 8.0;
let mut ke = [[0.0f64; 8]; 8];
for gz in [-g, g] {
for gy in [-g, g] {
for gx in [-g, g] {
let grad = shape_gradients([gx, gy, gz], h);
for a in 0..8 {
for b in a..8 {
let mut acc = 0.0;
for axis in 0..3 {
acc += grad[a][axis] * grad[b][axis];
}
ke[a][b] += acc * det;
}
}
}
}
}
for a in 0..8 {
for b in 0..a {
ke[a][b] = ke[b][a];
}
}
ke
}
fn shape_gradients(xi: [f64; 3], h: [f64; 3]) -> [[f64; 3]; 8] {
let mut out = [[0.0f64; 3]; 8];
for c in 0..8 {
let sign = [
if c & 1 == 0 { -1.0 } else { 1.0 },
if (c >> 1) & 1 == 0 { -1.0 } else { 1.0 },
if (c >> 2) & 1 == 0 { -1.0 } else { 1.0 },
];
for axis in 0..3 {
let other = [(axis + 1) % 3, (axis + 2) % 3];
out[c][axis] = 0.125
* sign[axis]
* (1.0 + sign[other[0]] * xi[other[0]])
* (1.0 + sign[other[1]] * xi[other[1]])
* (2.0 / h[axis]);
}
}
out
}
fn symmetric_eigenvalues(a: &[[f64; 3]; 3]) -> [f64; 3] {
let off = a[0][1] * a[0][1] + a[0][2] * a[0][2] + a[1][2] * a[1][2];
if off < 1e-30 {
let mut d = [a[0][0], a[1][1], a[2][2]];
d.sort_by(|x, y| y.partial_cmp(x).unwrap_or(std::cmp::Ordering::Equal));
return d;
}
let q = (a[0][0] + a[1][1] + a[2][2]) / 3.0;
let p2 = (a[0][0] - q).powi(2) + (a[1][1] - q).powi(2) + (a[2][2] - q).powi(2) + 2.0 * off;
let p = (p2 / 6.0).max(1e-300).sqrt();
let mut b = *a;
for i in 0..3 {
b[i][i] -= q;
}
for row in &mut b {
for v in row.iter_mut() {
*v /= p;
}
}
let det = b[0][0] * (b[1][1] * b[2][2] - b[1][2] * b[2][1])
- b[0][1] * (b[1][0] * b[2][2] - b[1][2] * b[2][0])
+ b[0][2] * (b[1][0] * b[2][1] - b[1][1] * b[2][0]);
let phi = (det / 2.0).clamp(-1.0, 1.0).acos() / 3.0;
let hi = q + 2.0 * p * phi.cos();
let lo = q + 2.0 * p * (phi + 2.0 * std::f64::consts::PI / 3.0).cos();
[hi, 3.0 * q - hi - lo, lo]
}
fn unit_strain_displacements(h: [f64; 3]) -> [[f64; 24]; 6] {
let mut out = [[0.0f64; 24]; 6];
for (case, row) in out.iter_mut().enumerate() {
let mut eps = [[0.0f64; 3]; 3];
match case {
0..=2 => eps[case][case] = 1.0,
3 => {
eps[1][2] = 0.5;
eps[2][1] = 0.5;
}
4 => {
eps[0][2] = 0.5;
eps[2][0] = 0.5;
}
_ => {
eps[0][1] = 0.5;
eps[1][0] = 0.5;
}
}
for c in 0..8 {
let x = [
(c & 1) as f64 * h[0],
((c >> 1) & 1) as f64 * h[1],
((c >> 2) & 1) as f64 * h[2],
];
for axis in 0..3 {
row[c * 3 + axis] = eps[axis][0] * x[0] + eps[axis][1] * x[1] + eps[axis][2] * x[2];
}
}
}
out
}
fn element_stiffness(h: [f64; 3], poisson: f64) -> [[f64; 24]; 24] {
let d = constitutive(poisson);
let g = 1.0 / 3.0f64.sqrt();
let det = h[0] * h[1] * h[2] / 8.0;
let mut ke = [[0.0f64; 24]; 24];
for gz in [-g, g] {
for gy in [-g, g] {
for gx in [-g, g] {
let gradients = shape_gradients([gx, gy, gz], h);
let mut b = [[0.0f64; 24]; 6];
for c in 0..8 {
let (bx, by, bz) = (gradients[c][0], gradients[c][1], gradients[c][2]);
b[0][c * 3] = bx;
b[1][c * 3 + 1] = by;
b[2][c * 3 + 2] = bz;
b[3][c * 3 + 1] = bz;
b[3][c * 3 + 2] = by;
b[4][c * 3] = bz;
b[4][c * 3 + 2] = bx;
b[5][c * 3] = by;
b[5][c * 3 + 1] = bx;
}
let mut db = [[0.0f64; 24]; 6];
for i in 0..6 {
for col in 0..24 {
let mut acc = 0.0;
for k in 0..6 {
acc += d[i][k] * b[k][col];
}
db[i][col] = acc;
}
}
for a in 0..24 {
for bcol in a..24 {
let mut acc = 0.0;
for i in 0..6 {
acc += b[i][a] * db[i][bcol];
}
ke[a][bcol] += acc * det;
}
}
}
}
}
for a in 0..24 {
for b in 0..a {
ke[a][b] = ke[b][a];
}
}
ke
}
fn constitutive(poisson: f64) -> [[f64; 6]; 6] {
let nu = poisson.clamp(-0.99, 0.49);
let lambda = nu / ((1.0 + nu) * (1.0 - 2.0 * nu));
let mu = 0.5 / (1.0 + nu);
let mut d = [[0.0f64; 6]; 6];
for i in 0..3 {
for j in 0..3 {
d[i][j] = lambda;
}
d[i][i] += 2.0 * mu;
d[i + 3][i + 3] = mu;
}
d
}
fn strain_matrix(h: [f64; 3]) -> [[f64; 24]; 6] {
let gradients = shape_gradients([0.0, 0.0, 0.0], h);
let mut b = [[0.0f64; 24]; 6];
for c in 0..8 {
let (bx, by, bz) = (gradients[c][0], gradients[c][1], gradients[c][2]);
b[0][c * 3] = bx;
b[1][c * 3 + 1] = by;
b[2][c * 3 + 2] = bz;
b[3][c * 3 + 1] = bz;
b[3][c * 3 + 2] = by;
b[4][c * 3] = bz;
b[4][c * 3 + 2] = bx;
b[5][c * 3] = by;
b[5][c * 3 + 1] = bx;
}
b
}
fn tensor(s: &[[f64; 6]; 6], i: usize, j: usize, k: usize, l: usize) -> f64 {
const VOIGT: [[usize; 3]; 3] = [[0, 5, 4], [5, 1, 3], [4, 3, 2]];
let v = VOIGT[i][j];
let w = VOIGT[k][l];
let factor = match (v >= 3, w >= 3) {
(false, false) => 1.0,
(true, true) => 4.0,
_ => 2.0,
};
s[v][w] / factor
}
fn invert6(m: &[[f64; 6]; 6]) -> Option<[[f64; 6]; 6]> {
let mut a = *m;
let mut inv = [[0.0f64; 6]; 6];
for (i, row) in inv.iter_mut().enumerate() {
row[i] = 1.0;
}
for col in 0..6 {
let mut pivot = col;
for r in col + 1..6 {
if a[r][col].abs() > a[pivot][col].abs() {
pivot = r;
}
}
if a[pivot][col].abs() < 1e-300 {
return None;
}
a.swap(col, pivot);
inv.swap(col, pivot);
let scale = 1.0 / a[col][col];
for c in 0..6 {
a[col][c] *= scale;
inv[col][c] *= scale;
}
for r in 0..6 {
if r == col {
continue;
}
let factor = a[r][col];
if factor == 0.0 {
continue;
}
for c in 0..6 {
a[r][c] -= factor * a[col][c];
inv[r][c] -= factor * inv[col][c];
}
}
}
Some(inv)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn solid_recovers_the_base_material() {
let mat = SolidMaterial {
modulus: 210.0,
poisson: 0.3,
};
let c = homogenize(
|_| true,
Vector3::ZERO,
Vector3::new(1.0, 1.0, 1.0),
6,
mat,
Solver::Cpu,
);
let nu = mat.poisson;
let factor = mat.modulus / ((1.0 + nu) * (1.0 - 2.0 * nu));
let c11 = factor * (1.0 - nu);
let c12 = factor * nu;
let c44 = mat.modulus / (2.0 * (1.0 + nu));
assert!((c.c[0][0] - c11).abs() < 1e-6 * c11, "{} vs {c11}", c.c[0][0]);
assert!((c.c[0][1] - c12).abs() < 1e-6 * c12, "{} vs {c12}", c.c[0][1]);
assert!((c.c[3][3] - c44).abs() < 1e-6 * c44, "{} vs {c44}", c.c[3][3]);
assert!((c.relative_density - 1.0).abs() < 1e-12);
let e = c.youngs_moduli();
assert!((e[0] - mat.modulus).abs() < 1e-4 * mat.modulus, "{}", e[0]);
let nus = c.poisson_ratios();
assert!((nus[2] - nu).abs() < 1e-6, "{}", nus[2]);
let g = c.shear_moduli();
assert!((g[0] - c44).abs() < 1e-4 * c44, "{}", g[0]);
assert!((c.anisotropy() - 1.0).abs() < 1e-4, "{}", c.anisotropy());
}
#[test]
fn layers_are_stiff_in_plane_and_soft_across_it() {
let c = homogenize(
|p| p.z.rem_euclid(1.0) < 0.5,
Vector3::ZERO,
Vector3::new(1.0, 1.0, 1.0),
8,
SolidMaterial::default(),
Solver::Cpu,
);
let e = c.youngs_moduli();
assert!((c.relative_density - 0.5).abs() < 1e-4, "{}", c.relative_density);
assert!((e[0] - 0.5).abs() < 0.05, "in plane {}", e[0]);
assert!(e[2] < 0.01, "across {}", e[2]);
assert!(c.anisotropy() > 10.0, "{}", c.anisotropy());
}
#[test]
fn an_empty_cell_is_not_a_division_by_zero() {
let c = homogenize(
|_| false,
Vector3::ZERO,
Vector3::new(1.0, 1.0, 1.0),
4,
SolidMaterial::default(),
Solver::Cpu,
);
assert!(c.relative_density < 1e-4, "{}", c.relative_density);
for e in c.youngs_moduli() {
assert!(e.is_finite() && e < 1e-4, "{e}");
}
for nu in c.poisson_ratios() {
assert!(nu.is_finite(), "{nu}");
}
}
#[test]
fn the_stiffness_is_symmetric() {
let c = homogenize(
|p| (p.x + p.y + p.z).rem_euclid(1.0) < 0.6,
Vector3::ZERO,
Vector3::new(1.0, 1.0, 1.0),
6,
SolidMaterial::default(),
Solver::Cpu,
);
for i in 0..6 {
for j in 0..6 {
let scale = c.c[i][i].abs().max(c.c[j][j].abs()).max(1e-12);
assert!(
(c.c[i][j] - c.c[j][i]).abs() < 1e-9 * scale,
"{i},{j}: {} vs {}",
c.c[i][j],
c.c[j][i]
);
}
}
}
#[test]
fn solid_concentrates_nothing() {
let mat = SolidMaterial {
modulus: 200.0,
poisson: 0.3,
};
let s = homogenize_strength(
|_| true,
Vector3::ZERO,
Vector3::new(1.0, 1.0, 1.0),
6,
mat,
Solver::Cpu,
);
for axis in 0..3 {
assert!(
(s.concentration[axis] - 1.0).abs() < 1e-6,
"axis {axis}: {}",
s.concentration[axis]
);
assert!(
(s.concentration[axis + 3] - 3.0f64.sqrt()).abs() < 1e-6,
"shear {axis}: {}",
s.concentration[axis + 3]
);
}
let yielded = s.yield_strength(500.0);
assert!((yielded[0] - 500.0).abs() < 1e-3, "{}", yielded[0]);
assert!((yielded[3] - 500.0 / 3.0f64.sqrt()).abs() < 1e-3, "{}", yielded[3]);
assert!((s.efficiency()[0] - 1.0).abs() < 1e-3, "{:?}", s.efficiency());
assert!((s.peak_concentration[0] - 1.0).abs() < 1e-6);
}
#[test]
fn half_the_area_is_twice_the_stress() {
let s = homogenize_strength(
|p| p.z.rem_euclid(1.0) < 0.5,
Vector3::ZERO,
Vector3::new(1.0, 1.0, 1.0),
8,
SolidMaterial::default(),
Solver::Cpu,
);
assert!(
(s.concentration[0] - 2.0).abs() < 0.02,
"in plane {}",
s.concentration[0]
);
assert!((s.yield_strength(400.0)[0] - 200.0).abs() < 5.0);
assert!((s.efficiency()[0] - 1.0).abs() < 0.05, "{:?}", s.efficiency());
}
#[test]
fn stretching_is_more_efficient_than_bending() {
let measure = |seam: f32| {
homogenize_strength(
move |p| p.z.rem_euclid(1.0) < seam,
Vector3::ZERO,
Vector3::new(1.0, 1.0, 1.0),
8,
SolidMaterial::default(),
Solver::Cpu,
)
};
let thin = measure(0.25);
let thick = measure(0.5);
assert!(
thin.concentration[0] > thick.concentration[0],
"thin {} thick {}",
thin.concentration[0],
thick.concentration[0]
);
let ratio = thick.yield_strength(100.0)[0] / thin.yield_strength(100.0)[0];
assert!((ratio - 2.0).abs() < 0.1, "{ratio}");
}
#[test]
fn an_unresolved_grid_says_so() {
let build = |resolution| {
homogenize_strength(
|p| p.z.rem_euclid(1.0) < 0.1,
Vector3::ZERO,
Vector3::new(1.0, 1.0, 1.0),
resolution,
SolidMaterial::default(),
Solver::Cpu,
)
};
let coarse = build(8);
assert!(!coarse.resolved(), "sampled {} of the solid", coarse.sampled);
let fine = homogenize_strength(
|p| p.z.rem_euclid(1.0) < 0.125,
Vector3::ZERO,
Vector3::new(1.0, 1.0, 1.0),
24,
SolidMaterial::default(),
Solver::Cpu,
);
assert!(
(fine.concentration[0] - 8.0).abs() < 0.15,
"{}",
fine.concentration[0]
);
let crossed = homogenize_strength(
|p| p.z.rem_euclid(1.0) < 0.15 || p.x.rem_euclid(1.0) < 0.15,
Vector3::ZERO,
Vector3::new(1.0, 1.0, 1.0),
24,
SolidMaterial::default(),
Solver::Cpu,
);
assert!(
crossed.resolved(),
"floor {} sampled {} efficiency {:?}",
crossed.solid_floor,
crossed.sampled,
crossed.efficiency()
);
let efficiency = crossed.efficiency()[0];
assert!(
(0.5..0.95).contains(&efficiency),
"some of it should be idle, not all or none: {efficiency}"
);
}
#[test]
fn an_empty_cell_has_no_strength_and_no_panic() {
let s = homogenize_strength(
|_| false,
Vector3::ZERO,
Vector3::new(1.0, 1.0, 1.0),
4,
SolidMaterial::default(),
Solver::Cpu,
);
for v in s.yield_strength(500.0) {
assert!(v.is_finite() || v == 0.0, "{v}");
}
for v in s.collapse_strain(500.0) {
assert!(v.is_finite(), "{v}");
}
}
#[test]
fn the_voxel_grid_is_reported() {
let c = homogenize(
|_| true,
Vector3::ZERO,
Vector3::new(1.0, 1.0, 1.0),
4,
SolidMaterial::default(),
Solver::Cpu,
);
assert_eq!(c.voxels, 4);
let clamped = homogenize(
|_| true,
Vector3::ZERO,
Vector3::new(1.0, 1.0, 1.0),
999,
SolidMaterial::default(),
Solver::Cpu,
);
assert_eq!(clamped.voxels, 48);
}
#[test]
fn solid_conducts_like_the_base_material() {
let k = homogenize_conduction(
|_| true,
Vector3::ZERO,
Vector3::new(1.0, 1.0, 1.0),
6,
237.0,
Solver::Cpu,
);
for along in k.axes() {
assert!((along - 237.0).abs() < 1e-4, "{along}");
}
assert!(k.k[0][1].abs() < 1e-6 && k.k[0][2].abs() < 1e-6);
assert!((k.anisotropy() - 1.0).abs() < 1e-6, "{}", k.anisotropy());
assert!(
(k.directional(Vector3::new(1.0, 1.0, 1.0)) - 237.0).abs() < 1e-3,
"{}",
k.directional(Vector3::new(1.0, 1.0, 1.0))
);
assert!((k.tortuosity_factor(237.0) - 1.0).abs() < 1e-4);
}
#[test]
fn layers_conduct_in_plane_and_not_across() {
let k = homogenize_conduction(
|p| p.z.rem_euclid(1.0) < 0.5,
Vector3::ZERO,
Vector3::new(1.0, 1.0, 1.0),
8,
1.0,
Solver::Cpu,
);
let along = k.axes();
assert!((along[0] - 0.5).abs() < 0.01, "in plane {}", along[0]);
assert!(along[2] < 0.001, "across {}", along[2]);
assert!(k.anisotropy() > 100.0, "{}", k.anisotropy());
}
#[test]
fn an_empty_cell_conducts_nothing_without_dividing_by_zero() {
let k = homogenize_conduction(
|_| false,
Vector3::ZERO,
Vector3::new(1.0, 1.0, 1.0),
4,
1.0,
Solver::Cpu,
);
for along in k.axes() {
assert!(along.is_finite() && along < 1e-4, "{along}");
}
assert!(k.tortuosity_factor(1.0).is_finite());
}
#[test]
fn eigenvalues_of_a_known_matrix() {
let a = [[2.0, 1.0, 0.0], [1.0, 2.0, 0.0], [0.0, 0.0, 5.0]];
let e = symmetric_eigenvalues(&a);
assert!((e[0] - 5.0).abs() < 1e-9, "{e:?}");
assert!((e[1] - 3.0).abs() < 1e-9, "{e:?}");
assert!((e[2] - 1.0).abs() < 1e-9, "{e:?}");
let d = symmetric_eigenvalues(&[[1.0, 0.0, 0.0], [0.0, 7.0, 0.0], [0.0, 0.0, 4.0]]);
assert_eq!(d, [7.0, 4.0, 1.0]);
}
#[test]
fn the_gpu_agrees_with_the_cpu() {
let cell = |solver| {
homogenize(
|p| {
(p.x.rem_euclid(1.0) - 0.5).abs() < 0.2
|| (p.z.rem_euclid(1.0) - 0.5).abs() < 0.2
},
Vector3::ZERO,
Vector3::new(1.0, 1.0, 1.0),
16,
SolidMaterial {
modulus: 200.0,
poisson: 0.3,
},
solver,
)
};
let gpu = cell(Solver::Gpu);
if gpu.solver != Solver::Gpu {
eprintln!("no wgpu adapter — skipping the device comparison");
return;
}
let cpu = cell(Solver::Cpu);
assert_eq!(cpu.solver, Solver::Cpu);
assert!((gpu.relative_density - cpu.relative_density).abs() < 1e-12);
for i in 0..6 {
for j in 0..6 {
let scale = cpu.c[i][i].abs().max(cpu.c[j][j].abs()).max(1e-9);
assert!(
(gpu.c[i][j] - cpu.c[i][j]).abs() < 2e-3 * scale,
"{i},{j}: gpu {} cpu {}",
gpu.c[i][j],
cpu.c[i][j]
);
}
}
}
#[test]
fn the_gpu_conducts_the_same_as_the_cpu() {
let cell = |solver| {
homogenize_conduction(
|p| p.z.rem_euclid(1.0) < 0.4 || p.x.rem_euclid(1.0) < 0.3,
Vector3::ZERO,
Vector3::new(1.0, 1.0, 1.0),
16,
12.0,
solver,
)
};
let gpu = cell(Solver::Gpu);
if gpu.solver != Solver::Gpu {
eprintln!("no wgpu adapter — skipping the device comparison");
return;
}
let cpu = cell(Solver::Cpu);
for axis in 0..3 {
let (a, b) = (gpu.axes()[axis], cpu.axes()[axis]);
assert!(
(a - b).abs() < 2e-3 * b.abs().max(1e-9),
"axis {axis}: gpu {a} cpu {b}"
);
}
}
#[test]
fn the_gpu_finds_the_same_concentration() {
let cell = |solver| {
homogenize_strength(
|p| p.z.rem_euclid(1.0) < 0.125,
Vector3::ZERO,
Vector3::new(1.0, 1.0, 1.0),
24,
SolidMaterial::default(),
solver,
)
};
let gpu = cell(Solver::Gpu);
if gpu.stiffness.solver != Solver::Gpu {
eprintln!("no wgpu adapter — skipping the device comparison");
return;
}
assert!(
(gpu.concentration[0] - 8.0).abs() < 0.15,
"{}",
gpu.concentration[0]
);
let cpu = cell(Solver::Cpu);
assert!(
(gpu.concentration[0] - cpu.concentration[0]).abs() < 5e-3 * cpu.concentration[0],
"gpu {} cpu {}",
gpu.concentration[0],
cpu.concentration[0]
);
}
#[test]
fn inverting_a_singular_matrix_says_so() {
assert!(invert6(&[[0.0; 6]; 6]).is_none());
let mut identity = [[0.0f64; 6]; 6];
for i in 0..6 {
identity[i][i] = 2.0;
}
let inv = invert6(&identity).unwrap();
assert!((inv[3][3] - 0.5).abs() < 1e-12);
}
#[test]
fn a_stretched_cell_is_the_same_material() {
let cubic = homogenize(
|p| p.z.rem_euclid(1.0) < 0.5,
Vector3::ZERO,
Vector3::new(1.0, 1.0, 1.0),
8,
SolidMaterial::default(),
Solver::Cpu,
);
let stretched = homogenize(
|p| (p.z / 3.0).rem_euclid(1.0) < 0.5,
Vector3::ZERO,
Vector3::new(2.0, 2.0, 3.0),
8,
SolidMaterial::default(),
Solver::Cpu,
);
for i in 0..6 {
for j in 0..6 {
let scale = cubic.c[i][i].abs().max(1e-6);
assert!(
(cubic.c[i][j] - stretched.c[i][j]).abs() < 1e-3 * scale,
"{i},{j}: {} vs {}",
cubic.c[i][j],
stretched.c[i][j]
);
}
}
}
}