custom_jme_cff Namespace Reference

Functions
def	AddBTaggingScores (proc, jetTableName="")
def	AddDeepJetGluonLQuarkScores (proc, jetTableName="")
def	AddJetID (proc, jetName="", jetSrc="", jetTableName="", jetSequenceName="")
def	AddNewAK8CHSJets (proc, recoJA, runOnMC)
def	AddNewAK8GenJetsForJEC (proc, genJA)
def	AddNewAK8PuppiJetsForJEC (proc, recoJA, runOnMC)
def	AddNewGenJets (proc, genJetInfo)
def	AddNewPatJets (proc, recoJetInfo, runOnMC)
def	AddParticleNetAK4Scores (proc, jetTableName="")
def	AddPileUpJetIDVars (proc, jetName="", jetSrc="", jetTableName="", jetSequenceName="")
def	AddQGLTaggerVars (proc, jetName="", jetSrc="", jetTableName="", jetSequenceName="", calculateQGLVars=False)
def	AddVariablesForAK4GenJets (proc)
def	AddVariablesForAK8GenJets (proc)
def	AddVariablesForAK8PuppiJets (proc)
def	PrepJMECustomNanoAOD (process, runOnMC)
def	PrepJMECustomNanoAOD_Data (process)
def	PrepJMECustomNanoAOD_MC (process)
def	ReclusterAK4CHSJets (proc, recoJA, runOnMC)
def	ReclusterAK4GenJets (proc, genJA)
def	RemoveAllJetPtCuts (proc)
def	SaveGenJets (proc, genJetName, genJetAlgo, genJetSizeNr, genJetFinalColl, genJetTablePrefix, genJetTableDoc, runOnMC=False)
def	SavePatJets (proc, jetName, payload, patJetFinalColl, jetTablePrefix, jetTableDoc, doPF, doCalo, ptcut="", doPUIDVar=False, doQGL=False, doBTag=False, runOnMC=False)

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

Function Documentation

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

Store b-tagging scores from various algortihm

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

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

Store DeepJet raw score in jetTable for gluon and light quark

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

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

Setup modules to calculate PF jet ID

Definition at line 217 of file custom_jme_cff.py.

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

Referenced by SavePatJets().

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

  isPUPPIJet = True if "Puppi" in jetName else False
  
  looseJetId = "looseJetId{}".format(jetName)
  setattr(proc, looseJetId, proc.looseJetId.clone(
      src = jetSrc,
      filterParams = proc.looseJetId.filterParams.clone(
        version = "WINTER16"
      ),
    )
  )

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

  for modifier in run2_miniAOD_80XLegacy, run2_nanoAOD_94X2016:
    modifier.toModify(getattr(proc, tightJetId).filterParams, version = "WINTER16" )
    modifier.toModify(getattr(proc, tightJetIdLepVeto).filterParams, version = "WINTER16" )
  for modifier in run2_nanoAOD_94XMiniAODv1, run2_nanoAOD_94XMiniAODv2:
    modifier.toModify(getattr(proc, tightJetId).filterParams, version = "WINTER17{}".format("PUPPI" if isPUPPIJet else ""))
    modifier.toModify(getattr(proc, tightJetIdLepVeto).filterParams, version = "WINTER17{}".format("PUPPI" if isPUPPIJet else ""))
  run2_nanoAOD_102Xv1.toModify(getattr(proc, tightJetId).filterParams, version = "SUMMER18{}".format("PUPPI" if isPUPPIJet else "") )
  run2_nanoAOD_102Xv1.toModify(getattr(proc, tightJetIdLepVeto).filterParams, version = "SUMMER18{}".format("PUPPI" if isPUPPIJet else "") )
  
  #
  # Save variables as userInts in each jet
  # 
  patJetWithUserData = "{}WithUserData".format(jetSrc)
  getattr(proc, patJetWithUserData).userInts.tightId = cms.InputTag(tightJetId)
  getattr(proc, patJetWithUserData).userInts.tightIdLepVeto = cms.InputTag(tightJetIdLepVeto)
  for modifier in run2_miniAOD_80XLegacy, run2_nanoAOD_94X2016:
    modifier.toModify(getattr(proc, patJetWithUserData).userInts, looseId = cms.InputTag(looseJetId))

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


  getattr(proc,jetSequenceName).insert(getattr(proc,jetSequenceName).index(getattr(proc, jetSrc))+1, getattr(proc, tightJetId))
  getattr(proc,jetSequenceName).insert(getattr(proc,jetSequenceName).index(getattr(proc, tightJetId))+1, getattr(proc, tightJetIdLepVeto))
  
  setattr(proc,"_"+jetSequenceName+"_2016", getattr(proc,jetSequenceName).copy())
  getattr(proc,"_"+jetSequenceName+"_2016").insert(getattr(proc, "_"+jetSequenceName+"_2016").index(getattr(proc, tightJetId)), getattr(proc, looseJetId))
  for modifier in run2_miniAOD_80XLegacy, run2_nanoAOD_94X2016:
    modifier.toReplaceWith(getattr(proc,jetSequenceName), getattr(proc, "_"+jetSequenceName+"_2016"))

  return proc

