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
	modules_found

Function Documentation

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 559 of file EgammaHLTValidationUtils.py.

References mps_setup.append.

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

#----------------------------------------------------------------------

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 653 of file EgammaHLTValidationUtils.py.

References getModuleNamesOfPath().

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

#----------------------------------------------------------------------

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 616 of file EgammaHLTValidationUtils.py.

Referenced by getCXXTypesOfPath().

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


#----------------------------------------------------------------------

def EgammaHLTValidationUtils.getModulesOfSequence

(

sequence

)

returns the modules found in a sequence.

Note that a module can appear more than once.

Definition at line 678 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


#----------------------------------------------------------------------

def EgammaHLTValidationUtils.getPathsOfDataSet	(		process,
			datasetName
	)

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

Definition at line 11 of file EgammaHLTValidationUtils.py.

References list().

def getPathsOfDataSet(process, datasetName):
    """ returns the names of the trigger paths contained in the
        given (primary) dataset """

    return list(getattr(process.datasets, datasetName))

#----------------------------------------------------------------------

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 20 of file EgammaHLTValidationUtils.py.

Referenced by edm::CFWriter.branchesActivate(), edm::MixingModule.branchesActivate(), HLTConfigProvider.init(), and makeGeneratedParticleAndFiducialVolumeFilter().

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


#----------------------------------------------------------------------

def EgammaHLTValidationUtils.getResult

(

self

)

returns the composed analyzer module 

Definition at line 536 of file EgammaHLTValidationUtils.py.

References ConfigBuilder.dumpPython().

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

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 49 of file EgammaHLTValidationUtils.py.

References getProcessName().

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

def EgammaHLTValidationUtils.makePSetForEgammaGenericFilter	(		self,
			module,
			moduleName
	)

Definition at line 395 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 + "'")

def EgammaHLTValidationUtils.makePSetForElectronGenericFilter	(		self,
			module,
			moduleName
	)

Definition at line 480 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 + "'")

def EgammaHLTValidationUtils.makePSetForEtFilter	(		self,
			moduleName
	)

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

Definition at line 362 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)
        )

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

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

def EgammaHLTValidationUtils.makePSetForOneOEMinusOneOPFilter	(		self,
			moduleName
	)

Definition at line 374 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)
            )

def EgammaHLTValidationUtils.makePSetForPixelMatchFilter	(		self,
			moduleName
	)

Definition at line 385 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

EgammaHLTValidationUtils.module_names_found

Definition at line 632 of file EgammaHLTValidationUtils.py.

EgammaHLTValidationUtils.modules_found

Definition at line 689 of file EgammaHLTValidationUtils.py.

---

Generated for CMSSW Reference Manual by  1.8.11