bentopy 0.2.0a10__cp313-cp313-manylinux_2_34_x86_64.whl

mask/utilities.py

@@ -0,0 +1,38 @@
+from pathlib import Path
+
+import MDAnalysis as mda
+import numpy as np
+
+
+def voxels_to_gro(path: Path, arr, scale: float = 1.0, place_in_center: bool = True):
+    scale *= 10.0  # We go from Å to nm scale.
+    n_atoms = np.prod(arr.shape)
+
+    # Set up our output universe.
+    u = mda.Universe.empty(
+        n_atoms,
+        n_residues=n_atoms,
+        atom_resindex=range(n_atoms),
+        residue_segindex=[0] * n_atoms,
+        trajectory=True,
+    )
+
+    # Fill it up with an 3×n_atoms coordinate array.
+    indices = np.array(list(np.ndindex(arr.shape)))
+    u.atoms.positions = indices * scale
+
+    if place_in_center:
+        # Place the atoms in the _middle_ of their voxel, rather than at the voxel origin.
+        u.atoms.positions += scale / 2
+
+    # Derive the box size from the array shape.
+    box = np.array(arr.shape) * scale
+    u.dimensions = np.array([*box, 90, 90, 90], dtype=np.int32)
+
+    # Assign appropriate residue names. We want to distinguish between the
+    # different values we find in the array (the different compartments!).
+    names = [str(name) for name in arr.flatten()]
+    u.add_TopologyAttr("name", names)
+
+    # Write them!
+    u.atoms.write(path)

merge/merge.py

@@ -0,0 +1,175 @@
+import argparse
+from sys import stderr
+
+# This should be sufficient space to write the final natoms into.
+NATOMS_PLACEHOLDER = " " * 32
+RESNAME_MAX_LEN = 5
+
+
+class InputFile:
+    divider = ":"
+
+    def __init__(self, s: str):
+        if self.divider in s:
+            path, resname = s.split(self.divider)
+            if len(resname) > RESNAME_MAX_LEN:
+                raise ValueError(
+                    f"A resname cannot be longer than 5 characters, found '{resname}' with {len(resname)} characters"
+                )
+        else:
+            path = s
+            resname = None
+        self.file = argparse.FileType("r")(path)
+        self.resname = resname
+
+
+def eprint(*args, **kwargs):
+    """
+    Print to standard error.
+    """
+    print(*args, **kwargs, file=stderr)
+
+
+def guarantee_newline(line: str) -> str:
+    """
+    If the provided line does not have a trailing newline, yet, add it.
+    Otherwise leave it alone.
+
+    Note that this is an idempotent operation (i.e., ∀x f(x) = f(f(x))).
+    """
+    if line.endswith("\n"):
+        return line
+    else:
+        return line + "\n"
+
+
+def parse_boxvec(s: str) -> tuple[float]:
+    """
+    Parse a gro box vector line.
+    """
+    boxvec = [float(v) for v in s.split()]
+    nv = len(boxvec)
+    if nv == 3 or nv == 9:
+        return boxvec
+    raise ValueError(
+        f"Could not parse '{s}'. The box vector must have either 3 or 9 values, found {nv}."
+    )
+
+
+def merge(args):
+    output = args.output
+    if not output.seekable():
+        eprint("ERROR: Output into non-seekable files is currently not supported.")
+        return 1
+
+    # Write the title.
+    if args.title is not None:
+        output.write(guarantee_newline(args.title))
+
+    boxvecs = []
+    natoms_total = 0
+    natoms_location = None  # The location in output where the natoms are written.
+    # We know that there will be at least one file provided through args.
+    for input_file in args.files:
+        # TODO: Unpack this with a tuple in the for loop? How can we implement that for a custom class?
+        file = input_file.file
+        resname = input_file.resname
+
+        # Report on the file and if we replace the resnames.
+        if resname is None:
+            info = "Leaving resnames in place."
+        else:
+            assert (
+                len(resname) <= RESNAME_MAX_LEN
+            )  # Already verified during argument parsing.
+            info = f"Replacing resnames with '{resname}'."
+        eprint(f"Reading from {file.name}...", info)
+
+        next(file)  # Skip the title.
+
+        # Put in a natoms placeholder if this is the first file that is written.
+        if natoms_location is None:
+            natoms_location = output.tell()
+            output.write(NATOMS_PLACEHOLDER + "\n")
+
+        # Read the number of atoms that are in this file.
+        natoms = int(next(file).strip())
+
+        # Write that number of lines into the output file.
+        if resname is not None:
+            # Modify the resname for each atom.
+            padded_resname = f"{resname:<5}"
+            for _ in range(natoms):
+                line = next(file)
+                output.write(line[:5])
+                output.write(padded_resname)
+                output.write(line[10:])
+        else:
+            for _ in range(natoms):
+                output.write(next(file))
+
+        # Now that we have written the lines, we'll add them to our total.
+        natoms_total += natoms
+
+        # Parse the box vector and add it to our collection.
+        boxvec = parse_boxvec(next(file))
+        boxvecs.append(boxvec)
+
+    # TODO: Take into account args.box.
+    # Write out the final box vector.
+    final_boxvec = boxvecs[0]
+    output.write(" ".join([str(v) for v in final_boxvec]) + "\n")
+
+    # Finally, we go and seek back to the start, where we left our natoms placeholder.
+    # Let's replace that with the correct total number of atom records we wrote to output.
+    output.seek(natoms_location)
+    output.write(str(natoms_total))
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Concatenate gro files.",
+    )
+
+    parser.add_argument(
+        "files",
+        type=InputFile,
+        nargs="+",
+        help="""Files to concatenate (gro; <path>[:<resname>]). 
+
+        Optionally, a residue name can be set for all atoms in a file by 
+        appending a colon followed by the residue name. 
+        Note that this name can be at most 5 characters long. 
+
+        Replacing the residue names can be very useful in distinguishing between 
+        parts of very large systems within a concatenated file.""",
+    )
+    parser.add_argument(
+        "-o",
+        "--output",
+        type=argparse.FileType("w"),
+        required=True,
+        help="Output path.",
+    )
+    parser.add_argument(
+        "-t",
+        "--title",
+        type=str,
+        default="bentopy merge",
+        help="Set the final title. (default: %(default)s)",
+    )
+    parser.add_argument(
+        "-b",
+        "--box",
+        type=parse_boxvec,
+        help="""Set the final box vectors. 
+        Expects a valid gro box line, which is a space-separated list of either 3 or 9 floats. 
+        By default, the box vector of the first file is chosen.""",
+    )
+
+    args = parser.parse_args()
+    merge(args)
+
+
+if __name__ == "__main__":
+    main()

