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 = "SUMMER18{}".format("PUPPI" if isPUPPIJet else "")
),
)
)
tightJetIdLepVeto = "tightJetIdLepVeto{}".format(jetName)
setattr(proc, tightJetIdLepVeto, proc.tightJetIdLepVeto.clone(
src = jetSrc,
filterParams=proc.tightJetIdLepVeto.filterParams.clone(
version = "SUMMER18{}".format("PUPPI" if isPUPPIJet else "")
),
)
)
run2_jme_2016.toModify(getattr(proc, tightJetId) .filterParams, version = "WINTER16" )
run2_jme_2016.toModify(getattr(proc, tightJetIdLepVeto) .filterParams, version = "WINTER16" )
run2_jme_2017.toModify(getattr(proc, tightJetId) .filterParams, version = "WINTER17{}".format("PUPPI" if isPUPPIJet else ""))
run2_jme_2017.toModify(getattr(proc, tightJetIdLepVeto) .filterParams, version = "WINTER17{}".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)
run2_jme_2016.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")
run2_jme_2016.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))
run2_jme_2016.toReplaceWith(getattr(proc,jetSequenceName), getattr(proc, "_"+jetSequenceName+"_2016"))
return proc
def AddQGLTaggerVars(proc):
#
# Save variables as userFloats and userInts
#
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")
#
# Specfiy variables in the jetTable to save in NanoAOD
#
proc.jetTable.variables.qgl_axis2 = Var(
"userFloat('qgl_axis2')",
float,
doc="ellipse minor jet axis (Quark vs Gluon likelihood input variable)",
precision=6)
proc.jetTable.variables.qgl_ptD = Var(
"userFloat('qgl_ptD')",
float,
doc=
"pT-weighted average pT of constituents (Quark vs Gluon likelihood input variable)",
precision=6)
proc.jetTable.variables.qgl_mult = Var(
"userInt('qgl_mult')",
int,
doc=
"PF candidates multiplicity (Quark vs Gluon likelihood input variable)"
)
def nanoTuples_customizeFatJetTable(process, runOnMC, addDeepAK8Probs=False):
if addDeepAK8Probs:
# add DeepAK8 raw scores: nominal
from RecoBTag.ONNXRuntime.pfDeepBoostedJet_cff import _pfDeepBoostedJetTagsProbs
for prob in _pfDeepBoostedJetTagsProbs:
name = prob.split(':')[1]
setattr(
process.fatJetTable.variables, 'deepTag_' + name,
Var("bDiscriminator('%s')" % prob,
float,
doc=prob,
precision=-1))
# add DeepAK8 raw scores: mass decorrelated
from RecoBTag.ONNXRuntime.pfDeepBoostedJet_cff import _pfMassDecorrelatedDeepBoostedJetTagsProbs
for prob in _pfMassDecorrelatedDeepBoostedJetTagsProbs:
name = prob.split(':')[1]
setattr(
process.fatJetTable.variables, 'deepTagMD_' + name,
Var("bDiscriminator('%s')" % prob,
float,
doc=prob,
precision=-1))
if runOnMC:
process.finalGenParticles.select.append(
'keep+ (abs(pdgId) == 6 || abs(pdgId) == 23 || abs(pdgId) == 24 || abs(pdgId) == 25)'
)
return process
def customizeNanoGENFromMini(process):
process.nanogenSequence.insert(0, process.genParticles2HepMCHiggsVtx)
process.nanogenSequence.insert(0, process.genParticles2HepMC)
process.nanogenSequence.insert(0, process.mergedGenParticles)
from Configuration.Eras.Modifier_run2_miniAOD_80XLegacy_cff import run2_miniAOD_80XLegacy
from Configuration.Eras.Modifier_run2_nanoAOD_94X2016_cff import run2_nanoAOD_94X2016
from Configuration.Eras.Modifier_run2_nanoAOD_94XMiniAODv1_cff import run2_nanoAOD_94XMiniAODv1
from Configuration.Eras.Modifier_run2_nanoAOD_94XMiniAODv2_cff import run2_nanoAOD_94XMiniAODv2
from Configuration.Eras.Modifier_run2_nanoAOD_102Xv1_cff import run2_nanoAOD_102Xv1
from Configuration.Eras.Modifier_run2_nanoAOD_92X_cff import run2_nanoAOD_92X
(run2_nanoAOD_92X | run2_miniAOD_80XLegacy | run2_nanoAOD_94X2016 | run2_nanoAOD_94X2016 | \
run2_nanoAOD_94XMiniAODv1 | run2_nanoAOD_94XMiniAODv2 | \
run2_nanoAOD_102Xv1).toReplaceWith(nanogenSequence, nanogenSequence.copyAndExclude([genVertexTable, genVertexT0Table]))
process.metMCTable.src = "slimmedMETs"
process.metMCTable.variables.pt = Var("genMET.pt", float, doc="pt")
process.metMCTable.variables.phi = Var("genMET.phi", float, doc="phi")
process.metMCTable.variables.phi.precision = CandVars.phi.precision
process.rivetProducerHTXS.HepMCCollection = "genParticles2HepMCHiggsVtx:unsmeared"
process.genParticleTable.src = "prunedGenParticles"
process.patJetPartons.particles = "prunedGenParticles"
process.particleLevel.src = "genParticles2HepMC:unsmeared"
process.genJetTable.src = "slimmedGenJets"
process.genJetAK8Table.src = "slimmedGenJetsAK8"
process.tauGenJets.GenParticles = "prunedGenParticles"
process.genVisTaus.srcGenParticles = "prunedGenParticles"
nanoGenCommonCustomize(process)
return process
def addTable(self, proc, recoJetInfo):
currentTasks = []
print("custom_jme_cff::TableRecoJetAdder::addTable: Adding Table for Reco Jet Collection: {}".format(recoJetInfo.jet))
name = nanoInfo_recojets[recoJetInfo.jet]["name"]
doc = nanoInfo_recojets[recoJetInfo.jet]["doc"]
if name in recojetNameInNano:
raise RuntimeError('RecoJet collection name (%s) taken in NanoAOD for %s' %(name, recoJetInfo.jet))
table = "{}Table".format(recoJetInfo.jetTagName)
if recoJetInfo.skipUserData:
if recoJetInfo.doCalo:
tableContents = cms.PSet(
P4Vars,
area = jetTable.variables.area,
rawFactor = jetTable.variables.rawFactor,
emf = Var("emEnergyFraction()", float, doc = "electromagnetic energy fraction", precision = 10),
)
else:
tableContents = cms.PSet(
P4Vars,
area = jetTable.variables.area,
rawFactor = jetTable.variables.rawFactor,
)
elif "puppi" in recoJetInfo.jet:
tableContents = JETVARS.clone(
puppiMultiplicity = Var("userFloat('patPuppiJetSpecificProducer:puppiMultiplicity')",float,doc="Sum of PUPPI weights of particles in the jet", precision= 6),
neutralPuppiMultiplicity = Var("userFloat('patPuppiJetSpecificProducer:neutralPuppiMultiplicity')",float,doc="Sum of PUPPI weights of neutral particles in the jet", precision= 6)
)
else:
tableContents = JETVARS.clone()
updatedJets = "updatedJets{}".format(recoJetInfo.jetTagName)
setattr(proc, table, cms.EDProducer("SimpleCandidateFlatTableProducer",
src = cms.InputTag(updatedJets),
cut = cms.string(""),
name = cms.string(name),
doc = cms.string(doc),
singleton = cms.bool(False),
extension = cms.bool(False),
variables = tableContents,
)
)
currentTasks.append(table)
tightJetIdLepVeto = "tightJetIdLepVeto{}".format(recoJetInfo.jetTagName)
if not recoJetInfo.skipUserData:
altTasks = copy.deepcopy(currentTasks)
for idx, task in enumerate(altTasks):
if task == tightJetIdLepVeto:
altTasks[idx] = looseJetId
for modifier in run2_miniAOD_80XLegacy, run2_nanoAOD_94X2016:
modifier.toReplaceWith(currentTasks, altTasks)
self.main.extend(currentTasks)
def nanoTuples_customizeFatJetTable(process):
# add DeepAK8 raw scores: nominal
from RecoBTag.MXNet.pfDeepBoostedJet_cff import _pfDeepBoostedJetTagsProbs
for prob in _pfDeepBoostedJetTagsProbs:
name = prob.split(':')[1]
setattr(process.fatJetTable.variables, 'deepTag_' + name, Var("bDiscriminator('%s')" % prob, float, doc=prob, precision=-1))
# add DeepAK8 raw scores: mass decorrelated
from RecoBTag.MXNet.pfDeepBoostedJet_cff import _pfMassDecorrelatedDeepBoostedJetTagsProbs
for prob in _pfMassDecorrelatedDeepBoostedJetTagsProbs:
name = prob.split(':')[1]
setattr(process.fatJetTable.variables, 'deepTagMD_' + name, Var("bDiscriminator('%s')" % prob, float, doc=prob, precision=-1))
return process
def AddDeepJetGluonLQuarkScores(proc):
#
# Save DeepJet raw score for gluon and light quark
#
proc.jetTable.variables.btagDeepFlavG = Var(
"bDiscriminator('pfDeepFlavourJetTags:probg')",
float,
doc="DeepFlavour gluon tag raw score",
precision=10)
proc.jetTable.variables.btagDeepFlavUDS = Var(
"bDiscriminator('pfDeepFlavourJetTags:probuds')",
float,
doc="DeepFlavour uds tag raw score",
precision=10)
def nanoTuples_customizeVectexTable(process):
process.vertexTable.dlenMin = -1
process.vertexTable.dlenSigMin = -1
process.svCandidateTable.variables.ntracks = Var("numberOfDaughters()",
int,
doc="number of tracks")
return process
def addFSRphotonNano(process):
addFSRphotonSequence(process, 'slimmedMuons', "FSRPhotonRecovery/FSRPhotons/data/PhotonMVAv9_BDTG800TreesDY.weights.xml")
process.fsrPhotonTable = cms.EDProducer("SimpleCandidateFlatTableProducer",
src = cms.InputTag("FSRRecovery", "selectedFSRphotons"),
cut = cms.string(""), #we should not filter on cross linked collections
name = cms.string("FSRPhoton"),
doc = cms.string("FSR photons"),
singleton = cms.bool(False),
extension = cms.bool(False),
variables = cms.PSet(
P4Vars,
photonMVAIdValue = Var("userFloat('photonMVAIdValue')",float,doc="Photon MVA ID value"),
FSRphotonMVAValue = Var("userFloat('FSRphotonMVAValue')",float,doc="Photon FSR MVA value"),
PFphotonIso03 = Var("userFloat('PFphotonIso03')",float,doc="Isolation"),
)
)
process.FSRphotonSequence += process.fsrPhotonTable
process.fsr_step = cms.Path(process.FSRphotonSequence)
process.schedule.insert(0, process.fsr_step)
def addTable(self, proc, recoJetInfo):
currentTasks = []
print(
"custom_jme_cff::TableRecoJetAdder::addTable: Adding Table for Reco Jet Collection: {}"
.format(recoJetInfo.jet))
name = nanoInfo_recojets[recoJetInfo.jet]["name"]
doc = nanoInfo_recojets[recoJetInfo.jet]["doc"]
if name in recojetNameInNano:
raise RuntimeError(
'RecoJet collection name (%s) taken in NanoAOD for %s' %
(name, recoJetInfo.jet))
table = "{}Table".format(recoJetInfo.jetTagName)
if recoJetInfo.skipUserData:
if recoJetInfo.doCalo:
tableContents = cms.PSet(
P4Vars,
area=jetTable.variables.area,
rawFactor=jetTable.variables.rawFactor,
emf=Var("emEnergyFraction()",
float,
doc="electromagnetic energy fraction",
precision=10),
)
else:
tableContents = cms.PSet(
P4Vars,
area=jetTable.variables.area,
rawFactor=jetTable.variables.rawFactor,
)
else:
tableContents = JETVARS.clone()
updatedJets = "updatedJets{}".format(recoJetInfo.jetTagName)
setattr(
proc, table,
cms.EDProducer(
"SimpleCandidateFlatTableProducer",
src=cms.InputTag(updatedJets),
cut=cms.string(""),
name=cms.string(name),
doc=cms.string(doc),
singleton=cms.bool(False),
extension=cms.bool(False),
variables=tableContents,
))
currentTasks.append(table)
self.main.extend(currentTasks)
def customizeNanoGENFromMini(process):
process.nanoAOD_step.insert(0, process.genParticles2HepMCHiggsVtx)
process.nanoAOD_step.insert(0, process.genParticles2HepMC)
process.nanoAOD_step.insert(0, process.mergedGenParticles)
process.metMCTable.src = "slimmedMETs"
process.metMCTable.variables.pt = Var("genMET.pt", float, doc="pt")
process.metMCTable.variables.phi = Var("genMET.phi", float, doc="phi")
process.metMCTable.variables.phi.precision = CandVars.phi.precision
process.rivetProducerHTXS.HepMCCollection = "genParticles2HepMCHiggsVtx:unsmeared"
process.genParticleTable.src = "prunedGenParticles"
process.patJetPartons.particles = "prunedGenParticles"
process.particleLevel.src = "genParticles2HepMC:unsmeared"
process.genJetTable.src = "slimmedGenJets"
process.genJetAK8Table.src = "slimmedGenJetsAK8"
process.tauGenJets.GenParticles = "prunedGenParticles"
process.genVisTaus.srcGenParticles = "prunedGenParticles"
nanoGenCommonCustomize(process)
return process
def addEScaleSmearing2018(process):
process.calibratedPatElectrons102X = calibratedPatElectrons.clone(
produceCalibratedObjs=False,
correctionFile=cms.string(
"tthAnalysis/NanoAOD/data/ScalesSmearings/Run2018_Step2Closure_CoarseEtaR9Gain_v2"
),
)
run2_nanoAOD_102Xv1.toModify(
process.slimmedElectronsWithUserData.userFloats,
ecalTrkEnergyErrPostCorrNew=cms.InputTag("calibratedPatElectrons102X",
"ecalTrkEnergyErrPostCorr"),
ecalTrkEnergyPreCorrNew=cms.InputTag("calibratedPatElectrons102X",
"ecalTrkEnergyPreCorr"),
ecalTrkEnergyPostCorrNew=cms.InputTag("calibratedPatElectrons102X",
"ecalTrkEnergyPostCorr"),
)
run2_nanoAOD_102Xv1.toModify(
process.electronTable.variables,
pt=Var(
"pt*userFloat('ecalTrkEnergyPostCorrNew')/userFloat('ecalTrkEnergyPreCorrNew')",
float,
precision=-1,
doc="p_{T}"),
energyErr=Var("userFloat('ecalTrkEnergyErrPostCorrNew')",
float,
precision=10,
doc="energy error of the cluster-track combination"),
eCorr=Var(
"userFloat('ecalTrkEnergyPostCorrNew')/userFloat('ecalTrkEnergyPreCorrNew')",
float,
doc="ratio of the calibrated energy/miniaod energy"),
)
_with102XScale_sequence = process.electronSequence.copy()
_with102XScale_sequence.replace(
process.slimmedElectronsWithUserData,
process.calibratedPatElectrons102X +
process.slimmedElectronsWithUserData)
run2_nanoAOD_102Xv1.toReplaceWith(process.electronSequence,
_with102XScale_sequence)
def nanoTuples_customizeVectexTable(process):
process.vertexTable = cms.EDProducer("CustomVertexTableProducer",
pvSrc=cms.InputTag("offlineSlimmedPrimaryVertices"),
goodPvCut=cms.string("!isFake && ndof > 4 && abs(z) <= 24 && position.Rho <= 2"),
svSrc=cms.InputTag("slimmedSecondaryVertices"),
svCut=cms.string(""),
dlenMin=cms.double(0),
dlenSigMin=cms.double(0),
pvName=cms.string("PV"),
svName=cms.string("SV"),
svDoc=cms.string("secondary vertices from IVF algorithm"),
)
process.svCandidateTable.variables.ntracks = Var("numberOfDaughters()", int, doc="number of tracks")
return process
def nanoTuples_customizeMetTable(process):
process.metTable.variables.smearPt = Var(
"shiftedPt('NoShift','Type1Smear')",
float,
doc="JER smeared type-1 met pt",
precision=-1)
process.metTable.variables.smearPhi = Var(
"shiftedPhi('NoShift','Type1Smear')",
float,
doc="JER smeared type-1 met phi",
precision=12)
process.metTable.variables.smearMetJetEnUpDeltaX = Var(
"shiftedPx('JetEnUp','Type1Smear')-shiftedPx('NoShift','Type1Smear')",
float,
doc="Delta (smearMETx_mod-smearMETx) JES Up",
precision=10)
process.metTable.variables.smearMetJetEnUpDeltaY = Var(
"shiftedPy('JetEnUp','Type1Smear')-shiftedPy('NoShift','Type1Smear')",
float,
doc="Delta (smearMETy_mod-smearMETy) JES Up",
precision=10)
process.metTable.variables.smearMetJetResUpDeltaX = Var(
"shiftedPx('JetResUp','Type1Smear')-shiftedPx('NoShift','Type1Smear')",
float,
doc="Delta (smearMETx_mod-smearMETx) JER Up",
precision=10)
process.metTable.variables.smearMetJetResUpDeltaY = Var(
"shiftedPy('JetResUp','Type1Smear')-shiftedPy('NoShift','Type1Smear')",
float,
doc="Delta (smearMETy_mod-smearMETy) JER Up",
precision=10)
process.metTable.variables.smearMetUnclustEnUpDeltaX = Var(
"shiftedPx('UnclusteredEnUp','Type1Smear')-shiftedPx('NoShift','Type1Smear')",
float,
doc="Delta (smearMETx_mod-smearMETx) UnclusteredEn Up",
precision=10)
process.metTable.variables.smearMetUnclustEnUpDeltaY = Var(
"shiftedPy('UnclusteredEnUp','Type1Smear')-shiftedPy('NoShift','Type1Smear')",
float,
doc="Delta (smearMETy_mod-smearMETy) UnclusteredEn Up",
precision=10)
# use the same for metFixEE2017
process.metFixEE2017Table.variables = process.metTable.variables.clone()
return process
def ufloat(expr, precision = -1, doc = ''):
return Var('userFloat("%s")' % expr,
float, precision = precision, doc = doc)
def AddVariablesForAK8PuppiJets(proc):
"""
Add more variables for AK8 PFPUPPI jets
"""
#
# These variables are not stored for AK8PFCHS (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
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
}
recoJetInfo = recoJA.addRecoJetCollection(proc, **cfg)
jetName = recoJetInfo.jetUpper
patJetFinalColl = "selectedUpdatedPatJets{}Final".format(jetName)
#
# Change the input jet source for jetCorrFactorsNano
# and updatedJets
#
proc.jetCorrFactorsNano.src = patJetFinalColl
proc.updatedJets.jetSource = patJetFinalColl
#
# Change pt cut
#
proc.finalJets.cut = "pt > 2"
proc.simpleCleanerTable.jetSel = "pt > 10" # Change this from 15 -> 10
#
# Add variables
#
proc.jetTable.variables.hfHEF = PFJETVARS.hfHEF
proc.jetTable.variables.hfEmEF = PFJETVARS.hfEmEF
proc.jetTable.variables.nConstChHads = PFJETVARS.nConstChHads
proc.jetTable.variables.nConstNeuHads = PFJETVARS.nConstNeuHads
proc.jetTable.variables.nConstHFHads = PFJETVARS.nConstHFHads
proc.jetTable.variables.nConstHFEMs = PFJETVARS.nConstHFEMs
proc.jetTable.variables.nConstMuons = PFJETVARS.nConstMuons
proc.jetTable.variables.nConstElecs = PFJETVARS.nConstElecs
proc.jetTable.variables.nConstPhotons = PFJETVARS.nConstPhotons
proc.jetTable.doc = cms.string(
"AK4 PF CHS Jets with JECs applied, after basic selection (pt > 2)")
#
# 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")
#
# Specfiy variables in the jetTable to save in NanoAOD
#
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 DeepJet raw score for gluon and light quarks
#
proc.jetTable.variables.btagDeepFlavG = DEEPJETVARS.btagDeepFlavG
proc.jetTable.variables.btagDeepFlavUDS = DEEPJETVARS.btagDeepFlavUDS
#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 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
"""
#
# 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
#
finalJetsForTable = "finalJets{}".format(jetName)
setattr(proc, finalJetsForTable,
finalJets.clone(src=srcJetsWithUserData, cut=ptcut))
#
# Save jets in table
#
tableContent = PFJETVARS
if doCalo:
tableContent = CALOJETVARS
jetTable = "jet{}Table".format(jetName)
setattr(
proc,
jetTable,
cms.EDProducer(
"SimpleCandidateFlatTableProducer",
src=cms.InputTag(finalJetsForTable),
cut=cms.string(""), # Don't specify cuts here
name=cms.string(jetTablePrefix),
doc=cms.string(jetTableDoc),
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)
return proc
GENJETVARS = cms.PSet(
P4Vars,
nConstituents=jetTable.variables.nConstituents,
)
PFJETVARS = cms.PSet(
P4Vars,
rawFactor=jetTable.variables.rawFactor,
area=jetTable.variables.area,
chHEF=jetTable.variables.chHEF,
neHEF=jetTable.variables.neHEF,
chEmEF=jetTable.variables.chEmEF,
neEmEF=jetTable.variables.neEmEF,
muEF=jetTable.variables.muEF,
hfHEF=Var("HFHadronEnergyFraction()",
float,
doc="hadronic energy fraction in HF",
precision=6),
hfEmEF=Var("HFEMEnergyFraction()",
float,
doc="electromagnetic energy fraction in HF",
precision=6),
nMuons=jetTable.variables.nMuons,
nElectrons=jetTable.variables.nElectrons,
nConstituents=jetTable.variables.nConstituents,
nConstChHads=Var("chargedHadronMultiplicity()",
int,
doc="number of charged hadrons in the jet"),
nConstNeuHads=Var("neutralHadronMultiplicity()",
int,
doc="number of neutral hadrons in the jet"),
nConstHFHads=Var("HFHadronMultiplicity()",
def add_BTV(process, runOnMC=False, onlyAK4=False, onlyAK8=False, keepInputs=True):
addAK4 = not onlyAK8
addAK8 = not onlyAK4
if addAK4:
process = update_jets_AK4(process)
if addAK8:
process = update_jets_AK8(process)
process = update_jets_AK8_subjet(process)
process.customizeJetTask = cms.Task()
process.schedule.associate(process.customizeJetTask)
CommonVars = cms.PSet(
Proba=Var("bDiscriminator('pfJetProbabilityBJetTags')",
float,
doc="Jet Probability (Usage:BTV)",
precision=10),
nBHadrons=Var("jetFlavourInfo().getbHadrons().size()",
int,
doc="number of b-hadrons"),
nCHadrons=Var("jetFlavourInfo().getcHadrons().size()",
int,
doc="number of c-hadrons"),
btagDeepB_b=Var("bDiscriminator('pfDeepCSVJetTags:probb')",
float,
doc="DeepCSV b tag discriminator",
precision=10),
btagDeepB_bb=Var("bDiscriminator('pfDeepCSVJetTags:probbb')",
float,
doc="DeepCSV bb tag discriminator",
precision=10),
btagDeepL=Var("bDiscriminator('pfDeepCSVJetTags:probudsg')",
float,
doc="DeepCSV light btag discriminator",
precision=10),
)
# AK4
process.customJetExtTable = cms.EDProducer(
"SimpleCandidateFlatTableProducer",
src=jetTable.src,
cut=jetTable.cut,
name=jetTable.name,
doc=jetTable.doc,
singleton=cms.bool(False), # the number of entries is variable
extension=cms.bool(True), # this is the extension table for Jets
variables=cms.PSet(
CommonVars,
get_DeepCSV_vars() if keepInputs else cms.PSet(),
))
# AK8
process.customFatJetExtTable = cms.EDProducer(
"SimpleCandidateFlatTableProducer",
src=fatJetTable.src,
cut=fatJetTable.cut,
name=fatJetTable.name,
doc=fatJetTable.doc,
singleton=cms.bool(False), # the number of entries is variable
extension=cms.bool(True), # this is the extension table for FatJets
variables=cms.PSet(
CommonVars,
cms.PSet(
btagDDBvLV2 = Var("bDiscriminator('pfMassIndependentDeepDoubleBvLV2JetTags:probHbb')",float,doc="DeepDoubleX V2 discriminator for H(Z)->bb vs QCD",precision=10),
btagDDCvLV2 = Var("bDiscriminator('pfMassIndependentDeepDoubleCvLV2JetTags:probHcc')",float,doc="DeepDoubleX V2 discriminator for H(Z)->cc vs QCD",precision=10),
btagDDCvBV2 = Var("bDiscriminator('pfMassIndependentDeepDoubleCvBV2JetTags:probHcc')",float,doc="DeepDoubleX V2 discriminator for H(Z)->cc vs H(Z)->bb",precision=10),
),
get_DDX_vars() if keepInputs else cms.PSet(),
))
# Subjets
process.customSubJetExtTable = cms.EDProducer(
"SimpleCandidateFlatTableProducer",
src=subJetTable.src,
cut=subJetTable.cut,
name=subJetTable.name,
doc=subJetTable.doc,
singleton=cms.bool(False), # the number of entries is variable
extension=cms.bool(True), # this is the extension table for FatJets
variables=cms.PSet(
CommonVars,
btagDeepC = Var("bDiscriminator('pfDeepCSVJetTags:probc')",
float,
doc="DeepCSV charm btag discriminator",
precision=10),
))
process.customSubJetMCExtTable = cms.EDProducer(
"SimpleCandidateFlatTableProducer",
src = subJetTable.src,
cut = subJetTable.cut,
name = subJetTable.name,
doc=subJetTable.doc,
singleton = cms.bool(False),
extension = cms.bool(True),
variables = cms.PSet(
subGenJetAK8Idx = Var("?genJetFwdRef().backRef().isNonnull()?genJetFwdRef().backRef().key():-1",
int,
doc="index of matched gen Sub jet"),
)
)
if addAK4:
process.customizeJetTask.add(process.customJetExtTable)
if addAK8:
process.customizeJetTask.add(process.customFatJetExtTable)
process.customizeJetTask.add(process.customSubJetExtTable)
if runOnMC and addAK8:
process.customizeJetTask.add(process.customSubJetMCExtTable)
return process
def ubool(expr, precision = -1, doc = ''):
return Var('userInt("%s") == 1' % expr, bool, doc = doc)
#post fit all particles vertex
bodies3_fit_mass=ufloat('fitted_mass'),
bodies3_fit_massErr=ufloat('fitted_massErr'),
bodies3_fit_pt=ufloat('fitted_pt'),
bodies3_fit_eta=ufloat('fitted_eta'),
bodies3_fit_phi=ufloat('fitted_phi'),
bodies3_fit_mu1_pt=ufloat('fitted_mu1_pt'),
bodies3_fit_mu1_eta=ufloat('fitted_mu1_eta'),
bodies3_fit_mu1_phi=ufloat('fitted_mu1_phi'),
bodies3_fit_mu2_pt=ufloat('fitted_mu2_pt'),
bodies3_fit_mu2_eta=ufloat('fitted_mu2_eta'),
bodies3_fit_mu2_phi=ufloat('fitted_mu2_phi'),
bodies3_fit_cos2D=ufloat('fitted_cos_theta_2D'),
#2 particles vertex
jpsivtx_chi2=Var('userCand("dilepton").userFloat("sv_chi2")', float),
jpsivtx_svprob=Var('userCand("dilepton").userFloat("sv_prob")', float),
jpsivtx_l_xy=Var('userCand("dilepton").userFloat("l_xy")', float),
jpsivtx_l_xy_unc=Var('userCand("dilepton").userFloat("l_xy_unc")', float),
jpsivtx_vtx_x=Var('userCand("dilepton").userFloat("vtx_x")', float),
jpsivtx_vtx_y=Var('userCand("dilepton").userFloat("vtx_y")', float),
jpsivtx_vtx_z=Var('userCand("dilepton").userFloat("vtx_z")', float),
jpsivtx_vtx_ex=Var('userCand("dilepton").userFloat("vtx_ex")', float),
jpsivtx_vtx_ey=Var('userCand("dilepton").userFloat("vtx_ey")', float),
jpsivtx_vtx_ez=Var('userCand("dilepton").userFloat("vtx_ez")', float),
jpsivtx_cos2D=Var('userCand("dilepton").userFloat("cos_theta_2D")', float),
#post fit 2 particles vertex
jpsivtx_fit_mass=Var('userCand("dilepton").userFloat("fitted_mass")',
float),
jpsivtx_fit_massErr=Var('userCand("dilepton").userFloat("fitted_massErr")',
#
# The reco jet names already exists
# in NanoAOD.
#
recojetNameInNano = ["Jet", "FatJet"]
#
# The gen jet names already exists
# in NanoAOD.
#
genjetNameInNano = ["GenJet", "GenJetAK8"]
JETVARS = cms.PSet(
P4Vars,
HFHEF=Var("HFHadronEnergyFraction()",
float,
doc="energy fraction in forward hadronic calorimeter",
precision=6),
HFEMEF=Var("HFEMEnergyFraction()",
float,
doc="energy fraction in forward EM calorimeter",
precision=6),
area=jetTable.variables.area,
chHEF=jetTable.variables.chHEF,
neHEF=jetTable.variables.neHEF,
chEmEF=jetTable.variables.chEmEF,
neEmEF=jetTable.variables.neEmEF,
muEF=jetTable.variables.muEF,
rawFactor=jetTable.variables.rawFactor,
jetId=jetTable.variables.jetId,
chFPV0EF=jetTable.variables.chFPV0EF,
chFPV1EF=jetTable.variables.chFPV1EF,
def uint(expr, doc = ''):
return Var('userInt("%s")' % expr, int, doc = doc)
def AddPileUpJetIDVars(proc):
print(
"custom_jme_cff::AddPileUpJetIDVars: Recalculate pile-up jet ID variables and save them"
)
#
# Recalculate PUJet ID variables
#
from RecoJets.JetProducers.PileupJetID_cfi import pileupJetIdCalculator
proc.pileupJetIdCalculatorAK4PFCHS = pileupJetIdCalculator.clone(
jets="updatedJets",
vertexes="offlineSlimmedPrimaryVertices",
inputIsCorrected=True,
applyJec=False)
proc.jetSequence.insert(
proc.jetSequence.index(proc.updatedJets) + 1,
proc.pileupJetIdCalculatorAK4PFCHS)
#
# Get the variables
#
proc.puJetVarAK4PFCHS = cms.EDProducer(
"PileupJetIDVarProducer",
srcJet=cms.InputTag("updatedJets"),
srcPileupJetId=cms.InputTag("pileupJetIdCalculatorAK4PFCHS"))
proc.jetSequence.insert(
proc.jetSequence.index(proc.jercVars) + 1, proc.puJetVarAK4PFCHS)
#
# Save variables as userFloats and userInts in each jet
#
proc.updatedJetsWithUserData.userFloats.dR2Mean = cms.InputTag(
"puJetVarAK4PFCHS:dR2Mean")
proc.updatedJetsWithUserData.userFloats.majW = cms.InputTag(
"puJetVarAK4PFCHS:majW")
proc.updatedJetsWithUserData.userFloats.minW = cms.InputTag(
"puJetVarAK4PFCHS:minW")
proc.updatedJetsWithUserData.userFloats.frac01 = cms.InputTag(
"puJetVarAK4PFCHS:frac01")
proc.updatedJetsWithUserData.userFloats.frac02 = cms.InputTag(
"puJetVarAK4PFCHS:frac02")
proc.updatedJetsWithUserData.userFloats.frac03 = cms.InputTag(
"puJetVarAK4PFCHS:frac03")
proc.updatedJetsWithUserData.userFloats.frac04 = cms.InputTag(
"puJetVarAK4PFCHS:frac04")
proc.updatedJetsWithUserData.userFloats.ptD = cms.InputTag(
"puJetVarAK4PFCHS:ptD")
proc.updatedJetsWithUserData.userFloats.beta = cms.InputTag(
"puJetVarAK4PFCHS:beta")
proc.updatedJetsWithUserData.userFloats.pull = cms.InputTag(
"puJetVarAK4PFCHS:pull")
proc.updatedJetsWithUserData.userFloats.jetR = cms.InputTag(
"puJetVarAK4PFCHS:jetR")
proc.updatedJetsWithUserData.userFloats.jetRchg = cms.InputTag(
"puJetVarAK4PFCHS:jetRchg")
proc.updatedJetsWithUserData.userInts.nCharged = cms.InputTag(
"puJetVarAK4PFCHS:nCharged")
#
# Specfiy variables in the jetTable to save in NanoAOD
#
proc.jetTable.variables.dR2Mean = Var(
"userFloat('dR2Mean')",
float,
doc=
"pT^2-weighted average square distance of jet constituents from the jet axis",
precision=6)
proc.jetTable.variables.majW = Var(
"userFloat('majW')",
float,
doc="major axis of jet ellipsoid in eta-phi plane",
precision=6)
proc.jetTable.variables.minW = Var(
"userFloat('minW')",
float,
doc="minor axis of jet ellipsoid in eta-phi plane",
precision=6)
proc.jetTable.variables.frac01 = Var(
"userFloat('frac01')",
float,
doc="frac of constituents' pT contained within dR<0.1",
precision=6)
proc.jetTable.variables.frac02 = Var(
"userFloat('frac02')",
float,
doc="frac of constituents' pT contained within 0.1<dR<0.2",
precision=6)
proc.jetTable.variables.frac03 = Var(
"userFloat('frac03')",
float,
doc="frac of constituents' pT contained within 0.2<dR<0.3",
precision=6)
proc.jetTable.variables.frac04 = Var(
"userFloat('frac04')",
float,
doc="frac of constituents' pT contained within 0.3<dR<0.4",
precision=6)
proc.jetTable.variables.ptD = Var(
"userFloat('ptD')",
float,
doc="pT-weighted average pT of constituents",
precision=6)
proc.jetTable.variables.beta = Var(
"userFloat('beta')",
float,
doc="fraction of pT of charged constituents associated to PV",
precision=6)
proc.jetTable.variables.pull = Var("userFloat('pull')",
float,
doc="magnitude of pull vector",
precision=6)
proc.jetTable.variables.jetR = Var(
"userFloat('jetR')",
float,
doc="fraction of jet pT carried by the leading constituent",
precision=6)
proc.jetTable.variables.jetRchg = Var(
"userFloat('jetRchg')",
float,
doc="fraction of jet pT carried by the leading charged constituent",
precision=6)
proc.jetTable.variables.nCharged = Var(
"userInt('nCharged')", int, doc="number of charged constituents")
def add_BTV(process, runOnMC=False, onlyAK4=False, onlyAK8=False):
addAK4 = not onlyAK8
addAK8 = not onlyAK4
if addAK4:
process = update_jets_AK4(process)
if addAK8:
process = update_jets_AK8(process)
process = update_jets_AK8_subjet(process)
process.customizeJetTask = cms.Task()
process.schedule.associate(process.customizeJetTask)
CommonVars = cms.PSet(
Proba=Var("bDiscriminator('pfJetProbabilityBJetTags')",
float,
doc="Jet Probability (Usage:BTV)",
precision=10),
nBHadrons=Var("jetFlavourInfo().getbHadrons().size()",
int,
doc="number of b-hadrons"),
nCHadrons=Var("jetFlavourInfo().getcHadrons().size()",
int,
doc="number of c-hadrons"),
)
# AK4
process.customJetExtTable = cms.EDProducer(
"SimpleCandidateFlatTableProducer",
src=jetTable.src,
cut=jetTable.cut,
name=jetTable.name,
doc=jetTable.doc,
singleton=cms.bool(False), # the number of entries is variable
extension=cms.bool(True), # this is the extension table for Jets
variables=cms.PSet(
CommonVars,
))
# AK8
process.customFatJetExtTable = cms.EDProducer(
"SimpleCandidateFlatTableProducer",
src=fatJetTable.src,
cut=fatJetTable.cut,
name=fatJetTable.name,
doc=fatJetTable.doc,
singleton=cms.bool(False), # the number of entries is variable
extension=cms.bool(True), # this is the extension table for FatJets
variables=cms.PSet(
CommonVars,
))
# Subjets
process.customSubJetExtTable = cms.EDProducer(
"SimpleCandidateFlatTableProducer",
src=subJetTable.src,
cut=subJetTable.cut,
name=subJetTable.name,
doc=subJetTable.doc,
singleton=cms.bool(False), # the number of entries is variable
extension=cms.bool(True), # this is the extension table for FatJets
variables=cms.PSet(
CommonVars,
# Proba=Var("bDiscriminator('pfJetProbabilityBJetTags')",
# float,
# doc="Jet Probability (Usage:BTV)",
# precision=10),
))
if addAK4:
process.customizeJetTask.add(process.customJetExtTable)
if addAK8:
process.customizeJetTask.add(process.customFatJetExtTable)
process.customizeJetTask.add(process.customSubJetExtTable)
return process
def PrepJMECustomNanoAOD(process, runOnMC):
#
# Additional variables to AK4GenJets
#
process.genJetTable.variables.area = JETVARS.area
#
# Additional variables to AK8GenJets
#
process.genJetAK8Table.variables.area = JETVARS.area
#
# Additional variables for AK4PFCHS
#
process.jetTable.variables.HFHEF = JETVARS.HFHEF
process.jetTable.variables.HFEMEF = JETVARS.HFEMEF
#
# Additional variables to AK8PFPUPPI
#
# These variables are not stored for AK8PFCHS (slimmedJetsAK8)
# in MiniAOD if their pt < 170 GeV. Hence the conditional fill.
#
process.fatJetTable.variables.chHEF = Var(
"?isPFJet()?chargedHadronEnergyFraction():-1",
float,
doc="charged Hadron Energy Fraction",
precision=6)
process.fatJetTable.variables.neHEF = Var(
"?isPFJet()?neutralHadronEnergyFraction():-1",
float,
doc="neutral Hadron Energy Fraction",
precision=6)
process.fatJetTable.variables.chEmEF = Var(
"?isPFJet()?chargedEmEnergyFraction():-1",
float,
doc="charged Electromagnetic Energy Fraction",
precision=6)
process.fatJetTable.variables.neEmEF = Var(
"?isPFJet()?neutralEmEnergyFraction():-1",
float,
doc="neutral Electromagnetic Energy Fraction",
precision=6)
process.fatJetTable.variables.muEF = Var(
"?isPFJet()?muonEnergyFraction():-1",
float,
doc="muon Energy Fraction",
precision=6)
process.fatJetTable.variables.HFHEF = Var(
"?isPFJet()?HFHadronEnergyFraction():-1",
float,
doc="energy fraction in forward hadronic calorimeter",
precision=6)
process.fatJetTable.variables.HFEMEF = Var(
"?isPFJet()?HFEMEnergyFraction():-1",
float,
doc="energy fraction in forward EM calorimeter",
precision=6)
#
#
#
process.jercVarsFatJet = process.jercVars.clone(
srcJet="updatedJetsAK8",
maxDR=0.8,
)
process.jetSequence.insert(
process.jetSequence.index(process.updatedJetsAK8WithUserData),
process.jercVarsFatJet)
process.updatedJetsAK8WithUserData.userFloats = cms.PSet(
chFPV0EF=cms.InputTag("%s:chargedFromPV0EnergyFraction" %
process.jercVarsFatJet.label()),
chFPV1EF=cms.InputTag("%s:chargedFromPV1EnergyFraction" %
process.jercVarsFatJet.label()),
chFPV2EF=cms.InputTag("%s:chargedFromPV2EnergyFraction" %
process.jercVarsFatJet.label()),
chFPV3EF=cms.InputTag("%s:chargedFromPV3EnergyFraction" %
process.jercVarsFatJet.label()),
)
process.fatJetTable.variables.chFPV0EF = JETVARS.chFPV0EF
process.fatJetTable.variables.chFPV1EF = JETVARS.chFPV1EF
process.fatJetTable.variables.chFPV2EF = JETVARS.chFPV2EF
process.fatJetTable.variables.chFPV3EF = JETVARS.chFPV3EF
#
#
#
process.finalJets.cut = "" # 15 -> 10
process.finalJetsAK8.cut = "" # 170 -> 170
process.genJetTable.cut = "" # 10 -> 8
process.genJetFlavourTable.cut = "" # 10 -> 8
process.genJetAK8Table.cut = "" # 100 -> 80
process.genJetAK8FlavourTable.cut = "" # 100 -> 80
#
# Add variables for pileup jet ID studies.
#
AddPileUpJetIDVars(process)
#
# Add variables for quark guon likelihood tagger studies.
#
AddQGLTaggerVars(process)
######################################################################################################################
#
# Add GenJets to NanoAOD
#
genJA = GenJetAdder()
tableGenJA = TableGenJetAdder()
for jetConfig in config_genjets:
cfg = {k: v for k, v in jetConfig.items() if k != "enabled"}
genJetInfo = genJA.addGenJetCollection(process, **cfg)
tableGenJA.addTable(process, genJetInfo)
#
# Add RecoJets to NanoAOD
#
recoJA = RecoJetAdder(runOnMC=runOnMC)
tableRecoJA = TableRecoJetAdder()
for jetConfig in config_recojets:
cfg = {k: v for k, v in jetConfig.items() if k != "enabled"}
recoJetInfo = recoJA.addRecoJetCollection(process, **cfg)
tableRecoJA.addTable(process, recoJetInfo)
if runOnMC:
process.nanoSequenceMC += genJA.getSequence(process)
process.nanoSequenceMC += recoJA.getSequence(process)
process.nanoSequenceMC += tableGenJA.getSequence(process)
process.nanoSequenceMC += tableRecoJA.getSequence(process)
else:
process.nanoSequence += recoJA.getSequence(process)
process.nanoSequence += tableRecoJA.getSequence(process)
return process
def get_DDX_vars():
# retreive 27 jet-level features used in double-b and deep double-x taggers
# defined in arXiv:1712.07158
DDXVars = cms.PSet(
DDX_jetNTracks = Var("tagInfo(\'pfDeepDoubleX\').features().tag_info_features.jetNTracks", int, doc="number of tracks associated with the jet"),
DDX_jetNSecondaryVertices = Var("tagInfo(\'pfDeepDoubleX\').features().tag_info_features.jetNSecondaryVertices", int, doc="number of SVs associated with the jet"),
DDX_tau1_trackEtaRel_0 = Var("tagInfo(\'pfDeepDoubleX\').features().tag_info_features.tau1_trackEtaRel_0", float, doc="1st smallest track pseudorapidity, relative to the jet axis, associated to the 1st N-subjettiness axis", precision=10),
DDX_tau1_trackEtaRel_1 = Var("tagInfo(\'pfDeepDoubleX\').features().tag_info_features.tau1_trackEtaRel_1", float, doc="2nd smallest track pseudorapidity, relative to the jet axis, associated to the 1st N-subjettiness axis", precision=10),
DDX_tau1_trackEtaRel_2 = Var("tagInfo(\'pfDeepDoubleX\').features().tag_info_features.tau1_trackEtaRel_2", float, doc="3rd smallest track pseudorapidity, relative to the jet axis, associated to the 1st N-subjettiness axis", precision=10),
DDX_tau2_trackEtaRel_0 = Var("tagInfo(\'pfDeepDoubleX\').features().tag_info_features.tau2_trackEtaRel_0", float, doc="1st smallest track pseudorapidity, relative to the jet axis, associated to the 2nd N-subjettiness axis", precision=10),
DDX_tau2_trackEtaRel_1 = Var("tagInfo(\'pfDeepDoubleX\').features().tag_info_features.tau2_trackEtaRel_1", float, doc="2nd smallest track pseudorapidity, relative to the jet axis, associated to the 2nd N-subjettiness axis", precision=10),
DDX_tau2_trackEtaRel_3 = Var("tagInfo(\'pfDeepDoubleX\').features().tag_info_features.tau2_trackEtaRel_2", float, doc="3rd smallest track pseudorapidity, relative to the jet axis, associated to the 2nd N-subjettiness axis", precision=10),
DDX_tau1_flightDistance2dSig = Var("tagInfo(\'pfDeepDoubleX\').features().tag_info_features.tau1_flightDistance2dSig", float, doc="transverse distance significance between primary and secondary vertex associated to the 1st N-subjettiness axis", precision=10),
DDX_tau2_flightDistance2dSig = Var("tagInfo(\'pfDeepDoubleX\').features().tag_info_features.tau2_flightDistance2dSig", float, doc="transverse distance significance between primary and secondary vertex associated to the 2nd N-subjettiness axis", precision=10),
DDX_tau1_vertexDeltaR = Var("tagInfo(\'pfDeepDoubleX\').features().tag_info_features.tau1_vertexDeltaR", float, doc="deltaR between the 1st N-subjettiness axis and secondary vertex direction", precision=10),
DDX_tau1_vertexEnergyRatio = Var("tagInfo(\'pfDeepDoubleX\').features().tag_info_features.tau1_vertexEnergyRatio", float, doc="ratio of energy at secondary vertex over total energy associated to the 1st N-subjettiness axis", precision=10),
DDX_tau2_vertexEnergyRatio = Var("tagInfo(\'pfDeepDoubleX\').features().tag_info_features.tau2_vertexEnergyRatio", float, doc="ratio of energy at secondary vertex over total energy associated to the 2nd N-subjettiness axis", precision=10),
DDX_tau1_vertexMass = Var("tagInfo(\'pfDeepDoubleX\').features().tag_info_features.tau1_vertexMass", float, doc="mass of track sum at secondary vertex associated to the 1st N-subjettiness axis", precision=10),
DDX_tau2_vertexMass = Var("tagInfo(\'pfDeepDoubleX\').features().tag_info_features.tau2_vertexMass", float, doc="mass of track sum at secondary vertex associated to the 2nd N-subjettiness axis", precision=10),
DDX_trackSip2dSigAboveBottom_0 = Var("tagInfo(\'pfDeepDoubleX\').features().tag_info_features.trackSip2dSigAboveBottom_0", float, doc="track 2D signed impact parameter significance of 1st track lifting mass above bottom", precision=10),
DDX_trackSip2dSigAboveBottom_1 = Var("tagInfo(\'pfDeepDoubleX\').features().tag_info_features.trackSip2dSigAboveBottom_1", float, doc="track 2D signed impact parameter significance of 2nd track lifting mass above bottom", precision=10),
DDX_trackSip2dSigAboveCharm = Var("tagInfo(\'pfDeepDoubleX\').features().tag_info_features.trackSip2dSigAboveCharm", float, doc="track 2D signed impact parameter significance of 1st track lifting mass above charm", precision=10),
DDX_trackSip3dSig_0 = Var("tagInfo(\'pfDeepDoubleX\').features().tag_info_features.trackSip3dSig_0", float, doc="1st largest track 3D signed impact parameter significance", precision=10),
DDX_tau1_trackSip3dSig_0 = Var("tagInfo(\'pfDeepDoubleX\').features().tag_info_features.tau1_trackSip3dSig_0", float, doc="1st largest track 3D signed impact parameter significance associated to the 1st N-subjettiness axis", precision=10),
DDX_tau1_trackSip3dSig_1 = Var("tagInfo(\'pfDeepDoubleX\').features().tag_info_features.tau1_trackSip3dSig_1", float, doc="2nd largest track 3D signed impact parameter significance associated to the 1st N-subjettiness axis", precision=10),
DDX_trackSip3dSig_1 = Var("tagInfo(\'pfDeepDoubleX\').features().tag_info_features.trackSip3dSig_1", float, doc="2nd largest track 3D signed impact parameter significance", precision=10),
DDX_tau2_trackSip3dSig_0 = Var("tagInfo(\'pfDeepDoubleX\').features().tag_info_features.tau2_trackSip3dSig_0", float, doc="1st largest track 3D signed impact parameter significance associated to the 2nd N-subjettiness axis", precision=10),
DDX_tau2_trackSip3dSig_1 = Var("tagInfo(\'pfDeepDoubleX\').features().tag_info_features.tau2_trackSip3dSig_1", float, doc="2nd largest track 3D signed impact parameter significance associated to the 2nd N-subjettiness axis", precision=10),
DDX_trackSip3dSig_2 = Var("tagInfo(\'pfDeepDoubleX\').features().tag_info_features.trackSip3dSig_2", float, doc="3rd largest track 3D signed impact parameter significance", precision=10),
DDX_trackSip3dSig_3 = Var("tagInfo(\'pfDeepDoubleX\').features().tag_info_features.trackSip3dSig_3", float, doc="4th largest track 3D signed impact parameter significance", precision=10),
DDX_z_ratio = Var("tagInfo(\'pfDeepDoubleX\').features().tag_info_features.z_ratio", float, doc="z = deltaR(SV0,SV1)*pT(SV1)/m(SV0,SV1), defined in Eq. 7 of arXiv:1712.07158", precision=10)
)
return DDXVars
import FWCore.ParameterSet.Config as cms
from PhysicsTools.NanoAOD.common_cff import Var,ExtVar
genVertexTable = cms.EDProducer("SimpleXYZPointFlatTableProducer",
src = cms.InputTag("genParticles:xyz0"),
cut = cms.string(""),
name= cms.string("GenVtx"),
doc = cms.string("Gen vertex"),
singleton = cms.bool(True),
extension = cms.bool(False),
variables = cms.PSet(
x = Var("X", float, doc="gen vertex x", precision=10),
y = Var("Y", float, doc="gen vertex y", precision=10),
z = Var("Z", float, doc="gen vertex z", precision=16),
)
)
genVertexT0Table = cms.EDProducer("GlobalVariablesTableProducer",
name = cms.string("GenVtx"),
extension = cms.bool(True),
variables = cms.PSet(
t0 = ExtVar( cms.InputTag("genParticles:t0"), "float", doc = "gen vertex t0", precision=12),
)
)
genVertexTables = cms.Sequence(genVertexTable+genVertexT0Table)
def get_DeepCSV_vars():
DeepCSVVars = cms.PSet(
# Tagger inputs also include jet pt and eta
# Track based
DeepCSV_trackPtRel_0 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackPtRel\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackPtRel\')[0]:-999", float, doc="track transverse momentum, relative to the jet axis", precision=10),
DeepCSV_trackPtRel_1 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackPtRel\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackPtRel\')[1]:-999", float, doc="track transverse momentum, relative to the jet axis", precision=10),
DeepCSV_trackPtRel_2 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackPtRel\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackPtRel\')[2]:-999", float, doc="track transverse momentum, relative to the jet axis", precision=10),
DeepCSV_trackPtRel_3 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackPtRel\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackPtRel\')[3]:-999", float, doc="track transverse momentum, relative to the jet axis", precision=10),
DeepCSV_trackPtRel_4 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackPtRel\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackPtRel\')[4]:-999", float, doc="track transverse momentum, relative to the jet axis", precision=10),
DeepCSV_trackPtRel_5 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackPtRel\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackPtRel\')[5]:-999", float, doc="track transverse momentum, relative to the jet axis", precision=10),
DeepCSV_trackJetDistVal_0 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackJetDistVal\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackJetDistVal\')[0]:-999", float, doc="minimum track approach distance to jet axis", precision=10),
DeepCSV_trackJetDistVal_1 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackJetDistVal\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackJetDistVal\')[1]:-999", float, doc="minimum track approach distance to jet axis", precision=10),
DeepCSV_trackJetDistVal_2 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackJetDistVal\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackJetDistVal\')[2]:-999", float, doc="minimum track approach distance to jet axis", precision=10),
DeepCSV_trackJetDistVal_3 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackJetDistVal\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackJetDistVal\')[3]:-999", float, doc="minimum track approach distance to jet axis", precision=10),
DeepCSV_trackJetDistVal_4 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackJetDistVal\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackJetDistVal\')[4]:-999", float, doc="minimum track approach distance to jet axis", precision=10),
DeepCSV_trackJetDistVal_5 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackJetDistVal\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackJetDistVal\')[5]:-999", float, doc="minimum track approach distance to jet axis", precision=10),
DeepCSV_trackDeltaR_0 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackDeltaR\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackDeltaR\')[0]:-999", float, doc="track pseudoangular distance from the jet axis", precision=10),
DeepCSV_trackDeltaR_1 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackDeltaR\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackDeltaR\')[1]:-999", float, doc="track pseudoangular distance from the jet axis", precision=10),
DeepCSV_trackDeltaR_2 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackDeltaR\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackDeltaR\')[2]:-999", float, doc="track pseudoangular distance from the jet axis", precision=10),
DeepCSV_trackDeltaR_3 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackDeltaR\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackDeltaR\')[3]:-999", float, doc="track pseudoangular distance from the jet axis", precision=10),
DeepCSV_trackDeltaR_4 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackDeltaR\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackDeltaR\')[4]:-999", float, doc="track pseudoangular distance from the jet axis", precision=10),
DeepCSV_trackDeltaR_5 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackDeltaR\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackDeltaR\')[5]:-999", float, doc="track pseudoangular distance from the jet axis", precision=10),
DeepCSV_trackPtRatio_0 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackPtRatio\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackPtRatio\')[0]:-999", float, doc="track transverse momentum, relative to the jet axis, normalized to its energy", precision=10),
DeepCSV_trackPtRatio_1 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackPtRatio\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackPtRatio\')[1]:-999", float, doc="track transverse momentum, relative to the jet axis, normalized to its energy", precision=10),
DeepCSV_trackPtRatio_2 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackPtRatio\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackPtRatio\')[2]:-999", float, doc="track transverse momentum, relative to the jet axis, normalized to its energy", precision=10),
DeepCSV_trackPtRatio_3 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackPtRatio\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackPtRatio\')[3]:-999", float, doc="track transverse momentum, relative to the jet axis, normalized to its energy", precision=10),
DeepCSV_trackPtRatio_4 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackPtRatio\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackPtRatio\')[4]:-999", float, doc="track transverse momentum, relative to the jet axis, normalized to its energy", precision=10),
DeepCSV_trackPtRatio_5 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackPtRatio\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackPtRatio\')[5]:-999", float, doc="track transverse momentum, relative to the jet axis, normalized to its energy", precision=10),
DeepCSV_trackSip3dSig_0 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackSip3dSig\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackSip3dSig\')[0]:-999", float, doc="track 3D signed impact parameter significance", precision=10),
DeepCSV_trackSip3dSig_1 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackSip3dSig\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackSip3dSig\')[1]:-999", float, doc="track 3D signed impact parameter significance", precision=10),
DeepCSV_trackSip3dSig_2 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackSip3dSig\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackSip3dSig\')[2]:-999", float, doc="track 3D signed impact parameter significance", precision=10),
DeepCSV_trackSip3dSig_3 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackSip3dSig\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackSip3dSig\')[3]:-999", float, doc="track 3D signed impact parameter significance", precision=10),
DeepCSV_trackSip3dSig_4 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackSip3dSig\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackSip3dSig\')[4]:-999", float, doc="track 3D signed impact parameter significance", precision=10),
DeepCSV_trackSip3dSig_5 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackSip3dSig\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackSip3dSig\')[5]:-999", float, doc="track 3D signed impact parameter significance", precision=10),
DeepCSV_trackSip2dSig_0 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackSip2dSig\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackSip2dSig\')[0]:-999", float, doc="track 2D signed impact parameter significance", precision=10),
DeepCSV_trackSip2dSig_1 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackSip2dSig\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackSip2dSig\')[1]:-999", float, doc="track 2D signed impact parameter significance", precision=10),
DeepCSV_trackSip2dSig_2 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackSip2dSig\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackSip2dSig\')[2]:-999", float, doc="track 2D signed impact parameter significance", precision=10),
DeepCSV_trackSip2dSig_3 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackSip2dSig\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackSip2dSig\')[3]:-999", float, doc="track 2D signed impact parameter significance", precision=10),
DeepCSV_trackSip2dSig_4 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackSip2dSig\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackSip2dSig\')[4]:-999", float, doc="track 2D signed impact parameter significance", precision=10),
DeepCSV_trackSip2dSig_5 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackSip2dSig\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackSip2dSig\')[5]:-999", float, doc="track 2D signed impact parameter significance", precision=10),
DeepCSV_trackDecayLenVal_0 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackDecayLenVal\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackDecayLenVal\')[0]:-999", float, doc="track decay length", precision=10),
DeepCSV_trackDecayLenVal_1 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackDecayLenVal\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackDecayLenVal\')[1]:-999", float, doc="track decay length", precision=10),
DeepCSV_trackDecayLenVal_2 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackDecayLenVal\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackDecayLenVal\')[2]:-999", float, doc="track decay length", precision=10),
DeepCSV_trackDecayLenVal_3 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackDecayLenVal\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackDecayLenVal\')[3]:-999", float, doc="track decay length", precision=10),
DeepCSV_trackDecayLenVal_4 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackDecayLenVal\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackDecayLenVal\')[4]:-999", float, doc="track decay length", precision=10),
DeepCSV_trackDecayLenVal_5 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackDecayLenVal\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackDecayLenVal\')[5]:-999", float, doc="track decay length", precision=10),
DeepCSV_trackEtaRel_0 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackEtaRel\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackEtaRel\')[0]:-999", float, doc="track pseudorapidity, relative to the jet axis", precision=10),
DeepCSV_trackEtaRel_1 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackEtaRel\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackEtaRel\')[1]:-999", float, doc="track pseudorapidity, relative to the jet axis", precision=10),
DeepCSV_trackEtaRel_2 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackEtaRel\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackEtaRel\')[2]:-999", float, doc="track pseudorapidity, relative to the jet axis", precision=10),
DeepCSV_trackEtaRel_3 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackEtaRel\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackEtaRel\')[3]:-999", float, doc="track pseudorapidity, relative to the jet axis", precision=10),
# Jet based
DeepCSV_trackJetPt = Var("tagInfo(\'pfDeepCSV\').taggingVariables.get(\'trackJetPt\', -999)", float, doc="track-based jet transverse momentum", precision=10),
DeepCSV_vertexCategory = Var("tagInfo(\'pfDeepCSV\').taggingVariables.get(\'vertexCategory\', -999)", float, doc="category of secondary vertex (Reco, Pseudo, No)", precision=10),
DeepCSV_jetNSecondaryVertices = Var("tagInfo(\'pfDeepCSV\').taggingVariables.get(\'jetNSecondaryVertices\', -999)", int, doc="number of reconstructed possible secondary vertices in jet"),
DeepCSV_jetNSelectedTracks = Var("tagInfo(\'pfDeepCSV\').taggingVariables.get(\'jetNSelectedTracks\', -999)", int, doc="selected tracks in the jet"),
DeepCSV_jetNTracksEtaRel = Var("tagInfo(\'pfDeepCSV\').taggingVariables.get(\'jetNTracksEtaRel\', -999)", int, doc="number of tracks for which etaRel is computed"),
DeepCSV_trackSumJetEtRatio = Var("tagInfo(\'pfDeepCSV\').taggingVariables.get(\'trackSumJetEtRatio\', -999)", float, doc="ratio of track sum transverse energy over jet energy", precision=10),
DeepCSV_trackSumJetDeltaR = Var("tagInfo(\'pfDeepCSV\').taggingVariables.get(\'trackSumJetDeltaR\', -999)", float, doc="pseudoangular distance between jet axis and track fourvector sum", precision=10),
DeepCSV_trackSip2dValAboveCharm = Var("tagInfo(\'pfDeepCSV\').taggingVariables.get(\'trackSip2dValAboveCharm\', -999)", float, doc="track 2D signed impact parameter of first track lifting mass above charm", precision=10),
DeepCSV_trackSip2dSigAboveCharm = Var("tagInfo(\'pfDeepCSV\').taggingVariables.get(\'trackSip2dSigAboveCharm\', -999)", float, doc="track 2D signed impact parameter significance of first track lifting mass above charm", precision=10),
DeepCSV_trackSip3dValAboveCharm = Var("tagInfo(\'pfDeepCSV\').taggingVariables.get(\'trackSip3dValAboveCharm\', -999)", float, doc="track 3D signed impact parameter of first track lifting mass above charm", precision=10),
DeepCSV_trackSip3dSigAboveCharm = Var("tagInfo(\'pfDeepCSV\').taggingVariables.get(\'trackSip3dSigAboveCharm\', -999)", float, doc="track 3D signed impact parameter significance of first track lifting mass above charm", precision=10),
DeepCSV_vertexMass = Var("tagInfo(\'pfDeepCSV\').taggingVariables.get(\'vertexMass\', -999)", float, doc="mass of track sum at secondary vertex", precision=10),
DeepCSV_vertexNTracks = Var("tagInfo(\'pfDeepCSV\').taggingVariables.get(\'vertexNTracks\', -999)", int, doc="number of tracks at secondary vertex"),
DeepCSV_vertexEnergyRatio = Var("tagInfo(\'pfDeepCSV\').taggingVariables.get(\'vertexEnergyRatio\', -999)", float, doc="ratio of energy at secondary vertex over total energy", precision=10),
DeepCSV_vertexJetDeltaR = Var("tagInfo(\'pfDeepCSV\').taggingVariables.get(\'vertexJetDeltaR\', -999)", float, doc="pseudoangular distance between jet axis and secondary vertex direction", precision=10),
DeepCSV_flightDistance2dVal = Var("tagInfo(\'pfDeepCSV\').taggingVariables.get(\'flightDistance2dVal\', -999)", float, doc="transverse distance between primary and secondary vertex", precision=10),
DeepCSV_flightDistance2dSig = Var("tagInfo(\'pfDeepCSV\').taggingVariables.get(\'flightDistance2dSig\', -999)", float, doc="transverse distance significance between primary and secondary vertex", precision=10),
DeepCSV_flightDistance3dVal = Var("tagInfo(\'pfDeepCSV\').taggingVariables.get(\'flightDistance3dVal\', -999)", float, doc="distance between primary and secondary vertex", precision=10),
DeepCSV_flightDistance3dSig = Var("tagInfo(\'pfDeepCSV\').taggingVariables.get(\'flightDistance3dSig\', -999)", float, doc="distance significance between primary and secondary vertex", precision=10),
)
return DeepCSVVars