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	AddRobustParTAK4Scores (proc, jetTableName="")
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
	btagDDX
	btagDDXV2
	btagDeepB
	bTagDeepCSV
	btagDeepCvB
	btagDeepCvL
	btagDeepFlavB
	btagDeepFlavC
	btagDeepFlavCvB
	btagDeepFlavCvL
	btagDeepFlavG
	btagDeepFlavQG
	btagDeepFlavUDS
	bTagDeepJet
	bTagDiscriminatorsForAK4
	btagHbb
	btagRobustParTAK4B
	btagRobustParTAK4C
	btagRobustParTAK4CvB
	btagRobustParTAK4CvL
	btagRobustParTAK4G
	btagRobustParTAK4QG
	btagRobustParTAK4UDS
	BTAGVARS
	CALOJETVARS
	chEmEF
	chHadMultiplicity
	chHEF
	config_genjets
	config_recojets
	DEEPJETVARS
	doc
	elMultiplicity
	emf
	float
	foo
	GENJETVARS
	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
	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

Function Documentation

AddBTaggingScores()

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

Store b-tagging scores from various algortihm

Definition at line 394 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 413 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 220 of file custom_jme_cff.py.

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

Referenced by SavePatJets().

def AddJetID(proc, jetName="", jetSrc="", jetTableName="", jetTaskName=""):
  """
  Setup modules to calculate PF jet ID
  """

  isPUPPIJet = True if "PUPPI" in jetName.upper() else False

  looseJetId = "looseJetId{}".format(jetName)
  setattr(proc, looseJetId, proc.looseJetId.clone(
      src = jetSrc,
      filterParams = proc.looseJetId.filterParams.clone(
        version = "WINTER16"
      ),
    )
  )

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

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

  run3_jme_Winter22runsBCDEprompt.toModify(
    getattr(proc, tightJetId).filterParams, version = "RUN3WINTER22{}runsBCDEprompt".format("PUPPI" if isPUPPIJet else "CHS")
  ).toModify(
    getattr(proc, tightJetIdLepVeto).filterParams, version = "RUN3WINTER22{}runsBCDEprompt".format("PUPPI" if isPUPPIJet else "CHS")
  )

  (run2_jme_2017 | run2_jme_2018 | run3_nanoAOD_122 | run3_nanoAOD_124).toModify(
    getattr(proc, tightJetId).filterParams, version = "RUN2UL{}".format("PUPPI" if isPUPPIJet else "CHS")
  ).toModify(
    getattr(proc, tightJetIdLepVeto).filterParams, version = "RUN2UL{}".format("PUPPI" if isPUPPIJet else "CHS")
  )

  run2_jme_2016.toModify(
    getattr(proc, tightJetId).filterParams, version = "RUN2UL16{}".format("PUPPI" if isPUPPIJet else "CHS")
  ).toModify(
    getattr(proc, tightJetIdLepVeto).filterParams, version = "RUN2UL16{}".format("PUPPI" if isPUPPIJet else "CHS")
  )

  #
  # Save variables as userInts in each jet
  #
  patJetWithUserData = "{}WithUserData".format(jetSrc)
  getattr(proc, patJetWithUserData).userInts.tightId = cms.InputTag(tightJetId)
  getattr(proc, patJetWithUserData).userInts.tightIdLepVeto = cms.InputTag(tightJetIdLepVeto)

  #
  # Specfiy variables in the jetTable to save in NanoAOD
  #
  getattr(proc, jetTableName).variables.jetId = Var("userInt('tightId')*2+4*userInt('tightIdLepVeto')",int,doc="Jet ID flags bit1 is loose (always false in 2017 since it does not exist), bit2 is tight, bit3 is tightLepVeto")

  getattr(proc,jetTaskName).add(getattr(proc, tightJetId))
  getattr(proc,jetTaskName).add(getattr(proc, tightJetIdLepVeto))

  return proc

AddNewAK8CHSJets()

def custom_jme_cff.AddNewAK8CHSJets	(		proc,
			recoJA,
			runOnMC
	)

Store an AK8 CHS jet collection for JEC studies.

Definition at line 995 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 1162 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 962 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 1061 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 449 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 435 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 289 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 356 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 424 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

AddVariablesForAK4GenJets()

def custom_jme_cff.AddVariablesForAK4GenJets

(

proc

)

