Select the rate rules to average based on the norm distance

Previously, we were using a distance algorithm that choose
the manhattan distance.  Now we move to use the Euclidian norm
distance instead in hopes of decreasing the usage of very general nodes

Speed up norm distance calculation by storing the node's level
in the Entry() object when parsing group tree

Author: connie

rmgpy/data/base.py

@@ -451,7 +451,7 @@ def loadOldDictionary(self, path, pattern):
 
     def __loadTree(self, tree):
         """
-        Parse an old-style RMG tree located at `tree`. An RMG tree is an n-ary
+        Parse an group tree located at `tree`. An RMG tree is an n-ary
         tree representing the hierarchy of items in the dictionary.
         """
 
@@ -498,7 +498,10 @@ def __loadTree(self, tree):
                 else:
                     entry.parent = None
                     self.top.append(entry)
-
+                    
+                # Save the level of the tree into the entry
+                entry.level = level
+                
                 # Add node to list of parents for subsequent iteration
                 parents.append(label)
 

rmgpy/data/kinetics/rules.py

@@ -565,7 +565,25 @@ def __getAverageKinetics(self, kineticsList):
             E0 = (E0*0.001,"kJ/mol"),
         )
         return averagedKinetics
+    
+    def calculateNormDistance(self, template, otherTemplate):
+        """
+        Calculate the norm distance squared between two rate rules with
+        `template` and `otherTemplate`.  The norm distance is 
+        a^2 + b^2 + c^2 .... when a is the distance between the nodes in the
+        first tree, b is the distance between the nodes in the second tree, etc.
+        """
+        
+        # Do it the stupid way first and calculate distances from the top 
+        # rather than from each other for now... it's dumb but need to see results first
+        import numpy
+        depth = numpy.array([node.level for node in template])
+        otherDepth = numpy.array([otherNode.level for otherNode in otherTemplate])
 
+        distance = numpy.array(depth-otherDepth)
+        norm = numpy.dot(distance,distance)
+        return norm
+        
     def estimateKinetics(self, template, degeneracy=1):
         """
         Determine the appropriate kinetics for a reaction with the given
@@ -588,7 +606,14 @@ def getTemplateLabel(template):
                 kineticsList.append([kinetics, t])
 
             if len(kineticsList) > 0:                 
-                                
+                
+                if len(kineticsList) > 1:
+                    # Filter the kinetics to use templates with the lowest minimum euclidean distance 
+                    # from the specified template
+                    norms = [self.calculateNormDistance(template, t) for kinetics,t in kineticsList]
+                    minNorm = min(norms) 
+                    kineticsList = [pair for pair, norm in zip(kineticsList,norms) if norm == min(norms)]
+                    
                 if len(kineticsList) == 1:
                     kinetics, t = kineticsList[0]
                     # Check whether the exact rate rule for the original template (most specific