Analysis plugins — GromacsWrapper 0.5.0-dev documentation

# Analysis plugins

Analysis plugins consist of a book-keeping class derived from `gromacs.analysis.core.Plugin` and a “worker” class (a child of `gromacs.analysis.core.Worker`), which contains the actual analysis code.

## Plugins

Plugin modules are named like the plugin class but the filename is all lower case. All plugin classes are available in the `gromacs.analysis.plugins` name space.

### `analysis.plugins` – Plugin Modules

Classes for `gromacs.analysis.core.Simulation` that provide code to analyze trajectory data.

New analysis plugins should follow the API sketched out in `gromacs.analysis.core`; see an example for use there.

#### List of plugins

Right now the number of plugins is limited. Feel free to contribute your own by sending it to the package author. You will be acknowledged in the list below.

Plugins for analysis.
plugin | author | description
--- | --- | ---
`CysAccessibility` | [1] | estimate accessibility of Cys residues by water
`HelixBundle` | [1] | g_bundle analysis of helices
`Distances` | [1] | time series of distances
`MinDistances` | [1] | time series of shortest distances
`COM` | [1] | time series of centres of mass
`Dihedrals` | [1] | analysis of dihedral angles
`RMSF` | [1] | calculate root mean square fluctuations
`RMSD` | [1] | calculate root mean square distance
`Energy` | [1] | terms from the energy file
`HBonds` | [1] | hydrogen bond analysis, in particular hydrogen bond existence

