eightyseven—read and write gro files, pretty quickly


I just released version 0.1.1 of eightyseven, a library for reading and writing gro files.

A gro file (Gromos871) describes molecular structures in a plain-text format. (See the Gromacs manual or the old pretty manual.)

For now, only reading and writing of the classic fixed format is supported. The additional precision reading mode is on the agenda.

eightyseven can format the atoms section of a gro file in a parallel fashion, with WriteGro::write_par and related methods.

This library comes with its own Structure type, which mirrors the information that is stored in gro files. For Structure, the ReadGro, WriteGro, and WriteGroPar traits are implemented. The reading and writing functionality provided by these traits are provided as good default implementations, which rely on a couple of easy to implement bridging functions. This makes implementing the traits for custom types very easy.

Moreover, rather specialized readers that read only a subset of the atom line fields can be implemented easily and efficiently by setting the flags of the ReadGro::PARSE_LIST constant.

I don’t know whether I’m very keen on this way of configuring subset readers, but it does work. For now, I think that this is a good way of setting this behaviour in a way that there is zero overhead to the branches, since they will get compiled away.

As of writing, using the library looks something like this.

use eightyseven::structure::Structure;

// Read the structure from a file.
use eightyseven::reader::ReadGro;
let mut structure = Structure::open_gro("tests/eq.gro")?;
println!(" title: {}", structure.title);
println!("natoms: {}", structure.natoms());

// Modify the structure.
// For example, center the structure such that the `BB` beads are centered.
let bb_positions = structure
    .filter(|&atom| atom.atomname.as_str() == "BB")
    .map(|atom| atom.position);
let bb_center = bb_positions.clone().sum::<glam::Vec3>() / bb_positions.count() as f32;

for atom in &mut structure.atoms {
    atom.position -= bb_center;

// And write the structure.
use eightyseven::writer::WriteGro;

// Or, for fast writing of large files, format the atom section in parallel.
use eightyseven::writer::WriteGroPar;

// For both single-threaded and parallel formatting, generic writers exist as well.
// They can write to any type that implements `io::Write`.
structure.write_par(&mut std::io::empty())?;

tests and benchmarks

Tests and benchmarks are included. Run them in the cloned repository.

$ git clone
$ cd eightyseven
$ cargo test
$ cargo bench

other tools for the Gromacs universe

I’ve written a nice little set of tools and libraries for the Gromacs universe now. They’re mostly just used by me, though molly has caught some interest from others.

I have written an xtc reader library as well, called molly. xtc is a compressed trajectory format for Gromacs.

The graphing data format that is output by Gromacs analysis commands is xvg. phrace is a terminal viewer for that data format.


The name is indeed based on this number, here. :)

By Marieke Westendorp, 2024.