Functions
def	AddBTaggingScores (proc, jetTableName="")

def	AddDeepJetGluonLQuarkScores (proc, jetTableName="")

def	AddJetID (proc, jetName="", jetSrc="", jetTableName="", jetSequenceName="")

def	AddNewAK8CHSJets (proc, recoJA, runOnMC)

def	AddNewAK8GenJetsForJEC (proc, genJA)

def	AddNewAK8PuppiJetsForJEC (proc, recoJA, runOnMC)

def	AddNewGenJets (proc, genJetInfo)

def	AddNewPatJets (proc, recoJetInfo, runOnMC)

def	AddParticleNetAK4Scores (proc, jetTableName="")

def	AddPileUpJetIDVars (proc, jetName="", jetSrc="", jetTableName="", jetSequenceName="")

def	AddQGLTaggerVars (proc, jetName="", jetSrc="", jetTableName="", jetSequenceName="", calculateQGLVars=False)

def	AddVariablesForAK4GenJets (proc)

def	AddVariablesForAK8GenJets (proc)

def	AddVariablesForAK8PuppiJets (proc)

def	PrepJMECustomNanoAOD (process, runOnMC)

def	PrepJMECustomNanoAOD_Data (process)

def	PrepJMECustomNanoAOD_MC (process)

def	ReclusterAK4CHSJets (proc, recoJA, runOnMC)

def	ReclusterAK4GenJets (proc, genJA)

def	RemoveAllJetPtCuts (proc)

def	SaveGenJets (proc, genJetName, genJetAlgo, genJetSizeNr, genJetFinalColl, genJetTablePrefix, genJetTableDoc, runOnMC=False)

def	SavePatJets (proc, jetName, payload, patJetFinalColl, jetTablePrefix, jetTableDoc, doPF, doCalo, ptcut="", doPUIDVar=False, doQGL=False, doBTag=False, runOnMC=False)

Variables
	area

	bTagCSVV2

	btagCSVV2

	btagDDX

	btagDDXV2

	btagDeepB

	bTagDeepCSV

	btagDeepCvB

	btagDeepCvL

	btagDeepFlavB

	btagDeepFlavC

	btagDeepFlavCvB

	btagDeepFlavCvL

	btagDeepFlavG

	btagDeepFlavQG

	btagDeepFlavUDS

	bTagDeepJet

	bTagDiscriminatorsForAK4

	btagHbb

	BTAGVARS

	CALOJETVARS

	chEmEF

	chHEF

	config_genjets

	config_recojets

	DEEPJETVARS

	doc

	emf

	float

	GENJETVARS

	hfEmEF

	hfHEF

	int

	muEF

	nanoInfo_genjets

	nanoInfo_recojets

	nConstChHads

	nConstElecs

	nConstHFEMs

	nConstHFHads

	nConstituents

	nConstMuons

	nConstNeuHads

	nConstPhotons

	neEmEF

	neHEF

	nElectrons

	nMuons

	particleNetAK4_B

	particleNetAK4_CvsB

	particleNetAK4_CvsL

	particleNetAK4_puIdDisc

	particleNetAK4_QvsG

	PARTICLENETAK4VARS

	PFJETVARS

	precision

	puId_beta

	puId_dR2Mean

	puId_frac01

	puId_frac02

	puId_frac03

	puId_frac04

	puId_jetR

	puId_jetRchg

	puId_majW

	puId_minW

	puId_nCharged

	puId_ptD

	puId_pull

	PUIDVARS

	qgl_axis2

	qgl_mult

	qgl_ptD

	QGLVARS

	rawFactor

Function Documentation

◆ AddBTaggingScores()

def custom_jme_cff.AddBTaggingScores	(	proc,
		jetTableName = `""`
	)

Store b-tagging scores from various algortihm

Definition at line 386 of file custom_jme_cff.py.

 def AddBTaggingScores(proc, jetTableName=""):
   """
   Store b-tagging scores from various algortihm
   """
  
   getattr(proc, jetTableName).variables.btagDeepB       = BTAGVARS.btagDeepB
   getattr(proc, jetTableName).variables.btagCSVV2       = BTAGVARS.btagCSVV2
   getattr(proc, jetTableName).variables.btagDeepCvL     = BTAGVARS.btagDeepCvL
   getattr(proc, jetTableName).variables.btagDeepCvB     = BTAGVARS.btagDeepCvB
   getattr(proc, jetTableName).variables.btagDeepFlavB   = DEEPJETVARS.btagDeepFlavB
   getattr(proc, jetTableName).variables.btagDeepFlavCvL = DEEPJETVARS.btagDeepFlavCvL
   getattr(proc, jetTableName).variables.btagDeepFlavCvB = DEEPJETVARS.btagDeepFlavCvB
  
   return proc
  

Referenced by SavePatJets().

◆ AddDeepJetGluonLQuarkScores()

def custom_jme_cff.AddDeepJetGluonLQuarkScores	(	proc,
		jetTableName = `""`
	)

Store DeepJet raw score in jetTable for gluon and light quark

Definition at line 401 of file custom_jme_cff.py.

 def AddDeepJetGluonLQuarkScores(proc, jetTableName=""):
   """
   Store DeepJet raw score in jetTable for gluon and light quark
   """
  
   getattr(proc, jetTableName).variables.btagDeepFlavG   = DEEPJETVARS.btagDeepFlavG
   getattr(proc, jetTableName).variables.btagDeepFlavUDS = DEEPJETVARS.btagDeepFlavUDS
   getattr(proc, jetTableName).variables.btagDeepFlavQG  = DEEPJETVARS.btagDeepFlavQG
  
   return proc
  

Referenced by SavePatJets().

◆ AddJetID()

def custom_jme_cff.AddJetID	(	proc,
		jetName = `""`,
		jetSrc = `""`,
		jetTableName = `""`,
		jetSequenceName = `""`
	)

Setup modules to calculate PF jet ID

Definition at line 216 of file custom_jme_cff.py.

 def AddJetID(proc, jetName="", jetSrc="", jetTableName="", jetSequenceName=""):
   """
   Setup modules to calculate PF jet ID
   """
  
   isPUPPIJet = True if "Puppi" in jetName else False
   
   looseJetId = "looseJetId{}".format(jetName)
   setattr(proc, looseJetId, proc.looseJetId.clone(
       src = jetSrc,
       filterParams = proc.looseJetId.filterParams.clone(
         version = "WINTER16"
       ),
     )
   )
  
   tightJetId = "tightJetId{}".format(jetName)
   setattr(proc, tightJetId, proc.tightJetId.clone(
       src = jetSrc,
       filterParams = proc.tightJetId.filterParams.clone(
         version = "RUN2UL{}".format("PUPPI" if isPUPPIJet else "CHS")
       ),
     )
   )
   
   tightJetIdLepVeto = "tightJetIdLepVeto{}".format(jetName)
   setattr(proc, tightJetIdLepVeto, proc.tightJetIdLepVeto.clone(
       src = jetSrc,
       filterParams = proc.tightJetIdLepVeto.filterParams.clone(
         version = "RUN2UL{}".format("PUPPI" if isPUPPIJet else "CHS")
       ),
     )
   )
  
   for modifier in run2_miniAOD_80XLegacy, run2_nanoAOD_94X2016:
     modifier.toModify(getattr(proc, tightJetId).filterParams, version = "WINTER16" )
     modifier.toModify(getattr(proc, tightJetIdLepVeto).filterParams, version = "WINTER16" )
   for modifier in run2_nanoAOD_94XMiniAODv1, run2_nanoAOD_94XMiniAODv2:
     modifier.toModify(getattr(proc, tightJetId).filterParams, version = "WINTER17{}".format("PUPPI" if isPUPPIJet else ""))
     modifier.toModify(getattr(proc, tightJetIdLepVeto).filterParams, version = "WINTER17{}".format("PUPPI" if isPUPPIJet else ""))
   run2_nanoAOD_102Xv1.toModify(getattr(proc, tightJetId).filterParams, version = "SUMMER18{}".format("PUPPI" if isPUPPIJet else "") )
   run2_nanoAOD_102Xv1.toModify(getattr(proc, tightJetIdLepVeto).filterParams, version = "SUMMER18{}".format("PUPPI" if isPUPPIJet else "") )
   
   #
   # Save variables as userInts in each jet
   # 
   patJetWithUserData = "{}WithUserData".format(jetSrc)
   getattr(proc, patJetWithUserData).userInts.tightId = cms.InputTag(tightJetId)
   getattr(proc, patJetWithUserData).userInts.tightIdLepVeto = cms.InputTag(tightJetIdLepVeto)
   for modifier in run2_miniAOD_80XLegacy, run2_nanoAOD_94X2016:
     modifier.toModify(getattr(proc, patJetWithUserData).userInts, looseId = cms.InputTag(looseJetId))
  
   #
   # Specfiy variables in the jetTable to save in NanoAOD
   #
   getattr(proc, jetTableName).variables.jetId = Var("userInt('tightId')*2+4*userInt('tightIdLepVeto')",int,doc="Jet ID flags bit1 is loose (always false in 2017 since it does not exist), bit2 is tight, bit3 is tightLepVeto")
   for modifier in run2_miniAOD_80XLegacy, run2_nanoAOD_94X2016:
     modifier.toModify(getattr(proc, jetTableName).variables, jetId = Var("userInt('tightIdLepVeto')*4+userInt('tightId')*2+userInt('looseId')",int, doc="Jet ID flags bit1 is loose, bit2 is tight, bit3 is tightLepVeto"))
  
  
   getattr(proc,jetSequenceName).insert(getattr(proc,jetSequenceName).index(getattr(proc, jetSrc))+1, getattr(proc, tightJetId))
   getattr(proc,jetSequenceName).insert(getattr(proc,jetSequenceName).index(getattr(proc, tightJetId))+1, getattr(proc, tightJetIdLepVeto))
   
   setattr(proc,"_"+jetSequenceName+"_2016", getattr(proc,jetSequenceName).copy())
   getattr(proc,"_"+jetSequenceName+"_2016").insert(getattr(proc, "_"+jetSequenceName+"_2016").index(getattr(proc, tightJetId)), getattr(proc, looseJetId))
   for modifier in run2_miniAOD_80XLegacy, run2_nanoAOD_94X2016:
     modifier.toReplaceWith(getattr(proc,jetSequenceName), getattr(proc, "_"+jetSequenceName+"_2016"))
  
   return proc
  