def custom_jme_cff.AddNewAK8CHSJets	(		proc,
			recoJA,
			runOnMC
	)

Store an AK8 CHS jet collection for JEC studies.

Definition at line 789 of file custom_jme_cff.py.

References edm.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           = ""# No need to specify ptcut. Use default in SavePatJets function

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

  return proc

def custom_jme_cff.AddNewAK8GenJetsForJEC	(		proc,
			genJA
	)

Make a separate AK8 Gen jet collection for JEC studies.

Definition at line 953 of file custom_jme_cff.py.

References edm.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

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

References edm.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           = ""# No need to specify ptcut. Use default in SavePatJets function

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

  return proc

def custom_jme_cff.AddNewGenJets	(		proc,
			genJetInfo
	)

Add genJet into custom nanoAOD

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

def custom_jme_cff.AddNewPatJets	(		proc,
			recoJetInfo,
			runOnMC
	)

Add patJet into custom nanoAOD

Definition at line 426 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 ""
  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

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

Store ParticleNetAK4 scores in jetTable

Definition at line 413 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_puIdDisc = PARTICLENETAK4VARS.particleNetAK4_puIdDisc

  return proc

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

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

Definition at line 287 of file custom_jme_cff.py.

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

Referenced by ReclusterAK4CHSJets(), and SavePatJets().

def AddPileUpJetIDVars(proc, jetName="", jetSrc="", jetTableName="", jetSequenceName=""):
  """
  Setup modules to calculate pileup jet ID input variables for PF jet
  """

  #
  # Calculate pileup jet ID variables
  #
  puJetIdVarsCalculator = "puJetIdCalculator{}".format(jetName)
  setattr(proc, puJetIdVarsCalculator, pileupJetIdCalculator.clone(
      jets = jetSrc,
      vertexes  = "offlineSlimmedPrimaryVertices",
      inputIsCorrected = True,
      applyJec  = False,
      usePuppi = True if "Puppi" in jetName else False
    )
  )
  getattr(proc,jetSequenceName).insert(getattr(proc,jetSequenceName).index(getattr(proc, jetSrc))+1, getattr(proc, puJetIdVarsCalculator))

  #
  # Get the variables
  #
  puJetIDVar = "puJetIDVar{}".format(jetName)
  setattr(proc, puJetIDVar, cms.EDProducer("PileupJetIDVarProducer",
      srcJet = cms.InputTag(jetSrc),
      srcPileupJetId = cms.InputTag(puJetIdVarsCalculator)
    )
  )
  getattr(proc,jetSequenceName).insert(getattr(proc,jetSequenceName).index(getattr(proc, puJetIdVarsCalculator))+1, getattr(proc, puJetIDVar))

  #
  # Save variables as userFloats and userInts for each jet
  # 
  patJetWithUserData = "{}WithUserData".format(jetSrc)
  getattr(proc,patJetWithUserData).userFloats.puId_dR2Mean  = cms.InputTag("{}:dR2Mean".format(puJetIDVar))
  getattr(proc,patJetWithUserData).userFloats.puId_majW     = cms.InputTag("{}:majW".format(puJetIDVar))
  getattr(proc,patJetWithUserData).userFloats.puId_minW     = cms.InputTag("{}:minW".format(puJetIDVar))
  getattr(proc,patJetWithUserData).userFloats.puId_frac01   = cms.InputTag("{}:frac01".format(puJetIDVar))
  getattr(proc,patJetWithUserData).userFloats.puId_frac02   = cms.InputTag("{}:frac02".format(puJetIDVar))
  getattr(proc,patJetWithUserData).userFloats.puId_frac03   = cms.InputTag("{}:frac03".format(puJetIDVar))
  getattr(proc,patJetWithUserData).userFloats.puId_frac04   = cms.InputTag("{}:frac04".format(puJetIDVar))
  getattr(proc,patJetWithUserData).userFloats.puId_ptD      = cms.InputTag("{}:ptD".format(puJetIDVar))
  getattr(proc,patJetWithUserData).userFloats.puId_beta     = cms.InputTag("{}:beta".format(puJetIDVar))
  getattr(proc,patJetWithUserData).userFloats.puId_pull     = cms.InputTag("{}:pull".format(puJetIDVar))
  getattr(proc,patJetWithUserData).userFloats.puId_jetR     = cms.InputTag("{}:jetR".format(puJetIDVar))
  getattr(proc,patJetWithUserData).userFloats.puId_jetRchg  = cms.InputTag("{}:jetRchg".format(puJetIDVar))
  getattr(proc,patJetWithUserData).userInts.puId_nCharged   = cms.InputTag("{}:nCharged".format(puJetIDVar))

  #
  # Specfiy variables in the jet table to save in NanoAOD
  #
  getattr(proc,jetTableName).variables.puId_dR2Mean  = PUIDVARS.puId_dR2Mean
  getattr(proc,jetTableName).variables.puId_majW     = PUIDVARS.puId_majW
  getattr(proc,jetTableName).variables.puId_minW     = PUIDVARS.puId_minW
  getattr(proc,jetTableName).variables.puId_frac01   = PUIDVARS.puId_frac01
  getattr(proc,jetTableName).variables.puId_frac02   = PUIDVARS.puId_frac02
  getattr(proc,jetTableName).variables.puId_frac03   = PUIDVARS.puId_frac03
  getattr(proc,jetTableName).variables.puId_frac04   = PUIDVARS.puId_frac04
  getattr(proc,jetTableName).variables.puId_ptD      = PUIDVARS.puId_ptD
  getattr(proc,jetTableName).variables.puId_beta     = PUIDVARS.puId_beta
  getattr(proc,jetTableName).variables.puId_pull     = PUIDVARS.puId_pull
  getattr(proc,jetTableName).variables.puId_jetR     = PUIDVARS.puId_jetR
  getattr(proc,jetTableName).variables.puId_jetRchg  = PUIDVARS.puId_jetRchg
  getattr(proc,jetTableName).variables.puId_nCharged = PUIDVARS.puId_nCharged

  return proc

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

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

