Functions
def	AddBTaggingScores (proc, jetTableName="")

def	AddDeepJetGluonLQuarkScores (proc, jetTableName="")

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

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="", jetTaskName="")

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

def	AddRobustParTAK4Scores (proc, jetTableName="")

def	AddUnifiedParTAK4Scores (proc, jetTableName="")

def	AddVariablesForAK4GenJets (proc)

def	AddVariablesForAK8GenJets (proc)

def	AddVariablesForAK8PuppiJets (proc)

def	ModifyAK4JetMCTable (proc)

def	PrepJMECustomNanoAOD (process)

def	ReclusterAK4CHSJets (proc, recoJA, runOnMC)

def	ReclusterAK4GenJets (proc, genJA)

def	ReclusterAK4PuppiJets (proc, recoJA, runOnMC)

def	RecomputePuppiMET (proc)

def	RecomputePuppiWeights (proc)

def	RecomputePuppiWeightsAndMET (proc)

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

	btagDDX

	btagDDXV2

	btagDeepB

	bTagDeepCSV

	btagDeepCvB

	btagDeepCvL

	btagDeepFlavB

	btagDeepFlavC

	btagDeepFlavCvB

	btagDeepFlavCvL

	btagDeepFlavG

	btagDeepFlavQG

	btagDeepFlavUDS

	bTagDeepJet

	bTagDiscriminatorsForAK4

	btagHbb

	btagRobustParTAK4B

	btagRobustParTAK4C

	btagRobustParTAK4CvB

	btagRobustParTAK4CvL

	btagRobustParTAK4G

	btagRobustParTAK4QG

	btagRobustParTAK4UDS

	btagUParTAK4B

	btagUParTAK4CvB

	btagUParTAK4CvL

	btagUParTAK4QvG

	btagUParTAK4TauVJet

	BTAGVARS

	CALOJETVARS

	chEmEF

	chHadMultiplicity

	chHEF

	config_genjets

	config_recojets

	DEEPJETVARS

	doc

	elMultiplicity

	emf

	float

	foo

	genJetIdx

	GENJETVARS

	hadronFlavour

	hfEmEF

	hfEMMultiplicity

	hfHadMultiplicity

	hfHEF

	muEF

	muMultiplicity

	nanoInfo_genjets

	nanoInfo_recojets

	nConstituents

	neEmEF

	neHadMultiplicity

	neHEF

	nElectrons

	nMuons

	particleNetAK4_B

	particleNetAK4_CvsB

	particleNetAK4_CvsL

	particleNetAK4_G

	particleNetAK4_puIdDisc

	particleNetAK4_QvsG

	PARTICLENETAK4VARS

	partonFlavour

	PFJETVARS

	phoMultiplicity

	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

	ROBUSTPARTAK4VARS

	UNIFIEDPARTAK4VARS

	UParTAK4RegPtRawCorr

	UParTAK4RegPtRawCorrNeutrino

	UParTAK4RegPtRawRes

Function Documentation

◆ AddBTaggingScores()

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

Store b-tagging scores from various algortihm

Definition at line 408 of file custom_jme_cff.py.

References common_cff.Var().

Referenced by SavePatJets().

 def AddBTaggingScores(proc, jetTableName=""):
   """
   Store b-tagging scores from various algortihm
   """
 
   getattr(proc, jetTableName).variables.btagDeepFlavB   = DEEPJETVARS.btagDeepFlavB
   getattr(proc, jetTableName).variables.btagDeepFlavCvL = DEEPJETVARS.btagDeepFlavCvL
   getattr(proc, jetTableName).variables.btagDeepFlavCvB = DEEPJETVARS.btagDeepFlavCvB
 
   run2_nanoAOD_ANY.toModify(
     getattr(proc, jetTableName).variables,
     btagCSVV2 = Var("bDiscriminator('pfCombinedInclusiveSecondaryVertexV2BJetTags')",float,doc=" pfCombinedInclusiveSecondaryVertexV2 b-tag discriminator (aka CSVV2)",precision=10),
     btagDeepB = Var("?(bDiscriminator('pfDeepCSVJetTags:probb')+bDiscriminator('pfDeepCSVJetTags:probbb'))>=0?bDiscriminator('pfDeepCSVJetTags:probb')+bDiscriminator('pfDeepCSVJetTags:probbb'):-1",float,doc="DeepCSV b+bb tag discriminator",precision=10),
     btagDeepCvL = Var("?bDiscriminator('pfDeepCSVJetTags:probc')>=0?bDiscriminator('pfDeepCSVJetTags:probc')/(bDiscriminator('pfDeepCSVJetTags:probc')+bDiscriminator('pfDeepCSVJetTags:probudsg')):-1", float,doc="DeepCSV c vs udsg discriminator",precision=10),
     btagDeepCvB = Var("?bDiscriminator('pfDeepCSVJetTags:probc')>=0?bDiscriminator('pfDeepCSVJetTags:probc')/(bDiscriminator('pfDeepCSVJetTags:probc')+bDiscriminator('pfDeepCSVJetTags:probb')+bDiscriminator('pfDeepCSVJetTags:probbb')):-1",float,doc="DeepCSV c vs b+bb discriminator",precision=10)
   )
 
   return proc
 

◆ AddDeepJetGluonLQuarkScores()

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

Store DeepJet raw score in jetTable for gluon and light quark

Definition at line 427 of file custom_jme_cff.py.

Referenced by SavePatJets().

 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
 

◆ AddJetID()

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

Setup modules to calculate PF jet ID

Definition at line 234 of file custom_jme_cff.py.

References PVValHelper.add(), and common_cff.Var().

Referenced by SavePatJets().

 def AddJetID(proc, jetName="", jetSrc="", jetTableName="", jetTaskName=""):
   """
   Setup modules to calculate PF jet ID
   """
 
   isPUPPIJet = True if "PUPPI" in jetName.upper() 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 = "RUN3WINTER22{}".format("PUPPI" if isPUPPIJet else "CHS")
       ),
     )
   )
 
   tightJetIdLepVeto = "tightJetIdLepVeto{}".format(jetName)
   setattr(proc, tightJetIdLepVeto, proc.tightJetIdLepVeto.clone(
       src = jetSrc,
       filterParams = proc.tightJetIdLepVeto.filterParams.clone(
         version = "RUN3WINTER22{}".format("PUPPI" if isPUPPIJet else "CHS")
       ),
     )
   )
 
   run3_jme_Winter22runsBCDEprompt.toModify(
     getattr(proc, tightJetId).filterParams, version = "RUN3WINTER22{}runsBCDEprompt".format("PUPPI" if isPUPPIJet else "CHS")
   ).toModify(
     getattr(proc, tightJetIdLepVeto).filterParams, version = "RUN3WINTER22{}runsBCDEprompt".format("PUPPI" if isPUPPIJet else "CHS")
   )
 
   (run2_jme_2017 | run2_jme_2018 | run3_nanoAOD_122 | run3_nanoAOD_124).toModify(
     getattr(proc, tightJetId).filterParams, version = "RUN2UL{}".format("PUPPI" if isPUPPIJet else "CHS")
   ).toModify(
     getattr(proc, tightJetIdLepVeto).filterParams, version = "RUN2UL{}".format("PUPPI" if isPUPPIJet else "CHS")
   )
 
   run2_jme_2016.toModify(
     getattr(proc, tightJetId).filterParams, version = "RUN2UL16{}".format("PUPPI" if isPUPPIJet else "CHS")
   ).toModify(
     getattr(proc, tightJetIdLepVeto).filterParams, version = "RUN2UL16{}".format("PUPPI" if isPUPPIJet else "CHS")
   )
 
   #
   # 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)
 
   #
   # 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")
 
   getattr(proc,jetTaskName).add(getattr(proc, tightJetId))
   getattr(proc,jetTaskName).add(getattr(proc, tightJetIdLepVeto))
 
   return proc
 

◆ AddNewAK8CHSJets()

def custom_jme_cff.AddNewAK8CHSJets	(	proc,
		recoJA,
		runOnMC
	)

Store an AK8 CHS jet collection for JEC studies.

Definition at line 1037 of file custom_jme_cff.py.

References print(), and SavePatJets().

 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           = 15
 
   SavePatJets(proc,
     jetName, payload, patJetFinalColl, jetTablePrefix, jetTableDoc, doPF=True,
     doCalo=False, ptcut=ptcut, doPUIDVar=False, doQGL=False, doBTag=False, runOnMC=runOnMC
   )
 
   return proc
 

