custom_jme_cff Namespace Reference

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	AddVariablesForAK4GenJets (proc)
def	AddVariablesForAK8GenJets (proc)
def	AddVariablesForAK8PuppiJets (proc)
def	PrepJMECustomNanoAOD (process, runOnMC)
def	PrepJMECustomNanoAOD_Data (process)
def	PrepJMECustomNanoAOD_MC (process)
def	ReclusterAK4CHSJets (proc, recoJA, runOnMC)
def	ReclusterAK4GenJets (proc, genJA)
def	ReclusterAK4PuppiJets (proc, recoJA, runOnMC)
def	RemoveAllJetPtCuts (proc)
def	SaveGenJets (proc, genJetName, genJetAlgo, genJetSizeNr, genJetFinalColl, genJetTablePrefix, genJetTableDoc, runOnMC=False)
def	SavePatJets (proc, jetName, payload, patJetFinalColl, jetTablePrefix, jetTableDoc, doPF, doCalo, ptcut, doPUIDVar=False, doQGL=False, doBTag=False, runOnMC=False)

Variables
	area
	bTagCSVV2
	btagCSVV2
	btagDDX
	btagDDXV2
	btagDeepB
	bTagDeepCSV
	btagDeepCvB
	btagDeepCvL
	btagDeepFlavB
	btagDeepFlavC
	btagDeepFlavCvB
	btagDeepFlavCvL
	btagDeepFlavG
	btagDeepFlavQG
	btagDeepFlavUDS
	bTagDeepJet
	bTagDiscriminatorsForAK4
	btagHbb
	BTAGVARS
	CALOJETVARS
	chEmEF
	chHEF
	config_genjets
	config_recojets
	DEEPJETVARS
	doc
	emf
	float
	GENJETVARS
	hfEmEF
	hfHEF
	int
	muEF
	nanoInfo_genjets
	nanoInfo_recojets
	nConstChHads
	nConstElecs
	nConstHFEMs
	nConstHFHads
	nConstituents
	nConstMuons
	nConstNeuHads
	nConstPhotons
	neEmEF
	neHEF
	nElectrons
	nMuons
	particleNetAK4_B
	particleNetAK4_CvsB
	particleNetAK4_CvsL
	particleNetAK4_G
	particleNetAK4_puIdDisc
	particleNetAK4_QvsG
	PARTICLENETAK4VARS
	PFJETVARS
	precision
	puId_beta
	puId_dR2Mean
	puId_frac01
	puId_frac02
	puId_frac03
	puId_frac04
	puId_jetR
	puId_jetRchg
	puId_majW
	puId_minW
	puId_nCharged
	puId_ptD
	puId_pull
	PUIDVARS
	qgl_axis2
	qgl_mult
	qgl_ptD
	QGLVARS
	rawFactor

Function Documentation

AddBTaggingScores()

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

Store b-tagging scores from various algortihm

Definition at line 366 of file custom_jme_cff.py.

Referenced by SavePatJets().

def AddBTaggingScores(proc, jetTableName=""):
  """
  Store b-tagging scores from various algortihm
  """

  getattr(proc, jetTableName).variables.btagDeepB       = BTAGVARS.btagDeepB
  getattr(proc, jetTableName).variables.btagCSVV2       = BTAGVARS.btagCSVV2
  getattr(proc, jetTableName).variables.btagDeepCvL     = BTAGVARS.btagDeepCvL
  getattr(proc, jetTableName).variables.btagDeepCvB     = BTAGVARS.btagDeepCvB
  getattr(proc, jetTableName).variables.btagDeepFlavB   = DEEPJETVARS.btagDeepFlavB
  getattr(proc, jetTableName).variables.btagDeepFlavCvL = DEEPJETVARS.btagDeepFlavCvL
  getattr(proc, jetTableName).variables.btagDeepFlavCvB = DEEPJETVARS.btagDeepFlavCvB

  return proc

AddDeepJetGluonLQuarkScores()

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

Store DeepJet raw score in jetTable for gluon and light quark