pack/args.rs

@@ -0,0 +1,77 @@
+use std::path::PathBuf;
+
+use clap::{Parser, ValueEnum};
+
+/// Pack a space.
+#[derive(Debug, Parser)]
+#[command(version = bentopy::core::version::VERSION)]
+pub struct Args {
+    // Configuration input file to define the run (bent).
+    pub config: PathBuf,
+
+    // Placement list output file (json).
+    pub output: PathBuf,
+
+    /// Sort the input structures by approximate size to optimize packing.
+    ///
+    /// Different heuristics are available.
+    #[arg(long, default_value = "moment")]
+    pub rearrange: RearrangeMethod,
+
+    /// Random number generator seed.
+    #[arg(long)]
+    pub seed: Option<u64>,
+
+    /// Set the bead radius that is considered during voxelization in nm.
+    ///
+    /// If set, this value overwrites any value provided in the input file.
+    /// If this value is not provided in the input file, the default value is 0.20 nm.
+    #[arg(long)]
+    pub bead_radius: Option<f64>,
+
+    /// Set the multiplier for determining the maximum number of tries for placing a segment.
+    ///
+    /// The number of segments requested is multiplied with this value to set the upper limit on
+    /// how many unsuccessful attempts will be made to place it.
+    ///
+    /// Setting a higher value will result in more attempts, which can help improve the total
+    /// number of segments packed in very dense systems.
+    ///
+    /// If set, this value overwrites any value provided in the input file.
+    /// If this value is not provided in the input file, the default value is 1000.
+    #[arg(long)]
+    pub max_tries_mult: Option<u64>,
+
+    /// Set the divisor for determining the maximum number of tries for placing a segment per
+    /// rotation.
+    ///
+    /// This is a rather advanced option, and it is unlikely that it requires tweaking.
+    ///
+    /// The maximum number of attempts (see `--max-tries-mult`) is divided by this divisor value to
+    /// determine the number of unsuccessful attempts that are allowed for a given rotation. After
+    /// this number of unsuccessful tries, the next random rotation will be tried.
+    ///
+    /// If set, this value overwrites any value provided in the input file.
+    /// If this value is not provided in the input file, the default value is 100.
+    #[arg(long)]
+    pub max_tries_rot_div: Option<u64>,
+
+    /// Disable printing the summary after the placement procedure.
+    #[arg(long)]
+    pub no_summary: bool,
+
+    /// Display verbose output.
+    #[arg(short, long)]
+    pub verbose: bool,
+}
+
+#[derive(Debug, Clone, ValueEnum)]
+pub enum RearrangeMethod {
+    /// Use the geometric moment (sum of squared distances from geometric center).
+    #[value(alias = "moment-of-inertia")]
+    Moment,
+    Volume,
+    BoundingSphere,
+    /// Keep the arrangement specified in the input file.
+    None,
+}