Definition at line 1189 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 1193 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 1027 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
#
#
#******************************************

PrepJMECustomNanoAOD()

def custom_jme_cff.PrepJMECustomNanoAOD	(		process,
			runOnMC
	)

Definition at line 1222 of file custom_jme_cff.py.

References 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 = 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 1335 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 1330 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 775 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:
      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
      )
    )
    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 1121 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 619 of file custom_jme_cff.py.

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

Referenced by PrepJMECustomNanoAOD().

def ReclusterAK4PuppiJets(proc, recoJA, runOnMC):
  """
  Recluster AK4 Puppi jets and replace slimmedJetsPuppi
  that is used as default to save AK4 Puppi jets in NanoAODs.
  """
  print("custom_jme_cff::ReclusterAK4PuppiJets: Recluster AK4 PF Puppi jets")

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

  jetName = recoJetInfo.jetUpper
  patJetFinalColl = recoJetInfo.patJetFinalCollection

  #
  # Set the jetID for UL 16 era
  #
  run2_jme_2016.toModify(
    proc.tightJetPuppiId.filterParams, version = "RUN2UL16PUPPI"
  ).toModify(
    proc.tightJetIdLepVeto.filterParams, version = "RUN2UL16PUPPI"
  )

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

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

  proc.finalJetsPuppi.cut = finalJetsPuppiCut
  #
  # Add a minimum pt cut for corrT1METJets.
  #
  proc.corrT1METJetPuppiTable.cut = "pt>=8 && pt<15 && abs(eta)<9.9"

  #
  # Jet table
  #
  # For Run-2 eras, the main AK4 jet collection in NanoAOD is the CHS collection
  run2_nanoAOD_ANY.toModify(
    proc.jetTable, name = "Jet"
  ).toModify(
    # So need to change the table name for AK4 puppi here
    proc.jetPuppiTable,
    name = "JetPuppi",
    src = cms.InputTag("finalJetsPuppi")
  )

  #
  # Jet table documentation
  #
  jetPuppiTableDoc = "AK4 PF Puppi jets with JECs applied. Jets with pt >= 8 GeV are stored."
  if runOnMC:
    jetPuppiTableDoc += "For jets with pt < 8 GeV, only those matched to AK4 Gen jets are stored."
  proc.jetPuppiTable.doc = jetPuppiTableDoc

  proc.jetPuppiTable.variables.rawFactor.precision = 10

  #
  # Add variables
  #
  proc.jetPuppiTable.variables.chHadMultiplicity = PFJETVARS.chHadMultiplicity
  proc.jetPuppiTable.variables.neHadMultiplicity = PFJETVARS.neHadMultiplicity
  proc.jetPuppiTable.variables.hfHadMultiplicity = PFJETVARS.hfHadMultiplicity
  proc.jetPuppiTable.variables.hfEMMultiplicity  = PFJETVARS.hfEMMultiplicity
  proc.jetPuppiTable.variables.muMultiplicity    = PFJETVARS.muMultiplicity
  proc.jetPuppiTable.variables.elMultiplicity    = PFJETVARS.elMultiplicity
  proc.jetPuppiTable.variables.phoMultiplicity   = PFJETVARS.phoMultiplicity

  #
  # Add variables for pileup jet ID studies.
  #

  proc = AddPileUpJetIDVars(proc,
    jetName = jetName,
    jetSrc = "updatedJetsPuppi",
    jetTableName = "jetPuppiTable",
    jetTaskName = "jetPuppiTask"
  )
  #
  # Add variables for quark guon likelihood tagger studies.
  # Save variables as userFloats and userInts in each jet
  #
  proc = AddQGLTaggerVars(proc,
                          jetName = jetName,
                          jetSrc = "updatedJetsPuppi",
                          jetTableName = "jetPuppiTable",
                          jetTaskName = "jetPuppiTask",
                          calculateQGLVars=True
                        )
  #
  # Save DeepJet b-tagging and c-tagging variables
  #
  proc.jetPuppiTable.variables.btagDeepFlavB   = DEEPJETVARS.btagDeepFlavB
  proc.jetPuppiTable.variables.btagDeepFlavCvL = DEEPJETVARS.btagDeepFlavCvL
  proc.jetPuppiTable.variables.btagDeepFlavCvB = DEEPJETVARS.btagDeepFlavCvB
  #
  # Save DeepJet raw score for gluon and light quarks
  #
  proc.jetPuppiTable.variables.btagDeepFlavG   = DEEPJETVARS.btagDeepFlavG
  proc.jetPuppiTable.variables.btagDeepFlavUDS = DEEPJETVARS.btagDeepFlavUDS
  proc.jetPuppiTable.variables.btagDeepFlavQG  = DEEPJETVARS.btagDeepFlavQG
  #
  # Save RobustParTAK4 b-tagging and c-tagging variables
  #
  proc.jetPuppiTable.variables.btagRobustParTAK4B   = ROBUSTPARTAK4VARS.btagRobustParTAK4B
  proc.jetPuppiTable.variables.btagRobustParTAK4CvL = ROBUSTPARTAK4VARS.btagRobustParTAK4CvL
  proc.jetPuppiTable.variables.btagRobustParTAK4CvB = ROBUSTPARTAK4VARS.btagRobustParTAK4CvB

  #
  # 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 1202 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 1078 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 476 of file custom_jme_cff.py.

