mod kernel;
mod lattice;
mod point;
pub use point::{FieldSample, Patch, SesField};
pub(crate) use kernel::{Engine, ScratchPool};
pub(crate) use lattice::pack;
pub(crate) use point::{Feature, LocalCandidates, NearEval};
use crate::error::Result;
use crate::geom::Sphere;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
#[non_exhaustive]
pub enum SurfaceKind {
#[default]
Ses,
Sas,
Vdw,
}
impl SurfaceKind {
pub fn from_name(name: &str) -> Option<Self> {
match name.to_ascii_lowercase().as_str() {
"ses" => Some(Self::Ses),
"sas" => Some(Self::Sas),
"vdw" => Some(Self::Vdw),
_ => None,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
#[non_exhaustive]
pub enum SimdLevel {
#[default]
Auto,
Scalar,
Sse4_2,
Avx2,
Avx512,
Neon,
}
impl SimdLevel {
pub const ALL: [SimdLevel; 6] = [
SimdLevel::Auto,
SimdLevel::Scalar,
SimdLevel::Sse4_2,
SimdLevel::Avx2,
SimdLevel::Avx512,
SimdLevel::Neon,
];
pub fn name(self) -> &'static str {
match self {
Self::Auto => "auto",
Self::Scalar => "scalar",
Self::Sse4_2 => "sse4.2",
Self::Avx2 => "avx2",
Self::Avx512 => "avx512",
Self::Neon => "neon",
}
}
pub fn effective(self) -> Option<&'static str> {
kernel::effective_level_name(self)
}
pub fn from_name(name: &str) -> Option<Self> {
Self::ALL
.into_iter()
.find(|l| l.name().eq_ignore_ascii_case(name.trim()))
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub struct SamplingStats {
pub touched_bricks: usize,
pub surface_bricks: usize,
pub samples: usize,
pub inside_samples: usize,
pub simd: &'static str,
pub checksum: u64,
}
pub fn sample_surface_bricks(
spheres: &[Sphere],
probe_radius: f64,
kind: SurfaceKind,
spacing: f64,
brick_cells: usize,
simd: SimdLevel,
) -> Result<SamplingStats> {
let field = SesField::new(spheres, probe_radius, kind)?;
let engine = Engine::new(field, spacing, brick_cells, simd)?;
let (touched, bricks) = engine.surface_bricks()?;
let per_brick = engine.map_bricks(&bricks, |_, values| {
let inside = values.iter().filter(|v| **v < 0.0).count();
let hash = values.iter().fold(0xcbf2_9ce4_8422_2325u64, |h, v| {
(h ^ u64::from(v.to_bits())).wrapping_mul(0x100_0000_01b3)
});
(inside, hash)
});
let checksum = per_brick
.iter()
.fold(0u64, |h, &(_, b)| h.rotate_left(5) ^ b);
Ok(SamplingStats {
touched_bricks: touched,
surface_bricks: bricks.len(),
samples: bricks.len() * engine.samples_per_brick(),
inside_samples: per_brick.iter().map(|p| p.0).sum(),
simd: engine.simd_name(),
checksum,
})
}
#[cfg(test)]
mod tests;