Definition at line 354 of file custom_jme_cff.py.

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

Referenced by SavePatJets().

def AddQGLTaggerVars(proc, jetName="", jetSrc="", jetTableName="", jetSequenceName="", calculateQGLVars=False):
  """
  Schedule the QGTagger module to calculate input variables to the QG likelihood
  """

  QGLTagger="qgtagger{}".format(jetName)
  patJetWithUserData="{}WithUserData".format(jetSrc)

  if calculateQGLVars:
    setattr(proc, QGLTagger, qgtagger.clone(
        srcJets = jetSrc
      )
    )

  #
  # Save variables as userFloats and userInts for each jet
  # 
  getattr(proc,patJetWithUserData).userFloats.qgl_axis2 = cms.InputTag(QGLTagger+":axis2")
  getattr(proc,patJetWithUserData).userFloats.qgl_ptD   = cms.InputTag(QGLTagger+":ptD")
  getattr(proc,patJetWithUserData).userInts.qgl_mult    = cms.InputTag(QGLTagger+":mult")

  #
  # Specfiy variables in the jet table to save in NanoAOD
  #
  getattr(proc,jetTableName).variables.qgl_axis2 =  QGLVARS.qgl_axis2
  getattr(proc,jetTableName).variables.qgl_ptD   =  QGLVARS.qgl_ptD
  getattr(proc,jetTableName).variables.qgl_mult  =  QGLVARS.qgl_mult

  if calculateQGLVars:
    getattr(proc,jetSequenceName).insert(getattr(proc,jetSequenceName).index(getattr(proc, jetSrc))+1, getattr(proc, QGLTagger))

  return proc

def custom_jme_cff.AddVariablesForAK4GenJets

(

proc

)

Definition at line 979 of file custom_jme_cff.py.

Referenced by PrepJMECustomNanoAOD().

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

def custom_jme_cff.AddVariablesForAK8GenJets

(

proc

)

Definition at line 983 of file custom_jme_cff.py.

Referenced by PrepJMECustomNanoAOD().

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

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

def custom_jme_cff.AddVariablesForAK8PuppiJets

