bentopy 0.2.0a10__cp313-cp313-manylinux_2_34_x86_64.whl

pack/structure.rs

@@ -0,0 +1,185 @@
+use std::io::{BufRead, BufReader};
+use std::num::NonZeroUsize;
+
+use eightyseven::reader::{ParseList, ReadGro};
+use eightyseven::structure::{AtomName, AtomNum, ResName, ResNum};
+use eightyseven::writer::{WriteGro, format_atom_line};
+use glam::Vec3;
+
+pub type Atom = Vec3;
+
+/// Load a [`Structure`] from a structure file.
+///
+/// This function will return an error if the structure is empty. Downstream functions may assume
+/// that a [`Structure`] has at least one atom.
+pub fn load_molecule<P: AsRef<std::path::Path> + std::fmt::Debug>(
+    path: P,
+) -> anyhow::Result<Structure> {
+    use anyhow::{Context, bail};
+
+    let file = std::fs::File::open(&path)?;
+
+    let structure = match path.as_ref().extension().and_then(|s| s.to_str()) {
+        Some("gro") => Structure::read_from_file(file)
+            .with_context(|| format!("Failed to parse gro file {path:?}"))?,
+        Some("pdb") => Structure::read_from_pdb_file(file)
+            .with_context(|| format!("Failed to parse PDB file {path:?}"))?,
+        None | Some(_) => {
+            eprintln!("WARNING: Assuming {path:?} is a PDB file.");
+            Structure::read_from_pdb_file(file)
+                .with_context(|| format!("Failed to parse the file {path:?} as PDB"))?
+        }
+    };
+
+    if structure.natoms() == 0 {
+        bail!("Structure from {path:?} contains no atoms")
+    }
+
+    Ok(structure)
+}
+
+/// A structure type that stores its atoms as simple positions.
+///
+/// Invariant: A `Structure` is always centered, such that its geometric center lies at the origin.
+///
+/// Invariant: A `Structure` has at least one atom.
+pub struct Structure {
+    atoms: Vec<Atom>,
+}
+
+impl ReadGro<Atom> for Structure {
+    const PARSE_LIST: ParseList = ParseList {
+        resnum: false,
+        resname: false,
+        atomname: false,
+        atomnum: false,
+        position: true,
+        velocity: false,
+    };
+
+    fn build_atom(
+        _resnum: Option<ResNum>,
+        _resname: Option<ResName>,
+        _atomname: Option<AtomName>,
+        _atomnum: Option<AtomNum>,
+        position: Option<[f32; 3]>,
+        _velocity: Option<[f32; 3]>,
+    ) -> Atom {
+        // We can safely unwrap because this is the only value we expect.
+        Atom::from_array(position.unwrap())
+    }
+
+    fn build_structure(
+        _title: String,
+        atoms: Vec<Atom>,
+        _boxvecs: eightyseven::structure::BoxVecs,
+    ) -> Self {
+        let mut structure = Self { atoms };
+        structure.translate_to_center();
+        structure
+    }
+}
+
+#[non_exhaustive]
+#[derive(Debug)]
+pub enum ParsePdbError {
+    IOError(std::io::Error),
+    BadPositionValue {
+        err: std::num::ParseFloatError,
+        /// Line number.
+        ln: NonZeroUsize,
+    },
+}
+
+impl std::error::Error for ParsePdbError {}
+
+impl std::fmt::Display for ParsePdbError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::IOError(err) => write!(f, "IO error: {err}"),
+            Self::BadPositionValue { err, ln } => {
+                write!(f, "Could not parse record on line {ln}: {err}")
+            }
+        }
+    }
+}
+
+impl From<std::io::Error> for ParsePdbError {
+    fn from(err: std::io::Error) -> Self {
+        Self::IOError(err)
+    }
+}
+
+impl Structure {
+    pub fn read_from_pdb_file(file: std::fs::File) -> Result<Structure, ParsePdbError> {
+        let reader = BufReader::new(file);
+
+        let mut atoms = Vec::new();
+        for (ln, line) in reader.lines().enumerate() {
+            let line = line?;
+            if line.starts_with("ATOM") || line.starts_with("HETATM") {
+                let ln = NonZeroUsize::new(ln + 1).unwrap(); // We know ln + 1 >= 1 because ln >= 0.
+                let bad_position = |err| ParsePdbError::BadPositionValue { err, ln };
+                let x = line[30..38].trim().parse().map_err(bad_position)?;
+                let y = line[38..46].trim().parse().map_err(bad_position)?;
+                let z = line[46..54].trim().parse().map_err(bad_position)?;
+                let atom = Atom::new(x, y, z) / 10.0; // Convert from Å to nm.
+                atoms.push(atom);
+            }
+        }
+
+        let mut structure = Self { atoms };
+        structure.translate_to_center();
+        Ok(structure)
+    }
+
+    /// Translate this [`Structure`] such that it's geometric center lies at the origin.
+    fn translate_to_center(&mut self) {
+        // Invariant: A Structure has at least one atom.
+        let center = self.atoms().sum::<Atom>() / self.natoms() as f32;
+        for pos in &mut self.atoms {
+            *pos -= center;
+        }
+    }
+
+    /// Calculate the moment of inertia for this [`Structure`].
+    ///
+    /// Invariant: Assumes that the structure is centered.
+    ///
+    ///     I = Σ(m_i * r_i²)
+    pub fn moment_of_inertia(&self) -> f32 {
+        self.atoms().map(|atom| atom.length_squared()).sum()
+    }
+
+    /// Returns the radius of the point that is farthest from the structure geometric center.
+    ///
+    /// Invariant: Assumes that the structure is centered.
+    pub fn bounding_sphere(&self) -> f32 {
+        self.atoms()
+            .map(|atom| atom.length())
+            .max_by(f32::total_cmp)
+            .unwrap() // Invariant: A structure has at least one atom.
+    }
+}
+
+impl<'atoms> WriteGro<'atoms, Atom> for Structure {
+    fn title(&self) -> String {
+        "debug".to_string()
+    }
+
+    fn natoms(&self) -> usize {
+        self.atoms.len()
+    }
+
+    fn atoms(&'atoms self) -> impl Iterator<Item = &'atoms Atom> {
+        self.atoms.iter()
+    }
+
+    fn boxvecs(&self) -> String {
+        "400.0 400.0 400.0".to_string()
+    }
+
+    fn format_atom_line(atom: &Atom) -> String {
+        format_atom_line(1, "DUMMY", "DUMMY", 2, atom.to_array(), None)
+    }
+}

pack/voxelize.rs

@@ -0,0 +1,85 @@
+use eightyseven::writer::WriteGro;
+use glam::{U64Vec3, Vec3A};
+
+use crate::state::{Rotation, Voxels};
+use crate::structure::Structure;
+
+/// Returns whether a sphere intersects with an axis-aligned, unit-sized cube.
+#[inline(always)]
+fn overlap(cube_center: Vec3A, sphere_center: Vec3A, sphere_radius_squared: f32) -> bool {
+    let c = 0.5; // Half side-length of the cube.
+    let rsc = sphere_center - cube_center;
+    let l = Vec3A::max(rsc.abs() - c, Vec3A::ZERO);
+    let l_squared = l * l;
+    l_squared.element_sum() <= sphere_radius_squared
+}
+
+/// Conservatively voxelize a [`Structure`].
+///
+/// Invariant: A [`Structure`] has at least one atom.
+pub fn voxelize(structure: &Structure, rotation: Rotation, resolution: f32, radius: f32) -> Voxels {
+    // Extract and rotate the points from the structure.
+    // And make them aligned (Vec3A) to encourage vectorization as well.
+    let mut points: Box<[Vec3A]> = structure
+        .atoms()
+        .map(|&position| rotation.mul_vec3a(position.into()))
+        .collect();
+
+    // Invariant: A Structure has at least one atom.
+    let npoints = points.len();
+    assert!(npoints >= 1, "a Structure has at least one atom");
+
+    // Invariant: A Structure has at least one atom.
+    let min = points.iter().copied().reduce(|a, b| a.min(b)).unwrap();
+    // Subtract one bead radius such that the lower bounds are treated correctly.
+    let min = min - radius;
+    // Translate the points such that they are all above (0, 0, 0).
+    points.iter_mut().for_each(|p| *p -= min);
+    // Find the bounds of our voxel grid.
+    // Invariant: A Structure has at least one atom.
+    let max = points.iter().copied().reduce(|a, b| a.max(b)).unwrap();
+    let max = max + radius;
+
+    // Set up our voxels.
+    let dimensions = (max / resolution).ceil().as_u64vec3();
+    let mut voxels = Voxels::new(dimensions.to_array());
+
+    // Transform points according to the resolution.
+    let scaled_points = {
+        points.iter_mut().for_each(|p| *p /= resolution);
+        points
+    };
+    // Scale the radius for the resolution along with the points.
+    let scaled_radius = radius / resolution;
+    let scaled_radius_squared = scaled_radius.powi(2);
+
+    // Go through each point and set the voxels its sphere radius occupies.
+    for point in scaled_points {
+        let lower_bound = point - scaled_radius;
+        let upper_bound = point + scaled_radius;
+        debug_assert!(Vec3A::cmpgt(lower_bound + 1e-5, Vec3A::ZERO).all());
+        debug_assert!(Vec3A::cmplt(upper_bound - 1e-5, max / resolution).all());
+        let lower_bound = lower_bound.floor().as_u64vec3();
+        let upper_bound = upper_bound.ceil().as_u64vec3();
+
+        for z in lower_bound.z..upper_bound.z {
+            for y in lower_bound.y..upper_bound.y {
+                for x in lower_bound.x..upper_bound.x {
+                    let position = U64Vec3::new(x, y, z);
+                    let cube_center = Vec3A::from(position.as_vec3() + 0.5);
+                    if overlap(cube_center, point, scaled_radius_squared) {
+                        let idx = position.to_array();
+                        voxels.set(idx, true);
+                    }
+                }
+            }
+        }
+    }
+
+    // Invariant: A Structure has at least one atom.
+    debug_assert!(
+        voxels.any::<true>(),
+        "the produced voxel mask contains no occupied voxels, should be impossible"
+    );
+    voxels
+}

render/args.rs

@@ -0,0 +1,109 @@
+use std::{path::PathBuf, str::FromStr};
+
+use crate::limits::Limits;
+use clap::{Parser, ValueEnum};
+
+/// Render structures from a placement list into a gro file.
+///
+///
+/// Structures specified in the placement list are retrieved from their pdb or gro
+/// files and placed into a gro file according to their rotations and positions.
+#[derive(Debug, Parser)]
+#[command(about, version = bentopy::core::version::VERSION)]
+pub struct Args {
+    /// Path to the placement list.
+    ///
+    /// To read from stdin, pass "-".
+    pub input: PathBuf,
+
+    /// Output gro file path.
+    pub output: PathBuf,
+
+    /// Write a topology (.top) file.
+    #[arg(short, long)]
+    pub topol: Option<PathBuf>,
+
+    /// Root path for the structure paths.
+    ///
+    /// When set, this path will be prepended to any relative path pointing to a structure in the
+    /// placement list. Absolute paths are respected.
+    #[arg(long)]
+    pub root: Option<PathBuf>,
+
+    /// Granularity of the produced output.
+    #[arg(long, value_enum, default_value_t = Mode::Full, conflicts_with="topol")]
+    pub mode: Mode,
+
+    /// Write out a unique resnum for each segment instance, or use one grouped resnum for each
+    /// instance of a segment.
+    #[arg(long, value_enum, default_value_t)]
+    pub resnum_mode: ResnumMode,
+
+    /// Only render structures that have a position within a smaller cuboid.
+    ///
+    /// Arguments can be provided as a comma-separated array of 6 values. Each value can be a
+    /// number indicating a bound or a non-numerical value indicating an unset bound.
+    #[arg(long)]
+    pub limits: Option<Limits>,
+
+    /// Retain the residue names from the input structure.
+    #[arg(long)]
+    pub ignore_tags: bool,
+
+    /// Print additional information.
+    #[arg(short, long)]
+    pub verbose: bool,
+}
+
+#[derive(Debug, Default, Clone, ValueEnum)]
+pub enum Mode {
+    /// Output all atoms.
+    #[default]
+    Full,
+    /// Only the backbone atoms.
+    Backbone,
+    /// Only the alpha carbons.
+    Alpha,
+    /// One bead per residue.
+    Residue,
+    /// One bead per instance of a structure.
+    Instance,
+}
+
+impl FromStr for Mode {
+    type Err = ();
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(match s.to_lowercase().as_str() {
+            "full" => Self::Full,
+            "backbone" | "bb" => Self::Full,
+            "alpha" | "ca" | "a" => Self::Alpha,
+            "residue" | "res" => Self::Residue,
+            "instance" => Self::Instance,
+            _ => return Err(()),
+        })
+    }
+}
+
+#[derive(Debug, Default, Clone, ValueEnum)]
+pub enum ResnumMode {
+    /// Each segment instance has a unique residue number.
+    #[default]
+    Instance,
+    /// All instances of a segment have the same residue number.
+    Segment,
+    /// The residue number appear exactly as in the input structure.
+    Keep,
+}
+
+impl FromStr for ResnumMode {
+    type Err = ();
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(match s.to_lowercase().as_str() {
+            "instance" => Self::Instance,
+            "segment" => Self::Segment,
+            _ => return Err(()),
+        })
+    }
+}

