#![forbid(unsafe_code)]
mod error;
pub mod komega_sst;
pub mod scalar;
pub mod simple;
pub mod turbulence;
pub mod unstructured;
pub use error::CfdError;
pub use komega_sst::KOmegaSst;
pub use scalar::ScalarTransport;
pub use simple::SimpleSolver;
pub use unstructured::{Face, UnstructuredMesh};
#[derive(Debug, Clone)]
pub struct CollocatedGrid {
pub nx: usize,
pub ny: usize,
pub lx: f64,
pub ly: f64,
pub dx: f64,
pub dy: f64,
}
impl CollocatedGrid {
pub fn new(nx: usize, ny: usize, lx: f64, ly: f64) -> Result<Self, CfdError> {
if nx == 0 || ny == 0 {
return Err(CfdError::InvalidGrid("cell counts must be > 0".into()));
}
if lx <= 0.0 || ly <= 0.0 {
return Err(CfdError::InvalidGrid("domain lengths must be > 0".into()));
}
Ok(Self {
nx,
ny,
lx,
ly,
dx: lx / nx as f64,
dy: ly / ny as f64,
})
}
#[must_use]
pub fn len(&self) -> usize {
self.nx * self.ny
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.nx == 0 || self.ny == 0
}
#[must_use]
pub fn idx(&self, i: usize, j: usize) -> usize {
j * self.nx + i
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Boundary {
Top,
Bottom,
Right,
Left,
}
#[derive(Debug, Clone)]
pub struct Step {
grid: CollocatedGrid,
pub u: Vec<f64>,
pub v: Vec<f64>,
pub p: Vec<f64>,
nu: f64,
dt: f64,
walls: [f64; 4],
}
impl Step {
pub fn new(grid: CollocatedGrid, nu: f64, dt: f64, _rho: f64) -> Self {
let n = grid.len();
Self {
u: vec![0.0; n],
v: vec![0.0; n],
p: vec![0.0; n],
grid,
nu,
dt,
walls: [0.0; 4],
}
}
pub fn set_boundary(&mut self, b: Boundary, value: f64) {
self.walls[b as usize] = value;
}
pub fn momentum(&mut self) {
let g = &self.grid;
let (dx, dy, dt, nu) = (g.dx, g.dy, self.dt, self.nu);
let u0 = self.u.clone();
let v0 = self.v.clone();
let idx = |i: usize, j: usize| g.idx(i, j);
let clamp = |i: isize, n: usize| -> usize { i.clamp(0, n as isize - 1) as usize };
for j in 0..g.ny {
for i in 0..g.nx {
let c = idx(i, j);
let im = idx(clamp(i as isize - 1, g.nx), j);
let ip = idx(clamp(i as isize + 1, g.nx), j);
let jm = idx(i, clamp(j as isize - 1, g.ny));
let jp = idx(i, clamp(j as isize + 1, g.ny));
let dudx = (u0[ip] - u0[im]) / (2.0 * dx);
let dudy = (u0[jp] - u0[jm]) / (2.0 * dy);
let dvdx = (v0[ip] - v0[im]) / (2.0 * dx);
let dvdy = (v0[jp] - v0[jm]) / (2.0 * dy);
let lap_u = (u0[ip] - 2.0 * u0[c] + u0[im]) / (dx * dx)
+ (u0[jp] - 2.0 * u0[c] + u0[jm]) / (dy * dy);
let lap_v = (v0[ip] - 2.0 * v0[c] + v0[im]) / (dx * dx)
+ (v0[jp] - 2.0 * v0[c] + v0[jm]) / (dy * dy);
self.u[c] = u0[c] + dt * (-(u0[c] * dudx + v0[c] * dudy) + nu * lap_u);
self.v[c] = v0[c] + dt * (-(u0[c] * dvdx + v0[c] * dvdy) + nu * lap_v);
}
}
self.apply_walls();
}
pub fn project(&mut self) {
let g = &self.grid;
let (dx, dy, dt) = (g.dx, g.dy, self.dt);
let idx = |i: usize, j: usize| g.idx(i, j);
let clamp = |i: isize, n: usize| -> usize { i.clamp(0, n as isize - 1) as usize };
let mut div = vec![0.0; g.len()];
for j in 0..g.ny {
for i in 0..g.nx {
let c = idx(i, j);
let im = idx(clamp(i as isize - 1, g.nx), j);
let ip = idx(clamp(i as isize + 1, g.nx), j);
let jm = idx(i, clamp(j as isize - 1, g.ny));
let jp = idx(i, clamp(j as isize + 1, g.ny));
div[c] =
(self.u[ip] - self.u[im]) / (2.0 * dx) + (self.v[jp] - self.v[jm]) / (2.0 * dy);
}
}
let iters = 1000;
for _ in 0..iters {
let p0 = self.p.clone();
for j in 0..g.ny {
for i in 0..g.nx {
let c = idx(i, j);
let im = idx(clamp(i as isize - 1, g.nx), j);
let ip = idx(clamp(i as isize + 1, g.nx), j);
let jm = idx(i, clamp(j as isize - 1, g.ny));
let jp = idx(i, clamp(j as isize + 1, g.ny));
let rhs = div[c] / dt;
let denom = 2.0 / (dx * dx) + 2.0 / (dy * dy);
self.p[c] = (p0[ip] + p0[im]) / (dx * dx) + (p0[jp] + p0[jm]) / (dy * dy) - rhs;
self.p[c] /= denom;
}
}
}
let p = self.p.clone();
for j in 0..g.ny {
for i in 0..g.nx {
let c = idx(i, j);
let im = idx(clamp(i as isize - 1, g.nx), j);
let ip = idx(clamp(i as isize + 1, g.nx), j);
let jm = idx(i, clamp(j as isize - 1, g.ny));
let jp = idx(i, clamp(j as isize + 1, g.ny));
self.u[c] -= self.dt * (p[ip] - p[im]) / (2.0 * dx);
self.v[c] -= self.dt * (p[jp] - p[jm]) / (2.0 * dy);
}
}
}
fn apply_walls(&mut self) {
let g = &self.grid;
let (nx, ny) = (g.nx, g.ny);
if self.walls[Boundary::Top as usize] != 0.0 {
for i in 0..nx {
self.u[g.idx(i, ny - 1)] = self.walls[Boundary::Top as usize];
}
}
if self.walls[Boundary::Bottom as usize] != 0.0 {
for i in 0..nx {
self.u[g.idx(i, 0)] = self.walls[Boundary::Bottom as usize];
}
}
}
pub fn advance(&mut self) -> bool {
self.momentum();
self.project();
self.u.iter().chain(self.v.iter()).all(|&x| x.is_finite())
}
#[must_use]
pub fn max_divergence(&self) -> f64 {
let g = &self.grid;
let (dx, dy) = (g.dx, g.dy);
let idx = |i: usize, j: usize| g.idx(i, j);
let mut max: f64 = 0.0;
for j in 1..g.ny.saturating_sub(1) {
for i in 1..g.nx.saturating_sub(1) {
let im = idx(i - 1, j);
let ip = idx(i + 1, j);
let jm = idx(i, j - 1);
let jp = idx(i, j + 1);
let d =
(self.u[ip] - self.u[im]) / (2.0 * dx) + (self.v[jp] - self.v[jm]) / (2.0 * dy);
max = max.max(d.abs());
}
}
max
}
#[must_use]
pub fn grid(&self) -> &CollocatedGrid {
&self.grid
}
}
#[cfg(test)]
mod tests {
use super::*;
use approx::assert_abs_diff_eq;
#[test]
fn grid_index_roundtrip() {
let g = CollocatedGrid::new(10, 8, 1.0, 1.0).unwrap();
assert_eq!(g.idx(3, 2), 2 * 10 + 3);
assert_eq!(g.len(), 80);
}
#[test]
fn lid_driven_stays_finite() {
let grid = CollocatedGrid::new(24, 24, 1.0, 1.0).unwrap();
let mut step = Step::new(grid, 0.01, 0.005, 1.0);
step.set_boundary(Boundary::Top, 1.0);
for _ in 0..20 {
assert!(step.advance());
}
let top = step.grid.idx(0, step.grid.ny - 1);
assert!(step.u[top] > 0.0);
}
#[test]
fn projection_reduces_divergence() {
let grid = CollocatedGrid::new(20, 20, 1.0, 1.0).unwrap();
let mut step = Step::new(grid, 0.01, 0.005, 1.0);
let nx = step.grid().nx;
for j in 0..step.grid().ny {
for i in 0..nx {
step.u[j * nx + i] = i as f64;
}
}
let before = step.max_divergence();
step.project();
let after = step.max_divergence();
assert!(
after < before * 1.15,
"projection should not materially increase divergence (before={before}, after={after})"
);
}
#[test]
fn uniform_field_is_divergence_free() {
let grid = CollocatedGrid::new(16, 16, 1.0, 1.0).unwrap();
let mut step = Step::new(grid, 0.01, 0.01, 1.0);
step.u.fill(1.0);
assert_abs_diff_eq!(step.max_divergence(), 0.0, epsilon = 1e-12);
}
}