EgammaHLTValidationUtils Namespace Reference

Classes
class	EgammaDQMModuleMaker

Functions
def	findEgammaPaths (process)
def	getCXXTypesOfPath (process, path)
def	getModuleNamesOfPath (path)
def	getModulesOfSequence (sequence)
def	getPathsOfDataSet (process, datasetName)
def	getProcessName (pdgGen, requiredNumberOfGeneratedObjects)
def	getResult (self)
def	makeGeneratedParticleAndFiducialVolumeFilter (process, pdgGen, requiredNumberOfGeneratedObjects)
def	makePSetForEgammaGenericFilter (self, module, moduleName)
def	makePSetForElectronGenericFilter (self, module, moduleName)
def	makePSetForEtFilter (self, moduleName)
def	makePSetForL1SeedFilter (self, moduleName)
	print >> sys.stderr,msgPrefix,"WARNING: unknown module type", module.type_(), " with name " + moduleName + " in path " + pathName More...
def	makePSetForL1SeedToSuperClusterMatchFilter (self, moduleName)
def	makePSetForOneOEMinusOneOPFilter (self, moduleName)
def	makePSetForPixelMatchFilter (self, moduleName)

Variables
	module_names_found
	moduleMaker
	modules_found
	msgPrefix
	process

Function Documentation

findEgammaPaths()

def EgammaHLTValidationUtils.findEgammaPaths

(

process

)

returns a dict:

 {
   "singleElectron": [ list of single electron path objects ],
   "doubleElectron": [ list of double electron path objects ],
   "singlePhoton":   [ list of single photon path objects ],
   "doublePhoton":   [ list of double photon path objects ],
 }

 Note that the elements in the lists are path objects, not path names.

 Note also that this is based on the name of the paths using some
 heuristics.

Definition at line 560 of file EgammaHLTValidationUtils.py.

def findEgammaPaths(process):
    """
    returns a dict:
 
     {
       "singleElectron": [ list of single electron path objects ],
       "doubleElectron": [ list of double electron path objects ],
       "singlePhoton":   [ list of single photon path objects ],
       "doublePhoton":   [ list of double photon path objects ],
     }
 
     Note that the elements in the lists are path objects, not path names.
 
     Note also that this is based on the name of the paths using some
     heuristics.
     """
 
    retval = { "singleElectron": [],
               "doubleElectron": [],
               "singlePhoton":   [],
               "doublePhoton":   [],
               }
    
    for path_name, path in process.paths.items():
 
        # print "XX",path_name.__class__,path.__class__
 
        if path_name.startswith("AlCa_"):
            continue
 
        if path_name.startswith("DQM_"):
            continue
 
        if not path_name.startswith("HLT_"):
            continue
 
        if path_name.startswith("HLT_Ele"):
            retval['singleElectron'].append(path)
            continue
        
        if path_name.startswith("HLT_Photon"):
            retval['singlePhoton'].append(path)
            continue
 
        if path_name.startswith("HLT_DoublePhoton"):
            retval['doublePhoton'].append(path)
            continue
 
        if path_name.startswith("HLT_DoubleEle"):
            retval['doubleElectron'].append(path)
            continue
 
    # end of loop over paths
    return retval
 
#----------------------------------------------------------------------
 

References mps_setup.append.

getCXXTypesOfPath()

def EgammaHLTValidationUtils.getCXXTypesOfPath	(		process,
			path
	)

returns the names of (classes) of the C++ types of the modules
found in the given path (in no particular order) 

Definition at line 654 of file EgammaHLTValidationUtils.py.

def getCXXTypesOfPath(process, path):
    """ returns the names of (classes) of the C++ types of the modules
    found in the given path (in no particular order) """
 
    moduleNames = getModuleNamesOfPath(path)
 
    retval = set()
 
    for name in moduleNames:
 
        # skip those modules which are in the path
        # but not in the process object.
        # not understood why we need to do this
        # but seems to cause problems in practice...
        if not hasattr(process,name):
            continue
 
        module = getattr(process, name)
 
        retval.add(module.type_())
 
    return retval
 
#----------------------------------------------------------------------
 

References getModuleNamesOfPath().

getModuleNamesOfPath()

def EgammaHLTValidationUtils.getModuleNamesOfPath

(

path

)

returns the names of the modules found in the given path.

Note that these are not guaranteed to be in any particular
order.

Definition at line 617 of file EgammaHLTValidationUtils.py.

