pub const WGSL_CHARGE_SPREAD_F64: &str = include_str!("charge_spread_f64.wgsl");
use super::PppmParams;
use super::bspline::BsplineCoeffs;
#[derive(Clone, Debug)]
pub struct ChargeMesh {
pub dims: [usize; 3],
pub values: Vec<f64>,
pub box_dims: [f64; 3],
}
impl ChargeMesh {
#[must_use]
pub fn new(dims: [usize; 3], box_dims: [f64; 3]) -> Self {
let size = dims[0] * dims[1] * dims[2];
Self {
dims,
values: vec![0.0; size],
box_dims,
}
}
pub fn clear(&mut self) {
self.values.fill(0.0);
}
#[inline]
#[must_use]
pub fn index(&self, ix: usize, iy: usize, iz: usize) -> usize {
iz + self.dims[2] * (iy + self.dims[1] * ix)
}
#[inline]
#[must_use]
pub fn get(&self, ix: usize, iy: usize, iz: usize) -> f64 {
self.values[self.index(ix, iy, iz)]
}
#[inline]
pub fn add(&mut self, ix: usize, iy: usize, iz: usize, value: f64) {
let idx = self.index(ix, iy, iz);
self.values[idx] += value;
}
#[must_use]
pub fn spacing(&self) -> [f64; 3] {
[
self.box_dims[0] / self.dims[0] as f64,
self.box_dims[1] / self.dims[1] as f64,
self.box_dims[2] / self.dims[2] as f64,
]
}
#[must_use]
pub fn len(&self) -> usize {
self.values.len()
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.values.is_empty()
}
}
#[must_use]
pub fn spread_charges(positions: &[[f64; 3]], charges: &[f64], params: &PppmParams) -> ChargeMesh {
assert_eq!(positions.len(), charges.len());
let mut mesh = ChargeMesh::new(params.mesh_dims, params.box_dims);
let order = params.interpolation_order;
for (pos, &charge) in positions.iter().zip(charges.iter()) {
let wrapped_pos = wrap_position(*pos, params.box_dims);
let coeffs = BsplineCoeffs::compute(order, wrapped_pos, params.mesh_dims, params.box_dims);
for ix in 0..order {
for iy in 0..order {
for iz in 0..order {
let [mx, my, mz] = coeffs.mesh_index(ix, iy, iz, params.mesh_dims);
let weight = coeffs.weight(ix, iy, iz);
mesh.add(mx, my, mz, charge * weight);
}
}
}
}
mesh
}
#[must_use]
pub fn spread_charges_with_coeffs(
positions: &[[f64; 3]],
charges: &[f64],
params: &PppmParams,
) -> (ChargeMesh, Vec<BsplineCoeffs>) {
assert_eq!(positions.len(), charges.len());
let mut mesh = ChargeMesh::new(params.mesh_dims, params.box_dims);
let order = params.interpolation_order;
let mut all_coeffs = Vec::with_capacity(positions.len());
for (pos, &charge) in positions.iter().zip(charges.iter()) {
let wrapped_pos = wrap_position(*pos, params.box_dims);
let coeffs = BsplineCoeffs::compute(order, wrapped_pos, params.mesh_dims, params.box_dims);
for ix in 0..order {
for iy in 0..order {
for iz in 0..order {
let [mx, my, mz] = coeffs.mesh_index(ix, iy, iz, params.mesh_dims);
let weight = coeffs.weight(ix, iy, iz);
mesh.add(mx, my, mz, charge * weight);
}
}
}
all_coeffs.push(coeffs);
}
(mesh, all_coeffs)
}
fn wrap_position(pos: [f64; 3], box_dims: [f64; 3]) -> [f64; 3] {
[
(pos[0] / box_dims[0]).floor().mul_add(-box_dims[0], pos[0]),
(pos[1] / box_dims[1]).floor().mul_add(-box_dims[1], pos[1]),
(pos[2] / box_dims[2]).floor().mul_add(-box_dims[2], pos[2]),
]
}
#[cfg(test)]
mod tests {
use super::*;
use crate::ops::md::electrostatics::PppmAccuracy;
#[test]
fn test_charge_mesh_indexing() {
let mesh = ChargeMesh::new([4, 4, 4], [10.0, 10.0, 10.0]);
assert_eq!(mesh.index(0, 0, 0), 0);
assert_eq!(mesh.index(0, 0, 1), 1);
assert_eq!(mesh.index(0, 1, 0), 4);
assert_eq!(mesh.index(1, 0, 0), 16);
}
#[test]
fn test_charge_conservation() {
let params = PppmParams::auto(10, 10.0, PppmAccuracy::Medium);
let positions: Vec<[f64; 3]> = (0..10)
.map(|i| {
let t = i as f64 / 10.0;
[t * 9.0 + 0.5, t * 7.0 + 1.0, t * 8.0 + 0.5]
})
.collect();
let charges: Vec<f64> = vec![1.0; 10];
let mesh = spread_charges(&positions, &charges, ¶ms);
let mesh_total: f64 = mesh.values.iter().sum();
let particle_total: f64 = charges.iter().sum();
assert!((mesh_total - particle_total).abs() < 1e-10);
}
#[test]
fn test_single_particle_spread() {
let params = PppmParams::custom(
1,
[10.0, 10.0, 10.0],
[8, 8, 8],
2.0,
2.5,
4, );
let positions = vec![[5.0, 5.0, 5.0]];
let charges = vec![1.0];
let mesh = spread_charges(&positions, &charges, ¶ms);
let total: f64 = mesh.values.iter().sum();
assert!((total - 1.0).abs() < 1e-10);
let nonzero_count = mesh.values.iter().filter(|&&v| v.abs() > 1e-14).count();
assert!(nonzero_count <= 64); assert!(nonzero_count > 0);
}
#[test]
fn test_periodic_wrapping() {
let params = PppmParams::custom(1, [10.0, 10.0, 10.0], [8, 8, 8], 2.0, 2.5, 4);
let positions = vec![[15.0, -3.0, 25.0]]; let charges = vec![1.0];
let mesh = spread_charges(&positions, &charges, ¶ms);
let total: f64 = mesh.values.iter().sum();
assert!((total - 1.0).abs() < 1e-10);
}
#[test]
fn test_wrap_position() {
let box_dims = [10.0, 10.0, 10.0];
let p1 = wrap_position([5.0, 5.0, 5.0], box_dims);
assert!((p1[0] - 5.0).abs() < 1e-10);
let p2 = wrap_position([15.0, 25.0, 35.0], box_dims);
assert!((p2[0] - 5.0).abs() < 1e-10);
assert!((p2[1] - 5.0).abs() < 1e-10);
assert!((p2[2] - 5.0).abs() < 1e-10);
let p3 = wrap_position([-3.0, -13.0, -23.0], box_dims);
assert!((p3[0] - 7.0).abs() < 1e-10);
assert!((p3[1] - 7.0).abs() < 1e-10);
assert!((p3[2] - 7.0).abs() < 1e-10);
}
}