basic guesser features

package/MDAnalysis/core/universe.py

@@ -72,7 +72,7 @@
 import os
 import uuid
 
-from .. import _TOPOLOGY_ATTRS, _PARSERS
+from .. import _TOPOLOGY_ATTRS, _PARSERS, _GUESSERS
 from ..exceptions import NoDataError
 from ..lib import util
 from ..lib.log import ProgressBar
@@ -86,8 +86,7 @@
 from .topology import Topology
 from .topologyattrs import AtomAttr, ResidueAttr, SegmentAttr, BFACTOR_WARNING
 from .topologyobjects import TopologyObject
-
-
+from ..guesser.core import get_guesser
 logger = logging.getLogger("MDAnalysis.core.universe")
 
 
@@ -173,7 +172,6 @@ def _generate_from_topology(universe):
     universe.segments = SegmentGroup(
             np.arange(universe._topology.n_segments), universe)
 
-
 class Universe(object):
     """The MDAnalysis Universe contains all the information describing the system.
 
@@ -316,7 +314,8 @@ class Universe(object):
     """
     def __init__(self, topology=None, *coordinates, all_coordinates=False,
                  format=None, topology_format=None, transformations=None,
-                 guess_bonds=False, vdwradii=None, in_memory=False,
+                 guess_bonds=False, vdwradii=None, context='default',
+                 to_guess=[], in_memory=False,
                  in_memory_step=1, **kwargs):
 
         self._trajectory = None  # managed attribute holding Reader