(

proc

)

Add more variables for AK8 PFPUPPI jets

Definition at line 821 of file custom_jme_cff.py.

References common_cff.Var().

Referenced by PrepJMECustomNanoAOD().

def AddVariablesForAK8PuppiJets(proc):
  """
  Add more variables for AK8 PFPUPPI jets
  """

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

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

def custom_jme_cff.PrepJMECustomNanoAOD	(		process,
			runOnMC
	)

Definition at line 1011 of file custom_jme_cff.py.

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

Referenced by PrepJMECustomNanoAOD_Data(), and PrepJMECustomNanoAOD_MC().

def PrepJMECustomNanoAOD(process,runOnMC):

  ############################################################################
  # Remove all default jet pt cuts from jets_cff.py
  ############################################################################
  process = RemoveAllJetPtCuts(process)

  ###########################################################################
  #
  # Gen-level jets related functions. Only for MC.
  #
  ###########################################################################
  genJA = GenJetAdder()
  if runOnMC:
    ############################################################################
    # Save additional variables for AK8 GEN jets
    ############################################################################
    process = AddVariablesForAK8GenJets(process)
    ############################################################################
    # Recluster AK8 GEN jets
    ############################################################################
    process = AddNewAK8GenJetsForJEC(process, genJA)
    ###########################################################################
    # Recluster AK4 GEN jets
    ###########################################################################
    process = ReclusterAK4GenJets(process, genJA)
    process = AddVariablesForAK4GenJets(process)
    ###########################################################################
    # Add additional GEN jets to NanoAOD
    ###########################################################################
    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)

  ###########################################################################
  #
  # Reco-level jets related functions. For both MC and data.
  #
  ###########################################################################
  recoJA = RecoJetAdder(runOnMC=runOnMC)
  ###########################################################################
  # Save additional variables for AK8Puppi jets
  ###########################################################################
  process = AddVariablesForAK8PuppiJets(process)
  ###########################################################################
  # Build a separate AK8Puppi jet collection for JEC studies
  ###########################################################################
  process = AddNewAK8PuppiJetsForJEC(process, recoJA, runOnMC)
  ###########################################################################
  # Build a AK8CHS jet collection for JEC studies
  ###########################################################################
  process = AddNewAK8CHSJets(process, recoJA, runOnMC)
  ###########################################################################
  # Recluster AK4 CHS jets and replace "slimmedJets"
  ###########################################################################
  process = ReclusterAK4CHSJets(process, recoJA, runOnMC)
  ###########################################################################
  # Add additional Reco jets to NanoAOD
  ###########################################################################
  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)
    
  ###########################################################################
  # Save Maximum of Pt Hat Max
  ###########################################################################
  if runOnMC:
    process.puTable.savePtHatMax = True

  ###########################################################################
  # Save all Parton-Shower weights
  ###########################################################################
  if runOnMC:
    process.genWeightsTable.keepAllPSWeights = True
  
  return process

def custom_jme_cff.PrepJMECustomNanoAOD_Data

(

process

)

Definition at line 1094 of file custom_jme_cff.py.

References PrepJMECustomNanoAOD().

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

def custom_jme_cff.PrepJMECustomNanoAOD_MC

(

process

)

Definition at line 1090 of file custom_jme_cff.py.

References PrepJMECustomNanoAOD().

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

def custom_jme_cff.ReclusterAK4CHSJets	(		proc,
			recoJA,
			runOnMC
	)

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

Definition at line 597 of file custom_jme_cff.py.

