custom_jme_cff Namespace Reference

Functions
def	AddBTaggingScores (proc, jetTableName="")
def	AddDeepJetGluonLQuarkScores (proc, jetTableName="")
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	RecomputePuppiWeightsMETAK8 (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
	btagDeepB
	bTagDeepCSV
	btagDeepCvB
	btagDeepCvL
	btagDeepFlavB
	btagDeepFlavC
	btagDeepFlavCvB
	btagDeepFlavCvL
	btagDeepFlavG
	btagDeepFlavQG
	btagDeepFlavUDS
	bTagDeepJet
	bTagDiscriminatorsForAK4
	btagRobustParTAK4B
	btagRobustParTAK4C
	btagRobustParTAK4CvB
	btagRobustParTAK4CvL
	btagRobustParTAK4G
	btagRobustParTAK4QG
	btagRobustParTAK4UDS
	btagUParTAK4B
	btagUParTAK4CvB
	btagUParTAK4CvL
	btagUParTAK4QvG
	btagUParTAK4SvCB
	btagUParTAK4SvUDG
	btagUParTAK4TauVJet
	btagUParTAK4UDG
	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 324 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 343 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

AddNewAK8CHSJets()

def custom_jme_cff.AddNewAK8CHSJets	(		proc,
			recoJA,
			runOnMC
	)

Store an AK8 CHS jet collection for JEC studies.

Definition at line 1017 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 1184 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 984 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 1083 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 398 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 384 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 219 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 286 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 354 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 365 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.btagUParTAK4SvCB = UNIFIEDPARTAK4VARS.btagUParTAK4SvCB
  getattr(proc, jetTableName).variables.btagUParTAK4SvUDG = UNIFIEDPARTAK4VARS.btagUParTAK4SvUDG
  getattr(proc, jetTableName).variables.btagUParTAK4UDG = UNIFIEDPARTAK4VARS.btagUParTAK4UDG
  getattr(proc, jetTableName).variables.btagUParTAK4QvG = UNIFIEDPARTAK4VARS.btagUParTAK4QvG
  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 1211 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 1215 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 1049 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 1219 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 1339 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 789 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)
    if "UParTAK4Reg" in varNames:
      delattr(proc.jetTable.variables, varNames)
    if "svIdx" in varNames or "muonIdx" in varNames:
      delattr(proc.jetTable.variables, varNames)
    if "nElectrons" in varNames or "nMuons" in varNames or "nSVs" 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 1143 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 568 of file custom_jme_cff.py.

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

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

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

  #
  #
  #

  from PhysicsTools.NanoAOD.patJetPFConstituentVarProducer_cfi import patJetPFConstituentVarProducer
  jetPFConstituentVarName = "jetPFConstituentVar{}".format(jetName)
  setattr(proc, jetPFConstituentVarName, patJetPFConstituentVarProducer.clone(
      jets = "updatedJetsPuppi",
      puppi_value_map = 'packedpuppi',
      fallback_puppi_weight = False,
    )
  )
  proc.jetPuppiTask.add(getattr(proc, jetPFConstituentVarName))
  proc.updatedJetsPuppiWithUserData.userFloats.leadConstNeHadEF = cms.InputTag(jetPFConstituentVarName+':leadConstNeHadEF')
  proc.updatedJetsPuppiWithUserData.userFloats.leadConstChHadEF = cms.InputTag(jetPFConstituentVarName+':leadConstChHadEF')
  proc.updatedJetsPuppiWithUserData.userFloats.leadConstPhotonEF = cms.InputTag(jetPFConstituentVarName+':leadConstPhotonEF')
  proc.updatedJetsPuppiWithUserData.userFloats.leadConstElectronEF = cms.InputTag(jetPFConstituentVarName+':leadConstElectronEF')
  proc.updatedJetsPuppiWithUserData.userFloats.leadConstMuonEF = cms.InputTag(jetPFConstituentVarName+':leadConstMuonEF')
  proc.updatedJetsPuppiWithUserData.userFloats.leadConstHFHADEF = cms.InputTag(jetPFConstituentVarName+':leadConstHFHADEF')
  proc.updatedJetsPuppiWithUserData.userFloats.leadConstHFEMEF = cms.InputTag(jetPFConstituentVarName+':leadConstHFEMEF')
  proc.updatedJetsPuppiWithUserData.userFloats.leadConstNeHadPuppiWeight = cms.InputTag(jetPFConstituentVarName+':leadConstNeHadPuppiWeight')
  proc.updatedJetsPuppiWithUserData.userFloats.leadConstChHadPuppiWeight = cms.InputTag(jetPFConstituentVarName+':leadConstChHadPuppiWeight')
  proc.updatedJetsPuppiWithUserData.userFloats.leadConstPhotonPuppiWeight = cms.InputTag(jetPFConstituentVarName+':leadConstPhotonPuppiWeight')
  proc.updatedJetsPuppiWithUserData.userFloats.leadConstElectronPuppiWeight = cms.InputTag(jetPFConstituentVarName+':leadConstElectronPuppiWeight')
  proc.updatedJetsPuppiWithUserData.userFloats.leadConstMuonPuppiWeight = cms.InputTag(jetPFConstituentVarName+':leadConstMuonPuppiWeight')
  proc.updatedJetsPuppiWithUserData.userFloats.leadConstHFHADPuppiWeight = cms.InputTag(jetPFConstituentVarName+':leadConstHFHADPuppiWeight')
  proc.updatedJetsPuppiWithUserData.userFloats.leadConstHFEMPuppiWeight = cms.InputTag(jetPFConstituentVarName+':leadConstHFEMPuppiWeight')
  proc.jetPuppiTable.variables.leadConstNeHadEF = Var("userFloat('leadConstNeHadEF')",float,doc="Leading PF neutral hadron constituent energy fraction w.r.t jet raw energy",precision=10)
  proc.jetPuppiTable.variables.leadConstChHadEF = Var("userFloat('leadConstChHadEF')",float,doc="Leading PF charged hadron constituent energy fraction w.r.t jet raw energy",precision=10)
  proc.jetPuppiTable.variables.leadConstPhotonEF = Var("userFloat('leadConstPhotonEF')",float,doc="Leading PF photon constituent energy fraction w.r.t jet raw energy",precision=10)
  proc.jetPuppiTable.variables.leadConstElectronEF = Var("userFloat('leadConstElectronEF')",float,doc="Leading PF electron constituent energy fraction w.r.t jet raw energy",precision=10)
  proc.jetPuppiTable.variables.leadConstMuonEF = Var("userFloat('leadConstMuonEF')",float,doc="Leading PF muon constituent energy fraction w.r.t jet raw energy",precision=10)
  proc.jetPuppiTable.variables.leadConstHFHADEF = Var("userFloat('leadConstHFHADEF')",float,doc="Leading PF HF HAD constituent energy fraction w.r.t jet raw energy",precision=10)
  proc.jetPuppiTable.variables.leadConstHFEMEF = Var("userFloat('leadConstHFEMEF')",float,doc="Leading PF HF EM constituent energy fraction w.r.t jet raw energy",precision=10)
  proc.jetPuppiTable.variables.leadConstNeHadPuppiWeight = Var("userFloat('leadConstNeHadPuppiWeight')",float,doc="Leading PF neutral hadron constituent puppi weight",precision=10)
  proc.jetPuppiTable.variables.leadConstChHadPuppiWeight = Var("userFloat('leadConstChHadPuppiWeight')",float,doc="Leading PF charged hadron constituent puppi weight",precision=10)
  proc.jetPuppiTable.variables.leadConstPhotonPuppiWeight = Var("userFloat('leadConstPhotonPuppiWeight')",float,doc="Leading PF photon constituent puppi weight",precision=10)
  proc.jetPuppiTable.variables.leadConstElectronPuppiWeight = Var("userFloat('leadConstElectronPuppiWeight')",float,doc="Leading PF electron constituent puppi weight",precision=10)
  proc.jetPuppiTable.variables.leadConstMuonPuppiWeight = Var("userFloat('leadConstMuonPuppiWeight')",float,doc="Leading PF muon constituent puppi weight",precision=10)
  proc.jetPuppiTable.variables.leadConstHFHADPuppiWeight = Var("userFloat('leadConstHFHADPuppiWeight')",float,doc="Leading PF HF HAD constituent puppi weight",precision=10)
  proc.jetPuppiTable.variables.leadConstHFEMPuppiWeight = Var("userFloat('leadConstHFEMPuppiWeight')",float,doc="Leading PF HF EM constituent puppi weight",precision=10)


  #
  # Add Pileup Jet ID for Puppi jets
  #
  from RecoJets.JetProducers.PileupJetID_cfi import pileupJetIdPuppi
  pileupJetIdName = "pileupJetId{}".format(jetName)
  setattr(proc, pileupJetIdName, pileupJetIdPuppi.clone(
      jets = "updatedJetsPuppi",
      srcConstituentWeights = "packedpuppi",
      vertexes  = "offlineSlimmedPrimaryVertices",
      inputIsCorrected=True,
      applyJec=False
    )
  )
  proc.jetPuppiTask.add(getattr(proc, pileupJetIdName))
  proc.updatedJetsPuppiWithUserData.userFloats.puIdDisc = cms.InputTag(pileupJetIdName+':fullDiscriminant')
  proc.jetPuppiTable.variables.puIdDisc = Var("userFloat('puIdDisc')", float, doc="Pileup ID BDT discriminant with 133X Winter24 PuppiV18 training",precision=10)


  #
  # 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.btagUParTAK4SvCB = UNIFIEDPARTAK4VARS.btagUParTAK4SvCB
  proc.jetPuppiTable.variables.btagUParTAK4SvUDG = UNIFIEDPARTAK4VARS.btagUParTAK4SvUDG
  proc.jetPuppiTable.variables.btagUParTAK4UDG = UNIFIEDPARTAK4VARS.btagUParTAK4UDG
  proc.jetPuppiTable.variables.btagUParTAK4QvG = UNIFIEDPARTAK4VARS.btagUParTAK4QvG
  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 1255 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