◆ AddNewAK8GenJetsForJEC()

def custom_jme_cff.AddNewAK8GenJetsForJEC	(	proc,
		genJA
	)

Make a separate AK8 Gen jet collection for JEC studies.

Definition at line 1204 of file custom_jme_cff.py.

References print(), and SaveGenJets().

Referenced by PrepJMECustomNanoAOD().

 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",
     "minPtFastjet" : 10.
   }
   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 > 10 GeV. Reclustered for JEC studies."
 
   SaveGenJets(proc, genJetName, genJetAlgo, genJetSizeNr, genJetFinalColl, genJetTablePrefix, genJetTableDoc, runOnMC=False)
 
   return proc
 

◆ 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 1004 of file custom_jme_cff.py.

References print(), and SavePatJets().

Referenced by PrepJMECustomNanoAOD().

 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           = 15
 
   SavePatJets(proc,
     jetName, payload, patJetFinalColl, jetTablePrefix, jetTableDoc, doPF=True,
     doCalo=False, ptcut=ptcut, doPUIDVar=False, doQGL=False, doBTag=False, runOnMC=runOnMC
   )
 
   return proc
 

◆ AddNewGenJets()

def custom_jme_cff.AddNewGenJets	(	proc,
		genJetInfo
	)

Add genJet into custom nanoAOD

Definition at line 1103 of file custom_jme_cff.py.

References SaveGenJets().

Referenced by PrepJMECustomNanoAOD().

 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
 

◆ AddNewPatJets()

def custom_jme_cff.AddNewPatJets	(	proc,
		recoJetInfo,
		runOnMC
	)

Add patJet into custom nanoAOD

Definition at line 478 of file custom_jme_cff.py.

References SavePatJets().

Referenced by PrepJMECustomNanoAOD().

 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 8
   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
 

◆ AddParticleNetAK4Scores()

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

Store ParticleNetAK4 scores in jetTable

Definition at line 464 of file custom_jme_cff.py.

Referenced by SavePatJets().

 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_G = PARTICLENETAK4VARS.particleNetAK4_G
   getattr(proc, jetTableName).variables.particleNetAK4_puIdDisc = PARTICLENETAK4VARS.particleNetAK4_puIdDisc
 
   return proc
 

◆ AddPileUpJetIDVars()

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

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

Definition at line 303 of file custom_jme_cff.py.

References PVValHelper.add().