References filterCSVwithJSON.copy, edm::eventsetup::heterocontainer.insert(), and common_cff.Var().

Referenced by SavePatJets().

◆ AddNewAK8CHSJets()

def custom_jme_cff.AddNewAK8CHSJets	(	proc,
		recoJA,
		runOnMC
	)

Store an AK8 CHS jet collection for JEC studies.

Definition at line 801 of file custom_jme_cff.py.

 def AddNewAK8CHSJets(proc, recoJA, runOnMC):
   """
   Store an AK8 CHS jet collection for JEC studies.
   """
   print("custom_jme_cff::AddNewAK8CHSJets: Make a new AK8 PF CHS jet collection for JEC studies")
  
   #
   # Recluster AK8 CHS jets
   #
   cfg = {
     "jet" : "ak8pfchs",
     "inputCollection" : "",
     "genJetsCollection": "AK8GenJetsNoNu",
     "minPtFastjet" : 0., # Remove any pt threshold at the jet clustering stage.
   }
   recoJetInfo = recoJA.addRecoJetCollection(proc, **cfg)
  
   jetName = recoJetInfo.jetUpper
   payload = recoJetInfo.jetCorrPayload
  
   patJetFinalColl = recoJetInfo.patJetFinalCollection
   jetTablePrefix  = "FatJetCHS"
   jetTableDoc     = "AK8 PF CHS jets with JECs applied. Reclustered for JEC studies so only minimal info stored."
   ptcut           = ""# No need to specify ptcut. Use default in SavePatJets function
  
   SavePatJets(proc,
     jetName, payload, patJetFinalColl, jetTablePrefix, jetTableDoc, doPF=True,
     doCalo=False, ptcut=ptcut, doPUIDVar=False, doQGL=False, doBTag=False, runOnMC=runOnMC
   )
  
   return proc
  

References print(), and SavePatJets().

Referenced by PrepJMECustomNanoAOD().

◆ AddNewAK8GenJetsForJEC()

def custom_jme_cff.AddNewAK8GenJetsForJEC	(	proc,
		genJA
	)

Make a separate AK8 Gen jet collection for JEC studies.

Definition at line 965 of file custom_jme_cff.py.

 def AddNewAK8GenJetsForJEC(proc, genJA):
   """
   Make a separate AK8 Gen jet collection for JEC studies.
   """
   print("custom_jme_cff::AddNewAK8GenJetsForJEC: Add new AK8 Gen jets for JEC studies")
  
   #
   # Recluster AK8 Gen jet
   #
   cfg = {
     "jet" : "ak8gen",
   }
   genJetInfo = genJA.addGenJetCollection(proc, **cfg)
  
   genJetName         = genJetInfo.jetUpper
   genJetAlgo         = genJetInfo.jetAlgo
   genJetSize         = genJetInfo.jetSize
   genJetSizeNr       = genJetInfo.jetSizeNr
   genJetFinalColl    = "{}{}{}".format(genJetAlgo.upper(), genJetSize, "GenJetsNoNu")
   genJetTablePrefix  = "GenJetAK8ForJEC"
   genJetTableDoc     = "AK8 Gen jets (made with visible genparticles) with pt > 3 GeV. Reclustered for JEC studies."
  
   SaveGenJets(proc, genJetName, genJetAlgo, genJetSizeNr, genJetFinalColl, genJetTablePrefix, genJetTableDoc, runOnMC=False)
  
   return proc
  

References print(), and SaveGenJets().

Referenced by PrepJMECustomNanoAOD().

◆ AddNewAK8PuppiJetsForJEC()

def custom_jme_cff.AddNewAK8PuppiJetsForJEC	(	proc,
		recoJA,
		runOnMC
	)

Store a separate AK8 Puppi jet collection for JEC studies.
Only minimal info are stored

Definition at line 768 of file custom_jme_cff.py.

 def AddNewAK8PuppiJetsForJEC(proc, recoJA, runOnMC):
   """
   Store a separate AK8 Puppi jet collection for JEC studies.
   Only minimal info are stored
   """
   print("custom_jme_cff::AddNewAK8PuppiJetsForJEC: Make a new AK8 PF Puppi jet collection for JEC studies")
  
   #
   # Recluster AK8 Puppi jets
   #
   cfg = {
     "jet" : "ak8pfpuppi",
     "inputCollection" : "",
     "genJetsCollection": "AK8GenJetsNoNu",
     "minPtFastjet" : 0., # Remove any pt threshold at the jet clustering stage.
   }
   recoJetInfo = recoJA.addRecoJetCollection(proc, **cfg)
  
   jetName = recoJetInfo.jetUpper
   payload = recoJetInfo.jetCorrPayload
  
   patJetFinalColl = recoJetInfo.patJetFinalCollection
   jetTablePrefix  = "FatJetForJEC"
   jetTableDoc     = "AK8 PF Puppi jets with JECs applied. Reclustered for JEC studies so only minimal info stored."
   ptcut           = ""# No need to specify ptcut. Use default in SavePatJets function
  
   SavePatJets(proc,
     jetName, payload, patJetFinalColl, jetTablePrefix, jetTableDoc, doPF=True,
     doCalo=False, ptcut=ptcut, doPUIDVar=False, doQGL=False, doBTag=False, runOnMC=runOnMC
   )
  
   return proc
  

References print(), and SavePatJets().

Referenced by PrepJMECustomNanoAOD().

◆ AddNewGenJets()

def custom_jme_cff.AddNewGenJets	(	proc,
		genJetInfo
	)

Add genJet into custom nanoAOD

Definition at line 865 of file custom_jme_cff.py.

 def AddNewGenJets(proc, genJetInfo):
   """
   Add genJet into custom nanoAOD
   """
  
   genJetName         = genJetInfo.jetUpper
   genJetAlgo         = genJetInfo.jetAlgo
   genJetSize         = genJetInfo.jetSize
   genJetSizeNr       = genJetInfo.jetSizeNr
   genJetFinalColl    = "{}{}{}".format(genJetAlgo.upper(), genJetSize, "GenJetsNoNu")
   genJetTablePrefix  = nanoInfo_genjets[genJetInfo.jet]["name"]
   genJetTableDoc     = nanoInfo_genjets[genJetInfo.jet]["doc"]
  
   SaveGenJets(proc, genJetName, genJetAlgo, genJetSizeNr, genJetFinalColl, genJetTablePrefix, genJetTableDoc, runOnMC=False)
  
   return proc
  

References SaveGenJets().

Referenced by PrepJMECustomNanoAOD().

◆ AddNewPatJets()

def custom_jme_cff.AddNewPatJets	(	proc,
		recoJetInfo,
		runOnMC
	)

Add patJet into custom nanoAOD

Definition at line 425 of file custom_jme_cff.py.

 def AddNewPatJets(proc, recoJetInfo, runOnMC):
   """
   Add patJet into custom nanoAOD
   """
  
   jetName = recoJetInfo.jetUpper
   payload = recoJetInfo.jetCorrPayload
   doPF    = recoJetInfo.doPF
   doCalo  = recoJetInfo.doCalo
   patJetFinalColl = recoJetInfo.patJetFinalCollection
  
   nanoInfoForJet = nanoInfo_recojets[recoJetInfo.jet]
   jetTablePrefix = nanoInfoForJet["name"]
   jetTableDoc    = nanoInfoForJet["doc"]
   ptcut          = nanoInfoForJet["ptcut"] if "ptcut" in nanoInfoForJet else ""
   doPUIDVar      = nanoInfoForJet["doPUIDVar"] if "doPUIDVar" in nanoInfoForJet else False
   doQGL          = nanoInfoForJet["doQGL"] if "doQGL" in nanoInfoForJet else False
   doBTag         = nanoInfoForJet["doBTag"] if "doBTag" in nanoInfoForJet else False
  
   SavePatJets(proc,
     jetName, payload, patJetFinalColl, jetTablePrefix, jetTableDoc, doPF, doCalo,
     ptcut=ptcut, doPUIDVar=doPUIDVar, doQGL=doQGL, doBTag=doBTag, runOnMC=runOnMC
   )
  
   return proc
  