Definition at line 381 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 204 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 = "RUN2UL{}".format("PUPPI" if isPUPPIJet else "CHS")
      ),
    )
  )

  tightJetIdLepVeto = "tightJetIdLepVeto{}".format(jetName)
  setattr(proc, tightJetIdLepVeto, proc.tightJetIdLepVeto.clone(
      src = jetSrc,
      filterParams = proc.tightJetIdLepVeto.filterParams.clone(
        version = "RUN2UL{}".format("PUPPI" if isPUPPIJet else "CHS")
      ),
    )
  )

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

References print(), and SavePatJets().

Referenced by PrepJMECustomNanoAOD().

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 1156 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",
  }
  genJetInfo = genJA.addGenJetCollection(proc, **cfg)

  genJetName         = genJetInfo.jetUpper
  genJetAlgo         = genJetInfo.jetAlgo
  genJetSize         = genJetInfo.jetSize
  genJetSizeNr       = genJetInfo.jetSizeNr
  genJetFinalColl    = "{}{}{}".format(genJetAlgo.upper(), genJetSize, "GenJetsNoNu")
  genJetTablePrefix  = "GenJetAK8ForJEC"
  genJetTableDoc     = "AK8 Gen jets (made with visible genparticles) with pt > 3 GeV. Reclustered for JEC studies."

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

  return proc

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 957 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 1056 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 406 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 392 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 261 of file custom_jme_cff.py.

References PVValHelper.add().

Referenced by ReclusterAK4CHSJets(), 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,
      usePuppi = True if "PUPPI" in jetName.upper() else False
    )
  )
  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 328 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("packedPFCandidatespuppi")

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

AddVariablesForAK4GenJets()

def custom_jme_cff.AddVariablesForAK4GenJets

(

proc

)

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

Referenced by PrepJMECustomNanoAOD().

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

#===========================================================================
#
# Misc. functions
#
#===========================================================================

AddVariablesForAK8PuppiJets()

def custom_jme_cff.AddVariablesForAK8PuppiJets

(

proc

)

Add more variables for AK8 PFPUPPI jets

Definition at line 1022 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.nConstChHads   = Var("?isPFJet()?chargedHadronMultiplicity():-1",int, doc="number of charged hadrons in the jet")
  proc.fatJetTable.variables.nConstNeuHads  = Var("?isPFJet()?neutralHadronMultiplicity():-1",int, doc="number of neutral hadrons in the jet")
  proc.fatJetTable.variables.nConstHFHads   = Var("?isPFJet()?HFHadronMultiplicity():-1", int, doc="number of HF Hadrons in the jet")
  proc.fatJetTable.variables.nConstHFEMs    = Var("?isPFJet()?HFEMMultiplicity():-1", int, doc="number of HF EMs in the jet")
  proc.fatJetTable.variables.nConstMuons    = Var("?isPFJet()?muonMultiplicity():-1", int, doc="number of muons in the jet")
  proc.fatJetTable.variables.nConstElecs    = Var("?isPFJet()?electronMultiplicity():-1", int, doc="number of electrons in the jet")
  proc.fatJetTable.variables.nConstPhotons  = Var("?isPFJet()?photonMultiplicity():-1", int, doc="number of photons in the jet")

  return proc
#******************************************
#
#
# Gen Jets related functions
#
#
#******************************************

PrepJMECustomNanoAOD()

def custom_jme_cff.PrepJMECustomNanoAOD	(		process,
			runOnMC
	)

Definition at line 1215 of file custom_jme_cff.py.

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

Referenced by PrepJMECustomNanoAOD_Data(), and PrepJMECustomNanoAOD_MC().

def PrepJMECustomNanoAOD(process,runOnMC):

  
  process = RemoveAllJetPtCuts(process)

  
  genJA = GenJetAdder()
  if runOnMC:
    
    process = AddVariablesForAK8GenJets(process)
    
    process = AddNewAK8GenJetsForJEC(process, genJA)
    
    process = ReclusterAK4GenJets(process, genJA)
    process = AddVariablesForAK4GenJets(process)
    
    for jetConfig in config_genjets:
      cfg = { k : v for k, v in jetConfig.items() if k != "enabled"}
      genJetInfo = genJA.addGenJetCollection(process, **cfg)
      AddNewGenJets(process, genJetInfo)

  
  recoJA = RecoJetAdder(runOnMC=runOnMC)
  
  process = AddVariablesForAK8PuppiJets(process)
  
  process = AddNewAK8PuppiJetsForJEC(process, recoJA, runOnMC)
  
  process = AddNewAK8CHSJets(process, recoJA, runOnMC)
  
  process = ReclusterAK4CHSJets(process, recoJA, runOnMC)
  
  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

