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 191 of file jetCollectionTools.py.

Constructor & Destructor Documentation

◆ init()

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

Definition at line 195 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 207 of file jetCollectionTools.py.

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

References helpers.addToProcessAndTask(), and helpers.getPatAlgosToolsTask().

Referenced by jetCollectionTools.RecoJetAdder.addRecoJetCollection().

◆ addRecoJetCollection()

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

Definition at line 211 of file jetCollectionTools.py.

   def addRecoJetCollection(self,
     proc,
     jet,
     inputCollection    = "",
     minPtFastjet       = None,
     genJetsCollection  = "",
     bTagDiscriminators = ["None"],
     JETCorrLevels      = ["L1FastJet", "L2Relative", "L3Absolute", "L2L3Residual"],
     ):
     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, cms.EDFilter("CandPtrSelector",
               src = cms.InputTag(self.pfLabel),
               cut = cms.string("fromPV"),
             )
           )
           self.prerequisites.append(pfCand)
         #
         # PUPPI
         #
         elif recoJetInfo.jetPUMethod == "puppi":
           self.addProcessAndTask(proc, pfCand, puppi.clone(
               candName = self.pfLabel,
               vertexName = self.pvLabel,
             )
           )
           self.prerequisites.append(pfCand)
         #
         # 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 = pfCand
             )
           )
         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(pfCand)
  
       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