References AddBTaggingScores(), AddDeepJetGluonLQuarkScores(), AddJetID(), AddParticleNetAK4Scores(), AddPileUpJetIDVars(), AddQGLTaggerVars(), AddRobustParTAK4Scores(), 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)
    AddRobustParTAK4Scores(proc,jetTableName=jetTableName)

  return proc

Variable Documentation

area

custom_jme_cff.area

Definition at line 135 of file custom_jme_cff.py.

Referenced by HGCalWaferType.areaPolygon(), AreaSeededTrackingRegionsProducer.AreaSeededTrackingRegionsProducer(), RPCRecHitValid.bookHistograms(), FWTracksterLayersProxyBuilder.build(), 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(), RPCSimModelTiming.simulateNoise(), RPCSimAverageNoiseEffCls.simulateNoise(), RPCSimAverageNoiseEff.simulateNoise(), RPCSimAsymmetricCls.simulateNoise(), CosmicMuonGenerator.terminate(), and DDI::EllipticalTube.volume().

bTagCSVV2

custom_jme_cff.bTagCSVV2

Definition at line 19 of file custom_jme_cff.py.

btagDDX

custom_jme_cff.btagDDX

Definition at line 44 of file custom_jme_cff.py.

btagDDXV2

custom_jme_cff.btagDDXV2

Definition at line 52 of file custom_jme_cff.py.

btagDeepB

custom_jme_cff.btagDeepB

Definition at line 175 of file custom_jme_cff.py.

bTagDeepCSV

custom_jme_cff.bTagDeepCSV

Definition at line 20 of file custom_jme_cff.py.

btagDeepCvB

custom_jme_cff.btagDeepCvB

Definition at line 177 of file custom_jme_cff.py.

btagDeepCvL

custom_jme_cff.btagDeepCvL

Definition at line 176 of file custom_jme_cff.py.

btagDeepFlavB

custom_jme_cff.btagDeepFlavB

Definition at line 180 of file custom_jme_cff.py.

btagDeepFlavC

custom_jme_cff.btagDeepFlavC

Definition at line 181 of file custom_jme_cff.py.

btagDeepFlavCvB

custom_jme_cff.btagDeepFlavCvB

Definition at line 185 of file custom_jme_cff.py.

btagDeepFlavCvL

custom_jme_cff.btagDeepFlavCvL

Definition at line 184 of file custom_jme_cff.py.

btagDeepFlavG

custom_jme_cff.btagDeepFlavG

Definition at line 182 of file custom_jme_cff.py.

btagDeepFlavQG

custom_jme_cff.btagDeepFlavQG

Definition at line 186 of file custom_jme_cff.py.

btagDeepFlavUDS

custom_jme_cff.btagDeepFlavUDS

Definition at line 183 of file custom_jme_cff.py.

bTagDeepJet

custom_jme_cff.bTagDeepJet

Definition at line 21 of file custom_jme_cff.py.

bTagDiscriminatorsForAK4

custom_jme_cff.bTagDiscriminatorsForAK4

Definition at line 29 of file custom_jme_cff.py.

btagHbb

custom_jme_cff.btagHbb

Definition at line 43 of file custom_jme_cff.py.

btagRobustParTAK4B

custom_jme_cff.btagRobustParTAK4B

Definition at line 189 of file custom_jme_cff.py.

btagRobustParTAK4C