#===========================================================================
#
# Functions to setup recomputation of Puppi weights and recluster PuppiMET
# and AK8 Puppi jets (slimmedJetsAK8)
#
#===========================================================================

RecomputePuppiWeights()

def custom_jme_cff.RecomputePuppiWeights

(

proc

)

Setup packedpuppi and packedpuppiNoLep to recompute puppi weights

Definition at line 1245 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 and PuppiMET.

Definition at line 1277 of file custom_jme_cff.py.

References RecomputePuppiMET(), and RecomputePuppiWeights().

Referenced by RecomputePuppiWeightsMETAK8().

def RecomputePuppiWeightsAndMET(proc):
  """
  Recompute Puppi weights and PuppiMET.
  """

  proc = RecomputePuppiWeights(proc)
  proc = RecomputePuppiMET(proc)

  return proc

RecomputePuppiWeightsMETAK8()

def custom_jme_cff.RecomputePuppiWeightsMETAK8

(

proc

)

Recompute Puppi weights and PuppiMET and rebuild slimmedJetsAK8.

Definition at line 1287 of file custom_jme_cff.py.

References RecomputePuppiWeightsAndMET(), and puppiJetMETReclusteringFromMiniAOD_cff.setupPuppiAK4AK8METReclustering().

def RecomputePuppiWeightsMETAK8(proc):
  """
  Recompute Puppi weights and PuppiMET and rebuild slimmedJetsAK8.
  """
  runOnMC=True
  if hasattr(proc,"NANOEDMAODoutput") or hasattr(proc,"NANOAODoutput"):
    runOnMC = False

  proc = RecomputePuppiWeightsAndMET(proc)

  from RecoBTag.ONNXRuntime.pfParticleNet_cff import _pfParticleNetJetTagsAll as pfParticleNetJetTagsAll
  from RecoBTag.ONNXRuntime.pfParticleNet_cff import _pfParticleNetMassRegressionOutputs as pfParticleNetMassRegressionOutputs
  from RecoBTag.ONNXRuntime.pfParticleNet_cff import _pfParticleNetMassCorrelatedJetTagsAll as pfParticleNetMassCorrelatedJetTagsAll
  from RecoBTag.ONNXRuntime.pfParticleNetFromMiniAODAK8_cff import _pfParticleNetFromMiniAODAK8JetTagsAll as pfParticleNetFromMiniAODAK8JetTagsAll
  from RecoBTag.ONNXRuntime.pfGlobalParticleTransformerAK8_cff import _pfGlobalParticleTransformerAK8JetTagsAll as pfGlobalParticleTransformerAK8JetTagsAll

  btagDiscriminatorsAK8 = cms.PSet(names = cms.vstring(
      pfParticleNetMassCorrelatedJetTagsAll+
      pfGlobalParticleTransformerAK8JetTagsAll+
      pfParticleNetFromMiniAODAK8JetTagsAll+
      pfParticleNetJetTagsAll+
      pfParticleNetMassRegressionOutputs
    )
  )

  btagDiscriminatorsAK8Subjets = cms.PSet(names = cms.vstring(
      'pfDeepFlavourJetTags:probb',
      'pfDeepFlavourJetTags:probbb',
      'pfDeepFlavourJetTags:problepb',
      'pfUnifiedParticleTransformerAK4DiscriminatorsJetTags:BvsAll'
    )
  )

  run3_nanoAOD_pre142X.toModify(btagDiscriminatorsAK8Subjets,
    names = cms.vstring('pfDeepCSVJetTags:probb','pfDeepCSVJetTags:probbb')
  )

  from PhysicsTools.PatAlgos.tools.puppiJetMETReclusteringFromMiniAOD_cff import setupPuppiAK4AK8METReclustering
  proc = setupPuppiAK4AK8METReclustering(proc, runOnMC=runOnMC, useExistingWeights=False,
    reclusterAK4MET=False, # Already setup to recluster AK4 Puppi jets and PuppiMET
    reclusterAK8=True,
    btagDiscriminatorsAK8=btagDiscriminatorsAK8,
    btagDiscriminatorsAK8Subjets=btagDiscriminatorsAK8Subjets
  )

  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 1230 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 1100 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 425 of file custom_jme_cff.py.