render/limits.rs

@@ -0,0 +1,73 @@
+use std::str::FromStr;
+
+use glam::Vec3;
+
+#[derive(Debug, Default, Clone)]
+pub struct Limits {
+    pub minx: Option<f32>,
+    pub maxx: Option<f32>,
+    pub miny: Option<f32>,
+    pub maxy: Option<f32>,
+    pub minz: Option<f32>,
+    pub maxz: Option<f32>,
+}
+
+impl Limits {
+    pub fn is_inside(&self, point: impl Into<Vec3>) -> bool {
+        let point = point.into();
+        self.minx.is_none_or(|minx| minx <= point.x)
+            && self.miny.is_none_or(|miny| miny <= point.y)
+            && self.minz.is_none_or(|minz| minz <= point.z)
+            && self.maxx.is_none_or(|maxx| point.x <= maxx)
+            && self.maxy.is_none_or(|maxy| point.y <= maxy)
+            && self.maxz.is_none_or(|maxz| point.z <= maxz)
+    }
+
+    // NOTE: This implementation is slightly verbose, and could be shortened. But that is not
+    // necessary. This is not speed-critical and I'd rather keep it entirely clear what is
+    // going on.
+    /// Determine the appropriate box size based on the constraints posed by the [`Limits`].
+    pub fn box_size(&self, boxsize: Vec3) -> Vec3 {
+        // We bake the limits with the information from the original box size.
+        let baked_limits = Limits {
+            minx: Some(self.minx.unwrap_or(0.0)),
+            maxx: Some(self.maxx.unwrap_or(boxsize.x)),
+            miny: Some(self.miny.unwrap_or(0.0)),
+            maxy: Some(self.maxy.unwrap_or(boxsize.y)),
+            minz: Some(self.minz.unwrap_or(0.0)),
+            maxz: Some(self.maxz.unwrap_or(boxsize.z)),
+        };
+
+        // We can safely unwrap these, because we just initialized them as Some(f32).
+        Vec3::new(
+            baked_limits.maxx.unwrap() - baked_limits.minx.unwrap(),
+            baked_limits.maxy.unwrap() - baked_limits.miny.unwrap(),
+            baked_limits.maxz.unwrap() - baked_limits.minz.unwrap(),
+        )
+    }
+}
+
+impl FromStr for Limits {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let Ok([minx, maxx, miny, maxy, minz, maxz]): Result<[Option<f32>; 6], _> = s
+            .split(',')
+            .map(|v| v.trim().parse().ok())
+            .collect::<Vec<_>>()
+            .try_into()
+        else {
+            let n = s.split(',').count();
+            return Err(format!("expected 6 values, found {n}"));
+        };
+
+        Ok(Self {
+            minx,
+            maxx,
+            miny,
+            maxy,
+            minz,
+            maxz,
+        })
+    }
+}

render/main.rs

@@ -0,0 +1,12 @@
+//! Render a placement list to a gro file with speed.
+//!
+//! By Marieke Westendorp, 2024.
+//! <ma3ke.cyber@gmail.com>
+mod args;
+mod limits;
+mod render;
+mod structure;
+
+fn main() -> anyhow::Result<()> {
+    render::render(clap::Parser::parse())
+}