use std::f64::consts::PI;
use std::sync::Arc;
use crate::device::WgpuDevice;
use crate::ops::fft::Fft3DF64;
use super::{
ChargeMesh, GreensFunction, PotentialMesh, PppmParams, compute_short_range, dipole_correction,
interpolate_forces, self_energy_correction, spread_charges_with_coeffs,
};
#[derive(Clone)]
pub struct Pppm {
params: PppmParams,
greens: GreensFunction,
device: Arc<WgpuDevice>,
}
#[expect(
dead_code,
reason = "CPU reference path for GPU parity validation in tests"
)]
impl Pppm {
#[must_use]
pub fn new(device: Arc<WgpuDevice>, params: PppmParams) -> Self {
let greens = GreensFunction::new(¶ms);
Self {
params,
greens,
device,
}
}
pub fn compute(
&self,
positions: &[[f64; 3]],
charges: &[f64],
) -> Result<(Vec<[f64; 3]>, f64), PppmError> {
if positions.len() != charges.len() {
return Err(PppmError::SizeMismatch {
positions: positions.len(),
charges: charges.len(),
});
}
let n = positions.len();
if n == 0 {
return Ok((vec![], 0.0));
}
let (charge_mesh, coeffs) = spread_charges_with_coeffs(positions, charges, &self.params);
let rho_k = self.forward_fft(&charge_mesh)?;
let phi_k = self.greens.apply(&rho_k);
let volume = self.params.box_dims[0] * self.params.box_dims[1] * self.params.box_dims[2];
let e_kspace = self.greens.kspace_energy(&rho_k, volume);
let potential_mesh = self.backward_fft(&phi_k)?;
let kspace_forces = interpolate_forces(&potential_mesh, charges, &coeffs, &self.params);
let (short_forces, e_short) = compute_short_range(positions, charges, &self.params);
let e_self =
self_energy_correction(charges, self.params.alpha, self.params.coulomb_constant);
let e_dipole = dipole_correction(
positions,
charges,
self.params.box_dims,
self.params.coulomb_constant,
);
let mut forces = vec![[0.0, 0.0, 0.0]; n];
for i in 0..n {
forces[i][0] = kspace_forces[i][0] + short_forces[i][0];
forces[i][1] = kspace_forces[i][1] + short_forces[i][1];
forces[i][2] = kspace_forces[i][2] + short_forces[i][2];
}
let total_energy = e_kspace + e_short + e_self + e_dipole;
Ok((forces, total_energy))
}
pub fn compute_forces(
&self,
positions: &[[f64; 3]],
charges: &[f64],
) -> Result<Vec<[f64; 3]>, PppmError> {
let (forces, _) = self.compute(positions, charges)?;
Ok(forces)
}
#[must_use]
pub fn params(&self) -> &PppmParams {
&self.params
}
async fn forward_fft_async(&self, mesh: &ChargeMesh) -> Result<Vec<f64>, PppmError> {
let [kx, ky, kz] = self.params.mesh_dims;
if !kx.is_power_of_two() || !ky.is_power_of_two() || !kz.is_power_of_two() {
return Err(PppmError::FftError(format!(
"Mesh dimensions must be powers of 2 for GPU FFT, got ({kx}, {ky}, {kz})"
)));
}
let size = kx * ky * kz;
let mut complex = vec![0.0f64; size * 2];
for i in 0..size {
complex[i * 2] = mesh.values[i];
}
let fft = Fft3DF64::new(self.device.clone(), kx, ky, kz)
.map_err(|e| PppmError::FftError(e.to_string()))?;
fft.forward(&complex)
.await
.map_err(|e| PppmError::FftError(e.to_string()))
}
fn forward_fft(&self, mesh: &ChargeMesh) -> Result<Vec<f64>, PppmError> {
crate::runtime::tokio_block_on(self.forward_fft_async(mesh))
}
async fn backward_fft_async(&self, phi_k: &[f64]) -> Result<PotentialMesh, PppmError> {
let [kx, ky, kz] = self.params.mesh_dims;
if !kx.is_power_of_two() || !ky.is_power_of_two() || !kz.is_power_of_two() {
return Err(PppmError::FftError(format!(
"Mesh dimensions must be powers of 2 for GPU FFT, got ({kx}, {ky}, {kz})"
)));
}
let size = kx * ky * kz;
let fft = Fft3DF64::new(self.device.clone(), kx, ky, kz)
.map_err(|e| PppmError::FftError(e.to_string()))?;
let mut complex = fft
.inverse(phi_k)
.await
.map_err(|e| PppmError::FftError(e.to_string()))?;
let scale = 1.0 / (kx * ky * kz) as f64;
for v in &mut complex {
*v *= scale;
}
let mut values = vec![0.0; size];
for i in 0..size {
values[i] = complex[i * 2];
}
Ok(PotentialMesh::from_values(
self.params.mesh_dims,
values,
self.params.box_dims,
))
}
fn backward_fft(&self, phi_k: &[f64]) -> Result<PotentialMesh, PppmError> {
crate::runtime::tokio_block_on(self.backward_fft_async(phi_k))
}
fn fft_3d_cpu(
&self,
data: &mut [f64],
nx: usize,
ny: usize,
nz: usize,
inverse: bool,
) -> Result<(), PppmError> {
for ix in 0..nx {
for iy in 0..ny {
let mut pencil = vec![0.0; nz * 2];
for iz in 0..nz {
let idx = ((ix * ny + iy) * nz + iz) * 2;
pencil[iz * 2] = data[idx];
pencil[iz * 2 + 1] = data[idx + 1];
}
self.fft_1d_cpu(&mut pencil, nz, inverse);
for iz in 0..nz {
let idx = ((ix * ny + iy) * nz + iz) * 2;
data[idx] = pencil[iz * 2];
data[idx + 1] = pencil[iz * 2 + 1];
}
}
}
for ix in 0..nx {
for iz in 0..nz {
let mut pencil = vec![0.0; ny * 2];
for iy in 0..ny {
let idx = ((ix * ny + iy) * nz + iz) * 2;
pencil[iy * 2] = data[idx];
pencil[iy * 2 + 1] = data[idx + 1];
}
self.fft_1d_cpu(&mut pencil, ny, inverse);
for iy in 0..ny {
let idx = ((ix * ny + iy) * nz + iz) * 2;
data[idx] = pencil[iy * 2];
data[idx + 1] = pencil[iy * 2 + 1];
}
}
}
for iy in 0..ny {
for iz in 0..nz {
let mut pencil = vec![0.0; nx * 2];
for ix in 0..nx {
let idx = ((ix * ny + iy) * nz + iz) * 2;
pencil[ix * 2] = data[idx];
pencil[ix * 2 + 1] = data[idx + 1];
}
self.fft_1d_cpu(&mut pencil, nx, inverse);
for ix in 0..nx {
let idx = ((ix * ny + iy) * nz + iz) * 2;
data[idx] = pencil[ix * 2];
data[idx + 1] = pencil[ix * 2 + 1];
}
}
}
if inverse {
let scale = 1.0 / (nx * ny * nz) as f64;
for v in data.iter_mut() {
*v *= scale;
}
}
Ok(())
}
fn fft_1d_cpu(&self, data: &mut [f64], n: usize, inverse: bool) {
let mut j = 0;
for i in 0..n {
if i < j {
data.swap(i * 2, j * 2);
data.swap(i * 2 + 1, j * 2 + 1);
}
let mut m = n >> 1;
while m > 0 && j >= m {
j -= m;
m >>= 1;
}
j += m;
}
let sign = if inverse { 1.0 } else { -1.0 };
let mut len = 2;
while len <= n {
let half = len / 2;
let angle_step = sign * 2.0 * PI / len as f64;
for start in (0..n).step_by(len) {
let mut angle: f64 = 0.0;
for k in 0..half {
let i = start + k;
let j = start + k + half;
let tw_re = angle.cos();
let tw_im = angle.sin();
let t_re = tw_re.mul_add(data[j * 2], -(tw_im * data[j * 2 + 1]));
let t_im = tw_re.mul_add(data[j * 2 + 1], tw_im * data[j * 2]);
data[j * 2] = data[i * 2] - t_re;
data[j * 2 + 1] = data[i * 2 + 1] - t_im;
data[i * 2] += t_re;
data[i * 2 + 1] += t_im;
angle += angle_step;
}
}
len *= 2;
}
}
}
#[derive(Debug, Clone, thiserror::Error)]
pub enum PppmError {
#[error("Position count ({positions}) doesn't match charge count ({charges})")]
SizeMismatch {
positions: usize,
charges: usize,
},
#[error("FFT error: {0}")]
FftError(String),
}
#[cfg(test)]
mod tests {
use super::*;
use crate::device::test_pool::get_test_device_if_f64_gpu_available_sync;
use crate::ops::md::electrostatics::PppmAccuracy;
#[test]
fn test_pppm_two_opposite_charges() {
let Some(device) = get_test_device_if_f64_gpu_available_sync() else {
return;
};
let params = PppmParams::custom(
2,
[10.0, 10.0, 10.0],
[8, 8, 8],
2.0, 3.0, 4, );
let pppm = Pppm::new(device, params);
let positions = vec![[4.0, 5.0, 5.0], [6.0, 5.0, 5.0]];
let charges = vec![1.0, -1.0];
let (forces, energy) = pppm.compute(&positions, &charges).unwrap();
assert!(energy < 0.0, "Energy should be negative: {energy}");
assert!(
forces[0][0] > 0.0,
"Force on +q should be positive x: {}",
forces[0][0]
);
assert!(
forces[1][0] < 0.0,
"Force on -q should be negative x: {}",
forces[1][0]
);
let force_sum = forces[0][0] + forces[1][0];
assert!(
force_sum.abs() < 0.1,
"Forces should sum to ~0: {force_sum}"
);
}
#[test]
fn test_pppm_two_like_charges() {
let Some(device) = get_test_device_if_f64_gpu_available_sync() else {
return;
};
let params = PppmParams::custom(2, [10.0, 10.0, 10.0], [8, 8, 8], 2.0, 3.0, 4);
let pppm = Pppm::new(device, params);
let positions = vec![[4.0, 5.0, 5.0], [6.0, 5.0, 5.0]];
let charges = vec![1.0, 1.0];
let (forces, _energy) = pppm.compute(&positions, &charges).unwrap();
assert!(
forces[0][0] < 0.0,
"First charge should be pushed left: {}",
forces[0][0]
);
assert!(
forces[1][0] > 0.0,
"Second charge should be pushed right: {}",
forces[1][0]
);
let force_sum = forces[0][0] + forces[1][0];
assert!(
force_sum.abs() < 0.1,
"Forces should sum to ~0: {force_sum}"
);
}
#[test]
fn test_pppm_neutral_system() {
let Some(device) = get_test_device_if_f64_gpu_available_sync() else {
return;
};
let params = PppmParams::auto(4, 10.0, PppmAccuracy::Medium);
let pppm = Pppm::new(device, params);
let positions = vec![
[2.0, 5.0, 5.0],
[4.0, 5.0, 5.0],
[6.0, 5.0, 5.0],
[8.0, 5.0, 5.0],
];
let charges = vec![1.0, 1.0, -1.0, -1.0];
let (forces, _energy) = pppm.compute(&positions, &charges).unwrap();
let total_fx: f64 = forces.iter().map(|f| f[0]).sum();
let total_fy: f64 = forces.iter().map(|f| f[1]).sum();
let total_fz: f64 = forces.iter().map(|f| f[2]).sum();
assert!(total_fx.abs() < 0.1, "Total Fx should be ~0: {total_fx}");
assert!(total_fy.abs() < 0.1, "Total Fy should be ~0: {total_fy}");
assert!(total_fz.abs() < 0.1, "Total Fz should be ~0: {total_fz}");
}
#[test]
fn test_pppm_empty_system() {
let Some(device) = get_test_device_if_f64_gpu_available_sync() else {
return;
};
let params = PppmParams::auto(0, 10.0, PppmAccuracy::Low);
let pppm = Pppm::new(device, params);
let (forces, energy) = pppm.compute(&[], &[]).unwrap();
assert!(forces.is_empty());
assert!((energy - 0.0).abs() < 1e-10);
}
#[test]
fn test_pppm_size_mismatch() {
let Some(device) = get_test_device_if_f64_gpu_available_sync() else {
return;
};
let params = PppmParams::auto(2, 10.0, PppmAccuracy::Low);
let pppm = Pppm::new(device, params);
let result = pppm.compute(&[[0.0, 0.0, 0.0]], &[1.0, 2.0]);
assert!(result.is_err());
if let Err(PppmError::SizeMismatch { positions, charges }) = result {
assert_eq!(positions, 1);
assert_eq!(charges, 2);
}
}
#[test]
fn test_fft_1d_roundtrip() {
let Some(device) = get_test_device_if_f64_gpu_available_sync() else {
return;
};
let params = PppmParams::auto(10, 10.0, PppmAccuracy::Medium);
let pppm = Pppm::new(device, params);
let mut data = vec![1.0, 0.0, 2.0, 0.0, 3.0, 0.0, 4.0, 0.0];
let original = data.clone();
pppm.fft_1d_cpu(&mut data, 4, false);
pppm.fft_1d_cpu(&mut data, 4, true);
for v in &mut data {
*v /= 4.0;
}
for (a, b) in original.iter().zip(data.iter()) {
assert!((a - b).abs() < 1e-10, "FFT roundtrip failed: {a} != {b}");
}
}
}