References SavePatJets().

Referenced by PrepJMECustomNanoAOD().

◆ AddParticleNetAK4Scores()

def custom_jme_cff.AddParticleNetAK4Scores	(	proc,
		jetTableName = `""`
	)

Store ParticleNetAK4 scores in jetTable

Definition at line 412 of file custom_jme_cff.py.

 def AddParticleNetAK4Scores(proc, jetTableName=""):
   """
   Store ParticleNetAK4 scores in jetTable
   """
  
   getattr(proc, jetTableName).variables.particleNetAK4_B = PARTICLENETAK4VARS.particleNetAK4_B
   getattr(proc, jetTableName).variables.particleNetAK4_CvsL = PARTICLENETAK4VARS.particleNetAK4_CvsL
   getattr(proc, jetTableName).variables.particleNetAK4_CvsB = PARTICLENETAK4VARS.particleNetAK4_CvsB
   getattr(proc, jetTableName).variables.particleNetAK4_QvsG = PARTICLENETAK4VARS.particleNetAK4_QvsG
   getattr(proc, jetTableName).variables.particleNetAK4_puIdDisc = PARTICLENETAK4VARS.particleNetAK4_puIdDisc
  
   return proc
  

Referenced by SavePatJets().

◆ AddPileUpJetIDVars()

def custom_jme_cff.AddPileUpJetIDVars	(	proc,
		jetName = `""`,
		jetSrc = `""`,
		jetTableName = `""`,
		jetSequenceName = `""`
	)

Setup modules to calculate pileup jet ID input variables for PF jet

Definition at line 286 of file custom_jme_cff.py.

 def AddPileUpJetIDVars(proc, jetName="", jetSrc="", jetTableName="", jetSequenceName=""):
   """
   Setup modules to calculate pileup jet ID input variables for PF jet
   """
  
   #
   # Calculate pileup jet ID variables
   #
   puJetIdVarsCalculator = "puJetIdCalculator{}".format(jetName)
   setattr(proc, puJetIdVarsCalculator, pileupJetIdCalculator.clone(
       jets = jetSrc,
       vertexes  = "offlineSlimmedPrimaryVertices",
       inputIsCorrected = True,
       applyJec  = False,
       usePuppi = True if "Puppi" in jetName else False
     )
   )
   getattr(proc,jetSequenceName).insert(getattr(proc,jetSequenceName).index(getattr(proc, jetSrc))+1, getattr(proc, puJetIdVarsCalculator))
  
   #
   # Get the variables
   #
   puJetIDVar = "puJetIDVar{}".format(jetName)
   setattr(proc, puJetIDVar, cms.EDProducer("PileupJetIDVarProducer",
       srcJet = cms.InputTag(jetSrc),
       srcPileupJetId = cms.InputTag(puJetIdVarsCalculator)
     )
   )
   getattr(proc,jetSequenceName).insert(getattr(proc,jetSequenceName).index(getattr(proc, puJetIdVarsCalculator))+1, getattr(proc, puJetIDVar))
  
   #
   # Save variables as userFloats and userInts for each jet
   # 
   patJetWithUserData = "{}WithUserData".format(jetSrc)
   getattr(proc,patJetWithUserData).userFloats.puId_dR2Mean  = cms.InputTag("{}:dR2Mean".format(puJetIDVar))
   getattr(proc,patJetWithUserData).userFloats.puId_majW     = cms.InputTag("{}:majW".format(puJetIDVar))
   getattr(proc,patJetWithUserData).userFloats.puId_minW     = cms.InputTag("{}:minW".format(puJetIDVar))
   getattr(proc,patJetWithUserData).userFloats.puId_frac01   = cms.InputTag("{}:frac01".format(puJetIDVar))
   getattr(proc,patJetWithUserData).userFloats.puId_frac02   = cms.InputTag("{}:frac02".format(puJetIDVar))
   getattr(proc,patJetWithUserData).userFloats.puId_frac03   = cms.InputTag("{}:frac03".format(puJetIDVar))
   getattr(proc,patJetWithUserData).userFloats.puId_frac04   = cms.InputTag("{}:frac04".format(puJetIDVar))
   getattr(proc,patJetWithUserData).userFloats.puId_ptD      = cms.InputTag("{}:ptD".format(puJetIDVar))
   getattr(proc,patJetWithUserData).userFloats.puId_beta     = cms.InputTag("{}:beta".format(puJetIDVar))
   getattr(proc,patJetWithUserData).userFloats.puId_pull     = cms.InputTag("{}:pull".format(puJetIDVar))
   getattr(proc,patJetWithUserData).userFloats.puId_jetR     = cms.InputTag("{}:jetR".format(puJetIDVar))
   getattr(proc,patJetWithUserData).userFloats.puId_jetRchg  = cms.InputTag("{}:jetRchg".format(puJetIDVar))
   getattr(proc,patJetWithUserData).userInts.puId_nCharged   = cms.InputTag("{}:nCharged".format(puJetIDVar))
  
   #
   # Specfiy variables in the jet table to save in NanoAOD
   #
   getattr(proc,jetTableName).variables.puId_dR2Mean  = PUIDVARS.puId_dR2Mean
   getattr(proc,jetTableName).variables.puId_majW     = PUIDVARS.puId_majW
   getattr(proc,jetTableName).variables.puId_minW     = PUIDVARS.puId_minW
   getattr(proc,jetTableName).variables.puId_frac01   = PUIDVARS.puId_frac01
   getattr(proc,jetTableName).variables.puId_frac02   = PUIDVARS.puId_frac02
   getattr(proc,jetTableName).variables.puId_frac03   = PUIDVARS.puId_frac03
   getattr(proc,jetTableName).variables.puId_frac04   = PUIDVARS.puId_frac04
   getattr(proc,jetTableName).variables.puId_ptD      = PUIDVARS.puId_ptD
   getattr(proc,jetTableName).variables.puId_beta     = PUIDVARS.puId_beta
   getattr(proc,jetTableName).variables.puId_pull     = PUIDVARS.puId_pull
   getattr(proc,jetTableName).variables.puId_jetR     = PUIDVARS.puId_jetR
   getattr(proc,jetTableName).variables.puId_jetRchg  = PUIDVARS.puId_jetRchg
   getattr(proc,jetTableName).variables.puId_nCharged = PUIDVARS.puId_nCharged
  
   return proc
  

References edm::eventsetup::heterocontainer.insert().

Referenced by ReclusterAK4CHSJets(), and SavePatJets().

◆ AddQGLTaggerVars()

def custom_jme_cff.AddQGLTaggerVars	(	proc,
		jetName = `""`,
		jetSrc = `""`,
		jetTableName = `""`,
		jetSequenceName = `""`,
		calculateQGLVars = `False`
	)

Schedule the QGTagger module to calculate input variables to the QG likelihood

Definition at line 353 of file custom_jme_cff.py.

 def AddQGLTaggerVars(proc, jetName="", jetSrc="", jetTableName="", jetSequenceName="", calculateQGLVars=False):
   """
   Schedule the QGTagger module to calculate input variables to the QG likelihood
   """
  
   QGLTagger="qgtagger{}".format(jetName)
   patJetWithUserData="{}WithUserData".format(jetSrc)
  
   if calculateQGLVars:
     setattr(proc, QGLTagger, qgtagger.clone(
         srcJets = jetSrc
       )
     )
  
   #
   # Save variables as userFloats and userInts for each jet
   # 
   getattr(proc,patJetWithUserData).userFloats.qgl_axis2 = cms.InputTag(QGLTagger+":axis2")
   getattr(proc,patJetWithUserData).userFloats.qgl_ptD   = cms.InputTag(QGLTagger+":ptD")
   getattr(proc,patJetWithUserData).userInts.qgl_mult    = cms.InputTag(QGLTagger+":mult")
  
   #
   # Specfiy variables in the jet table to save in NanoAOD
   #
   getattr(proc,jetTableName).variables.qgl_axis2 =  QGLVARS.qgl_axis2
   getattr(proc,jetTableName).variables.qgl_ptD   =  QGLVARS.qgl_ptD
   getattr(proc,jetTableName).variables.qgl_mult  =  QGLVARS.qgl_mult
  
   if calculateQGLVars:
     getattr(proc,jetSequenceName).insert(getattr(proc,jetSequenceName).index(getattr(proc, jetSrc))+1, getattr(proc, QGLTagger))
  
   return proc
  

References edm::eventsetup::heterocontainer.insert().

Referenced by SavePatJets().

◆ AddVariablesForAK4GenJets()

def custom_jme_cff.AddVariablesForAK4GenJets ( proc )

Definition at line 991 of file custom_jme_cff.py.

 def AddVariablesForAK4GenJets(proc):
   proc.genJetTable.variables.nConstituents = GENJETVARS.nConstituents
   return proc
  

Referenced by PrepJMECustomNanoAOD().