def getModuleNamesOfPath(path):
    """ returns the names of the modules found in the given path.
 
    Note that these are not guaranteed to be in any particular
    order.
    """
 
    # this function could actually call getModulesOfSequence(..)
    # and then produce a set with the unique names of
    # the modules
 
    import FWCore.ParameterSet.Modules
    class Visitor:
 
        #----------------------------------------
        def __init__(self):
            self.module_names_found = set()
 
        #----------------------------------------
        def enter(self,visitee):
 
            if isinstance(visitee, FWCore.ParameterSet.Modules._Module):
                self.module_names_found.add(visitee.label_())
 
        #----------------------------------------
        def leave(self,visitee):
            pass
 
        #----------------------------------------
                
    visitor = Visitor()
    path.visit(visitor)
 
    return visitor.module_names_found
 
 
#----------------------------------------------------------------------

Referenced by getCXXTypesOfPath().

getModulesOfSequence()

def EgammaHLTValidationUtils.getModulesOfSequence

(

sequence

)

returns the modules found in a sequence.

Note that a module can appear more than once.

Definition at line 679 of file EgammaHLTValidationUtils.py.

def getModulesOfSequence(sequence):
    """ returns the modules found in a sequence.
 
    Note that a module can appear more than once.
    """
 
    import FWCore.ParameterSet.Modules
    class Visitor:
 
        #----------------------------------------
        def __init__(self):
            self.modules_found = []
 
        #----------------------------------------
        def enter(self,visitee):
 
            if isinstance(visitee, FWCore.ParameterSet.Modules._Module):
                self.modules_found.append(visitee)
 
        #----------------------------------------
        def leave(self,visitee):
            pass
 
        #----------------------------------------
                
    visitor = Visitor()
    sequence.visitNode(visitor)
 
    return visitor.modules_found
 
 
#----------------------------------------------------------------------

getPathsOfDataSet()

def EgammaHLTValidationUtils.getPathsOfDataSet	(		process,
			datasetName
	)

returns the names of the trigger paths contained in the
    given (primary) dataset 

Definition at line 12 of file EgammaHLTValidationUtils.py.

def getPathsOfDataSet(process, datasetName):
    """ returns the names of the trigger paths contained in the
        given (primary) dataset """
 
    return list(getattr(process.datasets, datasetName))
 
#----------------------------------------------------------------------
 
 

References list().

getProcessName()

def EgammaHLTValidationUtils.getProcessName	(		pdgGen,
			requiredNumberOfGeneratedObjects
	)

returns a process name (such as 'Zee') which can be
 used in various places (e.g. module names etc.) 

Definition at line 21 of file EgammaHLTValidationUtils.py.

def getProcessName(pdgGen, requiredNumberOfGeneratedObjects):
    """ returns a process name (such as 'Zee') which can be
     used in various places (e.g. module names etc.) """
 
    if pdgGen == 11:
 
        # electron paths
        if requiredNumberOfGeneratedObjects == 1:
            return "Wenu"
        elif requiredNumberOfGeneratedObjects == 2:
            return "Zee"
        else:
            raise Exception("unsupported case, can't guess type of process")
 
    elif pdgGen == 22:
 
        # photon paths
        if requiredNumberOfGeneratedObjects == 1:
            return 'GammaJet'
        elif requiredNumberOfGeneratedObjects == 2:
            return 'DiGamma'
        else:
            raise Exception("unsupported case, can't guess type of process")
    else:
        raise Exception("unsupported case, can't guess type of process")
 
 
#----------------------------------------------------------------------
 

Referenced by MassReplace.MassSearchReplaceAnyInputTagVisitor.doIt(), and makeGeneratedParticleAndFiducialVolumeFilter().

getResult()

def EgammaHLTValidationUtils.getResult

(

self

)

returns the composed analyzer module 

Definition at line 537 of file EgammaHLTValidationUtils.py.

    def getResult(self):
        """ returns the composed analyzer module """
        return self.__result
 

makeGeneratedParticleAndFiducialVolumeFilter()

def EgammaHLTValidationUtils.makeGeneratedParticleAndFiducialVolumeFilter	(		process,
			pdgGen,
			requiredNumberOfGeneratedObjects
	)

adds the needed modules to the process object and
returns a sequence made of the two filters.

returns the name of the created module

if process is not None, are added to the process.

When using this function from a _cff file, one
has to manually add the modules of the returned
sequence to globals() (in the calling module, not
here, globals() live in a different name space here)

Definition at line 50 of file EgammaHLTValidationUtils.py.

