---

GenObject.py

Go to the documentation of this file.

##  Note: Please do not use or modify any data or functions with a
##  leading underscore.  If you "mess" with the internal structure,
##  the classes may not function as intended.


from FWCore.Python.Enumerate import Enumerate
import re
import os
import copy
import ROOT
import ConfigParser
import PhysicsTools.PythonAnalysis as cmstools
import pprint
import random


class GenObject (object):
    """Infrastruture to define general objects and their attributes."""

    ########################
    ## Static Member Data ##
    ########################

    types              = Enumerate ("float int string", "type")
    _objFunc           = Enumerate ("obj func", "of")
    _cppType           = dict ( {types.float  : 'double',
                                 types.int    : 'int',
                                 types.string : 'std::string' } )
    _defaultValue      = dict ( {types.float  : 0.,
                                 types.int    : 0,
                                 types.string : '""' } )
    _objsDict          = {} # info about GenObjects
    _equivDict         = {} # hold info about 'equivalent' muons
    _ntupleDict        = {} # information about different ntuples
    _tofillDict        = {} # information on how to fill from different ntuples
    _rootObjectDict    = {} # hold objects and stl::vectors to objects
                            # hooked up to a root tree
    _rootClassDict     = {} # holds classes (not instances) associated with
                            # a given GenObject
    _kitchenSinkDict   = {} # dictionary that holds everything else...
    
    #############################
    ## Static Member Functions ##
    #############################

    @staticmethod
    def addObjectVariable (obj, var, **optionsDict):
        """ User passes in in object and variable names."""
        if not optionsDict.has_key ('varType'):
            optionsDict['varType'] = GenObject.types.float
        varType = optionsDict['varType']
        if not GenObject.types.isValidValue (varType):
            print "Type '%s' not valid.  Skipping (%s, %s, %s)." % \
                  (varType, obj, var, varType)
            return
        if not optionsDict.has_key ('default'):
            optionsDict['default'] = GenObject._defaultValue[varType]
        if obj.startswith ("_") or var.startswith ("_"):
            print "Skipping (%s, %s, %s) because of leading underscore." % \
                  (obj, var, varType)
            return
        GenObject._objsDict.setdefault (obj, {}).setdefault (var, optionsDict)


    @staticmethod
    def getVariableProperty (obj, var, key):
        """Returns property assoicated with 'key' for variable 'var'
        of object 'obj'.  Returns 'None' if any of the above are not
        defined."""
        return GenObject._objsDict.get (obj, {}).get (var, {}). get (key, None)


    @staticmethod
    def setEquivExpression (obj, variable, precision):
        """Adds an equivalence constraint.  Must have at least one to
        compare GO objects."""
        if obj.startswith ("_"):
            print "Skipping (%s, %s) because of leading underscore." % \
                  (obj, expression)
            return
        GenObject._equivDict.setdefault (obj,[]).append ( (variable,
                                                           precision) )
        
    
    @staticmethod
    def printStatic():
        """Meant for debugging, but ok if called by user"""
        print "objs: "
        pprint.pprint (GenObject._objsDict,   indent=4)
        print "equiv: "
        pprint.pprint (GenObject._equivDict,  indent=4)
        print "ntuple: "
        pprint.pprint (GenObject._ntupleDict, indent=4)
        print "tofill: "
        pprint.pprint (GenObject._tofillDict, indent=4)
        print "kitchenSink: "
        pprint.pprint (GenObject._kitchenSinkDict, indent=4)


    @staticmethod
    def checksum (str):
        """Calculates a checksum of a string.  Returns it as a hex
        string"""
        return hex( reduce( lambda x, y : x + y, map(ord, str) ) )[2:]


    @staticmethod
    def rootClassName (objName):
        """Returns the name of the equivalent Root object"""
        return "go_" + objName


    @staticmethod
    def _createCppClass (objName):
        """Returns a string containing the '.C' file necessary to
        generate a shared object library with dictionary."""
        if not GenObject._objsDict.has_key (objName):
            # not good
            print "Error: GenObject does not know about object '%s'." % objName
            raise RuntimeError, "Failed to create C++ class."
        classname = GenObject.rootClassName (objName)
        retval = "#include <string>\n#include <vector>\n" \
                 + "using namespace std;\n\nclass %s\n" % classname
        retval = retval + "{\n  public:\n"
        retval = retval + "      typedef std::vector< %s > Collection;\n\n" \
                 % classname
        # constructor
        retval = retval + "      %s() :\n" % classname
        datadec = "\n      // data members\n"
        first = True
        for key in sorted( GenObject._objsDict[objName].keys() ):
            if key.startswith ("_"): continue
            varTypeList = GenObject._objsDict[objName][key]
            cppType = GenObject._cppType[ varTypeList['varType'] ]
            default = varTypeList['default']
            if first:
                first = False
            else:
                retval = retval + ",\n"
            retval = retval + "         %s (%s)" % (key, default)
            # definition
            datadec  = datadec + "      %s %s;\n" % (cppType, key)
        retval = retval + "\n      {}\n" + datadec
        retval = retval + "};\n";
        retval = retval + "#ifdef __MAKECINT__\n#pragma link C++ class " + \
                 "vector< %s >+;\n#endif\n\n" % classname
        return retval


    @staticmethod
    def _loadGoRootLibrary ():
        """Loads Root shared object library associated with all
        defined GenObjects. Will create library if necessary."""
        print "Loading GO Root Library"
        key = "_loadedLibrary"        
        if GenObject._kitchenSinkDict.get (key):
            # Already done, don't do it again:
            return
        # Mark it as done
        GenObject._kitchenSinkDict[key] = True
        # Generate source code
        sourceCode = ""
        for objClassName in sorted( GenObject._objsDict.keys() ):
            sourceCode = sourceCode + GenObject._createCppClass (objClassName)
        GenObjectRootLibDir = "genobjectrootlibs"
        if not os.path.exists (GenObjectRootLibDir):
            os.mkdir (GenObjectRootLibDir)
        key = GenObject.checksum( sourceCode )
        basename = "%s_%s" % ("GenObject", key)
        SO = "%s/%s_C" % (GenObjectRootLibDir, basename)
        linuxSO = "%s.so" % SO
        windowsSO = "%s.dll" % SO
        if not os.path.exists (linuxSO) and not os.path.exists (windowsSO):
            print "creating SO"
            filename = "%s/%s.C" % (GenObjectRootLibDir, basename)
            if not os.path.exists (filename):
                print "creating .C file"
                target = open (filename, "w")
                target.write (sourceCode)
                target.close()
            else:
                print "%s exists" % filename
            command = "echo .L %s+ | root.exe -b" % filename
            os.system (command)
        ROOT.gSystem.Load(SO)
        return


    @staticmethod
    def _tofillGenObject():
        """Makes sure that I know how to read root files I made myself"""
        genObject = "GenObject"
        ntupleDict = GenObject._ntupleDict.setdefault (genObject, {})
        ntupleDict['_useChain'] = True
        ntupleDict['_tree'] = "goTree"
        for objName in GenObject._objsDict.keys():
            rootObjName = GenObject.rootClassName (objName)
            if GenObject.isSingleton (objName):
                ntupleDict[objName] = objName
            else:
                ntupleDict[objName] = objName + "s"
            tofillDict = GenObject._tofillDict.\
                         setdefault (genObject, {}).\
                         setdefault (objName, {})
            for varName in GenObject._objsDict [objName].keys():
                # if the key starts with an '_', then it is not a
                # variable, so don't treat it as one.
                if varName.startswith ("_"):
                    continue
                tofillDict[varName] = [ [(varName, GenObject._objFunc.obj)],
                                        {}]


    @staticmethod
    def prepareToLoadGenObject():
        """Makes all necessary preparations to load root files created
        by GenObject."""
        GenObject._tofillGenObject()
        GenObject._loadGoRootLibrary()


    @staticmethod
    def loadConfigFile (configFile):
        """Loads configuration file"""
        objName    = ""
        tupleName  = ""
        tofillName = ""
        modeEnum   = Enumerate ("none define tofill ntuple", "mode")
        mode       = modeEnum.none
        config     = ConfigParser.SafeConfigParser()
        config.read (configFile)
        for section in config.sections():
            pieces = re.split (r'\s+', section)
            if not len (pieces): continue
            objName, pieces = pieces[0], pieces[1:]
            colonMatch = re.search (r'(.+?):(.+?):(.+)', objName)
            mode = modeEnum.none
            if colonMatch:
                ##########################
                ## Object 'tofill' Info ##
                ##########################
                mode = modeEnum.tofill
                objName    = colonMatch.group (1)
                tupleName  = colonMatch.group (2)
                tofillName = colonMatch.group (3)
                ntupleDict = GenObject._ntupleDict.\
                             setdefault (tupleName, {})
                ntupleDict[objName] = tofillName
                for word in pieces:
                    aliasMatch = re.search (r'alias=(\S+)', word)
                    if aliasMatch:
                        myTuple = (tofillName, aliasMatch.group (1))
                        ntupleDict.setdefault ('_alias', []).append (myTuple)
                        continue
                    # If we're still here, then we didn't have a valid
                    # option.  Complain vociferously
                    print "I don't understand '%s' in section '%s' : %s" \
                          % (word, section, mode)
                    raise RuntimeError, "Config file parsing error"
            else:
                colonMatch = re.search (r'(.+?):(.+)', objName)
                if colonMatch:
                    #######################
                    ## Ntuple Definition ##
                    #######################
                    mode = modeEnum.ntuple
                    ntupleDict = GenObject._ntupleDict.\
                                setdefault (colonMatch.group(1), {})
                    ntupleDict['_tree'] = colonMatch.group(2)
            if not re.search (r':', section):
                ##########################
                ## GenObject Definition ##
                ##########################
                mode = modeEnum.define
                for word in pieces:
                    if re.match (r'singleton', word, re.IGNORECASE):
                        #GenObject._singletonSet.add (objName)
                        objsDict = GenObject._objsDict.setdefault (objName, {})
                        objsDict['_singleton'] = True
                        continue
                    # If we're still here, then we didn't have a valid
                    # option.  Complain vociferously
                    print "I don't understand '%s' in section '%s' : %s" \
                          % (word, section, mode)
                    raise RuntimeError, "Config file parsing error"
            if modeEnum.none == mode:
                # Poorly formatted 'section' tag
                print "I don't understand section '%s'." % section
                raise RuntimeError, "Config file parsing error"
            for varName in config.options (section):
                option = config.get (section, varName)
                if option:
                    pieces = re.split (r'\s+', option)
                else:
                    pieces = []
                if modeEnum.define == mode:
                    #########################
                    ## Variable Definition ##
                    #########################
                    # is this a variable or an option?
                    if varName.startswith("-"):
                        # this is an option
                        if "-equiv" == varName.lower():
                            for part in pieces:
                                halves = part.split (",")
                                if 2 != len (halves):
                                    print "Problem with -equiv '%s' in '%s'" % \
                                          (part, section)
                                    raise RuntimeError, \
                                          "Config file parsing error"
                                if halves[1]:
                                    halves[1] = float (halves[1])
                                    if not halves[1] > 0:
                                        print "Problem with -equiv ",\
                                              "'%s' in '%s'" % \
                                              (part, section)
                                        raise RuntimeError, \
                                              "Config file parsing error"
                                GenObject.setEquivExpression (section,
                                                              halves[0],
                                                              halves[1])
                        continue
                    # If we're here, then this is a variable
                    optionsDict = {}
                    for word in pieces:
                        typeMatch = re.search (r'type=(\S+)', word)
                        if typeMatch and \
                               GenObject.types.isValidKey (typeMatch.group(1)):
                            varType = typeMatch.group(1).lower()
                            optionsDict['varType'] = GenObject.types (varType)
                            continue
                        defaultMatch = re.search (r'default=(\S+)', word)
                        if defaultMatch:
                            optionsDict['default'] = defaultMatch.group(1)
                            continue
                        precMatch =  re.search (r'prec=(\S+)', word)
                        if precMatch:
                            optionsDict['prec'] = float (precMatch.group (1))
                            continue
                        formMatch =  re.search (r'form=(\S+)', word)
                        if formMatch:
                            optionsDict['form'] = formMatch.group (1)
                            continue
                        # If we're still here, then we didn't have a valid
                        # option.  Complain vociferously
                        print "I don't understand '%s' in section '%s'." \
                              % (word, option)
                        raise RuntimeError, "Config file parsing error"
                    GenObject.addObjectVariable (objName, varName, \
                                                 **optionsDict)
                else:
                    ############################
                    ## Variable 'tofill' Info ##
                    ############################
                    if len (pieces) < 1:
                        continue
                    fillname, pieces = pieces[0], pieces[1:]
                    parts = re.split (r'\s*\.\s*', fillname)
                    partsList = []
                    for part in parts:
                        parenMatch = re.search (r'(.+)\(.*\)', part)
                        mode = GenObject._objFunc.obj
                        if parenMatch:
                            part = parenMatch.group (1)
                            mode = GenObject._objFunc.func
                        partsList.append(  (part, mode) )
                    # I don't yet have any options available here, but
                    # I'm keeping the code here for when I add them.
                    optionsDict = {}
                    for word in pieces:
                        # If we're still here, then we didn't have a valid
                        # option.  Complain vociferously
                        print "I don't understand '%s' in section '%s'." \
                              % (word, option)
                        raise RuntimeError, "Config file parsing error"
                    tofillDict = GenObject._tofillDict.\
                                 setdefault (tupleName, {}).\
                                 setdefault (objName, {})
                    tofillDict[varName] = [partsList, optionsDict]


    @staticmethod
    def _genObjectClone (objName, tupleName, obj):
        """Creates a GenObject copy of Root object"""
        tofillObjDict = GenObject._tofillDict.get(tupleName, {})\
                        .get(objName, {})
        genObj = GenObject (objName)
        origObj = obj
        #print "obj", objName
        for genVar, ntDict in tofillObjDict.iteritems():
            partsList = ntDict[0]
            for part in partsList:
                #print "  ", part
                obj = getattr (obj, part[0])
            if GenObject._objFunc.func == part[1]:                
                obj = obj()
            setattr (genObj, genVar, obj)
            obj = origObj
        return genObj


    @staticmethod
    def _rootObjectCopy (goSource, rootTarget):
        """Copies information from goSourse into Root Object"""
        objName = goSource._objName
        for varName in GenObject._objsDict [objName].keys():
            # if the key starts with an '_', then it is not a
            # variable, so don't treat it as one.
            if varName.startswith ("_"):
                continue
            setattr( rootTarget, varName, goSource (varName) )
        
        
    @staticmethod
    def _rootObjectClone (obj):
        """Creates the approprite type of Root object and copies the
        information into it from the GO object."""
        objName = obj._objName
        rootObj = GenObject._rootClassDict[objName]()
        for varName in GenObject._objsDict [objName].keys():
            setattr( rootObj, varName, obj (varName) )
        return rootObj


    @staticmethod
    def setupOutputTree (outputfile, treename, treeDescription = "",
                         otherNtupleName = ""):
        """Opens the output file, loads all of the necessary shared
        object libraries, and returns the output file and tree.  If
        'otherNtupleName' is given, it will check and make sure that
        only objects that are defined in it are written out."""
        rootfile = ROOT.TFile.Open (outputfile, "recreate")
        tree = ROOT.TTree (treename, treeDescription)
        GenObject._loadGoRootLibrary()
        for objName in sorted (GenObject._objsDict.keys()):
            classname = GenObject.rootClassName (objName)
            rootObj = \
                    GenObject._rootClassDict[objName] = \
                    getattr (ROOT, classname)
            if GenObject.isSingleton (objName):
                # singleton object
                obj = GenObject._rootObjectDict[objName] = rootObj()
                tree.Branch (objName, classname, obj)
            else:
                # vector of objects - PLEASE don't forget the '()' on
                # the end of the declaration.  Without this, you are
                # defining a type, not instantiating an object.
                vec = \
                    GenObject._rootObjectDict[objName] = \
                    ROOT.std.vector( rootObj )()
                
                branchName = objName + "s"
                vecName = "vector<%s>" % classname
                tree.Branch( branchName, vecName, vec)
            # end else if isSingleton
        # end for objName
        return rootfile, tree


    @staticmethod
    def _fillRootObjects (event):
        """Fills root objects from GenObject 'event'"""
        for objName, obj in sorted (event.iteritems()):
            if GenObject.isSingleton (objName):
                # Just one
                GenObject._rootObjectCopy (obj,
                                           GenObject._rootObjectDict[objName])
            else:
                # a vector
                vec = GenObject._rootObjectDict[objName]
                vec.clear()
                for goObj in obj:
                    vec.push_back( GenObject._rootObjectClone (goObj) )


    @staticmethod
    def isSingleton (objName):
        """Returns true if object is a singleton"""
        return GenObject._objsDict[objName].get('_singleton')


    @staticmethod
    def loadEventFromTree (eventTree, eventIndex,
                           onlyRunEvent  = False):
        """Loads event information from Root file (as interfaced by
        'cmstools.EventTree' or 'ROOT.TChain').  Returns a dictionary
        'event' containing lists of objects or singleton object.  If
        'onlyRunEvent' is et to True, then only run and event number
        is read in from the tree."""
        tupleName = GenObject._kitchenSinkDict[eventTree]['tupleName']
        event = {}
        # is this a cint tree
        isChain = eventTree.__class__.__name__ == 'TChain'
        if isChain:
            # This means that 'eventTree' is a ROOT.TChain
            eventTree.GetEntry (eventIndex)
        else:
            # This means that 'evenTree' is a cmstools.EventTree
            rootEvent = eventTree[eventIndex]
        tofillDict = GenObject._tofillDict.get (tupleName)
        ntupleDict = GenObject._ntupleDict.get (tupleName)
        if not tofillDict:
            print "Don't know how to fill from '%s' ntuple." % tupleName
            return
        eventBranchName = ntupleDict['runevent']
        for objName in tofillDict:
            branchName = ntupleDict[objName]
            if onlyRunEvent and branchName != eventBranchName:
                # not now
                continue
            # Have we been given 'tofill' info for this object?
            if not branchName:
                # guess not
                continue
            if isChain:
                objects = getattr (eventTree, branchName)
            else:
                objects = rootEvent.getProduct (branchName)
            # is this a singleton?
            if GenObject.isSingleton (objName):
                event[objName] = GenObject.\
                                 _genObjectClone (objName,
                                                  tupleName,
                                                  objects)
                continue
            # if we're here then we have a vector of items
            event[objName] = []
            for obj in objects:
                event[objName].append( GenObject.\
                                       _genObjectClone (objName,
                                                        tupleName,
                                                        obj) )
            # end for obj
        # end for objName
        return event


    @staticmethod
    def printEvent (event):
        """Prints out event dictionary.  Mostly for debugging"""
        # Print out all singletons first
        for objName, obj in sorted (event.iteritems()):
            #obj = event[objName]
            # is this a singleton?
            if GenObject.isSingleton (objName):
                print "%s: %s" % (objName, obj)
        # Now print out all vectors
        for objName, obj in sorted (event.iteritems()):
            #obj = event[objName]
            # is this a singleton?
            if not GenObject.isSingleton (objName):
                # o.k. obj is a vector
                print "%s:" % objName
                for single in obj:
                    print "  ", single
        print


    @staticmethod
    def setAliases (eventTree, tupleName):
        """runs SetAlias on all saved aliases"""
        aliases = GenObject._ntupleDict[tupleName].get('_alias', [])
        for alias in aliases:
            eventTree.SetAlias (alias[0], alias[1])


    @staticmethod
    def prepareTuple (tupleName, files):
        """Given the tuple name and list of files, returns either a
        TChain or EventTree, and number of entries"""
        if "GenObject" == tupleName:
            GenObject.prepareToLoadGenObject()            
        if isinstance (files, list):
            # for now, we can only deal with one file
            files = files[0:1]
        else:
            # If this isn't a list, make it one
            files = [files]
        ntupleDict = GenObject._ntupleDict[tupleName]
        treeName = ntupleDict["_tree"]
        chain = ROOT.TChain (treeName)
        for filename in files:
            chain.AddFile (filename)
        numEntries = chain.GetEntries()
        # Are we using a chain or EventTree here?
        if not ntupleDict.get('_useChain'):
            # cmstools.EventTree
            chain = cmstools.EventTree (chain)
            GenObject.setAliases (chain, tupleName)
        chainDict = GenObject._kitchenSinkDict.setdefault (chain, {})
        chainDict['numEntries'] = numEntries
        chainDict['tupleName' ] = tupleName
        return chain


    @staticmethod
    def getRunEventEntryDict (chain, tupleName, numEntries):
        """Returns a dictionary of run, event tuples to entryIndicies"""
        reeDict = {}
        for entryIndex in xrange (numEntries):
            event = GenObject.loadEventFromTree (chain,
                                                 entryIndex,
                                                 onlyRunEvent = True)
            runevent = event['runevent']
            reeDict[ (runevent.run, runevent.event) ] = entryIndex
        return reeDict


    @staticmethod
    def compareRunEventDicts (firstDict, secondDict):
        """Compares the keys of the two dicts and returns three sets:
        the overlap, first but not second, and second but not first."""
        overlap    = set()
        firstOnly  = set()
        secondOnly = set()
        # loop over the keys of the first dict and compare to second dict
        for key in firstDict.keys():
            if secondDict.has_key (key):
                overlap.add (key)
            else:
                firstOnly.add (key)
        # now loop over keys of second dict and only check for missing
        # entries in first dict
        for key in secondDict.keys():
            if not firstDict.has_key (key):
                secondOnly.add (key)
        # All done
        return overlap, firstOnly, secondOnly


    @staticmethod
    def pairEquivalentObjects (vec1, vec2):
        """Finds the equivalent objects in the two vectors"""
        len1, len2 = len (vec1), len (vec2)
        if not len1 or not len2:
            # Nothing to see here folks.  Keep moving.
            if len1:
                noMatch1Set = set( xrange(len1) )
            else:
                noMatch1Set = set ()
            if len2:
                noMatch2Set = set( xrange(len2) )
            else:
                noMatch2Set = set ()
            return set(), noMatch1Set, noMatch2Set
        objName = vec1[0]._objName
        equivList = GenObject._equivDict[objName]
        firstDict = {}
        secondDict = {}
        # First, look for vec2 objects that are equivalent to a
        # given vec1 object.
        for index1 in xrange (len1):
            objList = []
            obj1 = vec1[index1]
            for index2 in xrange (len2):
                total = 0.
                obj2 = vec2[index2]
                ok = True
                for equiv in equivList:
                    var, precision = equiv[0], equiv[1]
                    val1 = obj1 (var)
                    val2 = obj2 (var)
                    # Do we check equality or a precision
                    if precision:
                        value = abs (val1 - val2) / precision
                        if value > 1.:
                            ok = False
                            break
                        total += value ** 2
                    elif val1 != val2:
                        ok = False
                        break
                if ok:
                    objList.append( (total, index2) )
            objList.sort()
            firstDict[index1] = objList
        # Now do the same thing, but this time look for vec1 objects
        # that are equivalent to a given vec2 object
        for index2 in xrange (len2):
            objList = []
            obj2 = vec2[index2]
            for index1 in xrange (len1):
                total = 0.
                obj1 = vec1[index1]
                ok = True
                for equiv in equivList:
                    var, precision = equiv[0], equiv[1]
                    val2 = obj2 (var)
                    val1 = obj1 (var)
                    # Do we check equality or a precision
                    if precision:
                        value = abs (val2 - val1) / precision
                        if value > 1.:
                            ok = False
                            break
                        total += value ** 2
                    elif val2 != val1:
                        ok = False
                        break
                if ok:
                    objList.append( (total, index1) )
            objList.sort()
            secondDict[index2] = objList
        # O.k. Now that we have the candidate matches, lets see who is
        # really matched.
        matchedSet = set()
        noMatch1Set = set()
        for index1 in firstDict.keys():
            list1 = firstDict[index1]
            # do I have a match?
            if not len (list1):
                # no match
                noMatch1Set.add (index1)
                continue
            # we've got at least one match
            best1 = list1[0]
            index2 = best1[1]
            # Does this one match me?
            list2 = secondDict.get (index2, [])
            if len(list2) and list2[0][1] == index1:
                matchedSet.add( (index1, index2) )
                # get rid of the 2nd key hash
                del secondDict[index2]
            else:
                # no match
                noMatch1Set.add (index1)
        noMatch2Set = set( secondDict.keys() )
        return matchedSet, noMatch1Set, noMatch2Set


    @staticmethod
    def compareTwoItems (item1, item2):
        """Compares all of the variables making sure they are the same
        on the two objects."""
        objName = item1._objName
        problems = {}
        for varName in GenObject._objsDict[objName].keys():
            prec = item1.getVariableProperty (varName, 'prec')
            if prec:
                # we want to check within a precision
                value = abs( item1(varName) - item2(varName) )
                if value > prec:
                    # we've got a problem
                    problems[varName] = value
            else:
                # we want to check equality
                if item1(varName) != item2(varName):
                    # we have a problem.  sort the values
                    val1, val2 = item1(varName), item2(varName)
                    if val1 > val2:
                        val1, val2 = val2, val1
                    problems[varName] = "%s != %s" % (val1, val2)
        # end for
        return problems


    @staticmethod
    def blurEvent (event, value, where = ""):
        for objName in sorted (event.keys()):
            if "runevent" == objName:
                # runevent is a special case.  We don't compare these
                continue
            if GenObject.isSingleton (objName):
                # I'll add this in later.  For now, just skip it
                continue
            count = 0
            for obj in event[objName]:
                count += 1
                for varName in GenObject._objsDict[objName].keys():
                    randNumber = random.random()
                    #print "rN", randNumber
                    if randNumber < GenObject._kitchenSinkDict['blurRate']:
                        print "  %s: changing '%s' of '%s:%d'" \
                              % (where, varName, obj._objName, count)
                        obj.__dict__[varName] += value
        

    @staticmethod
    def compareTwoTrees (chain1, chain2, **kwargs):
        """Given all of the necessary information, this routine will
        go through and compare two trees making sure they are
        'identical' within requested precision."""
        print "Comparing Two Trees"
        tupleName1  = GenObject._kitchenSinkDict[chain1]['tupleName']
        numEntries1 = GenObject._kitchenSinkDict[chain1]['numEntries']
        tupleName2  = GenObject._kitchenSinkDict[chain2]['tupleName']
        numEntries2 = GenObject._kitchenSinkDict[chain2]['numEntries']
        ree1 = GenObject.getRunEventEntryDict (chain1, tupleName1, numEntries1)
        ree2 = GenObject.getRunEventEntryDict (chain2, tupleName2, numEntries2)
        overlap, firstOnly, secondOnly = \
                 GenObject.compareRunEventDicts (ree1, ree2)
        #print "overlap   ", overlap
        problemDict = {}
        if firstOnly:
            #print "firstOnly ", firstOnly
            problemDict.setdefault ('_runevent', {})['firstOnly'] = \
                                   len (firstOnly)
        if secondOnly:
            #print "secondOnly", secondOnly
            problemDict.setdefault ('_runevent', {})['secondOnly'] = \
                                   len (secondOnly)
        for reTuple in overlap:
            event1 = GenObject.loadEventFromTree (chain1, ree1 [reTuple])
            event2 = GenObject.loadEventFromTree (chain2, ree2 [reTuple])
            if GenObject._kitchenSinkDict.get('printEvent'):
                print "event1:"
                GenObject.printEvent (event1)
                print "event2:"
                GenObject.printEvent (event2)
            if GenObject._kitchenSinkDict.get('blur'):
                where = "run %d event %d" % reTuple
                GenObject.blurEvent (event1,
                                     GenObject._kitchenSinkDict['blur'],
                                     where)
            for objName in sorted (event1.keys()):
                if "runevent" == objName:
                    # runevent is a special case.  We don't compare these
                    continue
                if not GenObject._equivDict.get (objName):
                    # we don't know how to compare these objects, so
                    # skip them.
                    continue
                if GenObject.isSingleton (objName):
                    # I'll add this in later.  For now, just skip it
                    continue
                vec1 = event1[objName]
                vec2 = event2[objName]
                matchedSet, noMatch1Set, noMatch2Set = \
                            GenObject.pairEquivalentObjects (vec1, vec2)
                if noMatch1Set or noMatch2Set:
                    ## print "No match 1", noMatch1Set
                    ## print "No match 2", noMatch2Set
                    count1 = len (noMatch1Set)
                    count2 = len (noMatch2Set)
                    key = (count1, count2)
                    countDict = problemDict.\
                                setdefault (objName, {}).\
                                setdefault ('_missing', {})
                    if countDict.has_key (key):
                        countDict[key] += 1
                    else:
                        countDict[key] = 1
                                
                # o.k.  Now that we have them matched, let's compare
                # the proper items:
                for pair in matchedSet:
                    problems = GenObject.\
                               compareTwoItems (vec1[ pair[1 - 1] ],
                                                vec2[ pair[2 - 1] ])
                    if problems.keys():
                        # pprint.pprint (problems)
                        for varName in problems.keys():
                            countDict = problemDict.\
                                        setdefault (objName, {}).\
                                        setdefault ('_var', {})
                            if countDict.has_key (varName):
                                countDict[varName] += 1
                            else:
                                countDict[varName] = 1
                            
            ## print "event 1"
            ## GenObject.printEvent (event1)
            ## print "event 2"
            ## GenObject.printEvent (event2)
            ## print
        return problemDict


    @staticmethod
    def saveTupleAs (chain, rootFile):
        """Saves a chain as a GO tree"""
        print "saveTupleAs"
        rootfile, tree = GenObject.setupOutputTree (rootFile, "goTree")
        numEntries = GenObject._kitchenSinkDict[chain]['numEntries']        
        for entryIndex in xrange (numEntries):
            event = GenObject.loadEventFromTree (chain, entryIndex)            
            if GenObject._kitchenSinkDict.get('blur'):
                where = "run %d event %d" % (event['runevent'].run,
                                             event['runevent'].event)
                if random.random() < GenObject._kitchenSinkDict.get('blur'):
                    # dropping event
                    print "Dropping", where
                    continue
                GenObject.blurEvent (event,
                                     GenObject._kitchenSinkDict['blur'],
                                     where)
                # check to see if we should drop the event
            if GenObject._kitchenSinkDict.get('printEvent'):
                GenObject.printEvent (event)
            GenObject._fillRootObjects (event)
            tree.Fill()
        tree.Write()
        rootfile.Close()


    @staticmethod
    def try1 ():
        """A temporary function for development"""
        # Set a random seed for 'blurEvents'
        if False:
            tupleName = "pat"
            chain = GenObject.prepareTuple (tupleName,
                                            "PatAnalyzerSkeletonSkim.root")
        else:
            tupleName = "GenObject"
            chain = GenObject.prepareTuple (tupleName,
                                            "go1.root")
        event = {}
        GenObject.compareTwoTrees (chain, chain, blur=True)
        return
    
        
    ######################
    ## Member Functions ##
    ######################


    def __init__ (self, objName):
        """Class initializer"""
        if not GenObject._objsDict.has_key (objName):# or \
            #not GenObject._equivDict.has_key (objName) :
            # not good
            print "Error: GenObject does not know about object '%s'." % objName
            raise RuntimeError, "Failed to create GenObject object."
        self._localObjsDict = GenObject._objsDict [objName]
        self._objName = objName;
        for key, varDict in self._localObjsDict.iteritems():
            # if the key starts with an '_', then it is not a
            # variable, so don't treat it as one.
            if key.startswith ("_"):
                continue
            self.setValue (key, varDict['default'])
            

    def setValue (self, name, value):
        """Wrapper for __setattr___"""
        self.__setattr__ (name, value)

    
    def getVariableProperty (self, var, key):
        """ Returns property assoicated with 'key' for variable 'var'
        of object of the same type as 'self'.  Returns 'None' if 'var'
        or 'key' is not defined."""
        return GenObject._objsDict.get (self._objName,
                                        {}).get (var, {}). get (key, None)


    def __setattr__ (self, name, value):
        """Controls setting of values."""
        if name.startswith ("_"):
            # The internal version. Set anything you want.
            object.__setattr__ (self, name, value)
        else:
            # user version - Make sure this variable has already been

            # defined for this type:
            if not self._localObjsDict.has_key (name):
                # this variable has not been defined
                print "Warning: '%s' for class '%s' not setup. Skipping." % \
                      (name, self._objName)
                return
            varType = self.getVariableProperty (name, 'varType')
            # if this is an int, make sure it stays an int
            if GenObject.types.int == varType:
                try:
                    # This will work with integers, floats, and string
                    # representations of integers.
                    value = int (value)
                except:
                    # This works with string representations of floats
                    value = int( float( value ) )
            elif GenObject.types.float == varType:
                # Make sure it's a float
                value = float (value)
            elif GenObject.types.string == varType:
                # make sure it's a string
                value = str (value)
            # if we're still here, set it
            object.__setattr__ (self, name, value)


    def __call__ (self, key):
        """Makes object callable"""
        return object.__getattribute__ (self, key)


    def __str__ (self):
        """String representation"""
        retval = ""
        for varName, value in sorted (self.__dict__.iteritems()):
            if varName.startswith ('_'): continue
            form = self.getVariableProperty (varName, "form")
            if form:
                format = "%s:%s  " % (varName, form)
                retval = retval + format % value
            else:
                retval = retval + "%s:%s  " % (varName, value)
        return retval

---