use super::super::{Axis, StaggeredLeapfrog3D};
use super::{reflect, window_sum};
use crate::infrastructure::parallel::for_each_plane_mut;
use eunomia::{NumericElement, RealField};
use leto::{ArrayView3, ArrayViewMut3};
pub(crate) fn divergence<T: RealField>(
op: &StaggeredLeapfrog3D<T>,
axis: Axis,
field: ArrayView3<'_, T>,
dst: &mut ArrayViewMut3<'_, T>,
shape: [usize; 3],
) {
let (index, extent, scale) = op.axis_geometry(axis, shape);
let (Some(source), Some(target)) = (field.as_slice(), dst.as_mut_slice()) else {
dst.fill(<T as NumericElement>::ZERO);
divergence_indexed(op, index, extent, scale, field, dst, shape);
return;
};
if source.is_empty() {
return;
}
let extent = extent as usize;
let plane = shape[1] * shape[2];
let element_bytes = size_of::<T>();
match index {
0 => {
let reads = 1 + 2 * op.halo_width();
for_each_plane_mut(target, plane, reads * element_bytes, |here, out| {
divergence_block_gather(op, source, out, here, extent, scale);
});
}
1 => for_each_plane_mut(target, plane, 2 * element_bytes, |x, out| {
out.fill(<T as NumericElement>::ZERO);
let start = x * plane;
divergence_blocks(
op,
&source[start..start + plane],
out,
extent,
shape[2],
scale,
);
}),
_ => for_each_plane_mut(target, plane, 2 * element_bytes, |x, out| {
out.fill(<T as NumericElement>::ZERO);
let start = x * plane;
for (source, target) in source[start..start + plane]
.chunks_exact(extent)
.zip(out.chunks_exact_mut(extent))
{
divergence_line(op, source, target, scale);
}
}),
}
}
fn divergence_blocks<T: RealField>(
op: &StaggeredLeapfrog3D<T>,
source: &[T],
target: &mut [T],
extent: usize,
block: usize,
scale: T,
) {
let reach = extent as isize;
for (here, value) in source.chunks_exact(block).enumerate() {
for (offset, &c) in op.coefficients().taps().iter().enumerate() {
let n = offset as isize + 1;
let hi = reflect(here as isize + n, reach) * block;
for (out, &value) in target[hi..hi + block].iter_mut().zip(value) {
*out -= c * (value * scale);
}
let lo = reflect(here as isize - n + 1, reach) * block;
for (out, &value) in target[lo..lo + block].iter_mut().zip(value) {
*out += c * (value * scale);
}
}
}
}
fn divergence_block_gather<T: RealField>(
op: &StaggeredLeapfrog3D<T>,
source: &[T],
out: &mut [T],
here: usize,
extent: usize,
scale: T,
) {
let block = out.len();
divergence_gather(op, out, here, extent, scale, |at| {
&source[at * block..(at + 1) * block]
});
}
fn divergence_gather<'a, T: RealField + 'a>(
op: &StaggeredLeapfrog3D<T>,
out: &mut [T],
here: usize,
extent: usize,
scale: T,
lane: impl Fn(usize) -> &'a [T],
) {
let reach = extent as isize;
out.fill(<T as NumericElement>::ZERO);
let halo = op.halo_width();
let sources = if here >= 2 * halo && here + 2 * halo < extent {
here - halo..here + halo + 1
} else {
0..extent
};
for from in sources {
for (offset, &c) in op.coefficients().taps().iter().enumerate() {
let n = offset as isize + 1;
if reflect(from as isize + n, reach) == here {
for (out, &value) in out.iter_mut().zip(lane(from)) {
*out -= c * (value * scale);
}
}
if reflect(from as isize - n + 1, reach) == here {
for (out, &value) in out.iter_mut().zip(lane(from)) {
*out += c * (value * scale);
}
}
}
}
}
pub(crate) fn divergence_row<T: RealField>(
op: &StaggeredLeapfrog3D<T>,
axis: Axis,
source: &[T],
out: &mut [T],
[x, y]: [usize; 2],
shape: [usize; 3],
) {
let (index, extent, scale) = op.axis_geometry(axis, shape);
let extent = extent as usize;
let [_, ny, nz] = shape;
let row_at = |plane: usize, row: usize| {
let start = (plane * ny + row) * nz;
&source[start..start + nz]
};
match index {
0 => divergence_gather(op, out, x, extent, scale, |plane| row_at(plane, y)),
1 => divergence_gather(op, out, y, extent, scale, |row| row_at(x, row)),
_ => {
out.fill(<T as NumericElement>::ZERO);
divergence_line(op, row_at(x, y), out, scale);
}
}
}
fn divergence_line<T: RealField>(
op: &StaggeredLeapfrog3D<T>,
source: &[T],
target: &mut [T],
scale: T,
) {
let halo = op.halo_width();
let extent = source.len();
let interior = if extent >= 2 * halo {
halo..(extent - halo)
} else {
0..0
};
for (out, window) in target[interior.clone()]
.iter_mut()
.zip(source.windows(2 * halo))
{
*out = window_sum(op, window) * scale;
}
let reach = extent as isize;
let near_a_wall = |here: &usize| *here < 2 * halo || *here + 2 * halo >= extent;
for here in (0..extent).filter(near_a_wall) {
let value = source[here] * scale;
for (offset, &c) in op.coefficients().taps().iter().enumerate() {
let n = offset as isize + 1;
let hi = reflect(here as isize + n, reach);
if !interior.contains(&hi) {
target[hi] -= c * value;
}
let lo = reflect(here as isize - n + 1, reach);
if !interior.contains(&lo) {
target[lo] += c * value;
}
}
}
}
fn divergence_indexed<T: RealField>(
op: &StaggeredLeapfrog3D<T>,
index: usize,
extent: isize,
scale: T,
field: ArrayView3<'_, T>,
dst: &mut ArrayViewMut3<'_, T>,
shape: [usize; 3],
) {
for i in 0..shape[0] {
for j in 0..shape[1] {
for k in 0..shape[2] {
let base = [i, j, k];
let here = base[index] as isize;
let value = field[base] * scale;
for (offset, &c) in op.coefficients().taps().iter().enumerate() {
let n = offset as isize + 1;
let mut hi = base;
hi[index] = reflect(here + n, extent);
let mut lo = base;
lo[index] = reflect(here - n + 1, extent);
dst[hi] -= c * value;
dst[lo] += c * value;
}
}
}
}
}