custom_jme_cff.btagRobustParTAK4C

Definition at line 190 of file custom_jme_cff.py.

btagRobustParTAK4CvB

custom_jme_cff.btagRobustParTAK4CvB

Definition at line 194 of file custom_jme_cff.py.

btagRobustParTAK4CvL

custom_jme_cff.btagRobustParTAK4CvL

Definition at line 193 of file custom_jme_cff.py.

btagRobustParTAK4G

custom_jme_cff.btagRobustParTAK4G

Definition at line 191 of file custom_jme_cff.py.

btagRobustParTAK4QG

custom_jme_cff.btagRobustParTAK4QG

Definition at line 195 of file custom_jme_cff.py.

btagRobustParTAK4UDS

custom_jme_cff.btagRobustParTAK4UDS

Definition at line 192 of file custom_jme_cff.py.

BTAGVARS

custom_jme_cff.BTAGVARS

Definition at line 174 of file custom_jme_cff.py.

CALOJETVARS

custom_jme_cff.CALOJETVARS

Definition at line 206 of file custom_jme_cff.py.

chEmEF

custom_jme_cff.chEmEF

Definition at line 138 of file custom_jme_cff.py.

chHadMultiplicity

custom_jme_cff.chHadMultiplicity

Definition at line 146 of file custom_jme_cff.py.

chHEF

custom_jme_cff.chHEF

Definition at line 136 of file custom_jme_cff.py.

config_genjets

custom_jme_cff.config_genjets

Definition at line 64 of file custom_jme_cff.py.

config_recojets

custom_jme_cff.config_recojets

Definition at line 87 of file custom_jme_cff.py.

DEEPJETVARS

custom_jme_cff.DEEPJETVARS

Definition at line 179 of file custom_jme_cff.py.

doc

custom_jme_cff.doc

Definition at line 141 of file custom_jme_cff.py.

elMultiplicity

custom_jme_cff.elMultiplicity

Definition at line 151 of file custom_jme_cff.py.

emf

custom_jme_cff.emf

Definition at line 209 of file custom_jme_cff.py.

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

float

custom_jme_cff.float

Definition at line 141 of file custom_jme_cff.py.

foo

custom_jme_cff.foo

Definition at line 29 of file custom_jme_cff.py.

Referenced by TriggerResultsFilter.beginStream(), FWConvTrackHitsDetailView.build(), FWConvTrackHitsDetailView.camera1Callback(), FWConvTrackHitsDetailView.camera2Callback(), FWConvTrackHitsDetailView.camera3Callback(), mkfit.execTrackerInfoCreatorPlugin(), AlignPCLThresholdPlotHelper::AlignPCLThresholds_DisplayBase< PayloadType >.fill(), AlignPCLThresholdPlotHelper::AlignPCLThresholds_CompareBase< PayloadType, nIOVs, ntags >.fill(), beamSpotPI::DisplayParameters< PayloadType >.fill(), beamSpotPI::DisplayParametersDiff< PayloadType, nIOVs, ntags >.fill(), simBeamSpotPI::DisplayParameters< PayloadType >.fill(), simBeamSpotPI::DisplayParametersDiff< PayloadType, nIOVs, ntags >.fill(), 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().

GENJETVARS

custom_jme_cff.GENJETVARS

Definition at line 130 of file custom_jme_cff.py.

hfEmEF

custom_jme_cff.hfEmEF

Definition at line 142 of file custom_jme_cff.py.

hfEMMultiplicity

custom_jme_cff.hfEMMultiplicity

Definition at line 149 of file custom_jme_cff.py.

hfHadMultiplicity

custom_jme_cff.hfHadMultiplicity

Definition at line 148 of file custom_jme_cff.py.

hfHEF

custom_jme_cff.hfHEF

Definition at line 141 of file custom_jme_cff.py.

muEF

custom_jme_cff.muEF

Definition at line 140 of file custom_jme_cff.py.

muMultiplicity

custom_jme_cff.muMultiplicity

Definition at line 150 of file custom_jme_cff.py.

nanoInfo_genjets

custom_jme_cff.nanoInfo_genjets

Definition at line 74 of file custom_jme_cff.py.

nanoInfo_recojets

custom_jme_cff.nanoInfo_recojets

Definition at line 113 of file custom_jme_cff.py.

nConstituents

custom_jme_cff.nConstituents