Referenced by ReclusterAK4PuppiJets(), and SavePatJets().

 def AddPileUpJetIDVars(proc, jetName="", jetSrc="", jetTableName="", jetTaskName=""):
   """
   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,
       srcConstituentWeights = "packedpuppi" if "PUPPI" in jetName.upper() else ""
     )
   )
   getattr(proc,jetTaskName).add(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,jetTaskName).add(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
 

◆ AddQGLTaggerVars()

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

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

Definition at line 370 of file custom_jme_cff.py.

References PVValHelper.add().

Referenced by ReclusterAK4PuppiJets(), and SavePatJets().

 def AddQGLTaggerVars(proc, jetName="", jetSrc="", jetTableName="", jetTaskName="", calculateQGLVars=False):
   """
   Schedule the QGTagger module to calculate input variables to the QG likelihood
   """
 
   isPUPPIJet = True if "PUPPI" in jetName.upper() else False
 
   QGLTagger="qgtagger{}".format(jetName)
   patJetWithUserData="{}WithUserData".format(jetSrc)
 
   if calculateQGLVars:
     setattr(proc, QGLTagger, qgtagger.clone(
         srcJets = jetSrc,
         computeLikelihood = False,
       )
     )
     if isPUPPIJet:
       getattr(proc,QGLTagger).srcConstituentWeights = cms.InputTag("packedpuppi")
 
   #
   # 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,jetTaskName).add(getattr(proc, QGLTagger))
 
   return proc
 

◆ AddRobustParTAK4Scores()

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

Store RobustParTAK4 scores in jetTable

Definition at line 438 of file custom_jme_cff.py.

Referenced by SavePatJets().

 def AddRobustParTAK4Scores(proc, jetTableName=""):
   """
   Store RobustParTAK4 scores in jetTable
   """
 
   getattr(proc, jetTableName).variables.btagRobustParTAK4B = ROBUSTPARTAK4VARS.btagRobustParTAK4B
   getattr(proc, jetTableName).variables.btagRobustParTAK4CvL = ROBUSTPARTAK4VARS.btagRobustParTAK4CvL
   getattr(proc, jetTableName).variables.btagRobustParTAK4CvB = ROBUSTPARTAK4VARS.btagRobustParTAK4CvB
 
   return proc
 

◆ AddUnifiedParTAK4Scores()

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

Store RobustParTAK4 scores in jetTable

Definition at line 449 of file custom_jme_cff.py.

Referenced by SavePatJets().

 def AddUnifiedParTAK4Scores(proc, jetTableName=""):
   """
   Store RobustParTAK4 scores in jetTable
   """
 
   getattr(proc, jetTableName).variables.btagUParTAK4B = UNIFIEDPARTAK4VARS.btagUParTAK4B
   getattr(proc, jetTableName).variables.btagUParTAK4CvL = UNIFIEDPARTAK4VARS.btagUParTAK4CvL
   getattr(proc, jetTableName).variables.btagUParTAK4CvB = UNIFIEDPARTAK4VARS.btagUParTAK4CvB
   getattr(proc, jetTableName).variables.btagUParTAK4TauVJet = UNIFIEDPARTAK4VARS.btagUParTAK4TauVJet
   getattr(proc, jetTableName).variables.UParTAK4RegPtRawCorr = UNIFIEDPARTAK4VARS.UParTAK4RegPtRawCorr
   getattr(proc, jetTableName).variables.UParTAK4RegPtRawCorrNeutrino = UNIFIEDPARTAK4VARS.UParTAK4RegPtRawCorrNeutrino
   getattr(proc, jetTableName).variables.UParTAK4RegPtRawRes = UNIFIEDPARTAK4VARS.UParTAK4RegPtRawRes
 
   return proc
 

◆ AddVariablesForAK4GenJets()

def custom_jme_cff.AddVariablesForAK4GenJets ( proc )

Definition at line 1231 of file custom_jme_cff.py.

Referenced by PrepJMECustomNanoAOD().

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

◆ AddVariablesForAK8GenJets()

def custom_jme_cff.AddVariablesForAK8GenJets ( proc )

Definition at line 1235 of file custom_jme_cff.py.

Referenced by PrepJMECustomNanoAOD().

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

◆ AddVariablesForAK8PuppiJets()

def custom_jme_cff.AddVariablesForAK8PuppiJets ( proc )

Add more variables for AK8 PFPUPPI jets

Definition at line 1069 of file custom_jme_cff.py.

References common_cff.Var().

Referenced by PrepJMECustomNanoAOD().

 def AddVariablesForAK8PuppiJets(proc):
   """
   Add more variables for AK8 PFPUPPI jets
   """
 
   proc.fatJetTable.variables.rawFactor.precision = 10
 
   #
   #  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.chHadMultiplicity = Var("?isPFJet()?chargedHadronMultiplicity():-1","int16", doc="(Puppi-weighted) number of charged hadrons in the jet")
   proc.fatJetTable.variables.neHadMultiplicity = Var("?isPFJet()?neutralHadronMultiplicity():-1","int16", doc="(Puppi-weighted) number of neutral hadrons in the jet")
   proc.fatJetTable.variables.hfHadMultiplicity = Var("?isPFJet()?HFHadronMultiplicity():-1", "int16", doc="(Puppi-weighted) number of HF Hadrons in the jet")
   proc.fatJetTable.variables.hfEMMultiplicity  = Var("?isPFJet()?HFEMMultiplicity():-1", "int16", doc="(Puppi-weighted) number of HF EMs in the jet")
   proc.fatJetTable.variables.muMultiplicity    = Var("?isPFJet()?muonMultiplicity():-1", "int16", doc="(Puppi-weighted) number of muons in the jet")
   proc.fatJetTable.variables.elMultiplicity    = Var("?isPFJet()?electronMultiplicity():-1", "int16", doc="(Puppi-weighted) number of electrons in the jet")
   proc.fatJetTable.variables.phoMultiplicity   = Var("?isPFJet()?photonMultiplicity():-1", "int16", doc="(Puppi-weighted) number of photons in the jet")
 
   return proc
 #******************************************
 #
 #
 # Gen Jets related functions
 #
 #
 #******************************************

◆ ModifyAK4JetMCTable()

def custom_jme_cff.ModifyAK4JetMCTable ( proc )

Definition at line 1239 of file custom_jme_cff.py.

Referenced by PrepJMECustomNanoAOD().

 def ModifyAK4JetMCTable(proc):
   # Remove the genjet pt selection when saving the genJetIdx, which is
   # the default in main Nano
   proc.jetMCTable.variables.genJetIdx = PFJETVARS.genJetIdx
   return proc
 
 #===========================================================================
 #
 # Misc. functions
 #
 #===========================================================================

◆ PrepJMECustomNanoAOD()

def custom_jme_cff.PrepJMECustomNanoAOD ( process )

Definition at line 1304 of file custom_jme_cff.py.

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

 def PrepJMECustomNanoAOD(process):
   
   runOnMC=True
   if hasattr(process,"NANOEDMAODoutput") or hasattr(process,"NANOAODoutput"):
     runOnMC = False
   
   process = RemoveAllJetPtCuts(process)
 
   
   genJA = GenJetAdder()
   if runOnMC:
     
     process = AddVariablesForAK8GenJets(process)
     
     process = AddNewAK8GenJetsForJEC(process, genJA)
     
     process = ModifyAK4JetMCTable(process)
     
     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 = ReclusterAK4CHSJets(process, recoJA, runOnMC)
   
   process = ReclusterAK4PuppiJets(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)
 
   
   def addAK4JetTasks(proc, addAK4CHSJetTasks, addAK4PuppiJetTasks):
     if addAK4CHSJetTasks:
       proc.nanoTableTaskCommon.add(proc.jetTask)
       proc.nanoTableTaskCommon.add(proc.jetTablesTask)
       proc.nanoTableTaskCommon.add(proc.jetForMETTask)
     if addAK4PuppiJetTasks:
       proc.nanoTableTaskCommon.add(proc.jetPuppiTask)
       proc.nanoTableTaskCommon.add(proc.jetPuppiTablesTask)
       proc.nanoTableTaskCommon.add(proc.jetPuppiForMETTask)
     return proc
 
   jmeNano_addAK4JetTasks_switch = cms.PSet(
     jmeNano_addAK4CHS_switch = cms.untracked.bool(True),
     jmeNano_addAK4Puppi_switch = cms.untracked.bool(False)
   )
   run2_nanoAOD_ANY.toModify(jmeNano_addAK4JetTasks_switch,
     jmeNano_addAK4CHS_switch = False,
     jmeNano_addAK4Puppi_switch = True
   )
   process = addAK4JetTasks(process,
     addAK4CHSJetTasks = jmeNano_addAK4JetTasks_switch.jmeNano_addAK4CHS_switch,
     addAK4PuppiJetTasks = jmeNano_addAK4JetTasks_switch.jmeNano_addAK4Puppi_switch,
   )
 
   
   if runOnMC:
     process.puTable.savePtHatMax = True
 
   
   if runOnMC:
     process.genWeightsTable.keepAllPSWeights = True
 
   return process
 

◆ 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 (for Run-2).

Definition at line 815 of file custom_jme_cff.py.

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

Referenced by PrepJMECustomNanoAOD().

 def ReclusterAK4CHSJets(proc, recoJA, runOnMC):
   """
   Recluster AK4 CHS jets and replace slimmedJets that is used as default to
   save AK4 CHS jets in NanoAODs (for Run-2).
   """
   print("custom_jme_cff::ReclusterAK4CHSJets: Recluster AK4 PF CHS jets")
 
   from RecoBTag.ONNXRuntime.pfParticleNetFromMiniAODAK4_cff import _pfParticleNetFromMiniAODAK4CHSCentralJetTagsAll
   from RecoBTag.ONNXRuntime.pfParticleNetFromMiniAODAK4_cff import _pfParticleNetFromMiniAODAK4CHSForwardJetTagsAll
 
   bTagDiscriminatorsForAK4CHS = cms.PSet(
     foo = cms.vstring(_pfParticleNetFromMiniAODAK4CHSCentralJetTagsAll+_pfParticleNetFromMiniAODAK4CHSForwardJetTagsAll)
   )
   bTagDiscriminatorsForAK4CHS = bTagDiscriminatorsForAK4CHS.foo.value()
 
   #
   # Recluster AK4 CHS jets
   #
   cfg = {
     "jet" : "ak4pfchs",
     "inputCollection" : "",
     "genJetsCollection": "AK4GenJetsNoNu",
     "bTagDiscriminators": bTagDiscriminatorsForAK4CHS,
     "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 >= 10) || ((pt < 10) && (genJetFwdRef().backRef().isNonnull()))"
   else:
     finalJetsCut = "(pt >= 10)"
 
   proc.finalJets.cut = finalJetsCut
   #
   # Add a minimum pt cut for corrT1METJets.
   #
   proc.corrT1METJetTable.cut = "pt>=10 && 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.src   = cms.InputTag("finalJets")
   proc.jetTable.cut   = jetTableCut
   proc.jetMCTable.cut = jetTableCut
   proc.jetTable.name  = "JetCHS"
 
   #
   # For Run-2 eras, the main AK4 jet collection in NanoAOD is the CHS collection
   #
   run2_nanoAOD_ANY.toModify(
     proc.jetTable,
     src = cms.InputTag("linkedObjects","jets"),
     name = "Jet"
   )
 
   #
   # Jet table documentation
   #
   jetTableDoc = "AK4 PF CHS jets with JECs applied. Jets with pt >= 10 GeV are stored."
   if runOnMC:
     jetTableDoc += "For jets with pt < 10 GeV, only those matched to AK4 Gen jets are stored."
   proc.jetTable.doc   = jetTableDoc
 
   proc.jetTable.variables.rawFactor.precision = 10
 
   #
   # Add variables
   #
   proc.jetTable.variables.chHadMultiplicity = PFJETVARS.chHadMultiplicity
   proc.jetTable.variables.neHadMultiplicity = PFJETVARS.neHadMultiplicity
   proc.jetTable.variables.hfHadMultiplicity = PFJETVARS.hfHadMultiplicity
   proc.jetTable.variables.hfEMMultiplicity  = PFJETVARS.hfEMMultiplicity
   proc.jetTable.variables.muMultiplicity    = PFJETVARS.muMultiplicity
   proc.jetTable.variables.elMultiplicity    = PFJETVARS.elMultiplicity
   proc.jetTable.variables.phoMultiplicity   = PFJETVARS.phoMultiplicity
 
   #
   # 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)
 
   #
   # Remove these tagger branches since for CHS, we just want to store
   # one tagger only.
   #
   for varNames in proc.jetTable.variables.parameterNames_():
     if "btagDeepFlav" in varNames or "btagRobustParT" in varNames or "btagUParT" in varNames:
       delattr(proc.jetTable.variables, varNames)
 
   proc.jetTable.variables.btagPNetB = Var("?pt>15 && bDiscriminator('pfParticleNetFromMiniAODAK4CHSCentralDiscriminatorsJetTags:BvsAll')>0?bDiscriminator('pfParticleNetFromMiniAODAK4CHSCentralDiscriminatorsJetTags:BvsAll'):-1",float,precision=10,doc="ParticleNet b vs. udscg")
   proc.jetTable.variables.btagPNetCvL = Var("?pt>15 && bDiscriminator('pfParticleNetFromMiniAODAK4CHSCentralDiscriminatorsJetTags:CvsL')>0?bDiscriminator('pfParticleNetFromMiniAODAK4CHSCentralDiscriminatorsJetTags:CvsL'):-1",float,precision=10,doc="ParticleNet c vs. udsg")
   proc.jetTable.variables.btagPNetCvB = Var("?pt>15 && bDiscriminator('pfParticleNetFromMiniAODAK4CHSCentralDiscriminatorsJetTags:CvsB')>0?bDiscriminator('pfParticleNetFromMiniAODAK4CHSCentralDiscriminatorsJetTags:CvsB'):-1",float,precision=10,doc="ParticleNet c vs. b")
   proc.jetTable.variables.btagPNetQvG = Var("?pt>15 && abs(eta())<2.5?bDiscriminator('pfParticleNetFromMiniAODAK4CHSCentralDiscriminatorsJetTags:QvsG'):bDiscriminator('pfParticleNetFromMiniAODAK4CHSForwardDiscriminatorsJetTags:QvsG')",float,precision=10,doc="ParticleNet q (udsbc) vs. g")
   proc.jetTable.variables.btagPNetTauVJet = Var("?pt>15 && bDiscriminator('pfParticleNetFromMiniAODAK4CHSCentralDiscriminatorsJetTags:TauVsJet')>0?bDiscriminator('pfParticleNetFromMiniAODAK4CHSCentralDiscriminatorsJetTags:TauVsJet'):-1",float,precision=10,doc="ParticleNet tau vs. jet")
   proc.jetTable.variables.PNetRegPtRawCorr = Var("?pt>15 && abs(eta())<2.5?bDiscriminator('pfParticleNetFromMiniAODAK4CHSCentralJetTags:ptcorr'):bDiscriminator('pfParticleNetFromMiniAODAK4CHSForwardJetTags:ptcorr')",float,precision=10,doc="ParticleNet universal flavor-aware visible pT regression (no neutrinos), correction relative to raw jet pT")
   proc.jetTable.variables.PNetRegPtRawCorrNeutrino = Var("?pt>15 && abs(eta())<2.5?bDiscriminator('pfParticleNetFromMiniAODAK4CHSCentralJetTags:ptnu'):bDiscriminator('pfParticleNetFromMiniAODAK4CHSForwardJetTags:ptnu')",float,precision=10,doc="ParticleNet universal flavor-aware pT regression neutrino correction, relative to visible. To apply full regression, multiply raw jet pT by both PNetRegPtRawCorr and PNetRegPtRawCorrNeutrino.")
   proc.jetTable.variables.PNetRegPtRawRes = Var("?pt>15 && abs(eta())<2.5?0.5*(bDiscriminator('pfParticleNetFromMiniAODAK4CHSCentralJetTags:ptreshigh')-bDiscriminator('pfParticleNetFromMiniAODAK4CHSCentralJetTags:ptreslow')):0.5*(bDiscriminator('pfParticleNetFromMiniAODAK4CHSForwardJetTags:ptreshigh')-bDiscriminator('pfParticleNetFromMiniAODAK4CHSForwardJetTags:ptreslow'))",float,precision=10,doc="ParticleNet universal flavor-aware jet pT resolution estimator, (q84 - q16)/2")
 
 
   #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, hfJetShowerShape.clone(jets="updatedJets", vertices="offlineSlimmedPrimaryVertices") )
   proc.jetUserDataTask.add(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) ")
 
   #
   # Since AK4 Puppi jet is the main AK4 jet collection for Run-3, disable
   # b-jets/c-jets NN-based mass regression for AK4 CHS.
   #
   (~run2_nanoAOD_ANY).toReplaceWith(
     proc.jetUserDataTask,
     proc.jetUserDataTask.copyAndExclude([proc.bJetVars])
   ).toReplaceWith(
     proc.jetTablesTask,
     proc.jetTablesTask.copyAndExclude([proc.bjetNN, proc.cjetNN])
   ).toModify(proc.updatedJetsWithUserData.userFloats,
     leadTrackPt = None,
     leptonPtRelv0 = None,
     leptonPtRelInvv0 = None,
     leptonDeltaR = None,
     vtxPt = None,
     vtxMass = None,
     vtx3dL = None,
     vtx3deL = None,
     ptD = None,
   ).toModify(
     proc.updatedJetsWithUserData.userInts,
     vtxNtrk = None,
     leptonPdgId = None
   ).toModify(
     proc.jetTable, externalVariables = cms.PSet()
   ).toReplaceWith(
   #
   # For Run-3, don't need to save the low pt AK4 CHS jet table for MET
   #
     proc.jetForMETTask,
     proc.jetForMETTask.copyAndExclude([proc.corrT1METJetTable])
   )
 
   #
   # Save MC-only jet variables in jet table
   #
   if runOnMC:
     jetMCTableName = "jet{}MCTable".format(jetName)
     setattr(proc, jetMCTableName, proc.jetMCTable.clone(
         src = proc.jetTable.src,
         name = proc.jetTable.name
       )
     )
     getattr(proc,jetMCTableName).variables.genJetIdx = PFJETVARS.genJetIdx
 
     jetMCTableTaskName = "jet{}MCTablesTask".format(jetName)
     setattr(proc, jetMCTableTaskName, cms.Task(getattr(proc,jetMCTableName)))
 
     (~run2_nanoAOD_ANY).toReplaceWith(
       proc.nanoTableTaskFS,
       proc.nanoTableTaskFS.copyAndAdd(getattr(proc,jetMCTableTaskName))
     )
 
   return proc
 

◆ 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 1163 of file custom_jme_cff.py.

References print().

Referenced by PrepJMECustomNanoAOD().

 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",
     "minPtFastjet" : 5.
   }
   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 > 5 GeV"
 
   genJetFlavourAssociationName = "genJet{}FlavourAssociation".format(genJetName)
   setattr(proc, genJetFlavourAssociationName, genJetFlavourAssociation.clone(
       jets           = proc.genJetTable.src,
       jetAlgorithm   = supportedJetAlgos[genJetAlgo],
       rParam         = genJetSizeNr,
     )
   )
   proc.jetMCTask.add(getattr(proc, genJetFlavourAssociationName))
   return proc
 

◆ ReclusterAK4PuppiJets()

def custom_jme_cff.ReclusterAK4PuppiJets	(	proc,
		recoJA,
		runOnMC
	)

Recluster AK4 Puppi jets and replace slimmedJetsPuppi
that is used as default to save AK4 Puppi jets in NanoAODs.

Definition at line 649 of file custom_jme_cff.py.

References AddPileUpJetIDVars(), AddQGLTaggerVars(), and print().

Referenced by PrepJMECustomNanoAOD().

 def ReclusterAK4PuppiJets(proc, recoJA, runOnMC):
   """
   Recluster AK4 Puppi jets and replace slimmedJetsPuppi
   that is used as default to save AK4 Puppi jets in NanoAODs.
   """
   print("custom_jme_cff::ReclusterAK4PuppiJets: Recluster AK4 PF Puppi jets")
 
   #
   # Recluster AK4 Puppi jets
   #
   cfg = {
     "jet" : "ak4pfpuppi",
     "inputCollection" : "",
     "genJetsCollection": "AK4GenJetsNoNu",
     "bTagDiscriminators": bTagDiscriminatorsForAK4,
     "minPtFastjet" : 0.,
   }
   recoJetInfo = recoJA.addRecoJetCollection(proc, **cfg)
 
   jetName = recoJetInfo.jetUpper
   patJetFinalColl = recoJetInfo.patJetFinalCollection
 
   #
   # Set the jetID for UL 16 era
   #
   run2_jme_2016.toModify(
     proc.tightJetPuppiId.filterParams, version = "RUN2UL16PUPPI"
   ).toModify(
     proc.tightJetIdLepVeto.filterParams, version = "RUN2UL16PUPPI"
   )
 
   #
   # Change the input jet source for jetCorrFactorsNano
   # and updatedJets
   #
   proc.jetPuppiCorrFactorsNano.src=patJetFinalColl
   proc.updatedJetsPuppi.jetSource=patJetFinalColl
 
   #
   # Change pt cut
   #
   finalJetsPuppiCut = ""
   if runOnMC:
     finalJetsPuppiCut = "(pt >= 8) || ((pt < 8) && (genJetFwdRef().backRef().isNonnull()))"
   else:
     finalJetsPuppiCut = "(pt >= 8)"
 
   proc.finalJetsPuppi.cut = finalJetsPuppiCut
   #
   # Add a minimum pt cut for corrT1METJets.
   #
   proc.corrT1METJetPuppiTable.cut = "pt>=8 && pt<15 && abs(eta)<9.9"
 
   #
   # Jet table
   #
   # For Run-2 eras, the main AK4 jet collection in NanoAOD is the CHS collection
   run2_nanoAOD_ANY.toModify(
     proc.jetTable, name = "Jet"
   ).toModify(
     # So need to change the table name for AK4 puppi here
     proc.jetPuppiTable,
     name = "JetPuppi",
     src = cms.InputTag("finalJetsPuppi")
   )
 
   #
   # Jet table documentation
   #
   jetPuppiTableDoc = "AK4 PF Puppi jets with JECs applied. Jets with pt >= 8 GeV are stored."
   if runOnMC:
     jetPuppiTableDoc += "For jets with pt < 8 GeV, only those matched to AK4 Gen jets are stored."
   proc.jetPuppiTable.doc = jetPuppiTableDoc
 
   proc.jetPuppiTable.variables.rawFactor.precision = 10
 
   #
   # Add variables
   #
   proc.jetPuppiTable.variables.chHadMultiplicity = PFJETVARS.chHadMultiplicity
   proc.jetPuppiTable.variables.neHadMultiplicity = PFJETVARS.neHadMultiplicity
   proc.jetPuppiTable.variables.hfHadMultiplicity = PFJETVARS.hfHadMultiplicity
   proc.jetPuppiTable.variables.hfEMMultiplicity  = PFJETVARS.hfEMMultiplicity
   proc.jetPuppiTable.variables.muMultiplicity    = PFJETVARS.muMultiplicity
   proc.jetPuppiTable.variables.elMultiplicity    = PFJETVARS.elMultiplicity
   proc.jetPuppiTable.variables.phoMultiplicity   = PFJETVARS.phoMultiplicity
 
   #
   # Add variables for pileup jet ID studies.
   #
 
   proc = AddPileUpJetIDVars(proc,
     jetName = jetName,
     jetSrc = "updatedJetsPuppi",
     jetTableName = "jetPuppiTable",
     jetTaskName = "jetPuppiTask"
   )
   #
   # Add variables for quark guon likelihood tagger studies.
   # Save variables as userFloats and userInts in each jet
   #
   proc = AddQGLTaggerVars(proc,
                           jetName = jetName,
                           jetSrc = "updatedJetsPuppi",
                           jetTableName = "jetPuppiTable",
                           jetTaskName = "jetPuppiTask",
                           calculateQGLVars=True
                         )
   #
   # Save DeepJet b-tagging and c-tagging variables
   #
   proc.jetPuppiTable.variables.btagDeepFlavB   = DEEPJETVARS.btagDeepFlavB
   proc.jetPuppiTable.variables.btagDeepFlavCvL = DEEPJETVARS.btagDeepFlavCvL
   proc.jetPuppiTable.variables.btagDeepFlavCvB = DEEPJETVARS.btagDeepFlavCvB
   #
   # Save DeepJet raw score for gluon and light quarks
   #
   proc.jetPuppiTable.variables.btagDeepFlavG   = DEEPJETVARS.btagDeepFlavG
   proc.jetPuppiTable.variables.btagDeepFlavUDS = DEEPJETVARS.btagDeepFlavUDS
   proc.jetPuppiTable.variables.btagDeepFlavQG  = DEEPJETVARS.btagDeepFlavQG
   #
   # Save RobustParTAK4 b-tagging and c-tagging variables
   #
   proc.jetPuppiTable.variables.btagRobustParTAK4B   = ROBUSTPARTAK4VARS.btagRobustParTAK4B
   proc.jetPuppiTable.variables.btagRobustParTAK4CvL = ROBUSTPARTAK4VARS.btagRobustParTAK4CvL
   proc.jetPuppiTable.variables.btagRobustParTAK4CvB = ROBUSTPARTAK4VARS.btagRobustParTAK4CvB
   #
   # Save UnifiedParTAK4 b-tagging and c-tagging variables
   #
   proc.jetPuppiTable.variables.btagUParTAK4B = UNIFIEDPARTAK4VARS.btagUParTAK4B
   proc.jetPuppiTable.variables.btagUParTAK4CvL = UNIFIEDPARTAK4VARS.btagUParTAK4CvL
   proc.jetPuppiTable.variables.btagUParTAK4CvB = UNIFIEDPARTAK4VARS.btagUParTAK4CvB
   proc.jetPuppiTable.variables.btagUParTAK4TauVJet = UNIFIEDPARTAK4VARS.btagUParTAK4TauVJet
   proc.jetPuppiTable.variables.UParTAK4RegPtRawCorr = UNIFIEDPARTAK4VARS.UParTAK4RegPtRawCorr
   proc.jetPuppiTable.variables.UParTAK4RegPtRawCorrNeutrino = UNIFIEDPARTAK4VARS.UParTAK4RegPtRawCorrNeutrino
   proc.jetPuppiTable.variables.UParTAK4RegPtRawRes = UNIFIEDPARTAK4VARS.UParTAK4RegPtRawRes
   #
   # For Run-2 eras, don't need to save the low pt AK4 Puppi jet table for MET
   #
   run2_nanoAOD_ANY.toReplaceWith(
     proc.jetPuppiForMETTask,
     proc.jetPuppiForMETTask.copyAndExclude([proc.corrT1METJetPuppiTable])
   )
 
   #
   # Save MC-only jet variables in jet table
   #
   if runOnMC:
     jetMCTableName = "jet{}MCTable".format(jetName)
     setattr(proc, jetMCTableName, proc.jetMCTable.clone(
         src = proc.jetPuppiTable.src,
         name = proc.jetPuppiTable.name
       )
     )
     getattr(proc,jetMCTableName).variables.genJetIdx = PFJETVARS.genJetIdx
 
     jetMCTableTaskName = "jet{}MCTablesTask".format(jetName)
     setattr(proc, jetMCTableTaskName, cms.Task(getattr(proc,jetMCTableName)))
 
     run2_nanoAOD_ANY.toReplaceWith(
       proc.nanoTableTaskFS,
       proc.nanoTableTaskFS.copyAndAdd( getattr(proc,jetMCTableTaskName))
     )
 
   return proc
 

◆ RecomputePuppiMET()

def custom_jme_cff.RecomputePuppiMET ( proc )

Recompute PuppiMET. This is useful when puppi weights are recomputed.

Definition at line 1275 of file custom_jme_cff.py.

References runMETCorrectionsAndUncertainties.runMetCorAndUncFromMiniAOD().

Referenced by RecomputePuppiWeightsAndMET().

 def RecomputePuppiMET(proc):
   """
   Recompute PuppiMET. This is useful when puppi weights are recomputed.
   """
   runOnMC=True
   if hasattr(proc,"NANOEDMAODoutput") or hasattr(proc,"NANOAODoutput"):
     runOnMC = False
 
   from PhysicsTools.PatUtils.tools.runMETCorrectionsAndUncertainties import runMetCorAndUncFromMiniAOD
   runMetCorAndUncFromMiniAOD(proc, isData=not(runOnMC),
     jetCollUnskimmed='updatedJetsPuppi',metType='Puppi',postfix='Puppi',jetFlavor='AK4PFPuppi',
     puppiProducerLabel='packedpuppi',puppiProducerForMETLabel='packedpuppiNoLep',
     recoMetFromPFCs=True
   )
   return proc
 

◆ RecomputePuppiWeights()

def custom_jme_cff.RecomputePuppiWeights ( proc )

Setup packedpuppi and packedpuppiNoLep to recompute puppi weights

Definition at line 1265 of file custom_jme_cff.py.

Referenced by RecomputePuppiWeightsAndMET().

 def RecomputePuppiWeights(proc):
   """
   Setup packedpuppi and packedpuppiNoLep to recompute puppi weights
   """
   if hasattr(proc,"packedpuppi"):
     proc.packedpuppi.useExistingWeights = False
   if hasattr(proc,"packedpuppiNoLep"):
     proc.packedpuppiNoLep.useExistingWeights = False
   return proc
 

◆ RecomputePuppiWeightsAndMET()

def custom_jme_cff.RecomputePuppiWeightsAndMET ( proc )

Recompute Puppi weights PuppiMET.

Definition at line 1291 of file custom_jme_cff.py.

References RecomputePuppiMET(), and RecomputePuppiWeights().

 def RecomputePuppiWeightsAndMET(proc):
   """
   Recompute Puppi weights PuppiMET.
   """
   proc = RecomputePuppiWeights(proc)
   proc = RecomputePuppiMET(proc)
   return proc
 
 #===========================================================================
 #
 # CUSTOMIZATION function
 #
 #===========================================================================

◆ RemoveAllJetPtCuts()

def custom_jme_cff.RemoveAllJetPtCuts ( proc )

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

Definition at line 1250 of file custom_jme_cff.py.

Referenced by PrepJMECustomNanoAOD().

 def RemoveAllJetPtCuts(proc):
   """
   Remove default pt cuts for all jets set in jets_cff.py
   """
 
   proc.finalJets.cut             = "" # 15 -> 10
   proc.finalJetsPuppi.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
 

◆ 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 1120 of file custom_jme_cff.py.

Referenced by AddNewAK8GenJetsForJEC(), and AddNewGenJets().

 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
   """
 
   genJetTableName = "jet{}Table".format(genJetName)
   setattr(proc, genJetTableName, genJetTable.clone(
       src       = genJetFinalColl,
       cut       = "", # No cut specified here. Save all gen jets after clustering
       name      = genJetTablePrefix,
       doc       = genJetTableDoc,
       variables = GENJETVARS
     )
   )
 
   genJetFlavourAssociationName = "genJet{}FlavourAssociation".format(genJetName)
   setattr(proc, genJetFlavourAssociationName, genJetFlavourAssociation.clone(
       jets           = getattr(proc,genJetTableName).src,
       jetAlgorithm   = supportedJetAlgos[genJetAlgo],
       rParam         = genJetSizeNr,
     )
   )
 
   genJetFlavourTableName = "genJet{}FlavourTable".format(genJetName)
   setattr(proc, genJetFlavourTableName, genJetFlavourTable.clone(
       name            = getattr(proc,genJetTableName).name,
       src             = getattr(proc,genJetTableName).src,
       cut             = getattr(proc,genJetTableName).cut,
       jetFlavourInfos = genJetFlavourAssociationName,
     )
   )
 
   genJetTaskName = "genJet{}Task".format(genJetName)
   setattr(proc, genJetTaskName, cms.Task(
       getattr(proc,genJetTableName),
       getattr(proc,genJetFlavourAssociationName),
       getattr(proc,genJetFlavourTableName)
     )
   )
   proc.jetMCTask.add(getattr(proc,genJetTaskName))
 
   return proc
 