PrepJMECustomNanoAOD_Data()

def custom_jme_cff.PrepJMECustomNanoAOD_Data

(

process

)

Definition at line 1332 of file custom_jme_cff.py.

References PrepJMECustomNanoAOD().

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

PrepJMECustomNanoAOD_MC()

def custom_jme_cff.PrepJMECustomNanoAOD_MC

(

process

)

Definition at line 1327 of file custom_jme_cff.py.

References PrepJMECustomNanoAOD().

def PrepJMECustomNanoAOD_MC(process):
  process = PrepJMECustomNanoAOD(process,runOnMC=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 743 of file custom_jme_cff.py.

References AddPileUpJetIDVars(), 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")

  #
  # Recluster AK4 CHS jets
  #
  cfg = {
    "jet" : "ak4pfchs",
    "inputCollection" : "",
    "genJetsCollection": "AK4GenJetsNoNu",
    "bTagDiscriminators": bTagDiscriminatorsForAK4,
    "minPtFastjet" : 0.,
  }
  recoJetInfo = recoJA.addRecoJetCollection(proc, **cfg)

  jetName = recoJetInfo.jetUpper
  patJetFinalColl = recoJetInfo.patJetFinalCollection

  #
  # Change the input jet source for jetCorrFactorsNano
  # and updatedJets
  #
  proc.jetCorrFactorsNano.src=patJetFinalColl
  proc.updatedJets.jetSource=patJetFinalColl

  #
  # Change pt cut
  #
  finalJetsCut = ""
  if runOnMC:
    finalJetsCut = "(pt >= 8) || ((pt < 8) && (genJetFwdRef().backRef().isNonnull()))"
  else:
    finalJetsCut = "(pt >= 8)"

  proc.finalJets.cut = finalJetsCut
  #
  # Add a minimum pt cut for corrT1METJets.
  #
  proc.corrT1METJetTable.cut = "pt>=8 && pt<15 && abs(eta)<9.9"

  #
  # Jet table cut
  #
  jetTableCut = "" # must not have any cut at the jetTable for AK4 CHS as it has been cross-cleaned
  proc.jetTable.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 >= 8 GeV are stored."
  if runOnMC:
    jetTableDoc += "For jets with pt < 8 GeV, only those matched to AK4 Gen jets are stored."
  proc.jetTable.doc   = jetTableDoc

  proc.jetTable.variables.rawFactor.precision = 10

  #
  # Add variables
  #
  proc.jetTable.variables.hfHEF         = PFJETVARS.hfHEF
  proc.jetTable.variables.hfEmEF        = PFJETVARS.hfEmEF
  proc.jetTable.variables.nConstChHads  = PFJETVARS.nConstChHads
  proc.jetTable.variables.nConstNeuHads = PFJETVARS.nConstNeuHads
  proc.jetTable.variables.nConstHFHads  = PFJETVARS.nConstHFHads
  proc.jetTable.variables.nConstHFEMs   = PFJETVARS.nConstHFEMs
  proc.jetTable.variables.nConstMuons   = PFJETVARS.nConstMuons
  proc.jetTable.variables.nConstElecs   = PFJETVARS.nConstElecs
  proc.jetTable.variables.nConstPhotons = PFJETVARS.nConstPhotons

  #
  # Add charged energy fraction from other primary vertices
  #
  proc.updatedJetsWithUserData.userFloats.chFPV1EF = cms.InputTag("jercVars:chargedFromPV1EnergyFraction")
  proc.updatedJetsWithUserData.userFloats.chFPV2EF = cms.InputTag("jercVars:chargedFromPV2EnergyFraction")
  proc.updatedJetsWithUserData.userFloats.chFPV3EF = cms.InputTag("jercVars:chargedFromPV3EnergyFraction")
  proc.jetTable.variables.chFPV1EF = Var("userFloat('chFPV1EF')", float, doc="charged fromPV==1 Energy Fraction (component of the total charged Energy Fraction).", precision= 6)
  proc.jetTable.variables.chFPV2EF = Var("userFloat('chFPV2EF')", float, doc="charged fromPV==2 Energy Fraction (component of the total charged Energy Fraction).", precision= 6)
  proc.jetTable.variables.chFPV3EF = Var("userFloat('chFPV3EF')", float, doc="charged fromPV==3 Energy Fraction (component of the total charged Energy Fraction).", precision= 6)

  #
  # Add variables for pileup jet ID studies.
  #
  proc = AddPileUpJetIDVars(proc,
    jetName = jetName,
    jetSrc = "updatedJets",
    jetTableName = "jetTable",
    jetTaskName = "jetTask"
  )
  #
  # Add variables for quark guon likelihood tagger studies.
  # Save variables as userFloats and userInts in each jet
  #
  proc.updatedJetsWithUserData.userFloats.qgl_axis2 = cms.InputTag("qgtagger:axis2")
  proc.updatedJetsWithUserData.userFloats.qgl_ptD   = cms.InputTag("qgtagger:ptD")
  proc.updatedJetsWithUserData.userInts.qgl_mult    = cms.InputTag("qgtagger:mult")
  #
  # Save quark gluon likelihood input variables variables
  #
  proc.jetTable.variables.qgl_axis2 =  QGLVARS.qgl_axis2
  proc.jetTable.variables.qgl_ptD   =  QGLVARS.qgl_ptD
  proc.jetTable.variables.qgl_mult  =  QGLVARS.qgl_mult
  #
  # Save standard b-tagging and c-tagging variables
  #
  proc.jetTable.variables.btagDeepB = BTAGVARS.btagDeepB
  proc.jetTable.variables.btagCSVV2 = BTAGVARS.btagCSVV2
  proc.jetTable.variables.btagDeepCvL = BTAGVARS.btagDeepCvL
  proc.jetTable.variables.btagDeepCvB = BTAGVARS.btagDeepCvB
  #
  # Save DeepJet b-tagging and c-tagging variables
  #
  proc.jetTable.variables.btagDeepFlavB    = DEEPJETVARS.btagDeepFlavB
  proc.jetTable.variables.btagDeepFlavCvL  = DEEPJETVARS.btagDeepFlavCvL
  proc.jetTable.variables.btagDeepFlavCvB  = DEEPJETVARS.btagDeepFlavCvB
  #
  # Save DeepJet raw score for gluon and light quarks
  #
  proc.jetTable.variables.btagDeepFlavG   = DEEPJETVARS.btagDeepFlavG
  proc.jetTable.variables.btagDeepFlavUDS = DEEPJETVARS.btagDeepFlavUDS
  proc.jetTable.variables.btagDeepFlavQG  = DEEPJETVARS.btagDeepFlavQG
  #
  # Add ParticleNetAK4 scores
  #
  proc.jetTable.variables.particleNetAK4_B          = PARTICLENETAK4VARS.particleNetAK4_B
  proc.jetTable.variables.particleNetAK4_CvsL       = PARTICLENETAK4VARS.particleNetAK4_CvsL
  proc.jetTable.variables.particleNetAK4_CvsB       = PARTICLENETAK4VARS.particleNetAK4_CvsB
  proc.jetTable.variables.particleNetAK4_QvsG       = PARTICLENETAK4VARS.particleNetAK4_QvsG
  proc.jetTable.variables.particleNetAK4_G          = PARTICLENETAK4VARS.particleNetAK4_G
  proc.jetTable.variables.particleNetAK4_puIdDisc   = PARTICLENETAK4VARS.particleNetAK4_puIdDisc

  #Adding hf shower shape producer to the jet sequence. By default this producer is not automatically rerun at the NANOAOD step
  #The following lines make sure it is.
  hfJetShowerShapeforCustomNanoAOD = "hfJetShowerShapeforCustomNanoAOD"
  setattr(proc, hfJetShowerShapeforCustomNanoAOD, 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
      )
    )
    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 1116 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",
  }
  genJetInfo = genJA.addGenJetCollection(proc, **cfg)

  genJetName      = genJetInfo.jetUpper
  genJetAlgo      = genJetInfo.jetAlgo
  genJetSize      = genJetInfo.jetSize
  genJetSizeNr    = genJetInfo.jetSizeNr
  selectedGenJets = "{}{}{}".format(genJetAlgo.upper(), genJetSize, "GenJetsNoNu")

  #
  # Change jet source to the newly clustered jet collection. Set very low pt cut for jets
  # to be stored in the GenJet Table
  #
  proc.genJetTable.src = selectedGenJets
  proc.genJetTable.cut = "" # No cut specified here. Save all gen jets after clustering
  proc.genJetTable.doc = "AK4 Gen jets (made with visible genparticles) with pt > 3 GeV" # default pt cut after clustering is 3 GeV

  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 575 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.hfHEF         = PFJETVARS.hfHEF
  proc.jetPuppiTable.variables.hfEmEF        = PFJETVARS.hfEmEF
  proc.jetPuppiTable.variables.nConstChHads  = PFJETVARS.nConstChHads
  proc.jetPuppiTable.variables.nConstNeuHads = PFJETVARS.nConstNeuHads
  proc.jetPuppiTable.variables.nConstHFHads  = PFJETVARS.nConstHFHads
  proc.jetPuppiTable.variables.nConstHFEMs   = PFJETVARS.nConstHFEMs
  proc.jetPuppiTable.variables.nConstMuons   = PFJETVARS.nConstMuons
  proc.jetPuppiTable.variables.nConstElecs   = PFJETVARS.nConstElecs
  proc.jetPuppiTable.variables.nConstPhotons = PFJETVARS.nConstPhotons

  #
  # 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 standard b-tagging and c-tagging variables
  #
  proc.jetPuppiTable.variables.btagDeepB = BTAGVARS.btagDeepB
  proc.jetPuppiTable.variables.btagCSVV2 = BTAGVARS.btagCSVV2
  proc.jetPuppiTable.variables.btagDeepCvL = BTAGVARS.btagDeepCvL
  proc.jetPuppiTable.variables.btagDeepCvB = BTAGVARS.btagDeepCvB
  #
  # 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
  #
  # Add ParticleNetAK4 scores
  #
  proc.jetPuppiTable.variables.particleNetAK4_B        = PARTICLENETAK4VARS.particleNetAK4_B
  proc.jetPuppiTable.variables.particleNetAK4_CvsL     = PARTICLENETAK4VARS.particleNetAK4_CvsL
  proc.jetPuppiTable.variables.particleNetAK4_CvsB     = PARTICLENETAK4VARS.particleNetAK4_CvsB
  proc.jetPuppiTable.variables.particleNetAK4_QvsG     = PARTICLENETAK4VARS.particleNetAK4_QvsG
  proc.jetPuppiTable.variables.particleNetAK4_G        = PARTICLENETAK4VARS.particleNetAK4_G
  proc.jetPuppiTable.variables.particleNetAK4_puIdDisc = PARTICLENETAK4VARS.particleNetAK4_puIdDisc

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

