def _add_deepMET(process):
process.load('RecoMET.METPUSubtraction.deepMETProducer_cfi')
addToProcessAndTask('deepMETsResolutionTune',
process.deepMETProducer.clone(), process, task)
addToProcessAndTask('deepMETsResponseTune',
process.deepMETProducer.clone(), process, task)
process.deepMETsResponseTune.graph_path = 'RecoMET/METPUSubtraction/data/deepmet/deepmet_resp_v1_2018.pb'
from Configuration.Eras.Modifier_phase2_common_cff import phase2_common
phase2_common.toModify(
process.deepMETsResolutionTune,
max_n_pf=12500,
graph_path=
"RecoMET/METPUSubtraction/data/deepmet/deepmet_v1_phase2.pb")
phase2_common.toModify(
process.deepMETsResponseTune,
max_n_pf=12500,
graph_path=
"RecoMET/METPUSubtraction/data/deepmet/deepmet_resp_v1_phase2.pb")
from Configuration.Eras.Modifier_run2_jme_2016_cff import run2_jme_2016
run2_jme_2016.toModify(
process.deepMETsResponseTune,
graph_path=
"RecoMET/METPUSubtraction/data/deepmet/deepmet_resp_v1_2016.pb")
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 miniAOD_customizeCommon(process):
process.patMuons.isoDeposits = cms.PSet()
process.patElectrons.isoDeposits = cms.PSet()
process.patTaus.isoDeposits = cms.PSet()
process.patPhotons.isoDeposits = cms.PSet()
#
process.patMuons.embedTrack = True # used for IDs
process.patMuons.embedCombinedMuon = True # used for IDs
process.patMuons.embedMuonBestTrack = True # used for IDs
process.patMuons.embedStandAloneMuon = True # maybe?
process.patMuons.embedPickyMuon = False # no, use best track
process.patMuons.embedTpfmsMuon = False # no, use best track
process.patMuons.embedDytMuon = False # no, use best track
process.patMuons.addPuppiIsolation = cms.bool(True)
process.patMuons.puppiIsolationChargedHadrons = cms.InputTag(
"muonPUPPIIsolation", "h+-DR040-ThresholdVeto000-ConeVeto000")
process.patMuons.puppiIsolationNeutralHadrons = cms.InputTag(
"muonPUPPIIsolation", "h0-DR040-ThresholdVeto000-ConeVeto001")
process.patMuons.puppiIsolationPhotons = cms.InputTag(
"muonPUPPIIsolation", "gamma-DR040-ThresholdVeto000-ConeVeto001")
process.patMuons.puppiNoLeptonsIsolationChargedHadrons = cms.InputTag(
"muonPUPPINoLeptonsIsolation", "h+-DR040-ThresholdVeto000-ConeVeto000")
process.patMuons.puppiNoLeptonsIsolationNeutralHadrons = cms.InputTag(
"muonPUPPINoLeptonsIsolation", "h0-DR040-ThresholdVeto000-ConeVeto001")
process.patMuons.puppiNoLeptonsIsolationPhotons = cms.InputTag(
"muonPUPPINoLeptonsIsolation",
"gamma-DR040-ThresholdVeto000-ConeVeto001")
process.patMuons.computeMiniIso = True
process.patMuons.computeMuonMVA = True
process.patMuons.computeSoftMuonMVA = True
process.patMuons.addTriggerMatching = True
from Configuration.Eras.Modifier_run2_muon_2016_cff import run2_muon_2016
from Configuration.Eras.Modifier_run2_muon_2017_cff import run2_muon_2017
from Configuration.Eras.Modifier_run2_muon_2018_cff import run2_muon_2018
run2_muon_2016.toModify(
process.patMuons,
effectiveAreaVec=[0.0735, 0.0619, 0.0465, 0.0433, 0.0577])
run2_muon_2017.toModify(
process.patMuons,
effectiveAreaVec=[0.0566, 0.0562, 0.0363, 0.0119, 0.0064])
run2_muon_2018.toModify(
process.patMuons,
effectiveAreaVec=[0.0566, 0.0562, 0.0363, 0.0119, 0.0064])
run2_muon_2016.toModify(
process.patMuons,
mvaTrainingFile=
"RecoMuon/MuonIdentification/data/mu_2016_BDTG.weights.xml")
process.patMuons.computePuppiCombinedIso = True
#
# disable embedding of electron and photon associated objects already stored by the ReducedEGProducer
process.patElectrons.embedGsfElectronCore = False ## process.patElectrons.embed in AOD externally stored gsf electron core
process.patElectrons.embedSuperCluster = False ## process.patElectrons.embed in AOD externally stored supercluster
process.patElectrons.embedPflowSuperCluster = False ## process.patElectrons.embed in AOD externally stored supercluster
process.patElectrons.embedSeedCluster = False ## process.patElectrons.embed in AOD externally stored the electron's seedcluster
process.patElectrons.embedBasicClusters = False ## process.patElectrons.embed in AOD externally stored the electron's basic clusters
process.patElectrons.embedPreshowerClusters = False ## process.patElectrons.embed in AOD externally stored the electron's preshower clusters
process.patElectrons.embedPflowBasicClusters = False ## process.patElectrons.embed in AOD externally stored the electron's pflow basic clusters
process.patElectrons.embedPflowPreshowerClusters = False ## process.patElectrons.embed in AOD externally stored the electron's pflow preshower clusters
process.patElectrons.embedRecHits = False ## process.patElectrons.embed in AOD externally stored the RecHits - can be called from the PATElectronProducer
process.patElectrons.electronSource = cms.InputTag(
"reducedEgamma", "reducedGedGsfElectrons")
process.patElectrons.usePfCandidateMultiMap = True
process.patElectrons.pfCandidateMultiMap = cms.InputTag(
"reducedEgamma", "reducedGsfElectronPfCandMap")
process.patElectrons.electronIDSources = cms.PSet()
from Configuration.Eras.Modifier_run2_miniAOD_80XLegacy_cff import run2_miniAOD_80XLegacy
from Configuration.Eras.Modifier_run2_miniAOD_94XFall17_cff import run2_miniAOD_94XFall17
(run2_miniAOD_80XLegacy | run2_miniAOD_94XFall17).toModify(
process.patElectrons,
addPFClusterIso=True,
ecalPFClusterIsoMap="reducedEgamma:eleEcalPFClusIso",
hcalPFClusterIsoMap="reducedEgamma:eleHcalPFClusIso")
#add puppi isolation in miniAOD
process.patElectrons.addPuppiIsolation = cms.bool(True)
process.patElectrons.puppiIsolationChargedHadrons = cms.InputTag(
"egmElectronPUPPIIsolation", "h+-DR030-BarVeto000-EndVeto001")
process.patElectrons.puppiIsolationNeutralHadrons = cms.InputTag(
"egmElectronPUPPIIsolation", "h0-DR030-BarVeto000-EndVeto000")
process.patElectrons.puppiIsolationPhotons = cms.InputTag(
"egmElectronPUPPIIsolation", "gamma-DR030-BarVeto000-EndVeto008")
process.patElectrons.puppiNoLeptonsIsolationChargedHadrons = cms.InputTag(
"egmElectronPUPPINoLeptonsIsolation", "h+-DR030-BarVeto000-EndVeto001")
process.patElectrons.puppiNoLeptonsIsolationNeutralHadrons = cms.InputTag(
"egmElectronPUPPINoLeptonsIsolation", "h0-DR030-BarVeto000-EndVeto000")
process.patElectrons.puppiNoLeptonsIsolationPhotons = cms.InputTag(
"egmElectronPUPPINoLeptonsIsolation",
"gamma-DR030-BarVeto000-EndVeto008")
process.patElectrons.computeMiniIso = cms.bool(True)
process.elPFIsoDepositChargedPAT.src = cms.InputTag(
"reducedEgamma", "reducedGedGsfElectrons")
process.elPFIsoDepositChargedAllPAT.src = cms.InputTag(
"reducedEgamma", "reducedGedGsfElectrons")
process.elPFIsoDepositNeutralPAT.src = cms.InputTag(
"reducedEgamma", "reducedGedGsfElectrons")
process.elPFIsoDepositGammaPAT.src = cms.InputTag(
"reducedEgamma", "reducedGedGsfElectrons")
process.elPFIsoDepositPUPAT.src = cms.InputTag("reducedEgamma",
"reducedGedGsfElectrons")
#
process.patPhotons.embedSuperCluster = False ## whether to process.patPhotons.embed in AOD externally stored supercluster
process.patPhotons.embedSeedCluster = False ## process.patPhotons.embed in AOD externally stored the photon's seedcluster
process.patPhotons.embedBasicClusters = False ## process.patPhotons.embed in AOD externally stored the photon's basic clusters
process.patPhotons.embedPreshowerClusters = False ## process.patPhotons.embed in AOD externally stored the photon's preshower clusters
process.patPhotons.embedRecHits = False ## process.patPhotons.embed in AOD externally stored the RecHits - can be called from the PATPhotonProducer
#add puppi isolation in miniAOD
process.patPhotons.addPuppiIsolation = cms.bool(True)
process.patPhotons.puppiIsolationChargedHadrons = cms.InputTag(
"egmPhotonPUPPIIsolation", "h+-DR030-")
process.patPhotons.puppiIsolationNeutralHadrons = cms.InputTag(
"egmPhotonPUPPIIsolation", "h0-DR030-")
process.patPhotons.puppiIsolationPhotons = cms.InputTag(
"egmPhotonPUPPIIsolation", "gamma-DR030-")
(run2_miniAOD_80XLegacy | run2_miniAOD_94XFall17).toModify(
process.patPhotons,
addPFClusterIso=True,
ecalPFClusterIsoMap="reducedEgamma:phoEcalPFClusIso",
hcalPFClusterIsoMap="reducedEgamma:phoHcalPFClusIso")
#the 80X legacy customsations are done in ootPhotonProducer for OOT photons
run2_miniAOD_94XFall17.toModify(
process.patOOTPhotons,
addPFClusterIso=True,
ecalPFClusterIsoMap="reducedEgamma:ootPhoEcalPFClusIso",
hcalPFClusterIsoMap="reducedEgamma:ootPhoHcalPFClusIso")
process.patPhotons.photonSource = cms.InputTag("reducedEgamma",
"reducedGedPhotons")
process.patPhotons.electronSource = cms.InputTag("reducedEgamma",
"reducedGedGsfElectrons")
process.phPFIsoDepositChargedPAT.src = cms.InputTag(
"reducedEgamma", "reducedGedPhotons")
process.phPFIsoDepositChargedAllPAT.src = cms.InputTag(
"reducedEgamma", "reducedGedPhotons")
process.phPFIsoDepositNeutralPAT.src = cms.InputTag(
"reducedEgamma", "reducedGedPhotons")
process.phPFIsoDepositGammaPAT.src = cms.InputTag("reducedEgamma",
"reducedGedPhotons")
process.phPFIsoDepositPUPAT.src = cms.InputTag("reducedEgamma",
"reducedGedPhotons")
#
process.patOOTPhotons.photonSource = cms.InputTag("reducedEgamma",
"reducedOOTPhotons")
process.patOOTPhotons.electronSource = cms.InputTag(
"reducedEgamma", "reducedGedGsfElectrons")
#
process.selectedPatJets.cut = cms.string("pt > 10")
process.selectedPatMuons.cut = cms.string(
"pt > 5 || isPFMuon || (pt > 3 && (isGlobalMuon || isStandAloneMuon || numberOfMatches > 0 || muonID('RPCMuLoose')))"
)
from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon
phase2_muon.toModify(
process.selectedPatMuons,
cut=
"pt > 5 || isPFMuon || (pt > 3 && (isGlobalMuon || isStandAloneMuon || numberOfMatches > 0 || muonID('RPCMuLoose') || muonID('ME0MuonArbitrated') || muonID('GEMMuonArbitrated')) )"
)
from Configuration.Eras.Modifier_pp_on_AA_2018_cff import pp_on_AA_2018
from Configuration.Eras.Modifier_pp_on_PbPb_run3_cff import pp_on_PbPb_run3
(pp_on_AA_2018 | pp_on_PbPb_run3).toModify(
process.selectedPatMuons,
cut=
"pt > 5 || isPFMuon || (pt > 1.2 && (isGlobalMuon || isStandAloneMuon) )"
)
process.selectedPatElectrons.cut = cms.string("")
process.selectedPatTaus.cut = cms.string(
"pt > 18. && tauID('decayModeFindingNewDMs')> 0.5")
process.selectedPatPhotons.cut = cms.string("")
from PhysicsTools.PatAlgos.tools.jetTools import addJetCollection
from PhysicsTools.PatAlgos.slimming.applySubstructure_cff import applySubstructure
applySubstructure(process)
#
from PhysicsTools.PatAlgos.tools.trigTools import switchOnTriggerStandAlone
switchOnTriggerStandAlone(process, outputModule='')
process.patTrigger.packTriggerPathNames = cms.bool(True)
#
# apply type I + other PFMEt corrections to pat::MET object
# and estimate systematic uncertainties on MET
from PhysicsTools.PatUtils.tools.runMETCorrectionsAndUncertainties import runMetCorAndUncForMiniAODProduction
runMetCorAndUncForMiniAODProduction(process,
metType="PF",
jetCollUnskimmed="patJets")
#caloMET computation
from PhysicsTools.PatAlgos.tools.metTools import addMETCollection
addMETCollection(process, labelName="patCaloMet", metSource="caloMetM")
#noHF pfMET =========
task = getPatAlgosToolsTask(process)
process.noHFCands = cms.EDFilter(
"GenericPFCandidateSelector",
src=cms.InputTag("particleFlow"),
cut=cms.string("abs(pdgId)!=1 && abs(pdgId)!=2 && abs(eta)<3.0"))
task.add(process.noHFCands)
runMetCorAndUncForMiniAODProduction(
process,
pfCandColl=cms.InputTag("noHFCands"),
recoMetFromPFCs=True, #needed for HF removal
jetSelection="pt>15 && abs(eta)<3.",
postfix="NoHF")
process.load('PhysicsTools.PatAlgos.slimming.slimmedMETs_cfi')
task.add(process.slimmedMETs)
process.slimmedMETs.addDeepMETs = True
addToProcessAndTask('slimmedMETsNoHF', process.slimmedMETs.clone(),
process, task)
process.slimmedMETsNoHF.src = cms.InputTag("patMETsNoHF")
process.slimmedMETsNoHF.rawVariation = cms.InputTag("patPFMetNoHF")
process.slimmedMETsNoHF.t1Uncertainties = cms.InputTag("patPFMetT1%sNoHF")
process.slimmedMETsNoHF.t01Variation = cms.InputTag("patPFMetT0pcT1NoHF")
process.slimmedMETsNoHF.t1SmearedVarsAndUncs = cms.InputTag(
"patPFMetT1Smear%sNoHF")
process.slimmedMETsNoHF.tXYUncForRaw = cms.InputTag("patPFMetTxyNoHF")
process.slimmedMETsNoHF.tXYUncForT1 = cms.InputTag("patPFMetT1TxyNoHF")
process.slimmedMETsNoHF.tXYUncForT01 = cms.InputTag(
"patPFMetT0pcT1TxyNoHF")
process.slimmedMETsNoHF.tXYUncForT1Smear = cms.InputTag(
"patPFMetT1SmearTxyNoHF")
process.slimmedMETsNoHF.tXYUncForT01Smear = cms.InputTag(
"patPFMetT0pcT1SmearTxyNoHF")
del process.slimmedMETsNoHF.caloMET
# ================== NoHF pfMET
# ================== CHSMET
process.CHSCands = cms.EDFilter("CandPtrSelector",
src=cms.InputTag("packedPFCandidates"),
cut=cms.string("fromPV(0) > 0"))
task.add(process.CHSCands)
from RecoMET.METProducers.pfMet_cfi import pfMet
process.pfMetCHS = pfMet.clone(src='CHSCands')
task.add(process.pfMetCHS)
addMETCollection(process, labelName="patCHSMet", metSource="pfMetCHS")
process.patCHSMet.computeMETSignificance = cms.bool(False)
# ================== CHSMET
# ================== TrkMET
process.TrkCands = cms.EDFilter(
"CandPtrSelector",
src=cms.InputTag("packedPFCandidates"),
cut=cms.string(
"charge()!=0 && pvAssociationQuality()>=4 && vertexRef().key()==0")
)
task.add(process.TrkCands)
process.pfMetTrk = pfMet.clone(src='TrkCands')
task.add(process.pfMetTrk)
addMETCollection(process, labelName="patTrkMet", metSource="pfMetTrk")
process.patTrkMet.computeMETSignificance = cms.bool(False)
# ================== TrkMET
## PU JetID
process.load("RecoJets.JetProducers.PileupJetID_cfi")
task.add(process.pileUpJetIDTask)
process.patJets.userData.userFloats.src = [
cms.InputTag("pileupJetId:fullDiscriminant"),
]
process.patJets.userData.userInts.src = [
cms.InputTag("pileupJetId:fullId"),
]
## Quark Gluon Likelihood
process.load('RecoJets.JetProducers.QGTagger_cfi')
task.add(process.QGTaggerTask)
process.patJets.userData.userFloats.src += [
cms.InputTag('QGTagger:qgLikelihood'),
]
## DeepCSV meta discriminators (simple arithmethic on output probabilities)
process.load('RecoBTag.Combined.deepFlavour_cff')
task.add(process.pfDeepCSVDiscriminatorsJetTags)
process.patJets.discriminatorSources.extend([
cms.InputTag('pfDeepCSVDiscriminatorsJetTags:BvsAll'),
cms.InputTag('pfDeepCSVDiscriminatorsJetTags:CvsB'),
cms.InputTag('pfDeepCSVDiscriminatorsJetTags:CvsL'),
])
## CaloJets
process.caloJetMap = cms.EDProducer(
"RecoJetDeltaRValueMapProducer",
src=process.patJets.jetSource,
matched=cms.InputTag("ak4CaloJets"),
distMax=cms.double(0.4),
values=cms.vstring('pt', 'emEnergyFraction'),
valueLabels=cms.vstring('pt', 'emEnergyFraction'),
lazyParser=cms.bool(True))
task.add(process.caloJetMap)
process.patJets.userData.userFloats.src += [
cms.InputTag("caloJetMap:pt"),
cms.InputTag("caloJetMap:emEnergyFraction")
]
#Muon object modifications
from PhysicsTools.PatAlgos.slimming.muonIsolationsPUPPI_cfi import makeInputForPUPPIIsolationMuon
makeInputForPUPPIIsolationMuon(process)
#EGM object modifications
from PhysicsTools.PatAlgos.slimming.egmIsolationsPUPPI_cfi import makeInputForPUPPIIsolationEgm
makeInputForPUPPIIsolationEgm(process)
from RecoEgamma.EgammaTools.egammaObjectModificationsInMiniAOD_cff import egamma_modifications
process.slimmedElectrons.modifierConfig.modifications = egamma_modifications
process.slimmedPhotons.modifierConfig.modifications = egamma_modifications
#VID Electron IDs
process.patElectrons.addElectronID = cms.bool(True)
electron_ids = [
'RecoEgamma.ElectronIdentification.Identification.heepElectronID_HEEPV70_cff',
'RecoEgamma.ElectronIdentification.Identification.heepElectronID_HEEPV71_cff',
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Fall17_94X_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Fall17_94X_V2_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Fall17_noIso_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Fall17_iso_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Fall17_noIso_V2_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Fall17_iso_V2_cff',
'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Summer16_80X_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring16_GeneralPurpose_V1_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring16_HZZ_V1_cff',
]
switchOnVIDElectronIdProducer(process, DataFormat.MiniAOD, task)
process.egmGsfElectronIDs.physicsObjectSrc = cms.InputTag(
"reducedEgamma", "reducedGedGsfElectrons")
process.electronMVAValueMapProducer.src = cms.InputTag(
'reducedEgamma', 'reducedGedGsfElectrons')
# To use older DataFormats, the electronMVAValueMapProducer MUST take a updated electron collection
# such that the conversion variables are filled correctly.
process.load("RecoEgamma.EgammaTools.gedGsfElectronsTo106X_cff")
run2_miniAOD_80XLegacy.toModify(
task, func=lambda t: t.add(process.gedGsfElectronsFrom80XTo106XTask))
run2_miniAOD_80XLegacy.toModify(
process.electronMVAValueMapProducer,
keysForValueMaps=cms.InputTag('reducedEgamma',
'reducedGedGsfElectrons'),
src=cms.InputTag("gedGsfElectronsFrom80XTo106X"))
run2_miniAOD_94XFall17.toModify(
task, func=lambda t: t.add(process.gedGsfElectronsFrom94XTo106XTask))
run2_miniAOD_94XFall17.toModify(
process.electronMVAValueMapProducer,
keysForValueMaps=cms.InputTag('reducedEgamma',
'reducedGedGsfElectrons'),
src=cms.InputTag("gedGsfElectronsFrom94XTo106X"))
from Configuration.Eras.Modifier_pp_on_AA_2018_cff import pp_on_AA_2018
pp_on_AA_2018.toModify(
task, func=lambda t: t.add(process.gedGsfElectronsFrom94XTo106XTask))
pp_on_AA_2018.toModify(process.electronMVAValueMapProducer,
keysForValueMaps=cms.InputTag(
'reducedEgamma', 'reducedGedGsfElectrons'),
src="gedGsfElectronsFrom94XTo106X")
for idmod in electron_ids:
setupAllVIDIdsInModule(process, idmod, setupVIDElectronSelection, None,
False, task)
#VID Photon IDs
process.patPhotons.addPhotonID = cms.bool(True)
photon_ids = [
'RecoEgamma.PhotonIdentification.Identification.cutBasedPhotonID_Fall17_94X_V1_TrueVtx_cff',
'RecoEgamma.PhotonIdentification.Identification.cutBasedPhotonID_Fall17_94X_V2_cff',
'RecoEgamma.PhotonIdentification.Identification.mvaPhotonID_Fall17_94X_V1p1_cff',
'RecoEgamma.PhotonIdentification.Identification.mvaPhotonID_Fall17_94X_V2_cff',
'RecoEgamma.PhotonIdentification.Identification.cutBasedPhotonID_Spring16_V2p2_cff',
'RecoEgamma.PhotonIdentification.Identification.mvaPhotonID_Spring16_nonTrig_V1_cff'
]
switchOnVIDPhotonIdProducer(process, DataFormat.AOD, task)
process.egmPhotonIDs.physicsObjectSrc = cms.InputTag(
"reducedEgamma", "reducedGedPhotons")
process.photonMVAValueMapProducer.src = cms.InputTag(
'reducedEgamma', 'reducedGedPhotons')
for idmod in photon_ids:
setupAllVIDIdsInModule(process, idmod, setupVIDPhotonSelection, None,
False, task)
#add the cut base IDs bitmaps of which cuts passed
from RecoEgamma.EgammaTools.egammaObjectModifications_tools import makeVIDBitsModifier
egamma_modifications.append(
makeVIDBitsModifier(process, "egmGsfElectronIDs", "egmPhotonIDs"))
#-- Adding boosted taus
from RecoTauTag.Configuration.boostedHPSPFTaus_cfi import addBoostedTaus
addBoostedTaus(process)
process.load("RecoTauTag.Configuration.RecoPFTauTag_cff")
process.load("RecoTauTag.Configuration.HPSPFTaus_cff")
#-- Adding customization for 94X 2017 legacy reMniAOD
_makePatTausTaskWithRetrainedMVATauID = process.makePatTausTask.copy()
_makePatTausTaskWithRetrainedMVATauID.add(
process.hpsPFTauBasicDiscriminatorsTask,
process.hpsPFTauDiscriminationByIsolationMVArun2v1DBoldDMwLTTask,
process.hpsPFTauDiscriminationByIsolationMVArun2v1DBnewDMwLTTask,
process.hpsPFTauBasicDiscriminatorsdR03Task,
process.hpsPFTauDiscriminationByIsolationMVArun2v1DBdR03oldDMwLTTask,
process.hpsPFTauDiscriminationByMVA6rawElectronRejection,
process.hpsPFTauDiscriminationByMVA6ElectronRejection,
process.hpsPFTauDiscriminationByMuonRejection3)
from Configuration.ProcessModifiers.run2_miniAOD_UL_cff import run2_miniAOD_UL
(run2_miniAOD_94XFall17 | run2_miniAOD_UL).toReplaceWith(
process.makePatTausTask, _makePatTausTaskWithRetrainedMVATauID)
#-- Adding DeepTauID
# deepTau v2p1
_updatedTauName = 'slimmedTausDeepIDsv2p1'
_noUpdatedTauName = 'slimmedTausNoDeepIDs'
import RecoTauTag.RecoTau.tools.runTauIdMVA as tauIdConfig
tauIdEmbedder = tauIdConfig.TauIDEmbedder(process,
debug=False,
updatedTauName=_updatedTauName,
toKeep=['deepTau2017v2p1'])
from Configuration.Eras.Modifier_phase2_common_cff import phase2_common #Phase2 Tau MVA
phase2_common.toModify(
tauIdEmbedder.toKeep,
func=lambda t: t.append('newDMPhase2v1')) #Phase2 Tau MVA
tauIdEmbedder.runTauID()
addToProcessAndTask(_noUpdatedTauName, process.slimmedTaus.clone(),
process, task)
delattr(process, 'slimmedTaus')
process.deepTau2017v2p1.taus = _noUpdatedTauName
process.slimmedTaus = getattr(process,
_updatedTauName).clone(src=_noUpdatedTauName)
process.deepTauIDTask = cms.Task(process.deepTau2017v2p1,
process.slimmedTaus)
task.add(process.deepTauIDTask)
if 'newDMPhase2v1' in tauIdEmbedder.toKeep:
process.rerunDiscriminationByIsolationMVADBnewDMwLTPhase2raw.PATTauProducer = _noUpdatedTauName
process.rerunDiscriminationByIsolationMVADBnewDMwLTPhase2.PATTauProducer = _noUpdatedTauName
task.add(process.rerunIsolationMVADBnewDMwLTPhase2Task)
#-- Rerun tauID against dead ECal towers to taus for the various re-MiniAOD eras
# to enable default behoviour with leading track extrapolation to ECAL
_makePatTausTaskWithDeadECalVeto = process.makePatTausTask.copy()
_makePatTausTaskWithDeadECalVeto.add(
process.hpsPFTauDiscriminationByDeadECALElectronRejection)
_run2_miniAOD_ANY = (run2_miniAOD_80XLegacy | run2_miniAOD_94XFall17
| run2_miniAOD_UL)
_run2_miniAOD_ANY.toReplaceWith(process.makePatTausTask,
_makePatTausTaskWithDeadECalVeto)
#-- Adding customization for 80X 2016 legacy reMiniAOD and 2018 heavy ions
_makePatTausTaskWithTauReReco = process.makePatTausTask.copy()
_makePatTausTaskWithTauReReco.add(process.PFTauTask)
(run2_miniAOD_80XLegacy | pp_on_AA_2018).toReplaceWith(
process.makePatTausTask, _makePatTausTaskWithTauReReco)
# Adding puppi jets
process.load('CommonTools.PileupAlgos.Puppi_cff')
process.load('RecoJets.JetProducers.ak4PFJets_cfi')
from Configuration.Eras.Modifier_pA_2016_cff import pA_2016
_rerun_puppijets_task = task.copy()
_rerun_puppijets_task.add(process.puppi, process.ak4PFJetsPuppi)
(_run2_miniAOD_ANY | pA_2016 | pp_on_AA_2018).toReplaceWith(
task, _rerun_puppijets_task)
from RecoJets.JetAssociationProducers.j2tParametersVX_cfi import j2tParametersVX
process.ak4PFJetsPuppiTracksAssociatorAtVertex = cms.EDProducer(
"JetTracksAssociatorAtVertex",
j2tParametersVX,
jets=cms.InputTag("ak4PFJetsPuppi"))
task.add(process.ak4PFJetsPuppiTracksAssociatorAtVertex)
process.patJetPuppiCharge = cms.EDProducer(
"JetChargeProducer",
src=cms.InputTag("ak4PFJetsPuppiTracksAssociatorAtVertex"),
var=cms.string('Pt'),
exp=cms.double(1.0))
task.add(process.patJetPuppiCharge)
noDeepFlavourDiscriminators = [
x.value() for x in process.patJets.discriminatorSources
if not "DeepFlavour" in x.value()
]
addJetCollection(process,
postfix="",
labelName='Puppi',
jetSource=cms.InputTag('ak4PFJetsPuppi'),
jetCorrections=('AK4PFPuppi',
['L2Relative', 'L3Absolute'], ''),
pfCandidates=cms.InputTag("particleFlow"),
algo='AK',
rParam=0.4,
btagDiscriminators=noDeepFlavourDiscriminators)
process.patJetGenJetMatchPuppi.matched = 'slimmedGenJets'
process.patJetsPuppi.jetChargeSource = cms.InputTag("patJetPuppiCharge")
process.selectedPatJetsPuppi.cut = cms.string("pt > 15")
from PhysicsTools.PatAlgos.slimming.applyDeepBtagging_cff import applyDeepBtagging
applyDeepBtagging(process)
addToProcessAndTask(
'slimmedJetsPuppi',
process.slimmedJetsNoDeepFlavour.clone(
src="selectedPatJetsPuppi",
packedPFCandidates="packedPFCandidates"), process, task)
task.add(process.slimmedJetsPuppi)
# Embed pixelClusterTagInfos in slimmedJets
process.patJets.addTagInfos = True
process.patJets.tagInfoSources = ["pixelClusterTagInfos"]
process.slimmedJetsNoDeepFlavour.dropTagInfos = '0'
process.updatedPatJetsTransientCorrectedSlimmedDeepFlavour.addTagInfos = True
process.updatedPatJetsTransientCorrectedSlimmedDeepFlavour.tagInfoSources = [
"pixelClusterTagInfos"
]
_run2_miniAOD_ANY.toModify(process.patJets, addTagInfos=False)
_run2_miniAOD_ANY.toModify(
process.updatedPatJetsTransientCorrectedSlimmedDeepFlavour,
addTagInfos=False)
## puppi met
process.load('RecoMET.METProducers.pfMetPuppi_cfi')
_rerun_puppimet_task = task.copy()
_rerun_puppimet_task.add(process.puppiNoLep, process.pfMetPuppi)
(_run2_miniAOD_ANY | pA_2016 | pp_on_AA_2018).toReplaceWith(
task, _rerun_puppimet_task)
runMetCorAndUncForMiniAODProduction(process,
metType="Puppi",
jetCollUnskimmed="slimmedJetsPuppi",
recoMetFromPFCs=True,
jetFlavor="AK4PFPuppi",
postfix="Puppi")
process.load('PhysicsTools.PatAlgos.slimming.slimmedMETs_cfi')
task.add(process.slimmedMETs)
addToProcessAndTask('slimmedMETsPuppi', process.slimmedMETs.clone(),
process, task)
process.slimmedMETsPuppi.src = cms.InputTag("patMETsPuppi")
process.slimmedMETsPuppi.rawVariation = cms.InputTag("patPFMetPuppi")
process.slimmedMETsPuppi.t1Uncertainties = cms.InputTag(
"patPFMetT1%sPuppi")
process.slimmedMETsPuppi.t01Variation = cms.InputTag("patPFMetT0pcT1Puppi")
process.slimmedMETsPuppi.t1SmearedVarsAndUncs = cms.InputTag(
"patPFMetT1Smear%sPuppi")
process.slimmedMETsPuppi.tXYUncForRaw = cms.InputTag("patPFMetTxyPuppi")
process.slimmedMETsPuppi.tXYUncForT1 = cms.InputTag("patPFMetT1TxyPuppi")
process.slimmedMETsPuppi.tXYUncForT01 = cms.InputTag(
"patPFMetT0pcT1TxyPuppi")
process.slimmedMETsPuppi.tXYUncForT1Smear = cms.InputTag(
"patPFMetT1SmearTxyPuppi")
process.slimmedMETsPuppi.tXYUncForT01Smear = cms.InputTag(
"patPFMetT0pcT1SmearTxyPuppi")
del process.slimmedMETsPuppi.caloMET
process.load('RecoMET.METPUSubtraction.deepMETProducer_cfi')
addToProcessAndTask('deepMETsResolutionTune',
process.deepMETProducer.clone(), process, task)
addToProcessAndTask('deepMETsResponseTune',
process.deepMETProducer.clone(), process, task)
process.deepMETsResponseTune.graph_path = 'RecoMET/METPUSubtraction/data/deepmet/deepmet_resp_v1_2018.pb'
from Configuration.Eras.Modifier_phase2_common_cff import phase2_common
phase2_common.toModify(
process.deepMETsResolutionTune,
max_n_pf=12500,
graph_path="RecoMET/METPUSubtraction/data/deepmet/deepmet_v1_phase2.pb"
)
phase2_common.toModify(
process.deepMETsResponseTune,
max_n_pf=12500,
graph_path=
"RecoMET/METPUSubtraction/data/deepmet/deepmet_resp_v1_phase2.pb")
from Configuration.Eras.Modifier_run2_jme_2016_cff import run2_jme_2016
run2_jme_2016.toModify(
process.deepMETsResponseTune,
graph_path=
"RecoMET/METPUSubtraction/data/deepmet/deepmet_resp_v1_2016.pb")
# add DetIdAssociatorRecords to EventSetup (for isolatedTracks)
process.load("TrackingTools.TrackAssociator.DetIdAssociatorESProducer_cff")
# EGamma objects from HGCal are not yet in GED
# so add companion collections for Phase-II MiniAOD production
from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal
process.load("RecoEgamma.EgammaTools.slimmedEgammaFromMultiCl_cff")
phase2_hgcal.toModify(
task, func=lambda t: t.add(process.slimmedEgammaFromMultiClTask))
# L1 pre-firing weights for 2016 and 2017
from Configuration.Eras.Modifier_run2_L1prefiring_cff import run2_L1prefiring
from Configuration.Eras.Modifier_stage1L1Trigger_cff import stage1L1Trigger
from Configuration.Eras.Modifier_stage2L1Trigger_2017_cff import stage2L1Trigger_2017
process.load("PhysicsTools.PatUtils.L1ECALPrefiringWeightProducer_cff")
stage1L1Trigger.toModify(process.prefiringweight, DataEra="2016BtoH")
stage2L1Trigger_2017.toModify(process.prefiringweight, DataEra="2017BtoF")
run2_L1prefiring.toModify(task,
func=lambda t: t.add(process.prefiringweight))
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 setupAK15(process, runOnMC=False, path=None, runParticleNetMD=True):
# recluster Puppi jets
bTagDiscriminators = [
'pfJetProbabilityBJetTags',
'pfCombinedInclusiveSecondaryVertexV2BJetTags',
'pfDeepCSVJetTags:probb',
'pfDeepCSVJetTags:probbb',
]
subjetBTagDiscriminators = [
'pfJetProbabilityBJetTags',
'pfCombinedInclusiveSecondaryVertexV2BJetTags',
'pfDeepCSVJetTags:probb',
'pfDeepCSVJetTags:probbb',
]
JETCorrLevels = ['L2Relative', 'L3Absolute', 'L2L3Residual']
from PhysicsTools.PFNano.jetToolbox_cff import jetToolbox
jetToolbox(process,
'ak15',
'dummySeqAK15',
'noOutput',
PUMethod='Puppi',
JETCorrPayload='AK8PFPuppi',
JETCorrLevels=JETCorrLevels,
Cut='pt > 160.0 && abs(rapidity()) < 2.4',
runOnMC=runOnMC,
addNsub=True,
maxTau=3,
addSoftDrop=True,
addSoftDropSubjets=True,
subJETCorrPayload='AK4PFPuppi',
subJETCorrLevels=JETCorrLevels,
bTagDiscriminators=bTagDiscriminators,
subjetBTagDiscriminators=subjetBTagDiscriminators)
if runOnMC:
process.ak15GenJetsNoNu.jetPtMin = 100
process.ak15GenJetsNoNuSoftDrop.jetPtMin = 100
from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection
from RecoBTag.ONNXRuntime.pfParticleNet_cff import _pfParticleNetJetTagsProbs as pfParticleNetJetTagsProbs
from RecoBTag.ONNXRuntime.pfParticleNet_cff import _pfMassDecorrelatedParticleNetJetTagsProbs as pfMassDecorrelatedParticleNetJetTagsProbs
bTagDiscriminators += pfParticleNetJetTagsProbs
if runParticleNetMD:
bTagDiscriminators += pfMassDecorrelatedParticleNetJetTagsProbs
#from RecoBTag.ONNXRuntime.pfDeepBoostedJet_cff import _pfDeepBoostedJetTagsProbs, _pfMassDecorrelatedDeepBoostedJetTagsProbs, _pfDeepBoostedJetTagsMetaDiscrs, _pfMassDecorrelatedDeepBoostedJetTagsMetaDiscrs
#bTagDiscriminators += _pfDeepBoostedJetTagsProbs + _pfMassDecorrelatedDeepBoostedJetTagsProbs + _pfDeepBoostedJetTagsMetaDiscrs + _pfMassDecorrelatedDeepBoostedJetTagsMetaDiscrs
updateJetCollection(
process,
jetSource=cms.InputTag('packedPatJetsAK15PFPuppiSoftDrop'),
rParam=1.5,
jetCorrections=('AK8PFPuppi', cms.vstring(JETCorrLevels), 'None'),
btagDiscriminators=bTagDiscriminators,
postfix='AK15ParticleNet',
)
from RecoBTag.ONNXRuntime.pfParticleNet_cff import pfMassDecorrelatedParticleNetJetTags
if runParticleNetMD:
process.pfParticleNetTagInfosAK15ParticleNet.jet_radius = 1.5
process.pfMassDecorrelatedParticleNetJetTagsAK15ParticleNet = pfMassDecorrelatedParticleNetJetTags.clone(
src=process.pfMassDecorrelatedParticleNetJetTagsAK15ParticleNet.
src,
preprocess_json=
'PhysicsTools/PFNano/data/ParticleNet-MD/ak15/preprocess.json',
model_path=
'PhysicsTools/PFNano/data/ParticleNet-MD/ak15/particle-net.onnx',
)
# src
srcJets = cms.InputTag('selectedUpdatedPatJetsAK15ParticleNet')
# jetID
process.looseJetIdAK15Puppi = cms.EDProducer(
"PatJetIDValueMapProducer",
filterParams=cms.PSet(
version=cms.string('WINTER16'),
quality=cms.string('LOOSE'),
),
src=srcJets)
process.tightJetIdAK15Puppi = cms.EDProducer(
"PatJetIDValueMapProducer",
filterParams=cms.PSet(
version=cms.string('SUMMER18PUPPI'),
quality=cms.string('TIGHT'),
),
src=srcJets)
process.tightJetIdLepVetoAK15Puppi = cms.EDProducer(
"PatJetIDValueMapProducer",
filterParams=cms.PSet(
version=cms.string('SUMMER18PUPPI'),
quality=cms.string('TIGHTLEPVETO'),
),
src=srcJets)
run2_jme_2016.toModify(process.tightJetIdAK15Puppi.filterParams,
version="WINTER16")
run2_jme_2016.toModify(process.tightJetIdLepVetoAK15Puppi.filterParams,
version="WINTER16")
run2_jme_2017.toModify(process.tightJetIdAK15Puppi.filterParams,
version="WINTER17PUPPI")
run2_jme_2017.toModify(process.tightJetIdLepVetoAK15Puppi.filterParams,
version="WINTER17PUPPI")
process.ak15WithUserData = cms.EDProducer(
"PATJetUserDataEmbedder",
src=srcJets,
userFloats=cms.PSet(),
userInts=cms.PSet(
tightId=cms.InputTag("tightJetIdAK15Puppi"),
tightIdLepVeto=cms.InputTag("tightJetIdLepVetoAK15Puppi"),
),
)
run2_jme_2016.toModify(
process.ak15WithUserData.userInts,
looseId=cms.InputTag("looseJetIdAK15Puppi"),
tightIdLepVeto=None,
)
process.ak15Table = cms.EDProducer(
"SimpleCandidateFlatTableProducer",
src=cms.InputTag("ak15WithUserData"),
name=cms.string("FatJetAK15"), # AK15Puppi
cut=cms.string(""),
doc=cms.string("ak15 puppi jets"),
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(
P4Vars,
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"
),
area=Var("jetArea()",
float,
doc="jet catchment area, for JECs",
precision=10),
rawFactor=Var("1.-jecFactor('Uncorrected')",
float,
doc="1 - Factor to get back to raw pT",
precision=6),
nPFConstituents=Var("numberOfDaughters()",
int,
doc="Number of PF candidate constituents"),
tau1=Var("userFloat('NjettinessAK15Puppi:tau1')",
float,
doc="Nsubjettiness (1 axis)",
precision=10),
tau2=Var("userFloat('NjettinessAK15Puppi:tau2')",
float,
doc="Nsubjettiness (2 axis)",
precision=10),
tau3=Var("userFloat('NjettinessAK15Puppi:tau3')",
float,
doc="Nsubjettiness (3 axis)",
precision=10),
msoftdrop=Var("groomedMass()",
float,
doc="Corrected soft drop mass with PUPPI",
precision=10),
btagCSVV2=Var(
"bDiscriminator('pfCombinedInclusiveSecondaryVertexV2BJetTags')",
float,
doc=
"pfCombinedInclusiveSecondaryVertexV2 b-tag discriminator (aka CSVV2)",
precision=10),
btagDeepB=Var(
"bDiscriminator('pfDeepCSVJetTags:probb')+bDiscriminator('pfDeepCSVJetTags:probbb')",
float,
doc="DeepCSV b+bb tag discriminator",
precision=10),
btagJP=Var(
"bDiscriminator('pfJetProbabilityBJetTags')",
float,
doc="pfJetProbabilityBJetTags b-tag discriminator (aka JP)",
precision=10),
nBHadrons=Var("jetFlavourInfo().getbHadrons().size()",
int,
doc="number of b-hadrons"),
nCHadrons=Var("jetFlavourInfo().getcHadrons().size()",
int,
doc="number of c-hadrons"),
subJetIdx1=Var(
"?nSubjetCollections()>0 && subjets().size()>0?subjets()[0].key():-1",
int,
doc="index of first subjet"),
subJetIdx2=Var(
"?nSubjetCollections()>0 && subjets().size()>1?subjets()[1].key():-1",
int,
doc="index of second subjet"),
))
run2_jme_2016.toModify(
process.ak15Table.variables,
jetId=Var("userInt('tightId')*2+userInt('looseId')",
int,
doc="Jet ID flags bit1 is loose, bit2 is tight"))
process.ak15Table.variables.pt.precision = 10
# add mass-decorelated taggers
for prob in pfParticleNetJetTagsProbs:
name = 'ParticleNet_' + prob.split(':')[1]
setattr(
process.ak15Table.variables, name,
Var("bDiscriminator('%s')" % prob, float, doc=prob, precision=-1))
if runParticleNetMD:
for prob in pfMassDecorrelatedParticleNetJetTagsProbs:
name = 'ParticleNetMD_' + prob.split(':')[1]
name = name.replace('QCDothers', 'QCD') # FIXME
setattr(
process.ak15Table.variables, name,
Var("bDiscriminator('%s')" % prob,
float,
doc=prob,
precision=-1))
process.ak15SubJetTable = cms.EDProducer(
"SimpleCandidateFlatTableProducer",
src=cms.InputTag("selectedPatJetsAK15PFPuppiSoftDropPacked",
"SubJets"),
cut=cms.string(""),
name=cms.string("FatJetAK15SubJet"), # AK15PuppiSubJet
doc=cms.string("ak15 puppi subjets"),
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(
P4Vars,
area=Var("jetArea()",
float,
doc="jet catchment area, for JECs",
precision=10),
rawFactor=Var("1.-jecFactor('Uncorrected')",
float,
doc="1 - Factor to get back to raw pT",
precision=6),
btagDeepB=Var(
"bDiscriminator('pfDeepCSVJetTags:probb')+bDiscriminator('pfDeepCSVJetTags:probbb')",
float,
doc="DeepCSV b+bb tag discriminator",
precision=10),
btagCSVV2=Var(
"bDiscriminator('pfCombinedInclusiveSecondaryVertexV2BJetTags')",
float,
doc=
" pfCombinedInclusiveSecondaryVertexV2 b-tag discriminator (aka CSVV2)",
precision=10),
btagJP=Var(
"bDiscriminator('pfJetProbabilityBJetTags')",
float,
doc="pfJetProbabilityBJetTags b-tag discriminator (aka JP)",
precision=10),
nBHadrons=Var("jetFlavourInfo().getbHadrons().size()",
int,
doc="number of b-hadrons"),
nCHadrons=Var("jetFlavourInfo().getcHadrons().size()",
int,
doc="number of c-hadrons"),
))
process.ak15SubJetTable.variables.pt.precision = 10
process.ak15Task = cms.Task(
process.tightJetIdAK15Puppi,
process.tightJetIdLepVetoAK15Puppi,
process.ak15WithUserData,
process.ak15Table,
process.ak15SubJetTable,
)
if runOnMC:
process.genJetAK15Table = cms.EDProducer(
"SimpleCandidateFlatTableProducer",
src=cms.InputTag("ak15GenJetsNoNu"),
cut=cms.string("pt > 100."),
name=cms.string("GenJetAK15"),
doc=cms.string("AK15 GenJets made with visible genparticles"),
singleton=cms.bool(False), # the number of entries is variable
extension=cms.bool(
False), # this is the main table for the genjets
variables=cms.PSet(P4Vars, ))
process.genJetAK15Table.variables.pt.precision = 10
process.genSubJetAK15Table = cms.EDProducer(
"SimpleCandidateFlatTableProducer",
src=cms.InputTag("ak15GenJetsNoNuSoftDrop", "SubJets"),
cut=cms.string(""),
name=cms.string("GenSubJetAK15"),
doc=cms.string("AK15 Gen-SubJets made with visible genparticles"),
singleton=cms.bool(False), # the number of entries is variable
extension=cms.bool(
False), # this is the main table for the genjets
variables=cms.PSet(P4Vars, ))
process.genSubJetAK15Table.variables.pt.precision = 10
process.ak15Task.add(process.genJetAK15Table)
process.ak15Task.add(process.genSubJetAK15Table)
###### hack to avoid circular dependency ######
process.jetMC.remove(process.patJetPartons)
process.ak15Task.add(process.patJetPartons)
###############################################
_ak15Task_2016 = process.ak15Task.copy()
_ak15Task_2016.replace(process.tightJetIdLepVetoAK15Puppi,
process.looseJetIdAK15Puppi)
run2_jme_2016.toReplaceWith(process.ak15Task, _ak15Task_2016)
if path is None:
process.schedule.associate(process.ak15Task)
else:
getattr(process, path).associate(process.ak15Task)
quality=cms.string('LOOSE'),
),
src=cms.InputTag("updatedJets"))
tightJetId = cms.EDProducer("PatJetIDValueMapProducer",
filterParams=cms.PSet(
version=cms.string('SUMMER18'),
quality=cms.string('TIGHT'),
),
src=cms.InputTag("updatedJets"))
tightJetIdLepVeto = cms.EDProducer("PatJetIDValueMapProducer",
filterParams=cms.PSet(
version=cms.string('SUMMER18'),
quality=cms.string('TIGHTLEPVETO'),
),
src=cms.InputTag("updatedJets"))
run2_jme_2016.toModify(tightJetId.filterParams, version="WINTER16")
run2_jme_2016.toModify(tightJetIdLepVeto.filterParams, version="WINTER16")
run2_jme_2017.toModify(tightJetId.filterParams, version="WINTER17")
run2_jme_2017.toModify(tightJetIdLepVeto.filterParams, version="WINTER17")
looseJetIdAK8 = cms.EDProducer("PatJetIDValueMapProducer",
filterParams=cms.PSet(
version=cms.string('WINTER16'),
quality=cms.string('LOOSE'),
),
src=cms.InputTag("updatedJetsAK8"))
tightJetIdAK8 = cms.EDProducer("PatJetIDValueMapProducer",
filterParams=cms.PSet(
version=cms.string('SUMMER18PUPPI'),
quality=cms.string('TIGHT'),
),
deepMETsResolutionTune,
max_n_pf=12500,
graph_path=
"RecoMET/METPUSubtraction/data/models/deepmet_phase2/deepmet_v1_phase2/model.graphdef"
)
phase2_common.toModify(
deepMETsResponseTune,
max_n_pf=12500,
graph_path=
"RecoMET/METPUSubtraction/data/models/deepmet_phase2/deepmet_resp_v1_phase2/model.graphdef"
)
from Configuration.Eras.Modifier_run2_jme_2016_cff import run2_jme_2016
run2_jme_2016.toModify(
deepMETsResponseTune,
graph_path=
"RecoMET/METPUSubtraction/data/models/deepmet/deepmet_resp_v1_2016/model.graphdef"
)
from RecoMET.METPUSubtraction.deepMETSonicProducer_cff import deepMETSonicProducer as _deepMETSonicProducer
from Configuration.ProcessModifiers.deepMETSonicTriton_cff import deepMETSonicTriton
def split_model_path(path):
Client = dict(
modelName=path.split('/')[-3],
modelConfigPath='/'.join(path.split('/')[:-2]) + '/config.pbtxt',
# version "1" is the resolutionTune
# version "2" is the responeTune
modelVersion=os.path.realpath(
pfnInPath(path).split(':')[-1]).split('/')[-2],
def setupCustomizedAK8(process, runOnMC=False, path=None):
# recluster Puppi jets
bTagDiscriminators = [
'pfCombinedInclusiveSecondaryVertexV2BJetTags',
'pfBoostedDoubleSecondaryVertexAK8BJetTags',
]
subjetBTagDiscriminators = [
'pfCombinedInclusiveSecondaryVertexV2BJetTags',
'pfDeepCSVJetTags:probb',
'pfDeepCSVJetTags:probbb',
]
JETCorrLevels = ['L2Relative', 'L3Absolute', 'L2L3Residual']
from PhysicsTools.NanoTuples.jetToolbox_cff import jetToolbox
jetToolbox(process,
'ak8',
'dummySeqAK8',
'noOutput',
PUMethod='Puppi',
JETCorrPayload='AK8PFPuppi',
JETCorrLevels=JETCorrLevels,
Cut='pt > 170.0 && abs(rapidity()) < 2.4',
runOnMC=runOnMC,
addNsub=True,
maxTau=3,
addSoftDrop=True,
addSoftDropSubjets=True,
subJETCorrPayload='AK4PFPuppi',
subJETCorrLevels=JETCorrLevels,
bTagDiscriminators=bTagDiscriminators,
subjetBTagDiscriminators=subjetBTagDiscriminators)
if runOnMC:
process.ak8GenJetsNoNu.jetPtMin = 100
process.ak8GenJetsNoNuSoftDrop.jetPtMin = 100
from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection
from RecoBTag.ONNXRuntime.pfDeepBoostedJet_cff import _pfDeepBoostedJetTagsProbs, _pfMassDecorrelatedDeepBoostedJetTagsProbs
from RecoBTag.MXNet.pfParticleNet_cff import _pfParticleNetJetTagsProbs, _pfMassDecorrelatedParticleNetJetTagsProbs
updateJetCollection(
process,
jetSource=cms.InputTag('packedPatJetsAK8PFPuppiSoftDrop'),
rParam=0.8,
jetCorrections=('AK8PFPuppi', cms.vstring(JETCorrLevels), 'None'),
btagDiscriminators=bTagDiscriminators + _pfDeepBoostedJetTagsProbs +
_pfMassDecorrelatedDeepBoostedJetTagsProbs +
_pfParticleNetJetTagsProbs +
_pfMassDecorrelatedParticleNetJetTagsProbs,
postfix='AK8WithPuppiDaughters',
)
# src
srcJets = cms.InputTag('selectedUpdatedPatJetsAK8WithPuppiDaughters')
# jetID
process.looseJetIdCustomAK8 = cms.EDProducer(
"PatJetIDValueMapProducer",
filterParams=cms.PSet(
version=cms.string('WINTER16'),
quality=cms.string('LOOSE'),
),
src=srcJets)
process.tightJetIdCustomAK8 = cms.EDProducer(
"PatJetIDValueMapProducer",
filterParams=cms.PSet(
version=cms.string('SUMMER18PUPPI'),
quality=cms.string('TIGHT'),
),
src=srcJets)
process.tightJetIdLepVetoCustomAK8 = cms.EDProducer(
"PatJetIDValueMapProducer",
filterParams=cms.PSet(
version=cms.string('SUMMER18PUPPI'),
quality=cms.string('TIGHTLEPVETO'),
),
src=srcJets)
run2_jme_2016.toModify(process.tightJetIdCustomAK8.filterParams,
version="WINTER16")
run2_jme_2016.toModify(process.tightJetIdLepVetoCustomAK8.filterParams,
version="WINTER16")
run2_jme_2017.toModify(process.tightJetIdCustomAK8.filterParams,
version="WINTER17PUPPI")
run2_jme_2017.toModify(process.tightJetIdLepVetoCustomAK8.filterParams,
version="WINTER17PUPPI")
process.customAK8WithUserData = cms.EDProducer(
"PATJetUserDataEmbedder",
src=srcJets,
userFloats=cms.PSet(),
userInts=cms.PSet(
tightId=cms.InputTag("tightJetIdCustomAK8"),
tightIdLepVeto=cms.InputTag("tightJetIdLepVetoCustomAK8"),
),
)
run2_jme_2016.toModify(
process.customAK8WithUserData.userInts,
looseId=cms.InputTag("looseJetIdCustomAK8"),
tightIdLepVeto=None,
)
process.customAK8Table = cms.EDProducer(
"SimpleCandidateFlatTableProducer",
src=cms.InputTag("customAK8WithUserData"),
name=cms.string("CustomAK8Puppi"),
cut=cms.string(""),
doc=cms.string("reclustered ak8 puppi jets"),
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(
P4Vars,
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"
),
area=Var("jetArea()",
float,
doc="jet catchment area, for JECs",
precision=10),
rawFactor=Var("1.-jecFactor('Uncorrected')",
float,
doc="1 - Factor to get back to raw pT",
precision=6),
nPFConstituents=Var("numberOfDaughters()",
int,
doc="Number of PF candidate constituents"),
tau1=Var("userFloat('NjettinessAK8Puppi:tau1')",
float,
doc="Nsubjettiness (1 axis)",
precision=10),
tau2=Var("userFloat('NjettinessAK8Puppi:tau2')",
float,
doc="Nsubjettiness (2 axis)",
precision=10),
tau3=Var("userFloat('NjettinessAK8Puppi:tau3')",
float,
doc="Nsubjettiness (3 axis)",
precision=10),
msoftdrop=Var("groomedMass()",
float,
doc="Corrected soft drop mass with PUPPI",
precision=10),
btagCSVV2=Var(
"bDiscriminator('pfCombinedInclusiveSecondaryVertexV2BJetTags')",
float,
doc=
" pfCombinedInclusiveSecondaryVertexV2 b-tag discriminator (aka CSVV2)",
precision=10),
btagHbb=Var(
"bDiscriminator('pfBoostedDoubleSecondaryVertexAK8BJetTags')",
float,
doc="Higgs to BB tagger discriminator",
precision=10),
nBHadrons=Var("jetFlavourInfo().getbHadrons().size()",
int,
doc="number of b-hadrons"),
nCHadrons=Var("jetFlavourInfo().getcHadrons().size()",
int,
doc="number of c-hadrons"),
subJetIdx1=Var(
"?nSubjetCollections()>0 && subjets().size()>0?subjets()[0].key():-1",
int,
doc="index of first subjet"),
subJetIdx2=Var(
"?nSubjetCollections()>0 && subjets().size()>1?subjets()[1].key():-1",
int,
doc="index of second subjet"),
))
run2_jme_2016.toModify(
process.customAK8Table.variables,
jetId=Var("userInt('tightId')*2+userInt('looseId')",
int,
doc="Jet ID flags bit1 is loose, bit2 is tight"))
process.customAK8Table.variables.pt.precision = 10
# add DeepAK8 scores: nominal
for prob in _pfDeepBoostedJetTagsProbs:
name = 'DeepAK8_' + prob.split(':')[1]
setattr(
process.customAK8Table.variables, name,
Var("bDiscriminator('%s')" % prob, float, doc=prob, precision=-1))
# add DeepAK8 scores: mass decorrelated
for prob in _pfMassDecorrelatedDeepBoostedJetTagsProbs:
name = 'DeepAK8MD_' + prob.split(':')[1]
setattr(
process.customAK8Table.variables, name,
Var("bDiscriminator('%s')" % prob, float, doc=prob, precision=-1))
# add ParticleNet nominal taggers
for prob in _pfParticleNetJetTagsProbs:
name = 'ParticleNet_' + prob.split(':')[1]
setattr(
process.customAK8Table.variables, name,
Var("bDiscriminator('%s')" % prob, float, doc=prob, precision=-1))
# add ParticleNet mass-decorelated taggers
for prob in _pfMassDecorrelatedParticleNetJetTagsProbs:
name = 'ParticleNetMD_' + prob.split(':')[1]
setattr(
process.customAK8Table.variables, name,
Var("bDiscriminator('%s')" % prob, float, doc=prob, precision=-1))
process.customAK8SubJetTable = cms.EDProducer(
"SimpleCandidateFlatTableProducer",
src=cms.InputTag("selectedPatJetsAK8PFPuppiSoftDropPacked", "SubJets"),
cut=cms.string(""),
name=cms.string("CustomAK8PuppiSubJet"),
doc=cms.string("reculstered ak8 puppi subjets"),
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(
P4Vars,
area=Var("jetArea()",
float,
doc="jet catchment area, for JECs",
precision=10),
rawFactor=Var("1.-jecFactor('Uncorrected')",
float,
doc="1 - Factor to get back to raw pT",
precision=6),
btagDeepB=Var(
"bDiscriminator('pfDeepCSVJetTags:probb')+bDiscriminator('pfDeepCSVJetTags:probbb')",
float,
doc="DeepCSV b+bb tag discriminator",
precision=10),
btagCSVV2=Var(
"bDiscriminator('pfCombinedInclusiveSecondaryVertexV2BJetTags')",
float,
doc=
" pfCombinedInclusiveSecondaryVertexV2 b-tag discriminator (aka CSVV2)",
precision=10),
nBHadrons=Var("jetFlavourInfo().getbHadrons().size()",
int,
doc="number of b-hadrons"),
nCHadrons=Var("jetFlavourInfo().getcHadrons().size()",
int,
doc="number of c-hadrons"),
))
process.customAK8SubJetTable.variables.pt.precision = 10
process.customizedAK8Task = cms.Task(process.tightJetIdCustomAK8,
process.tightJetIdLepVetoCustomAK8,
process.customAK8WithUserData,
process.customAK8Table,
process.customAK8SubJetTable)
if runOnMC:
process.customGenJetAK8Table = cms.EDProducer(
"SimpleCandidateFlatTableProducer",
src=cms.InputTag("ak8GenJetsNoNu"),
cut=cms.string("pt > 100."),
name=cms.string("CustomGenJetAK8"),
doc=cms.string("AK8 GenJets made with visible genparticles"),
singleton=cms.bool(False), # the number of entries is variable
extension=cms.bool(
False), # this is the main table for the genjets
variables=cms.PSet(P4Vars, ))
process.customGenJetAK8Table.variables.pt.precision = 10
process.customGenSubJetAK8Table = cms.EDProducer(
"SimpleCandidateFlatTableProducer",
src=cms.InputTag("ak8GenJetsNoNuSoftDrop", "SubJets"),
cut=cms.string(""),
name=cms.string("CustomGenSubJetAK8"),
doc=cms.string("AK8 Gen-SubJets made with visible genparticles"),
singleton=cms.bool(False), # the number of entries is variable
extension=cms.bool(
False), # this is the main table for the genjets
variables=cms.PSet(P4Vars, ))
process.customGenSubJetAK8Table.variables.pt.precision = 10
process.customizedAK8Task.add(process.customGenJetAK8Table)
process.customizedAK8Task.add(process.customGenSubJetAK8Table)
_customizedAK8Task_80X = process.customizedAK8Task.copy()
_customizedAK8Task_80X.replace(process.tightJetIdLepVetoCustomAK8,
process.looseJetIdCustomAK8)
run2_jme_2016.toReplaceWith(process.customizedAK8Task,
_customizedAK8Task_80X)
if path is None:
process.schedule.associate(process.customizedAK8Task)
else:
getattr(process, path).associate(process.customizedAK8Task)
def addRecoJetCollection(
self,
proc,
jet,
inputCollection="",
genJetsCollection="",
minPt=5.,
bTagDiscriminators=None,
JETCorrLevels=None,
):
print(
"jetCollectionTools::RecoJetAdder::addRecoJetCollection: Adding Reco Jet Collection: {}"
.format(jet))
currentTasks = []
if inputCollection and inputCollection not in [
"slimmedJets",
"slimmedJetsAK8",
"slimmedJetsPuppi",
"slimmedCaloJets",
]:
raise RuntimeError("Invalid input collection: %s" %
inputCollection)
if bTagDiscriminators is None:
bTagDiscriminators = self.bTagDiscriminators
if JETCorrLevels is None:
JETCorrLevels = self.JETCorrLevels
#
# Decide which jet collection we're dealing with
#
recoJetInfo = RecoJetInfo(jet, inputCollection)
jetLower = recoJetInfo.jetLower
jetUpper = recoJetInfo.jetUpper
tagName = recoJetInfo.jetTagName
if inputCollection == "slimmedJets":
assert (jetLower == "ak4pfchs")
elif inputCollection == "slimmedJetsAK8":
assert (jetLower == "ak8pfpuppi")
elif inputCollection == "slimmedJetsPuppi":
assert (jetLower == "ak4pfpuppi")
elif inputCollection == "slimmedCaloJets":
assert (jetLower == "ak4calo")
#=======================================================
#
# If jet collection in MiniAOD is not
# specified, build the jet collection.
#
#========================================================
if not inputCollection or recoJetInfo.doCalo:
print(
"jetCollectionTools::RecoJetAdder::addRecoJetCollection: inputCollection not specified. Building recojet collection now"
)
#=======================================================
#
# Prepare the inputs to jet clustering
#
#========================================================
#
# Set up PF candidates
#
pfCand = self.pfLabel
#
# Setup PU method for PF candidates
#
if recoJetInfo.jetPUMethod not in ["", "cs"]:
pfCand += recoJetInfo.jetPUMethod
#
#
#
if pfCand not in self.prerequisites:
#
# Skip if no PU Method or CS specified
#
if recoJetInfo.jetPUMethod in ["", "cs"]:
pass
#
# CHS
#
elif recoJetInfo.jetPUMethod == "chs":
setattr(
proc, pfCand,
cms.EDFilter(
"CandPtrSelector",
src=cms.InputTag(self.pfLabel),
cut=cms.string("fromPV"),
))
self.prerequisites.append(pfCand)
#
# PUPPI
#
elif recoJetInfo.jetPUMethod == "puppi":
setattr(
proc, pfCand,
puppi.clone(
candName=self.pfLabel,
vertexName=self.pvLabel,
))
self.prerequisites.append(pfCand)
#
# Softkiller
#
elif recoJetInfo.jetPUMethod == "sk":
setattr(
proc, pfCand,
softKiller.clone(
PFCandidates=self.pfLabel,
rParam=recoJetInfo.jetSizeNr,
))
self.prerequisites.append(pfCand)
else:
raise RuntimeError(
"Currently unsupported PU method: '%s'" %
recoJetInfo.jetPUMethod)
#============================================
#
# Create the recojet collection
#
#============================================
if not recoJetInfo.doCalo:
jetCollection = '{}Collection'.format(tagName)
if jetCollection in self.main:
raise ValueError("Step '%s' already implemented" %
jetCollection)
setattr(
proc, jetCollection,
ak4PFJetsCS.clone(
src=pfCand,
doAreaFastjet=True,
jetPtMin=minPt,
jetAlgorithm=supportedJetAlgos[recoJetInfo.jetAlgo],
rParam=recoJetInfo.jetSizeNr,
useConstituentSubtraction=recoJetInfo.doCS,
csRParam=0.4 if recoJetInfo.doCS else -1.,
csRho_EtaMax=PFJetParameters.Rho_EtaMax
if recoJetInfo.doCS else -1.,
useExplicitGhosts=recoJetInfo.doCS
or recoJetInfo.jetPUMethod == "sk",
))
currentTasks.append(jetCollection)
else:
jetCollection = inputCollection
#
# PATify
#
if recoJetInfo.jetPUMethod == "puppi":
jetCorrLabel = "Puppi"
elif recoJetInfo.jetPUMethod in ["cs", "sk"]:
jetCorrLabel = "chs"
else:
jetCorrLabel = recoJetInfo.jetPUMethod
#
# Jet correction
#
jetCorrections = (
"{}{}{}{}".format(
recoJetInfo.jetAlgo.upper(), recoJetInfo.jetSize, "Calo"
if recoJetInfo.doCalo else recoJetInfo.jetReco.upper(),
jetCorrLabel),
JETCorrLevels,
"None",
)
addJetCollection(
proc,
labelName=tagName,
jetSource=cms.InputTag(jetCollection),
algo=recoJetInfo.jetAlgo,
rParam=recoJetInfo.jetSizeNr,
pvSource=cms.InputTag(self.pvLabel),
pfCandidates=cms.InputTag(self.pfLabel),
svSource=cms.InputTag(self.svLabel),
muSource=cms.InputTag(self.muLabel),
elSource=cms.InputTag(self.elLabel),
btagDiscriminators=bTagDiscriminators
if not recoJetInfo.doCalo else ["None"],
jetCorrections=jetCorrections,
genJetCollection=cms.InputTag(genJetsCollection),
genParticles=cms.InputTag(self.gpLabel),
)
getJetMCFlavour = not recoJetInfo.doCalo and recoJetInfo.jetPUMethod != "cs"
if not self.runOnMC: #Remove modules for Gen-level object matching
delattr(proc, 'patJetGenJetMatch{}'.format(tagName))
delattr(proc, 'patJetPartonMatch{}'.format(tagName))
getJetMCFlavour = False
setattr(getattr(proc, "patJets{}".format(tagName)),
"getJetMCFlavour", cms.bool(getJetMCFlavour))
setattr(getattr(proc, "patJetCorrFactors{}".format(tagName)),
"payload", cms.string(recoJetInfo.jetCorrPayload))
selJet = "selectedPatJets{}".format(tagName)
else:
selJet = inputCollection
if not recoJetInfo.skipUserData:
#
#
#
jercVar = "jercVars{}".format(tagName)
if jercVar in self.main:
raise ValueError("Step '%s' already implemented" % jercVar)
setattr(proc, jercVar, proc.jercVars.clone(srcJet=selJet))
currentTasks.append(jercVar)
#
# JetID Loose
#
looseJetId = "looseJetId{}".format(tagName)
if looseJetId in self.main:
raise ValueError("Step '%s' already implemented" % looseJetId)
setattr(
proc, looseJetId,
proc.looseJetId.clone(
src=selJet,
filterParams=proc.looseJetId.filterParams.clone(
version="WINTER16"),
))
currentTasks.append(looseJetId)
#
# JetID Tight
#
tightJetId = "tightJetId{}".format(tagName)
if tightJetId in self.main:
raise ValueError("Step '%s' already implemented" % tightJetId)
setattr(
proc, tightJetId,
proc.tightJetId.clone(
src=selJet,
filterParams=proc.tightJetId.filterParams.clone(
version="SUMMER18{}".format(
"PUPPI" if recoJetInfo.jetPUMethod ==
"puppi" else "")),
))
tightJetIdObj = getattr(proc, tightJetId)
run2_jme_2016.toModify(tightJetIdObj.filterParams,
version="WINTER16")
run2_jme_2017.toModify(
tightJetIdObj.filterParams,
version='WINTER17{}'.format(
"PUPPI" if recoJetInfo.jetPUMethod == "puppi" else ""))
currentTasks.append(tightJetId)
#
# JetID TightLepVeto
#
tightJetIdLepVeto = "tightJetIdLepVeto{}".format(tagName)
if tightJetIdLepVeto in self.main:
raise ValueError("Step '%s' already implemented" %
tightJetIdLepVeto)
setattr(
proc, tightJetIdLepVeto,
proc.tightJetIdLepVeto.clone(
src=selJet,
filterParams=proc.tightJetIdLepVeto.filterParams.clone(
version="SUMMER18{}".format(
"PUPPI" if recoJetInfo.jetPUMethod ==
"puppi" else "")),
))
tightJetIdLepVetoObj = getattr(proc, tightJetIdLepVeto)
run2_jme_2016.toModify(tightJetIdLepVetoObj.filterParams,
version="WINTER16")
run2_jme_2017.toModify(
tightJetIdLepVetoObj.filterParams,
version='WINTER17{}'.format(
"PUPPI" if recoJetInfo.jetPUMethod == "puppi" else ""),
)
currentTasks.append(tightJetIdLepVeto)
#
#
#
selectedPatJetsWithUserData = "{}WithUserData".format(selJet)
if selectedPatJetsWithUserData in self.main:
raise ValueError("Step '%s' already implemented" %
selectedPatJetsWithUserData)
setattr(
proc, selectedPatJetsWithUserData,
cms.EDProducer(
"PATJetUserDataEmbedder",
src=cms.InputTag(selJet),
userFloats=cms.PSet(
jercCHPUF=cms.InputTag(
"{}:chargedHadronPUEnergyFraction".format(
jercVar)),
jercCHF=cms.InputTag(
"{}:chargedHadronCHSEnergyFraction".format(
jercVar)),
),
userInts=cms.PSet(
tightId=cms.InputTag(tightJetId),
tightIdLepVeto=cms.InputTag(tightJetIdLepVeto),
),
))
selectedPatJetsWithUserDataObj = getattr(
proc, selectedPatJetsWithUserData)
run2_jme_2016.toModify(
selectedPatJetsWithUserDataObj.userInts,
looseId=cms.InputTag(looseJetId),
)
currentTasks.append(selectedPatJetsWithUserData)
else:
selectedPatJetsWithUserData = "selectedPatJets{}".format(tagName)
#
# Not sure why we can't re-use patJetCorrFactors* created by addJetCollection()
# (even cloning doesn't work) Let's just create our own
#
jetCorrFactors = "jetCorrFactors{}".format(tagName)
if jetCorrFactors in self.main:
raise ValueError("Step '%s' already implemented" % jetCorrFactors)
setattr(
proc, jetCorrFactors,
patJetCorrFactors.clone(
src=selectedPatJetsWithUserData,
levels=JETCorrLevels,
primaryVertices=self.pvLabel,
payload=recoJetInfo.jetCorrPayload,
rho="fixedGridRhoFastjetAll{}".format(
"Calo" if recoJetInfo.doCalo else ""),
))
currentTasks.append(jetCorrFactors)
updatedJets = "updatedJets{}".format(tagName)
if updatedJets in self.main:
raise ValueError("Step '%s' already implemented" % updatedJets)
setattr(
proc, updatedJets,
updatedPatJets.clone(
addBTagInfo=False,
jetSource=selectedPatJetsWithUserData,
jetCorrFactorsSource=[jetCorrFactors],
))
currentTasks.append(updatedJets)
self.main.extend(currentTasks)
return recoJetInfo
)
tightJetId = cms.EDProducer("PatJetIDValueMapProducer",
filterParams=cms.PSet(
version = cms.string('SUMMER18'),
quality = cms.string('TIGHT'),
),
src = cms.InputTag("updatedJets")
)
tightJetIdLepVeto = cms.EDProducer("PatJetIDValueMapProducer",
filterParams=cms.PSet(
version = cms.string('SUMMER18'),
quality = cms.string('TIGHTLEPVETO'),
),
src = cms.InputTag("updatedJets")
)
run2_jme_2016.toModify( tightJetId.filterParams, version = "WINTER16" )
run2_jme_2016.toModify( tightJetIdLepVeto.filterParams, version = "WINTER16" )
run2_jme_2017.toModify( tightJetId.filterParams, version = "WINTER17" )
run2_jme_2017.toModify( tightJetIdLepVeto.filterParams, version = "WINTER17" )
looseJetIdAK8 = cms.EDProducer("PatJetIDValueMapProducer",
filterParams=cms.PSet(
version = cms.string('WINTER16'),
quality = cms.string('LOOSE'),
),
src = cms.InputTag("updatedJetsAK8")
)
tightJetIdAK8 = cms.EDProducer("PatJetIDValueMapProducer",
filterParams=cms.PSet(
version = cms.string('SUMMER18PUPPI'),
)
tightJetId = cms.EDProducer("PatJetIDValueMapProducer",
filterParams=cms.PSet(
version = cms.string('SUMMER18'),
quality = cms.string('TIGHT'),
),
src = cms.InputTag("updatedJets")
)
tightJetIdLepVeto = cms.EDProducer("PatJetIDValueMapProducer",
filterParams=cms.PSet(
version = cms.string('SUMMER18'),
quality = cms.string('TIGHTLEPVETO'),
),
src = cms.InputTag("updatedJets")
)
run2_jme_2016.toModify( tightJetId.filterParams, version = "WINTER16" )
run2_jme_2016.toModify( tightJetIdLepVeto.filterParams, version = "WINTER16" )
run2_jme_2017.toModify( tightJetId.filterParams, version = "WINTER17" )
run2_jme_2017.toModify( tightJetIdLepVeto.filterParams, version = "WINTER17" )
looseJetIdAK8 = cms.EDProducer("PatJetIDValueMapProducer",
filterParams=cms.PSet(
version = cms.string('WINTER16'),
quality = cms.string('LOOSE'),
),
src = cms.InputTag("updatedJetsAK8")
)
tightJetIdAK8 = cms.EDProducer("PatJetIDValueMapProducer",
filterParams=cms.PSet(
version = cms.string('SUMMER18PUPPI'),
neEmEF = Var("neutralEmEnergyFraction()", float, doc="neutral Electromagnetic Energy Fraction", precision= 6),
muEF = Var("muonEnergyFraction()", float, doc="muon Energy Fraction", precision= 6),
chFPV0EF = Var("userFloat('chFPV0EF')", float, doc="charged fromPV==0 Energy Fraction (energy excluded from CHS jets). Previously called betastar.", precision= 6),
chFPV1EF = Var("userFloat('chFPV1EF')", float, doc="charged fromPV==1 Energy Fraction (component of the total charged Energy Fraction).", precision= 6),
chFPV2EF = Var("userFloat('chFPV2EF')", float, doc="charged fromPV==2 Energy Fraction (component of the total charged Energy Fraction).", precision= 6),
chFPV3EF = Var("userFloat('chFPV3EF')", float, doc="charged fromPV==3 Energy Fraction (component of the total charged Energy Fraction).", precision= 6),
)
)
#jets are not as precise as muons
jetTable.variables.pt.precision=10
### Era dependent customization
for modifier in run2_miniAOD_80XLegacy, run2_nanoAOD_94X2016:
modifier.toModify( jetTable.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"))
run2_jme_2016.toModify( jetTable.variables, puIdDisc = Var("userFloat('pileupJetId:fullDiscriminant')",float,doc="Pilup ID discriminant with 80X (2016) training",precision=10))
run2_jme_2017.toModify( jetTable.variables, puIdDisc = Var("userFloat('puId94XDisc')", float,doc="Pilup ID discriminant with 94X (2017) training",precision=10))
bjetNN= cms.EDProducer("BJetEnergyRegressionMVA",
backend = cms.string("TF"),
src = cms.InputTag("linkedObjects","jets"),
pvsrc = cms.InputTag("offlineSlimmedPrimaryVertices"),
svsrc = cms.InputTag("slimmedSecondaryVertices"),
rhosrc = cms.InputTag("fixedGridRhoFastjetAll"),
weightFile = cms.FileInPath("PhysicsTools/NanoAOD/data/breg_training_2018.pb"),
name = cms.string("JetRegNN"),
isClassifier = cms.bool(False),
variablesOrder = cms.vstring(["Jet_pt","Jet_eta","rho","Jet_mt","Jet_leadTrackPt","Jet_leptonPtRel","Jet_leptonDeltaR","Jet_neHEF",
"Jet_neEmEF","Jet_vtxPt","Jet_vtxMass","Jet_vtx3dL","Jet_vtxNtrk","Jet_vtx3deL",
"Jet_numDaughters_pt03","Jet_energyRing_dR0_em_Jet_rawEnergy","Jet_energyRing_dR1_em_Jet_rawEnergy",
