basic guesser features

package/MDAnalysis/core/universe.py

@@ -60,7 +60,6 @@
 import warnings
 import contextlib
 import collections
-
 import MDAnalysis
 import sys
 
@@ -72,7 +71,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 +85,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 +171,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 +313,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 +326,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,
@@ -372,6 +372,13 @@ def __init__(self, topology=None, *coordinates, all_coordinates=False,
 
         if guess_bonds:
             self.atoms.guess_bonds(vdwradii=vdwradii)
+        # add mass and type to the to_guess list
+        toplist = list(self._topology.read_attributes)
+        if not any(att.singular == 'type' for att in toplist) and 'type' not in to_guess:
+            to_guess.append('type')
+        if not any(att.singular == 'mass' for att in toplist) and 'mass' not in to_guess:
+            to_guess.append('mass')
+        self.guess_TopologyAttr(context, to_guess)
 
     def copy(self):
         """Return an independent copy of this Universe"""
@@ -1436,6 +1443,27 @@ def from_smiles(cls, smiles, sanitize=True, addHs=True,
 
         return cls(mol, **kwargs)
 
+    def guess_TopologyAttr(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):
+            # sort attributes
+            to_guess = self._guesser.rank_attributes(to_guess)
+            # check if the attribute already have been read from topology file
+            toplist = list(self._topology.read_attributes)
+            for attr in to_guess:
+                if any(attr == a.singular for a in toplist):
+                    warnings.warn('The atrribute {} have already been read '
+                                  'from the topology file, you are overwriting'
+                                  'it by guessed values'.format(attr))
+                values = self._guesser.guess_topologyAttr(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,155 @@
+from .base import GuesserBase
+import numpy as np
+import warnings
+
+import re
+
+from ..lib import distances
+from . import tables
+
+
+class DefaultGuesser(GuesserBase):
+    context = 'default'
+
+    def __init__(self, atoms):
+        super().__init__(atoms)
+        self._guess = {'mass': self.guess_masses,
+                       'type': self.guess_types}
+        self._rank = {'mass': 2,
+                      'type': 1
+                      }
+
+    def guess_masses(self):
+        """Guess the mass of many atoms based upon their type
+
+        Returns
+        -------
+        atom_masses : np.ndarray dtype float64
+        """
+        if hasattr(self._atoms, 'elements'):
+            atom_types = self._atoms.elements
+        else:
+            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))
+
+    def guess_types(self):
+        """Guess the atom type of many atoms based on atom name
+
+        Parameters
+        ----------
+        atom_names
+          Name of each atom
+
+        Returns
+        -------
+        atom_types : np.ndarray dtype object
+        """
+        names = self._atoms.names
+        return
+        np.array([self.guess_atom_element(n) for n in names], dtype=object)
+
+    NUMBERS = re.compile(r'[0-9]')  # match numbers
+    SYMBOLS = re.compile(r'[*+-]')  # match *, +, -
+
+    def guess_atom_element(self, atomname):
+        """Guess the element of the atom from the name.
+
+        Looks in dict to see if element is found, otherwise it uses the first
+        character in the atomname. The table comes from CHARMM and AMBER atom
+        types, where the first character is not sufficient to determine the
+        atom type. Some GROMOS ions have also been added.
+
+        .. Warning: The translation table is incomplete.
+           This will probably result in some mistakes,
+           but it still bbetter than nothing!
+
+        See Also
+        --------
+        :func:`guess_atom_type`
+        :mod:`MDAnalysis.topology.tables`
+        """
+        if atomname == '':
+            return ''
+        try:
+            return tables.atomelements[atomname.upper()]
+        except KeyError:
+            # strip symbols and numbers
+            no_symbols = re.sub(self.SYMBOLS, '', atomname)
+            name = re.sub(self.NUMBERS, '', no_symbols).upper()
+
+            # just in case
+            if name in tables.atomelements:
+                return tables.atomelements[name]
+
+            while name:
+                if name in tables.elements:
+                    return name
+                if name[:-1] in tables.elements:
+                    return name[:-1]
+                if name[1:] in tables.elements:
+                    return name[1:]
+                if len(name) <= 2:
+                    return name[0]
+                name = name[:-1]  # probably element is on left not right
+
+            # if it's numbers
+            return no_symbols

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,59 @@
+class GuesserBase:
+    context = "base"
+    _guess = {}
+
+    # give a rank to each atrribute based on its dependency on other attributes
+    # to be guessed, so that the attribute with lesser dependcy will be guessed 
+    # first
+    _rank = {}
+
+    def __init__(self, atoms):
+        self._atoms = atoms
+
+    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 ValueError
+        """
+        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 guess_topologyAttr(self, guess):
+        """map the attribute to be guessed with the apporpiate guessing method
+
+        Parameters
+        ----------
+        guess: an atrribute to be guessed then added to the universe
+
+        Returns
+        -------
+        values: list of guessed values
+        """
+        return self._guess[guess]()
+
+    def rank_attributes(self, attrs):
+       """give a rank to each atrribute based on
+          its dependency on other attributes to be guessed,
+          so that the attribute with lesser dependcy will
+          be guessed first
+
+       Parameters
+       ----------
+       attrs: attributes list to be sorted
+
+       Returns
+       -------
+       sorted attributes list
+       """
+        to_rank = {a: self._rank[a] for a in attrs}
+        ranked_attrs = sorted(to_rank, key=to_rank.get)
+        return ranked_attrs

package/MDAnalysis/guesser/core.py

@@ -0,0 +1,27 @@
+
+from .base import GuesserBase
+from .DefaultGuesser import DefaultGuesser
+
+# guessers dictionary mimic registaration by metaclass
+GUESSERS = {'DEFAULT': DefaultGuesser}
+
+
+def get_guesser(a, 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
+    -------
+    Guesser class
+    """
+    if isinstance(context, GuesserBase):
+        return context
+    try:
+        guesser = GUESSERS[context.upper()](a)
+    except KeyError:
+        raise TypeError("Unidentified guesser type {0}".format(context))
+    return guesser