References AddBTaggingScores(), AddDeepJetGluonLQuarkScores(), 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:
    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 117 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.

btagDeepB

custom_jme_cff.btagDeepB

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

btagDeepCvL

custom_jme_cff.btagDeepCvL

Definition at line 162 of file custom_jme_cff.py.

btagDeepFlavB

custom_jme_cff.btagDeepFlavB

Definition at line 166 of file custom_jme_cff.py.

btagDeepFlavC

custom_jme_cff.btagDeepFlavC

Definition at line 167 of file custom_jme_cff.py.

btagDeepFlavCvB

custom_jme_cff.btagDeepFlavCvB

Definition at line 171 of file custom_jme_cff.py.

btagDeepFlavCvL

custom_jme_cff.btagDeepFlavCvL

Definition at line 170 of file custom_jme_cff.py.

btagDeepFlavG

custom_jme_cff.btagDeepFlavG

Definition at line 168 of file custom_jme_cff.py.

btagDeepFlavQG

custom_jme_cff.btagDeepFlavQG

Definition at line 172 of file custom_jme_cff.py.

btagDeepFlavUDS

custom_jme_cff.btagDeepFlavUDS

Definition at line 169 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.

btagRobustParTAK4B

custom_jme_cff.btagRobustParTAK4B

Definition at line 175 of file custom_jme_cff.py.

