GenObject.GenObject Class Reference

Inheritance diagram for GenObject.GenObject:

Public Member Functions
def	__call__ (self, key)
def	__init__ (self, objName)
	Member Functions ##. More...
def	__setattr__ (self, name, value)
def	__str__ (self)
def	getVariableProperty (self, var, key)
def	setValue (self, name, value)

Static Public Member Functions
def	addObjectVariable (obj, var, optionsDict)
def	ascii2char (match)
def	blurEvent (event, value, where="")
def	changeAlias (tupleName, name, alias)
def	changeLabel (tupleName, objectName, label)
def	changeVariable (tupleName, objName, varName, fillname)
def	char2ascii (match)
	Static Member Functions ##. More...
def	checksum (str)
def	compareRunEventDicts (firstDict, secondDict)
def	compareTwoItems (item1, item2)
def	compareTwoTrees (chain1, chain2, kwargs)
def	decodeNonAlphanumerics (line)
def	encodeNonAlphanumerics (line)
def	evaluateFunction (obj, partsList, debug=False)
def	getRunEventEntryDict (chain, tupleName, numEntries)
def	getVariableProperty (obj, var, key)
def	isSingleton (objName)
def	loadConfigFile (configFile)
def	loadEventFromTree (eventTree, eventIndex, onlyRunEvent=False)
def	pairEquivalentObjects (vec1, vec2)
def	parseVariableTofill (fillname)
def	prepareToLoadGenObject ()
def	prepareTuple (tupleName, files, numEventsWanted=0)
def	printEvent (event)
def	printGlobal ()
def	printTuple (chain)
def	rootClassName (objName)
def	rootDiffClassName (objName)
def	rootDiffContClassName (objName)
def	saveTupleAs (chain, rootFile)
def	setAliases (eventTree, tupleName)
def	setEquivExpression (obj, variable, precision)
def	setGlobalFlag (key, value)
def	setupDiffOutputTree (outputFile, diffName, missingName, diffDescription='', missingDescription='')
def	setupOutputTree (outputFile, treeName, treeDescription="", otherNtupleName="")

Static Public Attributes
	types
	Static Member Data ##. More...
	uselessReturnCode

Static Private Member Functions
def	_convertStringToParameters (string)
def	_createCppClass (objName)
def	_fillRootDiffs (event1, event2)
def	_fillRootObjects (event)
def	_finishClassHeader (className, datadec)
def	_fixLostGreaterThans (handle)
def	_genObjectClone (objName, tupleName, obj, index=-1)
def	_key2re (key, runevent=None)
def	_loadGoRootLibrary ()
def	_re2key (runevent)
def	_rootDiffObject (obj1, obj2, rootObj=0)
def	_rootObjectClone (obj)
def	_rootObjectCopy (goSource, rootTarget)
def	_setupClassHeader (className, noColon=False)
def	_tofillGenObject ()

Private Attributes
	_localObjsDict
	_objName

Static Private Attributes
	_aliasRE
	_basicSet
	_bracketRE
	_colonRE
	_commaRE
	_commentRE
	_cppType
	_defaultRE
	_defaultValue
	_dotRE
	_doubleColonRE
	_doublePercentRE
	_doubleQuoteRE
	_equivDict
	_formRE
	_kitchenSinkDict
	_labelRE
	_nonAlphaRE
	_nonSpacesRE
	Compile Regexs ##. More...
	_ntupleDict
	_objFunc
	_objsDict
	_parenRE
	_percentAsciiRE
	_precRE
	_rootClassDict
	_rootObjectDict
	_runEventList
	_runEventListDone
	_shortcutRE
	_singleColonRE
	_singleQuoteRE
	_singletonRE
	_spacesRE
	_tofillDict
	_typeRE

Detailed Description

Infrastruture to define general objects and their attributes.

Definition at line 55 of file GenObject.py.

Constructor & Destructor Documentation

__init__()

def GenObject.GenObject.__init__	(		self,
			objName
	)

Member Functions ##.

Class initializer

Definition at line 1545 of file GenObject.py.

References print().

    def __init__ (self, objName):
        """Class initializer"""
        if objName not in GenObject._objsDict:# 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.items():
            # 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'])
            

Member Function Documentation

__call__()

def GenObject.GenObject.__call__	(		self,
			key
	)

Makes object callable

Definition at line 1617 of file GenObject.py.

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

__setattr__()

def GenObject.GenObject.__setattr__	(		self,
			name,
			value
	)

Controls setting of values.

Definition at line 1575 of file GenObject.py.

References GenObject.GenObject._localObjsDict, GenObject.GenObject._objName, nano_mu_digi_cff.float, GenObject.GenObject.getVariableProperty(), createfilelist.int, and print().

Referenced by GenObject.GenObject.setValue().

    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 name not in self._localObjsDict:
                # 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.long == varType:
                try:
                    # This will work with integers, floats, and string
                    # representations of integers.
                    value = long (value)
                except:
                    # This works with string representations of floats
                    value = long( 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)

__str__()

def GenObject.GenObject.__str__

(

self

)

String representation

Definition at line 1622 of file GenObject.py.

References GenObject.GenObject.getVariableProperty(), and mps_monitormerge.items.

    def __str__ (self):
        """String representation"""
        retval = ""
        for varName, value in sorted (self.__dict__.items()):
            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

_convertStringToParameters()

def GenObject.GenObject._convertStringToParameters (   string )

staticprivate

Convert comma-separated string into a python3 list of
parameters.  Currently only understands strings, floats, and
integers.

Definition at line 1506 of file GenObject.py.

    def _convertStringToParameters (string):
        """Convert comma-separated string into a python3 list of
        parameters.  Currently only understands strings, floats, and
        integers."""
        retval = []        
        words = GenObject._commaRE.split (string)
        for word in words:
            if not len (word):
                continue
            match = GenObject._singleQuoteRE.search (word)
            if match:
                retval.append (match.group (1))
                continue
            match = GenObject._doubleQuoteRE.search (word)
            if match:
                retval.append (match.group (1))
                continue
            try:
                val = int (word)
                retval.append (val)
                continue
            except:
                pass
            try:
                val = float (word)
                retval.append (val)
                continue
            except:
                pass
            # if we're still here, we've got a problem
            raise RuntimeError("Unknown parameter '%s'." % word)
        return retval

        

_createCppClass()

def GenObject.GenObject._createCppClass (   objName )

staticprivate

Returns a string containing the '.C' file necessary to
generate a shared object library with dictionary.

Definition at line 244 of file GenObject.py.