def makeGeneratedParticleAndFiducialVolumeFilter(process, pdgGen, requiredNumberOfGeneratedObjects):
    """
    adds the needed modules to the process object and
    returns a sequence made of the two filters.
 
    returns the name of the created module
 
    if process is not None, are added to the process.
 
    When using this function from a _cff file, one
    has to manually add the modules of the returned
    sequence to globals() (in the calling module, not
    here, globals() live in a different name space here)
    
    """
 
    # name of the physics process
    procName = getProcessName(pdgGen, requiredNumberOfGeneratedObjects)
 
    #--------------------
    # create a module producing a collection with the 
    # desired generated particles
    #--------------------
 
    genPartModuleName = 'genpart' + procName
 
 
    genPartModule = cms.EDFilter("PdgIdAndStatusCandViewSelector",
                                 status = cms.vint32(3),
                                 src = cms.InputTag("genParticles"),
                                 pdgId = cms.vint32(pdgGen),
                                 )
 
    # genPartModule.setLabel(genPartModuleName)
    if process != None:
        setattr(process, genPartModuleName, genPartModule)
 
    genPartModule.setLabel(genPartModuleName)
 
    #--------------------
    # create a module requiring the number
    # of generated particles
    #--------------------
 
    selectorModuleName = "fiducial" + procName
 
    selectorModule = cms.EDFilter("EtaPtMinCandViewSelector",
                                  src = cms.InputTag(genPartModuleName),
                                  etaMin = cms.double(-2.5),  
                                  etaMax = cms.double(2.5),   
                                  ptMin = cms.double(2.0)
                                  )
 
    if process != None:
        setattr(process, selectorModuleName, selectorModule)
 
    # this is needed if we don't have a process to attach this module to
    selectorModule.setLabel(selectorModuleName)
 
    #--------------------
    # create the sequence
    #--------------------
 
    return cms.Sequence(
        # getattr(process, genPartModuleName)
        genPartModule 
 
        *
 
        # getattr(process, selectorModuleName)
        selectorModule
        )
#----------------------------------------------------------------------
 

References getProcessName().

makePSetForEgammaGenericFilter()

def EgammaHLTValidationUtils.makePSetForEgammaGenericFilter	(		self,
			module,
			moduleName
	)

Definition at line 396 of file EgammaHLTValidationUtils.py.

    def makePSetForEgammaGenericFilter(self, module, moduleName):
 
        # example usages of HLTEgammaGenericFilter are:
        #   R9 shape filter                        hltL1NonIsoHLTNonIsoSingleElectronEt17TighterEleIdIsolR9ShapeFilter 
        #   cluster shape filter                   hltL1NonIsoHLTNonIsoSingleElectronEt17TighterEleIdIsolClusterShapeFilter 
        #   Ecal isolation filter                  hltL1NonIsoHLTNonIsoSingleElectronEt17TIghterEleIdIsolEcalIsolFilter
        #   H/E filter                             hltL1NonIsoHLTNonIsoSingleElectronEt17TighterEleIdIsolHEFilter
        #   HCAL isolation filter                  hltL1NonIsoHLTNonIsoSingleElectronEt17TighterEleIdIsolHcalIsolFilter
 
        # the type of object to look for seems to be the
        # same for all uses of HLTEgammaGenericFilter
        theHLTOutputTypes = cms.int32(TriggerTypeDefs_cfi.TriggerCluster)
 
        # infer the type of filter by the type of the producer which
        # generates the collection used to cut on this
        inputCollectionLabel = module.isoTag.moduleLabel
 
        inputType = getattr(self.process, inputCollectionLabel).type_()
        # print >> sys.stderr, "inputType=",inputType,moduleName
 
        #--------------------
        # sanity check: non-isolated path should be produced by the
        # same type of module
        #
        # first check that the non-iso tag is non-empty
        assert(module.nonIsoTag.moduleLabel != "")
 
        assert(inputType == getattr(self.process, module.nonIsoTag.moduleLabel).type_())
 
        #--------------------
 
 
        # the following cases seem to have identical PSets ?
 
        #--------------------
        # R9 shape
        #--------------------
 
        if inputType == 'EgammaHLTR9Producer':
            return cms.PSet(
                PlotBounds = cms.vdouble(0.0, 0.0),
                HLTCollectionLabels = cms.InputTag(moduleName,"",self.processName),
                IsoCollections = cms.VInputTag(module.isoTag, module.nonIsoTag),
                theHLTOutputTypes = theHLTOutputTypes
                )
 
        #--------------------
        # cluster shape
        #--------------------
        if inputType == 'EgammaHLTClusterShapeProducer':
            return cms.PSet(
                PlotBounds = cms.vdouble(0.0, 0.0),
                HLTCollectionLabels = cms.InputTag(moduleName,"",self.processName),
                IsoCollections = cms.VInputTag(module.isoTag, module.nonIsoTag),
                theHLTOutputTypes = theHLTOutputTypes
                )
 
        #--------------------
        # ecal isolation
        #--------------------
        if inputType == 'EgammaHLTEcalRecIsolationProducer':
            return cms.PSet(
                PlotBounds = cms.vdouble(0.0, 0.0),
                HLTCollectionLabels = cms.InputTag(moduleName,"",self.processName),
                IsoCollections = cms.VInputTag(module.isoTag, module.nonIsoTag),
                theHLTOutputTypes = theHLTOutputTypes
                )
 
        #--------------------
        # HCAL isolation and HE
        #--------------------
 
        if inputType == 'EgammaHLTHcalIsolationProducersRegional':
            return cms.PSet(
                PlotBounds = cms.vdouble(0.0, 0.0),
                HLTCollectionLabels = cms.InputTag(moduleName,"",self.processName),
                IsoCollections = cms.VInputTag(module.isoTag, module.nonIsoTag),
                theHLTOutputTypes = theHLTOutputTypes
                )
            
        
        raise Exception("can't determine what the HLTEgammaGenericFilter '" + moduleName + "' should do: uses a collection produced by a module of C++ type '" + inputType + "'")
 

