task = getPatAlgosToolsTask(process)
process.endpath = cms.EndPath(task)
## Tau ID
#from phoJetAnalysis.phoJetNtuplizer.runTauIdMVA import *
#na = TauIDEmbedder(process, cms, # pass tour process object
# debug=True,
# toKeep = ["2017v2"] # pick the one you need: ["2017v1", "2017v2", "newDM2017v2", "dR0p32017v2", "2016v1", "newDM2016v1"]
# )
#na.runTauID()
## Tau ID DNN based
updatedTauName = "slimmedTausNewID" #name of pat::Tau collection with new tau-Ids
import RecoTauTag.RecoTau.tools.runTauIdMVA as tauIdConfig
tauIdEmbedder = tauIdConfig.TauIDEmbedder(
process,
cms,
debug=False,
updatedTauName=updatedTauName,
toKeep=["2017v2", "deepTau2017v2p1", "againstEle2018"])
tauIdEmbedder.runTauID()
### Analyzer Related
process.load("phoJetAnalysis.phoJetNtuplizer.phoJetNtuplizer_cfi")
process.phoJetNtuplizer.debug = cms.bool(False)
process.phoJetNtuplizer.runak8Jets = cms.bool(False)
process.phoJetNtuplizer.runJetWidthCalculator = cms.bool(True)
# needed for monoZprime Analysis [Valid only if runJets is True]
process.phoJetNtuplizer.jetsAK4Token = cms.InputTag(
"selectedUpdatedPatJetsUpdatedJECAK4")
process.p = cms.Path(
process.fullPatMetSequence * process.ecalBadCalibReducedMINIAODFilter *
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.computeMuonIDMVA = 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.ProcessModifiers.pp_on_AA_cff import pp_on_AA
pp_on_AA.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("")
_dummyPatJets = process.selectedPatJets.clone(cut="pt < 0")
task = getPatAlgosToolsTask(process)
def _applySubstructure(process):
from PhysicsTools.PatAlgos.tools.jetTools import addJetCollection
from PhysicsTools.PatAlgos.slimming.applySubstructure_cff import applySubstructure
applySubstructure(process)
(~pp_on_AA).toModify(process, _applySubstructure)
pp_on_AA.toModify(process,
func=lambda p: addToProcessAndTask(
'slimmedJets', p.selectedPatJets.clone(), p, task))
pp_on_AA.toModify(process,
func=lambda p: addToProcessAndTask(
'slimmedJetsAK8', _dummyPatJets.clone(), p, task))
#
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 =========
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)
(~pp_on_AA).toModify(process.slimmedMETs, addDeepMETs=True)
def _add_slimmedMETsNoHF(process):
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
(~pp_on_AA).toModify(process, _add_slimmedMETsNoHF)
# ================== NoHF pfMET
# ================== CHSMET
process.load("CommonTools.ParticleFlow.pfCHS_cff")
task.add(process.pfCHS)
from RecoMET.METProducers.pfMet_cfi import pfMet
process.pfMetCHS = pfMet.clone(src='pfCHS')
task.add(process.pfMetCHS)
addMETCollection(process, labelName="patCHSMet", metSource="pfMetCHS")
process.patCHSMet.computeMETSignificance = cms.bool(False)
# ================== CHSMET
# ================== TrkMET
process.TrkCands = chargedPackedCandsForTkMet.clone()
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 += [
'QGTagger:qgLikelihood',
]
#HF jet shower shape
process.load('RecoJets.JetProducers.hfJetShowerShape_cfi')
task.add(process.hfJetShowerShape)
process.patJets.userData.userFloats.src += [
'hfJetShowerShape:sigmaEtaEta', 'hfJetShowerShape:sigmaPhiPhi'
]
process.patJets.userData.userInts.src += [
'hfJetShowerShape:centralEtaStripSize',
'hfJetShowerShape:adjacentEtaStripsSize'
]
## DeepCSV meta discriminators (simple arithmethic on output probabilities)
def _add_deepFlavour(process):
process.load('RecoBTag.Combined.deepFlavour_cff')
task.add(process.pfDeepCSVDiscriminatorsJetTags)
process.patJets.discriminatorSources.extend([
'pfDeepCSVDiscriminatorsJetTags:BvsAll',
'pfDeepCSVDiscriminatorsJetTags:CvsB',
'pfDeepCSVDiscriminatorsJetTags:CvsL',
])
from Configuration.Eras.Modifier_pp_on_AA_2018_cff import pp_on_AA_2018
(~pp_on_AA_2018).toModify(process, _add_deepFlavour)
## 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 += [
'caloJetMap:pt', 'caloJetMap:emEnergyFraction'
]
pp_on_AA.toModify(process.patJets.userData.userInts, src=[])
pp_on_AA.toModify(process.patJets.userData.userFloats, src=[])
#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',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Summer16UL_ID_ISO_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Summer17UL_ID_ISO_cff',
'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Summer18UL_ID_ISO_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 and v2p5
_updatedTauName = 'slimmedTausDeepIDsv2p1'
_noUpdatedTauName = 'slimmedTausNoDeepIDs'
import RecoTauTag.RecoTau.tools.runTauIdMVA as tauIdConfig
tauIdEmbedder = tauIdConfig.TauIDEmbedder(
process,
debug=False,
originalTauName=_noUpdatedTauName,
updatedTauName=_updatedTauName,
postfix='ForMini',
toKeep=['deepTau2017v2p1', 'deepTau2018v2p5'])
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 isolation MVA
phase2_common.toModify(
tauIdEmbedder.toKeep,
func=lambda t: t.append('againstElePhase2v1')) #Phase2 Tau anti-e MVA
tauIdEmbedder.runTauID()
addToProcessAndTask(_noUpdatedTauName, process.slimmedTaus.clone(),
process, task)
delattr(process, 'slimmedTaus')
process.slimmedTaus = getattr(process, _updatedTauName).clone()
process.rerunMvaIsolationTaskForMini.add(process.slimmedTaus)
task.add(process.rerunMvaIsolationTaskForMini)
#-- 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).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).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)
def _add_jetsPuppi(process):
from PhysicsTools.PatAlgos.tools.jetTools import addJetCollection
noDeepFlavourDiscriminators = [
x.value() if isinstance(x, cms.InputTag) else x
for x in process.patJets.discriminatorSources
if not "DeepFlavour" in str(x)
]
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 > 10")
from PhysicsTools.PatAlgos.slimming.applyDeepBtagging_cff import applyDeepBtagging
applyDeepBtagging(process)
process.slimmedJetsNoDeepFlavour.dropTagInfos = '0'
process.updatedPatJetsTransientCorrectedSlimmedDeepFlavour.addTagInfos = True
process.updatedPatJetsTransientCorrectedSlimmedDeepFlavour.tagInfoSources = [
"pixelClusterTagInfos"
]
_run2_miniAOD_ANY.toModify(
process.updatedPatJetsTransientCorrectedSlimmedDeepFlavour,
addTagInfos=False)
(~pp_on_AA).toModify(process, _add_jetsPuppi)
pp_on_AA.toModify(process,
func=lambda p: addToProcessAndTask(
'slimmedJetsPuppi', _dummyPatJets.clone(), p, task))
# Embed pixelClusterTagInfos in slimmedJets
process.patJets.addTagInfos = True
process.patJets.tagInfoSources = ["pixelClusterTagInfos"]
_run2_miniAOD_ANY.toModify(process.patJets, addTagInfos=False)
from Configuration.Eras.Modifier_pp_on_AA_2018_cff import pp_on_AA_2018
pp_on_AA_2018.toModify(process.patJets,
tagInfoSources=cms.VInputTag([
"impactParameterTagInfos",
"secondaryVertexTagInfos"
]))
## puppi met
def _add_metPuppi(process):
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).toReplaceWith(
task, _rerun_puppimet_task)
runMetCorAndUncForMiniAODProduction(
process,
metType="Puppi",
jetCollUnskimmed="slimmedJetsPuppi",
recoMetFromPFCs=True,
jetFlavor="AK4PFPuppi",
postfix="Puppi")
(~pp_on_AA).toModify(process, _add_metPuppi)
process.load('PhysicsTools.PatAlgos.slimming.slimmedMETs_cfi')
task.add(process.slimmedMETs)
def _add_slimmedMETsPuppi(process):
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
(~pp_on_AA).toModify(process, _add_slimmedMETsPuppi)
def _add_deepMET(process):
from RecoMET.METPUSubtraction.deepMETProducer_cff import deepMETsResolutionTune, deepMETsResponseTune
addToProcessAndTask('deepMETsResolutionTune', deepMETsResolutionTune,
process, task)
addToProcessAndTask('deepMETsResponseTune', deepMETsResponseTune,
process, task)
(~pp_on_AA).toModify(process, _add_deepMET)
# 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.slimmedEgammaHGC_cff")
phase2_hgcal.toModify(task,
func=lambda t: t.add(process.slimmedEgammaHGCTask))
# L1 pre-firing weights for 2016, 2017, and 2018
from Configuration.Eras.Modifier_run2_L1prefiring_cff import run2_L1prefiring
from Configuration.Eras.Modifier_stage2L1Trigger_cff import stage2L1Trigger
from Configuration.Eras.Modifier_stage2L1Trigger_2017_cff import stage2L1Trigger_2017
from Configuration.Eras.Modifier_stage2L1Trigger_2018_cff import stage2L1Trigger_2018
from Configuration.Eras.Modifier_tracker_apv_vfp30_2016_cff import tracker_apv_vfp30_2016
process.load("PhysicsTools.PatUtils.L1PrefiringWeightProducer_cff")
(stage2L1Trigger & tracker_apv_vfp30_2016).toModify(
process.prefiringweight,
DataEraECAL="UL2016preVFP",
DataEraMuon="2016preVFP")
(stage2L1Trigger & ~tracker_apv_vfp30_2016).toModify(
process.prefiringweight,
DataEraECAL="UL2016postVFP",
DataEraMuon="2016postVFP")
stage2L1Trigger_2017.toModify(process.prefiringweight,
DataEraECAL="UL2017BtoF",
DataEraMuon="20172018")
stage2L1Trigger_2018.toModify(process.prefiringweight,
DataEraECAL="None",
DataEraMuon="20172018")
run2_L1prefiring.toModify(task,
func=lambda t: t.add(process.prefiringweight))
from PhysicsTools.PatAlgos.producersHeavyIons.heavyIonJetSetup import removeL1FastJetJECs
pp_on_AA.toModify(process, removeL1FastJetJECs)
))
process.maxEvents = cms.untracked.PSet( input = cms.untracked.int32(eventsToProcess) )
# Add new TauIDs
import RecoTauTag.RecoTau.tools.runTauIdMVA as tauIdConfig
toKeep = [ "2017v2", "dR0p32017v2", "newDM2017v2",
# "deepTau2017v1",
"deepTau2017v2p1",
"deepTau2018v2p5",
# "DPFTau_2016_v0",
# "DPFTau_2016_v1",
"againstEle2018",
]
tauIdEmbedder = tauIdConfig.TauIDEmbedder(process, debug = False,
updatedTauName = updatedTauName,
toKeep = toKeep)
tauIdEmbedder.runTauID()
#Another tau collection with updated tauIDs
postfix = "Ver2"
tauIdEmbedder2 = tauIdConfig.TauIDEmbedder(process, debug = False,
originalTauName = "slimmedTaus", #one can run on top of other collection than default "slimmedTaus"
updatedTauName = updatedTauName+postfix,
postfix = postfix, # defaut "", specify non-trivial postfix if tool is run more than one time
toKeep = toKeep)
tauIdEmbedder2.runTauID()
# Output definition
process.out = cms.OutputModule("PoolOutputModule",
fileName = cms.untracked.string('patTuple_newTauIDs.root'),
compressionAlgorithm = cms.untracked.string('LZMA'),
def adaptTauToMiniAODReReco(self, reclusterJets=True):
# TRYING TO MAKE THINGS MINIAOD COMPATIBLE, FROM THE START, TO THE END, 1 BY 1
#print '[adaptTauToMiniAODReReco]: Start'
jetCollection = 'slimmedJets'
# Add new jet collections if reclustering is demanded
if self.runBoosted:
jetCollection = 'boostedTauSeedsPAT' + self.postfix
from RecoTauTag.Configuration.boostedHPSPFTaus_cff import ca8PFJetsCHSprunedForBoostedTaus
setattr(
self.process,
'ca8PFJetsCHSprunedForBoostedTausPAT' + self.postfix,
ca8PFJetsCHSprunedForBoostedTaus.clone(
src='packedPFCandidates',
jetCollInstanceName='subJetsForSeedingBoostedTausPAT'))
setattr(
self.process, 'boostedTauSeedsPAT' + self.postfix,
cms.EDProducer(
"PATBoostedTauSeedsProducer",
subjetSrc=cms.InputTag(
'ca8PFJetsCHSprunedForBoostedTausPAT' + self.postfix,
'subJetsForSeedingBoostedTausPAT'),
pfCandidateSrc=cms.InputTag('packedPFCandidates'),
verbosity=cms.int32(0)))
self.miniAODTausTask.add(
getattr(self.process,
'ca8PFJetsCHSprunedForBoostedTausPAT' + self.postfix))
self.miniAODTausTask.add(
getattr(self.process, 'boostedTauSeedsPAT' + self.postfix))
elif reclusterJets:
jetCollection = 'patJetsPAT' + self.postfix
from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets
setattr(self.process, 'ak4PFJetsPAT' + self.postfix,
ak4PFJets.clone(src="packedPFCandidates"))
# trivial PATJets
from PhysicsTools.PatAlgos.producersLayer1.jetProducer_cfi import _patJets
setattr(
self.process, 'patJetsPAT' + self.postfix,
_patJets.clone(
jetSource="ak4PFJetsPAT" + self.postfix,
addJetCorrFactors=False,
jetCorrFactorsSource=[],
addBTagInfo=False,
addDiscriminators=False,
discriminatorSources=[],
addAssociatedTracks=False,
addJetCharge=False,
addGenPartonMatch=False,
embedGenPartonMatch=False,
addGenJetMatch=False,
getJetMCFlavour=False,
addJetFlavourInfo=False,
))
self.miniAODTausTask.add(
getattr(self.process, 'ak4PFJetsPAT' + self.postfix))
self.miniAODTausTask.add(
getattr(self.process, 'patJetsPAT' + self.postfix))
# so this adds all tracks to jet in some deltaR region. we don't have tracks so don't need it :D
# self.process.ak4PFJetTracksAssociatorAtVertex.jets = cms.InputTag(jetCollection)
# Remove ak4PFJetTracksAssociatorAtVertex from recoTauCommonSequence
# Remove pfRecoTauTagInfoProducer from recoTauCommonSequence since it uses the jet-track association
# HOWEVER, may use https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookMiniAOD2017#Isolated_Tracks
# probably needs recovery of the two modules above
self.miniAODTausTask.remove(
getattr(self.process,
'ak4PFJetTracksAssociatorAtVertex' + self.postfix))
self.miniAODTausTask.remove(
getattr(self.process, 'pfRecoTauTagInfoProducer' + self.postfix))
self.miniAODTausTask.remove(
getattr(self.process, 'recoTauAK4PFJets08Region' + self.postfix))
setattr(
self.process, 'recoTauAK4Jets08RegionPAT' + self.postfix,
cms.EDProducer(
"RecoTauPatJetRegionProducer",
deltaR=self.process.recoTauAK4PFJets08Region.deltaR,
maxJetAbsEta=self.process.recoTauAK4PFJets08Region.
maxJetAbsEta,
minJetPt=self.process.recoTauAK4PFJets08Region.minJetPt,
pfCandAssocMapSrc=cms.InputTag(""),
pfCandSrc=cms.InputTag("packedPFCandidates"),
src=cms.InputTag(jetCollection)))
_jetRegionProducer = getattr(
self.process, 'recoTauAK4Jets08RegionPAT' + self.postfix)
self.miniAODTausTask.add(_jetRegionProducer)
if self.runBoosted:
_jetRegionProducer.pfCandAssocMapSrc = cms.InputTag(
jetCollection, 'pfCandAssocMapForIsolation')
getattr(self.process, 'recoTauPileUpVertices' +
self.postfix).src = "offlineSlimmedPrimaryVertices"
for moduleName in self.miniAODTausTask.moduleNames():
self.convertModuleToMiniAODInput(moduleName)
# Adapt TauPiZeros producer
_piZeroProducer = getattr(self.process,
'ak4PFJetsLegacyHPSPiZeros' + self.postfix)
for builder in _piZeroProducer.builders:
builder.qualityCuts.primaryVertexSrc = "offlineSlimmedPrimaryVertices"
_piZeroProducer.jetSrc = jetCollection
# Adapt TauChargedHadrons producer
_chargedHadronProducer = getattr(
self.process, 'ak4PFJetsRecoTauChargedHadrons' + self.postfix)
for builder in _chargedHadronProducer.builders:
builder.qualityCuts.primaryVertexSrc = "offlineSlimmedPrimaryVertices"
if builder.name.value(
) == 'tracks': #replace plugin based on generalTracks by one based on lostTracks
builder.name = 'lostTracks'
builder.plugin = 'PFRecoTauChargedHadronFromLostTrackPlugin'
builder.srcTracks = "lostTracks"
if self.runBoosted:
builder.dRcone = 0.3
builder.dRconeLimitedToJetArea = True
_chargedHadronProducer.jetSrc = jetCollection
# Adapt combinatoricRecoTau producer
_combinatoricRecoTauProducer = getattr(
self.process, 'combinatoricRecoTaus' + self.postfix)
_combinatoricRecoTauProducer.jetRegionSrc = 'recoTauAK4Jets08RegionPAT' + self.postfix
_combinatoricRecoTauProducer.jetSrc = jetCollection
# Adapt builders
for builder in _combinatoricRecoTauProducer.builders:
for name, value in builder.parameters_().items():
if name == 'qualityCuts':
builder.qualityCuts.primaryVertexSrc = 'offlineSlimmedPrimaryVertices'
elif name == 'pfCandSrc':
builder.pfCandSrc = 'packedPFCandidates'
# Adapt supported modifiers and remove unsupported ones
_modifiersToRemove = cms.VPSet()
for mod in _combinatoricRecoTauProducer.modifiers:
if mod.name.value() == 'elec_rej':
_modifiersToRemove.append(mod)
continue
elif mod.name.value() == 'TTIworkaround':
_modifiersToRemove.append(mod)
continue
elif mod.name.value() == 'tau_lost_tracks':
_modifiersToRemove.append(mod)
continue
for name, value in mod.parameters_().items():
if name == 'qualityCuts':
mod.qualityCuts.primaryVertexSrc = 'offlineSlimmedPrimaryVertices'
for mod in _modifiersToRemove:
_combinatoricRecoTauProducer.modifiers.remove(mod)
#print "\t\t Removing '%s' modifier from 'combinatoricRecoTaus'" %mod.name.value()
# Redefine tau PV producer
_tauPVProducer = getattr(
self.process, 'hpsPFTauPrimaryVertexProducer' + self.postfix)
_tauPVProducer.__dict__[
'_TypedParameterizable__type'] = 'PFTauMiniAODPrimaryVertexProducer'
_tauPVProducer.PVTag = 'offlineSlimmedPrimaryVertices'
_tauPVProducer.packedCandidatesTag = cms.InputTag("packedPFCandidates")
_tauPVProducer.lostCandidatesTag = cms.InputTag("lostTracks")
# Redefine tau SV producer
setattr(
self.process, 'hpsPFTauSecondaryVertexProducer' + self.postfix,
cms.EDProducer("PFTauSecondaryVertexProducer",
PFTauTag=cms.InputTag("hpsPFTauProducer" +
self.postfix)))
# Remove RecoTau producers which are not supported (yet?), i.e. against-e/mu discriminats
for moduleName in self.miniAODTausTask.moduleNames():
if 'ElectronRejection' in moduleName or 'MuonRejection' in moduleName:
if 'ByDeadECALElectronRejection' in moduleName: continue
self.miniAODTausTask.remove(getattr(self.process, moduleName))
# Instead add against-mu discriminants which are MiniAOD compatible
from RecoTauTag.RecoTau.hpsPFTauDiscriminationByMuonRejectionSimple_cff import hpsPFTauDiscriminationByMuonRejectionSimple
setattr(
self.process,
'hpsPFTauDiscriminationByMuonRejectionSimple' + self.postfix,
hpsPFTauDiscriminationByMuonRejectionSimple.clone(
PFTauProducer="hpsPFTauProducer" + self.postfix))
_tauIDAntiMuSimple = getattr(
self.process,
'hpsPFTauDiscriminationByMuonRejectionSimple' + self.postfix)
if self.runBoosted:
_tauIDAntiMuSimple.dRmuonMatch = 0.1
self.miniAODTausTask.add(_tauIDAntiMuSimple)
#####
# PAT part in the following
getattr(self.process, 'tauGenJets' +
self.postfix).GenParticles = "prunedGenParticles"
getattr(self.process,
'tauMatch' + self.postfix).matched = "prunedGenParticles"
# Remove unsupported tauIDs
_patTauProducer = getattr(self.process, 'patTaus' + self.postfix)
for name, src in _patTauProducer.tauIDSources.parameters_().items():
if name.find('againstElectron') > -1 or name.find(
'againstMuon') > -1:
if name.find('againstElectronDeadECAL') > -1: continue
delattr(_patTauProducer.tauIDSources, name)
# Add MiniAOD specific ones
setattr(
_patTauProducer.tauIDSources, 'againstMuonLooseSimple',
cms.PSet(inputTag=cms.InputTag(
'hpsPFTauDiscriminationByMuonRejectionSimple' + self.postfix),
provenanceConfigLabel=cms.string('IDWPdefinitions'),
idLabel=cms.string('ByLooseMuonRejectionSimple')))
setattr(
_patTauProducer.tauIDSources, 'againstMuonTightSimple',
cms.PSet(inputTag=cms.InputTag(
'hpsPFTauDiscriminationByMuonRejectionSimple' + self.postfix),
provenanceConfigLabel=cms.string('IDWPdefinitions'),
idLabel=cms.string('ByTightMuonRejectionSimple')))
#Add Run-2 tauIDs still used for boostedTaus
if self.runBoosted:
from PhysicsTools.PatAlgos.producersLayer1.tauProducer_cfi import containerID
containerID(
_patTauProducer.tauIDSources,
"hpsPFTauDiscriminationByIsolationMVArun2v1DBoldDMwLT" +
self.postfix, "rawValues",
[["byIsolationMVArun2DBoldDMwLTraw", "discriminator"]])
containerID(
_patTauProducer.tauIDSources,
"hpsPFTauDiscriminationByIsolationMVArun2v1DBoldDMwLT" +
self.postfix, "workingPoints",
[["byVVLooseIsolationMVArun2DBoldDMwLT", "_VVLoose"],
["byVLooseIsolationMVArun2DBoldDMwLT", "_VLoose"],
["byLooseIsolationMVArun2DBoldDMwLT", "_Loose"],
["byMediumIsolationMVArun2DBoldDMwLT", "_Medium"],
["byTightIsolationMVArun2DBoldDMwLT", "_Tight"],
["byVTightIsolationMVArun2DBoldDMwLT", "_VTight"],
["byVVTightIsolationMVArun2DBoldDMwLT", "_VVTight"]])
containerID(
_patTauProducer.tauIDSources,
"hpsPFTauDiscriminationByIsolationMVArun2v1DBnewDMwLT" +
self.postfix, "rawValues",
[["byIsolationMVArun2DBnewDMwLTraw", "discriminator"]])
containerID(
_patTauProducer.tauIDSources,
"hpsPFTauDiscriminationByIsolationMVArun2v1DBnewDMwLT" +
self.postfix, "workingPoints",
[["byVVLooseIsolationMVArun2DBnewDMwLT", "_VVLoose"],
["byVLooseIsolationMVArun2DBnewDMwLT", "_VLoose"],
["byLooseIsolationMVArun2DBnewDMwLT", "_Loose"],
["byMediumIsolationMVArun2DBnewDMwLT", "_Medium"],
["byTightIsolationMVArun2DBnewDMwLT", "_Tight"],
["byVTightIsolationMVArun2DBnewDMwLT", "_VTight"],
["byVVTightIsolationMVArun2DBnewDMwLT", "_VVTight"]])
# Run TauIDs (anti-e && deepTau) on top of selectedPatTaus
_updatedTauName = 'selectedPatTausNewIDs' + self.postfix
_noUpdatedTauName = 'selectedPatTausNoNewIDs' + self.postfix
toKeep = ['deepTau2017v2p1']
#For boosted do not run deepTauIDs, but add still used Run-2 anti-e MVA
if self.runBoosted:
toKeep = ['againstEle2018']
import RecoTauTag.RecoTau.tools.runTauIdMVA as tauIdConfig
tauIdEmbedder = tauIdConfig.TauIDEmbedder(
self.process,
debug=False,
originalTauName=_noUpdatedTauName,
updatedTauName=_updatedTauName,
postfix="MiniAODTaus" + self.postfix,
toKeep=toKeep)
tauIdEmbedder.runTauID()
setattr(
self.process, _noUpdatedTauName,
getattr(self.process, 'selectedPatTaus' + self.postfix).clone())
self.miniAODTausTask.add(getattr(self.process, _noUpdatedTauName))
delattr(self.process, 'selectedPatTaus' + self.postfix)
setattr(self.process, 'selectedPatTaus' + self.postfix,
getattr(self.process, _updatedTauName).clone())
delattr(self.process, _updatedTauName)
setattr(
self.process, 'newTauIDsTask' + self.postfix,
cms.Task(
getattr(self.process,
'rerunMvaIsolationTaskMiniAODTaus' + self.postfix),
getattr(self.process, 'selectedPatTaus' + self.postfix)))
self.miniAODTausTask.add(
getattr(self.process, 'newTauIDsTask' + self.postfix))
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
run2_miniAOD_80XLegacy.toModify(process.patElectrons,
addPFClusterIso = cms.bool(True),
ecalPFClusterIsoMap = cms.InputTag("reducedEgamma", "eleEcalPFClusIso"),
hcalPFClusterIsoMap = cms.InputTag("reducedEgamma", "eleHcalPFClusIso"))
from Configuration.Eras.Modifier_run2_miniAOD_94XFall17_cff import run2_miniAOD_94XFall17
run2_miniAOD_94XFall17.toModify(process.patElectrons,
addPFClusterIso = cms.bool(True),
ecalPFClusterIsoMap = cms.InputTag("reducedEgamma", "eleEcalPFClusIso"),
hcalPFClusterIsoMap = cms.InputTag("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-")
from Configuration.Eras.Modifier_run2_miniAOD_80XLegacy_cff import run2_miniAOD_80XLegacy
run2_miniAOD_80XLegacy.toModify(process.patPhotons,
addPFClusterIso = cms.bool(True),
ecalPFClusterIsoMap = cms.InputTag("reducedEgamma", "phoEcalPFClusIso"),
hcalPFClusterIsoMap = cms.InputTag("reducedEgamma", "phoHcalPFClusIso"))
from Configuration.Eras.Modifier_run2_miniAOD_94XFall17_cff import run2_miniAOD_94XFall17
run2_miniAOD_94XFall17.toModify(process.patPhotons,
addPFClusterIso = cms.bool(True),
ecalPFClusterIsoMap = cms.InputTag("reducedEgamma", "phoEcalPFClusIso"),
hcalPFClusterIsoMap = cms.InputTag("reducedEgamma", "phoHcalPFClusIso"))
#the 80X legacy customsations are done in ootPhotonProducer for OOT photons
run2_miniAOD_94XFall17.toModify(process.patOOTPhotons,
addPFClusterIso = cms.bool(True),
ecalPFClusterIsoMap = cms.InputTag("reducedEgamma", "ootPhoEcalPFClusIso"),
hcalPFClusterIsoMap = cms.InputTag("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')) )")
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)
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)
process.pfMetCHS = cms.EDProducer("PFMETProducer",
src = cms.InputTag("CHSCands"),
alias = cms.string('pfMet'),
globalThreshold = cms.double(0.0),
calculateSignificance = cms.bool(False),
)
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 = cms.EDProducer("PFMETProducer",
src = cms.InputTag("TrkCands"),
alias = cms.string('pfMet'),
globalThreshold = cms.double(0.0),
calculateSignificance = cms.bool(False),
)
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')
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
from Configuration.Eras.Modifier_run2_miniAOD_94XFall17_cff import run2_miniAOD_94XFall17
_makePatTausTaskWithRetrainedMVATauID = process.makePatTausTask.copy()
_makePatTausTaskWithRetrainedMVATauID.add(process.hpsPFTauDiscriminationByIsolationMVArun2v1DBoldDMwLTTask,
process.hpsPFTauDiscriminationByIsolationMVArun2v1DBnewDMwLTTask,
process.hpsPFTauIsolationSums03Task,
process.hpsPFTauDiscriminationByIsolationMVArun2v1DBdR03oldDMwLTTask)
run2_miniAOD_94XFall17.toReplaceWith(
process.makePatTausTask, _makePatTausTaskWithRetrainedMVATauID
)
#-- Adding DeepTauID
# deepTau v2p1
_updatedTauName = 'slimmedTausDeepIDsv2p1'
_noUpdatedTauName = 'slimmedTausNoDeepIDs'
import RecoTauTag.RecoTau.tools.runTauIdMVA as tauIdConfig
tauIdEmbedder = tauIdConfig.TauIDEmbedder(
process, cms, debug = False,
updatedTauName = _updatedTauName,
toKeep = ['deepTau2017v2p1']
)
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)
#-- Adding customization for 80X 2016 legacy reMiniAOD and 2018 heavy ions
from Configuration.Eras.Modifier_run2_miniAOD_80XLegacy_cff import run2_miniAOD_80XLegacy
from Configuration.Eras.Modifier_pp_on_AA_2018_cff import pp_on_AA_2018
_makePatTausTaskWithTauReReco = process.makePatTausTask.copy()
_makePatTausTaskWithTauReReco.add(process.PFTauTask)
(run2_miniAOD_80XLegacy | pp_on_AA_2018).toReplaceWith(
process.makePatTausTask, _makePatTausTaskWithTauReReco
)
# Adding puppi jets
if not hasattr(process, 'ak4PFJetsPuppi'): #MM: avoid confilct with substructure call
process.load('RecoJets.JetProducers.ak4PFJetsPuppi_cfi')
task.add(process.ak4PFJets)
task.add(process.ak4PFJetsPuppi)
process.ak4PFJetsPuppi.doAreaFastjet = True # even for standard ak4PFJets this is overwritten in RecoJets/Configuration/python/RecoPFJets_cff
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('slimmedJetsPuppiNoMultiplicities', process.slimmedJetsNoDeepFlavour.clone(), process, task)
process.slimmedJetsPuppiNoMultiplicities.src = cms.InputTag("selectedPatJetsPuppi")
process.slimmedJetsPuppiNoMultiplicities.packedPFCandidates = cms.InputTag("packedPFCandidates")
from PhysicsTools.PatAlgos.patPuppiJetSpecificProducer_cfi import patPuppiJetSpecificProducer
from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection
process.patPuppiJetSpecificProducer = patPuppiJetSpecificProducer.clone(
src=cms.InputTag("slimmedJetsPuppiNoMultiplicities"),
)
task.add(process.patPuppiJetSpecificProducer)
updateJetCollection(
process,
labelName = 'PuppiJetSpecific',
jetSource = cms.InputTag('slimmedJetsPuppiNoMultiplicities'),
)
process.updatedPatJetsPuppiJetSpecific.userData.userFloats.src = ['patPuppiJetSpecificProducer:puppiMultiplicity', 'patPuppiJetSpecificProducer:neutralPuppiMultiplicity', 'patPuppiJetSpecificProducer:neutralHadronPuppiMultiplicity', 'patPuppiJetSpecificProducer:photonPuppiMultiplicity', 'patPuppiJetSpecificProducer:HFHadronPuppiMultiplicity', 'patPuppiJetSpecificProducer:HFEMPuppiMultiplicity' ]
process.slimmedJetsPuppi = process.selectedUpdatedPatJetsPuppiJetSpecific.clone()
delattr(process, 'selectedUpdatedPatJetsPuppiJetSpecific')
task.add(process.slimmedJetsPuppi)
# Embed pixelClusterTagInfos in slimmedJets
process.patJets.addTagInfos = True
process.patJets.tagInfoSources = cms.VInputTag( cms.InputTag("pixelClusterTagInfos") )
process.slimmedJetsNoDeepFlavour.dropTagInfos = '0'
process.updatedPatJetsTransientCorrectedSlimmedDeepFlavour.addTagInfos = True
process.updatedPatJetsTransientCorrectedSlimmedDeepFlavour.tagInfoSources = cms.VInputTag( cms.InputTag("pixelClusterTagInfos") )
from Configuration.Eras.Modifier_run2_miniAOD_80XLegacy_cff import run2_miniAOD_80XLegacy
run2_miniAOD_80XLegacy.toModify(process.patJets, addTagInfos = False )
run2_miniAOD_80XLegacy.toModify(process.updatedPatJetsTransientCorrectedSlimmedDeepFlavour, addTagInfos = False )
from Configuration.Eras.Modifier_run2_miniAOD_94XFall17_cff import run2_miniAOD_94XFall17
run2_miniAOD_94XFall17.toModify(process.patJets, addTagInfos = False )
run2_miniAOD_94XFall17.toModify(process.updatedPatJetsTransientCorrectedSlimmedDeepFlavour, addTagInfos = False )
## puppi met
from PhysicsTools.PatAlgos.slimming.puppiForMET_cff import makePuppies
makePuppies( process );
runMetCorAndUncForMiniAODProduction(process, metType="Puppi",
pfCandColl=cms.InputTag("puppiForMET"),
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
# 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))
if options.maxEvents > 0:
process.maxEvents.input = options.maxEvents
if len(options.lumiFile) > 0:
import FWCore.PythonUtilities.LumiList as LumiList
process.source.lumisToProcess = LumiList.LumiList(
filename=options.lumiFile).getVLuminosityBlockRange()
if options.eventList != '':
process.source.eventsToProcess = cms.untracked.VEventRange(
re.split(',', options.eventList))
import RecoTauTag.RecoTau.tools.runTauIdMVA as tauIdConfig
updatedTauName = "slimmedTausNewID"
tauIdEmbedder = tauIdConfig.TauIDEmbedder(process,
cms,
updatedTauName=updatedTauName,
toKeep=["deepTau2017v2"])
tauIdEmbedder.runTauID()
process.tauTupleProducer = cms.EDAnalyzer(
'DeepTauTest',
isMC=cms.bool(not isData),
genEvent=cms.InputTag('generator'),
genParticles=cms.InputTag('prunedGenParticles'),
taus=cms.InputTag('slimmedTausNewID'))
process.tupleProductionSequence = cms.Sequence(process.tauTupleProducer)
process.p = cms.Path(process.rerunMvaIsolationSequence *
getattr(process, updatedTauName) *
process.tupleProductionSequence)
labelEra = '2018-Prompt'
rerunIDs = True
rerunEnergyCorrections = True
setupEgammaPostRecoSeq(process,
runVID=rerunIDs,
runEnergyCorrections=rerunEnergyCorrections,
era=labelEra)
# Tau ID ===============================================================================================
# https://twiki.cern.ch/twiki/bin/view/CMSPublic/SWGuidePFTauID#Running_of_the_DNN_based_tau_ID
updatedTauName = "NewTauIDsEmbedded" #name of pat::Tau collection with new tau-Ids
import RecoTauTag.RecoTau.tools.runTauIdMVA as tauIdConfig
tauIdEmbedder = tauIdConfig.TauIDEmbedder(
process,
cms,
debug=False,
updatedTauName=updatedTauName,
toKeep=["2017v2", "deepTau2017v2p1", "MVADM_2016_v1", "MVADM_2017_v1"])
tauIdEmbedder.runTauID()
# END Tau ID ===========================================================================================
# Vertex Refitting ===============================================================================================
#load vertex refitting excluding tau tracks
process.load('HiggsCPinTauDecays.TauRefit.AdvancedRefitVertexProducer_cfi')
process.load('HiggsCPinTauDecays.TauRefit.LeptonPreSelections_cfi')
process.load('HiggsCPinTauDecays.TauRefit.MiniAODRefitVertexProducer_cfi')
# END Vertex Refitting ===========================================================================================
# HTXS ========================================================================================================
rParam=cms.double(rParam),
jetAlgorithm=cms.string(jetAlgo))
process.matchGenBHadron = matchGenBHadron.clone(
genParticles=genParticleCollection, jetFlavourInfos=jetFlavourInfos)
process.matchGenCHadron = matchGenCHadron.clone(
genParticles=genParticleCollection, jetFlavourInfos=jetFlavourInfos)
#####Tau#####
updatedTauName = "slimmedTausNewID" #name of pat::Tau collection with new tau-Ids
import RecoTauTag.RecoTau.tools.runTauIdMVA as tauIdConfig
tauIdEmbedder = tauIdConfig.TauIDEmbedder(
process,
cms,
debug=False,
updatedTauName=updatedTauName,
toKeep=["deepTau2017v2p1", "dR0p32017v2"]
) # pick the one you need: ["2017v1", "2017v2", "newDM2017v2", "dR0p32017v2", "2016v1", "newDM2016v1","deepTau2017v2"]
tauIdEmbedder.runTauID()
############### MET Re-correct ##################
from PhysicsTools.PatUtils.tools.runMETCorrectionsAndUncertainties import runMetCorAndUncFromMiniAOD
runMetCorAndUncFromMiniAOD(
process,
isData=True, # false for MC
fixEE2017=False,
fixEE2017Params={
'userawPt': True,
'ptThreshold': 50.0,
if is2017: yy = '17'
elif is2018: yy = '18'
yyy = '16'
if is2017 or is2018: yyy = '17'
#
#Latest tau ID
#
updatedTauName = "slimmedTausNewID" #name of pat::Tau collection with new tau-Ids
import RecoTauTag.RecoTau.tools.runTauIdMVA as tauIdConfig
tauIdEmbedder = tauIdConfig.TauIDEmbedder(
process,
cms,
debug=False,
updatedTauName=updatedTauName,
toKeep=[
"2017v2",
"newDM2017v2", #classic MVAIso tau-Ids
"deepTau2017v2p1" #latest deepTau2017v2p1
])
tauIdEmbedder.runTauID()
#rochester correction file to use
if is2017:
rochesterCorrectionFile = 'RoccoR2017.txt'
elif is2018:
rochesterCorrectionFile = 'RoccoR2018.txt'
else:
rochesterCorrectionFile = 'RoccoR2016.txt'
# Main Process
# File from dataset DY1JetsToLL_M-50_TuneCP5_13TeV-madgraphMLM-pythia8
'/store/mc/RunIIFall17MiniAODv2/TTToHadronic_mtop169p5_TuneCP5_PSweights_13TeV-powheg-pythia8/MINIAODSIM/PU2017_12Apr2018_94X_mc2017_realistic_v14-v3/100000/64BE09E8-76A8-E811-8602-FA163EC538AA.root'
))
process.maxEvents = cms.untracked.PSet(
input=cms.untracked.int32(eventsToProcess))
# Add new TauIDs
import RecoTauTag.RecoTau.tools.runTauIdMVA as tauIdConfig
tauIdEmbedder = tauIdConfig.TauIDEmbedder(
process,
cms,
debug=False,
updatedTauName=updatedTauName,
toKeep=[
"2017v2",
"dR0p32017v2",
"newDM2017v2",
"deepTau2017v1",
"DPFTau_2016_v0",
# "DPFTau_2016_v1"
])
tauIdEmbedder.runTauID()
# Output definition
process.out = cms.OutputModule(
"PoolOutputModule",
fileName=cms.untracked.string('patTuple_newTauIDs.root'),
compressionAlgorithm=cms.untracked.string('LZMA'),
compressionLevel=cms.untracked.int32(4),
outputCommands=cms.untracked.vstring('drop *'))
if options.applyTauFilter:
process.tauFilter = cms.EDFilter(
"TauFilter",
tauCollection=cms.InputTag("slimmedTaus"),
minpt=cms.double(20.),
maxeta=cms.double(2.3),
)
mypath = mypath * process.tauFilter
updatedTauName = "slimmedTausNewID" #name of pat::Tau collection with new tau-Ids
import RecoTauTag.RecoTau.tools.runTauIdMVA as tauIdConfig
tauIdEmbedder = tauIdConfig.TauIDEmbedder(
process,
cms,
debug=False,
updatedTauName=updatedTauName,
toKeep=[
"deepTau2017v2p1", #deepTau TauIDs
])
tauIdEmbedder.runTauID()
process.goodTaus = cms.EDFilter("TauProducer",
tauCollection=cms.InputTag(updatedTauName),
minpt=cms.double(20.),
maxeta=cms.double(2.3),
applyFilter=cms.bool(False))
mypath = mypath * process.rerunMvaIsolationSequence * getattr(
process, updatedTauName) * process.goodTaus
process.triggerProducer = cms.EDFilter(
"TriggerProducer",
#from JetMETCorrections.Configuration.DefaultJEC_cff import ak4PFJetsL1FastL2L3
#process.load("RecoMET.METPUSubtraction.mvaPFMET_cff")
#process.task.add(process.pfMVAMEtTask)
#process.MVAMET = process.pfMVAMEtTask
#process.pfMVAMEt.srcLeptons = cms.VInputTag("slimmedElectrons")
#process.pfMVAMEt.srcPFCandidates = cms.InputTag("packedPFCandidates")
#process.pfMVAMEt.srcVertices = cms.InputTag("offlineSlimmedPrimaryVertices")
updatedTauName = "slimmedTausNewID" #name of pat::Tau collection with new tau-Id
import RecoTauTag.RecoTau.tools.runTauIdMVA as tauIdConfig
tauIdEmbedder = tauIdConfig.TauIDEmbedder(
process,
cms,
debug=False,
updatedTauName=updatedTauName,
toKeep=["MVADM_2017_v1"]) #other tauIDs can be added in
tauIdEmbedder.runTauID()
# Path and EndPath definitions
# Was not commented
#process.p = cms.Path(
# process.rerunMvaIsolationSequence *
# getattr(process,updatedTauName)
#)
# EGamma POG corrections (not sure in era is OK for MC samples we use now)
#from RecoEgamma.EgammaTools.EgammaPostRecoTools import setupEgammaPostRecoSeq
sys.path.append(
'/afs/cern.ch/user/a/aoskin/Tau_packeges/CMSSW_10_2_22/src/EgammaUser/EgammaPostRecoTools/python/'
)
process.pfImpactParameterTagInfosNewDFTraining +
process.pfInclusiveSecondaryVertexFinderTagInfosNewDFTraining +
process.pfDeepCSVTagInfosNewDFTraining +
process.pfDeepFlavourTagInfosNewDFTraining +
process.pfDeepFlavourJetTagsNewDFTraining +
process.patJetCorrFactorsTransientCorrectedNewDFTraining +
process.updatedPatJetsTransientCorrectedNewDFTraining +
process.selectedUpdatedPatJetsNewDFTraining)
#START RERUNNING OF ID TRAINING
#
# set up the rerunning of the latest tau id trainings
import RecoTauTag.RecoTau.tools.runTauIdMVA as idemb
na = idemb.TauIDEmbedder(process,
cms,
debug=True,
updatedTauName="NewTauIDsEmbedded",
toKeep=["2017v2", "newDM2017v2", "deepTau2017v2p1"])
na.runTauID()
# Produce the quark gluon likelihood variable
process.load("PhysicsTools.PatAlgos.patSequences_cff")
process.load("RecoJets.JetProducers.QGTagger_cfi")
process.QGTagger.srcJets = cms.InputTag("slimmedJets")
process.QGTagger.jetsLabel = cms.string("QGL_AK4PFchs")
if not isMC: # will use 80X
from Configuration.AlCa.autoCond import autoCond
process.GlobalTag.globaltag = '102X_dataRun2_Sep2018ABC_v2'
# process.GlobalTag.globaltag = '102X_dataRun2_Prompt_v13'
process.load('QCDTauTagAndProbe.QCDTauTagAndProbe.tagAndProbe_2018_cff')
process.source = cms.Source("PoolSource",
fileNames=cms.untracked.vstring(
test_files[key]['file']),
secondaryFileNames=cms.untracked.vstring())
process.maxEvents = cms.untracked.PSet(
input=cms.untracked.int32(options.maxEvents))
process.options = cms.untracked.PSet(wantSummary=cms.untracked.bool(True))
#--------------------------------------------------------------------------------
from RecoTauTag.RecoTau.tools import runTauIdMVA
tauIdEmbedder = runTauIdMVA.TauIDEmbedder(process,
cms,
updatedTauName="NewTauIDsEmbedded",
toKeep=[
"2017v2", "newDM2017v2",
"newDMPhase2v1",
"deepTau2017v2p1",
"againstEle2018",
"againstElePhase2v1"
])
tauIdEmbedder.runTauID()
print dir(process.loadRecoTauTagMVAsFromPrepDB.toGet)
print process.loadRecoTauTagMVAsFromPrepDB.toGet[-1]
# Output definition (MiniAOD + updated taus)
# MiniAOD output
print("output prep")
process.out = cms.OutputModule(
"PoolOutputModule",
compressionAlgorithm=cms.untracked.string('LZMA'),
def adaptTauToMiniAODReReco(process, reclusterJets=True):
# TRYING TO MAKE THINGS MINIAOD COMPATIBLE, FROM THE START, TO THE END, 1 BY 1
#print '[adaptTauToMiniAODReReco]: Start'
jetCollection = 'slimmedJets'
# Add new jet collections if reclustering is demanded
if reclusterJets:
jetCollection = 'patJetsPAT'
from RecoJets.JetProducers.ak4PFJets_cfi import ak4PFJets
process.ak4PFJetsPAT = ak4PFJets.clone(
src=cms.InputTag("packedPFCandidates"))
# trivial PATJets
from PhysicsTools.PatAlgos.producersLayer1.jetProducer_cfi import _patJets
process.patJetsPAT = _patJets.clone(
jetSource=cms.InputTag("ak4PFJetsPAT"),
addJetCorrFactors=cms.bool(False),
jetCorrFactorsSource=cms.VInputTag(),
addBTagInfo=cms.bool(False),
addDiscriminators=cms.bool(False),
discriminatorSources=cms.VInputTag(),
addAssociatedTracks=cms.bool(False),
addJetCharge=cms.bool(False),
addGenPartonMatch=cms.bool(False),
embedGenPartonMatch=cms.bool(False),
addGenJetMatch=cms.bool(False),
getJetMCFlavour=cms.bool(False),
addJetFlavourInfo=cms.bool(False),
)
process.miniAODTausTask.add(process.ak4PFJetsPAT)
process.miniAODTausTask.add(process.patJetsPAT)
# so this adds all tracks to jet in some deltaR region. we don't have tracks so don't need it :D
# process.ak4PFJetTracksAssociatorAtVertex.jets = cms.InputTag(jetCollection)
# Remove ak4PFJetTracksAssociatorAtVertex from recoTauCommonSequence
# Remove pfRecoTauTagInfoProducer from recoTauCommonSequence since it uses the jet-track association
# HOWEVER, may use https://twiki.cern.ch/twiki/bin/view/CMSPublic/WorkBookMiniAOD2017#Isolated_Tracks
# probably needs recovery of the two modules above
process.recoTauAK4Jets08RegionPAT = cms.EDProducer(
"RecoTauPatJetRegionProducer",
deltaR=process.recoTauAK4PFJets08Region.deltaR,
maxJetAbsEta=process.recoTauAK4PFJets08Region.maxJetAbsEta,
minJetPt=process.recoTauAK4PFJets08Region.minJetPt,
pfCandAssocMapSrc=cms.InputTag(""),
pfCandSrc=cms.InputTag("packedPFCandidates"),
src=cms.InputTag(jetCollection))
process.recoTauPileUpVertices.src = cms.InputTag(
"offlineSlimmedPrimaryVertices")
# Redefine recoTauCommonTask
# with redefined region and PU vertices, and w/o track-to-vertex associator and tauTagInfo (the two latter are probably obsolete and not needed at all)
process.recoTauCommonTask = cms.Task(process.recoTauAK4Jets08RegionPAT,
process.recoTauPileUpVertices)
for moduleName in process.TauReco.moduleNames():
convertModuleToMiniAODInput(process, moduleName)
# Adapt TauPiZeros producer
process.ak4PFJetsLegacyHPSPiZeros.builders[
0].qualityCuts.primaryVertexSrc = cms.InputTag(
"offlineSlimmedPrimaryVertices")
process.ak4PFJetsLegacyHPSPiZeros.jetSrc = cms.InputTag(jetCollection)
# Adapt TauChargedHadrons producer
for builder in process.ak4PFJetsRecoTauChargedHadrons.builders:
builder.qualityCuts.primaryVertexSrc = cms.InputTag(
"offlineSlimmedPrimaryVertices")
if builder.name.value(
) == 'tracks': #replace plugin based on generalTracks by one based on lostTracks
builder.name = 'lostTracks'
builder.plugin = 'PFRecoTauChargedHadronFromLostTrackPlugin'
builder.srcTracks = cms.InputTag("lostTracks")
process.ak4PFJetsRecoTauChargedHadrons.jetSrc = cms.InputTag(jetCollection)
# Adapt combinatoricRecoTau producer
process.combinatoricRecoTaus.jetRegionSrc = 'recoTauAK4Jets08RegionPAT'
process.combinatoricRecoTaus.jetSrc = jetCollection
# Adapt builders
for builder in process.combinatoricRecoTaus.builders:
for name, value in builder.parameters_().items():
if name == 'qualityCuts':
builder.qualityCuts.primaryVertexSrc = 'offlineSlimmedPrimaryVertices'
elif name == 'pfCandSrc':
builder.pfCandSrc = 'packedPFCandidates'
# Adapt supported modifiers and remove unsupported ones
modifiersToRemove_ = cms.VPSet()
for mod in process.combinatoricRecoTaus.modifiers:
if mod.name.value() == 'elec_rej':
modifiersToRemove_.append(mod)
continue
elif mod.name.value() == 'TTIworkaround':
modifiersToRemove_.append(mod)
continue
for name, value in mod.parameters_().items():
if name == 'qualityCuts':
mod.qualityCuts.primaryVertexSrc = 'offlineSlimmedPrimaryVertices'
for mod in modifiersToRemove_:
process.combinatoricRecoTaus.modifiers.remove(mod)
#print "\t\t Removing '%s' modifier from 'combinatoricRecoTaus'" %mod.name.value()
# Redefine tau PV producer
process.hpsPFTauPrimaryVertexProducer.__dict__[
'_TypedParameterizable__type'] = 'PFTauMiniAODPrimaryVertexProducer'
process.hpsPFTauPrimaryVertexProducer.PVTag = 'offlineSlimmedPrimaryVertices'
process.hpsPFTauPrimaryVertexProducer.packedCandidatesTag = cms.InputTag(
"packedPFCandidates")
process.hpsPFTauPrimaryVertexProducer.lostCandidatesTag = cms.InputTag(
"lostTracks")
# Redefine tau SV producer
process.hpsPFTauSecondaryVertexProducer = cms.EDProducer(
"PFTauSecondaryVertexProducer",
PFTauTag=cms.InputTag("hpsPFTauProducer"))
# Remove RecoTau producers which are not supported (yet?), i.e. against-e/mu discriminats
for moduleName in process.TauReco.moduleNames():
if 'ElectronRejection' in moduleName or 'MuonRejection' in moduleName:
if 'ByDeadECALElectronRejection' in moduleName: continue
process.miniAODTausTask.remove(getattr(process, moduleName))
# Instead add against-mu discriminants which are MiniAOD compatible
from RecoTauTag.RecoTau.hpsPFTauDiscriminationByMuonRejectionSimple_cff import hpsPFTauDiscriminationByMuonRejectionSimple
process.hpsPFTauDiscriminationByMuonRejectionSimple = hpsPFTauDiscriminationByMuonRejectionSimple
process.miniAODTausTask.add(
process.hpsPFTauDiscriminationByMuonRejectionSimple)
#####
# PAT part in the following
process.tauGenJets.GenParticles = cms.InputTag("prunedGenParticles")
process.tauMatch.matched = cms.InputTag("prunedGenParticles")
# Remove unsupported tauIDs
for name, src in process.patTaus.tauIDSources.parameters_().items():
if name.find('againstElectron') > -1 or name.find('againstMuon') > -1:
if name.find('againstElectronDeadECAL') > -1: continue
delattr(process.patTaus.tauIDSources, name)
# Add MiniAOD specific ones
setattr(
process.patTaus.tauIDSources, 'againstMuonLooseSimple',
cms.PSet(inputTag=cms.InputTag(
'hpsPFTauDiscriminationByMuonRejectionSimple'),
provenanceConfigLabel=cms.string('IDWPdefinitions'),
idLabel=cms.string('ByLooseMuonRejectionSimple')))
setattr(
process.patTaus.tauIDSources, 'againstMuonTightSimple',
cms.PSet(inputTag=cms.InputTag(
'hpsPFTauDiscriminationByMuonRejectionSimple'),
provenanceConfigLabel=cms.string('IDWPdefinitions'),
idLabel=cms.string('ByTightMuonRejectionSimple')))
# Run TauIDs (anti-e && deepTau) on top of selectedPatTaus
_updatedTauName = 'selectedPatTausNewIDs'
_noUpdatedTauName = 'selectedPatTausNoNewIDs'
import RecoTauTag.RecoTau.tools.runTauIdMVA as tauIdConfig
tauIdEmbedder = tauIdConfig.TauIDEmbedder(
process,
debug=False,
updatedTauName=_updatedTauName,
toKeep=['againstEle2018', 'deepTau2017v2p1'])
tauIdEmbedder.runTauID()
setattr(process, _noUpdatedTauName, process.selectedPatTaus.clone())
process.miniAODTausTask.add(getattr(process, _noUpdatedTauName))
delattr(process, 'selectedPatTaus')
process.deepTau2017v2p1.taus = _noUpdatedTauName
process.patTauDiscriminationByElectronRejectionMVA62018Raw.PATTauProducer = _noUpdatedTauName
process.patTauDiscriminationByElectronRejectionMVA62018.PATTauProducer = _noUpdatedTauName
process.selectedPatTaus = getattr(
process, _updatedTauName).clone(src=_noUpdatedTauName)
process.newTauIDsTask = cms.Task(process.rerunMvaIsolationTask,
process.selectedPatTaus)
process.miniAODTausTask.add(process.newTauIDsTask)