References relativeConstraints.keys, and print().

    def _createCppClass (objName):
        """Returns a string containing the '.C' file necessary to
        generate a shared object library with dictionary."""
        if objName not in GenObject._objsDict:
            # not good
            print("Error: GenObject does not know about object '%s'." % objName)
            raise RuntimeError("Failed to create C++ class.")
        className   = GenObject.rootClassName (objName)
        diffName    = GenObject.rootDiffClassName (objName)
        contName    = GenObject.rootDiffContClassName (objName)
        goClass     = GenObject._setupClassHeader (className)
        diffClass   = GenObject._setupClassHeader (diffName)
        contClass   = GenObject._setupClassHeader (contName, noColon = True)
        goDataDec   = diffDataDec = contDataDec = "\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:
                goClass   += ",\n"
                diffClass += ',\n'
            goClass   += "         %s (%s)" % (key, default)
            goDataDec += "      %s %s;\n" % (cppType, key)
            # is this a basic class?
            goType = varTypeList['varType']
            if goType in GenObject._basicSet:
                # basic type
                diffClass   += "         %s (%s),\n" % (key, default)
                diffDataDec += "      %s %s;\n" % (cppType, key)
                if goType == GenObject.types.string:
                    # string
                    otherKey = 'other_' + key
                    diffClass   += "         %s (%s)" % (otherKey, default)
                    diffDataDec += "      %s %s;\n" % (cppType, otherKey)
                else:
                    # float, long, or int
                    deltaKey = 'delta_' + key
                    diffClass   += "         %s (%s)" % (deltaKey, default)
                    diffDataDec += "      %s %s;\n" % (cppType, deltaKey)
            else:
                raise RuntimeError("Shouldn't be here yet.")
            # definition
        # do contClass
        if GenObject.isSingleton (objName):
            # singleton
            contDataDec += "      %s diff;\n" % diffName
            contDataDec += "      void setDiff (const %s &rhs)" % diffName + \
                           " { diff = rhs; }\n"
        else:
            # vector of objects
            contDataDec += "      void clear() {firstOnly.clear(); secondOnly.clear(); diff.clear(); }\n"
            contDataDec += "      %s::Collection firstOnly;\n"  % className
            contDataDec += "      %s::Collection secondOnly;\n" % className
            contDataDec += "      %s::Collection diff;\n"       % diffName
            # give me a way to clear them all at once
        # Finish off the classes
        goClass   += GenObject._finishClassHeader (className, goDataDec)
        diffClass += GenObject._finishClassHeader (diffName,  diffDataDec)
        contClass += GenObject._finishClassHeader (contName,  contDataDec)
        if objName == 'runevent':
            # we don't want a diff class for this
            diffClass = ''
            contClass = ''
        return goClass + diffClass + contClass

_fillRootDiffs()

def GenObject.GenObject._fillRootDiffs (   event1,   event2  )

staticprivate

Fills root diff containers from two GenObject 'event's

Definition at line 863 of file GenObject.py.

    def _fillRootDiffs (event1, event2):
        """Fills root diff containers from two GenObject 'event's"""
        

_fillRootObjects()

def GenObject.GenObject._fillRootObjects (   event )

staticprivate

Fills root objects from GenObject 'event'

Definition at line 847 of file GenObject.py.

    def _fillRootObjects (event):
        """Fills root objects from GenObject 'event'"""
        for objName, obj in sorted (event.items()):
            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) )

_finishClassHeader()

def GenObject.GenObject._finishClassHeader (   className,   datadec  )

staticprivate

Returns a stringg with the end of a class definition

Definition at line 235 of file GenObject.py.

    def _finishClassHeader (className, datadec):
        """Returns a stringg with the end of a class definition"""
        retval  = "\n      {}\n" + datadec + "};\n"
        retval += "#ifdef __MAKECINT__\n#pragma link C++ class " + \
                 "vector< %s >+;\n#endif\n\n" % className
        return retval

_fixLostGreaterThans()

def GenObject.GenObject._fixLostGreaterThans (   handle )

staticprivate

Definition at line 409 of file GenObject.py.

References print().

    def _fixLostGreaterThans (handle):
        offset = handle.count ('<') - handle.count('>')
        if not offset:
            return handle
        if offset < 0:
            print("Huh?  Too few '<' for each '>' in handle '%'" % handle)
            return handle
        return handle + ' >' * offset

_genObjectClone()

def GenObject.GenObject._genObjectClone (   objName,   tupleName,   obj,   index = -1  )

staticprivate

Creates a GenObject copy of Root object

Definition at line 693 of file GenObject.py.

    def _genObjectClone (objName, tupleName, obj, index = -1):
        """Creates a GenObject copy of Root object"""
        debug = GenObject._kitchenSinkDict.get ('debug', False)
        if objName == 'runevent':
            debug = False
        tofillObjDict = GenObject._tofillDict.get(tupleName, {})\
                        .get(objName, {})
        genObj = GenObject (objName)
        origObj = obj
        if debug: warn (objName, spaces = 9)
        for genVar, ntDict in tofillObjDict.items():
            if debug: warn (genVar, spaces = 12)
            # lets work our way down the list
            partsList = ntDict[0]
            # start off with the original object
            obj = GenObject.evaluateFunction (origObj, partsList, debug)
            if debug: warn (obj, spaces=12)
            setattr (genObj, genVar, obj)
        # Do I need to store the index of this object?
        if index >= 0:
            setattr (genObj, 'index', index)
        return genObj

_key2re()

def GenObject.GenObject._key2re (   key,   runevent = None  )

staticprivate

Given a key, returns a GO 'runevent' object

Definition at line 1068 of file GenObject.py.

References createfilelist.int.

    def _key2re (key, runevent=None):
        """Given a key, returns a GO 'runevent' object"""
        if not runevent:
            runevent = GenObject ('runevent')
        words = GenObject._spacesRE.split (key)
        for word in words:
            match = GenObject._singleColonRE.search (word)
            if match:
                # for now, I'm assuming everything in the runevent
                # tuple is an integer.  If this isn't the case, I'll
                # have to come back and be more clever here.
                runevent.__setattr__ (match.group(1), int( match.group(2) ))
        return runevent
                                     

_loadGoRootLibrary()

def GenObject.GenObject._loadGoRootLibrary ( )

staticprivate

Loads Root shared object library associated with all
defined GenObjects. Will create library if necessary.

Definition at line 315 of file GenObject.py.

References print().

    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 = "#include <string>\n#include <vector>\n" \
                     + "using namespace std;\n"
        for objClassName in sorted( GenObject._objsDict.keys() ):
            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)
            
            ROOT.gSystem.CompileMacro (filename, "k")
        else:
            print("loading %s" % SO)
            ROOT.gSystem.Load(SO)
        return

_re2key()

def GenObject.GenObject._re2key (   runevent )

staticprivate

Given a GO 'runevent' object, returns a sortable key

