Inheritance diagram for jetCollectionTools.RecoJetAdder:

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

def	addRecoJetCollection (self, proc, jet, inputCollection="", genJetsCollection="", minPt=5., bTagDiscriminators=None, JETCorrLevels=None)

def	getSequence (self, proc)

Public Attributes
	bTagDiscriminators

	elLabel

	gpLabel

	JETCorrLevels

	main

	muLabel

	pfLabel

	prerequisites

	pvLabel

	runOnMC

	svLabel

Detailed Description

Tool to schedule modules for building a recojet collection with input MiniAODs

Definition at line 204 of file jetCollectionTools.py.

Constructor & Destructor Documentation

◆ init()

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

Definition at line 208 of file jetCollectionTools.py.

   def __init__(self,runOnMC=True):    
     self.prerequisites = []
     self.main = []
     self.bTagDiscriminators = ["None"] # No b-tagging by default
     self.JETCorrLevels = [ "L1FastJet", "L2Relative", "L3Absolute" ]
     self.pfLabel = "packedPFCandidates"
     self.pvLabel = "offlineSlimmedPrimaryVertices"
     self.svLabel = "slimmedSecondaryVertices"
     self.muLabel = "slimmedMuons"
     self.elLabel = "slimmedElectrons"
     self.gpLabel = "prunedGenParticles"
     self.runOnMC = runOnMC
  

Member Function Documentation

◆ addRecoJetCollection()

def jetCollectionTools.RecoJetAdder.addRecoJetCollection	(	self,
		proc,
		jet,
		inputCollection = `""`,
		genJetsCollection = `""`,
		minPt = `5.`,
		bTagDiscriminators = `None`,
		JETCorrLevels = `None`
	)