btagRobustParTAK4C

custom_jme_cff.btagRobustParTAK4C

Definition at line 176 of file custom_jme_cff.py.

btagRobustParTAK4CvB

custom_jme_cff.btagRobustParTAK4CvB

Definition at line 180 of file custom_jme_cff.py.

btagRobustParTAK4CvL

custom_jme_cff.btagRobustParTAK4CvL

Definition at line 179 of file custom_jme_cff.py.

btagRobustParTAK4G

custom_jme_cff.btagRobustParTAK4G

Definition at line 177 of file custom_jme_cff.py.

btagRobustParTAK4QG

custom_jme_cff.btagRobustParTAK4QG

Definition at line 181 of file custom_jme_cff.py.

btagRobustParTAK4UDS

custom_jme_cff.btagRobustParTAK4UDS

Definition at line 178 of file custom_jme_cff.py.

btagUParTAK4B

custom_jme_cff.btagUParTAK4B

Definition at line 184 of file custom_jme_cff.py.

btagUParTAK4CvB

custom_jme_cff.btagUParTAK4CvB

Definition at line 186 of file custom_jme_cff.py.

btagUParTAK4CvL

custom_jme_cff.btagUParTAK4CvL

Definition at line 185 of file custom_jme_cff.py.

btagUParTAK4QvG