pack/main.rs

@@ -0,0 +1,121 @@
+use std::io::{self, Read};
+
+use anyhow::{Context, bail};
+use args::Args;
+use ariadne::{Color, Fmt};
+use clap::Parser;
+
+use bentopy::core::config::{Config, bent};
+use bentopy::core::utilities::CLEAR_LINE;
+use state::State;
+
+mod args;
+mod mask;
+mod session;
+mod state;
+mod structure;
+mod voxelize;
+
+type Location = usize;
+
+struct Summary {
+    entries: Vec<(String, usize, usize, f64)>,
+}
+
+impl Summary {
+    fn new() -> Self {
+        Self {
+            entries: Vec::new(),
+        }
+    }
+
+    fn push(&mut self, name: String, target: usize, placed: usize, time: f64) {
+        self.entries.push((name, target, placed, time))
+    }
+
+    fn present(&self, packing_duration: f64) {
+        fn percentage(hits: usize, target: usize) -> f32 {
+            match target {
+                0 => 0.0,
+                _ => (hits as f32 / target as f32) * 100.0,
+            }
+        }
+
+        println!("idx \tname      \t   ok%\ttarget\tplaced\ttime (s)\tremark");
+        println!("----\t----------\t------\t------\t------\t--------\t------");
+        let mut target_tot = 0;
+        let mut hits_tot = 0;
+        for (i, (name, target, hits, duration)) in self.entries.iter().enumerate() {
+            let perc = percentage(*hits, *target);
+            let ok = if hits == target { " " } else { "<" };
+            println!(
+                "{i:>4}\t{name:<10}\t{perc:>5.1}%\t{target:>6}\t{hits:>6}\t{duration:8.2}\t{ok}"
+            );
+            target_tot += target;
+            hits_tot += hits;
+        }
+        let perc = percentage(hits_tot, target_tot);
+        let ok = if hits_tot == target_tot { " " } else { "<" };
+        println!(
+            "    \t          \t{perc:>5.1}%\t{target_tot:>6}\t{hits_tot:>6}\t{packing_duration:8.2}\t{ok}"
+        )
+    }
+}
+
+fn main() -> anyhow::Result<()> {
+    // Preparation.
+    let args = Args::parse();
+    let mut state = {
+        let config_path = &args.config;
+        if config_path.extension().is_some_and(|ext| ext == "json") {
+            eprintln!("NOTE: Legacy bentopy input files can be converted to .bent files:");
+            let old_path = config_path.to_str().unwrap().fg(Color::Yellow);
+            let bent_path = config_path.with_extension("bent");
+            let bent_path = bent_path.to_str().unwrap().fg(Color::Cyan);
+            eprintln!("You can convert {old_path} to a bent file using the following command:");
+            eprintln!();
+            eprintln!("\tbentopy-init convert -i {old_path} -o {bent_path}");
+            eprintln!();
+            bail!("Legacy .json bentopy input files are deprecated")
+        }
+        let mut file = std::fs::File::open(config_path)
+            .with_context(|| format!("Failed to open the configuration file {config_path:?}"))?;
+        let mut buf = String::new();
+        file.read_to_string(&mut buf)?;
+        let config: Config = bent::parse_config(config_path.to_str().unwrap(), &buf)
+            .with_context(|| format!("Failed to process configuration from {config_path:?}"))?;
+
+        State::new(args, config).context("Failed to set up program state")?
+    };
+
+    // Check whether the compartment masks make any sense.
+    state
+        .check_masks()
+        .context("Encountered a problem while checking the compartment masks")?;
+
+    // Packing.
+    let packing_start = std::time::Instant::now();
+    let (placements, summary) = state
+        .pack(&mut io::stderr())
+        .context("Encountered a problem while packing")?;
+    let packing_duration = packing_start.elapsed().as_secs_f64();
+    eprintln!("Packing process took {packing_duration:.3} s.");
+
+    // Final summary.
+    if state.summary {
+        summary.present(packing_duration);
+    }
+
+    // Output.
+    let placement_list_path = &state.output.path;
+    eprint!("Writing placement list to {placement_list_path:?}... ");
+    let start_output = std::time::Instant::now();
+    let placement_list_file = std::fs::File::create(placement_list_path)
+        .with_context(|| format!("Failed to create placement list file {placement_list_path:?}"))?;
+    let placement_list = state.placement_list(placements);
+    serde_json::to_writer(placement_list_file, &placement_list)
+        .context("Encountered a problem while writing the placement list")?;
+    eprintln!("Done in {:.3} s.", start_output.elapsed().as_secs_f64());
+
+    Ok(())
+}