pub mod heat_current_gpu;
mod kinetic_energy;
mod kinetic_energy_f64;
pub mod msd_gpu;
mod rdf_f64;
mod ssf_gpu;
pub mod transport_gpu;
mod vacf_gpu;
pub use heat_current_gpu::HeatCurrentGpu;
pub use kinetic_energy::KineticEnergy;
pub use kinetic_energy_f64::KineticEnergyF64;
pub use msd_gpu::MsdGpu;
pub use rdf_f64::RdfHistogramF64;
pub use ssf_gpu::SsfGpu;
pub use transport_gpu::{GpuVelocityRing, StressVirialGpu, VacfBatchGpu};
pub use vacf_gpu::VacfGpu;
use std::f64::consts::PI;
#[derive(Clone, Debug)]
pub struct Rdf {
pub r_values: Vec<f64>,
pub g_values: Vec<f64>,
pub dr: f64,
}
#[derive(Clone, Debug)]
pub struct Vacf {
pub t_values: Vec<f64>,
pub c_values: Vec<f64>,
pub diffusion_coeff: f64,
}
#[derive(Clone, Debug)]
pub struct EnergyValidation {
pub mean_total: f64,
pub std_total: f64,
pub drift_pct: f64,
pub mean_temperature: f64,
pub std_temperature: f64,
pub passed: bool,
}
#[must_use]
pub fn compute_rdf(snapshots: &[Vec<f64>], n: usize, box_side: f64, n_bins: usize) -> Rdf {
let r_max = box_side / 2.0;
let dr = r_max / n_bins as f64;
let mut histogram = vec![0u64; n_bins];
let n_frames = snapshots.len();
for snap in snapshots {
for i in 0..n {
let xi = snap[i * 3];
let yi = snap[i * 3 + 1];
let zi = snap[i * 3 + 2];
for j in (i + 1)..n {
let mut dx = snap[j * 3] - xi;
let mut dy = snap[j * 3 + 1] - yi;
let mut dz = snap[j * 3 + 2] - zi;
dx = box_side.mul_add(-(dx / box_side).round(), dx);
dy = box_side.mul_add(-(dy / box_side).round(), dy);
dz = box_side.mul_add(-(dz / box_side).round(), dz);
let r = dz.mul_add(dz, dx.mul_add(dx, dy * dy)).sqrt();
let bin = (r / dr) as usize;
if bin < n_bins {
histogram[bin] += 1;
}
}
}
}
let n_density = 3.0 / (4.0 * PI); let n_f = n as f64;
let r_values: Vec<f64> = (0..n_bins).map(|i| (i as f64 + 0.5) * dr).collect();
let g_values: Vec<f64> = r_values
.iter()
.enumerate()
.map(|(i, &r)| {
let shell_vol = 4.0 * PI * r * r * dr;
2.0 * histogram[i] as f64 / (n_frames as f64 * n_f * n_density * shell_vol).max(1e-30)
})
.collect();
Rdf {
r_values,
g_values,
dr,
}
}
#[must_use]
pub fn compute_vacf(vel_snapshots: &[Vec<f64>], n: usize, dt_dump: f64, max_lag: usize) -> Vacf {
let n_frames = vel_snapshots.len();
let n_lag = max_lag.min(n_frames);
let mut c_values = vec![0.0f64; n_lag];
let mut counts = vec![0usize; n_lag];
for t0 in 0..n_frames {
for lag in 0..n_lag {
let t1 = t0 + lag;
if t1 >= n_frames {
break;
}
let v0 = &vel_snapshots[t0];
let v1 = &vel_snapshots[t1];
let mut dot_sum = 0.0;
for i in 0..n {
dot_sum += v0[i * 3 + 2].mul_add(
v1[i * 3 + 2],
v0[i * 3].mul_add(v1[i * 3], v0[i * 3 + 1] * v1[i * 3 + 1]),
);
}
c_values[lag] += dot_sum / n as f64;
counts[lag] += 1;
}
}
for i in 0..n_lag {
if counts[i] > 0 {
c_values[i] /= counts[i] as f64;
}
}
let c0 = c_values[0].max(1e-30);
let c_normalized: Vec<f64> = c_values.iter().map(|&c| c / c0).collect();
let mut integral = 0.0;
for i in 1..n_lag {
integral = (0.5 * (c_values[i - 1] + c_values[i])).mul_add(dt_dump, integral);
}
let diffusion_coeff = integral / 3.0;
let t_values: Vec<f64> = (0..n_lag).map(|i| i as f64 * dt_dump).collect();
Vacf {
t_values,
c_values: c_normalized,
diffusion_coeff,
}
}
#[must_use]
pub fn compute_ssf(
snapshots: &[Vec<f64>],
n: usize,
box_side: f64,
max_k_harmonics: usize,
) -> Vec<(f64, f64)> {
let dk = 2.0 * PI / box_side;
let _n_frames = snapshots.len(); let mut sk_values: Vec<(f64, f64)> = Vec::new();
for kn in 1..=max_k_harmonics {
let k_mag = kn as f64 * dk;
let mut sk_sum = 0.0;
let mut count = 0;
for snap in snapshots {
for axis in 0..3 {
let mut re = 0.0;
let mut im = 0.0;
for j in 0..n {
let r_component = snap[j * 3 + axis];
let phase = k_mag * r_component;
re += phase.cos();
im += phase.sin();
}
sk_sum += (re * re + im * im) / n as f64;
count += 1;
}
}
sk_values.push((k_mag, sk_sum / count as f64));
}
sk_values
}
#[derive(Clone, Debug)]
pub struct Msd {
pub t_values: Vec<f64>,
pub msd_values: Vec<f64>,
pub diffusion_coeff: f64,
}
#[must_use]
pub fn compute_msd(
snapshots: &[Vec<f64>],
n: usize,
box_side: f64,
dt: f64,
max_lag: usize,
) -> Msd {
let n_frames = snapshots.len();
let actual_max_lag = max_lag.min(n_frames - 1);
let mut t_values = Vec::with_capacity(actual_max_lag);
let mut msd_values = Vec::with_capacity(actual_max_lag);
let unwrapped = unwrap_positions(snapshots, n, box_side);
for lag in 1..=actual_max_lag {
let mut msd_sum = 0.0;
let mut count = 0;
for t0 in 0..(n_frames - lag) {
let t1 = t0 + lag;
for i in 0..n {
let dx = unwrapped[t1][i * 3] - unwrapped[t0][i * 3];
let dy = unwrapped[t1][i * 3 + 1] - unwrapped[t0][i * 3 + 1];
let dz = unwrapped[t1][i * 3 + 2] - unwrapped[t0][i * 3 + 2];
msd_sum += dz.mul_add(dz, dx.mul_add(dx, dy * dy));
count += 1;
}
}
let msd = msd_sum / count as f64;
t_values.push(lag as f64 * dt);
msd_values.push(msd);
}
let fit_start = (actual_max_lag * 3 / 4).max(1);
let diffusion_coeff = if fit_start < actual_max_lag {
let t_fit: Vec<f64> = t_values[fit_start..].to_vec();
let msd_fit: Vec<f64> = msd_values[fit_start..].to_vec();
linear_fit_slope(&t_fit, &msd_fit) / 6.0
} else if let (Some(&msd), Some(&t)) = (msd_values.last(), t_values.last()) {
msd / (6.0 * t)
} else {
0.0
};
Msd {
t_values,
msd_values,
diffusion_coeff,
}
}
fn unwrap_positions(snapshots: &[Vec<f64>], n: usize, box_side: f64) -> Vec<Vec<f64>> {
if snapshots.is_empty() {
return Vec::new();
}
let mut unwrapped = Vec::with_capacity(snapshots.len());
unwrapped.push(snapshots[0].clone());
let mut image_counts = vec![[0i32; 3]; n];
for frame_idx in 1..snapshots.len() {
let prev = &unwrapped[frame_idx - 1];
let curr = &snapshots[frame_idx];
let mut unwrapped_frame = Vec::with_capacity(n * 3);
for i in 0..n {
for d in 0..3 {
let r_prev = prev[i * 3 + d];
let r_curr = curr[i * 3 + d];
let delta = r_curr - (image_counts[i][d] as f64).mul_add(-box_side, r_prev);
if delta > box_side / 2.0 {
image_counts[i][d] -= 1;
} else if delta < -box_side / 2.0 {
image_counts[i][d] += 1;
}
unwrapped_frame.push((image_counts[i][d] as f64).mul_add(box_side, r_curr));
}
}
unwrapped.push(unwrapped_frame);
}
unwrapped
}
fn linear_fit_slope(x: &[f64], y: &[f64]) -> f64 {
if x.len() < 2 {
return 0.0;
}
let n = x.len() as f64;
let sum_x: f64 = x.iter().sum();
let sum_y: f64 = y.iter().sum();
let sum_xy: f64 = x.iter().zip(y.iter()).map(|(xi, yi)| xi * yi).sum();
let sum_x2: f64 = x.iter().map(|xi| xi * xi).sum();
let denom = n.mul_add(sum_x2, -(sum_x * sum_x));
if denom.abs() < 1e-30 {
return 0.0;
}
n.mul_add(sum_xy, -(sum_x * sum_y)) / denom
}
#[must_use]
pub fn validate_energy(
energies: &[(usize, f64, f64, f64)],
skip_fraction: f64,
) -> EnergyValidation {
if energies.is_empty() {
return EnergyValidation {
mean_total: 0.0,
std_total: 0.0,
drift_pct: 0.0,
mean_temperature: 0.0,
std_temperature: 0.0,
passed: false,
};
}
let skip = ((energies.len() as f64) * skip_fraction) as usize;
let stable: Vec<_> = energies.iter().skip(skip).collect();
if stable.is_empty() {
return EnergyValidation {
mean_total: 0.0,
std_total: 0.0,
drift_pct: 0.0,
mean_temperature: 0.0,
std_temperature: 0.0,
passed: false,
};
}
let totals: Vec<f64> = stable.iter().map(|e| e.3).collect();
let mean_e: f64 = totals.iter().sum::<f64>() / totals.len() as f64;
let var_e: f64 = totals.iter().map(|e| (e - mean_e).powi(2)).sum::<f64>() / totals.len() as f64;
let std_e = var_e.sqrt();
let e_initial = stable[0].3;
let e_final = stable[stable.len() - 1].3;
let drift_pct = if mean_e.abs() > 1e-30 {
((e_final - e_initial) / mean_e.abs()).abs() * 100.0
} else {
0.0
};
let passed = drift_pct < 5.0;
EnergyValidation {
mean_total: mean_e,
std_total: std_e,
drift_pct,
mean_temperature: 0.0, std_temperature: 0.0,
passed,
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_msd_ballistic_motion() {
let n = 2;
let box_side = 100.0; let dt = 0.1;
let velocity = 1.0;
let n_frames = 50;
let mut snapshots = Vec::with_capacity(n_frames);
for frame in 0..n_frames {
let t = frame as f64 * dt;
snapshots.push(vec![
t * velocity, 0.0, 0.0, -t * velocity, 0.0, 0.0, ]);
}
let msd = compute_msd(&snapshots, n, box_side, dt, 20);
assert!(!msd.msd_values.is_empty());
assert_eq!(msd.msd_values.len(), 20);
let msd_early = msd.msd_values[4]; let msd_late = msd.msd_values[9]; let ratio = msd_late / msd_early;
assert!((ratio - 4.0).abs() < 0.1, "Ballistic MSD ratio: {ratio}");
}
#[test]
fn test_msd_diffusive_motion() {
let n = 1;
let box_side = 1000.0;
let dt = 1.0;
let n_frames = 100;
let mut snapshots = Vec::with_capacity(n_frames);
let step_size = 0.5;
let mut x = 0.0;
let mut y = 0.0;
let mut z = 0.0;
#[expect(clippy::approx_constant, reason = "physics constant")]
let (mult_phi, mult_e) = (1.618, 2.718);
for frame in 0..n_frames {
snapshots.push(vec![x, y, z]);
let angle1 = (frame as f64 * mult_phi) % (2.0 * PI);
let angle2 = (frame as f64 * mult_e) % PI;
x = (step_size * angle2.sin()).mul_add(angle1.cos(), x);
y = (step_size * angle2.sin()).mul_add(angle1.sin(), y);
z += step_size * angle2.cos();
}
let msd = compute_msd(&snapshots, n, box_side, dt, 50);
assert!(!msd.msd_values.is_empty());
assert!(msd.msd_values[0] > 0.0);
assert!(msd.diffusion_coeff >= 0.0);
}
#[test]
fn test_msd_pbc_unwrapping() {
let n = 1;
let box_side = 10.0;
let dt = 1.0;
let snapshots = vec![
vec![9.0, 0.0, 0.0], vec![1.0, 0.0, 0.0], vec![3.0, 0.0, 0.0], ];
let msd = compute_msd(&snapshots, n, box_side, dt, 2);
assert!(msd.msd_values.len() == 2);
assert!(
(msd.msd_values[0] - 4.0).abs() < 0.5,
"MSD[0] = {}",
msd.msd_values[0]
);
assert!(
(msd.msd_values[1] - 16.0).abs() < 0.5,
"MSD[1] = {}",
msd.msd_values[1]
);
}
#[test]
fn test_linear_fit_slope() {
let x = vec![1.0, 2.0, 3.0, 4.0, 5.0];
let y = vec![2.0, 4.0, 6.0, 8.0, 10.0];
let slope = linear_fit_slope(&x, &y);
assert!((slope - 2.0).abs() < 1e-10);
}
}