use tpt_math_numeric::Scalar;
use crate::error::GridError;
pub fn linspace<T: Scalar>(start: T, end: T, n: usize) -> Vec<T> {
match n {
0 => Vec::new(),
1 => vec![start],
n => {
let step = (end - start) / T::from((n - 1) as f64).unwrap();
(0..n)
.map(|i| start + step * T::from(i as f64).unwrap())
.collect()
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum Boundary {
#[default]
Dirichlet,
Neumann,
}
#[derive(Debug, Clone)]
pub struct UniformGrid1D {
n: usize,
x0: f64,
x1: f64,
}
impl UniformGrid1D {
pub fn new(n: usize, x0: f64, x1: f64) -> Result<Self, GridError> {
if n < 2 {
return Err(GridError::TooFewPoints(2, n));
}
if x1 <= x0 {
return Err(GridError::InvalidDomain(x0, x1));
}
Ok(Self { n, x0, x1 })
}
pub fn n(&self) -> usize {
self.n
}
pub fn x0(&self) -> f64 {
self.x0
}
pub fn x1(&self) -> f64 {
self.x1
}
pub fn dx(&self) -> f64 {
(self.x1 - self.x0) / (self.n as f64 - 1.0)
}
pub fn coordinates(&self) -> Vec<f64> {
linspace(self.x0, self.x1, self.n)
}
}
#[derive(Debug, Clone)]
pub struct UniformGrid2D {
nx: usize,
x0: f64,
x1: f64,
ny: usize,
y0: f64,
y1: f64,
}
impl UniformGrid2D {
pub fn new(
nx: usize,
x0: f64,
x1: f64,
ny: usize,
y0: f64,
y1: f64,
) -> Result<Self, GridError> {
if nx < 2 {
return Err(GridError::TooFewPoints(2, nx));
}
if ny < 2 {
return Err(GridError::TooFewPoints(2, ny));
}
if x1 <= x0 {
return Err(GridError::InvalidDomain(x0, x1));
}
if y1 <= y0 {
return Err(GridError::InvalidDomain(y0, y1));
}
Ok(Self {
nx,
x0,
x1,
ny,
y0,
y1,
})
}
pub fn nx(&self) -> usize {
self.nx
}
pub fn ny(&self) -> usize {
self.ny
}
pub fn len(&self) -> usize {
self.nx * self.ny
}
pub fn is_empty(&self) -> bool {
self.len() == 0
}
pub fn dx(&self) -> f64 {
(self.x1 - self.x0) / (self.nx as f64 - 1.0)
}
pub fn dy(&self) -> f64 {
(self.y1 - self.y0) / (self.ny as f64 - 1.0)
}
pub fn x0(&self) -> f64 {
self.x0
}
pub fn x1(&self) -> f64 {
self.x1
}
pub fn y0(&self) -> f64 {
self.y0
}
pub fn y1(&self) -> f64 {
self.y1
}
pub fn x_coordinates(&self) -> Vec<f64> {
linspace(self.x0, self.x1, self.nx)
}
pub fn y_coordinates(&self) -> Vec<f64> {
linspace(self.y0, self.y1, self.ny)
}
}
#[derive(Debug, Clone)]
pub struct UniformGrid3D {
nx: usize,
x0: f64,
x1: f64,
ny: usize,
y0: f64,
y1: f64,
nz: usize,
z0: f64,
z1: f64,
}
impl UniformGrid3D {
#[allow(clippy::too_many_arguments)]
pub fn new(
nx: usize,
x0: f64,
x1: f64,
ny: usize,
y0: f64,
y1: f64,
nz: usize,
z0: f64,
z1: f64,
) -> Result<Self, GridError> {
if nx < 2 {
return Err(GridError::TooFewPoints(2, nx));
}
if ny < 2 {
return Err(GridError::TooFewPoints(2, ny));
}
if nz < 2 {
return Err(GridError::TooFewPoints(2, nz));
}
if x1 <= x0 {
return Err(GridError::InvalidDomain(x0, x1));
}
if y1 <= y0 {
return Err(GridError::InvalidDomain(y0, y1));
}
if z1 <= z0 {
return Err(GridError::InvalidDomain(z0, z1));
}
Ok(Self {
nx,
x0,
x1,
ny,
y0,
y1,
nz,
z0,
z1,
})
}
pub fn nx(&self) -> usize {
self.nx
}
pub fn ny(&self) -> usize {
self.ny
}
pub fn nz(&self) -> usize {
self.nz
}
pub fn len(&self) -> usize {
self.nx * self.ny * self.nz
}
pub fn is_empty(&self) -> bool {
self.len() == 0
}
pub fn dx(&self) -> f64 {
(self.x1 - self.x0) / (self.nx as f64 - 1.0)
}
pub fn dy(&self) -> f64 {
(self.y1 - self.y0) / (self.ny as f64 - 1.0)
}
pub fn dz(&self) -> f64 {
(self.z1 - self.z0) / (self.nz as f64 - 1.0)
}
pub fn x0(&self) -> f64 {
self.x0
}
pub fn x1(&self) -> f64 {
self.x1
}
pub fn y0(&self) -> f64 {
self.y0
}
pub fn y1(&self) -> f64 {
self.y1
}
pub fn z0(&self) -> f64 {
self.z0
}
pub fn z1(&self) -> f64 {
self.z1
}
pub fn x_coordinates(&self) -> Vec<f64> {
linspace(self.x0, self.x1, self.nx)
}
pub fn y_coordinates(&self) -> Vec<f64> {
linspace(self.y0, self.y1, self.ny)
}
pub fn z_coordinates(&self) -> Vec<f64> {
linspace(self.z0, self.z1, self.nz)
}
#[must_use]
pub fn index(&self, ix: usize, iy: usize, iz: usize) -> usize {
ix + iy * self.nx + iz * self.nx * self.ny
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn grid3d_rejects_invalid() {
assert!(UniformGrid3D::new(1, 0.0, 1.0, 2, 0.0, 1.0, 2, 0.0, 1.0).is_err());
assert!(UniformGrid3D::new(2, 1.0, 0.0, 2, 0.0, 1.0, 2, 0.0, 1.0).is_err());
assert!(UniformGrid3D::new(2, 0.0, 1.0, 2, 0.0, 1.0, 2, 1.0, 0.0).is_err());
}
#[test]
fn grid3d_index_is_lexicographic() {
let g = UniformGrid3D::new(3, 0.0, 1.0, 4, 0.0, 1.0, 5, 0.0, 1.0).unwrap();
assert_eq!(g.len(), 60);
assert_eq!(g.index(0, 0, 0), 0);
assert_eq!(g.index(1, 0, 0), 1);
assert_eq!(g.index(0, 1, 0), 3);
assert_eq!(g.index(0, 0, 1), 12);
let mut seen = vec![false; g.len()];
for iz in 0..g.nz() {
for iy in 0..g.ny() {
for ix in 0..g.nx() {
let k = g.index(ix, iy, iz);
assert!(!seen[k]);
seen[k] = true;
}
}
}
}
}