◆ 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 505 of file custom_jme_cff.py.

References AddBTaggingScores(), AddDeepJetGluonLQuarkScores(), AddJetID(), AddParticleNetAK4Scores(), AddPileUpJetIDVars(), AddQGLTaggerVars(), AddRobustParTAK4Scores(), and AddUnifiedParTAK4Scores().

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

                 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
   #
   finalJetsCut = "(pt >= {ptcut:.0f})".format(ptcut=ptcut)
   if runOnMC:
     finalJetsCut = "(pt >= {ptcut:.0f}) || ((pt < {ptcut:.0f}) && (genJetFwdRef().backRef().isNonnull()))".format(ptcut=ptcut)
 
   finalJetsForTable = "finalJets{}".format(jetName)
   setattr(proc, finalJetsForTable, finalJets.clone(
       src = srcJetsWithUserData,
       cut = finalJetsCut
     )
   )
 
   #
   # 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 >= {ptcut:.0f} GeV are stored.".format(ptcut=ptcut)
   if runOnMC:
     jetTableDocDefault += "For jets with pt < {ptcut:.0f} GeV, only those matched to gen jets are stored.".format(ptcut=ptcut)
 
   if doCalo:
     jetTableDocDefault = jetTableDoc
 
   jetTableName = "jet{}Table".format(jetName)
   setattr(proc,jetTableName, simplePATJetFlatTableProducer.clone(
       src = cms.InputTag(finalJetsForTable),
       cut = cms.string(jetTableCutDefault),
       name = cms.string(jetTablePrefix),
       doc  = cms.string(jetTableDocDefault),
       variables = cms.PSet(tableContent)
     )
   )
   getattr(proc,jetTableName).variables.pt.precision=10
   getattr(proc,jetTableName).variables.rawFactor.precision=10
 
   #
   # Save MC-only jet variables in table
   #
   jetMCTableName = "jet{}MCTable".format(jetName)
   setattr(proc, jetMCTableName, simplePATJetFlatTableProducer.clone(
       src = cms.InputTag(finalJetsForTable),
       cut = getattr(proc,jetTableName).cut,
       name = cms.string(jetTablePrefix),
       extension = cms.bool(True), # this is an extension table
       variables = cms.PSet(
       partonFlavour = PFJETVARS.partonFlavour,
       hadronFlavour = PFJETVARS.hadronFlavour,
       genJetIdx = PFJETVARS.genJetIdx,
       )
     )
   )
 
   #
   # Define the jet modules Task first
   #
   jetTaskName = "jet{}Task".format(jetName)
   setattr(proc, jetTaskName, cms.Task(
      getattr(proc,jetCorrFactors),
      getattr(proc,srcJets),
      getattr(proc,srcJetsWithUserData),
      getattr(proc,finalJetsForTable)
    )
   )
   proc.nanoTableTaskCommon.add(getattr(proc,jetTaskName))
 
   #
   # Define the jet tables Task
   #
   jetTableTaskName = "jet{}TablesTask".format(jetName)
   setattr(proc, jetTableTaskName, cms.Task(getattr(proc,jetTableName)))
   proc.nanoTableTaskCommon.add(getattr(proc,jetTableTaskName))
 
   jetMCTableTaskName = "jet{}MCTablesTask".format(jetName)
   setattr(proc, jetMCTableTaskName, cms.Task(getattr(proc,jetMCTableName)))
   if runOnMC:
     proc.nanoTableTaskFS.add(getattr(proc,jetMCTableTaskName))
 
   #
   # 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=jetTableName, jetTaskName=jetTaskName)
     if doPUIDVar:
       proc = AddPileUpJetIDVars(proc, jetName=jetName, jetSrc=srcJets, jetTableName=jetTableName, jetTaskName=jetTaskName)
     if doQGL:
       proc = AddQGLTaggerVars(proc,jetName=jetName, jetSrc=srcJets, jetTableName=jetTableName, jetTaskName=jetTaskName, 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=jetTableName)
     AddDeepJetGluonLQuarkScores(proc,jetTableName=jetTableName)
     AddParticleNetAK4Scores(proc,jetTableName=jetTableName)
     AddRobustParTAK4Scores(proc,jetTableName=jetTableName)
     AddUnifiedParTAK4Scores(proc,jetTableName=jetTableName)
 
   return proc
 
 