Definition at line 1045 of file GenObject.py.

    def _re2key (runevent):
        """Given a GO 'runevent' object, returns a sortable key"""
        # if we don't know how to make this object yet, let's figure
        # it out
        if not GenObject._runEventListDone:
            GenObject._runEventListDone = True
            ignoreSet = set( ['run', 'event'] )
            for varName in sorted (runevent.__dict__.keys()):
                if varName.startswith ('_') or varName in ignoreSet:
                    continue
                form = runevent.getVariableProperty (varName, "form")
                if not form:
                    form = '%s'                
                GenObject._runEventList.append ((varName, form))
        key = 'run:%d event:%d' % (runevent.run, runevent.event)
        for items in GenObject._runEventList:
            varName = items[0]
            form    = ' %s:%s' % (varName, items[1])
            key += form % runevent.getVariableProperty (varName)
        return key

_rootDiffObject()

def GenObject.GenObject._rootDiffObject (   obj1,   obj2,   rootObj = 0  )

staticprivate

Given to GOs, it will create and fill the corresponding
root diff object

Definition at line 745 of file GenObject.py.

References relativeConstraints.keys, and GenObject.GenObject.setupOutputTree().

    def _rootDiffObject (obj1, obj2, rootObj = 0):
        """Given to GOs, it will create and fill the corresponding
        root diff object"""
        objName = obj1._objName
        # if we don't already have a root object, create one
        if not rootObj:
            diffName = GenObject.rootDiffClassName( objName )
            rootObj = GenObject._rootClassDict[diffName]()
        for varName in GenObject._objsDict [objName].keys():
            if varName.startswith ("_"): continue
            goType = GenObject._objsDict[objName][varName]['varType']
            if not goType in GenObject._basicSet:
                # not yet
                continue
            setattr( rootObj, varName, obj1 (varName) )            
            if  goType == GenObject.types.string:
                # string
                otherName = 'other_' + varName
                if obj1 (varName) != obj2 (varName):
                    # don't agree
                    setattr( rootObj, otherName, obj2 (varName) )
                else:
                    # agree
                    setattr( rootObj, otherName, '' )
            else:
                # float, long, or int
                deltaName = 'delta_' + varName
                setattr( rootObj, deltaName,
                         obj2 (varName) - obj1 (varName) )
        return rootObj

_rootObjectClone()

def GenObject.GenObject._rootObjectClone (   obj )

staticprivate

Creates the approprite type of Root object and copies the
information into it from the GO object.

Definition at line 730 of file GenObject.py.

References relativeConstraints.keys.

    def _rootObjectClone (obj):
        """Creates the approprite type of Root object and copies the
        information into it from the GO object."""
        objName = obj._objName
        classObj = GenObject._rootClassDict.get (objName)
        if not classObj:
            goName = GenObject.rootClassName (objName)
            classObj = GenObject._rootClassDict[ goName ]
        rootObj = classObj()
        for varName in GenObject._objsDict [objName].keys():
            setattr( rootObj, varName, obj (varName) )
        return rootObj

_rootObjectCopy()

def GenObject.GenObject._rootObjectCopy (   goSource,   rootTarget  )

staticprivate

Copies information from goSourse into Root Object

Definition at line 718 of file GenObject.py.

References relativeConstraints.keys.

    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) )
        
        

_setupClassHeader()

def GenObject.GenObject._setupClassHeader (   className,   noColon = False  )

staticprivate

Returns a string with the class header for a class
'classname'

Definition at line 221 of file GenObject.py.

    def _setupClassHeader (className, noColon = False):
        """Returns a string with the class header for a class
        'classname'"""
        retval  = "\nclass %s\n{\n  public:\n" % className
        retval += "      typedef std::vector< %s > Collection;\n\n" % className
        # constructor
        if noColon:
            retval += "      %s()" % className
        else:
            retval += "      %s() :\n" % className
        return retval

_tofillGenObject()

def GenObject.GenObject._tofillGenObject ( )

staticprivate

Makes sure that I know how to read root files I made myself

Definition at line 358 of file GenObject.py.

References relativeConstraints.keys.

    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)],
                                        {}]

addObjectVariable()

def GenObject.GenObject.addObjectVariable (   obj,   var,   optionsDict  )

static

User passes in in object and variable names.

Definition at line 139 of file GenObject.py.

References print().

    def addObjectVariable (obj, var, **optionsDict):
        """ User passes in in object and variable names."""
        if 'varType' not in optionsDict:
            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 'default' not in optionsDict:
            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)

ascii2char()

def GenObject.GenObject.ascii2char (   match )

static

Definition at line 124 of file GenObject.py.

References createfilelist.int.

    def ascii2char (match):
        return chr( int( match.group(1), 16 ) )

blurEvent()

def GenObject.GenObject.blurEvent (   event,   value,   where = ""  )

static

For debugging purposes only.  Will deliberately change
values of first tree to verify that script is correctly
finding problems.

Definition at line 1281 of file GenObject.py.

References relativeConstraints.keys, and print().

    def blurEvent (event, value, where = ""):
        """For debugging purposes only.  Will deliberately change
        values of first tree to verify that script is correctly
        finding problems."""
        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():
                    if isinstance (obj.__dict__[varName], str):
                        # don't bother
                        continue
                    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

changeAlias()

def GenObject.GenObject.changeAlias (   tupleName,   name,   alias  )

static

Updates an alias for an object for a given tuple

Definition at line 981 of file GenObject.py.

    def changeAlias (tupleName, name, alias):
        """Updates an alias for an object for a given tuple"""
        aliasDict = GenObject._ntupleDict[tupleName]['_alias']
        if name not in aliasDict:
            raise RuntimeError("unknown name '%s' in tuple '%s'" % \
                  (name, tupleName))
        aliasDict[name] = alias

changeLabel()

def GenObject.GenObject.changeLabel (   tupleName,   objectName,   label  )

static

Updates an label for an object for a given tuple

Definition at line 991 of file GenObject.py.

References mkLumiAveragedPlots.tuple.

    def changeLabel (tupleName, objectName, label):
        """Updates an label for an object for a given tuple"""
        labelDict = GenObject._ntupleDict[tupleName]['_label']
        if objectName not in labelDict:
            raise RuntimeError("unknown name '%s' in tuple '%s'" % \
                  (objectName, tupleName))
        label = tuple( GenObject._commaRE.split( label ) )
        labelDict[objectName] = label

changeVariable()

def GenObject.GenObject.changeVariable (   tupleName,   objName,   varName,   fillname  )

static

Updates the definition used to go from a Root object to a
GenObject.  'tupleName' and 'objName' must already be defined.

Definition at line 656 of file GenObject.py.

    def changeVariable (tupleName, objName, varName, fillname):
        """Updates the definition used to go from a Root object to a
        GenObject.  'tupleName' and 'objName' must already be defined."""
        parts = GenObject._dotRE.split (fillname)
        partsList = []
        for part in parts:
            parenMatch = GenObject._parenRE.search (part)
            mode   = GenObject._objFunc.obj
            parens = []
            if parenMatch:
                part   = parenMatch.group (1)
                mode   = GenObject._objFunc.func
                parens = \
                       GenObject._convertStringToParameters \
                       (parenMatch.group (2))
            partsList.append(  (part, mode, parens) )
        GenObject._tofillDict[tupleName][objName][varName] = [partsList, {}]