◆ AddVariablesForAK8GenJets()

def custom_jme_cff.AddVariablesForAK8GenJets ( proc )

Definition at line 995 of file custom_jme_cff.py.

 def AddVariablesForAK8GenJets(proc):
   proc.genJetAK8Table.variables.nConstituents = GENJETVARS.nConstituents
   return proc
  
 #===========================================================================
 #
 # Misc. functions
 #
 #===========================================================================

Referenced by PrepJMECustomNanoAOD().

◆ AddVariablesForAK8PuppiJets()

def custom_jme_cff.AddVariablesForAK8PuppiJets ( proc )

Add more variables for AK8 PFPUPPI jets

Definition at line 833 of file custom_jme_cff.py.

 def AddVariablesForAK8PuppiJets(proc):
   """
   Add more variables for AK8 PFPUPPI jets
   """
  
   #
   #  These variables are not stored for AK8PFPUPPI (slimmedJetsAK8)
   #  in MiniAOD if their pt < 170 GeV. Hence the conditional fill.
   #
   proc.fatJetTable.variables.chHEF  = Var("?isPFJet()?chargedHadronEnergyFraction():-1", float, doc="charged Hadron Energy Fraction", precision = 6)
   proc.fatJetTable.variables.neHEF  = Var("?isPFJet()?neutralHadronEnergyFraction():-1", float, doc="neutral Hadron Energy Fraction", precision = 6)
   proc.fatJetTable.variables.chEmEF = Var("?isPFJet()?chargedEmEnergyFraction():-1", float, doc="charged Electromagnetic Energy Fraction", precision = 6)
   proc.fatJetTable.variables.neEmEF = Var("?isPFJet()?neutralEmEnergyFraction():-1", float, doc="neutral Electromagnetic Energy Fraction", precision = 6)
   proc.fatJetTable.variables.muEF   = Var("?isPFJet()?muonEnergyFraction():-1", float, doc="muon Energy Fraction", precision = 6)
   proc.fatJetTable.variables.hfHEF  = Var("?isPFJet()?HFHadronEnergyFraction():-1", float, doc="energy fraction in forward hadronic calorimeter", precision = 6)
   proc.fatJetTable.variables.hfEmEF = Var("?isPFJet()?HFEMEnergyFraction():-1", float, doc="energy fraction in forward EM calorimeter", precision = 6)
   proc.fatJetTable.variables.nConstChHads   = Var("?isPFJet()?chargedHadronMultiplicity():-1",int, doc="number of charged hadrons in the jet")
   proc.fatJetTable.variables.nConstNeuHads  = Var("?isPFJet()?neutralHadronMultiplicity():-1",int, doc="number of neutral hadrons in the jet")
   proc.fatJetTable.variables.nConstHFHads   = Var("?isPFJet()?HFHadronMultiplicity():-1", int, doc="number of HF Hadrons in the jet")
   proc.fatJetTable.variables.nConstHFEMs    = Var("?isPFJet()?HFEMMultiplicity():-1", int, doc="number of HF EMs in the jet")
   proc.fatJetTable.variables.nConstMuons    = Var("?isPFJet()?muonMultiplicity():-1", int, doc="number of muons in the jet")
   proc.fatJetTable.variables.nConstElecs    = Var("?isPFJet()?electronMultiplicity():-1", int, doc="number of electrons in the jet")
   proc.fatJetTable.variables.nConstPhotons  = Var("?isPFJet()?photonMultiplicity():-1", int, doc="number of photons in the jet")
  
   return proc
 #******************************************
 #
 #
 # Gen Jets related functions
 # 
 #
 #******************************************

References common_cff.Var().

Referenced by PrepJMECustomNanoAOD().

◆ PrepJMECustomNanoAOD()

def custom_jme_cff.PrepJMECustomNanoAOD	(	process,
		runOnMC
	)

Definition at line 1023 of file custom_jme_cff.py.

 def PrepJMECustomNanoAOD(process,runOnMC):
  
   process = RemoveAllJetPtCuts(process)
  
   genJA = GenJetAdder()
   if runOnMC:
     
     process = AddVariablesForAK8GenJets(process)
     
     process = AddNewAK8GenJetsForJEC(process, genJA)
     
     process = ReclusterAK4GenJets(process, genJA)
     process = AddVariablesForAK4GenJets(process)
     
     for jetConfig in config_genjets:
       cfg = { k : v for k, v in jetConfig.items() if k != "enabled"}
       genJetInfo = genJA.addGenJetCollection(process, **cfg)
       AddNewGenJets(process, genJetInfo)
  
   recoJA = RecoJetAdder(runOnMC=runOnMC)
   
   process = AddVariablesForAK8PuppiJets(process)
   
   process = AddNewAK8PuppiJetsForJEC(process, recoJA, runOnMC)
   
   process = AddNewAK8CHSJets(process, recoJA, runOnMC)
   
   process = ReclusterAK4CHSJets(process, recoJA, runOnMC)
   
   for jetConfig in config_recojets:
     cfg = { k : v for k, v in jetConfig.items() if k != "enabled"}
     recoJetInfo = recoJA.addRecoJetCollection(process, **cfg)
     AddNewPatJets(process, recoJetInfo, runOnMC)
  
   if runOnMC:
     process.puTable.savePtHatMax = True
  
   if runOnMC:
     process.genWeightsTable.keepAllPSWeights = True
   
   return process

References AddNewAK8CHSJets(), AddNewAK8GenJetsForJEC(), AddNewAK8PuppiJetsForJEC(), AddNewGenJets(), AddNewPatJets(), AddVariablesForAK4GenJets(), AddVariablesForAK8GenJets(), AddVariablesForAK8PuppiJets(), ReclusterAK4CHSJets(), ReclusterAK4GenJets(), and RemoveAllJetPtCuts().

Referenced by PrepJMECustomNanoAOD_Data(), and PrepJMECustomNanoAOD_MC().

◆ PrepJMECustomNanoAOD_Data()

def custom_jme_cff.PrepJMECustomNanoAOD_Data ( process )

Definition at line 1106 of file custom_jme_cff.py.

 def PrepJMECustomNanoAOD_Data(process):
   PrepJMECustomNanoAOD(process,runOnMC=False)
   return process

References PrepJMECustomNanoAOD().

◆ PrepJMECustomNanoAOD_MC()

def custom_jme_cff.PrepJMECustomNanoAOD_MC ( process )

Definition at line 1102 of file custom_jme_cff.py.

 def PrepJMECustomNanoAOD_MC(process):
   PrepJMECustomNanoAOD(process,runOnMC=True)
   return process
  

References PrepJMECustomNanoAOD().

◆ ReclusterAK4CHSJets()

def custom_jme_cff.ReclusterAK4CHSJets	(	proc,
		recoJA,
		runOnMC
	)

Recluster AK4 CHS jets and replace slimmedJets
that is used as default to save AK4 CHS jets 
in NanoAODs.