Variable Documentation

◆ area

custom_jme_cff.area

Definition at line 135 of file custom_jme_cff.py.

Referenced by HGCalWaferType.areaPolygon(), AreaSeededTrackingRegionsProducer.AreaSeededTrackingRegionsProducer(), RPCRecHitValid.bookHistograms(), FWTracksterLayersProxyBuilder.build(), HGCalCellOffset.cellAreaUV(), EventShapeVariables.circularity(), CaloDetIdAssociator.crossedElement(), RPCRecHitValidClient.dqmEndJob(), effectiveSigma(), FWECALDetailViewBuilder.fillEtaPhi(), HGCalHistoSeedingImpl.fillSmoothPhiHistoClusters(), HGCalTBGeometry.getArea(), 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(), RPCSimAverage.simulateNoise(), RPCSimAverageNoise.simulateNoise(), RPCSimAverageNoiseEffCls.simulateNoise(), RPCSimModelTiming.simulateNoise(), RPCSimAverageNoiseEff.simulateNoise(), RPCSimAsymmetricCls.simulateNoise(), CosmicMuonGenerator.terminate(), and DDI::EllipticalTube.volume().

◆ bTagCSVV2

custom_jme_cff.bTagCSVV2

Definition at line 18 of file custom_jme_cff.py.

