Merge pull request #223 from GreenGroup/universalDatabase

Universal database tests all seem to be working. Still need the databaseTester.py script to be removed, once all its features have been turned into unit tests.

Author: rwest

.travis.yml

@@ -9,7 +9,8 @@ before_install:
 #  - sudo apt-get install python-rdkit librdkit-dev librdkit1 rdkit-data
   - sudo apt-get install -qq python-numpy python-scipy python-matplotlib
   - cd ..
-  - git clone https://github.com/GreenGroup/RMG-database.git
+  # the following line should not have "--branch universalDatabase" when it is on the master branch
+  - git clone https://github.com/GreenGroup/RMG-database.git --branch universalDatabase
   - git clone https://github.com/GreenGroup/PyDAS.git
   - git clone https://github.com/GreenGroup/PyDQED.git
   # RDKit, based on https://github.com/rdkit/rdkit/blob/master/.travis.yml

databaseTester.py

@@ -0,0 +1,36 @@
+"""
+This scripts runs tests on the database 
+"""
+import os.path
+import logging
+
+from rmgpy import settings
+from rmgpy.data.rmg import RMGDatabase
+
+def checkFamilies(FullDatabase):
+    databaseLog=logging.getLogger('databaseLog')
+    familyStatus={}
+    for family in FullDatabase.kinetics.families:
+        databaseLog.error('\nChecking ' + family + "...")
+        print 'Checking ' + family + "..."
+        familyStatus[family]=FullDatabase.kinetics.families[family].checkWellFormed()
+    
+if __name__ == '__main__':
+    # Set up paths for database and logger
+    databaseDirectory = settings['database.directory']    # RMG-database/input    
+    logPath = os.path.join(databaseDirectory, '..', 'database.log')
+    #clear logger if it exists
+    if os.path.exists(logPath):
+        with open(logPath, 'w'): 
+            pass
+    databaseLog=logging.getLogger('databaseLog')
+    fh=logging.FileHandler(logPath)
+    fh.setLevel(logging.DEBUG)
+    databaseLog.addHandler(fh)
+    databaseLog.propagate=False #prevents these logging messages to being sent to ancestors (so that it doesn't print on console)
+#     logging.basicConfig(filename=logpath, level=logging.ERROR)
+
+    FullDatabase=RMGDatabase()
+    FullDatabase.load(databaseDirectory, kineticsFamilies='all')
+    checkFamilies(FullDatabase)
+

rmgpy/data/base.py

@@ -906,6 +906,49 @@ def checkWellFormed(self):
         notInTree=list(set(notInTree))
 
         return (noGroup, noMatchingGroup, notInTree, notSubgroup, probablyProduct)
+    
+    def matchNodeToNode(self, node, nodeOther):
+        """ 
+        Return `True` if `node` and `nodeOther` are identical.  Otherwise, return `False`.
+        Both `node` and `nodeOther` must be Entry types with items containing Group or LogicNode types.
+        """
+        if isinstance(node.item, Group) and isinstance(nodeOther.item, Group):
+            return self.matchNodeToStructure(node,nodeOther.item, atoms=nodeOther.item.getLabeledAtoms()) and self.matchNodeToStructure(nodeOther,node.item,atoms=node.item.getLabeledAtoms())
+        elif isinstance(node.item,LogicOr) and isinstance(nodeOther.item,LogicOr):
+            return node.item.matchToLogicOr(nodeOther.item)
+        else:
+            # Assume nonmatching
+            return False
+        
+    def matchNodeToChild(self, parentNode, childNode):        
+        """ 
+        Return `True` if `parentNode` is a parent of `childNode`.  Otherwise, return `False`.
+        Both `parentNode` and `childNode` must be Entry types with items containing Group or LogicNode types.
+        If `parentNode` and `childNode` are identical, the function will also return `False`.
+        """
+        
+        if isinstance(parentNode.item, Group) and isinstance(childNode.item, Group):
+            if self.matchNodeToStructure(parentNode,childNode.item, atoms=childNode.item.getLabeledAtoms()) is True:
+                if self.matchNodeToStructure(childNode,parentNode.item, atoms=parentNode.item.getLabeledAtoms()) is False:
+                    return True                
+            return False
+        
+        elif isinstance(parentNode.item,LogicOr) and isinstance(childNode.item,Group):
+            if self.matchNodeToStructure(parentNode,childNode.item, atoms=childNode.item.getLabeledAtoms()) is True:
+                return True
+            else:
+                return False
+        elif isinstance(parentNode.item,LogicOr) and isinstance(childNode.item,LogicOr):
+            if parentNode.item.matchToLogicOr(childNode.item):
+                # the two LogicOrs are identical
+                return False 
+            else:
+                for group in parentNode.item.components:
+                    if group not in childNode.item.components:
+                        return False
+                return True
+        else:
+            return False
 
     def matchNodeToStructure(self, node, structure, atoms):
         """
@@ -917,6 +960,15 @@ def matchNodeToStructure(self, node, structure, atoms):
         include extra labels, and so we only require that every labeled atom in
         the functional group represented by `node` has an equivalent labeled
         atom in `structure`.
+        
+        Matching to structure is more strict than to node.  All labels in structure must 
+        be found in node.  However the reverse is not true.
+        
+        Usage: node = either an Entry or a key in the self.entries dictionary which has
+                      a Group or LogicNode as its Entry.item
+               structure = a Group or a Molecule
+               atoms = dictionary of {label: atom} in the structure.  A possible dictionary
+                       is the one produced by structure.getLabeledAtoms()
         """
         if isinstance(node, str): node = self.entries[node]
         group = node.item