char2ascii()

def GenObject.GenObject.char2ascii (   match )

static

Static Member Functions ##.

Definition at line 120 of file GenObject.py.

    def char2ascii (match):
        return "%%%02x" % ord (match.group(0))

checksum()

def GenObject.GenObject.checksum (   str )

static

Returns a string of hex value of a checksum of input
string.

Definition at line 195 of file GenObject.py.

References genParticles_cff.map.

    def checksum (str):
        """Returns a string of hex value of a checksum of input
        string."""
        return hex( reduce( lambda x, y : x + y, map(ord, str) ) )[2:]

compareRunEventDicts()

def GenObject.GenObject.compareRunEventDicts (   firstDict,   secondDict  )

static

Compares the keys of the two dicts and returns three sets:
the overlap, first but not second, and second but not first.

Definition at line 1084 of file GenObject.py.

    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 key in secondDict:
                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 key not in firstDict:
                secondOnly.add (key)
        # All done
        return overlap, firstOnly, secondOnly

compareTwoItems()

def GenObject.GenObject.compareTwoItems (   item1,   item2  )

static

Compares all of the variables making sure they are the same
on the two objects.

Definition at line 1240 of file GenObject.py.

References funct.abs(), and relativeConstraints.keys.

    def compareTwoItems (item1, item2):
        """Compares all of the variables making sure they are the same
        on the two objects."""
        objName = item1._objName
        problems = {}
        relative = GenObject._kitchenSinkDict.get ('relative', False)
        for varName in GenObject._objsDict[objName].keys():
            prec = item1.getVariableProperty (varName, 'prec')
            if prec:
                # we want to check within a precision
                if relative:
                    val1 = item1(varName)
                    val2 = item2(varName)
                    numerator = 2 * abs (val1 - val2)
                    denominator = abs(val1) + abs(val2)
                    if not denominator:
                        # both are exactly zero, so there's no
                        # disagreement here.
                        continue
                    value = numerator / denominator
                    if value > prec:
                        # we've got a problem
                        problems[varName] = value                    
                else:
                    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

compareTwoTrees()

def GenObject.GenObject.compareTwoTrees (   chain1,   chain2,   kwargs  )

static

Given all of the necessary information, this routine will
go through and compare two trees making sure they are
'identical' within requested precision.  If 'diffOutputName'
is passed in, a root file with a diffTree and missingTree will
be produced.

Definition at line 1310 of file GenObject.py.