RemoveAllJetPtCuts()

def custom_jme_cff.RemoveAllJetPtCuts

(

proc

)

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

Definition at line 1195 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

#===========================================================================
#
# CUSTOMIZATION function
#
#===========================================================================

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 1073 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 433 of file custom_jme_cff.py.

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

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, simpleCandidateFlatTableProducer.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, simpleCandidateFlatTableProducer.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 = Var("partonFlavour()", int, doc="flavour from parton matching"),
        hadronFlavour = Var("hadronFlavour()", int, doc="flavour from hadron ghost clustering"),
        genJetIdx = Var("?genJetFwdRef().backRef().isNonnull()?genJetFwdRef().backRef().key():-1", int, doc="index of matched gen jet"),
      )
    )
  )

  #
  # Define the jet modules 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)

  return proc

Variable Documentation

area

custom_jme_cff.area

Definition at line 127 of file custom_jme_cff.py.

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

bTagCSVV2

custom_jme_cff.bTagCSVV2

Definition at line 23 of file custom_jme_cff.py.

btagCSVV2

custom_jme_cff.btagCSVV2

Definition at line 168 of file custom_jme_cff.py.

btagDDX

custom_jme_cff.btagDDX

Definition at line 36 of file custom_jme_cff.py.

btagDDXV2

