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)