bentopy 0.2.0a10__cp313-cp313-manylinux_2_34_x86_64.whl

bentopy-0.2.0a10.dist-info/METADATA

@@ -0,0 +1,358 @@
+Metadata-Version: 2.4
+Name: bentopy
+Version: 0.2.0a10
+Summary: Packs stuff in boxes
+Author-email: Marieke Westendorp <ma3ke.cyber@gmail.com>, Jan Stevens <j.a.stevens@rug.nl>, Bart Bruininks <bartbruininks@gmail.com>
+Project-URL: Homepage, https://github.com/marrink-lab/bentopy
+Project-URL: Issues, https://github.com/marrink-lab/bentopy/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: numpy>=2.2.3
+Requires-Dist: scipy>=1.15
+Requires-Dist: freud-analysis>=3.2.0
+Requires-Dist: MDAnalysis>=2.8
+Requires-Dist: mdvcontainment>=2.0.0a1
+Dynamic: license-file
+
+# _bentopy_&mdash;packs stuff in boxes
+
+![Bentopy](figures/logo_header.png)
+
+Bentopy packs molecules to assemble models for molecular dynamics simulations.
+It uses a voxel-based approach to place molecules into arbitrary geometries,
+handling systems from simple boxes to cellular-scale models. Additional tools
+provide efficient solvation and ion placement. Bentopy is force-field agnostic
+and integrates with existing molecular dynamics workflows. Example systems
+built with bentopy include entire cell models in the Martini force field and
+all-atom aerosols.
+
+- Build models at vast scales, quickly.
+- Powerful and flexible integration of spatial information.
+- Works with any forcefield, from Martini to all-atom.
+
+## Information
+
+A number of resources explaining how to build systems using bentopy are
+available.
+
+- The [_bentopy_ wiki][wiki] gives in-depth descriptions of different commands
+  and concepts.
+	- This includes [Examples][wiki-examples] of how different _bentopy_
+	  tools can be used to construct simple and more sophisticated systems.
+- Martini Workshop 2025: [Bentopy: from simple packing to building cellular
+  models][workshop], an in-depth tutorial. (Note that its current state is
+  outdated, and relies on _bentopy_ v0.1.0. An updated tutorial is in progress
+  and will soon be published.)
+
+[wiki]: https://github.com/marrink-lab/bentopy/wiki
+[wiki-examples]: https://github.com/marrink-lab/bentopy/wiki/Examples
+[workshop]: https://cgmartini.nl/docs/tutorials/Martini3/Bentopy
+
+## Citation
+
+If you use bentopy to set up your molecular dynamics system in a publication, please cite our work.
+
+<!-- TODO: Apa style citation with doi link. -->
+
+> Westendorp, M.S.S, Stevens, J.A. et al. Bentopy: building molecular dynamics simulations with cellular complexity and scale. _In preparation._
+
+<!-- TODO: Fill when paper is going to print.
+
+```
+@article{...}
+```
+
+-->
+
+## Installation
+
+_Bentopy_ can be installed through `pip`.
+
+```console
+pip install bentopy
+```
+
+For most Linux platforms, pre-built binaries are available and will be
+installed automatically through `pip`. For other platforms, such as macOS, a
+Rust compiler is required. See the [detailed installation
+instructions](#detailed-installation-instructions) below.
+
+## The _bentopy_ tools
+
+_Bentopy_ currently features five subcommands:
+
+- [_init_](#init): Initialize and validate bentopy input files.
+- [_mask_](#mask): Create masks based on voxel containments.
+- [_pack_](#pack): Pack a space and produce a placement list.
+- [_render_](#render): Write a structure file and topology based on a placement list.
+- [_solvate_](#solvate): Solvate large models, including very fast ion substitution.
+- [_merge_](#merge): Merge structure files.
+
+Each subcommand has detailed `--help` information.
+
+### Workflow
+
+A typical _bentopy_ workflow may look like this.
+
+![bentopy-merge -> bentopy-mask -> bentopy-pack -> bentopy-render -> bentopy-merge -> bentopy-solvate](figures/bentopy_workflow.png)
+
+The _init_ and _mask_ tools help prepare the configuration and masks for
+packing. Based on the input configuration and masks, _pack_ will create a
+placement list. Using _render_, you can create a structure file and system
+topology from the placement list. The _merge_ and _solvate_ tools help you
+prepare the model for simulation.
+
+What follows is a brief explanation and example invocation of these
+subcommands. A more detailed walkthrough can be found in the
+[Examples][wiki-examples] on the wiki.
+
+### Pre-processing
+
+#### _init_
+
+The _init_ subcommand serves to make setting up a new _bentopy_ project easy.
+It can be used to create an [example configuration file][example] with
+placeholder values or to validate input files.
+
+[example]: https://github.com/marrink-lab/bentopy/blob/main/src/init/example.bent
+
+```console
+bentopy-init example -o input.bent
+```
+
+Read more about the [_init_ command](https://github.com/marrink-lab/bentopy/wiki/bentopy-init).
+
+#### _mask_
+
+While simple shapes can be defined directly in a `bent` file, **space masks**
+enable you to capture the complex geometries of curved membranes and large
+complexes. This allows you to create models based on existing structures or
+empirical evidence, making sophisticated integrative modeling workflows
+possible.
+
+The _mask_ subcommand offers a powerful tool for creating these masks. It is
+built on top of a versatile library for segmenting point clouds and molecular
+structures, called [mdvcontainment][mdvc].
+
+With _mask_ you can take a structure or point cloud and determine the different
+compartments within it.
+
+```console
+bentopy-mask membrane.gro masks/inside.npz --autofill
+```
+
+_Determine the compartments contained by the structure in `membrane.gro` and
+automatically select the innermost compartment (`--autofill`). From that
+selected compartment, write a mask to `masks/inside.npz`._
+
+The masks created with `bentopy-mask` can be imported as a compartment in a
+`bent` file.
+
+```ini
+[ compartment ]
+cytoplasm from "masks/inside.npz"
+```
+
+Note that any boolean _numpy_ array [stored as a compressed file
+(`npz`)][numpy-npz] of the correct dimensions can function as a valid mask.
+This makes it possible to create custom scripts and techniques for preparing
+masks as well.
+
+### Packing the structure
+
+#### _pack_
+
+The _pack_ subcommand provides the core functionality of _bentopy_. Given an
+**input configuration file** (`bent`), the input structures will be packed and
+their positions and orientations are written to a **placement list**.
+
+```console
+bentopy-pack input.bent placements.json
+```
+
+The _placement list_ can be converted to a structure and associated topology
+using [_render_](#render).
+
+#### The `bent` input configuration file
+
+_On the wiki, a [detailed reference] for the `bent` configuration input file is
+available._
+
+This is a minimal but complete `bent` file.
+
+```ini
+[ general ]
+title "Lysozymes in a sphere"
+
+[ space ]
+dimensions 100, 100, 100
+resolution 0.5
+
+[ compartments ]
+ball as sphere at center with diameter 80
+
+[ segments ]
+3lyz 2000 from "structures/3lyz.pdb" in ball
+```
+
+Provided you have the structure file, this configuration can be used to create
+an 80 nm diameter sphere filled with lysozyme structures. This is a minimal
+version of the system described and explained in [Example 1: Simple
+sphere][wiki-example-1] on the wiki.
+
+[wiki-example-1]: https://github.com/marrink-lab/bentopy/wiki/Example-1:-Simple-sphere
+
+### Post-processing
+
+#### _render_
+
+The result of the packing process is stored as a **placement list**, which is a
+`json` file that describes _which structures_ at _what rotations_ are _placed
+where_. In order to create a structure file (and topology file) from this
+placement list, the _render_ subcommand can be used.
+
+```console
+bentopy-render placements.json structure.gro -t topol.top
+```
+
+_Render `placements.json` created by _pack_ to a `gro` file at `structure.gro`
+and write a topology file to `topol.top`._
+
+This is a separate operation from _packing_, since the packed systems can
+become very large. Storing the placement list as an intermediate result
+decouples the hard task of packing from the simple work of writing it into a
+structure file.
+
+#### _merge_
+
+As the name suggests, _merge_ is a tool for concatenating `gro` files. Though
+this is a relatively simple operation, _merge_ provides a convenient way of
+telling apart different sections of large models by optionally specifying a new
+residue name for a whole file in the argument list by appending
+`:<residue name>` to a file path.
+
+```console
+bentopy-merge chromosome.gro:CHROM membrane.gro:MEM -o chrom_mem.gro
+```
+
+_Concatenate `chromosome.gro` and `membrane.gro` into `chrom_mem.gro`, setting
+the residue names of the chromosome atoms to `CHROM` and those of the membrane
+to `MEM` in the concatenated structure._
+
+#### _solvate_
+
+With _solvate_, large boxes can be solvated quickly and conveniently, with
+one-step ion substitutions. _Solvate_ enables cellular-scale solvation and is
+designed to run very fast while having a low memory footprint. Both atomistic
+and coarse-grained Martini water placement is supported.
+
+```console
+bentopy-solvate -i packed.gro -o solvated.gro \
+	-s NA:0.15M -s CL:0.15M --charge 5172 \
+	--water-type tip3p
+```
+
+_Solvate the structure in `packed.gro` and output the result to `solvated.gro`.
+Substitute water residues for ions at 0.15M NaCl. Compensate the charge of
+`packed.gro` with 5172 additional Cl substitutions. Use Tip3P waters
+(atomistic)._
+
+A thorough description of the command is [provided in the `bentopy-solvate`
+README](src/solvate/README.md).
+
+## Why was _bentopy_ created?
+
+With _bentopy_, we address the lack of dedicated and generalized tools for
+packing detailed and MD-ready models while not sacrificing scale or
+efficiency.
+
+_Bentopy_ was created the goal of improving the workflow for building
+whole-cell models at the Marrink lab. While tools for preparing individual
+structures, polymers, and the cell membrane at that large scale were available,
+the procedure for packing the already crowded cytosol was slow and inflexible.
+As _bentopy_ was developed, it fulfilled this task excellently, and it quickly
+became clear that this is a tool that many people had their own creative
+applications for.
+
+Another problem with setting up large-scale molecular dynamics simulations is
+addressed by `bentopy-solvate`. Tools designed for boxes on the order of tens
+of nanometers start to break down at the mesoscale. With _solvate_, we
+introduce a well-considered and thoughtfully optimized tool. The improvement of
+the solvation stage for coarse-grained models has been excellent, but the
+improvement in performance and ergonomics is reported to be especially
+impressive for all-atom solvation.
+
+We want to thank the many fantastic researchers who are creating beautiful
+models with _bentopy_ for expressing their enthusiasm and providing hands-on
+feedback.
+
+## Detailed installation instructions
+
+If pre-built binaries are not available for your platform, you need access to
+`cargo`. First, you can check if Rust's build system `cargo` is installed.
+
+```console
+cargo --version
+```
+
+Make sure that this is at least `1.88`, the minimum supported rust version for
+this project. If this is not the case, update using `rustup update`.
+
+If `cargo` is not present, [you can install it][rust-installation] by any means
+you prefer. Installation through [_rustup_][rust-rustup] is very easy!
+
+Once `cargo` is installed, installing _bentopy_ using `pip` should work.
+
+### Install from source
+
+Installing bentopy from source gives you access to the very latest changes.
+Though the main branch of this project is generally stable, installation from
+releases is recommended.
+
+To install _bentopy_ from source, you need access to cargo, as described
+earlier. You can use `pip` directly to install the project right from the
+repository.
+
+```console
+pip install git+https://github.com/marrink-lab/bentopy
+```
+
+Alternatively, you can clone the repository somewhere, and build from there.
+
+```console
+git clone https://github.com/marrink-lab/bentopy
+cd bentopy
+pip install .
+```
+
+## License
+
+> Copyright 2024 Marieke S.S. Westendorp, Jan A. Stevens
+> 
+> Licensed under the Apache License, Version 2.0 (the "License");
+> you may not use this file except in compliance with the License.
+> You may obtain a copy of the License at
+> 
+> <http://www.apache.org/licenses/LICENSE-2.0>
+> 
+> Unless required by applicable law or agreed to in writing, software
+> distributed under the License is distributed on an "AS IS" BASIS,
+> WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+> See the License for the specific language governing permissions and
+> limitations under the License.
+
+[rust]: https://rust-lang.org/
+[rust-installation]: https://www.rust-lang.org/learn/get-started
+[rust-rustup]: https://rustup.rs/
+[numpy-npz]: https://numpy.org/doc/stable/reference/generated/numpy.savez.html
+[mdvc]: https://github.com/BartBruininks/mdvcontainment
+[gromacs-gro]: https://manual.gromacs.org/current/reference-manual/file-formats.html#gro
+[gromacs-top]: https://manual.gromacs.org/current/reference-manual/file-formats.html#top
+[gromacs-itp]: https://manual.gromacs.org/current/reference-manual/file-formats.html#itp
+[3lyz]: https://www.rcsb.org/structure/3LYZ
+[1ubq]: https://www.rcsb.org/structure/1UBQ
+[jq]: https://github.com/jqlang/jq
+[np-load]: https://numpy.org/doc/stable/reference/generated/numpy.load.html

bentopy-0.2.0a10.dist-info/RECORD

@@ -0,0 +1,58 @@
+bentopy-0.2.0a10.data/scripts/bentopy-init,sha256=lmW0W6U_Zm_PJ351j7HQ51kEkQwu0Fubkx1S9TTDHWA,4976544
+bentopy-0.2.0a10.data/scripts/bentopy-pack,sha256=NxXc_ofmFG0WGJsRrLp9p_lcJ3yoi8aSGQ3vgC3kWvk,6046680
+bentopy-0.2.0a10.data/scripts/bentopy-render,sha256=LgrLaPLoZJxihxEPHHKnqxCWNB5ss1ImH0dREUoHjC8,1778520
+bentopy-0.2.0a10.data/scripts/bentopy-solvate,sha256=5d3GC3SzNDd11Jeeg7N-TbwzO2v9_JZ9H0rEJ8C2yBI,1900736
+check/check.py,sha256=xbr4rL73t6gokB3sfZGpM-mCn6yccP2ew1HBMeBTen0,4510
+core/config.rs,sha256=UCldTCse3VrVyNm_chvC5nv83mDekRsLLNEuaCI-rME,8944
+core/mod.rs,sha256=D-P2C__zGtu275Zgsy9lv3iS2wpJThTkzg5U2RmtLUk,71
+core/placement.rs,sha256=R3Lo1wSrO6EWbIB7T38uin3XnddfYGwEFTCTrafU5CE,3082
+core/utilities.rs,sha256=PULJnA6hsGojkkse5GVTSZiftx5FQBoLVExMPy4TQhg,44
+core/version.rs,sha256=0aNOr-89Bj7Y3sEP3Ap4YyaiVPp9IdP23X4jdaFw8mE,883
+core/config/bent.rs,sha256=fwg3w7ibKcGN7Yf332O_V9xnPpVGlyfcm_kImn6H46Y,5220
+core/config/compartment_combinations.rs,sha256=d6scW7oaFwfkYXBS8rcESfd41LVWEUqaojAMSZSE-nQ,8940
+core/config/legacy.rs,sha256=I6yZf8AT0M6hCbCb1TPJPKYwY3rIim1Ws9NIu_vma3s,29719
+core/config/bent/lexer.rs,sha256=X629G3VOGlYWdi8NNZqxGq0Y_O5ORU7ETM17HzcH5zU,10118
+core/config/bent/parser.rs,sha256=wYW81KzMM037AZnbITkwTrzn6CVMIFCSyLPwKouIyaY,37563
+core/config/bent/writer.rs,sha256=T-DZpwrg_QbhVKd55FypbN0oID_7rdZyGvxUoMxw71o,5699
+init/example.bent,sha256=B6sGXAxDIZSc1OvFcXBGDf2YbZtOMsmY2gEf43lrbm8,2990
+init/main.rs,sha256=B-cJ-Apvz-eu53OCzuur9mXIhLC18UO_Ld-wRebR_Rw,8468
+mask/config.py,sha256=zf1lwGZ3G5btVNMlt4Ii4op2x_uyNNMtkdxJjt5wuIs,5410
+mask/mask.py,sha256=qLblYC7PT6E-RJw9dQcyhktsMMKZcM6Km1slsLPV-5k,12709
+mask/utilities.py,sha256=Yj8CAuUUZ34gUrbtQRIUf_bNKek_10_tI0V6In0UOtU,1192
+merge/merge.py,sha256=Kj83y99lrEYkxRnoQjT4zObN9NgKZCvlLEvKQpTe4WQ,5315
+pack/args.rs,sha256=gWb-eL5DgrAtt6rPoTrJTRl2ouCECg530qJEf7a7CMs,2775
+pack/main.rs,sha256=kdZ24eZ8cSPnZbojel5joufwqn8Fd0LI5Hv0_-2ywxE,4329
+pack/mask.rs,sha256=F2ePcar50lU3V4MA_uYWlXaJaemnprDelqsYbaUoaow,30883
+pack/session.rs,sha256=xELEdg_XjoqyeeNOV_EFRQDJiy5h6M5jjbtHaTQEutk,5874
+pack/state.rs,sha256=UkPsAX5LFzFPA84-UABTcubaU5KYg08GUe1FuhfhaW8,17134
+pack/structure.rs,sha256=ZeTO5zChlJCzmcSTfU7GV0CvLtSvRbfLG8UyNAM2e48,5760
+pack/voxelize.rs,sha256=JDHqYqcBKBH2l78ECL6R6spbvGSw4SDR8WNEX6umeMs,3426
+pack/state/combinations.rs,sha256=4FtCR9WHjkSPylRUOTV8Ob4waUHo2hUjOQhwWnNCBuY,1100
+pack/state/compartment.rs,sha256=W0IOaLFnWHJny1b83iknBO0yuoJevvSwZiMA8IgHevQ,1504
+pack/state/mask.rs,sha256=xykxkCKPy5D-Fk6Zgwp8lGzb2e8NydyyC8VgFV1NMc8,8150
+pack/state/pack.rs,sha256=l73gXqRethwh1RwXVTANv_OBIxvkIUhCy8UrcFfoasE,8108
+pack/state/segment.rs,sha256=yVrQJPVaH3xPKR_G3ZV6bOhwWEpLw19ChfNusaQMFfw,2653
+pack/state/space.rs,sha256=sexCSmJpgtgyOFEAEaXQrY-J1A2R-6s7fSMbSIRY8cI,3628
+render/args.rs,sha256=ZFBWeMdWJVbnJ_4rut94M4kcifEoiqua1x11HNj1N7U,3127
+render/limits.rs,sha256=Zgl4LitlkM5W_p3fZ0Y2s46bNletIXLMcU7umHxX1RI,2446
+render/main.rs,sha256=7CwMRRe2uh153v46DyDd0n8dhZmiKi8LthxvWN3XV7o,247
+render/render.rs,sha256=a4_orGwdsSTFcUEOsegdqdGdaY4w4GmeWJyJswWh20s,14545
+render/structure.rs,sha256=0hQFg5UypyhwLTYETCGvOvoAGldlnnq6jTklaW3ynBU,9419
+solvate/args.rs,sha256=5_usMAiLmf7Qx-yycf8dMeUOogkWRq639b-9J7RQKbw,10239
+solvate/convert.rs,sha256=Y_rNDGEcJutzQmjt7d7TyeqvlR3hgzi5QWI3YxMeyuI,818
+solvate/cookies.rs,sha256=TCcTJFZMhJNipl3JYoUb3MXGst1rihDvrp9EKcLjcls,7799
+solvate/main.rs,sha256=Zco_3VclT799kzZMLNXm9d_NKLCnte0E-CSgNv4-2FE,6018
+solvate/placement.rs,sha256=WOlOj8Lug5bp7w9mRrl3lTWK3MbMs4AD2F3EEnJQu0s,13004
+solvate/solvate.rs,sha256=jVtvV86AmVt1Z6S8gbxiHPA74OBazSNsMJIgQdGA4Jc,9440
+solvate/structure.rs,sha256=c1YBkQ35JGocGtm0ORpBUY5SKqeigYT7R44qCJVaI7Y,6355
+solvate/substitute.rs,sha256=AF0X0s1BComdYaKS41Tl05ri8iHelnoBjNke-0NyEsU,3590
+solvate/water.rs,sha256=ByAvd-Ncn0gMbclFoHx1wsUlSp1oTvZr_2qOxPyqgwI,3886
+solvate/water/martini.rs,sha256=lSsxaHKIKy8i-GnUkOdvGJHUN0dSoA_8bnXbLMazTBE,16206
+solvate/water/models.rs,sha256=-gvE0e8CC7g4WtMTAayeaafWwZdJoe511pzutYkfEuw,4119
+solvate/water/tip3p.rs,sha256=9q2egM4Fj72-k7yEjracJQmh9Qq1jFq_PKwjSWmHHNI,26207
+bentopy-0.2.0a10.dist-info/METADATA,sha256=kayGCEudoS4TXmAgiUy7Qt1EIDeEjgTcjPrK6d5yuTk,13165
+bentopy-0.2.0a10.dist-info/WHEEL,sha256=uhLz8SDHJs36mcQZMP4tcf-dNi5WGO0r_zqro-OTbpc,113
+bentopy-0.2.0a10.dist-info/entry_points.txt,sha256=3s9bQ1c4SHyXySu2dxhuMDzUQFFeZpBsDAp7m5DO-C4,114
+bentopy-0.2.0a10.dist-info/top_level.txt,sha256=92l6J9HF6NcudyfLgcpRRuB-bQ788BRK2uh5FUTNyoI,47
+bentopy-0.2.0a10.dist-info/RECORD,,
+bentopy-0.2.0a10.dist-info/licenses/LICENSE.txt,sha256=5QaaBeiP30jt8g3jaLTorMrcgoxG5MuK-FzuIqqnGSM,580

bentopy-0.2.0a10.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: false
+Tag: cp313-cp313-manylinux_2_34_x86_64
+

bentopy-0.2.0a10.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+bentopy-check = check:check.main
+bentopy-mask = mask:mask.main
+bentopy-merge = merge:merge.main

bentopy-0.2.0a10.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,13 @@
+Copyright 2024 Marieke S.S. Westendorp, Jan A. Stevens
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

bentopy-0.2.0a10.dist-info/top_level.txt

@@ -0,0 +1,8 @@
+check
+core
+init
+mask
+merge
+pack
+render
+solvate

check/check.py

@@ -0,0 +1,128 @@
+import argparse
+from pathlib import Path
+from time import time
+from sys import stderr
+
+import freud
+import MDAnalysis as mda
+import numpy as np
+
+def log(*args, **kwargs):
+    print(*args, **kwargs, file=stderr)
+
+
+def check(args):
+    # Read in structure.
+    structure_path = args.file
+    log(f"Reading in structure from {structure_path}... ", end="")
+    u = mda.Universe(structure_path)
+    log(f"done. (Read {u.atoms.n_atoms} atoms.)")
+
+    # Adjust the box for Freud and convert the cutoff distance.
+    box = mda_box_to_freud(u.dimensions)
+    cutoff_nm = args.cutoff
+    cutoff_A = cutoff_nm * 10.0  # Convert from nm to Å.
+
+    # Set up the locality query.
+    positions = u.atoms.positions
+    aq = freud.locality.AABBQuery(box, positions)
+    neighbors = aq.query(positions, {"r_max": cutoff_A}).toNeighborList()
+    log(f"The AABB query was set up with a {cutoff_nm} nm cutoff.")
+
+    # Sift through the neighbors to find collisions.
+    collision = False
+    min_distance = None
+    collisions = [] if args.output_collisions else None
+    try:
+        for id, hit in neighbors:
+            a = u.atoms[id]
+            b = u.atoms[hit]
+            if a.resid != b.resid:
+                if args.ignore_same_resname and a.resname == b.resname:
+                    continue
+                collision = True
+                distance = np.linalg.norm(a.position - b.position) / 10.0  # From Å to nm.
+                new_low = min_distance is not None and min_distance > distance
+                if new_low or min_distance is None:
+                    min_distance = distance
+                print(
+                    f"Distance between atom {id:>6} and {hit:>6} (residue {a.resname} ({a.resid:>3}) and {b.resname} ({b.resid:>3})) is {distance:<6.3} <= {cutoff_nm} nm.",
+                    "(new smallest distance)" if new_low else "",
+                )
+                if collisions is not None:
+                    collisions.append(a.position )
+                if args.exit_early:
+                    break
+        log("Done.")
+    except KeyboardInterrupt:
+        log("Stopping the search.")
+
+    # If desired, write out a structure with beads at the collision sites.
+    if args.output_collisions is not None:
+        natoms = len(collisions)
+        if natoms > 0:
+            log(f"Writing {natoms} collision coordinates to {args.output_collisions}... ", end="")
+            start = time()
+            positions = np.array(collisions)
+            assert positions.shape == (natoms, 3)
+            # Create a new Universe. We need to set trajectory to True in order to add positions.
+            cu = mda.Universe.empty(natoms, trajectory=True)
+            cu.atoms.positions = positions
+            cu.dimensions = u.dimensions
+            cu.atoms.write(args.output_collisions)
+            duration = time() - start
+            log(f"Done in {duration:.3} s.")
+        else:
+            log("No collisions were found, so no need to write out coordinates.")
+
+    # Report whether we found any collisions through the error number.
+    return 1 if collision else 0
+
+
+def mda_box_to_freud(mda_box):
+    x, y, z, alpha, beta, gamma = mda_box.astype(np.float64)
+    cosa = np.cos(np.pi * alpha / 180)
+    cosb = np.cos(np.pi * beta / 180)
+    cosg = np.cos(np.pi * gamma / 180)
+    sing = np.sin(np.pi * gamma / 180)
+    zx = z * cosb
+    zy = z * (cosa - cosb * cosg) / sing
+    zz = np.sqrt(z**2 - zx**2 - zy**2)
+    matrix = np.array([[x, 0, 0], [y * cosg, y * sing, 0], [zx, zy, zz]])
+    return matrix.astype(np.float32).T
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Check for collisions in rendered structures.",
+    )
+    parser.add_argument("file", type=Path, help="File to check (a structure file).")
+    parser.add_argument(
+        "--cutoff",
+        type=float,
+        default=0.4,
+        help="Collision distance between beads in nm. (default: %(default)s nm)",
+    )
+    parser.add_argument(
+        "--output-collisions",
+        type=Path,
+        help="Write out a structure file with dummy beads at the collision sites.",
+    )
+    parser.add_argument(
+        "--ignore-same-resname",
+        action="store_true",
+        help="Ignore collisions between particles with the same residue name.",
+    )
+    parser.add_argument(
+        "-e",
+        "--exit-early",
+        action="store_true",
+        help="Exit early at the first collision.",
+    )
+
+    args = parser.parse_args()
+    return check(args)
+
+
+if __name__ == "__main__":
+    main()