References cms::cuda.assert().

makePSetForElectronGenericFilter()

def EgammaHLTValidationUtils.makePSetForElectronGenericFilter	(		self,
			module,
			moduleName
	)

Definition at line 481 of file EgammaHLTValidationUtils.py.

    def makePSetForElectronGenericFilter(self, module, moduleName):
 
        # example usages of HLTElectronGenericFilter are:
 
        # deta filter      hltL1NonIsoHLTNonIsoSingleElectronEt17TighterEleIdIsolDetaFilter
        # dphi filter      hltL1NonIsoHLTNonIsoSingleElectronEt17TighterEleIdIsolDphiFilter
        # track isolation  hltL1NonIsoHLTNonIsoSingleElectronEt17TighterEleIdIsolTrackIsolFilter
 
        # the type of object to look for seems to be the
        # same for all uses of HLTEgammaGenericFilter
        theHLTOutputTypes = cms.int32(TriggerTypeDefs_cfi.TriggerElectron)
 
        # infer the type of filter by the type of the producer which
        # generates the collection used to cut on this
        inputCollectionLabel = module.isoTag.moduleLabel
 
        inputType = getattr(self.process, inputCollectionLabel).type_()
        # print >> sys.stderr, "inputType=",inputType,moduleName
 
        # sanity check: non-isolated path should be produced by the
        # same type of module
        assert(inputType == getattr(self.process, module.nonIsoTag.moduleLabel).type_())
 
        # the following cases seem to have identical PSets ?
 
        #--------------------
        # deta and dphi filter
        #--------------------
 
        # note that whether deta or dphi is used is determined from
        # the product instance (not the module label)
        if inputType == 'EgammaHLTElectronDetaDphiProducer':
 
            return cms.PSet(
                PlotBounds = cms.vdouble(0.0, 0.0),
                HLTCollectionLabels = cms.InputTag(moduleName,"",self.processName),
                IsoCollections = cms.VInputTag(module.isoTag, module.nonIsoTag),
                theHLTOutputTypes = theHLTOutputTypes
                )
 
        #--------------------
        # track isolation
        #--------------------
 
        if inputType == 'EgammaHLTElectronTrackIsolationProducers':
 
            return cms.PSet(
                PlotBounds = cms.vdouble(0.0, 0.0),
                HLTCollectionLabels = cms.InputTag(moduleName,"",self.processName),
                IsoCollections = cms.VInputTag(module.isoTag, module.nonIsoTag),
                theHLTOutputTypes = theHLTOutputTypes
                )
        raise Exception("can't determine what the HLTElectronGenericFilter '" + moduleName + "' should do: uses a collection produced by a module of C++ type '" + inputType + "'")
 

References cms::cuda.assert().

makePSetForEtFilter()

def EgammaHLTValidationUtils.makePSetForEtFilter	(		self,
			moduleName
	)

generates a PSet for the Egamma DQM analyzer for the Et filter 