Definition at line 596 of file custom_jme_cff.py.

 def ReclusterAK4CHSJets(proc, recoJA, runOnMC):
   """
   Recluster AK4 CHS jets and replace slimmedJets
   that is used as default to save AK4 CHS jets 
   in NanoAODs.  
   """
   print("custom_jme_cff::ReclusterAK4CHSJets: Recluster AK4 PF CHS jets")
  
   #
   # Recluster AK4 CHS jets
   #
   cfg = { 
     "jet" : "ak4pfchs",
     "inputCollection" : "",
     "genJetsCollection": "AK4GenJetsNoNu",
     "bTagDiscriminators": bTagDiscriminatorsForAK4,
     "minPtFastjet" : 0.,
   }
   recoJetInfo = recoJA.addRecoJetCollection(proc, **cfg)
  
   jetName = recoJetInfo.jetUpper
   patJetFinalColl = recoJetInfo.patJetFinalCollection
   
   #
   # Change the input jet source for jetCorrFactorsNano
   # and updatedJets
   # 
   proc.jetCorrFactorsNano.src=patJetFinalColl
   proc.updatedJets.jetSource=patJetFinalColl
  
   #
   # Change pt cut
   #
   finalJetsCut = ""
   if runOnMC:
     finalJetsCut = "(pt >= 8) || ((pt < 8) && (genJetFwdRef().backRef().isNonnull()))"
   else:
     finalJetsCut = "(pt >= 8)"
  
   proc.finalJets.cut = finalJetsCut
   #
   # Add a minimum pt cut for corrT1METJets.
   #
   proc.corrT1METJetTable.cut = "pt>=8 && pt<15 && abs(eta)<9.9"
  
   #
   # Jet table cut
   #
   jetTableCut = "" # must not have any cut at the jetTable for AK4 CHS as it has been cross-cleaned
   proc.jetTable.cut   = jetTableCut
   proc.jetMCTable.cut = jetTableCut
  
   #
   # Jet table documentation
   #
   jetTableDoc = "AK4 PF CHS jets with JECs applied. Jets with pt > 8 GeV are stored."
   if runOnMC:
     jetTableDoc += "For jets with pt < 8 GeV, only those matched to AK4 Gen jets are stored."
   proc.jetTable.doc   = jetTableDoc
  
   #
   # Add variables
   #
   proc.jetTable.variables.hfHEF         = PFJETVARS.hfHEF
   proc.jetTable.variables.hfEmEF        = PFJETVARS.hfEmEF
   proc.jetTable.variables.nConstChHads  = PFJETVARS.nConstChHads
   proc.jetTable.variables.nConstNeuHads = PFJETVARS.nConstNeuHads
   proc.jetTable.variables.nConstHFHads  = PFJETVARS.nConstHFHads
   proc.jetTable.variables.nConstHFEMs   = PFJETVARS.nConstHFEMs
   proc.jetTable.variables.nConstMuons   = PFJETVARS.nConstMuons
   proc.jetTable.variables.nConstElecs   = PFJETVARS.nConstElecs
   proc.jetTable.variables.nConstPhotons = PFJETVARS.nConstPhotons
  
   #
   # Setup pileup jet ID with 80X training.
   #
   pileupJetId80X = "pileupJetId80X"
   setattr(proc, pileupJetId80X, pileupJetId.clone(
       jets = "updatedJets",
       algos = cms.VPSet(_chsalgos_81x),
       inputIsCorrected = True,
       applyJec = False,
       vertexes = "offlineSlimmedPrimaryVertices"
     )
   )
   proc.jetSequence.insert(proc.jetSequence.index(proc.pileupJetId94X), getattr(proc, pileupJetId80X))
  
   proc.updatedJetsWithUserData.userInts.puId80XfullId = cms.InputTag('pileupJetId80X:fullId')
   proc.updatedJetsWithUserData.userFloats.puId80XDisc = cms.InputTag("pileupJetId80X:fullDiscriminant")
  
   run2_jme_2016.toModify(proc.jetTable.variables, puIdDisc = Var("userFloat('puId80XDisc')",float,doc="Pilup ID discriminant with 80X (2016) training",precision=10))
   run2_jme_2016.toModify(proc.jetTable.variables, puId = Var("userInt('puId80XfullId')",int,doc="Pileup ID flags with 80X (2016) training"))
  
   for modifier in run2_nanoAOD_94X2016, run2_nanoAOD_94XMiniAODv1, run2_nanoAOD_94XMiniAODv2, run2_nanoAOD_102Xv1:
     modifier.toModify(proc.jetTable.variables, puId = Var("userInt('puId80XfullId')", int, doc="Pileup ID flags with 80X (2016) training"))
  
   #
   # Add charged energy fraction from other primary vertices
   #
   proc.updatedJetsWithUserData.userFloats.chFPV1EF = cms.InputTag("jercVars:chargedFromPV1EnergyFraction")
   proc.updatedJetsWithUserData.userFloats.chFPV2EF = cms.InputTag("jercVars:chargedFromPV2EnergyFraction")
   proc.updatedJetsWithUserData.userFloats.chFPV3EF = cms.InputTag("jercVars:chargedFromPV3EnergyFraction")
   proc.jetTable.variables.chFPV1EF = Var("userFloat('chFPV1EF')", float, doc="charged fromPV==1 Energy Fraction (component of the total charged Energy Fraction).", precision= 6)
   proc.jetTable.variables.chFPV2EF = Var("userFloat('chFPV2EF')", float, doc="charged fromPV==2 Energy Fraction (component of the total charged Energy Fraction).", precision= 6)
   proc.jetTable.variables.chFPV3EF = Var("userFloat('chFPV3EF')", float, doc="charged fromPV==3 Energy Fraction (component of the total charged Energy Fraction).", precision= 6)
  
   #
   # Add variables for pileup jet ID studies.
   #
   proc = AddPileUpJetIDVars(proc, 
     jetName = "",
     jetSrc = "updatedJets",
     jetTableName = "jetTable",
     jetSequenceName = "jetSequence"
   )
   #
   # Add variables for quark guon likelihood tagger studies.
   # Save variables as userFloats and userInts in each jet
   #
   proc.updatedJetsWithUserData.userFloats.qgl_axis2 = cms.InputTag("qgtagger:axis2")
   proc.updatedJetsWithUserData.userFloats.qgl_ptD   = cms.InputTag("qgtagger:ptD")
   proc.updatedJetsWithUserData.userInts.qgl_mult    = cms.InputTag("qgtagger:mult")
   #
   # Save quark gluon likelihood input variables variables
   #
   proc.jetTable.variables.qgl_axis2 =  QGLVARS.qgl_axis2
   proc.jetTable.variables.qgl_ptD   =  QGLVARS.qgl_ptD
   proc.jetTable.variables.qgl_mult  =  QGLVARS.qgl_mult
   #
   # Save standard b-tagging and c-tagging variables
   #
   proc.jetTable.variables.btagDeepB = BTAGVARS.btagDeepB
   proc.jetTable.variables.btagCSVV2 = BTAGVARS.btagCSVV2
   proc.jetTable.variables.btagDeepCvL = BTAGVARS.btagDeepCvL
   proc.jetTable.variables.btagDeepCvB = BTAGVARS.btagDeepCvB
   #
   # Save DeepJet b-tagging and c-tagging variables
   #
   proc.jetTable.variables.btagDeepFlavB    = DEEPJETVARS.btagDeepFlavB
   proc.jetTable.variables.btagDeepFlavCvL  = DEEPJETVARS.btagDeepFlavCvL
   proc.jetTable.variables.btagDeepFlavCvB  = DEEPJETVARS.btagDeepFlavCvB
   #
   # Save DeepJet raw score for gluon and light quarks
   #
   proc.jetTable.variables.btagDeepFlavG   = DEEPJETVARS.btagDeepFlavG
   proc.jetTable.variables.btagDeepFlavUDS = DEEPJETVARS.btagDeepFlavUDS
   proc.jetTable.variables.btagDeepFlavQG  = DEEPJETVARS.btagDeepFlavQG
   #
   # Add ParticleNetAK4 scores
   #
   proc.jetTable.variables.particleNetAK4_B          = PARTICLENETAK4VARS.particleNetAK4_B
   proc.jetTable.variables.particleNetAK4_CvsL       = PARTICLENETAK4VARS.particleNetAK4_CvsL
   proc.jetTable.variables.particleNetAK4_CvsB       = PARTICLENETAK4VARS.particleNetAK4_CvsB
   proc.jetTable.variables.particleNetAK4_QvsG       = PARTICLENETAK4VARS.particleNetAK4_QvsG
   proc.jetTable.variables.particleNetAK4_puIdDisc   = PARTICLENETAK4VARS.particleNetAK4_puIdDisc
  
   #Adding hf shower shape producer to the jet sequence. By default this producer is not automatically rerun at the NANOAOD step
   #The following lines make sure it is.
   hfJetShowerShapeforCustomNanoAOD = "hfJetShowerShapeforCustomNanoAOD"
   setattr(proc, hfJetShowerShapeforCustomNanoAOD, hfJetShowerShapeforNanoAOD.clone(jets="updatedJets",vertices="offlineSlimmedPrimaryVertices") )
   proc.jetSequence.insert(proc.jetSequence.index(proc.updatedJetsWithUserData), getattr(proc, hfJetShowerShapeforCustomNanoAOD))
   proc.updatedJetsWithUserData.userFloats.hfsigmaEtaEta = cms.InputTag('hfJetShowerShapeforCustomNanoAOD:sigmaEtaEta')
   proc.updatedJetsWithUserData.userFloats.hfsigmaPhiPhi = cms.InputTag('hfJetShowerShapeforCustomNanoAOD:sigmaPhiPhi')
   proc.updatedJetsWithUserData.userInts.hfcentralEtaStripSize = cms.InputTag('hfJetShowerShapeforCustomNanoAOD:centralEtaStripSize')
   proc.updatedJetsWithUserData.userInts.hfadjacentEtaStripsSize = cms.InputTag('hfJetShowerShapeforCustomNanoAOD:adjacentEtaStripsSize')
   proc.jetTable.variables.hfsigmaEtaEta = Var("userFloat('hfsigmaEtaEta')",float,doc="sigmaEtaEta for HF jets (noise discriminating variable)",precision=10)
   proc.jetTable.variables.hfsigmaPhiPhi = Var("userFloat('hfsigmaPhiPhi')",float,doc="sigmaPhiPhi for HF jets (noise discriminating variable)",precision=10)
   proc.jetTable.variables.hfcentralEtaStripSize = Var("userInt('hfcentralEtaStripSize')", int, doc="eta size of the central tower strip in HF (noise discriminating variable) ")
   proc.jetTable.variables.hfadjacentEtaStripsSize = Var("userInt('hfadjacentEtaStripsSize')", int, doc="eta size of the strips next to the central tower strip in HF (noise discriminating variable) ")
  
   return proc
  

References AddPileUpJetIDVars(), print(), and common_cff.Var().

Referenced by PrepJMECustomNanoAOD().

◆ ReclusterAK4GenJets()

def custom_jme_cff.ReclusterAK4GenJets	(	proc,
		genJA
	)

Recluster AK4 Gen jets and replace
slimmedGenJets that is used as default
to save AK4 Gen jets in NanoAODs.

