def alignCoordsets(atoms, weights=None):
"""Returns *atoms* after superposing coordinate sets onto its active
coordinate set. Transformations will be calculated for *atoms* and
applied to its :class:`.AtomGroup`, when applicable. Optionally,
atomic *weights* can be passed for weighted superposition."""
try:
acsi, n_csets = atoms.getACSIndex(), atoms.numCoordsets()
except AttributeError:
raise TypeError('atoms must have type Atomic, not {0}'.format(
type(atoms)))
if n_csets < 2:
LOGGER.warning('{0} contains fewer than two coordinate sets, '
'alignment was not performed.'.format(str(atoms)))
return
try:
ag = atoms.getAtomGroup()
except AttributeError:
ag = atoms
agacsi = ag.getACSIndex()
tar = atoms._getCoords()
for i in range(n_csets):
if i == acsi:
continue
atoms.setACSIndex(i)
ag.setACSIndex(i)
calcTransformation(atoms, tar, weights).apply(ag)
atoms.setACSIndex(acsi)
ag.setACSIndex(agacsi)
return atoms
def pathPDBMirror(path=None, format=None):
"""Returns or specify PDB mirror path to be used by :func:`.fetchPDB`.
To release the current mirror, pass an invalid path, e.g. ``path=''``.
If you are keeping a partial mirror, such as PDB files in
:file:`/data/structures/divided/pdb/` folder, specify *format*, which is
``'pdb'`` in this case."""
if path is None:
path = SETTINGS.get('pdb_mirror_path')
format = SETTINGS.get('pdb_mirror_format', None)
if path:
if isdir(path):
if format is None:
return path
else:
return path, format
else:
LOGGER.warning(
'PDB mirror path {0} is not a accessible.'.format(
repr(path)))
else:
if isdir(path):
path = abspath(path)
LOGGER.info('Local PDB mirror path is set: {0}'.format(repr(path)))
SETTINGS['pdb_mirror_path'] = path
SETTINGS['pdb_mirror_format'] = format
SETTINGS.save()
else:
current = SETTINGS.pop('pdb_mirror_path')
if current:
LOGGER.info('PDB mirror {0} is released.'.format(
repr(current)))
SETTINGS.save()
else:
raise IOError('{0} is not a valid path.'.format(repr(path)))
def getCoordsets(self, indices=None):
"""Returns coordinate sets at given *indices*. *indices* may be an
integer, a list of integers or **None**. **None** returns all
coordinate sets."""
if self._closed:
raise ValueError('I/O operation on closed file')
if (self._indices is None
and (indices is None or indices == slice(None))):
nfi = self._nfi
self.reset()
n_floats = self._n_floats + self._unitcell * 14
n_atoms = self._n_atoms
n_csets = self._n_csets
data = self._file.read(self._itemsize * n_floats * n_csets)
data = fromstring(data, self._dtype)
if len(data) > n_floats * n_csets:
n_csets = len(data) / n_floats
data = data[:n_csets]
LOGGER.warning('DCD is corrupt, {0} out of {1} frames '
'were parsed.'.format(n_csets, self._n_csets))
data = data.reshape((n_csets, n_floats))
if self._unitcell:
data = data[:, 14:]
data = data.reshape((n_csets, 3, n_atoms + 2))
data = data[:, :, 1:-1]
data = data.transpose(0, 2, 1)
self.goto(nfi)
if self._astype is not None and self._astype != data.dtype:
data = data.astype(self._astype)
return data
else:
return TrajFile.getCoordsets(self, indices)
def getDeviations(self):
"""Returns deviations from reference coordinates for selected atoms.
Conformations can be aligned using one of :meth:`superpose` or
:meth:`iterpose` methods prior to calculating deviations."""
if not isinstance(self._confs, ndarray):
LOGGER.warning('Conformations are not set.')
return None
if not isinstance(self._coords, ndarray):
LOGGER.warning('Coordinates are not set.')
return None
return self._getCoordsets() - self._getCoords()
def alignAtomicsUsingEnsemble(atomics, ensemble):
"""Align a set of :class:`.Atomic` objects using transformations from *ensemble*,
which may be a :class:`.PDBEnsemble` or a :class:`.PDBConformation` instance.
Transformations will be applied based on indices so *atomics* and *ensemble* must
have the same number of members.
:arg atomics: a set of :class:`.Atomic` objects to be aligned
:type atomics: tuple, list, :class:`~numpy.ndarray`
:arg ensemble: a :class:`.PDBEnsemble` or a :class:`.PDBConformation` from which
transformations can be extracted
:type ensemble: :class:`.PDBEnsemble`, :class:`.PDBConformation`
"""
if not isListLike(atomics):
raise TypeError('atomics must be list-like')
if not isinstance(ensemble, (PDBEnsemble, PDBConformation)):
raise TypeError('ensemble must be a PDBEnsemble or PDBConformation')
if isinstance(ensemble, PDBConformation):
ensemble = [ensemble]
if len(atomics) != len(ensemble):
raise ValueError('atomics and ensemble must have the same length')
output = []
for i, conf in enumerate(ensemble):
trans = conf.getTransformation()
if trans is None:
raise ValueError('transformations are not calculated, call '
'`superpose` or `iterpose`')
ag = atomics[i]
if not isinstance(ag, Atomic):
LOGGER.warning(
'No atomic object found for conformation {0}.'.format(i))
output.append(None)
continue
output.append(trans.apply(ag))
if len(output) == 1:
return output[0]
else:
return output
def _iterDonors(self):
"""Yield pairs of indices for donored atoms that are within the pointer.
Use :meth:`setDonors` for setting donors."""
if self._ag._donors is None:
LOGGER.warning('donors are not set, use `AtomGroup.setDonors`')
indices = self._getIndices()
iset = set(indices)
if len(self._ag) / 2 >= len(self):
for a, b in self._ag._iterDonors():
if a in iset and b in iset:
yield a, b
else:
for a, dmap in zip(indices, self._ag._domap[indices]):
for b in dmap:
if b > -1 and b in iset:
yield a, b
iset.remove(a)
def _iterNBExclusions(self):
"""Yield pairs of indices for nbexclusioned atoms that are within the pointer.
Use :meth:`setNBExclusions` for setting nbexclusions."""
if self._ag._nbexclusions is None:
LOGGER.warning(
'nbexclusions are not set, use `AtomGroup.setNBExclusions`')
indices = self._getIndices()
iset = set(indices)
if len(self._ag) / 2 >= len(self):
for a, b in self._ag._iterNBExclusions():
if a in iset and b in iset:
yield a, b
else:
for a, nbemap in zip(indices, self._ag._nbemap[indices]):
for b in nbemap:
if b > -1 and b in iset:
yield a, b
iset.remove(a)
def getCoordsets(self, indices=None):
if self._closed:
raise ValueError('I/O operation on closed file')
if indices is None:
indices = np.arange(self._n_csets)
elif isinstance(indices, int):
indices = np.array([indices])
elif isinstance(indices, slice):
indices = np.arange(*indices.indices(self._n_csets))
indices.sort()
elif isinstance(indices, (list, np.ndarray)):
indices = np.unique(indices)
else:
raise TypeError('indices must be an integer or a list of integers')
nfi = self._nfi
self.reset()
n_atoms = self.numSelected()
coords = np.zeros((len(indices), n_atoms, 3), self._dtype)
prev = 0
next = self.nextCoordset
for i, index in enumerate(indices):
diff = index - prev
if diff > 1:
self.skip(diff-1)
xyz = next()
if xyz is None:
LOGGER.warning('Expected {0} frames, but parsed {1}.'
.format(len(indices), i))
self.goto(nfi)
return coords[:i]
coords[i] = xyz
prev = index
self.goto(nfi)
return coords
def __add__(self, other):
"""Returnss an :class:`.AtomMap` instance. Order of pointed atoms are
preserved."""
try:
ag = other.getAtomGroup()
except AttributeError:
raise TypeError('unsupported operand type(s) for +: {0} and '
'{1}'.format(repr(type(self).__name__),
repr(type(other).__name__)))
if ag != self._ag:
raise ValueError('AtomPointer instances must point to the same '
'AtomGroup instance')
acsi = self.getACSIndex()
if acsi != other.getACSIndex():
LOGGER.warning('Active coordset indices of atoms are not the same.'
' Result will have ACSI {0}.'.format(acsi))
title = '({0}) + ({1})'.format(str(self), str(other))
indices = concatenate([self._getIndices(), other._getIndices()])
dummies = 0
try:
dummies += self.numDummies()
except AttributeError:
pass
try:
dummies += other.numDummies()
except AttributeError:
pass
return AtomMap(ag,
indices,
acsi,
title=title,
intarrays=True,
dummies=dummies)
def __and__(self, other):
if self is other:
return self
try:
ag = other.getAtomGroup()
except AttributeError:
raise TypeError('other must be an AtomPointer')
if self._ag != ag:
raise ValueError('both selections must be from the same AtomGroup')
acsi = self.getACSIndex()
if acsi != other.getACSIndex():
LOGGER.warning('active coordinate set indices do not match, '
'so it will be set to zero in the union.')
acsi = 0
acsi = self.getACSIndex()
if acsi != other.getACSIndex():
LOGGER.warn('Active coordinate set indices do not match, it will '
'be set to zero.')
acsi = 0
indices = set(self._getIndices())
indices = indices.intersection(other.getIndices())
if indices:
indices = unique(indices)
if indices[-1] == atommap.DUMMY:
indices = indices[:-1]
return Selection(
self._ag,
indices, '({0}) and ({1})'.format(self.getSelstr(),
other.getSelstr()), acsi)
def _parseHeader(self):
"""Read the header information from a dcd file.
Input: fd - a file struct opened for binary reading.
Output: 0 on success, negative error code on failure.
Side effects: *natoms set to number of atoms per frame
*nsets set to number of frames in dcd file
*istart set to starting timestep of dcd file
*nsavc set to timesteps between dcd saves
*delta set to value of trajectory timestep
*nfixed set to number of fixed atoms
*freeind may be set to heap-allocated space
*reverse set to one if reverse-endian, zero if not.
*charmm set to internal code for handling charmm data.
"""
dcd = self._file
endian = b'' #'=' # native endian
rec_scale = RECSCALE32BIT
charmm = None
dcdcordmagic = unpack(endian + b'i', b'CORD')[0]
# Check magic number in file header and determine byte order
bits = dcd.read(calcsize('ii'))
temp = unpack(endian + b'ii', bits)
if temp[0] + temp[1] == 84:
LOGGER.info('Detected CHARMM -i8 64-bit DCD file of native '
'endianness.')
rec_scale = RECSCALE64BIT
elif temp[0] == 84 and temp[1] == dcdcordmagic:
pass
#LOGGER.info('Detected standard 32-bit DCD file of native '
# 'endianness.')
else:
if unpack(b'>ii', bits) == temp:
endian = '>'
else:
endian = '<'
temp = unpack(endian + b'ii', bits)
if temp[0] + temp[1] == 84:
rec_scale = RECSCALE64BIT
LOGGER.info('Detected CHARMM -i8 64-bit DCD file of opposite '
'endianness.')
else:
endian = ''
temp = unpack(endian + b'ii', bits)
if temp[0] == 84 and temp[1] == dcdcordmagic:
LOGGER.info('Detected standard 32-bit DCD file of '
'opposite endianness.')
else:
raise IOError('Unrecognized DCD header or unsupported '
'DCD format.')
# check for magic string, in case of long record markers
if rec_scale == RECSCALE64BIT:
raise IOError('CHARMM 64-bit DCD files are not yet supported.')
temp = unpack(b'I', dcd.read(calcsize('I')))
if temp[0] != dcdcordmagic:
raise IOError('Failed to find CORD magic in CHARMM -i8 64-bit '
'DCD file.')
# Buffer the entire header for random access
bits = dcd.read(80)
# CHARMm-genereate DCD files set the last integer in the
# header, which is unused by X-PLOR, to its version number.
# Checking if this is nonzero tells us this is a CHARMm file
# and to look for other CHARMm flags.
temp = unpack(endian + b'i' * 20, bits)
if temp[-1] != 0:
charmm = True
if charmm:
#LOGGER.info('CHARMM format DCD file (also NAMD 2.1 and later).')
temp = unpack(endian + b'i' * 9 + b'f' + b'i' * 10, bits)
else:
LOGGER.info('X-PLOR format DCD file (also NAMD 2.0 and earlier) '
'is not supported.')
return None
# Store the number of sets of coordinates (NSET)
self._n_csets = temp[0]
# Store ISTART, the starting timestep
self._first_ts = temp[1]
# Store NSAVC, the number of timesteps between dcd saves
self._framefreq = temp[2]
# Store NAMNF, the number of fixed atoms
self._n_fixed = temp[8]
if self._n_fixed > 0:
raise IOError('DCD files with fixed atoms is not yet supported.')
# Read in the timestep, DELTA
# Note: DELTA is stored as double with X-PLOR but as float with CHARMm
self._timestep = temp[9]
self._unitcell = temp[10] == 1
# Get the end size of the first block
if unpack(endian + b'i', dcd.read(rec_scale * calcsize('i')))[0] != 84:
raise IOError('Unrecognized DCD format.')
# Read in the size of the next block
temp = unpack(endian + b'i', dcd.read(rec_scale * calcsize('i')))
if (temp[0] - 4) % 80 != 0:
raise IOError('Unrecognized DCD format.')
noremarks = temp[0] == 84
# Read NTITLE, the number of 80 character title strings there are
temp = unpack(endian + b'i', dcd.read(rec_scale * calcsize('i')))
self._dcdtitle = dcd.read(80)
if not noremarks:
self._remarks = dcd.read(80)
# Get the ending size for this block
temp = unpack(endian + b'i', dcd.read(rec_scale * calcsize('i')))
if (temp[0] - 4) % 80 != 0:
raise IOError('Unrecognized DCD format.')
# Read in an integer '4'
if unpack(endian + b'i', dcd.read(rec_scale * calcsize('i')))[0] != 4:
raise IOError('Unrecognized DCD format.')
# Read in the number of atoms
self._n_atoms = unpack(endian + b'i',
dcd.read(rec_scale * calcsize('i')))[0]
# Read in an integer '4'
if unpack(endian + b'i', dcd.read(rec_scale * calcsize('i')))[0] != 4:
raise IOError('Bad DCD format.')
self._is64bit = rec_scale == RECSCALE64BIT
self._endian = endian
self._n_floats = (self._n_atoms + 2) * 3
if self._is64bit:
if self._unitcell:
self._bytes_per_frame = 56 + self._n_floats * 8
else:
self._bytes_per_frame = self._n_floats * 8
LOGGER.warning('Reading of 64 bit DCD files has not been tested. '
'Please report any problems that you may find.')
self._dtype = np.float64
self._itemsize = 8
else:
if self._unitcell:
self._bytes_per_frame = 56 + self._n_floats * 4
else:
self._bytes_per_frame = self._n_floats * 4
self._dtype = np.float32
self._itemsize = 4
self._first_byte = self._file.tell()
n_csets = (getsize(self._filename) -
self._first_byte) // self._bytes_per_frame
if n_csets != self._n_csets:
LOGGER.warning('DCD header claims {0} frames, file size '
'indicates there are actually {1} frames.'.format(
self._n_csets, n_csets))
self._n_csets = n_csets
self._coords = self.nextCoordset()
self._file.seek(self._first_byte)
self._nfi = 0