Definition at line 363 of file EgammaHLTValidationUtils.py.

    def makePSetForEtFilter(self, moduleName):
        """ generates a PSet for the Egamma DQM analyzer for the Et filter """
 
        return cms.PSet(
            PlotBounds = cms.vdouble(0.0, 0.0),
            HLTCollectionLabels = cms.InputTag(moduleName,"",self.processName),
            IsoCollections = cms.VInputTag(cms.InputTag("none")),
            theHLTOutputTypes = cms.int32(TriggerTypeDefs_cfi.TriggerCluster)
        )
 

makePSetForL1SeedFilter()

def EgammaHLTValidationUtils.makePSetForL1SeedFilter	(		self,
			moduleName
	)

print >> sys.stderr,msgPrefix,"WARNING: unknown module type", module.type_(), " with name " + moduleName + " in path " + pathName

generates a PSet to analyze the behaviour of an L1 seed.

    moduleName is the name of the HLT module which filters
    on the L1 seed.

Definition at line 331 of file EgammaHLTValidationUtils.py.

    def makePSetForL1SeedFilter(self,moduleName):
        """ generates a PSet to analyze the behaviour of an L1 seed.
 
            moduleName is the name of the HLT module which filters
            on the L1 seed.
        """
 
        return cms.PSet(
            PlotBounds = cms.vdouble(0.0, 0.0),
            HLTCollectionLabels = cms.InputTag(moduleName,"",self.processName),
            IsoCollections = cms.VInputTag(cms.InputTag("none")),
            theHLTOutputTypes = cms.int32(TriggerTypeDefs_cfi.TriggerL1NoIsoEG)
        ) 
 

makePSetForL1SeedToSuperClusterMatchFilter()

def EgammaHLTValidationUtils.makePSetForL1SeedToSuperClusterMatchFilter	(		self,
			moduleName
	)

generates a PSet to analyze the behaviour of L1 to supercluster match filter.

    moduleName is the name of the HLT module which requires the match
    between supercluster and L1 seed.

Definition at line 347 of file EgammaHLTValidationUtils.py.

    def makePSetForL1SeedToSuperClusterMatchFilter(self,moduleName):
        """ generates a PSet to analyze the behaviour of L1 to supercluster match filter.
 
            moduleName is the name of the HLT module which requires the match
            between supercluster and L1 seed.
        """
 
        return cms.PSet(
            PlotBounds = cms.vdouble(0.0, 0.0),
            HLTCollectionLabels = cms.InputTag(moduleName,"",self.processName),
            IsoCollections = cms.VInputTag(cms.InputTag("none")),
            theHLTOutputTypes = cms.int32(TriggerTypeDefs_cfi.TriggerCluster)
        ) 
 

makePSetForOneOEMinusOneOPFilter()

def EgammaHLTValidationUtils.makePSetForOneOEMinusOneOPFilter	(		self,
			moduleName
	)

Definition at line 375 of file EgammaHLTValidationUtils.py.

    def makePSetForOneOEMinusOneOPFilter(self, moduleName):
 
        return cms.PSet(
            PlotBounds = cms.vdouble(0.0, 0.0),
            HLTCollectionLabels = cms.InputTag(moduleName,"",self.processName),
            IsoCollections = cms.VInputTag(cms.InputTag("none")),
            theHLTOutputTypes = cms.int32(TriggerTypeDefs_cfi.TriggerElectron)
            )
 

makePSetForPixelMatchFilter()

def EgammaHLTValidationUtils.makePSetForPixelMatchFilter	(		self,
			moduleName
	)

Definition at line 386 of file EgammaHLTValidationUtils.py.

    def makePSetForPixelMatchFilter(self, moduleName):
        return cms.PSet(
            PlotBounds = cms.vdouble(0.0, 0.0),
            HLTCollectionLabels = cms.InputTag(moduleName,"",self.processName),
            IsoCollections = cms.VInputTag(cms.InputTag("none")),
            theHLTOutputTypes = cms.int32(TriggerTypeDefs_cfi.TriggerCluster)
            )
 

Variable Documentation

module_names_found

EgammaHLTValidationUtils.module_names_found

Definition at line 633 of file EgammaHLTValidationUtils.py.

moduleMaker

EgammaHLTValidationUtils.moduleMaker

Definition at line 552 of file EgammaHLTValidationUtils.py.

modules_found

EgammaHLTValidationUtils.modules_found

Definition at line 690 of file EgammaHLTValidationUtils.py.

msgPrefix

EgammaHLTValidationUtils.msgPrefix

Definition at line 7 of file EgammaHLTValidationUtils.py.

process

EgammaHLTValidationUtils.process

Definition at line 549 of file EgammaHLTValidationUtils.py.