Definition at line 232 of file jetCollectionTools.py.

   def addRecoJetCollection(self,
     proc,
     jet,
     inputCollection    = "",
     genJetsCollection  = "",
     minPt              = 5.,
     bTagDiscriminators = None,
     JETCorrLevels      = None,
     ):
     print("jetCollectionTools::RecoJetAdder::addRecoJetCollection: Adding Reco Jet Collection: {}".format(jet))
  
     currentTasks = []
  
     if inputCollection and inputCollection not in [
         "slimmedJets", "slimmedJetsAK8", "slimmedJetsPuppi", "slimmedCaloJets",
       ]:
       raise RuntimeError("Invalid input collection: %s" % inputCollection)
  
     if bTagDiscriminators is None:
       bTagDiscriminators = self.bTagDiscriminators
  
     if JETCorrLevels is None:
       JETCorrLevels = self.JETCorrLevels
     
     #
     # Decide 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 jet collection in MiniAOD is not 
     # specified, build the jet collection.
     #
     #========================================================
     if not inputCollection or recoJetInfo.doCalo:
       print("jetCollectionTools::RecoJetAdder::addRecoJetCollection: inputCollection not specified. Building recojet collection now")
  
       #=======================================================
       #
       # Prepare the inputs to jet clustering
       #
       #========================================================
       #
       # Set up PF candidates
       #
       pfCand = self.pfLabel
       #
       # Setup PU method for PF candidates
       # 
       if recoJetInfo.jetPUMethod not in [ "", "cs" ]:
         pfCand += recoJetInfo.jetPUMethod
       #
       #
       #
       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":
           setattr(proc, pfCand,
             cms.EDFilter("CandPtrSelector",
               src = cms.InputTag(self.pfLabel),
               cut = cms.string("fromPV"),
             )
           )
           self.prerequisites.append(pfCand)
         #
         # PUPPI
         #
         elif recoJetInfo.jetPUMethod == "puppi":
           setattr(proc, pfCand,
             puppi.clone(
               candName   = self.pfLabel,
               vertexName = self.pvLabel,
             )
           )
           self.prerequisites.append(pfCand)
         #
         # Softkiller
         #
         elif recoJetInfo.jetPUMethod == "sk":
           setattr(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(tagName)
  
         if jetCollection in self.main:
           raise ValueError("Step '%s' already implemented" % jetCollection)
  
         setattr(proc, jetCollection, ak4PFJetsCS.clone(
             src                       = pfCand,
             doAreaFastjet             = True,
             jetPtMin                  = minPt,
             jetAlgorithm              = supportedJetAlgos[recoJetInfo.jetAlgo],
             rParam                    = recoJetInfo.jetSizeNr,
             useConstituentSubtraction = recoJetInfo.doCS,
             csRParam                  = 0.4 if recoJetInfo.doCS else -1.,
             csRho_EtaMax              = PFJetParameters.Rho_EtaMax if recoJetInfo.doCS else -1.,
             useExplicitGhosts         = recoJetInfo.doCS or recoJetInfo.jetPUMethod == "sk",
           )
         )
         if recoJetInfo.jetPUMethod == "puppi":
           _jets = getattr(proc, jetCollection)
           _jets.src = self.pfLabel
           _jets.srcWeights = pfCand
           _jets.applyWeights = True
         currentTasks.append(jetCollection)
       else:
         jetCollection = inputCollection
       
       #
       # PATify
       #
       if recoJetInfo.jetPUMethod == "puppi":
         jetCorrLabel = "Puppi"
       elif recoJetInfo.jetPUMethod in [ "cs", "sk" ]:
         jetCorrLabel = "chs"
       else:
         jetCorrLabel = recoJetInfo.jetPUMethod
       
       #
       # Jet correction
       #
       jetCorrections = (
         "{}{}{}{}".format(
           recoJetInfo.jetAlgo.upper(),
           recoJetInfo.jetSize,
           "Calo" if recoJetInfo.doCalo else recoJetInfo.jetReco.upper(),
           jetCorrLabel
         ),
         JETCorrLevels,
         "None",
       )
       
       addJetCollection(
         proc,
         labelName          = tagName,
         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),
         btagDiscriminators = bTagDiscriminators if not recoJetInfo.doCalo else [ "None" ],
         jetCorrections     = jetCorrections,
         genJetCollection   = cms.InputTag(genJetsCollection),
         genParticles       = cms.InputTag(self.gpLabel),
       )
  
       getJetMCFlavour = not recoJetInfo.doCalo and recoJetInfo.jetPUMethod != "cs"
  
       if not self.runOnMC: #Remove modules for Gen-level object matching
         delattr(proc, 'patJetGenJetMatch{}'.format(tagName))
         delattr(proc, 'patJetPartonMatch{}'.format(tagName))
         getJetMCFlavour = False 
  
       setattr(getattr(proc, "patJets{}".format(tagName)),           "getJetMCFlavour", cms.bool(getJetMCFlavour))
       setattr(getattr(proc, "patJetCorrFactors{}".format(tagName)), "payload",         cms.string(recoJetInfo.jetCorrPayload))
       selJet = "selectedPatJets{}".format(tagName)
     else:
       selJet = inputCollection
  
     if not recoJetInfo.skipUserData:
       #
       # 
       #
       jercVar = "jercVars{}".format(tagName)
       if jercVar in self.main:
         raise ValueError("Step '%s' already implemented" % jercVar)
       setattr(proc, jercVar, proc.jercVars.clone(srcJet = selJet))
       currentTasks.append(jercVar)
       #
       # JetID Loose
       #
       looseJetId = "looseJetId{}".format(tagName)
       if looseJetId in self.main:
         raise ValueError("Step '%s' already implemented" % looseJetId)
       setattr(proc, looseJetId, proc.looseJetId.clone(
           src = selJet,
           filterParams=proc.looseJetId.filterParams.clone(
             version ="WINTER16"
           ),
         )
       )
       currentTasks.append(looseJetId)
       #
       # JetID Tight
       #      
       tightJetId = "tightJetId{}".format(tagName)
       if tightJetId in self.main:
         raise ValueError("Step '%s' already implemented" % tightJetId)
       setattr(proc, tightJetId, proc.tightJetId.clone(
           src = selJet,
           filterParams=proc.tightJetId.filterParams.clone(
             version = "SUMMER18{}".format("PUPPI" if recoJetInfo.jetPUMethod == "puppi" else "")
           ),
         )
       )
       tightJetIdObj = getattr(proc, tightJetId)
       run2_jme_2016.toModify(
         tightJetIdObj.filterParams, 
           version = "WINTER16"
       )
       run2_jme_2017.toModify(
         tightJetIdObj.filterParams, 
           version = 'WINTER17{}'.format("PUPPI" if recoJetInfo.jetPUMethod == "puppi" else "")
       )
       currentTasks.append(tightJetId)
       #
       # JetID TightLepVeto 
       #
       tightJetIdLepVeto = "tightJetIdLepVeto{}".format(tagName)
       if tightJetIdLepVeto in self.main:
         raise ValueError("Step '%s' already implemented" % tightJetIdLepVeto)
       setattr(proc, tightJetIdLepVeto, proc.tightJetIdLepVeto.clone(
           src = selJet,
           filterParams=proc.tightJetIdLepVeto.filterParams.clone(
             version = "SUMMER18{}".format("PUPPI" if recoJetInfo.jetPUMethod == "puppi" else "")
           ),
         )
       )
       tightJetIdLepVetoObj = getattr(proc, tightJetIdLepVeto)
       run2_jme_2016.toModify(
         tightJetIdLepVetoObj.filterParams, 
         version = "WINTER16"
       )
       run2_jme_2017.toModify(
         tightJetIdLepVetoObj.filterParams, 
           version = 'WINTER17{}'.format("PUPPI" if recoJetInfo.jetPUMethod == "puppi" else ""),
       )
       currentTasks.append(tightJetIdLepVeto)
       #
       # 
       #
       selectedPatJetsWithUserData = "{}WithUserData".format(selJet)
       if selectedPatJetsWithUserData in self.main:
         raise ValueError("Step '%s' already implemented" % selectedPatJetsWithUserData)
       setattr(proc, selectedPatJetsWithUserData,
         cms.EDProducer("PATJetUserDataEmbedder",
           src = cms.InputTag(selJet),
           userFloats = cms.PSet(
             chFPV0EF = cms.InputTag("{}:chargedFromPV0EnergyFraction".format(jercVar)),
             chFPV1EF = cms.InputTag("{}:chargedFromPV1EnergyFraction".format(jercVar)),
             chFPV2EF = cms.InputTag("{}:chargedFromPV2EnergyFraction".format(jercVar)),
             chFPV3EF = cms.InputTag("{}:chargedFromPV3EnergyFraction".format(jercVar)),
           ),
           userInts = cms.PSet(
             tightId        = cms.InputTag(tightJetId),
             tightIdLepVeto = cms.InputTag(tightJetIdLepVeto),
           ),
         )
       )
       selectedPatJetsWithUserDataObj = getattr(proc, selectedPatJetsWithUserData)
       run2_jme_2016.toModify(selectedPatJetsWithUserDataObj.userInts,
         looseId  = cms.InputTag(looseJetId),
       )
       currentTasks.append(selectedPatJetsWithUserData)
     else:
       selectedPatJetsWithUserData = "selectedPatJets{}".format(tagName)
   
     #
     # Not sure why we can't re-use patJetCorrFactors* created by addJetCollection() 
     # (even cloning doesn't work) Let's just create our own
     #
     jetCorrFactors = "jetCorrFactors{}".format(tagName)
     if jetCorrFactors in self.main:
       raise ValueError("Step '%s' already implemented" % jetCorrFactors)
  
     setattr(proc, jetCorrFactors, patJetCorrFactors.clone(
         src             = selectedPatJetsWithUserData,
         levels          = JETCorrLevels,
         primaryVertices = self.pvLabel,
         payload         = recoJetInfo.jetCorrPayload,
         rho             = "fixedGridRhoFastjetAll{}".format("Calo" if recoJetInfo.doCalo else ""),
       )
     )
     currentTasks.append(jetCorrFactors)
  
     updatedJets = "updatedJets{}".format(tagName)
     if updatedJets in self.main:
       raise ValueError("Step '%s' already implemented" % updatedJets)
     
     setattr(proc, updatedJets, updatedPatJets.clone(
         addBTagInfo          = False,
         jetSource            = selectedPatJetsWithUserData,
         jetCorrFactorsSource = [jetCorrFactors],
       )
     )
     currentTasks.append(updatedJets)
  
     self.main.extend(currentTasks)
  
     return recoJetInfo

◆ getSequence()

def jetCollectionTools.RecoJetAdder.getSequence	(	self,
		proc
	)

Definition at line 221 of file jetCollectionTools.py.

   def getSequence(self, proc):
     tasks = self.prerequisites + self.main
  
     resultSequence = cms.Sequence()
     for idx, task in enumerate(tasks):
       if idx == 0:
         resultSequence = cms.Sequence(getattr(proc, task))
       else:
         resultSequence.insert(idx, getattr(proc, task))
     return resultSequence
   