rmgpy/data/baseTest.py

@@ -0,0 +1,96 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+import os
+import unittest
+from external.wip import work_in_progress
+
+from rmgpy import settings
+from rmgpy.data.base import Entry, Database
+from rmgpy.molecule import Group, Molecule
+
+################################################################################
+
+class TestBaseDatabase(unittest.TestCase):
+    """
+    Contains unit tests for the base class of rmgpy.data.
+    """
+    
+    
+    def setUp(self):
+        """
+        A function run before each unit test in this class.
+        """
+        # Set up a dummy database
+        self.database = Database()
+
+
+    def testMatchNodeToStructure(self):
+        """
+        Test that the MatchNodeToStructure family works properly.
+        """
+        entry1 = Entry(
+            item = Group().fromAdjacencyList(
+        """
+        1 *3 C  1 {2,D} {3,S}
+        2    C  0 {1,D}
+        3 *5 Cd 0 {1,S} {4,D}
+        4    C  0 {3,D}
+        """)
+        )        
+        
+        entry2 = Entry(
+            item= Group().fromAdjacencyList(
+        """
+        1 *3 C  1 {2,D} {3,S}
+        2 *5 C  0 {1,D}
+        3    Cd 0 {1,S} {4,D}
+        4    C  0 {3,D}
+        """)
+        )
+        
+        entry3 = Entry(
+            item = Group().fromAdjacencyList(
+        """
+        1 *3 C  1 {2,D} {3,S}
+        2    C  0 {1,D}
+        3    Cd 0 {1,S} {4,D}
+        4    C  0 {3,D}
+        """)
+        )
+        # The group should match to itself
+        self.assertTrue(self.database.matchNodeToStructure(entry1,entry1.item,atoms=entry1.item.getLabeledAtoms()))  
+        
+        # These groups should not match each other
+        self.assertFalse(self.database.matchNodeToStructure(entry1,entry2.item,atoms=entry2.item.getLabeledAtoms()))  
+
+        # entry1 contains more labels than entry3, therefore cannot be matched by entry3
+        self.assertFalse(self.database.matchNodeToStructure(entry3,entry1.item,atoms=entry1.item.getLabeledAtoms()))
+
+        # entry3 contains fewer labels than entry1, therefore it can be matched
+        self.assertTrue(self.database.matchNodeToStructure(entry1,entry3.item,atoms=entry3.item.getLabeledAtoms()))
+        
+    def testMatchNodeToNode(self):
+        """
+        Test that nodes can match other nodes.
+        """
+        entry1 = Entry(
+            item = Group().fromAdjacencyList(
+        """
+        1 *1 R!H 1
+        """)
+        )        
+        
+        entry2 = Entry(
+            item= Group().fromAdjacencyList(
+        """
+        1 *1 Cb 1
+        """)
+        )
+        self.assertTrue(self.database.matchNodeToNode(entry1,entry1))
+        self.assertFalse(self.database.matchNodeToNode(entry1,entry2))
+################################################################################
+
+if __name__ == '__main__':
+    unittest.main(testRunner=unittest.TextTestRunner(verbosity=2))
+