◆ btagDDX

custom_jme_cff.btagDDX

Definition at line 44 of file custom_jme_cff.py.

◆ btagDDXV2

custom_jme_cff.btagDDXV2

Definition at line 52 of file custom_jme_cff.py.

◆ btagDeepB

custom_jme_cff.btagDeepB

Definition at line 179 of file custom_jme_cff.py.

◆ bTagDeepCSV

custom_jme_cff.bTagDeepCSV

Definition at line 19 of file custom_jme_cff.py.

◆ btagDeepCvB

custom_jme_cff.btagDeepCvB

Definition at line 181 of file custom_jme_cff.py.

◆ btagDeepCvL

custom_jme_cff.btagDeepCvL

Definition at line 180 of file custom_jme_cff.py.

◆ btagDeepFlavB

custom_jme_cff.btagDeepFlavB

Definition at line 184 of file custom_jme_cff.py.

◆ btagDeepFlavC

custom_jme_cff.btagDeepFlavC

Definition at line 185 of file custom_jme_cff.py.

◆ btagDeepFlavCvB

custom_jme_cff.btagDeepFlavCvB

Definition at line 189 of file custom_jme_cff.py.

◆ btagDeepFlavCvL

custom_jme_cff.btagDeepFlavCvL

Definition at line 188 of file custom_jme_cff.py.

