#[derive(Clone, Debug)]
pub struct VerletList {
r_cut: f64,
r_skin: f64,
r_list: f64,
box_dims: [f64; 3],
offsets: Vec<usize>,
neighbors: Vec<u32>,
positions_at_build: Vec<f64>,
n_particles: usize,
rebuild_count: u64,
}
impl VerletList {
#[must_use]
pub fn new(r_cut: f64, r_skin: f64, box_side: f64) -> Self {
Self::new_with_dims(r_cut, r_skin, [box_side; 3])
}
#[must_use]
pub fn new_with_dims(r_cut: f64, r_skin: f64, box_dims: [f64; 3]) -> Self {
Self {
r_cut,
r_skin,
r_list: r_cut + r_skin,
box_dims,
offsets: Vec::new(),
neighbors: Vec::new(),
positions_at_build: Vec::new(),
n_particles: 0,
rebuild_count: 0,
}
}
pub fn build(&mut self, positions: &[f64], n: usize) {
self.n_particles = n;
self.rebuild_count += 1;
self.positions_at_build = positions[..n * 3].to_vec();
self.offsets.clear();
self.offsets.reserve(n + 1);
self.neighbors.clear();
let r_list_sq = self.r_list * self.r_list;
for i in 0..n {
self.offsets.push(self.neighbors.len());
let xi = positions[i * 3];
let yi = positions[i * 3 + 1];
let zi = positions[i * 3 + 2];
for j in 0..n {
if i == j {
continue;
}
let dx = Self::min_image(positions[j * 3] - xi, self.box_dims[0]);
let dy = Self::min_image(positions[j * 3 + 1] - yi, self.box_dims[1]);
let dz = Self::min_image(positions[j * 3 + 2] - zi, self.box_dims[2]);
let r_sq = dz.mul_add(dz, dx.mul_add(dx, dy * dy));
if r_sq <= r_list_sq {
self.neighbors.push(j as u32);
}
}
}
self.offsets.push(self.neighbors.len());
}
#[must_use]
pub fn needs_rebuild(&self, current_positions: &[f64]) -> bool {
if self.positions_at_build.is_empty() {
return true;
}
let half_skin_sq = (self.r_skin / 2.0) * (self.r_skin / 2.0);
for i in 0..self.n_particles {
let dx = Self::min_image(
current_positions[i * 3] - self.positions_at_build[i * 3],
self.box_dims[0],
);
let dy = Self::min_image(
current_positions[i * 3 + 1] - self.positions_at_build[i * 3 + 1],
self.box_dims[1],
);
let dz = Self::min_image(
current_positions[i * 3 + 2] - self.positions_at_build[i * 3 + 2],
self.box_dims[2],
);
if dz.mul_add(dz, dx.mul_add(dx, dy * dy)) > half_skin_sq {
return true;
}
}
false
}
#[must_use]
pub fn neighbors_of(&self, i: usize) -> &[u32] {
if i >= self.n_particles {
return &[];
}
&self.neighbors[self.offsets[i]..self.offsets[i + 1]]
}
#[must_use]
pub fn neighbor_count(&self, i: usize) -> usize {
if i >= self.n_particles {
return 0;
}
self.offsets[i + 1] - self.offsets[i]
}
#[must_use]
pub fn total_pairs(&self) -> usize {
self.neighbors.len()
}
#[must_use]
pub fn avg_neighbors(&self) -> f64 {
if self.n_particles == 0 {
return 0.0;
}
self.neighbors.len() as f64 / self.n_particles as f64
}
#[must_use]
pub fn rebuild_count(&self) -> u64 {
self.rebuild_count
}
#[must_use]
pub fn r_cut(&self) -> f64 {
self.r_cut
}
#[must_use]
pub fn r_skin(&self) -> f64 {
self.r_skin
}
#[must_use]
pub fn neighbor_indices(&self) -> &[u32] {
&self.neighbors
}
#[must_use]
pub fn neighbor_offsets(&self) -> &[usize] {
&self.offsets
}
fn min_image(dx: f64, box_len: f64) -> f64 {
let mut d = dx;
if d > box_len * 0.5 {
d -= box_len;
} else if d < -box_len * 0.5 {
d += box_len;
}
d
}
}
#[cfg(test)]
mod tests {
use super::*;
fn make_grid_positions(n_per_dim: usize, spacing: f64) -> Vec<f64> {
let mut positions = Vec::new();
for iz in 0..n_per_dim {
for iy in 0..n_per_dim {
for ix in 0..n_per_dim {
positions.push((ix as f64).mul_add(spacing, 0.1));
positions.push((iy as f64).mul_add(spacing, 0.1));
positions.push((iz as f64).mul_add(spacing, 0.1));
}
}
}
positions
}
#[test]
fn two_particles_within_cutoff() {
let positions = vec![0.0, 0.0, 0.0, 1.0, 0.0, 0.0];
let mut vl = VerletList::new(1.5, 0.3, 10.0);
vl.build(&positions, 2);
assert_eq!(vl.neighbor_count(0), 1);
assert_eq!(vl.neighbors_of(0), &[1]);
assert_eq!(vl.neighbor_count(1), 1);
assert_eq!(vl.neighbors_of(1), &[0]);
}
#[test]
fn two_particles_outside_cutoff() {
let positions = vec![0.0, 0.0, 0.0, 3.0, 0.0, 0.0];
let mut vl = VerletList::new(1.5, 0.3, 10.0);
vl.build(&positions, 2);
assert_eq!(vl.neighbor_count(0), 0);
assert_eq!(vl.neighbor_count(1), 0);
}
#[test]
fn periodic_boundary_neighbors() {
let positions = vec![0.5, 5.0, 5.0, 9.5, 5.0, 5.0];
let mut vl = VerletList::new(1.5, 0.3, 10.0);
vl.build(&positions, 2);
assert_eq!(vl.neighbor_count(0), 1, "PBC should connect them");
}
#[test]
fn needs_rebuild_after_displacement() {
let positions = vec![1.0, 1.0, 1.0, 5.0, 5.0, 5.0];
let mut vl = VerletList::new(2.0, 0.4, 10.0);
vl.build(&positions, 2);
let moved_small = vec![1.05, 1.0, 1.0, 5.0, 5.0, 5.0];
assert!(!vl.needs_rebuild(&moved_small));
let moved_large = vec![1.5, 1.0, 1.0, 5.0, 5.0, 5.0];
assert!(vl.needs_rebuild(&moved_large));
}
#[test]
fn grid_neighbor_count() {
let positions = make_grid_positions(3, 1.0);
let n = 27;
let mut vl = VerletList::new(1.5, 0.3, 10.0);
vl.build(&positions, n);
assert!(vl.total_pairs() > 0);
assert!(vl.avg_neighbors() > 0.0);
}
#[test]
fn rebuild_count_increments() {
let positions = vec![1.0, 1.0, 1.0, 5.0, 5.0, 5.0];
let mut vl = VerletList::new(2.0, 0.4, 10.0);
assert_eq!(vl.rebuild_count(), 0);
vl.build(&positions, 2);
assert_eq!(vl.rebuild_count(), 1);
vl.build(&positions, 2);
assert_eq!(vl.rebuild_count(), 2);
}
#[test]
fn empty_list() {
let vl = VerletList::new(2.0, 0.4, 10.0);
assert_eq!(vl.total_pairs(), 0);
assert!(vl.needs_rebuild(&[]));
}
#[test]
fn out_of_bounds_particle() {
let vl = VerletList::new(2.0, 0.4, 10.0);
assert_eq!(vl.neighbor_count(999), 0);
assert!(vl.neighbors_of(999).is_empty());
}
}