Source code for MDAnalysis.coordinates.DCD

# -*- Mode: python; tab-width: 4; indent-tabs-mode:nil; coding:utf-8 -*-
# vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4
# MDAnalysis ---
# Copyright (c) 2006-2017 The MDAnalysis Development Team and contributors
# (see the file AUTHORS for the full list of names)
# Released under the GNU Public Licence, v2 or any higher version
# Please cite your use of MDAnalysis in published work:
# R. J. Gowers, M. Linke, J. Barnoud, T. J. E. Reddy, M. N. Melo, S. L. Seyler,
# D. L. Dotson, J. Domanski, S. Buchoux, I. M. Kenney, and O. Beckstein.
# MDAnalysis: A Python package for the rapid analysis of molecular dynamics
# simulations. In S. Benthall and S. Rostrup editors, Proceedings of the 15th
# Python in Science Conference, pages 102-109, Austin, TX, 2016. SciPy.
# doi: 10.25080/majora-629e541a-00e
# N. Michaud-Agrawal, E. J. Denning, T. B. Woolf, and O. Beckstein.
# MDAnalysis: A Toolkit for the Analysis of Molecular Dynamics Simulations.
# J. Comput. Chem. 32 (2011), 2319--2327, doi:10.1002/jcc.21787
"""DCD trajectory I/O  --- :mod:`MDAnalysis.coordinates.DCD`

Classes to read and write DCD binary trajectories, the format used by
CHARMM, NAMD, and also LAMMPS. Trajectories can be read regardless of
system-endianness as this is auto-detected.

Generally, DCD trajectories produced by any code can be read (with the
:class:`DCDReader`) although there can be issues with the unitcell (simulation
box) representation (see :attr:`DCDReader.dimensions`). DCDs can also be
written but the :class:`DCDWriter` follows recent NAMD/VMD convention for the
unitcell but still writes AKMA time. Reading and writing these trajectories
within MDAnalysis will work seamlessly but if you process those trajectories
with other tools you might need to watch out that time and unitcell dimensions
are correctly interpreted.

See Also
  module provides a more flexible DCD reader/writer.

.. _Issue 187:


.. autoclass:: DCDReader
.. autoclass:: DCDWriter

from __future__ import absolute_import, division, print_function, unicode_literals
from six.moves import range

import os
import errno
import numpy as np
import struct
import types
import warnings

from .. import units as mdaunits  # use mdaunits instead of units to avoid a clash
from ..exceptions import NoDataError
from . import base, core
from ..lib.formats.libdcd import DCDFile
from ..lib.mdamath import triclinic_box

[docs]class DCDReader(base.ReaderBase): """Reader for the DCD format. DCD is used by NAMD, CHARMM and LAMMPS as the default trajectory format. The DCD file format is not well defined. In particular, NAMD and CHARMM use it differently. Currently, MDAnalysis tries to guess the correct **format for the unitcell representation** but it can be wrong. **Check the unitcell dimensions**, especially for triclinic unitcells (see `Issue 187`_). DCD trajectories produced by CHARMM and NAMD( >2.5) record time in AKMA units. If other units have been recorded (e.g., ps) then employ the configurable :class:MDAnalysis.coordinates.LAMMPS.DCDReader and set the time unit as a optional argument. You can find a list of units used in the DCD formats on the MDAnalysis `wiki`_. MDAnalysis always uses ``(*A*, *B*, *C*, *alpha*, *beta*, *gamma*)`` to represent the unit cell. Lengths *A*, *B*, *C* are in the MDAnalysis length unit (Å), and angles are in degrees. The ordering of the angles in the unitcell is the same as in recent versions of VMD's DCDplugin_ (2013), namely the `X-PLOR DCD format`_: The original unitcell is read as ``[A, gamma, B, beta, alpha, C]`` from the DCD file. If any of these values are < 0 or if any of the angles are > 180 degrees then it is assumed it is a new-style CHARMM unitcell (at least since c36b2) in which box vectors were recorded. .. warning:: The DCD format is not well defined. Check your unit cell dimensions carefully, especially when using triclinic boxes. Different software packages implement different conventions and MDAnalysis is currently implementing the newer NAMD/VMD convention and tries to guess the new CHARMM one. Old CHARMM trajectories might give wrong unitcell values. For more details see `Issue 187`_. .. _`X-PLOR DCD format`: .. _Issue 187: .. _DCDplugin: .. _wiki: """ format = 'DCD' flavor = 'CHARMM' units = {'time': 'AKMA', 'length': 'Angstrom'} def __init__(self, filename, convert_units=True, dt=None, **kwargs): """ Parameters ---------- filename : str trajectory filename convert_units : bool (optional) convert units to MDAnalysis units dt : float (optional) overwrite time delta stored in DCD **kwargs : dict General reader arguments. .. versionchanged:: 0.17.0 Changed to use libdcd.pyx library and removed the correl function """ super(DCDReader, self).__init__( filename, convert_units=convert_units, **kwargs) self._file = DCDFile(self.filename) self.n_atoms = self._file.header['natoms'] delta = mdaunits.convert(self._file.header['delta'], self.units['time'], 'ps') if dt is None: dt = delta * self._file.header['nsavc'] self.skip_timestep = self._file.header['nsavc'] self._ts_kwargs['dt'] = dt self.ts = self._Timestep(self.n_atoms, **self._ts_kwargs) frame = # reset trajectory if self._file.n_frames > 1: else: self._frame = 0 self.ts = self._frame_to_ts(frame, self.ts) # these should only be initialized once self.ts.dt = dt if self.convert_units: self.convert_pos_from_native(self.ts.dimensions[:3])
[docs] @staticmethod def parse_n_atoms(filename, **kwargs): with DCDFile(filename) as f: n_atoms = f.header['natoms'] return n_atoms
[docs] def close(self): """close reader""" self._file.close()
@property def n_frames(self): """number of frames in trajectory""" return len(self._file) def _reopen(self): """reopen trajectory""" self.ts.frame = 0 self._frame = -1 self._file.close()'r') def _read_frame(self, i): """read frame i""" self._frame = i - 1 return self._read_next_timestep() def _read_next_timestep(self, ts=None): """copy next frame into timestep""" if self._frame == self.n_frames - 1: raise IOError('trying to go over trajectory limit') if ts is None: # use a copy to avoid that ts always points to the same reference # removing this breaks lammps reader ts = self.ts.copy() frame = self._frame += 1 ts = self._frame_to_ts(frame, ts) self.ts = ts return ts
[docs] def Writer(self, filename, n_atoms=None, **kwargs): """Return writer for trajectory format""" if n_atoms is None: n_atoms = self.n_atoms return DCDWriter( filename, n_atoms=n_atoms, dt=self.ts.dt, convert_units=self.convert_units, **kwargs)
def _frame_to_ts(self, frame, ts): """convert a dcd-frame to a :class:`TimeStep`""" ts.frame = self._frame ts.time = (ts.frame + self._file.header['istart']/self._file.header['nsavc']) * self.ts.dt['step'] = self._file.tell() # The original unitcell is read as ``[A, gamma, B, beta, alpha, C]`` _ts_order = [0, 2, 5, 4, 3, 1] uc = np.take(frame.unitcell, _ts_order) pi_2 = np.pi / 2 if (-1.0 <= uc[3] <= 1.0) and (-1.0 <= uc[4] <= 1.0) and ( -1.0 <= uc[5] <= 1.0): # This file was generated by Charmm, or by NAMD > 2.5, with the # angle cosines of the periodic cell angles written to the DCD # file. This formulation improves rounding behavior for orthogonal # cells so that the angles end up at precisely 90 degrees, unlike # acos(). (changed in MDAnalysis 0.9.0 to have NAMD ordering of the # angles; see Issue 187) */ uc[3] = 90.0 - np.arcsin(uc[3]) * 90.0 / pi_2 uc[4] = 90.0 - np.arcsin(uc[4]) * 90.0 / pi_2 uc[5] = 90.0 - np.arcsin(uc[5]) * 90.0 / pi_2 # heuristic sanity check: uc = A,B,C,alpha,beta,gamma elif np.any(uc < 0.) or np.any(uc[3:] > 180.): # might be new CHARMM: box matrix vectors H = frame.unitcell.copy() e1, e2, e3 = H[[0, 1, 3]], H[[1, 2, 4]], H[[3, 4, 5]] uc = triclinic_box(e1, e2, e3) else: # This file was likely generated by NAMD 2.5 and the periodic cell # angles are specified in degrees rather than angle cosines. pass ts.dimensions = uc ts.positions = if self.convert_units: self.convert_pos_from_native(ts.dimensions[:3]) self.convert_pos_from_native(ts.positions) return ts @property def dimensions(self): """unitcell dimensions (*A*, *B*, *C*, *alpha*, *beta*, *gamma*) """ return self.ts.dimensions @property def dt(self): """timestep between frames""" return self.ts.dt
[docs] def timeseries(self, asel=None, start=None, stop=None, step=None, order='afc'): """Return a subset of coordinate data for an AtomGroup Parameters ---------- asel : :class:`~MDAnalysis.core.groups.AtomGroup` The :class:`~MDAnalysis.core.groups.AtomGroup` to read the coordinates from. Defaults to None, in which case the full set of coordinate data is returned. start : int (optional) Begin reading the trajectory at frame index `start` (where 0 is the index of the first frame in the trajectory); the default ``None`` starts at the beginning. stop : int (optional) End reading the trajectory at frame index `stop`-1, i.e, `stop` is excluded. The trajectory is read to the end with the default ``None``. step : int (optional) Step size for reading; the default ``None`` is equivalent to 1 and means to read every frame. order : str (optional) the order/shape of the return data array, corresponding to (a)tom, (f)rame, (c)oordinates all six combinations of 'a', 'f', 'c' are allowed ie "fac" - return array where the shape is (frame, number of atoms, coordinates) .. versionchanged:: 1.0.0 `skip` and `format` keywords have been removed. """ start, stop, step = self.check_slice_indices(start, stop, step) if asel is not None: if len(asel) == 0: raise NoDataError( "Timeseries requires at least one atom to analyze") atom_numbers = list(asel.indices) else: atom_numbers = list(range(self.n_atoms)) frames = self._file.readframes( start, stop, step, order=order, indices=atom_numbers) return
[docs]class DCDWriter(base.WriterBase): """DCD Writer class The writer follows recent NAMD/VMD convention for the unitcell (box lengths in Å and angle-cosines, ``[A, cos(gamma), B, cos(beta), cos(alpha), C]``) and writes positions in Å and time in AKMA time units. """ format = 'DCD' multiframe = True flavor = 'NAMD' units = {'time': 'AKMA', 'length': 'Angstrom'} def __init__(self, filename, n_atoms, convert_units=True, step=1, dt=1, remarks='', nsavc=1, istart=0, **kwargs): """Parameters ---------- filename : str filename of trajectory n_atoms : int number of atoms to be written convert_units : bool (optional) convert from MDAnalysis units to format specific units step : int (optional) number of steps between frames to be written dt : float (optional) time between two frames. If ``None`` guess from first written :class:`TimeStep` remarks : str (optional) remarks to be stored in DCD. Shouldn't be more then 240 characters nsavc : int (optional) DCD files can also store the number of integrator time steps that correspond to the interval between two frames as nsavc (i.e., every how many MD steps is a frame saved to the DCD). By default, this number is just set to one and this should be sufficient for almost all cases but if required, `nsavc` can be changed. istart : int (optional) starting frame number in integrator timesteps. CHARMM defaults to `nsavc`, i.e., start at frame number 1 = `istart` / `nsavc`. The value ``None`` will set `istart` to `nsavc` (the CHARMM default). The MDAnalysis default is 0 so that the frame number and time of the first frame is 0. **kwargs : dict General writer arguments """ self.filename = filename self._convert_units = convert_units if n_atoms is None: raise ValueError("n_atoms argument is required") self.n_atoms = n_atoms self._file = DCDFile(self.filename, 'w') self.step = step self.dt = dt dt = mdaunits.convert(dt, 'ps', self.units['time']) delta = float(dt) / nsavc istart = istart if istart is not None else nsavc self._file.write_header( remarks=remarks, natoms=self.n_atoms, nsavc=nsavc, delta=delta, is_periodic=1, istart=istart) def _write_next_frame(self, ag): """Write information associated with ``obj`` at current frame into trajectory Parameters ---------- ag : AtomGroup or Universe See Also -------- :meth:`DCDWriter.write` takes a more general input .. deprecated:: 1.0.0 Deprecated use of Timestep as argument. To be removed in version 2.0 .. versionchanged:: 1.0.0 Added ability to pass AtomGroup or Universe. Renamed from `write_next_timestep` to `_write_next_frame`. """ if isinstance(ag, base.Timestep): ts = ag else: try: ts = ag.ts except AttributeError: try: # Universe? ts = ag.trajectory.ts except AttributeError: raise TypeError("No Timestep found in ag argument") xyz = ts.positions.copy() dimensions = ts.dimensions.copy() if self._convert_units: xyz = self.convert_pos_to_native(xyz, inplace=True) dimensions = self.convert_dimensions_to_unitcell(ts, inplace=True) # we only support writing charmm format unit cell info # The DCD unitcell is written as ``[A, gamma, B, beta, alpha, C]`` _ts_order = [0, 5, 1, 4, 3, 2] box = np.take(dimensions, _ts_order) self._file.write(xyz=xyz, box=box)
[docs] def close(self): """close trajectory""" self._file.close()
def __del__(self): self.close()