◆ btagDeepFlavG

custom_jme_cff.btagDeepFlavG

Definition at line 186 of file custom_jme_cff.py.

◆ btagDeepFlavQG

custom_jme_cff.btagDeepFlavQG

Definition at line 190 of file custom_jme_cff.py.

◆ btagDeepFlavUDS

custom_jme_cff.btagDeepFlavUDS

Definition at line 187 of file custom_jme_cff.py.

◆ bTagDeepJet

custom_jme_cff.bTagDeepJet

Definition at line 20 of file custom_jme_cff.py.

◆ bTagDiscriminatorsForAK4

custom_jme_cff.bTagDiscriminatorsForAK4

Definition at line 29 of file custom_jme_cff.py.

◆ btagHbb

custom_jme_cff.btagHbb

Definition at line 43 of file custom_jme_cff.py.

◆ btagRobustParTAK4B

custom_jme_cff.btagRobustParTAK4B

Definition at line 193 of file custom_jme_cff.py.

◆ btagRobustParTAK4C

custom_jme_cff.btagRobustParTAK4C

Definition at line 194 of file custom_jme_cff.py.

◆ btagRobustParTAK4CvB

custom_jme_cff.btagRobustParTAK4CvB

Definition at line 198 of file custom_jme_cff.py.

◆ btagRobustParTAK4CvL

custom_jme_cff.btagRobustParTAK4CvL

Definition at line 197 of file custom_jme_cff.py.

◆ btagRobustParTAK4G

custom_jme_cff.btagRobustParTAK4G

Definition at line 195 of file custom_jme_cff.py.

◆ btagRobustParTAK4QG

custom_jme_cff.btagRobustParTAK4QG

Definition at line 199 of file custom_jme_cff.py.

◆ btagRobustParTAK4UDS

custom_jme_cff.btagRobustParTAK4UDS

Definition at line 196 of file custom_jme_cff.py.

◆ btagUParTAK4B

custom_jme_cff.btagUParTAK4B

Definition at line 202 of file custom_jme_cff.py.

◆ btagUParTAK4CvB

custom_jme_cff.btagUParTAK4CvB

Definition at line 204 of file custom_jme_cff.py.

◆ btagUParTAK4CvL

custom_jme_cff.btagUParTAK4CvL

Definition at line 203 of file custom_jme_cff.py.

◆ btagUParTAK4QvG

custom_jme_cff.btagUParTAK4QvG

Definition at line 205 of file custom_jme_cff.py.

◆ btagUParTAK4TauVJet

custom_jme_cff.btagUParTAK4TauVJet

Definition at line 206 of file custom_jme_cff.py.

◆ BTAGVARS

custom_jme_cff.BTAGVARS

Definition at line 178 of file custom_jme_cff.py.

◆ CALOJETVARS

custom_jme_cff.CALOJETVARS

Definition at line 220 of file custom_jme_cff.py.

◆ chEmEF

custom_jme_cff.chEmEF

Definition at line 138 of file custom_jme_cff.py.

◆ chHadMultiplicity

custom_jme_cff.chHadMultiplicity

Definition at line 146 of file custom_jme_cff.py.

◆ chHEF

custom_jme_cff.chHEF

Definition at line 136 of file custom_jme_cff.py.

◆ config_genjets

custom_jme_cff.config_genjets

Definition at line 64 of file custom_jme_cff.py.

◆ config_recojets

custom_jme_cff.config_recojets

Definition at line 87 of file custom_jme_cff.py.

◆ DEEPJETVARS

custom_jme_cff.DEEPJETVARS

Definition at line 183 of file custom_jme_cff.py.

◆ doc

custom_jme_cff.doc

Definition at line 141 of file custom_jme_cff.py.

◆ elMultiplicity

custom_jme_cff.elMultiplicity

Definition at line 151 of file custom_jme_cff.py.

◆ emf

custom_jme_cff.emf

Definition at line 223 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 141 of file custom_jme_cff.py.

◆ foo

custom_jme_cff.foo

Definition at line 29 of file custom_jme_cff.py.

Referenced by TriggerResultsFilter.beginStream(), FWConvTrackHitsDetailView.build(), FWConvTrackHitsDetailView.camera1Callback(), FWConvTrackHitsDetailView.camera2Callback(), FWConvTrackHitsDetailView.camera3Callback(), mkfit.execTrackerInfoCreatorPlugin(), AlignPCLThresholdPlotHelper::AlignPCLThresholds_DisplayBase< PayloadType >.fill(), AlignPCLThresholdPlotHelper::AlignPCLThresholds_CompareBase< PayloadType, nIOVs, ntags >.fill(), beamSpotPI::DisplayParameters< PayloadType >.fill(), beamSpotPI::DisplayParametersDiff< PayloadType, nIOVs, ntags >.fill(), simBeamSpotPI::DisplayParameters< PayloadType >.fill(), simBeamSpotPI::DisplayParametersDiff< PayloadType, nIOVs, ntags >.fill(), simBeamSpotHLLHCPI::DisplayParameters< PayloadType >.fill(), simBeamSpotHLLHCPI::DisplayParametersDiff< PayloadType, nIOVs, ntags >.fill(), ALPAKA_ACCELERATOR_NAMESPACE::PFClusterParamsESProducer.fillDescriptions(), HLTMuonValidator.fillLabels(), FWGUIManager.FWGUIManager(), HLTMuonPlotter.HLTMuonPlotter(), mtd_digitizer.loadSimHitAccumulator(), triggerExpression::L1uGTReader.mask(), triggerExpression::PathReader.mask(), edmtest::ExistingDictionaryTestProducer.produce(), l1t::PhysicsToBitConverter.ReadBitInInt(), FWConvTrackHitsDetailView.switchProjection(), HouseholderDecomposition.unzipMatrix(), and HLTMuonPlotter.vector_to_string().

◆ genJetIdx

custom_jme_cff.genJetIdx

Definition at line 156 of file custom_jme_cff.py.

◆ GENJETVARS

custom_jme_cff.GENJETVARS

Definition at line 130 of file custom_jme_cff.py.

◆ hadronFlavour

custom_jme_cff.hadronFlavour

Definition at line 155 of file custom_jme_cff.py.

Referenced by JetTester.analyze(), GenHFHadronMatcher.findHadronJets(), GenHFHadronMatcher.fixExtraSameFlavours(), GenJetFlavourTableProducer.produce(), JetFlavourClustering.produce(), JetFlavourClustering.setFlavours(), and reco::JetFlavourInfo.setHadronFlavour().

◆ hfEmEF

custom_jme_cff.hfEmEF

Definition at line 142 of file custom_jme_cff.py.

◆ hfEMMultiplicity

custom_jme_cff.hfEMMultiplicity

Definition at line 149 of file custom_jme_cff.py.

◆ hfHadMultiplicity

custom_jme_cff.hfHadMultiplicity

Definition at line 148 of file custom_jme_cff.py.

◆ hfHEF

custom_jme_cff.hfHEF

Definition at line 141 of file custom_jme_cff.py.

◆ muEF

custom_jme_cff.muEF

Definition at line 140 of file custom_jme_cff.py.

◆ muMultiplicity

custom_jme_cff.muMultiplicity

Definition at line 150 of file custom_jme_cff.py.

◆ nanoInfo_genjets

custom_jme_cff.nanoInfo_genjets

Definition at line 74 of file custom_jme_cff.py.

◆ nanoInfo_recojets

custom_jme_cff.nanoInfo_recojets

Definition at line 113 of file custom_jme_cff.py.

◆ nConstituents

custom_jme_cff.nConstituents

Definition at line 131 of file custom_jme_cff.py.

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

◆ neEmEF

custom_jme_cff.neEmEF

Definition at line 139 of file custom_jme_cff.py.

◆ neHadMultiplicity

custom_jme_cff.neHadMultiplicity

Definition at line 147 of file custom_jme_cff.py.

◆ neHEF

custom_jme_cff.neHEF

Definition at line 137 of file custom_jme_cff.py.

◆ nElectrons

custom_jme_cff.nElectrons

Definition at line 144 of file custom_jme_cff.py.

Referenced by TriggerSummaryAnalyzerRAW.analyze(), BTagAndProbe.analyze(), SusyDQM< Mu, Ele, Jet, Met >.analyze(), LowPtGsfElectronIDProducer.doWork(), L1TEGammaOffline.findTagAndProbePair(), and reco::RecoTauPiZero.numberOfElectrons().

