Public Member Functions
def	__init__ (self, process, pathName, pdgGen, requiredNumberOfGeneratedObjects, cutCollection=None)

Public Attributes
	path

	pathName

	process

	processName

Private Attributes
	__result

Detailed Description

a class which can be used to produce an analysis path
    for the EmDQM analyzer

Definition at line 126 of file EgammaHLTValidationUtils.py.

Constructor & Destructor Documentation

◆ init()

def EgammaHLTValidationUtils.EgammaDQMModuleMaker.__init__	(	self,
		process,
		pathName,
		pdgGen,
		requiredNumberOfGeneratedObjects,
		cutCollection = `None`
	)

pathName is the HLT path to be validated.

pdgGen is the PDG id of the corersponding generated particles
  (11 for electrons, 22 for photons)

requiredNumberOfGeneratedObjects should be 1 for single triggers,
and 2 for double triggers (e.g. double photon triggers)

cutCollection is the name of the collection which should be used
  to define the acceptance region (at reconstruction level ?).
  typical values are 'fiducialZee'. If this is set to None,
  will be determined automatically from pdgGen and requiredNumberOfGeneratedObjects

Definition at line 132 of file EgammaHLTValidationUtils.py.

     def __init__(self, process, pathName, pdgGen, requiredNumberOfGeneratedObjects, cutCollection = None):
         """
         pathName is the HLT path to be validated.
  
         pdgGen is the PDG id of the corersponding generated particles
           (11 for electrons, 22 for photons)
  
         requiredNumberOfGeneratedObjects should be 1 for single triggers,
         and 2 for double triggers (e.g. double photon triggers)
  
         cutCollection is the name of the collection which should be used
           to define the acceptance region (at reconstruction level ?).
           typical values are 'fiducialZee'. If this is set to None,
           will be determined automatically from pdgGen and requiredNumberOfGeneratedObjects
  
         """
  
         self.process = process
         self.pathName = pathName
  
         self.path = getattr(process,pathName)
  
         # the process whose products should be analyzed
         self.processName = "HLT"
  
         #--------------------
         # guess the collection for the fiducial volume cut
         #--------------------
  
         if cutCollection == None:
             cutCollection = "fiducial" + getProcessName(pdgGen, requiredNumberOfGeneratedObjects)
  
         #--------------------
         # find Et threshold of primary object
         #--------------------
         mo = re.match("HLT_.*?(\d+).*",pathName)
  
         if mo != None:
             etThreshold = float(mo.group(1))
         else:
             etThreshold = -1.0
  
         #--------------------
         # initialize the analyzer we put together here
         #--------------------
         from DQMServices.Core.DQMEDAnalyzer import DQMEDAnalyzer
         self.__result = DQMEDAnalyzer('EmDQM',
                                      triggerobject = cms.InputTag("hltTriggerSummaryRAW","","HLT"),                            
                                      genEtaAcc = cms.double(2.5),
                                      genEtAcc = cms.double(2.0),
                                      reqNum = cms.uint32(requiredNumberOfGeneratedObjects),
                                      filters = cms.VPSet(), # will be added later
                                      PtMax = cms.untracked.double(100.0),
                                      genEtMin = cms.untracked.double(etThreshold),
                                      pdgGen = cms.int32(pdgGen),
                                      cutcollection = cms.InputTag(cutCollection),
  
                                      # is this a requirement on reconstructed or generated number of objects ?
                                      cutnum = cms.int32(requiredNumberOfGeneratedObjects),
  
  
                                        
                                        )
  
         #--------------------
         # get all modules of this path.
         # dirty hack: assumes that all modules
         #   are concatenated by '+'
         # but easier than to use a node visitor
         # and order the modules ourselves afterwards..
  
         moduleNames = str(self.path).split('+')
  
         # now find out which of these are EDFilters
         # and what CMSSW class type they are
  
         # example:
         #
         # CMSSW type                               module name
         # --------------------------------------------------------------------------------------------------------------------
         # HLTTriggerTypeFilter                     hltTriggerType 
         # HLTLevel1GTSeed                          hltL1sL1SingleEG8 
         # HLTPrescaler                             hltPreEle17SWTighterEleIdIsolL1R 
         # HLTEgammaL1MatchFilterRegional           hltL1NonIsoHLTNonIsoSingleElectronEt17TighterEleIdIsolL1MatchFilterRegional 
         # HLTEgammaEtFilter                        hltL1NonIsoHLTNonIsoSingleElectronEt17TighterEleIdIsolEtFilter 
         # HLTEgammaGenericFilter                   hltL1NonIsoHLTNonIsoSingleElectronEt17TighterEleIdIsolR9ShapeFilter 
         # HLTEgammaGenericFilter                   hltL1NonIsoHLTNonIsoSingleElectronEt17TighterEleIdIsolClusterShapeFilter 
         # HLTEgammaGenericFilter                   hltL1NonIsoHLTNonIsoSingleElectronEt17TIghterEleIdIsolEcalIsolFilter 
         # HLTEgammaGenericFilter                   hltL1NonIsoHLTNonIsoSingleElectronEt17TighterEleIdIsolHEFilter 
         # HLTEgammaGenericFilter                   hltL1NonIsoHLTNonIsoSingleElectronEt17TighterEleIdIsolHcalIsolFilter 
         # HLTElectronPixelMatchFilter              hltL1NonIsoHLTNonIsoSingleElectronEt17TighterEleIdIsolPixelMatchFilter 
         # HLTElectronOneOEMinusOneOPFilterRegional hltL1NonIsoHLTNonIsoSingleElectronEt17TighterEleIdIsolOneOEMinusOneOPFilter 
         # HLTElectronGenericFilter                 hltL1NonIsoHLTNonIsoSingleElectronEt17TighterEleIdIsolDetaFilter 
         # HLTElectronGenericFilter                 hltL1NonIsoHLTNonIsoSingleElectronEt17TighterEleIdIsolDphiFilter 
         # HLTElectronGenericFilter                 hltL1NonIsoHLTNonIsoSingleElectronEt17TighterEleIdIsolTrackIsolFilter 
         # HLTBool                                  hltBoolEnd 
  
         # it looks like in the MC menu, all modules have a name containing 'L1NonIso' and then
         # have a parameter IsoCollections (which is mostly cms.Input("none")...)
  
         import FWCore.ParameterSet.Modules
  
         for moduleName in moduleNames:
  
             # add protection to avoid accessing non-existing modules
             # (not understood why this is needed but happens
             # in some cases...).
             #
             # should also cover the special cases listed afterwards
             # (i.e. the check after this one could be removed
             # at some point)
             if not hasattr(self.process, moduleName):
                 continue
  
             # protection for FastSim HLT menu
             # which seems to reference certain modules in some
             # paths but these modules are not defined when just
             # loading the HLT menu into a process object.
             #
             # this seems not to happen for the fullsim menu for some
             # reason...
             if moduleName in ('simulation',
                               'offlineBeamSpot',
                               'HLTEndSequence'):
                 continue
  
             
  
             module = getattr(self.process,moduleName)
  
             if not isinstance(module, FWCore.ParameterSet.Modules.EDFilter):
                 continue
  
             # ignore certain EDFilters
             if module.type_() in ('HLTTriggerTypeFilter',
                                   'HLTPrescaler',
                                   'HLTBool'):
                 continue
  
             # print "XX", module.type_(), moduleName
  
             #--------------------
             if module.type_() == 'HLTLevel1GTSeed':
                 # L1 seed
                 self.__result.filters.append(self.makePSetForL1SeedFilter(moduleName))
                 continue
  
             #--------------------
             if module.type_() == 'HLTEgammaL1MatchFilterRegional':
                 # L1 seed to supercluster match
                 self.__result.filters.append(self.makePSetForL1SeedToSuperClusterMatchFilter(moduleName))
                 continue
  
             #--------------------
  
             if module.type_() == "HLTEgammaEtFilter":
                 # minimum Et requirement
                 self.__result.filters.append(self.makePSetForEtFilter(moduleName))
                 continue
  
             #--------------------
  
             if module.type_() == "HLTElectronOneOEMinusOneOPFilterRegional":
                 self.__result.filters.append(self.makePSetForOneOEMinusOneOPFilter(moduleName))
                 continue
  
             #--------------------
             if module.type_() == "HLTElectronPixelMatchFilter":
                 self.__result.filters.append(self.makePSetForPixelMatchFilter(moduleName))
                 continue
  
             #--------------------
             # generic filters: the module types
             # aren't enough, we must check on which
             # input collections they filter on
             #--------------------
  
             if module.type_() == "HLTEgammaGenericFilter":
  
                 pset = self.makePSetForEgammaGenericFilter(module, moduleName)
                 if pset != None:
                     self.__result.filters.append(pset)
                     continue
  
             #--------------------
  
             if module.type_() == "HLTElectronGenericFilter":
  
                 pset = self.makePSetForElectronGenericFilter(module, moduleName)
                 if pset != None:
                     self.__result.filters.append(pset)
                     continue
  
             #--------------------
  