Inheritance diagram for jetCollectionTools.RecoJetAdder:

Public Member Functions
def	__init__ (self, runOnMC=True)

def	addProcessAndTask (self, proc, label, module)

def	addRecoJetCollection (self, proc, jet, inputCollection="", minPtFastjet=None, genJetsCollection="", bTagDiscriminators=["None"], JETCorrLevels=["L1FastJet", L2Relative, L3Absolute, L2L3Residual)

Public Attributes
	elLabel

	gpLabel

	main

	muLabel

	patJetsInMiniAOD

	pfLabel

	prerequisites

	pvLabel

	runOnMC

	svLabel

Detailed Description

Tool to schedule modules for building a patJet collection from MiniAODs

Definition at line 193 of file jetCollectionTools.py.

Constructor & Destructor Documentation

◆ init()

def jetCollectionTools.RecoJetAdder.__init__	(	self,
		runOnMC = `True`
	)

Definition at line 197 of file jetCollectionTools.py.

   def __init__(self,runOnMC=True):
     self.prerequisites = []
     self.main = []
     self.pfLabel = "packedPFCandidates"
     self.pvLabel = "offlineSlimmedPrimaryVertices"
     self.svLabel = "slimmedSecondaryVertices"
     self.muLabel = "slimmedMuons"
     self.elLabel = "slimmedElectrons"
     self.gpLabel = "prunedGenParticles"
     self.runOnMC = runOnMC
     self.patJetsInMiniAOD = ["slimmedJets", "slimmedJetsAK8", "slimmedJetsPuppi", "slimmedCaloJets"]
 

Member Function Documentation

◆ addProcessAndTask()

def jetCollectionTools.RecoJetAdder.addProcessAndTask	(	self,
		proc,
		label,
		module
	)

Definition at line 209 of file jetCollectionTools.py.

References jetCollectionTools.RecoJetAdder.addRecoJetCollection(), helpers.addToProcessAndTask(), and helpers.getPatAlgosToolsTask().

Referenced by jetCollectionTools.RecoJetAdder.addRecoJetCollection().

   def addProcessAndTask(self, proc, label, module):
     task = getPatAlgosToolsTask(proc)
     addToProcessAndTask(label, module, proc, task)
 

◆ addRecoJetCollection()

def jetCollectionTools.RecoJetAdder.addRecoJetCollection	(	self,
		proc,
		jet,
		inputCollection = `""`,
		minPtFastjet = `None`,
		genJetsCollection = `""`,
		bTagDiscriminators = `["None"]`,
		JETCorrLevels = `["L1FastJet"`,
		L2Relative,
		L3Absolute,
		L2L3Residual
	)

Definition at line 221 of file jetCollectionTools.py.

Referenced by jetCollectionTools.RecoJetAdder.addProcessAndTask().

     ):
     print("jetCollectionTools::RecoJetAdder::addRecoJetCollection: Adding Reco Jet Collection: {}".format(jet))
 
     currentTasks = []
 
     if inputCollection and inputCollection not in self.patJetsInMiniAOD:
       raise RuntimeError("Invalid input collection: %s" % inputCollection)
 
     #=======================================================
     #
     # Figure out which jet collection we're dealing with
     #
     #=======================================================
     recoJetInfo = RecoJetInfo(jet, inputCollection)
     jetLower = recoJetInfo.jetLower
     jetUpper = recoJetInfo.jetUpper
     tagName  = recoJetInfo.jetTagName
 
     if inputCollection == "slimmedJets":
       assert(jetLower == "ak4pfchs")
     elif inputCollection == "slimmedJetsAK8":
       assert(jetLower == "ak8pfpuppi")
     elif inputCollection == "slimmedJetsPuppi":
       assert(jetLower == "ak4pfpuppi")
     elif inputCollection == "slimmedCaloJets":
       assert(jetLower == "ak4calo")
 
     #=======================================================
     #
     # If the patJet collection in MiniAOD is not specified,
     # we have to build the patJet collection from scratch.
     #
     #========================================================
     if not inputCollection or recoJetInfo.doCalo:
       print("jetCollectionTools::RecoJetAdder::addRecoJetCollection: inputCollection not specified. Building recojet collection now")
 
       #=======================================================
       #
       # Prepare the inputs to jet clustering
       #
       #========================================================
       #
       # Specify PF candidates
       #
       pfCand = self.pfLabel
       #
       # Setup PU method for PF candidates
       #
       if recoJetInfo.jetPUMethod not in [ "", "cs" ]:
         pfCand += recoJetInfo.jetPUMethod
 
 
       #
       # Setup modules to perform PU mitigation for
       # PF candidates
       #
       if pfCand not in self.prerequisites:
         #
         # Skip if no PU Method or CS specified
         #
         if recoJetInfo.jetPUMethod in [ "", "cs" ]:
           pass
         #
         # CHS
         #
         elif recoJetInfo.jetPUMethod == "chs":
           self.addProcessAndTask(proc, pfCand, pfCHS.clone(
               src = self.pfLabel
              )
            )
           self.prerequisites.append(pfCand)
         #
         # PUPPI
         #
         elif recoJetInfo.jetPUMethod == "puppi":
           pfCandWeight = setupPuppiForPackedPF(proc)[0]
           self.prerequisites.append(pfCandWeight)
         #
         # Softkiller
         #
         elif recoJetInfo.jetPUMethod == "sk":
           self.addProcessAndTask(proc, pfCand, softKiller.clone(
               PFCandidates = self.pfLabel,
               rParam = recoJetInfo.jetSizeNr,
             )
           )
           self.prerequisites.append(pfCand)
         else:
           raise RuntimeError("Currently unsupported PU method: '%s'" % recoJetInfo.jetPUMethod)
 
       #============================================
       #
       # Create the recojet collection
       #
       #============================================
       if not recoJetInfo.doCalo:
         jetCollection = '{}Collection'.format(jetUpper)
 
         if jetCollection in self.main:
           raise ValueError("Step '%s' already implemented" % jetCollection)
         #
         # Cluster new jet
         #
         if recoJetInfo.jetPUMethod == "chs":
           self.addProcessAndTask(proc, jetCollection, ak4PFJetsCHS.clone(
               src = pfCand,
             )
           )
         elif recoJetInfo.jetPUMethod == "puppi":
           self.addProcessAndTask(proc, jetCollection, ak4PFJetsPuppi.clone(
               src = self.pfLabel,
               srcWeights = pfCandWeight
             )
           )
         elif recoJetInfo.jetPUMethod == "sk":
           self.addProcessAndTask(proc, pfCand, ak4PFJetsSK.clone(
               src = pfCand,
             )
           )
         elif recoJetInfo.jetPUMethod == "cs":
           self.addProcessAndTask(proc, jetCollection, ak4PFJetsCS.clone(
             src = pfCand,
           )
         )
         else:
           self.addProcessAndTask(proc, jetCollection, ak4PFJets.clone(
             src = pfCand,
           )
         )
         getattr(proc, jetCollection).jetAlgorithm = supportedJetAlgos[recoJetInfo.jetAlgo]
         getattr(proc, jetCollection).rParam = recoJetInfo.jetSizeNr
         #
         # Set minimum pt threshold of reco jets to be saved after fastjet clustering
         #
         if minPtFastjet != None:
           getattr(proc, jetCollection).jetPtMin = minPtFastjet
         currentTasks.append(jetCollection)
       else:
         jetCollection = inputCollection
 
 
       #=============================================
       #
       # Make patJet collection
       #
       #=============================================
       #
       # Jet correction
       #
       if recoJetInfo.jetPUMethod == "puppi":
         jetCorrLabel = "Puppi"
       elif recoJetInfo.jetPUMethod in [ "cs", "sk" ]:
         jetCorrLabel = "chs"
       else:
         jetCorrLabel = recoJetInfo.jetPUMethod
 
       jetCorrections = (
         "{}{}{}{}".format(
           recoJetInfo.jetAlgo.upper(),
           recoJetInfo.jetSize,
           "Calo" if recoJetInfo.doCalo else recoJetInfo.jetReco.upper(),
           jetCorrLabel
         ),
         JETCorrLevels,
         "None",
       )
 
       postfix = "Recluster" if inputCollection == "" else ""
       addJetCollection(
         proc,
         labelName          = jetUpper,
         postfix            = postfix,
         jetSource          = cms.InputTag(jetCollection),
         algo               = recoJetInfo.jetAlgo,
         rParam             = recoJetInfo.jetSizeNr,
         pvSource           = cms.InputTag(self.pvLabel),
         pfCandidates       = cms.InputTag(self.pfLabel),
         svSource           = cms.InputTag(self.svLabel),
         muSource           = cms.InputTag(self.muLabel),
         elSource           = cms.InputTag(self.elLabel),
         genJetCollection   = cms.InputTag(genJetsCollection),
         genParticles       = cms.InputTag(self.gpLabel),
         jetCorrections     = jetCorrections,
       )
 
       #
       # Need to set this explicitly for PUPPI jets
       #
       if recoJetInfo.jetPUMethod == "puppi":
         getattr(proc, "patJetFlavourAssociation{}{}".format(jetUpper,postfix)).weights = cms.InputTag(pfCandWeight)
 
       getJetMCFlavour = not recoJetInfo.doCalo and recoJetInfo.jetPUMethod != "cs"
       if not self.runOnMC: #Remove modules for Gen-level object matching
         delattr(proc, 'patJetGenJetMatch{}{}'.format(jetUpper,postfix))
         delattr(proc, 'patJetPartonMatch{}{}'.format(jetUpper,postfix))
         getJetMCFlavour = False
       setattr(getattr(proc, "patJets{}{}".format(jetUpper,postfix)), "getJetMCFlavour", cms.bool(getJetMCFlavour))
 
       selectedPatJets = "selectedPatJets{}{}".format(jetUpper,postfix)
       #=============================================
       #
       # Update the patJet collection.
       # This is where we setup
       # -  JEC
       # -  b-tagging discriminators
       #
       #=============================================
       updateJetCollection(
         proc,
         labelName          = jetUpper,
         postfix            = "Final",
         jetSource          = cms.InputTag(selectedPatJets),
         jetCorrections     = jetCorrections,
         btagDiscriminators = bTagDiscriminators,
       )
 
       recoJetInfo.patJetFinalCollection = "selectedUpdatedPatJets{}{}".format(jetUpper,"Final")
     else:
       recoJetInfo.patJetFinalCollection = inputCollection
 
     self.main.extend(currentTasks)
 
     return recoJetInfo