custom_jme_cff.btagUParTAK4QvG

Definition at line 190 of file custom_jme_cff.py.

btagUParTAK4SvCB

custom_jme_cff.btagUParTAK4SvCB

Definition at line 187 of file custom_jme_cff.py.

btagUParTAK4SvUDG

custom_jme_cff.btagUParTAK4SvUDG

Definition at line 188 of file custom_jme_cff.py.

btagUParTAK4TauVJet

custom_jme_cff.btagUParTAK4TauVJet

Definition at line 191 of file custom_jme_cff.py.

btagUParTAK4UDG

custom_jme_cff.btagUParTAK4UDG

Definition at line 189 of file custom_jme_cff.py.

BTAGVARS

custom_jme_cff.BTAGVARS

Definition at line 160 of file custom_jme_cff.py.

CALOJETVARS

custom_jme_cff.CALOJETVARS

Definition at line 205 of file custom_jme_cff.py.

chEmEF

custom_jme_cff.chEmEF

Definition at line 120 of file custom_jme_cff.py.

chHadMultiplicity

custom_jme_cff.chHadMultiplicity

Definition at line 128 of file custom_jme_cff.py.

chHEF

custom_jme_cff.chHEF

Definition at line 118 of file custom_jme_cff.py.

config_genjets

custom_jme_cff.config_genjets

Definition at line 46 of file custom_jme_cff.py.

config_recojets

custom_jme_cff.config_recojets

Definition at line 69 of file custom_jme_cff.py.

DEEPJETVARS

custom_jme_cff.DEEPJETVARS

Definition at line 165 of file custom_jme_cff.py.

doc

custom_jme_cff.doc

Definition at line 123 of file custom_jme_cff.py.

elMultiplicity

custom_jme_cff.elMultiplicity

Definition at line 133 of file custom_jme_cff.py.

emf

custom_jme_cff.emf

Definition at line 208 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 123 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 138 of file custom_jme_cff.py.

GENJETVARS

custom_jme_cff.GENJETVARS

Definition at line 112 of file custom_jme_cff.py.

hadronFlavour

custom_jme_cff.hadronFlavour

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

hfEMMultiplicity

custom_jme_cff.hfEMMultiplicity

Definition at line 131 of file custom_jme_cff.py.

hfHadMultiplicity

custom_jme_cff.hfHadMultiplicity

Definition at line 130 of file custom_jme_cff.py.

hfHEF

custom_jme_cff.hfHEF

Definition at line 123 of file custom_jme_cff.py.

muEF

custom_jme_cff.muEF

Definition at line 122 of file custom_jme_cff.py.

muMultiplicity

custom_jme_cff.muMultiplicity

Definition at line 132 of file custom_jme_cff.py.

nanoInfo_genjets

custom_jme_cff.nanoInfo_genjets

Definition at line 56 of file custom_jme_cff.py.

nanoInfo_recojets

custom_jme_cff.nanoInfo_recojets

Definition at line 95 of file custom_jme_cff.py.

nConstituents

custom_jme_cff.nConstituents

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

neHadMultiplicity

custom_jme_cff.neHadMultiplicity

Definition at line 129 of file custom_jme_cff.py.

neHEF

custom_jme_cff.neHEF

Definition at line 119 of file custom_jme_cff.py.

nElectrons

custom_jme_cff.nElectrons

Definition at line 126 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 125 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 197 of file custom_jme_cff.py.

particleNetAK4_CvsB

custom_jme_cff.particleNetAK4_CvsB