References AddPileUpJetIDVars(), edm.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.  
  """
  print("custom_jme_cff::ReclusterAK4CHSJets: Recluster AK4 PF CHS jets")

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

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

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

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

  #
  # Jet table cut
  #
  jetTableCut = "" # must not have any cut at the jetTable for AK4 CHS as it has been cross-cleaned
  proc.jetTable.cut   = jetTableCut
  proc.jetMCTable.cut = jetTableCut

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

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

  #
  # Setup pileup jet ID with 80X training.
  #
  pileupJetId80X = "pileupJetId80X"
  setattr(proc, pileupJetId80X, pileupJetId.clone(
      jets = "updatedJets",
      algos = cms.VPSet(_chsalgos_81x),
      inputIsCorrected = True,
      applyJec = False,
      vertexes = "offlineSlimmedPrimaryVertices"
    )
  )
  proc.jetSequence.insert(proc.jetSequence.index(proc.pileupJetId94X), getattr(proc, pileupJetId80X))

  proc.updatedJetsWithUserData.userInts.puId80XfullId = cms.InputTag('pileupJetId80X:fullId')
  run2_jme_2016.toModify(proc.updatedJetsWithUserData.userFloats, puId80XDisc = cms.InputTag("pileupJetId80X:fullDiscriminant"))

  proc.jetTable.variables.puId = Var("userInt('puId80XfullId')", int, doc="Pilup ID flags with 80X (2016) training")
  run2_jme_2016.toModify(proc.jetTable.variables, puIdDisc = Var("userFloat('puId80XDisc')",float,doc="Pilup ID discriminant with 80X (2016) training",precision=10))

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

  #Adding hf shower shape producer to the jet sequence. By default this producer is not automatically rerun at the NANOAOD step
  #The following lines make sure it is.
  hfJetShowerShapeforCustomNanoAOD = "hfJetShowerShapeforCustomNanoAOD"
  setattr(proc, hfJetShowerShapeforCustomNanoAOD, hfJetShowerShapeforNanoAOD.clone(jets="updatedJets",vertices="offlineSlimmedPrimaryVertices") )
  proc.jetSequence.insert(proc.jetSequence.index(proc.updatedJetsWithUserData), getattr(proc, hfJetShowerShapeforCustomNanoAOD))
  proc.updatedJetsWithUserData.userFloats.hfsigmaEtaEta = cms.InputTag('hfJetShowerShapeforCustomNanoAOD:sigmaEtaEta')
  proc.updatedJetsWithUserData.userFloats.hfsigmaPhiPhi = cms.InputTag('hfJetShowerShapeforCustomNanoAOD:sigmaPhiPhi')
  proc.updatedJetsWithUserData.userInts.hfcentralEtaStripSize = cms.InputTag('hfJetShowerShapeforCustomNanoAOD:centralEtaStripSize')
  proc.updatedJetsWithUserData.userInts.hfadjacentEtaStripsSize = cms.InputTag('hfJetShowerShapeforCustomNanoAOD:adjacentEtaStripsSize')
  proc.jetTable.variables.hfsigmaEtaEta = Var("userFloat('hfsigmaEtaEta')",float,doc="sigmaEtaEta for HF jets (noise discriminating variable)",precision=10)
  proc.jetTable.variables.hfsigmaPhiPhi = Var("userFloat('hfsigmaPhiPhi')",float,doc="sigmaPhiPhi for HF jets (noise discriminating variable)",precision=10)
  proc.jetTable.variables.hfcentralEtaStripSize = Var("userInt('hfcentralEtaStripSize')", int, doc="eta size of the central tower strip in HF (noise discriminating variable) ")
  proc.jetTable.variables.hfadjacentEtaStripsSize = Var("userInt('hfadjacentEtaStripsSize')", int, doc="eta size of the strips next to the central tower strip in HF (noise discriminating variable) ")

  return proc

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

References edm.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

  genJetFlavourAssociationThisJet = "genJet{}FlavourAssociation".format(genJetName)
  setattr(proc, genJetFlavourAssociationThisJet, genJetFlavourAssociation.clone(
      jets           = proc.genJetTable.src,
      jetAlgorithm   = supportedJetAlgos[genJetAlgo],
      rParam         = genJetSizeNr,
    )
  )
  proc.jetMC.insert(proc.jetMC.index(proc.genJetFlavourTable), getattr(proc, genJetFlavourAssociationThisJet))
  return proc

def custom_jme_cff.RemoveAllJetPtCuts

(

proc

)

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

Definition at line 992 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.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
#
#===========================================================================

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 870 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
  """

  genJetTableThisJet = "jet{}Table".format(genJetName)
  setattr(proc, genJetTableThisJet, genJetTable.clone(
      src       = genJetFinalColl,
      cut       = "", # No cut specified here. Save all gen jets after clustering
      name      = genJetTablePrefix,
      doc       = genJetTableDoc,
      variables = GENJETVARS
    )
  )

  genJetFlavourAssociationThisJet = "genJet{}FlavourAssociation".format(genJetName)
  setattr(proc, genJetFlavourAssociationThisJet, genJetFlavourAssociation.clone(
      jets           = getattr(proc,genJetTableThisJet).src,
      jetAlgorithm   = supportedJetAlgos[genJetAlgo],
      rParam         = genJetSizeNr,
    )
  )

  genJetFlavourTableThisJet = "genJet{}FlavourTable".format(genJetName)
  setattr(proc, genJetFlavourTableThisJet, genJetFlavourTable.clone(
      name            = getattr(proc,genJetTableThisJet).name,
      src             = getattr(proc,genJetTableThisJet).src,
      cut             = getattr(proc,genJetTableThisJet).cut,
      jetFlavourInfos = genJetFlavourAssociationThisJet,
    )
  )

  genJetSequenceName = "genJet{}Sequence".format(genJetName)
  setattr(proc, genJetSequenceName, cms.Sequence(
      getattr(proc,genJetTableThisJet)+
      getattr(proc,genJetFlavourAssociationThisJet)+
      getattr(proc,genJetFlavourTableThisJet)
    )
  )
  proc.nanoSequenceMC.insert(proc.nanoSequenceMC.index(proc.jetMC)+1, getattr(proc,genJetSequenceName))

  return proc

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 453 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
  #
  finalJetsCutDefault = "(pt >= 8)"
  if runOnMC:
    finalJetsCutDefault = "(pt >= 8) || ((pt < 8) && (genJetFwdRef().backRef().isNonnull()))"

  finalJetsForTable = "finalJets{}".format(jetName)
  setattr(proc, finalJetsForTable, finalJets.clone(
      src = srcJetsWithUserData,
      cut = ptcut if ptcut != "" else finalJetsCutDefault
    )
  )

  #
  # Save jets in table
  #
  tableContent = PFJETVARS
  if doCalo:
    tableContent = CALOJETVARS

  jetTableCutDefault = "" #Don't apply any cuts for the table.

  jetTableDocDefault = jetTableDoc + " with JECs applied. Jets with pt > 8 GeV are stored."
  if runOnMC:
    jetTableDocDefault += "For jets with pt < 8 GeV, only those matched to gen jets are stored."

  jetTable = "jet{}Table".format(jetName)
  setattr(proc,jetTable, cms.EDProducer("SimpleCandidateFlatTableProducer",
      src = cms.InputTag(finalJetsForTable),
      cut = cms.string(jetTableCutDefault),
      name = cms.string(jetTablePrefix),
      doc  = cms.string(jetTableDocDefault),
      singleton = cms.bool(False), # the number of entries is variable
      extension = cms.bool(False), # this is the main table for the jets
      variables = cms.PSet(tableContent)
    )
  )
  getattr(proc,jetTable).variables.pt.precision=10

  #
  # Save MC-only jet variables in table
  #
  jetMCTable = "jet{}MCTable".format(jetName)
  setattr(proc, jetMCTable, cms.EDProducer("SimpleCandidateFlatTableProducer",
      src = cms.InputTag(finalJetsForTable),
      cut = getattr(proc,jetTable).cut,
      name = cms.string(jetTablePrefix),
      singleton = cms.bool(False),
      extension = cms.bool(True), # this is an extension table
      variables = cms.PSet(
        partonFlavour = Var("partonFlavour()", int, doc="flavour from parton matching"),
        hadronFlavour = Var("hadronFlavour()", int, doc="flavour from hadron ghost clustering"),
        genJetIdx = Var("?genJetFwdRef().backRef().isNonnull()?genJetFwdRef().backRef().key():-1", int, doc="index of matched gen jet"),
      )
    )
  )

  #
  # Define the jet modules sequence first
  #
  jetSequenceName = "jet{}Sequence".format(jetName)
  setattr(proc, jetSequenceName, cms.Sequence(
      getattr(proc,jetCorrFactors)+
      getattr(proc,srcJets)+
      getattr(proc,srcJetsWithUserData)+
      getattr(proc,finalJetsForTable)
    )
  )

  #
  # Define the jet table sequences
  #
  jetTableSequenceName = "jet{}TablesSequence".format(jetName)
  setattr(proc, jetTableSequenceName, cms.Sequence(getattr(proc,jetTable)))

  jetTableSequenceMCName = "jet{}MCTablesSequence".format(jetName)
  setattr(proc, jetTableSequenceMCName, cms.Sequence(getattr(proc,jetMCTable)))
  
  if runOnMC:
    proc.nanoSequenceMC += getattr(proc,jetSequenceName)
    proc.nanoSequenceMC += getattr(proc,jetTableSequenceName)
    proc.nanoSequenceMC += getattr(proc,jetTableSequenceMCName)
  else:
    proc.nanoSequence += getattr(proc,jetSequenceName)
    proc.nanoSequence += getattr(proc,jetTableSequenceName)

  #
  # Schedule plugins to calculate Jet ID, PileUp Jet ID input variables, and Quark-Gluon Likehood input variables.
  #
  if doPF:
    proc = AddJetID(proc, jetName=jetName, jetSrc=srcJets, jetTableName=jetTable, jetSequenceName=jetSequenceName)
    if doPUIDVar:
      proc = AddPileUpJetIDVars(proc, jetName=jetName, jetSrc=srcJets, jetTableName=jetTable, jetSequenceName=jetSequenceName)
    if doQGL:
      proc = AddQGLTaggerVars(proc,jetName=jetName, jetSrc=srcJets, jetTableName=jetTable, jetSequenceName=jetSequenceName, calculateQGLVars=True)
  
  #
  # Save b-tagging algorithm scores. Should only be done for jet collection with b-tagging
  # calculated when reclustered or collection saved with b-tagging info in MiniAOD
  #
  if doBTag:
    AddBTaggingScores(proc,jetTableName=jetTable)
    AddDeepJetGluonLQuarkScores(proc,jetTableName=jetTable)
    AddParticleNetAK4Scores(proc,jetTableName=jetTable)

  return proc

