use eunomia::{FloatElement, NumericElement, RealField};
use leto::{ArrayView3, ArrayViewMut3, LetoError, Result};
use super::f;
use super::leapfrog::Axis;
use super::FiniteDifference3DScheme;
struct Scales<T> {
inv_h: T,
inv_2h: T,
inv_12h: T,
inv_60h: T,
}
fn scales<T: RealField + FloatElement + Copy>(h: T) -> Scales<T> {
let one = <T as NumericElement>::ONE;
Scales {
inv_h: one / h,
inv_2h: one / (f::<T>(2.0) * h),
inv_12h: one / (f::<T>(12.0) * h),
inv_60h: one / (f::<T>(60.0) * h),
}
}
fn is_central4_second(n: usize, i: usize) -> bool {
i >= 1 && i + 2 <= n && (i < 2 || i + 2 >= n)
}
fn is_central4_fourth(n: usize, i: usize) -> bool {
i >= 2 && i + 3 <= n
}
fn adjoint2_lane<T, F>(u: F, n: usize, j: usize, scales: &Scales<T>) -> T
where
T: RealField + FloatElement + Copy,
F: Fn(usize) -> T,
{
let zero = <T as NumericElement>::ZERO;
let mut v = zero;
if j == 0 {
v += (-u(0)) * scales.inv_h;
}
if j == 1 {
v += u(0) * scales.inv_h;
}
if j + 2 == n {
v += (-u(n - 1)) * scales.inv_h;
}
if j + 1 == n {
v += u(n - 1) * scales.inv_h;
}
if j + 3 <= n {
v += (-u(j + 1)) * scales.inv_2h;
}
if j >= 2 {
v += u(j - 1) * scales.inv_2h;
}
v
}
fn adjoint4_lane<T, F>(u: F, n: usize, j: usize, scales: &Scales<T>) -> T
where
T: RealField + FloatElement + Copy,
F: Fn(usize) -> T,
{
let zero = <T as NumericElement>::ZERO;
if n == 1 {
return zero;
}
let eight = f::<T>(8.0);
let mut v = zero;
if j == 0 {
v += (-u(0)) * scales.inv_h;
}
if j == 1 {
v += u(0) * scales.inv_h;
}
if j + 2 == n {
v += (-u(n - 1)) * scales.inv_h;
}
if j + 1 == n {
v += u(n - 1) * scales.inv_h;
}
if j + 1 < n && is_central4_second(n, j + 1) {
v += (-u(j + 1)) * scales.inv_2h;
}
if j >= 1 && is_central4_second(n, j - 1) {
v += u(j - 1) * scales.inv_2h;
}
if j + 2 < n && is_central4_fourth(n, j + 2) {
v += u(j + 2) * scales.inv_12h;
}
if j + 1 < n && is_central4_fourth(n, j + 1) {
v += ((-eight) * u(j + 1)) * scales.inv_12h;
}
if j >= 1 && is_central4_fourth(n, j - 1) {
v += (eight * u(j - 1)) * scales.inv_12h;
}
if j >= 2 && is_central4_fourth(n, j - 2) {
v += (-u(j - 2)) * scales.inv_12h;
}
v
}
fn adjoint6_lane<T, F>(u: F, n: usize, j: usize, scales: &Scales<T>) -> T
where
T: RealField + FloatElement + Copy,
F: Fn(usize) -> T,
{
let zero = <T as NumericElement>::ZERO;
let eight = f::<T>(8.0);
let nine = f::<T>(9.0);
let forty_five = f::<T>(45.0);
let is_second = |i: usize| i == 1 || i + 2 == n;
let is_fourth = |i: usize| i == 2 || i + 3 == n;
let is_sixth = |i: usize| i >= 3 && i + 4 <= n;
let mut v = zero;
if j == 0 {
v += (-u(0)) * scales.inv_h;
}
if j == 1 {
v += u(0) * scales.inv_h;
}
if j + 2 == n {
v += (-u(n - 1)) * scales.inv_h;
}
if j + 1 == n {
v += u(n - 1) * scales.inv_h;
}
if j + 1 < n && is_second(j + 1) {
v += (-u(j + 1)) * scales.inv_2h;
}
if j >= 1 && is_second(j - 1) {
v += u(j - 1) * scales.inv_2h;
}
if j + 2 < n && is_fourth(j + 2) {
v += u(j + 2) * scales.inv_12h;
}
if j + 1 < n && is_fourth(j + 1) {
v += ((-eight) * u(j + 1)) * scales.inv_12h;
}
if j >= 1 && is_fourth(j - 1) {
v += (eight * u(j - 1)) * scales.inv_12h;
}
if j >= 2 && is_fourth(j - 2) {
v += (-u(j - 2)) * scales.inv_12h;
}
if j + 3 < n && is_sixth(j + 3) {
v += (-u(j + 3)) * scales.inv_60h;
}
if j + 2 < n && is_sixth(j + 2) {
v += (nine * u(j + 2)) * scales.inv_60h;
}
if j + 1 < n && is_sixth(j + 1) {
v += ((-forty_five) * u(j + 1)) * scales.inv_60h;
}
if j >= 1 && is_sixth(j - 1) {
v += (forty_five * u(j - 1)) * scales.inv_60h;
}
if j >= 2 && is_sixth(j - 2) {
v += ((-nine) * u(j - 2)) * scales.inv_60h;
}
if j >= 3 && is_sixth(j - 3) {
v += u(j - 3) * scales.inv_60h;
}
v
}
fn adjoint_forward_lane<T, F>(u: F, n: usize, j: usize, inv_h: T) -> T
where
T: RealField + FloatElement + Copy,
F: Fn(usize) -> T,
{
let zero = <T as NumericElement>::ZERO;
let mut v = zero;
if j + 1 < n {
v += (-u(j)) * inv_h;
}
if j >= 1 {
v += u(j - 1) * inv_h;
}
v
}
fn adjoint_backward_lane<T, F>(u: F, n: usize, j: usize, inv_h: T) -> T
where
T: RealField + FloatElement + Copy,
F: Fn(usize) -> T,
{
let zero = <T as NumericElement>::ZERO;
let mut v = zero;
if j == 0 {
v += (-u(0)) * inv_h;
}
if j == 1 {
v += u(0) * inv_h;
}
if j + 2 <= n {
v += (-u(j + 1)) * inv_h;
}
if j >= 1 {
v += u(j) * inv_h;
}
v
}
fn minimum_extent(scheme: FiniteDifference3DScheme) -> usize {
match scheme {
FiniteDifference3DScheme::CentralSecondOrder => 3,
FiniteDifference3DScheme::CentralFourthOrder => 1,
FiniteDifference3DScheme::CentralSixthOrder => 7,
FiniteDifference3DScheme::StaggeredForward
| FiniteDifference3DScheme::StaggeredBackward => 2,
}
}
pub(super) fn adjoint_into<T>(
scheme: FiniteDifference3DScheme,
axis: Axis,
upstream: ArrayView3<T>,
grad: &mut ArrayViewMut3<'_, T>,
h: T,
) -> Result<()>
where
T: RealField + FloatElement + Copy,
{
let shape = grad.shape();
let n = shape[axis.index()];
let required = minimum_extent(scheme);
if n < required {
return Err(LetoError::InvalidInput(
format!(
"{scheme:?} adjoint: need at least {required} points on the differentiated axis, got {n}"
),
));
}
let mut expected = shape;
if matches!(scheme, FiniteDifference3DScheme::StaggeredForward) {
expected[axis.index()] -= 1;
}
if upstream.shape() != expected {
return Err(LetoError::InvalidInput(format!(
"{scheme:?} adjoint: upstream shape {:?} must be {expected:?} for grad shape {shape:?}",
upstream.shape(),
)));
}
let s = scales(h);
let [nx, ny, nz] = shape;
match axis {
Axis::X => {
for i in 0..nx {
for j in 0..ny {
for k in 0..nz {
grad[[i, j, k]] = lane(scheme, n, i, |t| upstream[[t, j, k]], &s);
}
}
}
}
Axis::Y => {
for i in 0..nx {
for j in 0..ny {
for k in 0..nz {
grad[[i, j, k]] = lane(scheme, n, j, |t| upstream[[i, t, k]], &s);
}
}
}
}
Axis::Z => {
for i in 0..nx {
for j in 0..ny {
for k in 0..nz {
grad[[i, j, k]] = lane(scheme, n, k, |t| upstream[[i, j, t]], &s);
}
}
}
}
}
Ok(())
}
fn lane<T, F>(scheme: FiniteDifference3DScheme, n: usize, j: usize, read: F, s: &Scales<T>) -> T
where
T: RealField + FloatElement + Copy,
F: Fn(usize) -> T,
{
match scheme {
FiniteDifference3DScheme::CentralSecondOrder => adjoint2_lane(read, n, j, s),
FiniteDifference3DScheme::CentralFourthOrder => adjoint4_lane(read, n, j, s),
FiniteDifference3DScheme::CentralSixthOrder => adjoint6_lane(read, n, j, s),
FiniteDifference3DScheme::StaggeredForward => adjoint_forward_lane(read, n, j, s.inv_h),
FiniteDifference3DScheme::StaggeredBackward => adjoint_backward_lane(read, n, j, s.inv_h),
}
}