custom_jme_cff.btagDDXV2

Definition at line 44 of file custom_jme_cff.py.

btagDeepB

custom_jme_cff.btagDeepB

Definition at line 167 of file custom_jme_cff.py.

bTagDeepCSV

custom_jme_cff.bTagDeepCSV

Definition at line 24 of file custom_jme_cff.py.

btagDeepCvB

custom_jme_cff.btagDeepCvB

Definition at line 170 of file custom_jme_cff.py.

btagDeepCvL

custom_jme_cff.btagDeepCvL

Definition at line 169 of file custom_jme_cff.py.

btagDeepFlavB

custom_jme_cff.btagDeepFlavB

Definition at line 173 of file custom_jme_cff.py.

btagDeepFlavC

custom_jme_cff.btagDeepFlavC

Definition at line 174 of file custom_jme_cff.py.

btagDeepFlavCvB

custom_jme_cff.btagDeepFlavCvB

Definition at line 178 of file custom_jme_cff.py.

btagDeepFlavCvL

custom_jme_cff.btagDeepFlavCvL

Definition at line 177 of file custom_jme_cff.py.

btagDeepFlavG

custom_jme_cff.btagDeepFlavG

Definition at line 175 of file custom_jme_cff.py.

btagDeepFlavQG

custom_jme_cff.btagDeepFlavQG