Variable Documentation

custom_jme_cff.area

Definition at line 141 of file custom_jme_cff.py.

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

custom_jme_cff.bTagCSVV2

Definition at line 20 of file custom_jme_cff.py.

custom_jme_cff.btagCSVV2

Definition at line 182 of file custom_jme_cff.py.

custom_jme_cff.btagDDX

Definition at line 34 of file custom_jme_cff.py.

custom_jme_cff.btagDDXV2

Definition at line 42 of file custom_jme_cff.py.

custom_jme_cff.btagDeepB

Definition at line 181 of file custom_jme_cff.py.

custom_jme_cff.bTagDeepCSV

Definition at line 21 of file custom_jme_cff.py.

custom_jme_cff.btagDeepCvB

Definition at line 184 of file custom_jme_cff.py.

custom_jme_cff.btagDeepCvL

Definition at line 183 of file custom_jme_cff.py.

custom_jme_cff.btagDeepFlavB

Definition at line 187 of file custom_jme_cff.py.

custom_jme_cff.btagDeepFlavC

Definition at line 188 of file custom_jme_cff.py.

custom_jme_cff.btagDeepFlavCvB

Definition at line 192 of file custom_jme_cff.py.

custom_jme_cff.btagDeepFlavCvL

Definition at line 191 of file custom_jme_cff.py.

