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