Definition at line 179 of file custom_jme_cff.py.

btagDeepFlavUDS

custom_jme_cff.btagDeepFlavUDS

Definition at line 176 of file custom_jme_cff.py.

bTagDeepJet

custom_jme_cff.bTagDeepJet

Definition at line 25 of file custom_jme_cff.py.

bTagDiscriminatorsForAK4

custom_jme_cff.bTagDiscriminatorsForAK4

Definition at line 30 of file custom_jme_cff.py.

btagHbb

custom_jme_cff.btagHbb

Definition at line 35 of file custom_jme_cff.py.

BTAGVARS

custom_jme_cff.BTAGVARS

Definition at line 166 of file custom_jme_cff.py.

CALOJETVARS

custom_jme_cff.CALOJETVARS

Definition at line 190 of file custom_jme_cff.py.

chEmEF

custom_jme_cff.chEmEF

Definition at line 130 of file custom_jme_cff.py.

chHEF

custom_jme_cff.chHEF

Definition at line 128 of file custom_jme_cff.py.

config_genjets

custom_jme_cff.config_genjets

Definition at line 56 of file custom_jme_cff.py.

config_recojets

custom_jme_cff.config_recojets

Definition at line 79 of file custom_jme_cff.py.

DEEPJETVARS

custom_jme_cff.DEEPJETVARS

Definition at line 172 of file custom_jme_cff.py.

doc

custom_jme_cff.doc

Definition at line 126 of file custom_jme_cff.py.

emf

custom_jme_cff.emf

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

GENJETVARS

custom_jme_cff.GENJETVARS

Definition at line 122 of file custom_jme_cff.py.

hfEmEF

custom_jme_cff.hfEmEF

Definition at line 134 of file custom_jme_cff.py.

hfHEF

custom_jme_cff.hfHEF

Definition at line 133 of file custom_jme_cff.py.

int

custom_jme_cff.int

Definition at line 138 of file custom_jme_cff.py.

muEF

custom_jme_cff.muEF

Definition at line 132 of file custom_jme_cff.py.

nanoInfo_genjets

custom_jme_cff.nanoInfo_genjets

Definition at line 66 of file custom_jme_cff.py.

nanoInfo_recojets

custom_jme_cff.nanoInfo_recojets

Definition at line 105 of file custom_jme_cff.py.

nConstChHads

custom_jme_cff.nConstChHads

Definition at line 138 of file custom_jme_cff.py.

nConstElecs

custom_jme_cff.nConstElecs

Definition at line 143 of file custom_jme_cff.py.

nConstHFEMs

custom_jme_cff.nConstHFEMs

Definition at line 141 of file custom_jme_cff.py.

nConstHFHads

custom_jme_cff.nConstHFHads

Definition at line 140 of file custom_jme_cff.py.

nConstituents

custom_jme_cff.nConstituents

Definition at line 123 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()().

nConstMuons