custom_jme_cff.btagDeepFlavG

Definition at line 189 of file custom_jme_cff.py.

custom_jme_cff.btagDeepFlavQG

Definition at line 193 of file custom_jme_cff.py.

custom_jme_cff.btagDeepFlavUDS

Definition at line 190 of file custom_jme_cff.py.

custom_jme_cff.bTagDeepJet

Definition at line 22 of file custom_jme_cff.py.

custom_jme_cff.bTagDiscriminatorsForAK4

Definition at line 28 of file custom_jme_cff.py.

custom_jme_cff.btagHbb

Definition at line 33 of file custom_jme_cff.py.

custom_jme_cff.BTAGVARS

Definition at line 180 of file custom_jme_cff.py.

custom_jme_cff.CALOJETVARS

Definition at line 203 of file custom_jme_cff.py.

custom_jme_cff.chEmEF

Definition at line 144 of file custom_jme_cff.py.

custom_jme_cff.chHEF

Definition at line 142 of file custom_jme_cff.py.

custom_jme_cff.config_genjets

Definition at line 54 of file custom_jme_cff.py.

custom_jme_cff.config_recojets

Definition at line 77 of file custom_jme_cff.py.

custom_jme_cff.DEEPJETVARS

Definition at line 186 of file custom_jme_cff.py.

custom_jme_cff.doc

Definition at line 140 of file custom_jme_cff.py.

custom_jme_cff.emf

Definition at line 206 of file custom_jme_cff.py.

Referenced by CommonHcalNoiseRBXData.CommonHcalNoiseRBXData(), JetIDSelectionFunctor.craft08Cuts(), JetIDSelectionFunctor.fwd09Cuts(), FWGUIManager.setFrom(), and FWGUISubviewArea.undock().

custom_jme_cff.float

Definition at line 140 of file custom_jme_cff.py.

custom_jme_cff.GENJETVARS

Definition at line 136 of file custom_jme_cff.py.