Definition at line 131 of file custom_jme_cff.py.

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

neEmEF

custom_jme_cff.neEmEF

Definition at line 139 of file custom_jme_cff.py.

neHadMultiplicity

custom_jme_cff.neHadMultiplicity

Definition at line 147 of file custom_jme_cff.py.

neHEF

custom_jme_cff.neHEF

Definition at line 137 of file custom_jme_cff.py.

nElectrons

custom_jme_cff.nElectrons

Definition at line 144 of file custom_jme_cff.py.

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

nMuons

custom_jme_cff.nMuons

Definition at line 143 of file custom_jme_cff.py.

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

particleNetAK4_B

custom_jme_cff.particleNetAK4_B

Definition at line 198 of file custom_jme_cff.py.

particleNetAK4_CvsB

custom_jme_cff.particleNetAK4_CvsB

Definition at line 200 of file custom_jme_cff.py.

particleNetAK4_CvsL

custom_jme_cff.particleNetAK4_CvsL

Definition at line 199 of file custom_jme_cff.py.

particleNetAK4_G

custom_jme_cff.particleNetAK4_G

Definition at line 202 of file custom_jme_cff.py.

particleNetAK4_puIdDisc

custom_jme_cff.particleNetAK4_puIdDisc

Definition at line 203 of file custom_jme_cff.py.

particleNetAK4_QvsG

custom_jme_cff.particleNetAK4_QvsG

Definition at line 201 of file custom_jme_cff.py.

PARTICLENETAK4VARS

custom_jme_cff.PARTICLENETAK4VARS

Definition at line 197 of file custom_jme_cff.py.

PFJETVARS

custom_jme_cff.PFJETVARS

Definition at line 133 of file custom_jme_cff.py.

phoMultiplicity

custom_jme_cff.phoMultiplicity

Definition at line 152 of file custom_jme_cff.py.

precision

custom_jme_cff.precision

Definition at line 141 of file custom_jme_cff.py.

puId_beta

custom_jme_cff.puId_beta

Definition at line 163 of file custom_jme_cff.py.

puId_dR2Mean

custom_jme_cff.puId_dR2Mean

Definition at line 155 of file custom_jme_cff.py.

puId_frac01

custom_jme_cff.puId_frac01

Definition at line 158 of file custom_jme_cff.py.

puId_frac02

custom_jme_cff.puId_frac02

Definition at line 159 of file custom_jme_cff.py.

puId_frac03

custom_jme_cff.puId_frac03

Definition at line 160 of file custom_jme_cff.py.

puId_frac04

custom_jme_cff.puId_frac04

Definition at line 161 of file custom_jme_cff.py.

puId_jetR

custom_jme_cff.puId_jetR

Definition at line 165 of file custom_jme_cff.py.

puId_jetRchg

custom_jme_cff.puId_jetRchg

Definition at line 166 of file custom_jme_cff.py.

puId_majW

custom_jme_cff.puId_majW

Definition at line 156 of file custom_jme_cff.py.

puId_minW

custom_jme_cff.puId_minW

Definition at line 157 of file custom_jme_cff.py.

puId_nCharged

custom_jme_cff.puId_nCharged

Definition at line 167 of file custom_jme_cff.py.

puId_ptD

custom_jme_cff.puId_ptD

Definition at line 162 of file custom_jme_cff.py.

puId_pull

custom_jme_cff.puId_pull

Definition at line 164 of file custom_jme_cff.py.

PUIDVARS

custom_jme_cff.PUIDVARS

Definition at line 154 of file custom_jme_cff.py.

qgl_axis2

custom_jme_cff.qgl_axis2

Definition at line 170 of file custom_jme_cff.py.

qgl_mult

custom_jme_cff.qgl_mult

Definition at line 172 of file custom_jme_cff.py.

qgl_ptD

custom_jme_cff.qgl_ptD

Definition at line 171 of file custom_jme_cff.py.

QGLVARS

custom_jme_cff.QGLVARS

Definition at line 169 of file custom_jme_cff.py.

rawFactor

custom_jme_cff.rawFactor

Definition at line 134 of file custom_jme_cff.py.

ROBUSTPARTAK4VARS

custom_jme_cff.ROBUSTPARTAK4VARS

Definition at line 188 of file custom_jme_cff.py.

---

Generated for CMSSW Reference Manual by  1.8.14