Plugins for trajectory manipulation and status queries.
plugin | author | description
--- | --- | ---
`Trajectories` | [1] | write xy-fitted trajectories
`FitCompact` | [1] | write fitted trajectories
`StripWater` | [1] | remove solvent (and optionally fit to reference)
:class:`ProteinOnly’ | [1] | remove all atoms except the Protein (and optionally fit to reference)
`Ls` | [1] | simple ls (for testing)

Footnotes

[1] | (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15) Oliver Beckstein <oliver.beckstein@asu.edu>

#### Plugin classes

class `gromacs.analysis.plugins.` `CysAccessibility`(name=None, simulation=None, **kwargs)

  CysAccessibility plugin.

  For each frame of a trajectory, the shortest distance of all water oxygens to all cysteine sulphur atoms is computed. For computational efficiency, only distances smaller than a cutoff are taken into account. A histogram of the distances shows how close water molecules can get to cysteines. The closest approach distance should be indicative of the reactivity of the SH group with crosslinking agents.

  class `CysAccessibility`(cysteines[, cys_cutoff[, name[, simulation]]])

  Arguments: | name : string plugin name (used to access it) simulation : instance The `gromacs.analysis.Simulation` instance that owns the plugin. cysteines : list list of all resids (eg from the sequence) that are used as labels or in the form ‘Cys<resid>’. (required) cys_cutoff : number cutoff in nm for the minimum S-OW distance [1.0]

  Note that all Cys residues in the protein are analyzed. Therefore, the list of cysteine labels must contain as many entries as there are cysteines in the protein. There are no sanity checks.

  Registers the plugin with the simulation class.

  Specific keyword arguments are listed below, all other kwargs are passed through.

  Arguments: | name : string Name of the plugin. Should differ for different instances. Defaults to the class name. simulation : Simulation instance The `Simulation` instance that owns this plugin instance. Can be `None` but then the `register()` method has to be called manually with a simulation instance later. kwargs All other keyword arguments are passed to the Worker.

  `CysAccessibility.` `worker_class`

    alias of `_CysAccessibility`

class `gromacs.analysis.plugins.` `HelixBundle`(name=None, simulation=None, **kwargs)

  HelixBundle plugin.

  `gromacs.g_bundle()` helix analysis

  class `HelixBundle`([helixtable, offset, with_kinks[, name[, simulation]]])

  Arguments: | helixtable reST table with columns “name”, “top”, “bottom”, “kink”; see `gromacs.analysis.plugins.helixbundle` for details offset add the offset to the residue numbers in helixtable [0] helixndx provide a index file with the appropriate groups instead of the table; also requires na na number of helices with_kinks take kinks into account [True] name plugin name [HelixBundle] simulation The `gromacs.analysis.Simulation` instance that owns the plugin. [None]

  Registers the plugin with the simulation class.

  Specific keyword arguments are listed below, all other kwargs are passed through.

  Arguments: | name : string Name of the plugin. Should differ for different instances. Defaults to the class name. simulation : Simulation instance The `Simulation` instance that owns this plugin instance. Can be `None` but then the `register()` method has to be called manually with a simulation instance later. kwargs All other keyword arguments are passed to the Worker.

  `HelixBundle.` `worker_class`

    alias of `_HelixBundle`

class `gromacs.analysis.plugins.` `Distances`(name=None, simulation=None, **kwargs)

  Distances plugin.

  The distance between the center of mass of two index groups are calculated for each time step and written to files.

  class `Distances`(groups, ndx[, cutoff[, name[, simulation]]])

  Arguments: | name : string plugin name (used to access it) simulation : instance The `gromacs.analysis.Simulation` instance that owns the plugin. groups : list of index group names The first entry is the primary group, the second is the *secondary group. ndx : index filename or list All index files that contain the listed groups. cutoff : float A contact is recorded if the distance is <cutoff [0.6 nm]

  Example:

  Generate index files with the groups of interest, for instance with `gromacs.cbook.IndexBuilder`:

      from gromacs.cbook import IndexBuilder
      A_grp, A_ndx = IndexBuilder(tpr, ['@a 62549 & r NA'], names=['Na1_ion'], offset=-9,
                                  out_ndx='Na1.ndx', name_all="Na1").combine()
      B = IndexBuilder(tpr, ['S312:OG','T313:OG1','A38:O','I41:O','A309:O'], offset=-9,
                            out_ndx='Na1_site.ndx', name_all="Na1_site")
      B_grp, B_ndx = B.combine()
      all_ndx_files = [A_ndx, B_ndx]

  To calculate the distance between “Na1” and the “Na1_site”, create an instance with the appropriate parameters and add them to a `gromacs.analysis.Simulation` instance:

      dist_Na1_site = Distances(name='Dsite', groups=['Na1', 'Na1_site'], ndx=all_ndx_files)
      S.add_plugin(dist_Na1_site)

  Registers the plugin with the simulation class.

  Specific keyword arguments are listed below, all other kwargs are passed through.

  Arguments: | name : string Name of the plugin. Should differ for different instances. Defaults to the class name. simulation : Simulation instance The `Simulation` instance that owns this plugin instance. Can be `None` but then the `register()` method has to be called manually with a simulation instance later. kwargs All other keyword arguments are passed to the Worker.

  `Distances.` `worker_class`

    alias of `_Distances`

class `gromacs.analysis.plugins.` `MinDistances`(name=None, simulation=None, **kwargs)

  MinDistances plugin.

  The minimum distances between the members of at least two index groups and the number of contacts are calculated for each time step and written to files.

  class `Distances`(groups, ndx[, cutoff[, name[, simulation]]])

  Arguments: | name : string plugin name (used to access it) simulation : instance The `gromacs.analysis.Simulation` instance that owns the plugin. groups : list of index group names The first entry is the primary group. All other entries are secondary groups and the plugin calculates the minimum distance between members of the primary group and the members of each secondary group. ndx : index filename or list All index files that contain the listed groups. cutoff : float A contact is recorded if the distance is <cutoff [0.6 nm]

  Example:

  Generate index files with the groups of interest, for instance with `gromacs.cbook.IndexBuilder`:

      from gromacs.cbook import IndexBuilder
      A_grp, A_ndx = IndexBuilder(tpr, ['@a 62549 & r NA'], names=['Na1_ion'], offset=-9,
                                  out_ndx='Na1.ndx', name_all="Na1").combine()
      B = IndexBuilder(tpr, ['S312:OG','T313:OG1','A38:O','I41:O','A309:O'], offset=-9,
                            out_ndx='Na1_site.ndx', name_all="Na1_site")
      B_grp, B_ndx = B.combine()
      all_ndx_files = [A_ndx, B_ndx]

  To calculate the distance between “Na1” and the “Na1_site”, create an instance with the appropriate parameters and add them to a `gromacs.analysis.Simulation` instance:

      dist_Na1_site = Distances(name='Dsite', groups=['Na1', 'Na1_site'], ndx=all_ndx_files)
      S.add_plugin(dist_Na1_site)

  To calculate the individual distances:

      dist_Na1_res = Distances(name='Dres', groups=['Na1']+B.names, ndx=all_ndx_files)
      S.add_plugin(dist_Na1_res)

  (Keeping the second IndexBuilder instance `B` allows us to directly use all groups without typing them, `B.names = ['A309_O', 'S312_OG', 'I41_O', 'T313_OG1', 'A38_O']`.)

  Registers the plugin with the simulation class.

  Specific keyword arguments are listed below, all other kwargs are passed through.

  Arguments: | name : string Name of the plugin. Should differ for different instances. Defaults to the class name. simulation : Simulation instance The `Simulation` instance that owns this plugin instance. Can be `None` but then the `register()` method has to be called manually with a simulation instance later. kwargs All other keyword arguments are passed to the Worker.

  `MinDistances.` `worker_class`

    alias of `_MinDistances`

class `gromacs.analysis.plugins.` `COM`(name=None, simulation=None, **kwargs)

  COM plugin.

  Calculate the centre of mass (COM) of various index groups.

  class `COM`(group_names[, ndx[, offset[, name[, simulation]]]])

  Registers the plugin with the simulation class.

  Specific keyword arguments are listed below, all other kwargs are passed through.

  Arguments: | name : string Name of the plugin. Should differ for different instances. Defaults to the class name. simulation : Simulation instance The `Simulation` instance that owns this plugin instance. Can be `None` but then the `register()` method has to be called manually with a simulation instance later. kwargs All other keyword arguments are passed to the Worker.

  `COM.` `worker_class`

    alias of `_COM`

class `gromacs.analysis.plugins.` `Dihedrals`(name=None, simulation=None, **kwargs)

  Dihedrals plugin.

  class `Dihedrals`(dihedrals[, labels[, name[, simulation]]])

  Keywords: | dihedrals list of tuples; each tuple contains atom indices that define the dihedral. labels optional list of labels for the dihedrals. Must have as many entries as dihedrals. name : string plugin name (used to access it) simulation : instance The `gromacs.analysis.Simulation` instance that owns the plugin.

  Registers the plugin with the simulation class.

  Specific keyword arguments are listed below, all other kwargs are passed through.

  Arguments: | name : string Name of the plugin. Should differ for different instances. Defaults to the class name. simulation : Simulation instance The `Simulation` instance that owns this plugin instance. Can be `None` but then the `register()` method has to be called manually with a simulation instance later. kwargs All other keyword arguments are passed to the Worker.

  `Dihedrals.` `worker_class`

    alias of `_Dihedrals`

class `gromacs.analysis.plugins.` `RMSF`(name=None, simulation=None, **kwargs)

  RMSF plugin.

  Compute the root mean square fluctuations (RMSF) of the C-alpha atoms. The trajectory is always fitted to the reference structure in the tpr file.

  class `RMSF`([name[, simulation]])

  Arguments: | name : string plugin name (used to access it) simulation : instance The `gromacs.analysis.Simulation` instance that owns the plugin.

  Registers the plugin with the simulation class.

  Specific keyword arguments are listed below, all other kwargs are passed through.

  Arguments: | name : string Name of the plugin. Should differ for different instances. Defaults to the class name. simulation : Simulation instance The `Simulation` instance that owns this plugin instance. Can be `None` but then the `register()` method has to be called manually with a simulation instance later. kwargs All other keyword arguments are passed to the Worker.

  `RMSF.` `worker_class`

    alias of `_RMSF`

class `gromacs.analysis.plugins.` `RMSD`(name=None, simulation=None, **kwargs)

  RMSD plugin.

  Calculation of the root mean square distance (RMSD) of a protein structure over the course of a MD simulation.

  The trajectory is always fitted to the reference structure in the tpr file.

  class `RMSD`([name[, simulation]])

  Arguments: | name : string plugin name (used to access it) simulation : instance The `gromacs.analysis.Simulation` instance that owns the plugin.

  Registers the plugin with the simulation class.

  Specific keyword arguments are listed below, all other kwargs are passed through.

  Arguments: | name : string Name of the plugin. Should differ for different instances. Defaults to the class name. simulation : Simulation instance The `Simulation` instance that owns this plugin instance. Can be `None` but then the `register()` method has to be called manually with a simulation instance later. kwargs All other keyword arguments are passed to the Worker.

  `RMSD.` `worker_class`

    alias of `_RMSD`

class `gromacs.analysis.plugins.` `Energy`(name=None, simulation=None, **kwargs)

  Energy plugin.

  Analysis of terms in the Gromacs energy (edr) file.

  class `Energy`([name[, simulation]])

    The following energy terms are extracted from the edr file:

    > - ‘Potential’
    > - ‘Kinetic-En.’
    > - ‘Total-Energy’
    > - ‘Temperature’
    > - ‘Pressure’
    > - ‘Volume’
    > - ‘Box-X’, ‘Box-Y’, ‘Box-Z’

  The list of terms corresponds to input values for `gromacs.g_energy()` and is defined in the attribute `_Energy.terms`.

  Arguments: | name : string plugin name (used to access it) simulation : instance The `gromacs.analysis.Simulation` instance that owns the plugin.

  Registers the plugin with the simulation class.

  Specific keyword arguments are listed below, all other kwargs are passed through.

  Arguments: | name : string Name of the plugin. Should differ for different instances. Defaults to the class name. simulation : Simulation instance The `Simulation` instance that owns this plugin instance. Can be `None` but then the `register()` method has to be called manually with a simulation instance later. kwargs All other keyword arguments are passed to the Worker.

  `Energy.` `worker_class`

    alias of `_Energy`

class `gromacs.analysis.plugins.` `HBonds`(name=None, simulation=None, **kwargs)

  HBonds plugin.

  Analysis of hydrogen bonds between two groups.

  Hydrogen bonds Donor-H...Acceptor are analyzed. Depending on the N_is_acceptor flag, nitrogens can be counted as donors and acceptors.

  class `HBonds`([group1, group2[, dmax, amax, ..., name[, simulation]]])

  Arguments: | group1 `gromacs.make_ndx()` selection string, e.g. ‘r 5FH’ [“Protein”] group2 `gromacs.make_ndx()` selection string, e.g. ‘“Protein”’ (note the double quotes) [“Protein”] dmax maximum length of an hydrogen bond (donor-acceptor), can be changed with use_donor_acceptor_distance [0.35 nm] amax maximum deviation of the acceptor-donor-hydrogen angle from linearity (which is 0º) [30º] use_donor_acceptor_distance `True`: dmax refers to the donor-acceptor distance; `False`: dmax is the hydrogen-acceptor max distance. [`True`] N_is_acceptor Count nitrogens as donors and acceptors? [`True`] name : string plugin name (used to access it) simulation : instance The `gromacs.analysis.Simulation` instance that owns the plugin.

  New in version 0.3.1.

  Registers the plugin with the simulation class.

  Specific keyword arguments are listed below, all other kwargs are passed through.

  Arguments: | name : string Name of the plugin. Should differ for different instances. Defaults to the class name. simulation : Simulation instance The `Simulation` instance that owns this plugin instance. Can be `None` but then the `register()` method has to be called manually with a simulation instance later. kwargs All other keyword arguments are passed to the Worker.

  `HBonds.` `worker_class`

    alias of `_HBonds`

class `gromacs.analysis.plugins.` `Trajectories`(name=None, simulation=None, **kwargs)

  Trajectories plugin.

  Write new xy-fitted trajectories (see `gromacs.cbook.trj_fitandcenter()`),

  class `Trajectories`([dt[,[name[, simulation]]])

  The plugin has only one user-settable argument; everything is hard-coded, including the output filenames: _fitxy is always inserted before the suffix.

  Arguments: | dt time step in ps of the output trajectory name : string plugin name (used to access it) simulation : instance The `gromacs.analysis.Simulation` instance that owns the plugin.

  Registers the plugin with the simulation class.

  Specific keyword arguments are listed below, all other kwargs are passed through.

  Arguments: | name : string Name of the plugin. Should differ for different instances. Defaults to the class name. simulation : Simulation instance The `Simulation` instance that owns this plugin instance. Can be `None` but then the `register()` method has to be called manually with a simulation instance later. kwargs All other keyword arguments are passed to the Worker.

  `Trajectories.` `worker_class`

    alias of `_Trajectories`

class `gromacs.analysis.plugins.` `FitCompact`(name=None, simulation=None, **kwargs)

  FitCompact plugin.

  Write new trajectories (see `gromacs.cbook.trj_fitandcenter()`) where the solvent is centered around the protein in a compact representation and the system is RMSD-fitted to the protein backbone.

  The output file names are the input names with “_fitcompact” added. For instance, if ”./MD/md.xtc” is the input trajectory then the output trajectory will be ”./MD/md_fitcompact.xtc”. In addition to the trajectory, compact fitted GRO and PDB files will also be produced.

  class `FitCompact`([xy[, name[, simulation]]])

  The plugin uses the defaults of `gromacs.cbook.trj_fitancenter()`; in particular it fits on the backbone, centers on protein, and writes system.

  Arguments: | xy : bool Rot+trans fit in 3D (`False`) or trans+rot in x-y plane (`True`) [`False`] name : string plugin name (used to access it) simulation : instance The `gromacs.analysis.Simulation` instance that owns the plugin.

  Registers the plugin with the simulation class.

  Specific keyword arguments are listed below, all other kwargs are passed through.

  Arguments: | name : string Name of the plugin. Should differ for different instances. Defaults to the class name. simulation : Simulation instance The `Simulation` instance that owns this plugin instance. Can be `None` but then the `register()` method has to be called manually with a simulation instance later. kwargs All other keyword arguments are passed to the Worker.

  `FitCompact.` `worker_class`

    alias of `_FitCompact`

class `gromacs.analysis.plugins.` `StripWater`(name=None, simulation=None, **kwargs)

  StripWater plugin.

  Write a new trajectory which has the water index group removed.

  class `StripWater`([resn[, force[, dt[, compact[, fit[, name[, simulation]]]]]]])

  Arguments: | resn name of the residues that are stripped (typically it is safe to leave this at the default ‘SOL’) force `True` will always regenerate trajectories even if they already exist, `False` raises an exception, `None` does the sensible thing in most cases (i.e. notify and then move on). dt : float or list of floats only write every dt timestep (in ps); if a list of floats is supplied, write multiple trajectories, one for each dt. compact : bool write a compact representation fit Create an additional trajectory from the stripped one in which the fitgroup group is rms-fitted to the initial structure. See `gromacs.cbook.Transformer.fit()` for details. Useful values: “xy” : perform a rot+trans fit in the x-y plane “all”: rot+trans `None`: no fitting If fit is not supplied then the constructor-default is used (`_StripWater.parameters.fit`). fitgroup Index group to fit to with the fit option; must be changed if molecule is not a protein and automatically recognized. Also consider supplying a custom index file. [“backbone”] name : string plugin name (used to access it) simulation : instance The `gromacs.analysis.Simulation` instance that owns the plugin.

  Note

  If set, dt is only applied to a fit step; the no-water trajectory is always generated for all time steps of the input.

  The defaults work for typical proteins but for e.g. nucleic acids you will need to supply group names in input and fitgroup and possibly also a custom index file.

  Registers the plugin with the simulation class.

  Specific keyword arguments are listed below, all other kwargs are passed through.

  Arguments: | name : string Name of the plugin. Should differ for different instances. Defaults to the class name. simulation : Simulation instance The `Simulation` instance that owns this plugin instance. Can be `None` but then the `register()` method has to be called manually with a simulation instance later. kwargs All other keyword arguments are passed to the Worker.

  `StripWater.` `worker_class`

    alias of `_StripWater`

class `gromacs.analysis.plugins.` `ProteinOnly`(name=None, simulation=None, **kwargs)

  ProteinOnly plugin.

  Write a new trajectory which has the water index group removed.

  class `ProteinOnly`([selection[, name[, simulation[, ...]]]])

  Arguments: | selection optional selection for the water instead of “SOL” name : string plugin name (used to access it) simulation : instance The `gromacs.analysis.Simulation` instance that owns the plugin. force `True` will always regenerate trajectories even if they already exist, `False` raises an exception, `None` does the sensible thing in most cases (i.e. notify and then move on). dt : float or list of floats only write every dt timestep (in ps); if a list of floats is supplied, write multiple trajectories, one for each dt. compact : bool write a compact representation fit Create an additional trajectory from the stripped one in which the Protein group is rms-fitted to the initial structure. See `gromacs.cbook.Transformer.fit()` for details. Useful values: “xy” : perform a rot+trans fit in the x-y plane “all”: rot+trans `None`: no fitting If fit is not supplied then the constructore-default is used (`_ProteinOnly.parameters.fit`). keepalso List of literal `make_ndx` selections that select additional groups of atoms that should also be kept in addition to the protein. For example keepalso = [‘“POPC”’, ‘resname DRUG’].

  Registers the plugin with the simulation class.

  Specific keyword arguments are listed below, all other kwargs are passed through.

  Arguments: | name : string Name of the plugin. Should differ for different instances. Defaults to the class name. simulation : Simulation instance The `Simulation` instance that owns this plugin instance. Can be `None` but then the `register()` method has to be called manually with a simulation instance later. kwargs All other keyword arguments are passed to the Worker.

  `ProteinOnly.` `worker_class`

    alias of `_ProteinOnly`

class `gromacs.analysis.plugins.` `Ls`(name=None, simulation=None, **kwargs)

  ls plugin.

  This simply lists the files on disk. It is useful for testing the plugin architecture.

  class `Ls`([name[, simulation]])

  Arguments: | name : string plugin name (used to access it) simulation : instance The `gromacs.analysis.Simulation` instance that owns the plugin.

  Registers the plugin with the simulation class.

  Specific keyword arguments are listed below, all other kwargs are passed through.

  Arguments: | name : string Name of the plugin. Should differ for different instances. Defaults to the class name. simulation : Simulation instance The `Simulation` instance that owns this plugin instance. Can be `None` but then the `register()` method has to be called manually with a simulation instance later. kwargs All other keyword arguments are passed to the Worker.

  `Ls.` `worker_class`

    alias of `_Ls`

#### Developer notes

In principle all that needs to be done to automatically load plugins is to add their name to `__plugins__`. See the source code for further comments and how the auto loading of plugins is done.

`gromacs.analysis.plugins.` `__plugins__` = ['CysAccessibility', 'Distances', 'MinDistances', 'Dihedrals', 'COM', 'RMSF', 'RMSD', 'Energy', 'HelixBundle', 'HBonds', 'Trajectories', 'FitCompact', 'StripWater', 'ProteinOnly', 'Ls']

  All available plugin names are listed here. Because this is used to automatically set up imports a module file must be named like the plugin class it contains but in all lower case. For example, the Distances plugin class is contained in the module distances (the file `plugins/distances.py`).

`gromacs.analysis.plugins.` `__plugin_classes__` = {'Distances': <class 'gromacs.analysis.plugins.distances.Distances'>, 'FitCompact': <class 'gromacs.analysis.plugins.fitcompact.FitCompact'>, 'RMSF': <class 'gromacs.analysis.plugins.rmsf.RMSF'>, 'RMSD': <class 'gromacs.analysis.plugins.rmsd.RMSD'>, 'StripWater': <class 'gromacs.analysis.plugins.stripwater.StripWater'>, 'MinDistances': <class 'gromacs.analysis.plugins.mindistances.MinDistances'>, 'COM': <class 'gromacs.analysis.plugins.com.COM'>, 'Energy': <class 'gromacs.analysis.plugins.energy.Energy'>, 'Trajectories': <class 'gromacs.analysis.plugins.trajectories.Trajectories'>, 'CysAccessibility': <class 'gromacs.analysis.plugins.cysaccessibility.CysAccessibility'>, 'ProteinOnly': <class 'gromacs.analysis.plugins.proteinonly.ProteinOnly'>, 'HelixBundle': <class 'gromacs.analysis.plugins.helixbundle.HelixBundle'>, 'Ls': <class 'gromacs.analysis.plugins.ls.Ls'>, 'HBonds': <class 'gromacs.analysis.plugins.hbonds.HBonds'>, 'Dihedrals': <class 'gromacs.analysis.plugins.dihedrals.Dihedrals'>}

  Gives access to all available plugin classes (or use the module __dict__)

## Helper modules

Various helper classes that can be used by plugins. Because they are not necessarily restricted to a single plugin they have been moved into separate modules for code reuse.

### `analysis.plugins.dist` — Helper Class for `g_dist`

`dist` contains helper classes for other analysis plugins that want to make use of the Gromacs command `g_dist`.

#### Overview

The task we are solving is to analyze output from

    g_dist -f md.xtc -s md.tpr -n cys_ow.ndx -dist 1.0 | bzip2 -vc > mindist_C60_OW_1nm.dat.bz2

and produce a histogram of minimum contact distances. This should provide an estimate for water accessibility of the atom (here: SG of Cys60).

#### File format

`g_dist` with the `-dist CUTOFF` option writes to stdout the identity of all atoms within the cutoff distance and the distance itself:

    Selected 22: 'CYSH_CYSH_60_&_SG'
    Selected 25: 'OW'
    ....
    t: 184  6682 SOL 35993 OW  0.955138 (nm)
    t: 184  10028 SOL 46031 OW  0.803889 (nm)
    t: 185  6682 SOL 35993 OW  0.879949 (nm)
    t: 185  10028 SOL 46031 OW  0.738299 (nm)
    t: 186  6682 SOL 35993 OW  0.897016 (nm)
    t: 186  10028 SOL 46031 OW  0.788268 (nm)
    t: 187  6682 SOL 35993 OW  0.997688 (nm)
    ....

#### Classes

class `gromacs.analysis.plugins.dist.` `Mindist`(datasource, cutoff=None)

  The Mindist class allows analysis of the output from `g_dist -dist CUTOFF`.

  Output is read from a file or stream. The raw data is transformed into a true ‘mindist’ time series (available in the `Mindist.distances` attribute): for each frame only the shortest distance is stored (whereas `g_dist` provides all distances below the cutoff).

  TODO: | Save analysis to pickle or data files. Export data as simple data files for plotting in other programs.

  Note

  `gromacs.tools.G_mindist` is apparently providing exactly the service that is required: a timeseries of the minimum distance between two groups. Feel free to use that tool instead :-).

  Read mindist data from file or stream.

  Arguments: | datasource a filename (plain, gzip, bzip2) or file object cutoff the `-dist CUTOFF` that was provided to `g_dist`; if supplied we work around a bug in `g_dist` (at least in Gromacs 4.0.2) in which sometimes numbers >> CUTOFF are printed.

  `dist`

    Distribution of the minimum distances.

  `edges`

    Edges of the histogram of the minimum distances.

  `hist`

    Histogram of the minimum distances.

  `histogram`(nbins=None, lo=None, hi=None, midpoints=False, normed=True)

    Returns a distribution or histogram of the minimum distances.

    If no values for the bin edges are given then they are set to 0.1 below and 0.1 above the minimum and maximum values seen in the data.

    If the number of bins is not provided then it is set so that on average 100 counts come to a bin. Set nbins manually if the histogram only contains a single bin (and then get more data)!

    Keywords: | nbins : int number of bins lo : float lower edge of histogram hi : float upper edge of histogram midpoints : boolean False: return edges. True: return midpoints normed : boolean True: return probability distribution. False: histogram

  `midpoints`

    Midpoints of the histogram of the minimum distances.

  `plot`(**kwargs)

    Plot histograms with matplotlib’s plot() function:

        plot(**histogramargs, **plotargs)

    Arguments for both `Mindist.histogram()` and `pylab.plot()` can be provided (qv).

class `gromacs.analysis.plugins.dist.` `GdistData`(stream)

  Object that represents the standard output of `g_dist -dist CUTOFF`.

  Initialize from a stream (e.g. a pipe) and the iterate over the instance to get the data line by line. Each line consists of a tuple

  > (frame, distance)

  Initialize with an open stream to the data (eg stdin or file).

  Arguments: | stream open stream (file or pipe or really any iterator providing the data from `g_dist`); the stream is not closed automatically when the iterator completes.

  `__iter__`()

    Iterator that filters the input stream and returns (frame, distance) tuples.