custom_jme_cff.hfEmEF

Definition at line 148 of file custom_jme_cff.py.

custom_jme_cff.hfHEF

Definition at line 147 of file custom_jme_cff.py.

custom_jme_cff.int

Definition at line 152 of file custom_jme_cff.py.

custom_jme_cff.muEF

Definition at line 146 of file custom_jme_cff.py.

custom_jme_cff.nanoInfo_genjets

Definition at line 64 of file custom_jme_cff.py.

custom_jme_cff.nanoInfo_recojets

Definition at line 111 of file custom_jme_cff.py.

custom_jme_cff.nConstChHads

Definition at line 152 of file custom_jme_cff.py.

custom_jme_cff.nConstElecs

Definition at line 157 of file custom_jme_cff.py.

custom_jme_cff.nConstHFEMs

Definition at line 155 of file custom_jme_cff.py.

custom_jme_cff.nConstHFHads

Definition at line 154 of file custom_jme_cff.py.

custom_jme_cff.nConstituents

Definition at line 137 of file custom_jme_cff.py.

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

custom_jme_cff.nConstMuons

Definition at line 156 of file custom_jme_cff.py.

custom_jme_cff.nConstNeuHads

Definition at line 153 of file custom_jme_cff.py.

custom_jme_cff.nConstPhotons

Definition at line 158 of file custom_jme_cff.py.

custom_jme_cff.neEmEF

Definition at line 145 of file custom_jme_cff.py.

custom_jme_cff.neHEF

Definition at line 143 of file custom_jme_cff.py.

custom_jme_cff.nElectrons

Definition at line 150 of file custom_jme_cff.py.

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

custom_jme_cff.nMuons

Definition at line 149 of file custom_jme_cff.py.

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

custom_jme_cff.particleNetAK4_B

Definition at line 196 of file custom_jme_cff.py.

custom_jme_cff.particleNetAK4_CvsB

Definition at line 198 of file custom_jme_cff.py.

custom_jme_cff.particleNetAK4_CvsL

Definition at line 197 of file custom_jme_cff.py.

custom_jme_cff.particleNetAK4_puIdDisc

Definition at line 200 of file custom_jme_cff.py.

custom_jme_cff.particleNetAK4_QvsG

Definition at line 199 of file custom_jme_cff.py.

custom_jme_cff.PARTICLENETAK4VARS

Definition at line 195 of file custom_jme_cff.py.

custom_jme_cff.PFJETVARS

Definition at line 139 of file custom_jme_cff.py.

custom_jme_cff.precision

Definition at line 140 of file custom_jme_cff.py.

custom_jme_cff.puId_beta

Definition at line 169 of file custom_jme_cff.py.

custom_jme_cff.puId_dR2Mean

Definition at line 161 of file custom_jme_cff.py.

custom_jme_cff.puId_frac01

Definition at line 164 of file custom_jme_cff.py.

custom_jme_cff.puId_frac02

Definition at line 165 of file custom_jme_cff.py.

custom_jme_cff.puId_frac03

Definition at line 166 of file custom_jme_cff.py.

custom_jme_cff.puId_frac04

Definition at line 167 of file custom_jme_cff.py.

custom_jme_cff.puId_jetR

Definition at line 171 of file custom_jme_cff.py.

custom_jme_cff.puId_jetRchg

Definition at line 172 of file custom_jme_cff.py.

custom_jme_cff.puId_majW

Definition at line 162 of file custom_jme_cff.py.

custom_jme_cff.puId_minW

Definition at line 163 of file custom_jme_cff.py.

custom_jme_cff.puId_nCharged

Definition at line 173 of file custom_jme_cff.py.

custom_jme_cff.puId_ptD

Definition at line 168 of file custom_jme_cff.py.

custom_jme_cff.puId_pull

Definition at line 170 of file custom_jme_cff.py.

custom_jme_cff.PUIDVARS

Definition at line 160 of file custom_jme_cff.py.

custom_jme_cff.qgl_axis2

Definition at line 176 of file custom_jme_cff.py.

custom_jme_cff.qgl_mult

Definition at line 178 of file custom_jme_cff.py.

custom_jme_cff.qgl_ptD

Definition at line 177 of file custom_jme_cff.py.

custom_jme_cff.QGLVARS

Definition at line 175 of file custom_jme_cff.py.

custom_jme_cff.rawFactor

Definition at line 140 of file custom_jme_cff.py.

---

Generated for CMSSW Reference Manual by  1.8.11