Definition at line 925 of file custom_jme_cff.py.

 def ReclusterAK4GenJets(proc, genJA):
   """
   Recluster AK4 Gen jets and replace
   slimmedGenJets that is used as default
   to save AK4 Gen jets in NanoAODs.
   """
   print("custom_jme_cff::ReclusterAK4GenJets: Recluster AK4 Gen jets")
  
   #
   # Recluster AK4 Gen jet
   #
   cfg = { 
     "jet" : "ak4gen",   
   }
   genJetInfo = genJA.addGenJetCollection(proc, **cfg)
  
   genJetName      = genJetInfo.jetUpper
   genJetAlgo      = genJetInfo.jetAlgo
   genJetSize      = genJetInfo.jetSize
   genJetSizeNr    = genJetInfo.jetSizeNr
   selectedGenJets = "{}{}{}".format(genJetAlgo.upper(), genJetSize, "GenJetsNoNu")
  
   #
   # Change jet source to the newly clustered jet collection. Set very low pt cut for jets
   # to be stored in the GenJet Table
   #
   proc.genJetTable.src = selectedGenJets
   proc.genJetTable.cut = "" # No cut specified here. Save all gen jets after clustering
   proc.genJetTable.doc = "AK4 Gen jets (made with visible genparticles) with pt > 3 GeV" # default pt cut after clustering is 3 GeV
  
   genJetFlavourAssociationThisJet = "genJet{}FlavourAssociation".format(genJetName)
   setattr(proc, genJetFlavourAssociationThisJet, genJetFlavourAssociation.clone(
       jets           = proc.genJetTable.src,
       jetAlgorithm   = supportedJetAlgos[genJetAlgo],
       rParam         = genJetSizeNr,
     )
   )
   proc.jetMC.insert(proc.jetMC.index(proc.genJetFlavourTable), getattr(proc, genJetFlavourAssociationThisJet))
   return proc
  

References print().

Referenced by PrepJMECustomNanoAOD().

◆ RemoveAllJetPtCuts()

def custom_jme_cff.RemoveAllJetPtCuts ( proc )

Remove default pt cuts for all jets set in jets_cff.py

Definition at line 1004 of file custom_jme_cff.py.

 def RemoveAllJetPtCuts(proc):
   """
   Remove default pt cuts for all jets set in jets_cff.py
   """
  
   proc.finalJets.cut             = "" # 15 -> 10
   proc.finalJetsAK8.cut          = "" # 170 -> 170
   proc.genJetTable.cut           = "" # 10 -> 8
   proc.genJetFlavourTable.cut    = "" # 10 -> 8
   proc.genJetAK8Table.cut        = "" # 100 -> 80
   proc.genJetAK8FlavourTable.cut = "" # 100 -> 80
  
   return proc
  
 #===========================================================================
 #
 # CUSTOMIZATION function
 #
 #===========================================================================

Referenced by PrepJMECustomNanoAOD().

◆ SaveGenJets()

def custom_jme_cff.SaveGenJets	(	proc,
		genJetName,
		genJetAlgo,
		genJetSizeNr,
		genJetFinalColl,
		genJetTablePrefix,
		genJetTableDoc,
		runOnMC = `False`
	)

Schedule modules for a given genJet collection and save its variables into custom NanoAOD

Definition at line 882 of file custom_jme_cff.py.

 def SaveGenJets(proc, genJetName, genJetAlgo, genJetSizeNr, genJetFinalColl, genJetTablePrefix, genJetTableDoc, runOnMC=False):
   """
   Schedule modules for a given genJet collection and save its variables into custom NanoAOD
   """
  
   genJetTableThisJet = "jet{}Table".format(genJetName)
   setattr(proc, genJetTableThisJet, genJetTable.clone(
       src       = genJetFinalColl,
       cut       = "", # No cut specified here. Save all gen jets after clustering
       name      = genJetTablePrefix,
       doc       = genJetTableDoc,
       variables = GENJETVARS
     )
   )
  
   genJetFlavourAssociationThisJet = "genJet{}FlavourAssociation".format(genJetName)
   setattr(proc, genJetFlavourAssociationThisJet, genJetFlavourAssociation.clone(
       jets           = getattr(proc,genJetTableThisJet).src,
       jetAlgorithm   = supportedJetAlgos[genJetAlgo],
       rParam         = genJetSizeNr,
     )
   )
  
   genJetFlavourTableThisJet = "genJet{}FlavourTable".format(genJetName)
   setattr(proc, genJetFlavourTableThisJet, genJetFlavourTable.clone(
       name            = getattr(proc,genJetTableThisJet).name,
       src             = getattr(proc,genJetTableThisJet).src,
       cut             = getattr(proc,genJetTableThisJet).cut,
       jetFlavourInfos = genJetFlavourAssociationThisJet,
     )
   )
  
   genJetSequenceName = "genJet{}Sequence".format(genJetName)
   setattr(proc, genJetSequenceName, cms.Sequence(
       getattr(proc,genJetTableThisJet)+
       getattr(proc,genJetFlavourAssociationThisJet)+
       getattr(proc,genJetFlavourTableThisJet)
     )
   )
   proc.nanoSequenceMC.insert(proc.nanoSequenceMC.index(proc.jetMC)+1, getattr(proc,genJetSequenceName))
  
   return proc
  

Referenced by AddNewAK8GenJetsForJEC(), and AddNewGenJets().

◆ SavePatJets()

def custom_jme_cff.SavePatJets	(	proc,
		jetName,
		payload,
		patJetFinalColl,
		jetTablePrefix,
		jetTableDoc,
		doPF,
		doCalo,
		ptcut = `""`,
		doPUIDVar = `False`,
		doQGL = `False`,
		doBTag = `False`,
		runOnMC = `False`
	)

Schedule modules for a given patJet collection and save its variables into custom NanoAOD

Definition at line 451 of file custom_jme_cff.py.

 def SavePatJets(proc, jetName, payload, patJetFinalColl, jetTablePrefix, jetTableDoc,
                 doPF, doCalo, ptcut="", doPUIDVar=False, doQGL=False, doBTag=False, runOnMC=False):
   """
   Schedule modules for a given patJet collection and save its variables into custom NanoAOD
   """
  
   #
   # Setup jet correction factors
   #
   jetCorrFactors = "jetCorrFactorsNano{}".format(jetName)
   setattr(proc, jetCorrFactors, jetCorrFactorsNano.clone(
       src = patJetFinalColl,
       payload = payload,
     )
   )
  
   #
   # Update jets
   #
   srcJets = "updatedJets{}".format(jetName)
   setattr(proc, srcJets, updatedJets.clone(
       jetSource = patJetFinalColl,
       jetCorrFactorsSource = [jetCorrFactors],
     )
   )
    
   #
   # Setup UserDataEmbedder
   #
   srcJetsWithUserData = "updatedJets{}WithUserData".format(jetName)
   setattr(proc, srcJetsWithUserData, cms.EDProducer("PATJetUserDataEmbedder",
       src = cms.InputTag(srcJets),
       userFloats = cms.PSet(),
       userInts = cms.PSet(),
     )
   )
   
   #
   # Filter jets with pt cut
   #
   finalJetsCutDefault = "(pt >= 8)"
   if runOnMC:
     finalJetsCutDefault = "(pt >= 8) || ((pt < 8) && (genJetFwdRef().backRef().isNonnull()))"
  
   finalJetsForTable = "finalJets{}".format(jetName)
   setattr(proc, finalJetsForTable, finalJets.clone(
       src = srcJetsWithUserData,
       cut = ptcut if ptcut != "" else finalJetsCutDefault
     )
   )
  
   #
   # Save jets in table
   #
   tableContent = PFJETVARS
   if doCalo:
     tableContent = CALOJETVARS
  
   jetTableCutDefault = "" #Don't apply any cuts for the table.
  
   jetTableDocDefault = jetTableDoc + " with JECs applied. Jets with pt > 8 GeV are stored."
   if runOnMC:
     jetTableDocDefault += "For jets with pt < 8 GeV, only those matched to gen jets are stored."
  
   jetTable = "jet{}Table".format(jetName)
   setattr(proc,jetTable, cms.EDProducer("SimpleCandidateFlatTableProducer",
       src = cms.InputTag(finalJetsForTable),
       cut = cms.string(jetTableCutDefault),
       name = cms.string(jetTablePrefix),
       doc  = cms.string(jetTableDocDefault),
       singleton = cms.bool(False), # the number of entries is variable
       extension = cms.bool(False), # this is the main table for the jets
       variables = cms.PSet(tableContent)
     )
   )
   getattr(proc,jetTable).variables.pt.precision=10
  
   #
   # Save MC-only jet variables in table
   #
   jetMCTable = "jet{}MCTable".format(jetName)
   setattr(proc, jetMCTable, cms.EDProducer("SimpleCandidateFlatTableProducer",
       src = cms.InputTag(finalJetsForTable),
       cut = getattr(proc,jetTable).cut,
       name = cms.string(jetTablePrefix),
       singleton = cms.bool(False),
       extension = cms.bool(True), # this is an extension table
       variables = cms.PSet(
         partonFlavour = Var("partonFlavour()", int, doc="flavour from parton matching"),
         hadronFlavour = Var("hadronFlavour()", int, doc="flavour from hadron ghost clustering"),
         genJetIdx = Var("?genJetFwdRef().backRef().isNonnull()?genJetFwdRef().backRef().key():-1", int, doc="index of matched gen jet"),
       )
     )
   )
  
   #
   # Define the jet modules sequence first
   #
   jetSequenceName = "jet{}Sequence".format(jetName)
   setattr(proc, jetSequenceName, cms.Sequence(
       getattr(proc,jetCorrFactors)+
       getattr(proc,srcJets)+
       getattr(proc,srcJetsWithUserData)+
       getattr(proc,finalJetsForTable)
     )
   )
  
   #
   # Define the jet table sequences
   #
   jetTableSequenceName = "jet{}TablesSequence".format(jetName)
   setattr(proc, jetTableSequenceName, cms.Sequence(getattr(proc,jetTable)))
  
   jetTableSequenceMCName = "jet{}MCTablesSequence".format(jetName)
   setattr(proc, jetTableSequenceMCName, cms.Sequence(getattr(proc,jetMCTable)))
   
   if runOnMC:
     proc.nanoSequenceMC += getattr(proc,jetSequenceName)
     proc.nanoSequenceMC += getattr(proc,jetTableSequenceName)
     proc.nanoSequenceMC += getattr(proc,jetTableSequenceMCName)
   else:
     proc.nanoSequence += getattr(proc,jetSequenceName)
     proc.nanoSequence += getattr(proc,jetTableSequenceName)
  
   #
   # Schedule plugins to calculate Jet ID, PileUp Jet ID input variables, and Quark-Gluon Likehood input variables.
   #
   if doPF:
     proc = AddJetID(proc, jetName=jetName, jetSrc=srcJets, jetTableName=jetTable, jetSequenceName=jetSequenceName)
     if doPUIDVar:
       proc = AddPileUpJetIDVars(proc, jetName=jetName, jetSrc=srcJets, jetTableName=jetTable, jetSequenceName=jetSequenceName)
     if doQGL:
       proc = AddQGLTaggerVars(proc,jetName=jetName, jetSrc=srcJets, jetTableName=jetTable, jetSequenceName=jetSequenceName, calculateQGLVars=True)
   
   #
   # Save b-tagging algorithm scores. Should only be done for jet collection with b-tagging
   # calculated when reclustered or collection saved with b-tagging info in MiniAOD
   #
   if doBTag:
     AddBTaggingScores(proc,jetTableName=jetTable)
     AddDeepJetGluonLQuarkScores(proc,jetTableName=jetTable)
     AddParticleNetAK4Scores(proc,jetTableName=jetTable)
  
   return proc
  

