use std::f64::consts::PI;
use super::PppmParams;
#[must_use]
pub fn erfc(x: f64) -> f64 {
if x < 0.0 {
return 2.0 - erfc(-x);
}
let t = 1.0 / 0.327_591_1f64.mul_add(x, 1.0);
let poly = t
* (0.254_829_592
+ t * (-0.284_496_736
+ t * (1.421_413_741 + t * (-1.453_152_027 + t * 1.061_405_429))));
poly * (-x * x).exp()
}
#[must_use]
pub fn erfc_deriv(x: f64) -> f64 {
-2.0 / PI.sqrt() * (-x * x).exp()
}
#[must_use]
pub fn compute_short_range(
positions: &[[f64; 3]],
charges: &[f64],
params: &PppmParams,
) -> (Vec<[f64; 3]>, f64) {
let n = positions.len();
assert_eq!(charges.len(), n);
let alpha = params.alpha;
let rc = params.real_cutoff;
let rc_sq = rc * rc;
let box_dims = params.box_dims;
let k = params.coulomb_constant;
let mut forces = vec![[0.0, 0.0, 0.0]; n];
let mut energy = 0.0;
for i in 0..n {
let qi = charges[i];
let ri = positions[i];
for j in (i + 1)..n {
let qj = charges[j];
let rj = positions[j];
let dx = minimum_image(ri[0] - rj[0], box_dims[0]);
let dy = minimum_image(ri[1] - rj[1], box_dims[1]);
let dz = minimum_image(ri[2] - rj[2], box_dims[2]);
let r_sq = dz.mul_add(dz, dx.mul_add(dx, dy * dy));
if r_sq >= rc_sq {
continue;
}
let r = r_sq.sqrt();
let ar = alpha * r;
let erfc_ar = erfc(ar);
let pot = k * qi * qj * erfc_ar / r;
energy += pot;
let exp_ar_sq = (-ar * ar).exp();
let force_mag =
k * qi * qj * (erfc_ar / r_sq + 2.0 * alpha / PI.sqrt() * exp_ar_sq / r);
let fx = force_mag * dx / r;
let fy = force_mag * dy / r;
let fz = force_mag * dz / r;
forces[i][0] += fx;
forces[i][1] += fy;
forces[i][2] += fz;
forces[j][0] -= fx;
forces[j][1] -= fy;
forces[j][2] -= fz;
}
}
(forces, energy)
}
#[must_use]
pub fn compute_short_range_forces(
positions: &[[f64; 3]],
charges: &[f64],
params: &PppmParams,
) -> Vec<[f64; 3]> {
let n = positions.len();
assert_eq!(charges.len(), n);
let alpha = params.alpha;
let rc = params.real_cutoff;
let rc_sq = rc * rc;
let box_dims = params.box_dims;
let k = params.coulomb_constant;
let mut forces = vec![[0.0, 0.0, 0.0]; n];
for i in 0..n {
let qi = charges[i];
let ri = positions[i];
for j in (i + 1)..n {
let qj = charges[j];
let rj = positions[j];
let dx = minimum_image(ri[0] - rj[0], box_dims[0]);
let dy = minimum_image(ri[1] - rj[1], box_dims[1]);
let dz = minimum_image(ri[2] - rj[2], box_dims[2]);
let r_sq = dz.mul_add(dz, dx.mul_add(dx, dy * dy));
if r_sq >= rc_sq {
continue;
}
let r = r_sq.sqrt();
let ar = alpha * r;
let erfc_ar = erfc(ar);
let exp_ar_sq = (-ar * ar).exp();
let force_mag =
k * qi * qj * (erfc_ar / r_sq + 2.0 * alpha / PI.sqrt() * exp_ar_sq / r);
let fx = force_mag * dx / r;
let fy = force_mag * dy / r;
let fz = force_mag * dz / r;
forces[i][0] += fx;
forces[i][1] += fy;
forces[i][2] += fz;
forces[j][0] -= fx;
forces[j][1] -= fy;
forces[j][2] -= fz;
}
}
forces
}
#[must_use]
pub fn self_energy_correction(charges: &[f64], alpha: f64, coulomb_constant: f64) -> f64 {
let q_sq_sum: f64 = charges.iter().map(|q| q * q).sum();
-alpha / PI.sqrt() * coulomb_constant * q_sq_sum
}
#[must_use]
pub fn dipole_correction(
positions: &[[f64; 3]],
charges: &[f64],
box_dims: [f64; 3],
coulomb_constant: f64,
) -> f64 {
let volume = box_dims[0] * box_dims[1] * box_dims[2];
let mut mx = 0.0;
let mut my = 0.0;
let mut mz = 0.0;
for (pos, &q) in positions.iter().zip(charges.iter()) {
mx = q.mul_add(pos[0], mx);
my = q.mul_add(pos[1], my);
mz = q.mul_add(pos[2], mz);
}
let m_sq = mx * mx + my * my + mz * mz;
2.0 * PI / (3.0 * volume) * coulomb_constant * m_sq
}
#[inline]
fn minimum_image(d: f64, box_len: f64) -> f64 {
box_len.mul_add(-(d / box_len).round(), d)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_erfc_values() {
assert!((erfc(0.0) - 1.0).abs() < 1e-6);
assert!((erfc(1.0) - 0.1572992).abs() < 1e-6);
assert!((erfc(2.0) - 0.0046778).abs() < 1e-6);
let x = 1.5;
assert!((erfc(-x) - (2.0 - erfc(x))).abs() < 1e-10);
}
#[test]
fn test_minimum_image() {
let l = 10.0;
assert!((minimum_image(3.0, l) - 3.0).abs() < 1e-10);
assert!((minimum_image(-3.0, l) - (-3.0)).abs() < 1e-10);
assert!((minimum_image(7.0, l) - (-3.0)).abs() < 1e-10);
assert!((minimum_image(-7.0, l) - 3.0).abs() < 1e-10);
}
#[test]
fn test_short_range_opposite_charges() {
let params = PppmParams::custom(
2,
[10.0, 10.0, 10.0],
[8, 8, 8],
1.0, 5.0, 4,
);
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) = compute_short_range(&positions, &charges, ¶ms);
assert!(energy < 0.0);
assert!(forces[0][0] > 0.0);
assert!(forces[1][0] < 0.0);
assert!((forces[0][0] + forces[1][0]).abs() < 1e-10);
}
#[test]
fn test_short_range_like_charges() {
let params = PppmParams::custom(2, [10.0, 10.0, 10.0], [8, 8, 8], 1.0, 5.0, 4);
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) = compute_short_range(&positions, &charges, ¶ms);
assert!(energy > 0.0);
assert!(forces[0][0] < 0.0);
assert!(forces[1][0] > 0.0);
}
#[test]
fn test_cutoff_respected() {
let params = PppmParams::custom(
2,
[10.0, 10.0, 10.0],
[8, 8, 8],
1.0,
2.0, 4,
);
let positions = vec![[1.0, 5.0, 5.0], [6.0, 5.0, 5.0]]; let charges = vec![1.0, 1.0];
let (forces, energy) = compute_short_range(&positions, &charges, ¶ms);
assert!(energy.abs() < 1e-14);
for force in &forces {
assert!(force[0].abs() < 1e-14);
assert!(force[1].abs() < 1e-14);
assert!(force[2].abs() < 1e-14);
}
}
#[test]
fn test_self_energy_correction() {
let charges = vec![1.0, 1.0, -2.0];
let alpha = 2.0;
let k = 1.0;
let e_self = self_energy_correction(&charges, alpha, k);
assert!(e_self < 0.0);
let expected = -alpha / PI.sqrt() * k * 6.0;
assert!((e_self - expected).abs() < 1e-10);
}
}