◆ nMuons

custom_jme_cff.nMuons

Definition at line 143 of file custom_jme_cff.py.

Referenced by TriggerSummaryAnalyzerRAW.analyze(), BTagAndProbe.analyze(), SiPixelCalSingleMuonAnalyzer.analyze(), SusyDQM< Mu, Ele, Jet, Met >.analyze(), NearbyPixelClustersAnalyzer.analyze(), PFAlgo.createCandidatesHCAL(), MuGEMMuonExtTableProducer.fillTable(), MuDTMuonExtTableProducer.fillTable(), 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(), pat::DisplacedMuonFilterProducer.produce(), MuonProducer.produce(), MuonIdProducer.produce(), and HIMuonTrackingRegionProducer.regions().

◆ particleNetAK4_B

custom_jme_cff.particleNetAK4_B

Definition at line 212 of file custom_jme_cff.py.

◆ particleNetAK4_CvsB

custom_jme_cff.particleNetAK4_CvsB

Definition at line 214 of file custom_jme_cff.py.

◆ particleNetAK4_CvsL

custom_jme_cff.particleNetAK4_CvsL

Definition at line 213 of file custom_jme_cff.py.

◆ particleNetAK4_G

custom_jme_cff.particleNetAK4_G

Definition at line 216 of file custom_jme_cff.py.

◆ particleNetAK4_puIdDisc

custom_jme_cff.particleNetAK4_puIdDisc

Definition at line 217 of file custom_jme_cff.py.

◆ particleNetAK4_QvsG

custom_jme_cff.particleNetAK4_QvsG

Definition at line 215 of file custom_jme_cff.py.

◆ PARTICLENETAK4VARS

custom_jme_cff.PARTICLENETAK4VARS

Definition at line 211 of file custom_jme_cff.py.

◆ partonFlavour

custom_jme_cff.partonFlavour

Definition at line 154 of file custom_jme_cff.py.

Referenced by JetTester.analyze(), reco::modules::JetFlavourIdentifier.findCandidates(), reco::modules::JetFlavourIdentifier.findLeptons(), GenJetFlavourTableProducer.produce(), JetFlavourClustering.produce(), JetFlavourClustering.setFlavours(), and reco::JetFlavourInfo.setPartonFlavour().

◆ PFJETVARS

custom_jme_cff.PFJETVARS

Definition at line 133 of file custom_jme_cff.py.

◆ phoMultiplicity

custom_jme_cff.phoMultiplicity

Definition at line 152 of file custom_jme_cff.py.

◆ precision

custom_jme_cff.precision

Definition at line 141 of file custom_jme_cff.py.

◆ puId_beta

custom_jme_cff.puId_beta

Definition at line 167 of file custom_jme_cff.py.

◆ puId_dR2Mean

custom_jme_cff.puId_dR2Mean

Definition at line 159 of file custom_jme_cff.py.

◆ puId_frac01

custom_jme_cff.puId_frac01

Definition at line 162 of file custom_jme_cff.py.

◆ puId_frac02

custom_jme_cff.puId_frac02

Definition at line 163 of file custom_jme_cff.py.

◆ puId_frac03

custom_jme_cff.puId_frac03

Definition at line 164 of file custom_jme_cff.py.

◆ puId_frac04

custom_jme_cff.puId_frac04

Definition at line 165 of file custom_jme_cff.py.

◆ puId_jetR

custom_jme_cff.puId_jetR

Definition at line 169 of file custom_jme_cff.py.

◆ puId_jetRchg

custom_jme_cff.puId_jetRchg

Definition at line 170 of file custom_jme_cff.py.

◆ puId_majW

custom_jme_cff.puId_majW

Definition at line 160 of file custom_jme_cff.py.

◆ puId_minW

custom_jme_cff.puId_minW

Definition at line 161 of file custom_jme_cff.py.

◆ puId_nCharged

custom_jme_cff.puId_nCharged

Definition at line 171 of file custom_jme_cff.py.

◆ puId_ptD

custom_jme_cff.puId_ptD

Definition at line 166 of file custom_jme_cff.py.

◆ puId_pull

custom_jme_cff.puId_pull

Definition at line 168 of file custom_jme_cff.py.

◆ PUIDVARS

custom_jme_cff.PUIDVARS

Definition at line 158 of file custom_jme_cff.py.

◆ qgl_axis2

custom_jme_cff.qgl_axis2

Definition at line 174 of file custom_jme_cff.py.

◆ qgl_mult

custom_jme_cff.qgl_mult

Definition at line 176 of file custom_jme_cff.py.

◆ qgl_ptD

custom_jme_cff.qgl_ptD

Definition at line 175 of file custom_jme_cff.py.

◆ QGLVARS

custom_jme_cff.QGLVARS

Definition at line 173 of file custom_jme_cff.py.

◆ rawFactor

custom_jme_cff.rawFactor

Definition at line 134 of file custom_jme_cff.py.

◆ ROBUSTPARTAK4VARS

custom_jme_cff.ROBUSTPARTAK4VARS

Definition at line 192 of file custom_jme_cff.py.

◆ UNIFIEDPARTAK4VARS

custom_jme_cff.UNIFIEDPARTAK4VARS

Definition at line 201 of file custom_jme_cff.py.

◆ UParTAK4RegPtRawCorr

custom_jme_cff.UParTAK4RegPtRawCorr

Definition at line 207 of file custom_jme_cff.py.

◆ UParTAK4RegPtRawCorrNeutrino

custom_jme_cff.UParTAK4RegPtRawCorrNeutrino

Definition at line 208 of file custom_jme_cff.py.

◆ UParTAK4RegPtRawRes

custom_jme_cff.UParTAK4RegPtRawRes

Definition at line 209 of file custom_jme_cff.py.

Functions

Variables

Function Documentation

◆ AddBTaggingScores()

◆ AddDeepJetGluonLQuarkScores()

◆ AddJetID()

◆ AddNewAK8CHSJets()

◆ AddNewAK8GenJetsForJEC()

◆ AddNewAK8PuppiJetsForJEC()

◆ AddNewGenJets()

◆ AddNewPatJets()

◆ AddParticleNetAK4Scores()

◆ AddPileUpJetIDVars()

◆ AddQGLTaggerVars()

◆ AddRobustParTAK4Scores()

◆ AddUnifiedParTAK4Scores()

◆ AddVariablesForAK4GenJets()

◆ AddVariablesForAK8GenJets()

◆ AddVariablesForAK8PuppiJets()

◆ ModifyAK4JetMCTable()

◆ PrepJMECustomNanoAOD()

◆ ReclusterAK4CHSJets()

◆ ReclusterAK4GenJets()

◆ ReclusterAK4PuppiJets()

◆ RecomputePuppiMET()

◆ RecomputePuppiWeights()

◆ RecomputePuppiWeightsAndMET()

◆ RemoveAllJetPtCuts()

◆ SaveGenJets()

◆ SavePatJets()

Variable Documentation

◆ area

◆ bTagCSVV2

◆ btagDDX

◆ btagDDXV2

◆ btagDeepB

◆ bTagDeepCSV

◆ btagDeepCvB

◆ btagDeepCvL

◆ btagDeepFlavB

◆ btagDeepFlavC

◆ btagDeepFlavCvB

◆ btagDeepFlavCvL

◆ btagDeepFlavG

◆ btagDeepFlavQG

◆ btagDeepFlavUDS

◆ bTagDeepJet

◆ bTagDiscriminatorsForAK4

◆ btagHbb

◆ btagRobustParTAK4B

◆ btagRobustParTAK4C

◆ btagRobustParTAK4CvB

◆ btagRobustParTAK4CvL

◆ btagRobustParTAK4G

◆ btagRobustParTAK4QG

◆ btagRobustParTAK4UDS

◆ btagUParTAK4B

◆ btagUParTAK4CvB

◆ btagUParTAK4CvL

◆ btagUParTAK4QvG

◆ btagUParTAK4TauVJet

◆ BTAGVARS

◆ CALOJETVARS

◆ chEmEF

◆ chHadMultiplicity

◆ chHEF

◆ config_genjets

◆ config_recojets

◆ DEEPJETVARS

◆ doc

◆ elMultiplicity

◆ emf

◆ float

◆ foo

◆ genJetIdx

◆ GENJETVARS

◆ hadronFlavour

◆ hfEmEF

◆ hfEMMultiplicity

◆ hfHadMultiplicity