References AddBTaggingScores(), AddDeepJetGluonLQuarkScores(), AddJetID(), AddParticleNetAK4Scores(), AddPileUpJetIDVars(), AddQGLTaggerVars(), and common_cff.Var().

Referenced by AddNewAK8CHSJets(), AddNewAK8PuppiJetsForJEC(), and AddNewPatJets().

Variable Documentation

◆ area

custom_jme_cff.area

Definition at line 140 of file custom_jme_cff.py.

Referenced by HGCalWaferType.areaPolygon(), AreaSeededTrackingRegionsProducer.AreaSeededTrackingRegionsProducer(), RPCRecHitValid.bookHistograms(), EventShapeVariables.circularity(), CaloDetIdAssociator.crossedElement(), RPCRecHitValidClient.dqmEndJob(), effectiveSigma(), HOCalibAnalyzer.endJob(), FWECALDetailViewBuilder.fillEtaPhi(), PhiSymmetryCalibration_step2_SM.fillHistos(), PhiSymmetryCalibration_step2.fillHistos(), HGCalHistoSeedingImpl.fillSmoothPhiHistoClusters(), HGCalGeometry.getArea(), pat::PATMuonProducer.getRelMiniIsoPUCorrected(), pat.muonRelMiniIsoPUCorrected(), HcalDDDSimConstants.printTileHB(), HcalDDDSimConstants.printTileHE(), HiFJRhoProducer.produce(), AreaSeededTrackingRegionsBuilder::Builder.regionImpl(), SubjetFilterAlgorithm.run(), JME::JetParameters.setJetArea(), RPCSimSimple.simulateNoise(), RPCSimParam.simulateNoise(), RPCSimAverageNoise.simulateNoise(), RPCSimAverage.simulateNoise(), RPCSimModelTiming.simulateNoise(), RPCSimAverageNoiseEff.simulateNoise(), RPCSimAverageNoiseEffCls.simulateNoise(), RPCSimAsymmetricCls.simulateNoise(), CosmicMuonGenerator.terminate(), and DDI::EllipticalTube.volume().

◆ bTagCSVV2

custom_jme_cff.bTagCSVV2

Definition at line 20 of file custom_jme_cff.py.

◆ btagCSVV2

custom_jme_cff.btagCSVV2

Definition at line 181 of file custom_jme_cff.py.

◆ btagDDX

custom_jme_cff.btagDDX

Definition at line 33 of file custom_jme_cff.py.

◆ btagDDXV2

custom_jme_cff.btagDDXV2

Definition at line 41 of file custom_jme_cff.py.

◆ btagDeepB

custom_jme_cff.btagDeepB

Definition at line 180 of file custom_jme_cff.py.

◆ bTagDeepCSV

custom_jme_cff.bTagDeepCSV

Definition at line 21 of file custom_jme_cff.py.

◆ btagDeepCvB

custom_jme_cff.btagDeepCvB

Definition at line 183 of file custom_jme_cff.py.

◆ btagDeepCvL

custom_jme_cff.btagDeepCvL

Definition at line 182 of file custom_jme_cff.py.

◆ btagDeepFlavB

custom_jme_cff.btagDeepFlavB

Definition at line 186 of file custom_jme_cff.py.

◆ btagDeepFlavC

custom_jme_cff.btagDeepFlavC

Definition at line 187 of file custom_jme_cff.py.

◆ btagDeepFlavCvB

custom_jme_cff.btagDeepFlavCvB

Definition at line 191 of file custom_jme_cff.py.

◆ btagDeepFlavCvL

custom_jme_cff.btagDeepFlavCvL

Definition at line 190 of file custom_jme_cff.py.

◆ btagDeepFlavG

custom_jme_cff.btagDeepFlavG

Definition at line 188 of file custom_jme_cff.py.

◆ btagDeepFlavQG

custom_jme_cff.btagDeepFlavQG

Definition at line 192 of file custom_jme_cff.py.

◆ btagDeepFlavUDS

custom_jme_cff.btagDeepFlavUDS

Definition at line 189 of file custom_jme_cff.py.

◆ bTagDeepJet

custom_jme_cff.bTagDeepJet

Definition at line 22 of file custom_jme_cff.py.

◆ bTagDiscriminatorsForAK4

custom_jme_cff.bTagDiscriminatorsForAK4

Definition at line 27 of file custom_jme_cff.py.

◆ btagHbb

custom_jme_cff.btagHbb

Definition at line 32 of file custom_jme_cff.py.

◆ BTAGVARS

custom_jme_cff.BTAGVARS

Definition at line 179 of file custom_jme_cff.py.

◆ CALOJETVARS

custom_jme_cff.CALOJETVARS

Definition at line 202 of file custom_jme_cff.py.

◆ chEmEF

custom_jme_cff.chEmEF

Definition at line 143 of file custom_jme_cff.py.

◆ chHEF

custom_jme_cff.chHEF

Definition at line 141 of file custom_jme_cff.py.

◆ config_genjets

custom_jme_cff.config_genjets

Definition at line 53 of file custom_jme_cff.py.

◆ config_recojets

custom_jme_cff.config_recojets

Definition at line 76 of file custom_jme_cff.py.

◆ DEEPJETVARS

custom_jme_cff.DEEPJETVARS

Definition at line 185 of file custom_jme_cff.py.

◆ doc

custom_jme_cff.doc

Definition at line 139 of file custom_jme_cff.py.

◆ emf

custom_jme_cff.emf

Definition at line 205 of file custom_jme_cff.py.

Referenced by CommonHcalNoiseRBXData.CommonHcalNoiseRBXData(), l1tpf::corrector.correctedPt(), JetIDSelectionFunctor.craft08Cuts(), JetIDSelectionFunctor.fwd09Cuts(), FWGUIManager.setFrom(), and FWGUISubviewArea.undock().

◆ float

custom_jme_cff.float

Definition at line 139 of file custom_jme_cff.py.

◆ GENJETVARS

custom_jme_cff.GENJETVARS

Definition at line 135 of file custom_jme_cff.py.

◆ hfEmEF

custom_jme_cff.hfEmEF

Definition at line 147 of file custom_jme_cff.py.

◆ hfHEF

custom_jme_cff.hfHEF

Definition at line 146 of file custom_jme_cff.py.

◆ int

custom_jme_cff.int

Definition at line 151 of file custom_jme_cff.py.

◆ muEF

custom_jme_cff.muEF

Definition at line 145 of file custom_jme_cff.py.