References print().

    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.  If 'diffOutputName'
        is passed in, a root file with a diffTree and missingTree will
        be produced."""
        print("Comparing Two Trees")
        diffOutputName = kwargs.get ('diffOutputName')
        tupleName1  = GenObject._kitchenSinkDict[chain1]['tupleName']
        numEntries1 = GenObject._kitchenSinkDict[chain1]['numEntries']
        tupleName2  = GenObject._kitchenSinkDict[chain2]['tupleName']
        numEntries2 = GenObject._kitchenSinkDict[chain2]['numEntries']
        debug       = GenObject._kitchenSinkDict.get ('debug', False)
        ree1 = GenObject.getRunEventEntryDict (chain1, tupleName1, numEntries1)
        ree2 = GenObject.getRunEventEntryDict (chain2, tupleName2, numEntries2)
        overlap, firstOnly, secondOnly = \
                 GenObject.compareRunEventDicts (ree1, ree2)
        if diffOutputName:
            rootfile, diffTree, missingTree = \
                      GenObject.setupDiffOutputTree (diffOutputName,
                                                     'diffTree',
                                                     'missingTree')
            if firstOnly:
                vec = GenObject._rootClassDict['firstOnly']
                for key in firstOnly:
                    runevent = GenObject._key2re (key)
                    vec.push_back( GenObject._rootObjectClone( runevent ) )
            if secondOnly:
                vec = GenObject._rootClassDict['secondOnly']
                for key in secondOnly:
                    runevent = GenObject._key2re (key)
                    vec.push_back( GenObject._rootObjectClone( runevent ) )
            missingTree.Fill()
        resultsDict = {}
        if firstOnly:
            resultsDict.setdefault ('_runevent', {})['firstOnly'] = \
                                   len (firstOnly)
        if secondOnly:
            resultsDict.setdefault ('_runevent', {})['secondOnly'] = \
                                   len (secondOnly)
        resultsDict['eventsCompared'] = len (overlap)
        for reTuple in sorted(overlap):
            # if we are filling the diff tree, then save the run and
            # event information.
            if diffOutputName:
                GenObject._key2re (reTuple,
                                   GenObject._rootClassDict['runevent'])
            if debug: warn ('event1', blankLines = 3)
            event1 = GenObject.loadEventFromTree (chain1, ree1 [reTuple])
            if debug: warn ('event2', blankLines = 3)
            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 = 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
                    print("singleton")
                    continue
                # Get ready to calculate root diff object if necessary
                rootObj = 0
                if diffOutputName:
                    rootObj = GenObject._rootObjectDict[objName]
                    rootObj.clear()
                vec1 = event1[objName]
                vec2 = event2[objName]
                matchedSet, noMatch1Set, noMatch2Set = \
                            GenObject.pairEquivalentObjects (vec1, vec2)
                if noMatch1Set or noMatch2Set:
                    
                    count1 = len (noMatch1Set)
                    count2 = len (noMatch2Set)
                    key = (count1, count2)
                    countDict = resultsDict.\
                                setdefault (objName, {}).\
                                setdefault ('_missing', {})
                    if key in countDict:
                        countDict[key] += 1
                    else:
                        countDict[key] = 1
                    # should be calculating root diff objects
                    if diffOutputName:
                        # first set
                        for index in sorted(list(noMatch1Set)):
                            goObj = vec1 [index]
                            rootObj.firstOnly.push_back ( GenObject.\
                                                          _rootObjectClone \
                                                          (goObj) )
                        # second set
                        for index in sorted(list(noMatch2Set)):
                            goObj = vec2 [index]
                            rootObj.secondOnly.push_back ( GenObject.\
                                                          _rootObjectClone \
                                                           (goObj) )
                # o.k.  Now that we have them matched, let's compare
                # the proper items:                
                for pair in sorted(list(matchedSet)):
                    if diffOutputName:
                        rootDiffObj = GenObject._rootDiffObject \
                                      ( vec1[ pair[1 - 1] ],
                                        vec2[ pair[2 - 1] ] ) 
                        rootObj.diff.push_back ( rootDiffObj )
                    problems = GenObject.\
                               compareTwoItems (vec1[ pair[1 - 1] ],
                                                vec2[ pair[2 - 1] ])
                    if problems.keys():
                        # pprint.pprint (problems)
                        for varName in problems.keys():
                            countDict = resultsDict.\
                                        setdefault (objName, {}).\
                                        setdefault ('_var', {})
                            if varName in countDict:
                                countDict[varName] += 1
                            else:
                                countDict[varName] = 1
                key = 'count_%s' % objName
                if key not in resultsDict:
                    resultsDict[key] = 0
                resultsDict[key] += len (matchedSet)
                # try cleaning up
                del vec1
                del vec2
            # end for objName        
            if diffOutputName:
                diffTree.Fill()
            del event1
            del event2
        # end for overlap
        if diffOutputName:
            diffTree.Write()
            missingTree.Write()
            rootfile.Close()
        return resultsDict

decodeNonAlphanumerics()

def GenObject.GenObject.decodeNonAlphanumerics (   line )

static

Decode lines encoded with encodeNonAlphanumerics()

Definition at line 133 of file GenObject.py.

    def decodeNonAlphanumerics (line):
        """Decode lines encoded with encodeNonAlphanumerics()"""
        return GenObject._percentAsciiRE.sub( GenObject.ascii2char, line )
        

encodeNonAlphanumerics()

def GenObject.GenObject.encodeNonAlphanumerics (   line )

static

Use a web like encoding of characters that are non-alphanumeric

Definition at line 128 of file GenObject.py.

    def encodeNonAlphanumerics (line):
        """Use a web like encoding of characters that are non-alphanumeric"""
        return GenObject._nonAlphaRE.sub( GenObject.char2ascii, line )

evaluateFunction()

def GenObject.GenObject.evaluateFunction (   obj,   partsList,   debug = False  )

static

Evaluates function described in partsList on obj

Definition at line 677 of file GenObject.py.

    def evaluateFunction (obj, partsList, debug=False):
        """Evaluates function described in partsList on obj"""
        for part in partsList:
            if debug: warn (part, spaces=15)
            obj = getattr (obj, part[0])
            if debug: warn (obj, spaces=15)
            # if this is a function instead of a data member, make
            # sure you call it with its arguments:
            if GenObject._objFunc.func == part[1]:
                # Arguments are stored as a list in part[2]
                obj = obj (*part[2])
                if debug: warn (obj, spaces=18)
        return obj

getRunEventEntryDict()

def GenObject.GenObject.getRunEventEntryDict (   chain,   tupleName,   numEntries  )

static

Returns a dictionary of run, event tuples to entryIndicies

Definition at line 1030 of file GenObject.py.

    def getRunEventEntryDict (chain, tupleName, numEntries):
        """Returns a dictionary of run, event tuples to entryIndicies"""
        reeDict = {}
        for entryIndex in range (numEntries):
            event = GenObject.loadEventFromTree (chain,
                                                 entryIndex,
                                                 onlyRunEvent = True)
            runevent = event['runevent']
            reeDict[ GenObject._re2key (runevent) ] = entryIndex
            #reeDict[ "one two three" ] = entryIndex
            del event
        return reeDict

getVariableProperty() [1/2]

def GenObject.GenObject.getVariableProperty (   obj,   var,   key  )

static

Returns property assoicated with 'key' for variable 'var'
of object 'obj'.  Returns 'None' if any of the above are not
defined.

Definition at line 158 of file GenObject.py.

Referenced by GenObject.GenObject.__setattr__(), GenObject.GenObject.__str__(), and GenObject.GenObject.getVariableProperty().

    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)

getVariableProperty() [2/2]

def GenObject.GenObject.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.

Definition at line 1567 of file GenObject.py.

References GenObject.GenObject._objName, and GenObject.GenObject.getVariableProperty().

    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)

isSingleton()

def GenObject.GenObject.isSingleton (   objName )

static

Returns true if object is a singleton

Definition at line 869 of file GenObject.py.

References GenObject.GenObject.loadEventFromTree().

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

loadConfigFile()

def GenObject.GenObject.loadConfigFile (   configFile )

static

Loads configuration file

Definition at line 420 of file GenObject.py.

References watchdog.group, print(), submitPVValidationJobs.split(), and mkLumiAveragedPlots.tuple.

    def loadConfigFile (configFile):
        """Loads configuration file"""
        objName    = ""
        tupleName  = ""
        tofillName = ""
        modeEnum   = Enumerate ("none define tofill ntuple", "mode")
        mode       = modeEnum.none
        try:
            config = open (configFile, 'r')        except:
            raise RuntimeError("Can't open configuration '%s'" % configFile)
        for lineNum, fullLine in enumerate (config):
            fullLine = fullLine.strip()
            # get rid of comments
            line = GenObject._commentRE.sub ('', fullLine)
            # Is there anything on this line?
            if not GenObject._nonSpacesRE.search (line):
                # Nothing to see here folks.  Keep moving....
                continue
            
            bracketMatch = GenObject._bracketRE.search (line)
            if bracketMatch:
                # a header
                section = bracketMatch.group(1)
                words = GenObject._spacesRE.split( section )
                if len (words) < 1:
                    raise RuntimeError("Don't understand line '%s'(%d)" \
                          % (fullLine, lineNum))
                # The first word is the object name
                # reset the rest of the list
                objName = words[0]
                words = words[1:]
                colonWords = GenObject._colonRE.split (objName)
                if len (colonWords) > 3:
                    raise RuntimeError("Don't understand line '%s'(%d)" \
                          % (fullLine, lineNum))
                if len (colonWords) == 1:
                    
                    mode = modeEnum.define
                    for word in words:
                        if GenObject._singletonRE.match (word):
                            #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 parser error '%s'(%d)" \
                              % (fullLine, lineNum))
                elif len (colonWords) == 2:
                    
                    mode = modeEnum.ntuple
                    ntupleDict = GenObject._ntupleDict.\
                                setdefault (colonWords[0], {})
                    ntupleDict['_tree'] = colonWords[1]
                else:
                    
                    mode = modeEnum.tofill
                    objName    = colonWords [0]
                    tupleName  = colonWords [1]
                    tofillName = colonWords [2]
                    ntupleDict = GenObject._ntupleDict.\
                                 setdefault (tupleName, {})
                    ntupleDict[objName] = tofillName
                    for word in words:
                        # label
                        labelMatch = GenObject._labelRE.search (word)
                        if labelMatch:
                            label = tuple( GenObject._commaRE.\
                                           split(  labelMatch.group (1) ) )
                            ntupleDict.setdefault ('_label', {}).\
                                                  setdefault (tofillName,
                                                              label)
                            continue
                        # shortcut
                        shortcutMatch = GenObject._shortcutRE.search (word)
                        if shortcutMatch:
                            shortcutFill = \
                                         GenObject.\
                                         parseVariableTofill ( shortcutMatch.\
                                                               group(1) )
                            ntupleDict.setdefault ('_shortcut', {}).\
                                                  setdefault (tofillName,
                                                              shortcutFill)
                            continue
                        # type/handle
                        typeMatch = GenObject._typeRE.search (word)
                        if typeMatch:
                            handleString = \
                                         GenObject.\
                                         _fixLostGreaterThans (typeMatch.group(1))
                            handle = Handle( handleString )
                            ntupleDict.setdefault ('_handle', {}).\
                                                  setdefault (tofillName,
                                                              handle)
                            continue
                        # alias 
                        aliasMatch = GenObject._aliasRE.search (word)
                        if aliasMatch:
                            ntupleDict.setdefault ('_alias', {}).\
                                                  setdefault (tofillName,
                                                              aliasMatch.\
                                                              group(1))
                            continue
                        # is this a lost '<'
                        if word == '>':
                            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 parser error '%s'(%d)" \
                              % (fullLine, lineNum))
            
            else:
                # a variable
                if modeEnum.none == mode:
                    # Poorly formatted 'section' tag
                    print("I don't understand line '%s'." % fullLine)
                    raise RuntimeError("Config file parser error '%s'(%d)" \
                          % (fullLine, lineNum))
                colonWords = GenObject._colonRE.split (line, 1)
                if len (colonWords) < 2:
                    # Poorly formatted 'section' tag
                    print("I don't understand line '%s'." % fullLine)
                    raise RuntimeError("Config file parser error '%s'(%d)" \
                          % (fullLine, lineNum))
                varName = colonWords[0]
                option  = colonWords[1]
                if option:
                    pieces = GenObject._spacesRE.split (option)
                else:
                    pieces = []
                if modeEnum.define == mode:
                    
                    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 parser error '%s'(%d)" \
                                          % (fullLine, lineNum))
                                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 parser error '%s'(%d)" \
                                              % (fullLine, lineNum))
                                GenObject.setEquivExpression (section,
                                                              halves[0],
                                                              halves[1])
                        continue
                    # If we're here, then this is a variable
                    optionsDict = {}
                    for word in pieces:
                        typeMatch = GenObject._typeRE.search (word)
                        if typeMatch and \
                               GenObject.types.isValidKey (typeMatch.group(1)):
                            varType = typeMatch.group(1).lower()
                            optionsDict['varType'] = GenObject.types (varType)
                            continue
                        defaultMatch = GenObject._defaultRE.search (word)
                        if defaultMatch:
                            optionsDict['default'] = defaultMatch.group(1)
                            continue
                        precMatch = GenObject._precRE.search (word)
                        if precMatch:
                            optionsDict['prec'] = float (precMatch.group (1))
                            continue
                        formMatch = GenObject._formRE.search (word)
                        if formMatch:
                            form = GenObject._doublePercentRE.\
                                   sub ('%', formMatch.group (1))
                            optionsDict['form'] = form
                            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 parser error '%s'(%d)" \
                              % (fullLine, lineNum))
                    GenObject.addObjectVariable (objName, varName, \
                                                 **optionsDict)
                else: # if modeEnum.define != mode
                    
                    if len (pieces) < 1:
                        continue
                    fillname, pieces = pieces[0], pieces[1:]
                    # 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 parser error '%s'(%d)" \
                              % (fullLine, lineNum))
                    tofillDict = GenObject._tofillDict.\
                                 setdefault (tupleName, {}).\
                                 setdefault (objName, {})
                    partsList = GenObject.parseVariableTofill (fillname)
                    tofillDict[varName] = [partsList, optionsDict]
        # for line
        for objName in GenObject._objsDict:
            # if this isn't a singleton, add 'index' as a variable
            if not GenObject.isSingleton (objName):
                GenObject.addObjectVariable (objName, 'index',
                                             varType = GenObject.types.int,
                                             form = '%3d')

loadEventFromTree()

def GenObject.GenObject.loadEventFromTree (   eventTree,   eventIndex,   onlyRunEvent = False  )

static

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.

Definition at line 876 of file GenObject.py.

References mps_setup.append, and print().

Referenced by GenObject.GenObject.isSingleton().

                           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."""
        debug     = GenObject._kitchenSinkDict.get ('debug', False)
        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 'eventTree' is a FWLite Events
            eventTree.to(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:
                # Root TChain
                objects = getattr (eventTree, branchName)
            else:
                # FWLite
                shortcut = ntupleDict.get('_shortcut', {}).get(branchName)
                if shortcut:
                    objects = GenObject.evaluateFunction (eventTree, shortcut)
                else:
                    eventTree.toBegin()
                    handle = ntupleDict.get('_handle', {}).get(branchName)
                    label  = ntupleDict.get('_label' , {}).get(branchName)
                    if not handle or not label:
                        raise RuntimeError("Missing handle or label for '%s'"\
                              % branchName)
                    if not eventTree.getByLabel (label, handle):
                        raise RuntimeError("not able to get %s for %s" \
                              % (label, branchName))
                    objects = handle.product()
            # 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
            if debug: warn (objName, spaces = 3)
            event[objName] = []
            for index, obj in enumerate (objects):
                event[objName].append( GenObject.\
                                       _genObjectClone (objName,
                                                        tupleName,
                                                        obj,
                                                        index) )
            del objects
            # end for obj        
        
        return event

pairEquivalentObjects()

def GenObject.GenObject.pairEquivalentObjects (   vec1,   vec2  )

static

Finds the equivalent objects in the two vectors

Definition at line 1106 of file GenObject.py.

References FastTimerService_cff.range.

    def pairEquivalentObjects (vec1, vec2):
        """Finds the equivalent objects in the two vectors"""
        len1, len2 = len (vec1), len (vec2)
        debug = GenObject._kitchenSinkDict.get ('debug', False)        
        if not len1 or not len2:
            # Nothing to see here folks.  Keep moving.
            if len1:
                noMatch1Set = set( range(len1) )
            else:
                noMatch1Set = set ()
            if len2:
                noMatch2Set = set( range(len2) )
            else:
                noMatch2Set = set ()
            if debug: warn ("Nothing found", sapces=6)
            return set(), noMatch1Set, noMatch2Set
        objName = vec1[0]._objName
        equivList = GenObject._equivDict[objName]
        firstDict = {}
        secondDict = {}
        # let's see if we're only using 'index' and nothing else
        if GenObject._kitchenSinkDict.get ('strictPairing') or \
               equivList == [('index', 0)]:
            # we're only matching on index, nothing else matters
            matchedSet = set (zip ( list(range( min (len1, len2))),
                                    list(range( min (len1, len2))) ) )
            if len1 > len2:
                # since main pairing goes from 0..len2-1, we now want
                # to go from len2..len1 inclusive
                noMatch1Set = set (range(len2, len1 + 1))
            else:
                noMatch1Set = set()
            if len2 > len1:
                # same logic as above
                noMatch2Set = set (range(len1, len2 + 1))
            else:
                noMatch2Set = set()
            return matchedSet, noMatch1Set, noMatch2Set
        
        
        # First, look for vec2 objects that are equivalent to a
        # given vec1 object.
        for index1 in range (len1):
            objList = []
            obj1 = vec1[index1]
            for index2 in range (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 range (len2):
            objList = []
            obj2 = vec2[index2]
            for index1 in range (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()
        firstDictKeys = sorted (firstDict.keys())
        for index1 in firstDictKeys:
            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 firstDict[index1]
                del secondDict[index2]
            else:
                # no match
                noMatch1Set.add (index1)
        noMatch2Set = set( secondDict.keys() )
        return matchedSet, noMatch1Set, noMatch2Set

parseVariableTofill()

def GenObject.GenObject.parseVariableTofill (   fillname )

static

Returns tofill tuple made from string

Definition at line 391 of file GenObject.py.

    def parseVariableTofill (fillname):
        """Returns tofill tuple made from string"""
        parts = GenObject._dotRE.split (fillname)
        partsList = []
        for part in parts:
            parenMatch = GenObject._parenRE.search (part)
            mode   = GenObject._objFunc.obj
            parens = []
            if parenMatch:
                part   = parenMatch.group (1)
                mode   = GenObject._objFunc.func
                parens = \
                       GenObject._convertStringToParameters \
                       (parenMatch.group (2))
            partsList.append(  (part, mode, parens) )
        return partsList

prepareToLoadGenObject()

def GenObject.GenObject.prepareToLoadGenObject ( )

static

Makes all necessary preparations to load root files created
by GenObject.

Definition at line 383 of file GenObject.py.

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

prepareTuple()

def GenObject.GenObject.prepareTuple (   tupleName,   files,   numEventsWanted = 0  )

static

Given the tuple name and list of files, returns either a
TChain or EventTree, and number of entries

Definition at line 1002 of file GenObject.py.

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

printEvent()

def GenObject.GenObject.printEvent (   event )

static

Prints out event dictionary.  Mostly for debugging

Definition at line 952 of file GenObject.py.

References print().

    def printEvent (event):
        """Prints out event dictionary.  Mostly for debugging"""
        # Print out all singletons first
        for objName, obj in sorted (event.items()):
            #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.items()):
            #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()

printGlobal()

def GenObject.GenObject.printGlobal ( )

static

Meant for debugging, but ok if called by user

Definition at line 178 of file GenObject.py.

References print().

    def printGlobal():
        """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)
        print("rootClassDict")
        pprint.pprint (GenObject._rootClassDict,   indent=4)

printTuple()

def GenObject.GenObject.printTuple (   chain )

static

Prints out all events to stdout

Definition at line 1494 of file GenObject.py.

References GenObject.warn().

    def printTuple (chain):
        """Prints out all events to stdout"""
        numEntries = GenObject._kitchenSinkDict[chain]['numEntries']
        debug = GenObject._kitchenSinkDict.get ('debug', False)
        if debug: warn (numEntries)
        for entryIndex in range (numEntries):
            if debug: warn (entryIndex, spaces=3)
            event = GenObject.loadEventFromTree (chain, entryIndex)            
            GenObject.printEvent (event)
            if debug: warn(spaces=3)

rootClassName()

def GenObject.GenObject.rootClassName (   objName )

static

Returns the name of the equivalent Root object

Definition at line 202 of file GenObject.py.

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

rootDiffClassName()

def GenObject.GenObject.rootDiffClassName (   objName )

static

Returns the name of the equivalent Root diff object

Definition at line 208 of file GenObject.py.

    def rootDiffClassName (objName):
        """Returns the name of the equivalent Root diff object"""
        return "goDiff_" + objName

rootDiffContClassName()

def GenObject.GenObject.rootDiffContClassName (   objName )

static

Returns the name of the equivalent Root diff container
object

Definition at line 214 of file GenObject.py.

    def rootDiffContClassName (objName):
        """Returns the name of the equivalent Root diff container
        object"""
        return "goDiffCont_" + objName

saveTupleAs()

def GenObject.GenObject.saveTupleAs (   chain,   rootFile  )

static

Saves a chain as a GO tree

Definition at line 1461 of file GenObject.py.

References print().

    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 range (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()

setAliases()

def GenObject.GenObject.setAliases (   eventTree,   tupleName  )

static

runs SetAlias on all saved aliases

Definition at line 973 of file GenObject.py.

    def setAliases (eventTree, tupleName):
        """runs SetAlias on all saved aliases"""
        aliases = GenObject._ntupleDict[tupleName].get('_alias', {})
        for name, alias in aliases.items():
            eventTree.SetAlias (name, alias)

setEquivExpression()

def GenObject.GenObject.setEquivExpression (   obj,   variable,   precision  )

static

Adds an equivalence constraint.  Must have at least one to
compare GO objects.

Definition at line 166 of file GenObject.py.

References print().

    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) )
        
    

setGlobalFlag()

def GenObject.GenObject.setGlobalFlag (   key,   value  )

static

Sets a global flag in _kitchenSinkDict

Definition at line 1488 of file GenObject.py.

    def setGlobalFlag (key, value):
        """Sets a global flag in _kitchenSinkDict"""
        GenObject._kitchenSinkDict [key] = value

setupDiffOutputTree()

def GenObject.GenObject.setupDiffOutputTree (   outputFile,   diffName,   missingName,   diffDescription = '',   missingDescription = ''  )

static

Opens the diff output file, loads all of the necessary
shared object libraries, and returns the output file and tree.b

Definition at line 813 of file GenObject.py.

Referenced by GenObject.GenObject.setupOutputTree().

                             diffDescription = '', missingDescription = ''):
        """Opens the diff output file, loads all of the necessary
        shared object libraries, and returns the output file and tree.b"""
        rootfile = ROOT.TFile.Open (outputFile, "recreate")
        GenObject._loadGoRootLibrary()
        # diff tree
        diffTree = ROOT.TTree (diffName, diffDescription)
        runEventObject = getattr (ROOT, 'go_runevent')()
        diffTree.Branch ('runevent', 'go_runevent', runEventObject)
        GenObject._rootClassDict['runevent'] = runEventObject
        for objName in sorted (GenObject._objsDict.keys()):
            if objName == 'runevent': continue
            classname = GenObject.rootClassName (objName)
            GenObject._rootClassDict[classname] = getattr (ROOT, classname)
            contName = GenObject.rootDiffContClassName (objName)
            diffName = GenObject.rootDiffClassName (objName)
            rootObj = GenObject._rootClassDict[contName] = \
                    getattr (ROOT, contName)
            GenObject._rootClassDict[diffName] = getattr (ROOT, diffName)
            obj = GenObject._rootObjectDict[objName] = rootObj()
            diffTree.Branch (objName, contName, obj)
        # missing tree
        missingTree = ROOT.TTree (missingName, missingDescription)
        rootRunEventClass = getattr (ROOT, 'go_runevent')
        firstOnly  = GenObject._rootClassDict['firstOnly'] = \
                     ROOT.std.vector( rootRunEventClass ) ()
        secondOnly = GenObject._rootClassDict['secondOnly'] = \
                     ROOT.std.vector( rootRunEventClass ) ()
        missingTree.Branch ('firstOnly',  'vector<go_runevent>', firstOnly) 
        missingTree.Branch ('secondOnly', 'vector<go_runevent>', secondOnly) 
        return rootfile, diffTree, missingTree

setupOutputTree()

def GenObject.GenObject.setupOutputTree (   outputFile,   treeName,   treeDescription = "",   otherNtupleName = ""  )

static

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.

Definition at line 779 of file GenObject.py.

References GenObject.GenObject.setupDiffOutputTree().

Referenced by GenObject.GenObject._rootDiffObject().

                         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

setValue()

def GenObject.GenObject.setValue	(		self,
			name,
			value
	)

Wrapper for __setattr___

Definition at line 1562 of file GenObject.py.

References ExternalGeneratorFilter.ExternalGeneratorFilter.__setattr__(), Enumerate.Enumerate.__setattr__(), Types._ProxyParameter.__setattr__(), python.rootplot.core.Options.__setattr__(), config.Analyzer.__setattr__(), options.HLTProcessOptions.__setattr__(), config.Service.__setattr__(), psClasses.BuildTreeNode.__setattr__(), Mixins._Parameterizable.__setattr__(), Modules.SwitchProducer.__setattr__(), Config.Process.__setattr__(), SequenceTypes._ModuleSequenceType.__setattr__(), VarParsing.VarParsing.__setattr__(), SequenceTypes._TaskBase.__setattr__(), GenObject.GenObject.__setattr__(), Config.ProcessFragment.__setattr__(), Config.FilteredStream.__setattr__, and Config.ProcessForProcessAccelerator.__setattr__().

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

    

Member Data Documentation

_aliasRE

GenObject.GenObject._aliasRE

staticprivate

Definition at line 103 of file GenObject.py.

_basicSet

GenObject.GenObject._basicSet

staticprivate

Definition at line 68 of file GenObject.py.

_bracketRE

GenObject.GenObject._bracketRE

staticprivate

Definition at line 101 of file GenObject.py.

_colonRE

GenObject.GenObject._colonRE

staticprivate

Definition at line 91 of file GenObject.py.

_commaRE

GenObject.GenObject._commaRE

staticprivate

Definition at line 98 of file GenObject.py.

_commentRE

GenObject.GenObject._commentRE

staticprivate

Definition at line 102 of file GenObject.py.

_cppType

GenObject.GenObject._cppType

staticprivate

Definition at line 64 of file GenObject.py.

_defaultRE

GenObject.GenObject._defaultRE

staticprivate

Definition at line 108 of file GenObject.py.

_defaultValue

GenObject.GenObject._defaultValue

staticprivate

Definition at line 70 of file GenObject.py.

Referenced by metTools.AddMETCollection.__init__(), and tauTools.AddTauCollection.__init__().

_dotRE

GenObject.GenObject._dotRE

staticprivate

Definition at line 97 of file GenObject.py.

_doubleColonRE

GenObject.GenObject._doubleColonRE

staticprivate

Definition at line 93 of file GenObject.py.

_doublePercentRE

GenObject.GenObject._doublePercentRE

staticprivate

Definition at line 94 of file GenObject.py.

_doubleQuoteRE

GenObject.GenObject._doubleQuoteRE

staticprivate

Definition at line 100 of file GenObject.py.

_equivDict

GenObject.GenObject._equivDict

staticprivate

Definition at line 75 of file GenObject.py.

_formRE

GenObject.GenObject._formRE

staticprivate

Definition at line 111 of file GenObject.py.

_kitchenSinkDict

GenObject.GenObject._kitchenSinkDict

staticprivate

Definition at line 82 of file GenObject.py.

_labelRE

GenObject.GenObject._labelRE

staticprivate

Definition at line 104 of file GenObject.py.

_localObjsDict

GenObject.GenObject._localObjsDict

private

Definition at line 1552 of file GenObject.py.

Referenced by GenObject.GenObject.__setattr__().

_nonAlphaRE

GenObject.GenObject._nonAlphaRE

staticprivate

Definition at line 112 of file GenObject.py.

_nonSpacesRE

GenObject.GenObject._nonSpacesRE

staticprivate

Compile Regexs ##.

Definition at line 90 of file GenObject.py.

_ntupleDict

GenObject.GenObject._ntupleDict

staticprivate

Definition at line 76 of file GenObject.py.

_objFunc

GenObject.GenObject._objFunc

staticprivate

Definition at line 63 of file GenObject.py.

_objName

GenObject.GenObject._objName

private

Definition at line 1553 of file GenObject.py.

Referenced by GenObject.GenObject.__setattr__(), and GenObject.GenObject.getVariableProperty().

_objsDict

GenObject.GenObject._objsDict

staticprivate

Definition at line 74 of file GenObject.py.

_parenRE

GenObject.GenObject._parenRE

staticprivate

Definition at line 95 of file GenObject.py.

_percentAsciiRE

GenObject.GenObject._percentAsciiRE

staticprivate

Definition at line 113 of file GenObject.py.

_precRE

GenObject.GenObject._precRE

staticprivate

Definition at line 110 of file GenObject.py.

_rootClassDict

GenObject.GenObject._rootClassDict

staticprivate

Definition at line 80 of file GenObject.py.

_rootObjectDict

GenObject.GenObject._rootObjectDict

staticprivate

Definition at line 78 of file GenObject.py.

_runEventList

GenObject.GenObject._runEventList

staticprivate

Definition at line 83 of file GenObject.py.

_runEventListDone

GenObject.GenObject._runEventListDone

staticprivate

Definition at line 84 of file GenObject.py.

_shortcutRE

GenObject.GenObject._shortcutRE

staticprivate

Definition at line 109 of file GenObject.py.

_singleColonRE

GenObject.GenObject._singleColonRE

staticprivate

Definition at line 92 of file GenObject.py.

_singleQuoteRE

GenObject.GenObject._singleQuoteRE

staticprivate

Definition at line 99 of file GenObject.py.

_singletonRE

GenObject.GenObject._singletonRE

staticprivate

Definition at line 106 of file GenObject.py.

_spacesRE

GenObject.GenObject._spacesRE

staticprivate

Definition at line 96 of file GenObject.py.

_tofillDict

GenObject.GenObject._tofillDict

staticprivate

Definition at line 77 of file GenObject.py.

_typeRE

GenObject.GenObject._typeRE

staticprivate

Definition at line 105 of file GenObject.py.

types

GenObject.GenObject.types

static

Static Member Data ##.

Definition at line 62 of file GenObject.py.

uselessReturnCode

GenObject.GenObject.uselessReturnCode

static

Definition at line 85 of file GenObject.py.

---

Generated for CMSSW Reference Manual by  1.8.14