custom_jme_cff.nConstMuons

Definition at line 142 of file custom_jme_cff.py.

nConstNeuHads

custom_jme_cff.nConstNeuHads

Definition at line 139 of file custom_jme_cff.py.

nConstPhotons

custom_jme_cff.nConstPhotons

Definition at line 144 of file custom_jme_cff.py.

neEmEF

custom_jme_cff.neEmEF

Definition at line 131 of file custom_jme_cff.py.

neHEF

custom_jme_cff.neHEF

Definition at line 129 of file custom_jme_cff.py.

nElectrons

custom_jme_cff.nElectrons

Definition at line 136 of file custom_jme_cff.py.

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

nMuons

custom_jme_cff.nMuons

Definition at line 135 of file custom_jme_cff.py.

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

particleNetAK4_B

custom_jme_cff.particleNetAK4_B

Definition at line 182 of file custom_jme_cff.py.

particleNetAK4_CvsB

custom_jme_cff.particleNetAK4_CvsB

Definition at line 184 of file custom_jme_cff.py.

particleNetAK4_CvsL

custom_jme_cff.particleNetAK4_CvsL

Definition at line 183 of file custom_jme_cff.py.

particleNetAK4_G

custom_jme_cff.particleNetAK4_G

Definition at line 186 of file custom_jme_cff.py.

particleNetAK4_puIdDisc

custom_jme_cff.particleNetAK4_puIdDisc

Definition at line 187 of file custom_jme_cff.py.

particleNetAK4_QvsG

custom_jme_cff.particleNetAK4_QvsG

Definition at line 185 of file custom_jme_cff.py.

PARTICLENETAK4VARS

custom_jme_cff.PARTICLENETAK4VARS

Definition at line 181 of file custom_jme_cff.py.

PFJETVARS

custom_jme_cff.PFJETVARS

Definition at line 125 of file custom_jme_cff.py.

precision

custom_jme_cff.precision

Definition at line 126 of file custom_jme_cff.py.

puId_beta

custom_jme_cff.puId_beta

Definition at line 155 of file custom_jme_cff.py.

puId_dR2Mean

custom_jme_cff.puId_dR2Mean

Definition at line 147 of file custom_jme_cff.py.

puId_frac01

custom_jme_cff.puId_frac01

Definition at line 150 of file custom_jme_cff.py.

puId_frac02

custom_jme_cff.puId_frac02

Definition at line 151 of file custom_jme_cff.py.

puId_frac03

custom_jme_cff.puId_frac03

Definition at line 152 of file custom_jme_cff.py.

puId_frac04

custom_jme_cff.puId_frac04

Definition at line 153 of file custom_jme_cff.py.

puId_jetR

custom_jme_cff.puId_jetR

Definition at line 157 of file custom_jme_cff.py.

puId_jetRchg

custom_jme_cff.puId_jetRchg

Definition at line 158 of file custom_jme_cff.py.

puId_majW

custom_jme_cff.puId_majW

Definition at line 148 of file custom_jme_cff.py.

puId_minW

custom_jme_cff.puId_minW

Definition at line 149 of file custom_jme_cff.py.

puId_nCharged

custom_jme_cff.puId_nCharged

Definition at line 159 of file custom_jme_cff.py.

puId_ptD

custom_jme_cff.puId_ptD

Definition at line 154 of file custom_jme_cff.py.

puId_pull

custom_jme_cff.puId_pull

Definition at line 156 of file custom_jme_cff.py.

PUIDVARS

custom_jme_cff.PUIDVARS

Definition at line 146 of file custom_jme_cff.py.

qgl_axis2

custom_jme_cff.qgl_axis2

Definition at line 162 of file custom_jme_cff.py.

qgl_mult

custom_jme_cff.qgl_mult

Definition at line 164 of file custom_jme_cff.py.

qgl_ptD

custom_jme_cff.qgl_ptD

Definition at line 163 of file custom_jme_cff.py.

QGLVARS

custom_jme_cff.QGLVARS

Definition at line 161 of file custom_jme_cff.py.

rawFactor

custom_jme_cff.rawFactor

Definition at line 126 of file custom_jme_cff.py.

---

Generated for CMSSW Reference Manual by  1.8.14