◆ nanoInfo_genjets

custom_jme_cff.nanoInfo_genjets

Definition at line 63 of file custom_jme_cff.py.

◆ nanoInfo_recojets

custom_jme_cff.nanoInfo_recojets

Definition at line 110 of file custom_jme_cff.py.

◆ nConstChHads

custom_jme_cff.nConstChHads

Definition at line 151 of file custom_jme_cff.py.

◆ nConstElecs

custom_jme_cff.nConstElecs

Definition at line 156 of file custom_jme_cff.py.

◆ nConstHFEMs

custom_jme_cff.nConstHFEMs

Definition at line 154 of file custom_jme_cff.py.

◆ nConstHFHads

custom_jme_cff.nConstHFHads

Definition at line 153 of file custom_jme_cff.py.

◆ nConstituents

custom_jme_cff.nConstituents

Definition at line 136 of file custom_jme_cff.py.

Referenced by JetToDigiDump.analyze(), myFastSimVal.analyze(), JetTester.analyze(), JetTester_HeavyIons.analyze(), JetAnalyzer_HeavyIons.analyze(), JetAnalyzer.analyze(), FFTGenericScaleCalculator.FFTGenericScaleCalculator(), and AcceptJet.operator()().

◆ nConstMuons

custom_jme_cff.nConstMuons

Definition at line 155 of file custom_jme_cff.py.

◆ nConstNeuHads

custom_jme_cff.nConstNeuHads

Definition at line 152 of file custom_jme_cff.py.

◆ nConstPhotons

custom_jme_cff.nConstPhotons

Definition at line 157 of file custom_jme_cff.py.

◆ neEmEF

custom_jme_cff.neEmEF

Definition at line 144 of file custom_jme_cff.py.

◆ neHEF

custom_jme_cff.neHEF

Definition at line 142 of file custom_jme_cff.py.

◆ nElectrons

custom_jme_cff.nElectrons

Definition at line 149 of file custom_jme_cff.py.

Referenced by TriggerSummaryAnalyzerRAW.analyze(), SusyDQM< Mu, Ele, Jet, Met >.analyze(), HLTEventAnalyzerRAW.analyzeTrigger(), L1TEGammaOffline.findTagAndProbePair(), reco::RecoTauPiZero.numberOfElectrons(), and WPlusJetsEventSelector.operator()().

◆ nMuons

custom_jme_cff.nMuons

Definition at line 148 of file custom_jme_cff.py.

Referenced by TriggerSummaryAnalyzerRAW.analyze(), SusyDQM< Mu, Ele, Jet, Met >.analyze(), HLTEventAnalyzerRAW.analyzeTrigger(), PFAlgo.createCandidatesHCAL(), HLTRFilter.hltFilter(), cms::MuonTCMETValueMapProducer.isGoodCaloMuon(), TrackMergeremb< T1 >.merg_and_put(), MuIsoDepositProducer.produce(), CandIsoDepositProducer.produce(), L3MuonIsolationProducer.produce(), L2MuonIsolationProducer.produce(), L3MuonCombinedRelativeIsolationProducer.produce(), MuonTimingProducer.produce(), cms::MuonTCMETValueMapProducer.produce(), MuonProducer.produce(), MuonIdProducer.produce(), and HIMuonTrackingRegionProducer.regions().

◆ particleNetAK4_B

custom_jme_cff.particleNetAK4_B

Definition at line 195 of file custom_jme_cff.py.

◆ particleNetAK4_CvsB

custom_jme_cff.particleNetAK4_CvsB

Definition at line 197 of file custom_jme_cff.py.

◆ particleNetAK4_CvsL

custom_jme_cff.particleNetAK4_CvsL

Definition at line 196 of file custom_jme_cff.py.

◆ particleNetAK4_puIdDisc

custom_jme_cff.particleNetAK4_puIdDisc

Definition at line 199 of file custom_jme_cff.py.

◆ particleNetAK4_QvsG

custom_jme_cff.particleNetAK4_QvsG

Definition at line 198 of file custom_jme_cff.py.

◆ PARTICLENETAK4VARS

custom_jme_cff.PARTICLENETAK4VARS

Definition at line 194 of file custom_jme_cff.py.

◆ PFJETVARS

custom_jme_cff.PFJETVARS

Definition at line 138 of file custom_jme_cff.py.

◆ precision

custom_jme_cff.precision

Definition at line 139 of file custom_jme_cff.py.

◆ puId_beta

custom_jme_cff.puId_beta

Definition at line 168 of file custom_jme_cff.py.

◆ puId_dR2Mean

custom_jme_cff.puId_dR2Mean

Definition at line 160 of file custom_jme_cff.py.

◆ puId_frac01

custom_jme_cff.puId_frac01

Definition at line 163 of file custom_jme_cff.py.

◆ puId_frac02

custom_jme_cff.puId_frac02

Definition at line 164 of file custom_jme_cff.py.

◆ puId_frac03

custom_jme_cff.puId_frac03

Definition at line 165 of file custom_jme_cff.py.

◆ puId_frac04

custom_jme_cff.puId_frac04

Definition at line 166 of file custom_jme_cff.py.

◆ puId_jetR

custom_jme_cff.puId_jetR

Definition at line 170 of file custom_jme_cff.py.

◆ puId_jetRchg

custom_jme_cff.puId_jetRchg

Definition at line 171 of file custom_jme_cff.py.

◆ puId_majW

custom_jme_cff.puId_majW

Definition at line 161 of file custom_jme_cff.py.

◆ puId_minW

custom_jme_cff.puId_minW

Definition at line 162 of file custom_jme_cff.py.

◆ puId_nCharged

custom_jme_cff.puId_nCharged

Definition at line 172 of file custom_jme_cff.py.

◆ puId_ptD

custom_jme_cff.puId_ptD

Definition at line 167 of file custom_jme_cff.py.

◆ puId_pull

custom_jme_cff.puId_pull

Definition at line 169 of file custom_jme_cff.py.

◆ PUIDVARS

custom_jme_cff.PUIDVARS

Definition at line 159 of file custom_jme_cff.py.

◆ qgl_axis2

custom_jme_cff.qgl_axis2

Definition at line 175 of file custom_jme_cff.py.

◆ qgl_mult

custom_jme_cff.qgl_mult

Definition at line 177 of file custom_jme_cff.py.

◆ qgl_ptD

custom_jme_cff.qgl_ptD

Definition at line 176 of file custom_jme_cff.py.

◆ QGLVARS

custom_jme_cff.QGLVARS

Definition at line 174 of file custom_jme_cff.py.

◆ rawFactor

custom_jme_cff.rawFactor

Definition at line 139 of file custom_jme_cff.py.

Functions

Variables

Function Documentation

◆ AddBTaggingScores()

◆ AddDeepJetGluonLQuarkScores()

◆ AddJetID()

◆ AddNewAK8CHSJets()

◆ AddNewAK8GenJetsForJEC()

◆ AddNewAK8PuppiJetsForJEC()

◆ AddNewGenJets()

◆ AddNewPatJets()

◆ AddParticleNetAK4Scores()

◆ AddPileUpJetIDVars()

◆ AddQGLTaggerVars()

◆ AddVariablesForAK4GenJets()

◆ AddVariablesForAK8GenJets()

◆ AddVariablesForAK8PuppiJets()

◆ PrepJMECustomNanoAOD()

◆ PrepJMECustomNanoAOD_Data()

◆ PrepJMECustomNanoAOD_MC()

◆ ReclusterAK4CHSJets()

◆ ReclusterAK4GenJets()

◆ RemoveAllJetPtCuts()

◆ SaveGenJets()

◆ SavePatJets()

Variable Documentation

◆ area

◆ bTagCSVV2

◆ btagCSVV2

◆ btagDDX

◆ btagDDXV2

◆ btagDeepB

◆ bTagDeepCSV

◆ btagDeepCvB

◆ btagDeepCvL

◆ btagDeepFlavB

◆ btagDeepFlavC

◆ btagDeepFlavCvB

◆ btagDeepFlavCvL

◆ btagDeepFlavG

◆ btagDeepFlavQG

◆ btagDeepFlavUDS

◆ bTagDeepJet

◆ bTagDiscriminatorsForAK4

◆ btagHbb

◆ BTAGVARS

◆ CALOJETVARS

◆ chEmEF

◆ chHEF

◆ config_genjets

◆ config_recojets

◆ DEEPJETVARS

◆ doc

◆ emf

◆ float

◆ GENJETVARS

◆ hfEmEF

◆ hfHEF

◆ int

◆ muEF

◆ nanoInfo_genjets

◆ nanoInfo_recojets

◆ nConstChHads

◆ nConstElecs

◆ nConstHFEMs

◆ nConstHFHads

◆ nConstituents

◆ nConstMuons

◆ nConstNeuHads

◆ nConstPhotons

◆ neEmEF

◆ neHEF

◆ nElectrons

◆ nMuons

◆ particleNetAK4_B

◆ particleNetAK4_CvsB

◆ particleNetAK4_CvsL

◆ particleNetAK4_puIdDisc

◆ particleNetAK4_QvsG

◆ PARTICLENETAK4VARS