@@ -328,6 +327,8 @@ def __init__(self, topology=None, *coordinates, all_coordinates=False,
 
         self._kwargs = {
             'transformations': transformations,
+            'context': context,
+            'to_guess': to_guess,
             'guess_bonds': guess_bonds,
             'vdwradii': vdwradii,
             'in_memory': in_memory,
@@ -373,6 +374,8 @@ def __init__(self, topology=None, *coordinates, all_coordinates=False,
         if guess_bonds:
             self.atoms.guess_bonds(vdwradii=vdwradii)
 
+        self.guess_topoloyAttribute(context, to_guess)
+
     def copy(self):
         """Return an independent copy of this Universe"""
         new = self.__class__(self._topology.copy())
@@ -1436,6 +1439,19 @@ def from_smiles(cls, smiles, sanitize=True, addHs=True,
 
         return cls(mol, **kwargs)
 
+    def guess_topoloyAttribute(self, context, to_guess):
+        """guess attributes passed to the universe within specific context
+
+        Parameters
+        ----------
+        context: string or Guesser class
+        to_guess: list of atrributes to be guessed then added to the universe
+        """
+        self._guesser = get_guesser(self.atoms, context)
+        if self._guesser.is_guessed(to_guess):
+            for attr in to_guess:
+                values = self._guesser.guessTopologyAttribute(attr)
+                self.add_TopologyAttr(attr, values)
 
 def Merge(*args):
     """Create a new new :class:`Universe` from one or more

package/MDAnalysis/guesser/DefaultGuesser.py

@@ -0,0 +1,79 @@
+from .base import GuesserBase
+import numpy as np
+import warnings
+from . import tables
+
+
+class DefaultGuesser(GuesserBase):
+    context = 'default'
+
+    def __init__(self):
+        self._guess = {'mass': self.guess_masses}
+
+    def guess_masses(self):
+        """Guess the mass of many atoms based upon their type
+
+        Returns
+        -------
+        atom_masses : np.ndarray dtype float64
+        """
+        atom_types = self._atoms.types
+        self.validate_atom_types(atom_types)
+        masses = np.array([self.get_atom_mass(atom_t)
+                           for atom_t in atom_types], dtype=np.float64)
+        return masses
+
+    def validate_atom_types(self, atom_types):
+        """Vaildates the atom types based on whether they are available
+        in our tables
+
+        Parameters
+        ----------
+        atom_types
+          Type of each atom
+
+        Returns
+        -------
+        None
+
+        .. versionchanged:: 0.20.0
+           Try uppercase atom type name as well
+        """
+        for atom_type in np.unique(atom_types):
+            try:
+                tables.masses[atom_type]
+            except KeyError:
+                try:
+                    tables.masses[atom_type.upper()]
+                except KeyError:
+                    warnings.warn
+                    ("Failed to guess the mass for the following atoms: {}"
+                     .format(atom_type))
+
+    def get_atom_mass(self, element):
+        """Return the atomic mass in u for *element*.
+
+        Masses are looked up in :data:`MDAnalysis.topology.tables.masses`.
+
+        .. Warning:: Unknown masses are set to 0.0
+
+        .. versionchanged:: 0.20.0
+           Try uppercase atom type name as well
+        """
+        try:
+            return tables.masses[element]
+        except KeyError:
+            try:
+                return tables.masses[element.upper()]
+            except KeyError:
+                return 0.0
+
+    def guess_atom_mass(self, atomname):
+        """Guess a mass based on the atom name.
+
+        :func:`guess_atom_element` is used to determine the kind of atom.
+
+        .. warning:: Anything not recognized is simply set to 0;
+        if you rely on the masses you might want to double check.
+        """
+        return self.get_atom_mass(self.guess_atom_element(atomname))

package/MDAnalysis/guesser/__init__.py

@@ -0,0 +1,23 @@
+# -*- Mode: python; tab-width: 4; indent-tabs-mode:nil; coding:utf-8 -*-
+# vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4
+#
+# MDAnalysis --- https://www.mdanalysis.org
+# 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
+#
+from . import DefaultGuesser

package/MDAnalysis/guesser/base.py

@@ -0,0 +1,48 @@
+class GuesserBase:
+    context = "base"
+    _guess = {}
+
+    def is_guessed(self, to_guess):
+        """check that the passed atrributes in the to_guess
+        list can be guessed by the class
+
+        Parameters
+        ----------
+        to_guess: list of atrributes to be guessed then added to the universe
+        Returns
+        -------
+        True or False
+        """
+        for a in to_guess:
+            if a.lower() not in self._guess:
+                raise ValueError('{0} guesser can not guess the {1} atrribute'
+                                 .format(self.context, a))
+        return True
+
+    def guessTopologyAttribute(self, to_guess):
+        """map the attribute to be guessed with the apporpiate guessing method
+
+        Parameters
+        ----------
+        to_guess: an atrribute to be guessed then added to the universe
+
+        Returns
+        -------
+        values: list of guessed values
+        """
+        values = self._guess[to_guess]()
+        return values
+
+    def setAtoms(self, atoms):
+        """get the AtomGroup of the universe to use its attributes
+           inside the guessing methods
+
+        Parameters
+        ----------
+        atoms: AtomGroup of the universe
+
+        Returns
+        -------
+        values: list of guessed values
+        """
+        self._atoms = atoms

package/MDAnalysis/guesser/core.py

@@ -0,0 +1,29 @@
+
+from .base import GuesserBase
+from .DefaultGuesser import DefaultGuesser
+
+# guessers dictionary mimic registaration by metaclass
+GUESSERS = {'DEFAULT': DefaultGuesser}
+
+
+def get_guesser(atoms, context):
+    """get an appropiate guesser to the universe and pass
+       the atomGroup of the universe to the guesser
+
+    Parameters
+    ----------
+    atoms: AtomGroup of the universe
+    context: string or Guesser class
+    Returns
+    -------
+    TGuesser class
+    """
+    if isinstance(context, GuesserBase):
+        context.setAtoms(atoms)
+        return context
+    try:
+        guesser = GUESSERS[context.upper()]
+        guesser.setAtoms(atoms)
+    except KeyError:
+        raise TypeError("Unidentified guesser type {0}".format(context))
+    return guesser