Definition at line 199 of file custom_jme_cff.py.

particleNetAK4_CvsL

custom_jme_cff.particleNetAK4_CvsL

Definition at line 198 of file custom_jme_cff.py.

particleNetAK4_G

custom_jme_cff.particleNetAK4_G

Definition at line 201 of file custom_jme_cff.py.

particleNetAK4_puIdDisc

custom_jme_cff.particleNetAK4_puIdDisc

Definition at line 202 of file custom_jme_cff.py.

particleNetAK4_QvsG

custom_jme_cff.particleNetAK4_QvsG

Definition at line 200 of file custom_jme_cff.py.

PARTICLENETAK4VARS

custom_jme_cff.PARTICLENETAK4VARS

Definition at line 196 of file custom_jme_cff.py.

partonFlavour

custom_jme_cff.partonFlavour

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

phoMultiplicity

custom_jme_cff.phoMultiplicity

Definition at line 134 of file custom_jme_cff.py.

precision

custom_jme_cff.precision

Definition at line 123 of file custom_jme_cff.py.

puId_beta

custom_jme_cff.puId_beta

Definition at line 149 of file custom_jme_cff.py.

puId_dR2Mean

custom_jme_cff.puId_dR2Mean

Definition at line 141 of file custom_jme_cff.py.

puId_frac01

custom_jme_cff.puId_frac01

Definition at line 144 of file custom_jme_cff.py.

puId_frac02

custom_jme_cff.puId_frac02

Definition at line 145 of file custom_jme_cff.py.

puId_frac03

custom_jme_cff.puId_frac03

Definition at line 146 of file custom_jme_cff.py.

puId_frac04

custom_jme_cff.puId_frac04

Definition at line 147 of file custom_jme_cff.py.

puId_jetR

custom_jme_cff.puId_jetR

Definition at line 151 of file custom_jme_cff.py.

puId_jetRchg

custom_jme_cff.puId_jetRchg

Definition at line 152 of file custom_jme_cff.py.

puId_majW

custom_jme_cff.puId_majW

Definition at line 142 of file custom_jme_cff.py.

puId_minW

custom_jme_cff.puId_minW

Definition at line 143 of file custom_jme_cff.py.

puId_nCharged

custom_jme_cff.puId_nCharged

Definition at line 153 of file custom_jme_cff.py.

puId_ptD

custom_jme_cff.puId_ptD

Definition at line 148 of file custom_jme_cff.py.

puId_pull

custom_jme_cff.puId_pull

Definition at line 150 of file custom_jme_cff.py.

PUIDVARS

custom_jme_cff.PUIDVARS

Definition at line 140 of file custom_jme_cff.py.

qgl_axis2

custom_jme_cff.qgl_axis2

Definition at line 156 of file custom_jme_cff.py.

qgl_mult

custom_jme_cff.qgl_mult

Definition at line 158 of file custom_jme_cff.py.

qgl_ptD

custom_jme_cff.qgl_ptD

Definition at line 157 of file custom_jme_cff.py.

QGLVARS

custom_jme_cff.QGLVARS

Definition at line 155 of file custom_jme_cff.py.

rawFactor

custom_jme_cff.rawFactor

Definition at line 116 of file custom_jme_cff.py.

ROBUSTPARTAK4VARS

custom_jme_cff.ROBUSTPARTAK4VARS

Definition at line 174 of file custom_jme_cff.py.

UNIFIEDPARTAK4VARS

custom_jme_cff.UNIFIEDPARTAK4VARS

Definition at line 183 of file custom_jme_cff.py.

UParTAK4RegPtRawCorr

custom_jme_cff.UParTAK4RegPtRawCorr

Definition at line 192 of file custom_jme_cff.py.

UParTAK4RegPtRawCorrNeutrino

custom_jme_cff.UParTAK4RegPtRawCorrNeutrino

Definition at line 193 of file custom_jme_cff.py.

UParTAK4RegPtRawRes

custom_jme_cff.UParTAK4RegPtRawRes

Definition at line 194 of file custom_jme_cff.py.

---

Generated for CMSSW Reference Manual by  1.8.14