def setCrossingFrameOn(process): process.mix.mixObjects.mixCH.crossingFrames = cms.untracked.vstring( 'CaloHitsTk', 'CastorBU', 'CastorFI', 'CastorPL', 'CastorTU', 'EcalHitsEB', 'EcalHitsEE', 'EcalHitsES', 'EcalTBH4BeamHits', 'HcalHits', 'HcalTB06BeamHits', 'ZDCHITS') process.mix.mixObjects.mixTracks.makeCrossingFrame = cms.untracked.bool( True) process.mix.mixObjects.mixVertices.makeCrossingFrame = cms.untracked.bool( True) process.mix.mixObjects.mixHepMC.makeCrossingFrame = cms.untracked.bool( True) process.mix.mixObjects.mixSH.crossingFrames = cms.untracked.vstring( 'BSCHits', 'FP420SI', 'MuonCSCHits', 'MuonDTHits', 'MuonRPCHits', 'TotemHitsRP', 'TotemHitsT1', 'TotemHitsT2Gem', 'TrackerHitsPixelBarrelHighTof', 'TrackerHitsPixelBarrelLowTof', 'TrackerHitsPixelEndcapHighTof', 'TrackerHitsPixelEndcapLowTof', 'TrackerHitsTECHighTof', 'TrackerHitsTECLowTof', 'TrackerHitsTIBHighTof', 'TrackerHitsTIBLowTof', 'TrackerHitsTIDHighTof', 'TrackerHitsTIDLowTof', 'TrackerHitsTOBHighTof', 'TrackerHitsTOBLowTof') from Configuration.Eras.Modifier_run2_GEM_2017_cff import run2_GEM_2017 run2_GEM_2017.toModify( process.mix.mixObjects, mixSH=dict(crossingFrames=process.mix.mixObjects.mixSH.crossingFrames + ['MuonGEMHits'])) from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM run3_GEM.toModify( process.mix.mixObjects, mixSH=dict(crossingFrames=process.mix.mixObjects.mixSH.crossingFrames + ['MuonGEMHits'])) from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon phase2_muon.toModify( process.mix.mixObjects, mixSH=dict(crossingFrames=process.mix.mixObjects.mixSH.crossingFrames + ['MuonME0Hits'])) from Configuration.Eras.Modifier_phase2_timing_layer_cff import phase2_timing_layer phase2_timing_layer.toModify( process.mix.mixObjects, mixSH=dict(crossingFrames=process.mix.mixObjects.mixSH.crossingFrames + ['FastTimerHitsBarrel', 'FastTimerHitsEndcap'])) return (process)
# minHit = cms.double(-0.5), maxHit = cms.double(74.5), nintHit = cms.int32(75), # minPhi = cms.double(-3.1416), maxPhi = cms.double(3.1416), nintPhi = cms.int32(36), # minDxy = cms.double(-3), maxDxy = cms.double(3), nintDxy = cms.int32(100), # minDz = cms.double(-10), maxDz = cms.double(10), nintDz = cms.int32(100), # TP originating vertical position minVertpos = cms.double(0), maxVertpos = cms.double(5), nintVertpos = cms.int32(100), # TP originating z position minZpos = cms.double(-10), maxZpos = cms.double(10), nintZpos = cms.int32(100) ) from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM run3_GEM.toModify( muonTrackValidator, useGEMs = cms.bool(True) ) from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon phase2_muon.toModify( muonTrackValidator, useME0 = cms.bool(True) )
) from Configuration.Eras.Modifier_run2_GEM_2017_cff import run2_GEM_2017 run2_GEM_2017.toModify( SimMuonFEVTDEBUG, outputCommands = SimMuonFEVTDEBUG.outputCommands + ['keep *_simMuonGEMDigis_*_*'] ) run2_GEM_2017.toModify( SimMuonRAW, outputCommands = SimMuonRAW.outputCommands + ['keep *DigiSimLinkedmDetSetVector_simMuonGEMDigis_*_*'] ) run2_GEM_2017.toModify( SimMuonRECO, outputCommands = SimMuonRECO.outputCommands + ['keep *DigiSimLinkedmDetSetVector_simMuonGEMDigis_*_*'] ) run2_GEM_2017.toModify( SimMuonPREMIX, outputCommands = SimMuonPREMIX.outputCommands + ['keep *_mix_g4SimHitsMuonGEMHits_*'] ) from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM run3_GEM.toModify( SimMuonFEVTDEBUG, outputCommands = SimMuonFEVTDEBUG.outputCommands + ['keep *_simMuonGEMDigis_*_*'] ) run3_GEM.toModify( SimMuonRAW, outputCommands = SimMuonRAW.outputCommands + ['keep *DigiSimLinkedmDetSetVector_simMuonGEMDigis_*_*'] ) run3_GEM.toModify( SimMuonRECO, outputCommands = SimMuonRECO.outputCommands + ['keep *DigiSimLinkedmDetSetVector_simMuonGEMDigis_*_*'] ) run3_GEM.toModify( SimMuonPREMIX, outputCommands = SimMuonPREMIX.outputCommands + ['keep *_mix_g4SimHitsMuonGEMHits_*'] ) from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon phase2_muon.toModify( SimMuonFEVTDEBUG, outputCommands = SimMuonFEVTDEBUG.outputCommands + ['keep *_simMuonME0PseudoDigis_*_*', 'keep *_simMuonME0PseudoReDigis_*_*', 'keep *_simMuonME0Digis_*_*'] ) phase2_muon.toModify( SimMuonRAW, outputCommands = SimMuonRAW.outputCommands + ['keep *DigiSimLinkedmDetSetVector_simMuonME0Digis_*_*'] ) phase2_muon.toModify( SimMuonRECO, outputCommands = SimMuonRECO.outputCommands + ['keep *DigiSimLinkedmDetSetVector_simMuonME0Digis_*_*'] ) phase2_muon.toModify( SimMuonPREMIX, outputCommands = SimMuonPREMIX.outputCommands + ['keep *_mix_g4SimHitsMuonME0Hits_*'] ) # FastSim uses different naming convention from Configuration.Eras.Modifier_fastSim_cff import fastSim def _renameForFastsim(s): return s.replace("_g4Sim", "_MuonSim") fastSim.toModify(SimMuonPREMIX, outputCommands = list( ( _renameForFastsim(item) for item in SimMuonPREMIX.outputCommands.value())))
standAloneSETMuons = cms.EDProducer("StandAloneMuonProducer", MuonTrackLoaderForSTA, MuonServiceProxy, InputObjects = cms.InputTag("SETMuonSeed"), MuonTrajectoryBuilder = cms.string("DirectMuonTrajectoryBuilder"), STATrajBuilderParameters = cms.PSet( SeedTransformerParameters = cms.PSet( Fitter = cms.string('KFFitterSmootherSTA'), RescaleError = cms.double(1.0), MuonRecHitBuilder = cms.string('MuonRecHitBuilder'), Propagator = cms.string('SteppingHelixPropagatorAny'), NMinRecHits = cms.uint32(2), # careful - used with UseSegmentsInTrajectory in SETMuonSeed_cfi.py # UseSubRecHits = cms.bool(True) UseSubRecHits = cms.bool(False) ) ) ) _enableGEMMeasurement = dict( EnableGEMMeasurement = cms.bool(True) ) from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM run3_GEM.toModify( standAloneMuons, STATrajBuilderParameters = dict( FilterParameters = _enableGEMMeasurement, BWFilterParameters = _enableGEMMeasurement ) ) _enableME0Measurement = dict( EnableME0Measurement = cms.bool(True) ) from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon phase2_muon.toModify( standAloneMuons, STATrajBuilderParameters = dict( FilterParameters = _enableME0Measurement, BWFilterParameters = _enableME0Measurement ) )
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 = cms.bool(True) process.patMuons.computeMuonMVA = cms.bool(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( # configure many IDs as InputTag <someName> = <someTag> you # can comment out those you don't want to save some disk space eidRobustLoose = cms.InputTag("reducedEgamma","eidRobustLoose"), eidRobustTight = cms.InputTag("reducedEgamma","eidRobustTight"), eidLoose = cms.InputTag("reducedEgamma","eidLoose"), eidTight = cms.InputTag("reducedEgamma","eidTight"), eidRobustHighEnergy = cms.InputTag("reducedEgamma","eidRobustHighEnergy"), ) process.patElectrons.addPFClusterIso = cms.bool(True) #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.patElectrons.ecalPFClusterIsoMap = cms.InputTag("reducedEgamma", "eleEcalPFClusIso") process.patElectrons.hcalPFClusterIsoMap = cms.InputTag("reducedEgamma", "eleHcalPFClusIso") 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 process.patPhotons.addPFClusterIso = cms.bool(True) #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-") process.patPhotons.ecalPFClusterIsoMap = cms.InputTag("reducedEgamma", "phoEcalPFClusIso") process.patPhotons.hcalPFClusterIsoMap = cms.InputTag("reducedEgamma", "phoHcalPFClusIso") process.patPhotons.photonSource = cms.InputTag("reducedEgamma","reducedGedPhotons") process.patPhotons.electronSource = cms.InputTag("reducedEgamma","reducedGedGsfElectrons") process.patPhotons.photonIDSources = cms.PSet( PhotonCutBasedIDLoose = cms.InputTag('reducedEgamma', 'PhotonCutBasedIDLoose'), PhotonCutBasedIDTight = cms.InputTag('reducedEgamma', 'PhotonCutBasedIDTight') ) 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'), ] ## 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 electron_ids = ['RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_PHYS14_PU20bx25_V2_cff', 'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Spring15_25ns_V1_cff', 'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Spring15_50ns_V2_cff', 'RecoEgamma.ElectronIdentification.Identification.heepElectronID_HEEPV60_cff', 'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring15_25ns_nonTrig_V1_cff', 'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring15_25ns_Trig_V1_cff', 'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring15_50ns_Trig_V1_cff'] switchOnVIDElectronIdProducer(process,DataFormat.MiniAOD, task) process.egmGsfElectronIDs.physicsObjectSrc = \ cms.InputTag("reducedEgamma","reducedGedGsfElectrons") process.electronMVAValueMapProducer.src = \ cms.InputTag('reducedEgamma','reducedGedGsfElectrons') process.electronRegressionValueMapProducer.src = \ cms.InputTag('reducedEgamma','reducedGedGsfElectrons') for idmod in electron_ids: setupAllVIDIdsInModule(process,idmod,setupVIDElectronSelection,None,False,task) #heepIDVarValueMaps only exists if HEEP V6.1 or HEEP 7.0 ID has already been loaded if hasattr(process,'heepIDVarValueMaps'): process.heepIDVarValueMaps.elesMiniAOD = cms.InputTag('reducedEgamma','reducedGedGsfElectrons') #force HEEP to use miniAOD (otherwise it'll detect the AOD) process.heepIDVarValueMaps.dataFormat = cms.int32(2) #VID Photon IDs photon_ids = ['RecoEgamma.PhotonIdentification.Identification.cutBasedPhotonID_Spring15_25ns_V1_cff', 'RecoEgamma.PhotonIdentification.Identification.cutBasedPhotonID_Spring15_50ns_V1_cff', 'RecoEgamma.PhotonIdentification.Identification.mvaPhotonID_Spring15_25ns_nonTrig_V2p1_cff', 'RecoEgamma.PhotonIdentification.Identification.mvaPhotonID_Spring15_50ns_nonTrig_V2p1_cff', 'RecoEgamma.PhotonIdentification.Identification.cutBasedPhotonID_Spring16_V2p2_cff', 'RecoEgamma.PhotonIdentification.Identification.mvaPhotonID_Spring16_nonTrig_V1_cff'] switchOnVIDPhotonIdProducer(process,DataFormat.AOD, task) process.egmPhotonIsolation.srcToIsolate = \ cms.InputTag("reducedEgamma","reducedGedPhotons") for iPSet in process.egmPhotonIsolation.isolationConeDefinitions: iPSet.particleBasedIsolation = cms.InputTag("reducedEgamma","reducedPhotonPfCandMap") process.egmPhotonIDs.physicsObjectSrc = \ cms.InputTag("reducedEgamma","reducedGedPhotons") process.photonIDValueMapProducer.src = \ cms.InputTag("reducedEgamma","reducedGedPhotons") process.photonRegressionValueMapProducer.src = \ cms.InputTag("reducedEgamma","reducedGedPhotons") process.photonIDValueMapProducer.particleBasedIsolation = \ cms.InputTag("reducedEgamma","reducedPhotonPfCandMap") process.photonMVAValueMapProducer.src = \ cms.InputTag('reducedEgamma','reducedGedPhotons') for idmod in photon_ids: setupAllVIDIdsInModule(process,idmod,setupVIDPhotonSelection,None,False,task) #--------------------------------------------------------------------------- #Adding Boosted Subjets taus from RecoTauTag.Configuration.boostedHPSPFTaus_cfi import addBoostedTaus addBoostedTaus(process) #--------------------------------------------------------------------------- #Adding tau reco for 80X legacy reMiniAOD #make a copy of makePatTauTask to avoid labels and substitution problems _makePatTausTaskWithTauReReco = process.makePatTausTask.copy() #add PFTau reco modules to cloned makePatTauTask process.load("RecoTauTag.Configuration.RecoPFTauTag_cff") _makePatTausTaskWithTauReReco.add(process.PFTauTask) #replace original task by extended one for the miniAOD_80XLegacy era from Configuration.Eras.Modifier_run2_miniAOD_80XLegacy_cff import run2_miniAOD_80XLegacy run2_miniAOD_80XLegacy.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) addJetCollection(process, postfix = "", labelName = 'Puppi', jetSource = cms.InputTag('ak4PFJetsPuppi'), jetCorrections = ('AK4PFPuppi', ['L2Relative', 'L3Absolute'], ''), pfCandidates = cms.InputTag('puppi'), # using Puppi candidates as input for b tagging of Puppi jets algo= 'AK', rParam = 0.4, btagDiscriminators = map(lambda x: x.value() ,process.patJets.discriminatorSources) ) process.patJetGenJetMatchPuppi.matched = 'slimmedGenJets' process.patJetsPuppi.jetChargeSource = cms.InputTag("patJetPuppiCharge") process.selectedPatJetsPuppi.cut = cms.string("pt > 15") process.load('PhysicsTools.PatAlgos.slimming.slimmedJets_cfi') task.add(process.slimmedJets) task.add(process.slimmedJetsAK8) addToProcessAndTask('slimmedJetsPuppi', process.slimmedJets.clone(), process, task) process.slimmedJetsPuppi.src = cms.InputTag("selectedPatJetsPuppi") process.slimmedJetsPuppi.packedPFCandidates = cms.InputTag("packedPFCandidates") ## 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")
def setCrossingFrameOn(process): process.mix.mixObjects.mixCH.crossingFrames = cms.untracked.vstring( 'CaloHitsTk', 'CastorBU', 'CastorFI', 'CastorPL', 'CastorTU', 'EcalHitsEB', 'EcalHitsEE', 'EcalHitsES', 'EcalTBH4BeamHits', 'HcalHits', 'HcalTB06BeamHits', 'ZDCHITS') process.mix.mixObjects.mixTracks.makeCrossingFrame = cms.untracked.bool(True) process.mix.mixObjects.mixVertices.makeCrossingFrame = cms.untracked.bool(True) process.mix.mixObjects.mixHepMC.makeCrossingFrame = cms.untracked.bool(True) process.mix.mixObjects.mixSH.crossingFrames = cms.untracked.vstring( 'BSCHits', 'FP420SI', 'MuonCSCHits', 'MuonDTHits', 'MuonRPCHits', 'TotemHitsRP', 'TotemHitsT1', 'TotemHitsT2Gem', 'TrackerHitsPixelBarrelHighTof', 'TrackerHitsPixelBarrelLowTof', 'TrackerHitsPixelEndcapHighTof', 'TrackerHitsPixelEndcapLowTof', 'TrackerHitsTECHighTof', 'TrackerHitsTECLowTof', 'TrackerHitsTIBHighTof', 'TrackerHitsTIBLowTof', 'TrackerHitsTIDHighTof', 'TrackerHitsTIDLowTof', 'TrackerHitsTOBHighTof', 'TrackerHitsTOBLowTof') from Configuration.Eras.Modifier_run2_GEM_2017_cff import run2_GEM_2017 run2_GEM_2017.toModify( process.mix.mixObjects, mixSH = dict( crossingFrames = process.mix.mixObjects.mixSH.crossingFrames + [ 'MuonGEMHits' ] ) ) from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM run3_GEM.toModify( process.mix.mixObjects, mixSH = dict( crossingFrames = process.mix.mixObjects.mixSH.crossingFrames + [ 'MuonGEMHits' ] ) ) from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon phase2_muon.toModify( process.mix.mixObjects, mixSH = dict( crossingFrames = process.mix.mixObjects.mixSH.crossingFrames + [ 'MuonME0Hits' ] ) ) return(process)
for _entry in [FEVTDEBUGEventContent,FEVTDEBUGHLTEventContent,FEVTEventContent]: phase2_tracker.toModify(_entry, outputCommands = _entry.outputCommands + [ 'keep Phase2TrackerDigiedmDetSetVector_mix_*_*', 'keep *_TTClustersFromPhase2TrackerDigis_*_*', 'keep *_TTStubsFromPhase2TrackerDigis_*_*' ]) from Configuration.Eras.Modifier_run2_GEM_2017_cff import run2_GEM_2017 from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon from Configuration.Eras.Modifier_pp_on_AA_2018_cff import pp_on_AA_2018 for _entry in [FEVTDEBUGEventContent,FEVTDEBUGHLTEventContent,FEVTEventContent]: run2_GEM_2017.toModify(_entry, outputCommands = _entry.outputCommands + ['keep *_muonGEMDigis_*_*']) run3_GEM.toModify(_entry, outputCommands = _entry.outputCommands + ['keep *_muonGEMDigis_*_*']) phase2_muon.toModify(_entry, outputCommands = _entry.outputCommands + ['keep *_muonGEMDigis_*_*']) pp_on_AA_2018.toModify(_entry, outputCommands = _entry.outputCommands + ['keep FEDRawDataCollection_rawDataRepacker_*_*']) from RecoLocalFastTime.Configuration.RecoLocalFastTime_EventContent_cff import RecoLocalFastTimeFEVT, RecoLocalFastTimeRECO, RecoLocalFastTimeAOD from Configuration.Eras.Modifier_phase2_timing_layer_cff import phase2_timing_layer def _addOutputCommands(mod, newCommands): phase2_timing_layer.toModify(mod, outputCommands = mod.outputCommands + newCommands.outputCommands) _addOutputCommands(FEVTDEBUGEventContent,RecoLocalFastTimeFEVT) _addOutputCommands(FEVTDEBUGHLTEventContent,RecoLocalFastTimeFEVT) _addOutputCommands(FEVTEventContent,RecoLocalFastTimeFEVT) _addOutputCommands(RECOSIMEventContent,RecoLocalFastTimeRECO) _addOutputCommands(AODSIMEventContent,RecoLocalFastTimeAOD) from RecoMTD.Configuration.RecoMTD_EventContent_cff import RecoMTDFEVT, RecoMTDRECO, RecoMTDAOD _addOutputCommands(FEVTDEBUGEventContent,RecoMTDFEVT)
GEMPadDigiProducer = cms.InputTag("simMuonGEMPadDigis"), GEMPadDigiClusterProducer = cms.InputTag("simMuonGEMPadDigiClusters"), commonParam = dict(isSLHC = True, runME11Up = cms.bool(True), runME11ILT = cms.bool(True), useClusters = cms.bool(False), enableAlctSLHC = cms.bool(True)), clctSLHC = dict(clctNplanesHitPattern = 3), me11tmbSLHCGEM = me11tmbSLHCGEM, copadParamGE11 = copadParamGE11 ) ## GEM-CSC ILT in ME2/1, CSC in ME3/1 and ME4/1 from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon phase2_muon.toModify( cscTriggerPrimitiveDigis, commonParam = dict(runME21Up = cms.bool(True), runME21ILT = cms.bool(True), runME31Up = cms.bool(True), runME41Up = cms.bool(True)), tmbSLHC = dict(ignoreAlctCrossClct = cms.bool(True)), clctSLHC = dict(useDynamicStateMachineZone = cms.bool(True)), alctSLHCME21 = cscTriggerPrimitiveDigis.alctSLHC.clone(alctNplanesHitPattern = 3), clctSLHCME21 = cscTriggerPrimitiveDigis.clctSLHC.clone(clctNplanesHitPattern = 3), me21tmbSLHCGEM = me21tmbSLHCGEM, alctSLHCME3141 = cscTriggerPrimitiveDigis.alctSLHC.clone(alctNplanesHitPattern = 4), clctSLHCME3141 = cscTriggerPrimitiveDigis.clctSLHC.clone(clctNplanesHitPattern = 4), meX1tmbSLHC = meX1tmbSLHC, copadParamGE11 = copadParamGE11, copadParamGE21 = copadParamGE21 )
from Configuration.Eras.Modifier_fastSim_cff import fastSim fastSim.toModify(trackingParticles, # for unknown reasons, fastsim needs this flag on allowDifferentSimHitProcesses = True, # fastsim labels for simhits, simtracks, simvertices simHitCollections = cms.PSet( muon = cms.VInputTag( cms.InputTag('MuonSimHits','MuonDTHits'), cms.InputTag('MuonSimHits','MuonCSCHits'), cms.InputTag('MuonSimHits','MuonRPCHits') ), trackerAndPixel = cms.VInputTag( cms.InputTag('famosSimHits','TrackerHits') ) ), simTrackCollection = 'famosSimHits', simVertexCollection = 'famosSimHits' ) from Configuration.Eras.Modifier_run2_GEM_2017_cff import run2_GEM_2017 run2_GEM_2017.toModify(trackingParticles, simHitCollections = dict( muon = trackingParticles.simHitCollections.muon+[cms.InputTag("g4SimHits","MuonGEMHits")])) from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM run3_GEM.toModify(trackingParticles, simHitCollections = dict( muon = trackingParticles.simHitCollections.muon+[cms.InputTag("g4SimHits","MuonGEMHits")])) from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon phase2_muon.toModify( trackingParticles, simHitCollections = dict( muon = trackingParticles.simHitCollections.muon+[cms.InputTag("g4SimHits","MuonME0Hits")])) from Configuration.Eras.Modifier_phase2_tracker_cff import phase2_tracker phase2_tracker.toModify( trackingParticles, simHitCollections = dict( tracker = []) )
nPhi = cms.int32(72) ) muonDetIdAssociator = cms.ESProducer("DetIdAssociatorESProducer", ComponentName = cms.string('MuonDetIdAssociator'), etaBinSize = cms.double(0.125), nEta = cms.int32(48), nPhi = cms.int32(48), includeBadChambers = cms.bool(False), includeGEM = cms.bool(False), includeME0 = cms.bool(False) ) # If running in Run 2, include bad chambers from Configuration.Eras.Modifier_run2_common_cff import run2_common run2_common.toModify( muonDetIdAssociator, includeBadChambers = True ) # include GEM & ME0 for phase2 from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM run3_GEM.toModify( muonDetIdAssociator, includeGEM = True ) from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon phase2_muon.toModify( muonDetIdAssociator, includeME0 = True ) phase2_muon.toModify( hcalDetIdAssociator, hcalRegion = 1 ) preshowerDetIdAssociator = cms.ESProducer("DetIdAssociatorESProducer", ComponentName = cms.string('PreshowerDetIdAssociator'), etaBinSize = cms.double(0.1), nEta = cms.int32(60), nPhi = cms.int32(30) )
labelSig = cms.InputTag("mix", "MergedCaloTruth"), pileInputTag = cms.InputTag("mix", "MergedCaloTruth"), collectionDM = cms.string("MergedCaloTruth"), ) ) ) phase2_hfnose.toModify(mixData, workers = dict( hfnose = cms.PSet( hfnoseDigitizer, workerType = cms.string("PreMixingHGCalWorker"), digiTagSig = cms.InputTag("mix", "HFNoseDigis"), pileInputTag = cms.InputTag("simHGCalUnsuppressedDigis", "HFNose"), ), ) ) # Muon phase2_muon.toModify(mixData, workers = dict( me0 = cms.PSet( workerType = cms.string("PreMixingCrossingFramePSimHitWorker"), labelSig = cms.InputTag("mix", "g4SimHitsMuonME0Hits"), pileInputTag = cms.InputTag("mix", "g4SimHitsMuonME0Hits"), collectionDM = cms.string("g4SimHitsMuonME0Hits"), ), ) )
'keep DTLayerIdDTDigiSimLinkMuonDigiCollection_simMuonDTDigis_*_*', 'keep RPCDigiSimLinkedmDetSetVector_simMuonRPCDigis_*_*') ) # Add extra collections if running in Run 2. Not sure why but these # collections were added to pretty much all event content in the old # customisation function. from Configuration.Eras.Modifier_run2_common_cff import run2_common run2_common.toModify( SimMuonRAW.outputCommands, func=lambda outputCommands: outputCommands.append('keep *_simMuonCSCDigis_*_*') ) run2_common.toModify( SimMuonRAW.outputCommands, func=lambda outputCommands: outputCommands.append('keep *_simMuonRPCDigis_*_*') ) #RECO content SimMuonRECO = cms.PSet( outputCommands = cms.untracked.vstring('keep StripDigiSimLinkedmDetSetVector_simMuonCSCDigis_*_*', 'keep DTLayerIdDTDigiSimLinkMuonDigiCollection_simMuonDTDigis_*_*', 'keep RPCDigiSimLinkedmDetSetVector_simMuonRPCDigis_*_*') ) #AOD content SimMuonAOD = cms.PSet( outputCommands = cms.untracked.vstring() ) from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM run3_GEM.toModify( SimMuonFEVTDEBUG, outputCommands = SimMuonFEVTDEBUG.outputCommands + ['keep *_simMuonGEMDigis_*_*', 'keep *_simMuonGEMPadDigis_*_*', 'keep *_simMuonGEMPadDigiClusters_*_*'] ) run3_GEM.toModify( SimMuonRAW, outputCommands = SimMuonRAW.outputCommands + ['keep StripDigiSimLinkedmDetSetVector_simMuonGEMDigis_*_*'] ) run3_GEM.toModify( SimMuonRECO, outputCommands = SimMuonRECO.outputCommands + ['keep StripDigiSimLinkedmDetSetVector_simMuonGEMDigis_*_*'] ) from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon phase2_muon.toModify( SimMuonFEVTDEBUG, outputCommands = SimMuonFEVTDEBUG.outputCommands + ['keep *_simMuonME0Digis_*_*', 'keep *_simMuonME0ReDigis_*_*'] )
stage2L1Trigger.toModify(L1TriggerRAWDEBUG, func=_appendStage2Digis) stage2L1Trigger.toModify(L1TriggerRECO, func=_appendStage2Digis) stage2L1Trigger.toModify(L1TriggerAOD, func=_appendStage2Digis) stage2L1Trigger.toModify(L1TriggerFEVTDEBUG, func=_appendStage2Digis) # adding HGCal L1 trigger digis def _appendHGCalDigis(obj): l1HGCalDigis = [ 'keep l1tHGCalTriggerCellBXVector_hgcalVFEProducer_*_*', 'keep l1tHGCalTriggerCellBXVector_hgcalConcentratorProducer_*_*', 'keep l1tHGCalTowerBXVector_hgcalTowerProducer_*_*', 'keep l1tHGCalClusterBXVector_hgcalBackEndLayer1Producer_*_*', 'keep l1tHGCalMulticlusterBXVector_hgcalBackEndLayer2Producer_*_*' ] obj.outputCommands += l1HGCalDigis from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal phase2_hgcal.toModify(L1TriggerFEVTDEBUG, func=_appendHGCalDigis) # adding ME0 pseudo trigger stubs def _appendME0PseudoStubs(obj): l1ME0PseudoStubs = [ 'keep *_simMuonME0PseudoReDigisCoarse__*', 'keep *_me0RecHitsCoarse__*', 'keep *_me0TriggerPseudoDigis__*', ] obj.outputCommands += l1ME0PseudoStubs from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon phase2_muon.toModify(L1TriggerFEVTDEBUG, func=_appendME0PseudoStubs)
STATrajBuilderParameters=cms.PSet(SeedTransformerParameters=cms.PSet( Fitter=cms.string('KFFitterSmootherSTA'), RescaleError=cms.double(1.0), MuonRecHitBuilder=cms.string('MuonRecHitBuilder'), Propagator=cms.string('SteppingHelixPropagatorAny'), NMinRecHits=cms.uint32(2), # careful - used with UseSegmentsInTrajectory in SETMuonSeed_cfi.py # UseSubRecHits = cms.bool(True) UseSubRecHits=cms.bool(False)))) _enableGEMMeasurement = dict(EnableGEMMeasurement=True) from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM run3_GEM.toModify(standAloneMuons, STATrajBuilderParameters=dict( FilterParameters=_enableGEMMeasurement, BWFilterParameters=_enableGEMMeasurement)) _enableME0Measurement = dict(EnableME0Measurement=True) from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon phase2_muon.toModify(standAloneMuons, STATrajBuilderParameters=dict( FilterParameters=_enableME0Measurement, BWFilterParameters=_enableME0Measurement)) _disableME0Measurement = dict(EnableME0Measurement=False) from Configuration.Eras.Modifier_phase2_GE0_cff import phase2_GE0 phase2_GE0.toModify(standAloneMuons, STATrajBuilderParameters=dict( FilterParameters=_disableME0Measurement, BWFilterParameters=_disableME0Measurement))
import FWCore.ParameterSet.Config as cms primitiveRPCProducer = cms.EDProducer( "L1TMuonRPCTriggerPrimitivesProducer", Primitiverechitlabel=cms.InputTag("rpcdigis"), Mapsource=cms.string( 'L1Trigger/L1TMuon/data/rpc/Linkboard_rpc_roll_mapping_lb_chamber2.txt' ), ApplyLinkBoardCut=cms.bool(True), LinkBoardCut=cms.int32( 2 ), # Number of clusters per linkboard greater than (default >2) are rejected ClusterSizeCut=cms.int32( 3), # Clustersize greater than (default >3) is rejected maskSource=cms.string('File'), maskvecfile=cms.FileInPath('RecoLocalMuon/RPCRecHit/data/RPCMaskVec.dat'), deadSource=cms.string('File'), deadvecfile=cms.FileInPath('RecoLocalMuon/RPCRecHit/data/RPCDeadVec.dat'), recAlgoConfig=cms.PSet(), recAlgo=cms.string('RPCRecHitStandardAlgo')) from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon phase2_muon.toModify(primitiveRPCProducer, ApplyLinkBoardCut=cms.bool(False)) phase2_muon.toModify(primitiveRPCProducer, ClusterSizeCut=cms.int32(4))
FEVTEventContent.outputCommands.extend(OnlineMetaDataContent.outputCommands) FEVTEventContent.outputCommands.extend(TcdsEventContent.outputCommands) FEVTEventContent.outputCommands.extend(CommonEventContent.outputCommands) ctpps.toModify(FEVTEventContent, outputCommands = FEVTEventContent.outputCommands + RecoCTPPSFEVT.outputCommands) phase2_hgcal.toModify(FEVTEventContent, outputCommands = FEVTEventContent.outputCommands + TICL_FEVT.outputCommands) phase2_tracker.toModify(FEVTEventContent, outputCommands = FEVTEventContent.outputCommands + [ 'keep Phase2TrackerDigiedmDetSetVector_mix_*_*', 'keep *_TTClustersFromPhase2TrackerDigis_*_*', 'keep *_TTStubsFromPhase2TrackerDigis_*_*', 'keep *_TrackerDTC_*_*', 'keep *_*_Level1TTTracks_*']) phase2_muon.toModify(FEVTEventContent, outputCommands = FEVTEventContent.outputCommands + ['keep *_muonGEMDigis_*_*']) run2_GEM_2017.toModify(FEVTEventContent, outputCommands = FEVTEventContent.outputCommands + ['keep *_muonGEMDigis_*_*']) run3_GEM.toModify(FEVTEventContent, outputCommands = FEVTEventContent.outputCommands + ['keep *_muonGEMDigis_*_*']) pp_on_AA.toModify(FEVTEventContent, outputCommands = FEVTEventContent.outputCommands + ['keep FEDRawDataCollection_rawDataRepacker_*_*']) phase2_timing_layer.toModify(FEVTEventContent, outputCommands = FEVTEventContent.outputCommands + RecoLocalFastTimeFEVT.outputCommands) phase2_timing_layer.toModify(FEVTEventContent, outputCommands = FEVTEventContent.outputCommands + RecoMTDFEVT.outputCommands) FEVTHLTALLEventContent = cms.PSet( outputCommands = cms.untracked.vstring('drop *'), splitLevel = cms.untracked.int32(0), )
runDigi = cms.bool(True), runStub = cms.bool(True), runL1 = cms.bool(True), runReco = cms.bool(False), verbose = cms.untracked.int32(0), minNHitsChamberGEMSimHit = cms.int32(1), minNHitsChamberCSCSimHit = cms.int32(3), minNHitsChamberCSCDigi = cms.int32(4), minNHitsChamberGEMDigi = cms.int32(1), minNHitsChamberCSCStub = cms.int32(3), ) GEMCSCAnalyzer.simTrack.minEta = 0.9 GEMCSCAnalyzer.simTrack.maxEta = 2.4 GEMCSCAnalyzer.simTrack.minPt = 3 GEMCSCAnalyzer.gemSimHit.verbose = 0 GEMCSCAnalyzer.gemStripDigi.verbose = 0 GEMCSCAnalyzer.gemStripDigi.matchDeltaStrip = 2 GEMCSCAnalyzer.gemPadDigi.verbose = 0 GEMCSCAnalyzer.gemCoPadDigi.verbose = 0 GEMCSCAnalyzer.gemPadCluster.verbose = 0 GEMCSCAnalyzer.cscComparatorDigi.verbose = 0 GEMCSCAnalyzer.cscWireDigi.verbose = 0 GEMCSCAnalyzer.cscALCT.verbose = 0 GEMCSCAnalyzer.cscCLCT.verbose = 0 GEMCSCAnalyzer.cscLCT.verbose = 0 GEMCSCAnalyzer.cscLCT.addGhostLCTs = cms.bool(True) phase2_muon.toModify(GEMCSCAnalyzer, l1Track = dict(run = cms.bool(False) ) ) phase2_muon.toModify(GEMCSCAnalyzer, l1TkMuon = dict(run = cms.bool(False) ) )
import FWCore.ParameterSet.Config as cms from RecoMuon.MuonSeedGenerator.ptSeedParameterization_cfi import * from RecoMuon.MuonSeedGenerator.MuonSeedPtScale_cfi import * # module standAloneMuonSeeds = MuonSeedGenerator { ancientMuonSeed = cms.EDProducer( "MuonSeedGenerator", ptSeedParameterization, dphiScale, beamSpotTag=cms.InputTag("offlineBeamSpot"), scaleDT=cms.bool(True), CSCRecSegmentLabel=cms.InputTag("cscSegments"), DTRecSegmentLabel=cms.InputTag("dt4DSegments"), ME0RecSegmentLabel=cms.InputTag("me0Segments"), EnableDTMeasurement=cms.bool(True), EnableCSCMeasurement=cms.bool(True), EnableME0Measurement=cms.bool(False), # places where it's OK to have single-segment seeds crackEtas=cms.vdouble(0.2, 1.6, 1.7), crackWindow=cms.double(0.04), deltaPhiSearchWindow=cms.double(0.25), deltaEtaSearchWindow=cms.double(0.2), deltaEtaCrackSearchWindow=cms.double(0.25), ) # phase2 ME0 from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon phase2_muon.toModify(ancientMuonSeed, EnableME0Measurement=cms.bool(True))
'SteppingHelixPropagatorAnyNoError', 'SteppingHelixPropagatorAlongNoError', 'SteppingHelixPropagatorOppositeNoError', 'SteppingHelixPropagatorL2AnyNoError', 'SteppingHelixPropagatorL2AlongNoError', 'SteppingHelixPropagatorL2OppositeNoError', 'PropagatorWithMaterial', 'PropagatorWithMaterialOpposite', 'SmartPropagator', 'SmartPropagatorOpposite', 'SmartPropagatorAnyOpposite', 'SmartPropagatorAny', 'SmartPropagatorRK', 'SmartPropagatorAnyRK', 'StraightLinePropagator'), RPCLayers=cms.bool(True), CSCLayers=cms.untracked.bool(True), GEMLayers=cms.untracked.bool(False), ME0Layers=cms.bool(False), UseMuonNavigation=cms.untracked.bool(True))) # run3_GEM from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM run3_GEM.toModify(MuonServiceProxy, ServiceParameters=dict(GEMLayers=cms.untracked.bool(True))) # phase2_muon from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon phase2_muon.toModify(MuonServiceProxy, ServiceParameters=dict(ME0Layers=cms.bool(True)))
# calo muons minCaloCompatibility = cms.double(0.6), # arbitration cleaning runArbitrationCleaner = cms.bool(True), arbitrationCleanerOptions = cms.PSet( ME1a = cms.bool(True), Overlap = cms.bool(True), Clustering = cms.bool(True), OverlapDPhi = cms.double(0.0786), # 4.5 degrees OverlapDTheta = cms.double(0.02), # 1.14 degrees ClusterDPhi = cms.double(0.6), # 34 degrees ClusterDTheta = cms.double(0.02) # 1.14 ), # tracker muon arbitration arbitrateTrackerMuons = cms.bool(True) ) from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM run3_GEM.toModify( muons1stStep, TrackAssociatorParameters = dict(useGEM = cms.bool(True) ) ) from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon phase2_muon.toModify( muons1stStep, TrackAssociatorParameters = dict(useME0 = cms.bool(True) ) ) muonEcalDetIds = cms.EDProducer("InterestingEcalDetIdProducer", inputCollection = cms.InputTag("muons1stStep") ) from Configuration.Eras.Modifier_pp_on_AA_2018_cff import pp_on_AA_2018 pp_on_AA_2018.toModify(muons1stStep, minPt = 0.8)
# customisation function. from Configuration.Eras.Modifier_run2_common_cff import run2_common run2_common.toModify( SimMuonRAW.outputCommands, func=lambda outputCommands: outputCommands.append('keep *_simMuonCSCDigis_*_*') ) run2_common.toModify( SimMuonRAW.outputCommands, func=lambda outputCommands: outputCommands.append('keep *_simMuonRPCDigis_*_*') ) #RECO content SimMuonRECO = cms.PSet( outputCommands = cms.untracked.vstring('keep StripDigiSimLinkedmDetSetVector_simMuonCSCDigis_*_*', 'keep DTLayerIdDTDigiSimLinkMuonDigiCollection_simMuonDTDigis_*_*', 'keep RPCDigiSimLinkedmDetSetVector_simMuonRPCDigis_*_*') ) #AOD content SimMuonAOD = cms.PSet( outputCommands = cms.untracked.vstring() ) from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM run3_GEM.toModify( SimMuonFEVTDEBUG, outputCommands = SimMuonFEVTDEBUG.outputCommands + ['keep *_simMuonGEMDigis_*_*', 'keep *_simMuonGEMPadDigis_*_*', 'keep *_simMuonGEMPadDigiClusters_*_*'] ) run3_GEM.toModify( SimMuonRAW, outputCommands = SimMuonRAW.outputCommands + ['keep StripDigiSimLinkedmDetSetVector_simMuonGEMDigis_*_*'] ) run3_GEM.toModify( SimMuonRECO, outputCommands = SimMuonRECO.outputCommands + ['keep StripDigiSimLinkedmDetSetVector_simMuonGEMDigis_*_*'] ) from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon phase2_muon.toModify( SimMuonFEVTDEBUG, outputCommands = SimMuonFEVTDEBUG.outputCommands + ['keep *_simMuonME0PseudoDigis_*_*', 'keep *_simMuonME0PseudoReDigis_*_*', 'keep *_simMuonME0Digis_*_*', 'keep *_simMuonME0PadDigis_*_*', 'keep *_simMuonME0PadDigiClusters_*_*'] ) phase2_muon.toModify( SimMuonRAW, outputCommands = SimMuonRAW.outputCommands + ['keep StripDigiSimLinkedmDetSetVector_simMuonME0Digis_*_*'] ) phase2_muon.toModify( SimMuonRECO, outputCommands = SimMuonRECO.outputCommands + ['keep StripDigiSimLinkedmDetSetVector_simMuonME0Digis_*_*'] )
phase2_muon.toModify( mixData, workers=dict( dt=dict(pileInputTag="simMuonDTDigis"), rpc=dict(pileInputTag="simMuonRPCDigis"), csc=dict( strip=dict(pileInputTag="simMuonCSCDigis:MuonCSCStripDigi"), wire=dict(pileInputTag="simMuonCSCDigis:MuonCSCWireDigi"), comparator=dict( pileInputTag="simMuonCSCDigis:MuonCSCComparatorDigi"), ), gem=cms.PSet( workerType=cms.string("PreMixingGEMWorker"), digiTagSig=cms.InputTag("simMuonGEMDigis"), pileInputTag=cms.InputTag("simMuonGEMDigis", ""), collectionDM=cms.string(''), ), me0=cms.PSet( workerType=cms.string("PreMixingME0Worker"), digiTagSig=cms.InputTag("simMuonME0Digis"), pileInputTag=cms.InputTag("simMuonME0Digis", ""), collectionDM=cms.string(''), ), me0SimHit=cms.PSet( workerType=cms.string("PreMixingCrossingFramePSimHitWorker"), labelSig=cms.InputTag("mix", "g4SimHitsMuonME0Hits"), pileInputTag=cms.InputTag("mix", "g4SimHitsMuonME0Hits"), collectionDM=cms.string("g4SimHitsMuonME0Hits"), ), gemSimLink=cms.PSet( workerType=cms.string("PreMixingGEMDigiSimLinkWorker"), labelSig=cms.InputTag("simMuonGEMDigis"), pileInputTag=cms.InputTag("simMuonGEMDigis"), collectionDM=cms.string('GEMDigiSimLink'), ), gemStripSimLink=cms.PSet( workerType=cms.string("PreMixingStripDigiSimLinkWorker"), labelSig=cms.InputTag("simMuonGEMDigis"), pileInputTag=cms.InputTag("simMuonGEMDigis"), collectionDM=cms.string('GEMStripDigiSimLink'), ), me0SimLink=cms.PSet( workerType=cms.string("PreMixingME0DigiSimLinkWorker"), labelSig=cms.InputTag("simMuonMe0Digis"), pileInputTag=cms.InputTag("simMuonME0Digis"), collectionDM=cms.string('ME0DigiSimLink'), ), me0StripSimLink=cms.PSet( workerType=cms.string("PreMixingStripDigiSimLinkWorker"), labelSig=cms.InputTag("simMuonME0Digis"), pileInputTag=cms.InputTag("simMuonME0Digis"), collectionDM=cms.string('ME0StripDigiSimLink'), ), ))
import FWCore.ParameterSet.Config as cms # AOD content RecoLocalMuonAOD = cms.PSet(outputCommands=cms.untracked.vstring()) from Configuration.Eras.Modifier_run2_GEM_2017_cff import run2_GEM_2017 from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon run2_GEM_2017.toModify(RecoLocalMuonAOD, outputCommands=RecoLocalMuonAOD.outputCommands + ['keep *_gemRecHits_*_*', 'keep *_gemSegments_*_*']) run3_GEM.toModify(RecoLocalMuonAOD, outputCommands=RecoLocalMuonAOD.outputCommands + ['keep *_gemRecHits_*_*', 'keep *_gemSegments_*_*']) phase2_muon.toModify(RecoLocalMuonAOD, outputCommands=RecoLocalMuonAOD.outputCommands + ['keep *_me0RecHits_*_*', 'keep *_me0Segments_*_*']) # RECO content RecoLocalMuonRECO = cms.PSet(outputCommands=cms.untracked.vstring( 'keep *_muonDTDigis_*_*', 'keep *_dttfDigis_*_*', 'keep *_dt1DRecHits_*_*', 'keep *_dt4DSegments_*_*', 'keep *_dt4DSegmentsT0Seg_*_*', 'keep *_csc2DRecHits_*_*', 'keep *_cscSegments_*_*', 'keep RPCDetIdRPCDigiMuonDigiCollection_muonRPCDigis_*_*', 'keep *_rpcRecHits_*_*')) RecoLocalMuonRECO.outputCommands.extend(RecoLocalMuonAOD.outputCommands) # Full Event content RecoLocalMuonFEVT = cms.PSet(outputCommands=cms.untracked.vstring( 'keep RPCDetIdRPCDigiMuonDigiCollection_*_*_*')) RecoLocalMuonFEVT.outputCommands.extend(RecoLocalMuonRECO.outputCommands)
def miniAOD_customizeCommon(process): process.patMuons.isoDeposits = cms.PSet() process.patElectrons.isoDeposits = cms.PSet() process.patTaus.isoDeposits = cms.PSet() process.patPhotons.isoDeposits = cms.PSet() # process.patMuons.embedTrack = True # used for IDs process.patMuons.embedCombinedMuon = True # used for IDs process.patMuons.embedMuonBestTrack = True # used for IDs process.patMuons.embedStandAloneMuon = True # maybe? process.patMuons.embedPickyMuon = False # no, use best track process.patMuons.embedTpfmsMuon = False # no, use best track process.patMuons.embedDytMuon = False # no, use best track process.patMuons.addPuppiIsolation = cms.bool(True) process.patMuons.puppiIsolationChargedHadrons = cms.InputTag( "muonPUPPIIsolation", "h+-DR040-ThresholdVeto000-ConeVeto000") process.patMuons.puppiIsolationNeutralHadrons = cms.InputTag( "muonPUPPIIsolation", "h0-DR040-ThresholdVeto000-ConeVeto001") process.patMuons.puppiIsolationPhotons = cms.InputTag( "muonPUPPIIsolation", "gamma-DR040-ThresholdVeto000-ConeVeto001") process.patMuons.puppiNoLeptonsIsolationChargedHadrons = cms.InputTag( "muonPUPPINoLeptonsIsolation", "h+-DR040-ThresholdVeto000-ConeVeto000") process.patMuons.puppiNoLeptonsIsolationNeutralHadrons = cms.InputTag( "muonPUPPINoLeptonsIsolation", "h0-DR040-ThresholdVeto000-ConeVeto001") process.patMuons.puppiNoLeptonsIsolationPhotons = cms.InputTag( "muonPUPPINoLeptonsIsolation", "gamma-DR040-ThresholdVeto000-ConeVeto001") process.patMuons.computeMiniIso = True process.patMuons.computeMuonMVA = True process.patMuons.computeSoftMuonMVA = True process.patMuons.addTriggerMatching = True from Configuration.Eras.Modifier_run2_muon_2016_cff import run2_muon_2016 from Configuration.Eras.Modifier_run2_muon_2017_cff import run2_muon_2017 from Configuration.Eras.Modifier_run2_muon_2018_cff import run2_muon_2018 run2_muon_2016.toModify( process.patMuons, effectiveAreaVec=[0.0735, 0.0619, 0.0465, 0.0433, 0.0577]) run2_muon_2017.toModify( process.patMuons, effectiveAreaVec=[0.0566, 0.0562, 0.0363, 0.0119, 0.0064]) run2_muon_2018.toModify( process.patMuons, effectiveAreaVec=[0.0566, 0.0562, 0.0363, 0.0119, 0.0064]) run2_muon_2016.toModify( process.patMuons, mvaTrainingFile= "RecoMuon/MuonIdentification/data/mu_2016_BDTG.weights.xml") process.patMuons.computePuppiCombinedIso = True # # disable embedding of electron and photon associated objects already stored by the ReducedEGProducer process.patElectrons.embedGsfElectronCore = False ## process.patElectrons.embed in AOD externally stored gsf electron core process.patElectrons.embedSuperCluster = False ## process.patElectrons.embed in AOD externally stored supercluster process.patElectrons.embedPflowSuperCluster = False ## process.patElectrons.embed in AOD externally stored supercluster process.patElectrons.embedSeedCluster = False ## process.patElectrons.embed in AOD externally stored the electron's seedcluster process.patElectrons.embedBasicClusters = False ## process.patElectrons.embed in AOD externally stored the electron's basic clusters process.patElectrons.embedPreshowerClusters = False ## process.patElectrons.embed in AOD externally stored the electron's preshower clusters process.patElectrons.embedPflowBasicClusters = False ## process.patElectrons.embed in AOD externally stored the electron's pflow basic clusters process.patElectrons.embedPflowPreshowerClusters = False ## process.patElectrons.embed in AOD externally stored the electron's pflow preshower clusters process.patElectrons.embedRecHits = False ## process.patElectrons.embed in AOD externally stored the RecHits - can be called from the PATElectronProducer process.patElectrons.electronSource = cms.InputTag( "reducedEgamma", "reducedGedGsfElectrons") process.patElectrons.usePfCandidateMultiMap = True process.patElectrons.pfCandidateMultiMap = cms.InputTag( "reducedEgamma", "reducedGsfElectronPfCandMap") process.patElectrons.electronIDSources = cms.PSet() from Configuration.Eras.Modifier_run2_miniAOD_80XLegacy_cff import run2_miniAOD_80XLegacy from Configuration.Eras.Modifier_run2_miniAOD_94XFall17_cff import run2_miniAOD_94XFall17 (run2_miniAOD_80XLegacy | run2_miniAOD_94XFall17).toModify( process.patElectrons, addPFClusterIso=True, ecalPFClusterIsoMap="reducedEgamma:eleEcalPFClusIso", hcalPFClusterIsoMap="reducedEgamma:eleHcalPFClusIso") #add puppi isolation in miniAOD process.patElectrons.addPuppiIsolation = cms.bool(True) process.patElectrons.puppiIsolationChargedHadrons = cms.InputTag( "egmElectronPUPPIIsolation", "h+-DR030-BarVeto000-EndVeto001") process.patElectrons.puppiIsolationNeutralHadrons = cms.InputTag( "egmElectronPUPPIIsolation", "h0-DR030-BarVeto000-EndVeto000") process.patElectrons.puppiIsolationPhotons = cms.InputTag( "egmElectronPUPPIIsolation", "gamma-DR030-BarVeto000-EndVeto008") process.patElectrons.puppiNoLeptonsIsolationChargedHadrons = cms.InputTag( "egmElectronPUPPINoLeptonsIsolation", "h+-DR030-BarVeto000-EndVeto001") process.patElectrons.puppiNoLeptonsIsolationNeutralHadrons = cms.InputTag( "egmElectronPUPPINoLeptonsIsolation", "h0-DR030-BarVeto000-EndVeto000") process.patElectrons.puppiNoLeptonsIsolationPhotons = cms.InputTag( "egmElectronPUPPINoLeptonsIsolation", "gamma-DR030-BarVeto000-EndVeto008") process.patElectrons.computeMiniIso = cms.bool(True) process.elPFIsoDepositChargedPAT.src = cms.InputTag( "reducedEgamma", "reducedGedGsfElectrons") process.elPFIsoDepositChargedAllPAT.src = cms.InputTag( "reducedEgamma", "reducedGedGsfElectrons") process.elPFIsoDepositNeutralPAT.src = cms.InputTag( "reducedEgamma", "reducedGedGsfElectrons") process.elPFIsoDepositGammaPAT.src = cms.InputTag( "reducedEgamma", "reducedGedGsfElectrons") process.elPFIsoDepositPUPAT.src = cms.InputTag("reducedEgamma", "reducedGedGsfElectrons") # process.patPhotons.embedSuperCluster = False ## whether to process.patPhotons.embed in AOD externally stored supercluster process.patPhotons.embedSeedCluster = False ## process.patPhotons.embed in AOD externally stored the photon's seedcluster process.patPhotons.embedBasicClusters = False ## process.patPhotons.embed in AOD externally stored the photon's basic clusters process.patPhotons.embedPreshowerClusters = False ## process.patPhotons.embed in AOD externally stored the photon's preshower clusters process.patPhotons.embedRecHits = False ## process.patPhotons.embed in AOD externally stored the RecHits - can be called from the PATPhotonProducer #add puppi isolation in miniAOD process.patPhotons.addPuppiIsolation = cms.bool(True) process.patPhotons.puppiIsolationChargedHadrons = cms.InputTag( "egmPhotonPUPPIIsolation", "h+-DR030-") process.patPhotons.puppiIsolationNeutralHadrons = cms.InputTag( "egmPhotonPUPPIIsolation", "h0-DR030-") process.patPhotons.puppiIsolationPhotons = cms.InputTag( "egmPhotonPUPPIIsolation", "gamma-DR030-") (run2_miniAOD_80XLegacy | run2_miniAOD_94XFall17).toModify( process.patPhotons, addPFClusterIso=True, ecalPFClusterIsoMap="reducedEgamma:phoEcalPFClusIso", hcalPFClusterIsoMap="reducedEgamma:phoHcalPFClusIso") #the 80X legacy customsations are done in ootPhotonProducer for OOT photons run2_miniAOD_94XFall17.toModify( process.patOOTPhotons, addPFClusterIso=True, ecalPFClusterIsoMap="reducedEgamma:ootPhoEcalPFClusIso", hcalPFClusterIsoMap="reducedEgamma:ootPhoHcalPFClusIso") process.patPhotons.photonSource = cms.InputTag("reducedEgamma", "reducedGedPhotons") process.patPhotons.electronSource = cms.InputTag("reducedEgamma", "reducedGedGsfElectrons") process.phPFIsoDepositChargedPAT.src = cms.InputTag( "reducedEgamma", "reducedGedPhotons") process.phPFIsoDepositChargedAllPAT.src = cms.InputTag( "reducedEgamma", "reducedGedPhotons") process.phPFIsoDepositNeutralPAT.src = cms.InputTag( "reducedEgamma", "reducedGedPhotons") process.phPFIsoDepositGammaPAT.src = cms.InputTag("reducedEgamma", "reducedGedPhotons") process.phPFIsoDepositPUPAT.src = cms.InputTag("reducedEgamma", "reducedGedPhotons") # process.patOOTPhotons.photonSource = cms.InputTag("reducedEgamma", "reducedOOTPhotons") process.patOOTPhotons.electronSource = cms.InputTag( "reducedEgamma", "reducedGedGsfElectrons") # process.selectedPatJets.cut = cms.string("pt > 10") process.selectedPatMuons.cut = cms.string( "pt > 5 || isPFMuon || (pt > 3 && (isGlobalMuon || isStandAloneMuon || numberOfMatches > 0 || muonID('RPCMuLoose')))" ) from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon phase2_muon.toModify( process.selectedPatMuons, cut= "pt > 5 || isPFMuon || (pt > 3 && (isGlobalMuon || isStandAloneMuon || numberOfMatches > 0 || muonID('RPCMuLoose') || muonID('ME0MuonArbitrated') || muonID('GEMMuonArbitrated')) )" ) from Configuration.Eras.Modifier_pp_on_AA_2018_cff import pp_on_AA_2018 from Configuration.Eras.Modifier_pp_on_PbPb_run3_cff import pp_on_PbPb_run3 (pp_on_AA_2018 | pp_on_PbPb_run3).toModify( process.selectedPatMuons, cut= "pt > 5 || isPFMuon || (pt > 1.2 && (isGlobalMuon || isStandAloneMuon) )" ) process.selectedPatElectrons.cut = cms.string("") process.selectedPatTaus.cut = cms.string( "pt > 18. && tauID('decayModeFindingNewDMs')> 0.5") process.selectedPatPhotons.cut = cms.string("") from PhysicsTools.PatAlgos.tools.jetTools import addJetCollection from PhysicsTools.PatAlgos.slimming.applySubstructure_cff import applySubstructure applySubstructure(process) # from PhysicsTools.PatAlgos.tools.trigTools import switchOnTriggerStandAlone switchOnTriggerStandAlone(process, outputModule='') process.patTrigger.packTriggerPathNames = cms.bool(True) # # apply type I + other PFMEt corrections to pat::MET object # and estimate systematic uncertainties on MET from PhysicsTools.PatUtils.tools.runMETCorrectionsAndUncertainties import runMetCorAndUncForMiniAODProduction runMetCorAndUncForMiniAODProduction(process, metType="PF", jetCollUnskimmed="patJets") #caloMET computation from PhysicsTools.PatAlgos.tools.metTools import addMETCollection addMETCollection(process, labelName="patCaloMet", metSource="caloMetM") #noHF pfMET ========= task = getPatAlgosToolsTask(process) process.noHFCands = cms.EDFilter( "GenericPFCandidateSelector", src=cms.InputTag("particleFlow"), cut=cms.string("abs(pdgId)!=1 && abs(pdgId)!=2 && abs(eta)<3.0")) task.add(process.noHFCands) runMetCorAndUncForMiniAODProduction( process, pfCandColl=cms.InputTag("noHFCands"), recoMetFromPFCs=True, #needed for HF removal jetSelection="pt>15 && abs(eta)<3.", postfix="NoHF") process.load('PhysicsTools.PatAlgos.slimming.slimmedMETs_cfi') task.add(process.slimmedMETs) process.slimmedMETs.addDeepMETs = True addToProcessAndTask('slimmedMETsNoHF', process.slimmedMETs.clone(), process, task) process.slimmedMETsNoHF.src = cms.InputTag("patMETsNoHF") process.slimmedMETsNoHF.rawVariation = cms.InputTag("patPFMetNoHF") process.slimmedMETsNoHF.t1Uncertainties = cms.InputTag("patPFMetT1%sNoHF") process.slimmedMETsNoHF.t01Variation = cms.InputTag("patPFMetT0pcT1NoHF") process.slimmedMETsNoHF.t1SmearedVarsAndUncs = cms.InputTag( "patPFMetT1Smear%sNoHF") process.slimmedMETsNoHF.tXYUncForRaw = cms.InputTag("patPFMetTxyNoHF") process.slimmedMETsNoHF.tXYUncForT1 = cms.InputTag("patPFMetT1TxyNoHF") process.slimmedMETsNoHF.tXYUncForT01 = cms.InputTag( "patPFMetT0pcT1TxyNoHF") process.slimmedMETsNoHF.tXYUncForT1Smear = cms.InputTag( "patPFMetT1SmearTxyNoHF") process.slimmedMETsNoHF.tXYUncForT01Smear = cms.InputTag( "patPFMetT0pcT1SmearTxyNoHF") del process.slimmedMETsNoHF.caloMET # ================== NoHF pfMET # ================== CHSMET process.CHSCands = cms.EDFilter("CandPtrSelector", src=cms.InputTag("packedPFCandidates"), cut=cms.string("fromPV(0) > 0")) task.add(process.CHSCands) from RecoMET.METProducers.pfMet_cfi import pfMet process.pfMetCHS = pfMet.clone(src='CHSCands') task.add(process.pfMetCHS) addMETCollection(process, labelName="patCHSMet", metSource="pfMetCHS") process.patCHSMet.computeMETSignificance = cms.bool(False) # ================== CHSMET # ================== TrkMET process.TrkCands = cms.EDFilter( "CandPtrSelector", src=cms.InputTag("packedPFCandidates"), cut=cms.string( "charge()!=0 && pvAssociationQuality()>=4 && vertexRef().key()==0") ) task.add(process.TrkCands) process.pfMetTrk = pfMet.clone(src='TrkCands') task.add(process.pfMetTrk) addMETCollection(process, labelName="patTrkMet", metSource="pfMetTrk") process.patTrkMet.computeMETSignificance = cms.bool(False) # ================== TrkMET ## PU JetID process.load("RecoJets.JetProducers.PileupJetID_cfi") task.add(process.pileUpJetIDTask) process.patJets.userData.userFloats.src = [ cms.InputTag("pileupJetId:fullDiscriminant"), ] process.patJets.userData.userInts.src = [ cms.InputTag("pileupJetId:fullId"), ] ## Quark Gluon Likelihood process.load('RecoJets.JetProducers.QGTagger_cfi') task.add(process.QGTaggerTask) process.patJets.userData.userFloats.src += [ cms.InputTag('QGTagger:qgLikelihood'), ] ## DeepCSV meta discriminators (simple arithmethic on output probabilities) process.load('RecoBTag.Combined.deepFlavour_cff') task.add(process.pfDeepCSVDiscriminatorsJetTags) process.patJets.discriminatorSources.extend([ cms.InputTag('pfDeepCSVDiscriminatorsJetTags:BvsAll'), cms.InputTag('pfDeepCSVDiscriminatorsJetTags:CvsB'), cms.InputTag('pfDeepCSVDiscriminatorsJetTags:CvsL'), ]) ## CaloJets process.caloJetMap = cms.EDProducer( "RecoJetDeltaRValueMapProducer", src=process.patJets.jetSource, matched=cms.InputTag("ak4CaloJets"), distMax=cms.double(0.4), values=cms.vstring('pt', 'emEnergyFraction'), valueLabels=cms.vstring('pt', 'emEnergyFraction'), lazyParser=cms.bool(True)) task.add(process.caloJetMap) process.patJets.userData.userFloats.src += [ cms.InputTag("caloJetMap:pt"), cms.InputTag("caloJetMap:emEnergyFraction") ] #Muon object modifications from PhysicsTools.PatAlgos.slimming.muonIsolationsPUPPI_cfi import makeInputForPUPPIIsolationMuon makeInputForPUPPIIsolationMuon(process) #EGM object modifications from PhysicsTools.PatAlgos.slimming.egmIsolationsPUPPI_cfi import makeInputForPUPPIIsolationEgm makeInputForPUPPIIsolationEgm(process) from RecoEgamma.EgammaTools.egammaObjectModificationsInMiniAOD_cff import egamma_modifications process.slimmedElectrons.modifierConfig.modifications = egamma_modifications process.slimmedPhotons.modifierConfig.modifications = egamma_modifications #VID Electron IDs process.patElectrons.addElectronID = cms.bool(True) electron_ids = [ 'RecoEgamma.ElectronIdentification.Identification.heepElectronID_HEEPV70_cff', 'RecoEgamma.ElectronIdentification.Identification.heepElectronID_HEEPV71_cff', 'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Fall17_94X_V1_cff', 'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Fall17_94X_V2_cff', 'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Fall17_noIso_V1_cff', 'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Fall17_iso_V1_cff', 'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Fall17_noIso_V2_cff', 'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Fall17_iso_V2_cff', 'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Summer16_80X_V1_cff', 'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring16_GeneralPurpose_V1_cff', 'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring16_HZZ_V1_cff', ] switchOnVIDElectronIdProducer(process, DataFormat.MiniAOD, task) process.egmGsfElectronIDs.physicsObjectSrc = cms.InputTag( "reducedEgamma", "reducedGedGsfElectrons") process.electronMVAValueMapProducer.src = cms.InputTag( 'reducedEgamma', 'reducedGedGsfElectrons') # To use older DataFormats, the electronMVAValueMapProducer MUST take a updated electron collection # such that the conversion variables are filled correctly. process.load("RecoEgamma.EgammaTools.gedGsfElectronsTo106X_cff") run2_miniAOD_80XLegacy.toModify( task, func=lambda t: t.add(process.gedGsfElectronsFrom80XTo106XTask)) run2_miniAOD_80XLegacy.toModify( process.electronMVAValueMapProducer, keysForValueMaps=cms.InputTag('reducedEgamma', 'reducedGedGsfElectrons'), src=cms.InputTag("gedGsfElectronsFrom80XTo106X")) run2_miniAOD_94XFall17.toModify( task, func=lambda t: t.add(process.gedGsfElectronsFrom94XTo106XTask)) run2_miniAOD_94XFall17.toModify( process.electronMVAValueMapProducer, keysForValueMaps=cms.InputTag('reducedEgamma', 'reducedGedGsfElectrons'), src=cms.InputTag("gedGsfElectronsFrom94XTo106X")) from Configuration.Eras.Modifier_pp_on_AA_2018_cff import pp_on_AA_2018 pp_on_AA_2018.toModify( task, func=lambda t: t.add(process.gedGsfElectronsFrom94XTo106XTask)) pp_on_AA_2018.toModify(process.electronMVAValueMapProducer, keysForValueMaps=cms.InputTag( 'reducedEgamma', 'reducedGedGsfElectrons'), src="gedGsfElectronsFrom94XTo106X") for idmod in electron_ids: setupAllVIDIdsInModule(process, idmod, setupVIDElectronSelection, None, False, task) #VID Photon IDs process.patPhotons.addPhotonID = cms.bool(True) photon_ids = [ 'RecoEgamma.PhotonIdentification.Identification.cutBasedPhotonID_Fall17_94X_V1_TrueVtx_cff', 'RecoEgamma.PhotonIdentification.Identification.cutBasedPhotonID_Fall17_94X_V2_cff', 'RecoEgamma.PhotonIdentification.Identification.mvaPhotonID_Fall17_94X_V1p1_cff', 'RecoEgamma.PhotonIdentification.Identification.mvaPhotonID_Fall17_94X_V2_cff', 'RecoEgamma.PhotonIdentification.Identification.cutBasedPhotonID_Spring16_V2p2_cff', 'RecoEgamma.PhotonIdentification.Identification.mvaPhotonID_Spring16_nonTrig_V1_cff' ] switchOnVIDPhotonIdProducer(process, DataFormat.AOD, task) process.egmPhotonIDs.physicsObjectSrc = cms.InputTag( "reducedEgamma", "reducedGedPhotons") process.photonMVAValueMapProducer.src = cms.InputTag( 'reducedEgamma', 'reducedGedPhotons') for idmod in photon_ids: setupAllVIDIdsInModule(process, idmod, setupVIDPhotonSelection, None, False, task) #add the cut base IDs bitmaps of which cuts passed from RecoEgamma.EgammaTools.egammaObjectModifications_tools import makeVIDBitsModifier egamma_modifications.append( makeVIDBitsModifier(process, "egmGsfElectronIDs", "egmPhotonIDs")) #-- Adding boosted taus from RecoTauTag.Configuration.boostedHPSPFTaus_cfi import addBoostedTaus addBoostedTaus(process) process.load("RecoTauTag.Configuration.RecoPFTauTag_cff") process.load("RecoTauTag.Configuration.HPSPFTaus_cff") #-- Adding customization for 94X 2017 legacy reMniAOD _makePatTausTaskWithRetrainedMVATauID = process.makePatTausTask.copy() _makePatTausTaskWithRetrainedMVATauID.add( process.hpsPFTauBasicDiscriminatorsTask, process.hpsPFTauDiscriminationByIsolationMVArun2v1DBoldDMwLTTask, process.hpsPFTauDiscriminationByIsolationMVArun2v1DBnewDMwLTTask, process.hpsPFTauBasicDiscriminatorsdR03Task, process.hpsPFTauDiscriminationByIsolationMVArun2v1DBdR03oldDMwLTTask, process.hpsPFTauDiscriminationByMVA6rawElectronRejection, process.hpsPFTauDiscriminationByMVA6ElectronRejection, process.hpsPFTauDiscriminationByMuonRejection3) from Configuration.ProcessModifiers.run2_miniAOD_UL_cff import run2_miniAOD_UL (run2_miniAOD_94XFall17 | run2_miniAOD_UL).toReplaceWith( process.makePatTausTask, _makePatTausTaskWithRetrainedMVATauID) #-- Adding DeepTauID # deepTau v2p1 _updatedTauName = 'slimmedTausDeepIDsv2p1' _noUpdatedTauName = 'slimmedTausNoDeepIDs' import RecoTauTag.RecoTau.tools.runTauIdMVA as tauIdConfig tauIdEmbedder = tauIdConfig.TauIDEmbedder(process, debug=False, updatedTauName=_updatedTauName, toKeep=['deepTau2017v2p1']) from Configuration.Eras.Modifier_phase2_common_cff import phase2_common #Phase2 Tau MVA phase2_common.toModify( tauIdEmbedder.toKeep, func=lambda t: t.append('newDMPhase2v1')) #Phase2 Tau MVA tauIdEmbedder.runTauID() addToProcessAndTask(_noUpdatedTauName, process.slimmedTaus.clone(), process, task) delattr(process, 'slimmedTaus') process.deepTau2017v2p1.taus = _noUpdatedTauName process.slimmedTaus = getattr(process, _updatedTauName).clone(src=_noUpdatedTauName) process.deepTauIDTask = cms.Task(process.deepTau2017v2p1, process.slimmedTaus) task.add(process.deepTauIDTask) if 'newDMPhase2v1' in tauIdEmbedder.toKeep: process.rerunDiscriminationByIsolationMVADBnewDMwLTPhase2raw.PATTauProducer = _noUpdatedTauName process.rerunDiscriminationByIsolationMVADBnewDMwLTPhase2.PATTauProducer = _noUpdatedTauName task.add(process.rerunIsolationMVADBnewDMwLTPhase2Task) #-- Rerun tauID against dead ECal towers to taus for the various re-MiniAOD eras # to enable default behoviour with leading track extrapolation to ECAL _makePatTausTaskWithDeadECalVeto = process.makePatTausTask.copy() _makePatTausTaskWithDeadECalVeto.add( process.hpsPFTauDiscriminationByDeadECALElectronRejection) _run2_miniAOD_ANY = (run2_miniAOD_80XLegacy | run2_miniAOD_94XFall17 | run2_miniAOD_UL) _run2_miniAOD_ANY.toReplaceWith(process.makePatTausTask, _makePatTausTaskWithDeadECalVeto) #-- Adding customization for 80X 2016 legacy reMiniAOD and 2018 heavy ions _makePatTausTaskWithTauReReco = process.makePatTausTask.copy() _makePatTausTaskWithTauReReco.add(process.PFTauTask) (run2_miniAOD_80XLegacy | pp_on_AA_2018).toReplaceWith( process.makePatTausTask, _makePatTausTaskWithTauReReco) # Adding puppi jets process.load('CommonTools.PileupAlgos.Puppi_cff') process.load('RecoJets.JetProducers.ak4PFJets_cfi') from Configuration.Eras.Modifier_pA_2016_cff import pA_2016 _rerun_puppijets_task = task.copy() _rerun_puppijets_task.add(process.puppi, process.ak4PFJetsPuppi) (_run2_miniAOD_ANY | pA_2016 | pp_on_AA_2018).toReplaceWith( task, _rerun_puppijets_task) from RecoJets.JetAssociationProducers.j2tParametersVX_cfi import j2tParametersVX process.ak4PFJetsPuppiTracksAssociatorAtVertex = cms.EDProducer( "JetTracksAssociatorAtVertex", j2tParametersVX, jets=cms.InputTag("ak4PFJetsPuppi")) task.add(process.ak4PFJetsPuppiTracksAssociatorAtVertex) process.patJetPuppiCharge = cms.EDProducer( "JetChargeProducer", src=cms.InputTag("ak4PFJetsPuppiTracksAssociatorAtVertex"), var=cms.string('Pt'), exp=cms.double(1.0)) task.add(process.patJetPuppiCharge) noDeepFlavourDiscriminators = [ x.value() for x in process.patJets.discriminatorSources if not "DeepFlavour" in x.value() ] addJetCollection(process, postfix="", labelName='Puppi', jetSource=cms.InputTag('ak4PFJetsPuppi'), jetCorrections=('AK4PFPuppi', ['L2Relative', 'L3Absolute'], ''), pfCandidates=cms.InputTag("particleFlow"), algo='AK', rParam=0.4, btagDiscriminators=noDeepFlavourDiscriminators) process.patJetGenJetMatchPuppi.matched = 'slimmedGenJets' process.patJetsPuppi.jetChargeSource = cms.InputTag("patJetPuppiCharge") process.selectedPatJetsPuppi.cut = cms.string("pt > 15") from PhysicsTools.PatAlgos.slimming.applyDeepBtagging_cff import applyDeepBtagging applyDeepBtagging(process) addToProcessAndTask( 'slimmedJetsPuppi', process.slimmedJetsNoDeepFlavour.clone( src="selectedPatJetsPuppi", packedPFCandidates="packedPFCandidates"), process, task) task.add(process.slimmedJetsPuppi) # Embed pixelClusterTagInfos in slimmedJets process.patJets.addTagInfos = True process.patJets.tagInfoSources = ["pixelClusterTagInfos"] process.slimmedJetsNoDeepFlavour.dropTagInfos = '0' process.updatedPatJetsTransientCorrectedSlimmedDeepFlavour.addTagInfos = True process.updatedPatJetsTransientCorrectedSlimmedDeepFlavour.tagInfoSources = [ "pixelClusterTagInfos" ] _run2_miniAOD_ANY.toModify(process.patJets, addTagInfos=False) _run2_miniAOD_ANY.toModify( process.updatedPatJetsTransientCorrectedSlimmedDeepFlavour, addTagInfos=False) ## puppi met process.load('RecoMET.METProducers.pfMetPuppi_cfi') _rerun_puppimet_task = task.copy() _rerun_puppimet_task.add(process.puppiNoLep, process.pfMetPuppi) (_run2_miniAOD_ANY | pA_2016 | pp_on_AA_2018).toReplaceWith( task, _rerun_puppimet_task) runMetCorAndUncForMiniAODProduction(process, metType="Puppi", jetCollUnskimmed="slimmedJetsPuppi", recoMetFromPFCs=True, jetFlavor="AK4PFPuppi", postfix="Puppi") process.load('PhysicsTools.PatAlgos.slimming.slimmedMETs_cfi') task.add(process.slimmedMETs) addToProcessAndTask('slimmedMETsPuppi', process.slimmedMETs.clone(), process, task) process.slimmedMETsPuppi.src = cms.InputTag("patMETsPuppi") process.slimmedMETsPuppi.rawVariation = cms.InputTag("patPFMetPuppi") process.slimmedMETsPuppi.t1Uncertainties = cms.InputTag( "patPFMetT1%sPuppi") process.slimmedMETsPuppi.t01Variation = cms.InputTag("patPFMetT0pcT1Puppi") process.slimmedMETsPuppi.t1SmearedVarsAndUncs = cms.InputTag( "patPFMetT1Smear%sPuppi") process.slimmedMETsPuppi.tXYUncForRaw = cms.InputTag("patPFMetTxyPuppi") process.slimmedMETsPuppi.tXYUncForT1 = cms.InputTag("patPFMetT1TxyPuppi") process.slimmedMETsPuppi.tXYUncForT01 = cms.InputTag( "patPFMetT0pcT1TxyPuppi") process.slimmedMETsPuppi.tXYUncForT1Smear = cms.InputTag( "patPFMetT1SmearTxyPuppi") process.slimmedMETsPuppi.tXYUncForT01Smear = cms.InputTag( "patPFMetT0pcT1SmearTxyPuppi") del process.slimmedMETsPuppi.caloMET process.load('RecoMET.METPUSubtraction.deepMETProducer_cfi') addToProcessAndTask('deepMETsResolutionTune', process.deepMETProducer.clone(), process, task) addToProcessAndTask('deepMETsResponseTune', process.deepMETProducer.clone(), process, task) process.deepMETsResponseTune.graph_path = 'RecoMET/METPUSubtraction/data/deepmet/deepmet_resp_v1_2018.pb' from Configuration.Eras.Modifier_phase2_common_cff import phase2_common phase2_common.toModify( process.deepMETsResolutionTune, max_n_pf=12500, graph_path="RecoMET/METPUSubtraction/data/deepmet/deepmet_v1_phase2.pb" ) phase2_common.toModify( process.deepMETsResponseTune, max_n_pf=12500, graph_path= "RecoMET/METPUSubtraction/data/deepmet/deepmet_resp_v1_phase2.pb") from Configuration.Eras.Modifier_run2_jme_2016_cff import run2_jme_2016 run2_jme_2016.toModify( process.deepMETsResponseTune, graph_path= "RecoMET/METPUSubtraction/data/deepmet/deepmet_resp_v1_2016.pb") # add DetIdAssociatorRecords to EventSetup (for isolatedTracks) process.load("TrackingTools.TrackAssociator.DetIdAssociatorESProducer_cff") # EGamma objects from HGCal are not yet in GED # so add companion collections for Phase-II MiniAOD production from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal process.load("RecoEgamma.EgammaTools.slimmedEgammaFromMultiCl_cff") phase2_hgcal.toModify( task, func=lambda t: t.add(process.slimmedEgammaFromMultiClTask)) # L1 pre-firing weights for 2016 and 2017 from Configuration.Eras.Modifier_run2_L1prefiring_cff import run2_L1prefiring from Configuration.Eras.Modifier_stage1L1Trigger_cff import stage1L1Trigger from Configuration.Eras.Modifier_stage2L1Trigger_2017_cff import stage2L1Trigger_2017 process.load("PhysicsTools.PatUtils.L1ECALPrefiringWeightProducer_cff") stage1L1Trigger.toModify(process.prefiringweight, DataEra="2016BtoH") stage2L1Trigger_2017.toModify(process.prefiringweight, DataEra="2017BtoF") run2_L1prefiring.toModify(task, func=lambda t: t.add(process.prefiringweight))
simHitCollections=cms.PSet(muon=cms.VInputTag( cms.InputTag('MuonSimHits', 'MuonDTHits'), cms.InputTag('MuonSimHits', 'MuonCSCHits'), cms.InputTag('MuonSimHits', 'MuonRPCHits')), trackerAndPixel=cms.VInputTag( cms.InputTag('famosSimHits', 'TrackerHits'))), simTrackCollection='famosSimHits', simVertexCollection='famosSimHits') from Configuration.Eras.Modifier_run2_GEM_2017_cff import run2_GEM_2017 run2_GEM_2017.toModify( trackingParticles, simHitCollections=dict(muon=trackingParticles.simHitCollections.muon + [cms.InputTag("g4SimHits", "MuonGEMHits")])) from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM run3_GEM.toModify( trackingParticles, simHitCollections=dict(muon=trackingParticles.simHitCollections.muon + [cms.InputTag("g4SimHits", "MuonGEMHits")])) from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon phase2_muon.toModify( trackingParticles, simHitCollections=dict(muon=trackingParticles.simHitCollections.muon + [cms.InputTag("g4SimHits", "MuonME0Hits")])) from Configuration.Eras.Modifier_phase2_tracker_cff import phase2_tracker phase2_tracker.toModify(trackingParticles, simHitCollections=dict(tracker=[]))
phase2_muon.toModify(mixData, workers = dict( dt = dict(pileInputTag = "simMuonDTDigis"), rpc = dict(pileInputTag = "simMuonRPCDigis"), csc = dict( strip = dict(pileInputTag = "simMuonCSCDigis:MuonCSCStripDigi"), wire = dict(pileInputTag = "simMuonCSCDigis:MuonCSCWireDigi"), comparator = dict(pileInputTag = "simMuonCSCDigis:MuonCSCComparatorDigi"), ), gem = cms.PSet( workerType = cms.string("PreMixingGEMWorker"), digiTagSig = cms.InputTag("simMuonGEMDigis"), pileInputTag = cms.InputTag("simMuonGEMDigis",""), collectionDM = cms.string(''), ), me0 = cms.PSet( workerType = cms.string("PreMixingME0Worker"), digiTagSig = cms.InputTag("simMuonME0Digis"), pileInputTag = cms.InputTag("simMuonME0Digis",""), collectionDM = cms.string(''), ), me0SimHit = cms.PSet( workerType = cms.string("PreMixingCrossingFramePSimHitWorker"), labelSig = cms.InputTag("mix", "g4SimHitsMuonME0Hits"), pileInputTag = cms.InputTag("mix", "g4SimHitsMuonME0Hits"), collectionDM = cms.string("g4SimHitsMuonME0Hits"), ), gemSimLink = cms.PSet( workerType = cms.string("PreMixingGEMDigiSimLinkWorker"), labelSig = cms.InputTag("simMuonGEMDigis"), pileInputTag = cms.InputTag("simMuonGEMDigis"), collectionDM = cms.string('GEMDigiSimLink'), ), gemStripSimLink = cms.PSet( workerType = cms.string("PreMixingStripDigiSimLinkWorker"), labelSig = cms.InputTag("simMuonGEMDigis"), pileInputTag = cms.InputTag("simMuonGEMDigis"), collectionDM = cms.string('GEMStripDigiSimLink'), ), me0SimLink = cms.PSet( workerType = cms.string("PreMixingME0DigiSimLinkWorker"), labelSig = cms.InputTag("simMuonMe0Digis"), pileInputTag = cms.InputTag("simMuonME0Digis"), collectionDM = cms.string('ME0DigiSimLink'), ), me0StripSimLink = cms.PSet( workerType = cms.string("PreMixingStripDigiSimLinkWorker"), labelSig = cms.InputTag("simMuonME0Digis"), pileInputTag = cms.InputTag("simMuonME0Digis"), collectionDM = cms.string('ME0StripDigiSimLink'), ), ) )
) simGmtStage2Digis = cms.EDProducer('L1TMuonProducer', barrelTFInput = cms.InputTag("simKBmtfDigis", "BMTF"), overlapTFInput = cms.InputTag("simOmtfDigis", "OMTF"), forwardTFInput = cms.InputTag("simEmtfDigis", "EMTF"), #triggerTowerInput = cms.InputTag("simGmtCaloSumDigis", "TriggerTower2x2s"), triggerTowerInput = cms.InputTag("simGmtCaloSumDigis", "TriggerTowerSums"), autoBxRange = cms.bool(True), # if True the output BX range is calculated from the inputs and 'bxMin' and 'bxMax' are ignored bxMin = cms.int32(-2), bxMax = cms.int32(2), autoCancelMode = cms.bool(False), # if True the cancel out methods are configured depending on the FW version number and 'emtfCancelMode' is ignored emtfCancelMode = cms.string("coordinate"), # 'tracks' or 'coordinate' runPhase2 = cms.bool(False) ) from CondCore.CondDB.CondDB_cfi import CondDB CondDB.connect = cms.string("frontier://FrontierProd/CMS_CONDITIONS") l1ugmtdb = cms.ESSource("PoolDBESSource", CondDB, toGet = cms.VPSet( cms.PSet( record = cms.string('L1TMuonGlobalParamsO2ORcd'), tag = cms.string("L1TMuonGlobalParamsPrototype_Stage2v0_hlt") ) ) ) from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon phase2_muon.toModify( simGmtStage2Digis, runPhase2 =cms.bool(True) )
import FWCore.ParameterSet.Config as cms from RecoMuon.MuonSeedGenerator.ptSeedParameterization_cfi import * from RecoMuon.MuonSeedGenerator.MuonSeedPtScale_cfi import * # module standAloneMuonSeeds = MuonSeedGenerator { ancientMuonSeed = cms.EDProducer( "MuonSeedGenerator", ptSeedParameterization, dphiScale, beamSpotTag=cms.InputTag("offlineBeamSpot"), scaleDT=cms.bool(True), CSCRecSegmentLabel=cms.InputTag("cscSegments"), DTRecSegmentLabel=cms.InputTag("dt4DSegments"), ME0RecSegmentLabel=cms.InputTag("me0Segments"), EnableDTMeasurement=cms.bool(True), EnableCSCMeasurement=cms.bool(True), EnableME0Measurement=cms.bool(False), # places where it's OK to have single-segment seeds crackEtas=cms.vdouble(0.2, 1.6, 1.7), crackWindow=cms.double(0.04), deltaPhiSearchWindow=cms.double(0.25), deltaEtaSearchWindow=cms.double(0.2), deltaEtaCrackSearchWindow=cms.double(0.25), ) # phase2 ME0 from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon phase2_muon.toModify(ancientMuonSeed, EnableME0Measurement=True)
run3_GEM.toModify( cscTriggerPrimitiveDigis, GEMPadDigiProducer=cms.InputTag("simMuonGEMPadDigis"), GEMPadDigiClusterProducer=cms.InputTag("simMuonGEMPadDigiClusters"), commonParam=dict(isSLHC=cms.bool(True), smartME1aME1b=cms.bool(True), runME11ILT=cms.bool(True), useClusters=cms.bool(False)), clctSLHC=dict(clctNplanesHitPattern=3), me11tmbSLHCGEM=me11tmbSLHCGEM, copadParamGE11=copadParamGE11) ## GEM-CSC ILT in ME2/1, CSC in ME3/1 and ME4/1 from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon phase2_muon.toModify(cscTriggerPrimitiveDigis, commonParam=dict(runME21ILT=cms.bool(True), runME3141ILT=cms.bool(True)), alctSLHCME21=cscTriggerPrimitiveDigis.alctSLHC.clone( alctNplanesHitPattern=3), clctSLHCME21=cscTriggerPrimitiveDigis.clctSLHC.clone( clctNplanesHitPattern=3), me21tmbSLHCGEM=me21tmbSLHCGEM, alctSLHCME3141=cscTriggerPrimitiveDigis.alctSLHC.clone( alctNplanesHitPattern=4), clctSLHCME3141=cscTriggerPrimitiveDigis.clctSLHC.clone( clctNplanesHitPattern=4), me3141tmbSLHC=me3141tmbSLHC, copadParamGE11=copadParamGE11, copadParamGE21=copadParamGE21)
recAlgoConfig = cms.PSet( ), recAlgo = cms.string('RPCRecHitStandardAlgo'), rpcDigiLabel = cms.InputTag('muonRPCDigis'), maskSource = cms.string('File'), maskvecfile = cms.FileInPath('RecoLocalMuon/RPCRecHit/data/RPCMaskVec.dat'), deadSource = cms.string('File'), deadvecfile = cms.FileInPath('RecoLocalMuon/RPCRecHit/data/RPCDeadVec.dat') ) rpcNewRecHits = cms.EDProducer("RPCRecHitProducer", recAlgoConfig = cms.PSet( ), recAlgo = cms.string('RPCRecHitStandardAlgo'), rpcDigiLabel = cms.InputTag('muonRPCNewDigis'), maskSource = cms.string('File'), maskvecfile = cms.FileInPath('RecoLocalMuon/RPCRecHit/data/RPCMaskVec.dat'), deadSource = cms.string('File'), deadvecfile = cms.FileInPath('RecoLocalMuon/RPCRecHit/data/RPCDeadVec.dat') ) #disabling DIGI2RAW,RAW2DIGI chain for Phase2 from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon phase2_muon.toModify(rpcRecHits, rpcDigiLabel = cms.InputTag('simMuonRPCDigis')) from Configuration.ProcessModifiers.premix_stage2_cff import premix_stage2 (premix_stage2 & phase2_muon).toModify(rpcRecHits, rpcDigiLabel = "mixData" )
crossingFrames = theMixObjects.mixSH.crossingFrames + [ 'MuonGEMHits' ] ) ) from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM run3_GEM.toModify( theMixObjects, mixSH = dict( input = theMixObjects.mixSH.input + [ cms.InputTag("g4SimHits","MuonGEMHits") ], subdets = theMixObjects.mixSH.subdets + [ 'MuonGEMHits' ], crossingFrames = theMixObjects.mixSH.crossingFrames + [ 'MuonGEMHits' ] ) ) from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon phase2_muon.toModify( theMixObjects, mixSH = dict( input = theMixObjects.mixSH.input + [ cms.InputTag("g4SimHits","MuonME0Hits") ], subdets = theMixObjects.mixSH.subdets + [ 'MuonME0Hits' ], crossingFrames = theMixObjects.mixSH.crossingFrames + [ 'MuonME0Hits' ] ) ) from Configuration.ProcessModifiers.premix_stage1_cff import premix_stage1 (premix_stage1 & phase2_muon).toModify(theMixObjects, mixSH = dict( pcrossingFrames = theMixObjects.mixSH.pcrossingFrames + [ 'MuonME0Hits' ] ) ) from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal phase2_hgcal.toModify( theMixObjects, mixCH = dict( input = theMixObjects.mixCH.input + [ cms.InputTag("g4SimHits",hgceeDigitizer.hitCollection.value()), cms.InputTag("g4SimHits",hgchefrontDigitizer.hitCollection.value()) ], subdets = theMixObjects.mixCH.subdets + [ hgceeDigitizer.hitCollection.value(),
# adding ME0 trigger primitives def _appendME0Digis(obj): l1ME0Digis = [ 'keep *_simMuonME0PadDigis__*', 'keep *_me0TriggerDigis__*', 'keep *_simMuonME0PseudoReDigisCoarse__*', 'keep *_me0RecHitsCoarse__*', 'keep *_me0TriggerPseudoDigis__*', 'keep *_me0TriggerConvertedPseudoDigis__*', ] obj.outputCommands += l1ME0Digis from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon phase2_muon.toModify(L1TriggerFEVTDEBUG, func=_appendME0Digis) # adding phase2 trigger def _appendPhase2Digis(obj): l1Phase2Digis = [ "keep *_simKBmtfDigis_*_*", 'keep *_hgcalVFEProducerhgcalConcentratorProducer_*_*', 'keep *_hgcalBackEndLayer1Producer_*_*', 'keep *_hgcalBackEndLayer2Producer_*_*', 'keep *_hgcalTowerMapProducer_*_*', 'keep *_hgcalTowerProducer_*_*', 'keep *_L1EGammaClusterEmuProducer_*_*', 'keep *_l1EGammaEEProducer_*_*', 'keep *_L1TkPrimaryVertex_*_*', 'keep *_L1TkElectronsCrystal_*_*',
debugParameters=True, checkBadChambers=False, commonParam=dict(gangedME1a=False)) ## GEM-CSC ILT in ME1/1 from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM run3_GEM.toModify(cscTriggerPrimitiveDigis, GEMPadDigiProducer=cms.InputTag("simMuonGEMPadDigis"), commonParam=dict(isSLHC=cms.bool(True), smartME1aME1b=cms.bool(True), runME11ILT=cms.bool(True)), clctSLHC=dict(clctNplanesHitPattern=3), me11tmbSLHCGEM=me11tmbSLHCGEM) ## GEM-CSC ILT in ME2/1, CSC-RPC ILT in ME3/1 and ME4/1 from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon phase2_muon.toModify(cscTriggerPrimitiveDigis, RPCDigiProducer=cms.InputTag("simMuonRPCDigis"), commonParam=dict(runME21ILT=cms.bool(True), runME3141ILT=cms.bool(False)), alctSLHCME21=cscTriggerPrimitiveDigis.alctSLHC.clone( alctNplanesHitPattern=3), clctSLHCME21=cscTriggerPrimitiveDigis.clctSLHC.clone( clctNplanesHitPattern=3), alctSLHCME3141=cscTriggerPrimitiveDigis.alctSLHC.clone( alctNplanesHitPattern=3), clctSLHCME3141=cscTriggerPrimitiveDigis.clctSLHC.clone( clctNplanesHitPattern=3), me21tmbSLHCGEM=me21tmbSLHCGEM, me3141tmbSLHCRPC=me3141tmbSLHCRPC)
checkBadChambers = False, commonParam = dict(gangedME1a = False) ) ## GEM-CSC ILT in ME1/1 from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM run3_GEM.toModify( cscTriggerPrimitiveDigis, GEMPadDigiProducer = cms.InputTag("simMuonGEMPadDigis"), commonParam = dict(isSLHC = cms.bool(True), smartME1aME1b = cms.bool(True), runME11ILT = cms.bool(True)), clctSLHC = dict(clctNplanesHitPattern = 3), me11tmbSLHCGEM = me11tmbSLHCGEM, copadParam = copadParam ) ## GEM-CSC ILT in ME2/1, CSC-RPC ILT in ME3/1 and ME4/1 from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon phase2_muon.toModify( cscTriggerPrimitiveDigis, RPCDigiProducer = cms.InputTag("simMuonRPCDigis"), commonParam = dict(runME21ILT = cms.bool(True), runME3141ILT = cms.bool(False)), alctSLHCME21 = cscTriggerPrimitiveDigis.alctSLHC.clone(alctNplanesHitPattern = 3), clctSLHCME21 = cscTriggerPrimitiveDigis.clctSLHC.clone(clctNplanesHitPattern = 3), alctSLHCME3141 = cscTriggerPrimitiveDigis.alctSLHC.clone(alctNplanesHitPattern = 3), clctSLHCME3141 = cscTriggerPrimitiveDigis.clctSLHC.clone(clctNplanesHitPattern = 3), me21tmbSLHCGEM = me21tmbSLHCGEM, me3141tmbSLHCRPC = me3141tmbSLHCRPC, copadParam = copadParam )
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 = cms.bool(True) process.patMuons.computeMuonMVA = cms.bool(True) process.patMuons.computeSoftMuonMVA = cms.bool(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.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.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') process.electronRegressionValueMapProducer.src = \ cms.InputTag('reducedEgamma','reducedGedGsfElectrons') for idmod in electron_ids: setupAllVIDIdsInModule(process,idmod,setupVIDElectronSelection,None,False,task) #heepIDVarValueMaps only exists if HEEP V6.1 or HEEP 7.0 ID has already been loaded if hasattr(process,'heepIDVarValueMaps'): process.heepIDVarValueMaps.elesMiniAOD = cms.InputTag('reducedEgamma','reducedGedGsfElectrons') #force HEEP to use miniAOD (otherwise it'll detect the AOD) process.heepIDVarValueMaps.dataFormat = cms.int32(2) #add the HEEP trk isol to the slimmed electron, add it to the first FromFloatValMap modifier for pset in process.slimmedElectrons.modifierConfig.modifications: if pset.hasParameter("modifierName") and pset.modifierName == cms.string('EGExtraInfoModifierFromFloatValueMaps'): pset.electron_config.heepTrkPtIso = cms.InputTag("heepIDVarValueMaps","eleTrkPtIso") break #VID Photon IDs process.patPhotons.addPhotonID = cms.bool(True) photon_ids = ['RecoEgamma.PhotonIdentification.Identification.cutBasedPhotonID_Fall17_94X_V1_TrueVtx_cff', 'RecoEgamma.PhotonIdentification.Identification.mvaPhotonID_Fall17_94X_V1_cff', 'RecoEgamma.PhotonIdentification.Identification.mvaPhotonID_Fall17_94X_V1p1_cff', 'RecoEgamma.PhotonIdentification.Identification.cutBasedPhotonID_Spring16_V2p2_cff', 'RecoEgamma.PhotonIdentification.Identification.mvaPhotonID_Spring16_nonTrig_V1_cff'] switchOnVIDPhotonIdProducer(process,DataFormat.AOD, task) process.egmPhotonIsolation.srcToIsolate = \ cms.InputTag("reducedEgamma","reducedGedPhotons") for iPSet in process.egmPhotonIsolation.isolationConeDefinitions: iPSet.particleBasedIsolation = cms.InputTag("reducedEgamma","reducedPhotonPfCandMap") process.egmPhotonIDs.physicsObjectSrc = \ cms.InputTag("reducedEgamma","reducedGedPhotons") process.photonIDValueMapProducer.src = \ cms.InputTag("reducedEgamma","reducedGedPhotons") process.photonRegressionValueMapProducer.src = \ cms.InputTag("reducedEgamma","reducedGedPhotons") process.photonIDValueMapProducer.particleBasedIsolation = \ cms.InputTag("reducedEgamma","reducedPhotonPfCandMap") 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) run2_miniAOD_94XFall17.toReplaceWith( process.makePatTausTask, _makePatTausTaskWithRetrainedMVATauID ) #-- Adding customization for 80X 2016 legacy reMiniAOD from Configuration.Eras.Modifier_run2_miniAOD_80XLegacy_cff import run2_miniAOD_80XLegacy _makePatTausTaskWithTauReReco = process.makePatTausTask.copy() _makePatTausTaskWithTauReReco.add(process.PFTauTask) run2_miniAOD_80XLegacy.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) ## 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))
from SimCalorimetry.HGCalSimProducers.hgcalDigitizer_cfi import hgceeDigitizer, hgchefrontDigitizer from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM run3_GEM.toModify( theMixObjects, mixSH = dict( input = theMixObjects.mixSH.input + [ cms.InputTag("g4SimHits","MuonGEMHits") ], subdets = theMixObjects.mixSH.subdets + [ 'MuonGEMHits' ], crossingFrames = theMixObjects.mixSH.crossingFrames + [ 'MuonGEMHits' ] ) ) from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon phase2_muon.toModify( theMixObjects, mixSH = dict( input = theMixObjects.mixSH.input + [ cms.InputTag("g4SimHits","MuonME0Hits") ], subdets = theMixObjects.mixSH.subdets + [ 'MuonME0Hits' ], crossingFrames = theMixObjects.mixSH.crossingFrames + [ 'MuonME0Hits' ] ) ) from Configuration.Eras.Modifier_phase2_hgcal_cff import phase2_hgcal phase2_hgcal.toModify( theMixObjects, mixCH = dict( input = theMixObjects.mixCH.input + [ cms.InputTag("g4SimHits",hgceeDigitizer.hitCollection.value()), cms.InputTag("g4SimHits",hgchefrontDigitizer.hitCollection.value()) ], subdets = theMixObjects.mixCH.subdets + [ hgceeDigitizer.hitCollection.value(), hgchefrontDigitizer.hitCollection.value() ] ) ) from Configuration.Eras.Modifier_phase2_timing_cff import phase2_timing phase2_timing.toModify( theMixObjects,
signalOnlyTP=cms.bool(True), intimeOnlyTP=cms.bool(False), minRapidityTP=cms.double(-2.6), minHitTP=cms.int32(3), ptMinTP=cms.double(0.2), ptMaxTP=cms.double(1e100), maxRapidityTP=cms.double(2.6), tipTP=cms.double(1000))) trackingParticleSelection = cms.Sequence(mergedtruth) from Configuration.Eras.Modifier_run2_GEM_2017_cff import run2_GEM_2017 run2_GEM_2017.toModify( trackingParticleSelection, simHitCollections=dict( muon=trackingParticleSelection.simHitCollections.muon + ["g4SimHitsMuonGEMHits"])) from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM run3_GEM.toModify(trackingParticleSelection, simHitCollections=dict( muon=trackingParticleSelection.simHitCollections.muon + ["g4SimHitsMuonGEMHits"])) from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon phase2_muon.toModify( trackingParticleSelection, simHitCollections=dict( muon=trackingParticleSelection.simHitCollections.muon + ["g4SimHitsMuonME0Hits"]))
# arbitration cleaning runArbitrationCleaner=cms.bool(True), arbitrationCleanerOptions=cms.PSet( ME1a=cms.bool(True), Overlap=cms.bool(True), Clustering=cms.bool(True), OverlapDPhi=cms.double(0.0786), # 4.5 degrees OverlapDTheta=cms.double(0.02), # 1.14 degrees ClusterDPhi=cms.double(0.6), # 34 degrees ClusterDTheta=cms.double(0.02) # 1.14 ), # tracker muon arbitration arbitrateTrackerMuons=cms.bool(True)) from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM run3_GEM.toModify(muons1stStep, TrackAssociatorParameters=dict(useGEM=True)) from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon phase2_muon.toModify(muons1stStep, TrackAssociatorParameters=dict(useME0=True)) from Configuration.Eras.Modifier_phase2_GE0_cff import phase2_GE0 phase2_GE0.toModify(muons1stStep, TrackAssociatorParameters=dict(useME0=False)) muonEcalDetIds = cms.EDProducer("InterestingEcalDetIdProducer", inputCollection=cms.InputTag("muons1stStep")) from Configuration.Eras.Modifier_pp_on_AA_2018_cff import pp_on_AA_2018 pp_on_AA_2018.toModify(muons1stStep, minPt=0.8) from Configuration.ProcessModifiers.recoFromReco_cff import recoFromReco recoFromReco.toModify(muons1stStep, fillShowerDigis=False)
phase2_muon.toModify(mixData, workers = dict( gem = cms.PSet( workerType = cms.string("PreMixingGEMWorker"), digiTagSig = cms.InputTag("simMuonGEMDigis"), pileInputTag = cms.InputTag("simMuonGEMDigis",""), collectionDM = cms.string(''), ), me0 = cms.PSet( workerType = cms.string("PreMixingME0Worker"), digiTagSig = cms.InputTag("simMuonME0Digis"), pileInputTag = cms.InputTag("simMuonME0Digis",""), collectionDM = cms.string(''), ), me0SimHit = cms.PSet( workerType = cms.string("PreMixingCrossingFramePSimHitWorker"), labelSig = cms.InputTag("mix", "g4SimHitsMuonME0Hits"), pileInputTag = cms.InputTag("mix", "g4SimHitsMuonME0Hits"), collectionDM = cms.string("g4SimHitsMuonME0Hits"), ), gemSimLink = cms.PSet( workerType = cms.string("PreMixingGEMDigiSimLinkWorker"), labelSig = cms.InputTag("simMuonGEMDigis"), pileInputTag = cms.InputTag("simMuonGEMDigis"), collectionDM = cms.string('GEMDigiSimLink'), ), gemStripSimLink = cms.PSet( workerType = cms.string("PreMixingStripDigiSimLinkWorker"), labelSig = cms.InputTag("simMuonGEMDigis"), pileInputTag = cms.InputTag("simMuonGEMDigis"), collectionDM = cms.string('GEMStripDigiSimLink'), ), me0SimLink = cms.PSet( workerType = cms.string("PreMixingME0DigiSimLinkWorker"), labelSig = cms.InputTag("simMuonMe0Digis"), pileInputTag = cms.InputTag("simMuonME0Digis"), collectionDM = cms.string('ME0DigiSimLink'), ), me0StripSimLink = cms.PSet( workerType = cms.string("PreMixingStripDigiSimLinkWorker"), labelSig = cms.InputTag("simMuonME0Digis"), pileInputTag = cms.InputTag("simMuonME0Digis"), collectionDM = cms.string('ME0StripDigiSimLink'), ), ) )
GEMPadDigiClusterProducer=cms.InputTag("simMuonGEMPadDigiClusters"), commonParam=dict(isSLHC=True, runME11Up=cms.bool(True), runME11ILT=cms.bool(True), useClusters=cms.bool(False), enableAlctSLHC=cms.bool(True)), clctSLHC=dict(clctNplanesHitPattern=3), me11tmbSLHCGEM=me11tmbSLHCGEM, copadParamGE11=copadParamGE11) ## GEM-CSC ILT in ME2/1, CSC in ME3/1 and ME4/1 from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon phase2_muon.toModify(cscTriggerPrimitiveDigis, commonParam=dict(runME21Up=cms.bool(True), runME21ILT=cms.bool(True), runME31Up=cms.bool(True), runME41Up=cms.bool(True)), tmbSLHC=dict(ignoreAlctCrossClct=cms.bool(False)), alctSLHCME21=cscTriggerPrimitiveDigis.alctSLHC.clone( alctNplanesHitPattern=3), clctSLHCME21=cscTriggerPrimitiveDigis.clctSLHC.clone( clctNplanesHitPattern=3), me21tmbSLHCGEM=me21tmbSLHCGEM, alctSLHCME3141=cscTriggerPrimitiveDigis.alctParam07.clone( alctNplanesHitPattern=4), clctSLHCME3141=cscTriggerPrimitiveDigis.clctSLHC.clone( clctNplanesHitPattern=4), meX1tmbSLHC=meX1tmbSLHC, copadParamGE11=copadParamGE11, copadParamGE21=copadParamGE21)
debugParameters=True, checkBadChambers=False, commonParam=dict(gangedME1a=False), mpcParam=auxPSets.mpcParamRun2.clone()) ## turn on upgrade CSC algorithm without GEMs ## originally intended for Phase-2, but moved up to Run-3 from Configuration.Eras.Modifier_run3_common_cff import run3_common run3_common.toModify(cscTriggerPrimitiveDigis, keepShowers=True, commonParam=dict(run3=True, runCCLUT_OTMB=True, runPhase2=True, runME11Up=True, runME21Up=True, runME31Up=True, runME41Up=True)) ## GEM-CSC integrated local trigger in ME1/1 from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM run3_GEM.toModify( cscTriggerPrimitiveDigis, GEMPadDigiClusterProducer=cms.InputTag("simMuonGEMPadDigiClusters"), commonParam=dict(runME11ILT=True)) ## GEM-CSC integrated local trigger in ME2/1 ## enable the Phase-2 ALCT processors from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon phase2_muon.toModify(cscTriggerPrimitiveDigis, commonParam=dict(runME21ILT=True, enableAlctPhase2=True))
), select = cms.PSet( lipTP = cms.double(1000), chargedOnlyTP = cms.bool(True), pdgIdTP = cms.vint32(), signalOnlyTP = cms.bool(True), intimeOnlyTP = cms.bool(False), minRapidityTP = cms.double(-2.6), minHitTP = cms.int32(3), ptMinTP = cms.double(0.2), ptMaxTP = cms.double(1e100), maxRapidityTP = cms.double(2.6), tipTP = cms.double(1000) ) ) trackingParticleSelection = cms.Sequence(mergedtruth) from Configuration.Eras.Modifier_run2_GEM_2017_cff import run2_GEM_2017 run2_GEM_2017.toModify(trackingParticleSelection, simHitCollections = dict( muon = trackingParticleSelection.simHitCollections.muon+["g4SimHitsMuonGEMHits"])) from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM run3_GEM.toModify(trackingParticleSelection, simHitCollections = dict( muon = trackingParticleSelection.simHitCollections.muon+["g4SimHitsMuonGEMHits"])) from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon phase2_muon.toModify( trackingParticleSelection, simHitCollections = dict( muon = trackingParticleSelection.simHitCollections.muon+["g4SimHitsMuonME0Hits"]))
from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM run3_GEM.toModify( SimMuonFEVTDEBUG, outputCommands=SimMuonFEVTDEBUG.outputCommands + [ 'keep *_simMuonGEMDigis_*_*', 'keep *_simMuonGEMPadDigis_*_*', 'keep *_simMuonGEMPadDigiClusters_*_*' ]) run3_GEM.toModify(SimMuonRAW, outputCommands=SimMuonRAW.outputCommands + ['keep StripDigiSimLinkedmDetSetVector_simMuonGEMDigis_*_*']) run3_GEM.toModify(SimMuonRECO, outputCommands=SimMuonRECO.outputCommands + ['keep StripDigiSimLinkedmDetSetVector_simMuonGEMDigis_*_*']) from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon phase2_muon.toModify( SimMuonFEVTDEBUG, outputCommands=SimMuonFEVTDEBUG.outputCommands + [ 'keep *_simMuonME0PseudoDigis_*_*', 'keep *_simMuonME0PseudoReDigis_*_*', 'keep *_simMuonME0Digis_*_*', 'keep *_simMuonME0PadDigis_*_*', 'keep *_simMuonME0PadDigiClusters_*_*' ]) phase2_muon.toModify( SimMuonRAW, outputCommands=SimMuonRAW.outputCommands + ['keep StripDigiSimLinkedmDetSetVector_simMuonME0Digis_*_*']) phase2_muon.toModify( SimMuonRECO, outputCommands=SimMuonRECO.outputCommands + ['keep StripDigiSimLinkedmDetSetVector_simMuonME0Digis_*_*'])
) ## GEM-CSC ILT in ME1/1 from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM run3_GEM.toModify( cscTriggerPrimitiveDigis, GEMPadDigiProducer = cms.InputTag("simMuonGEMPadDigis"), GEMPadDigiClusterProducer = cms.InputTag("simMuonGEMPadDigiClusters"), commonParam = dict(isSLHC = cms.bool(True), smartME1aME1b = cms.bool(True), runME11ILT = cms.bool(True), useClusters = cms.bool(False)), clctSLHC = dict(clctNplanesHitPattern = 3), me11tmbSLHCGEM = me11tmbSLHCGEM, copadParamGE11 = copadParamGE11 ) ## GEM-CSC ILT in ME2/1, CSC in ME3/1 and ME4/1 from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon phase2_muon.toModify( cscTriggerPrimitiveDigis, commonParam = dict(runME21ILT = cms.bool(True), runME3141ILT = cms.bool(True)), alctSLHCME21 = cscTriggerPrimitiveDigis.alctSLHC.clone(alctNplanesHitPattern = 3), clctSLHCME21 = cscTriggerPrimitiveDigis.clctSLHC.clone(clctNplanesHitPattern = 3), me21tmbSLHCGEM = me21tmbSLHCGEM, alctSLHCME3141 = cscTriggerPrimitiveDigis.alctSLHC.clone(alctNplanesHitPattern = 4), clctSLHCME3141 = cscTriggerPrimitiveDigis.clctSLHC.clone(clctNplanesHitPattern = 4), me3141tmbSLHC = me3141tmbSLHC, copadParamGE11 = copadParamGE11, copadParamGE21 = copadParamGE21 )
from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM run3_GEM.toModify(RandomNumberGeneratorService, simMuonGEMDigis=cms.PSet( initialSeed=cms.untracked.uint32(1234567), engineName=FullSimEngine)) from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon phase2_muon.toModify( RandomNumberGeneratorService, simMuonME0Digis=cms.PSet(initialSeed=cms.untracked.uint32(1234567), engineName=FullSimEngine), simMuonME0PseudoDigis=cms.PSet(initialSeed=cms.untracked.uint32(1234567), engineName=FullSimEngine), simMuonME0PseudoReDigis=cms.PSet(initialSeed=cms.untracked.uint32(7654321), engineName=FullSimEngine), simMuonME0PseudoReDigisCoarse=cms.PSet( initialSeed=cms.untracked.uint32(2234567), engineName=FullSimEngine), ) from Configuration.Eras.Modifier_phase2_timing_cff import phase2_timing phase2_timing.toModify(RandomNumberGeneratorService, trackTimeValueMapProducer=cms.PSet( initialSeed=cms.untracked.uint32(1234567), engineName=FullSimEngine), gsfTrackTimeValueMapProducer=cms.PSet( initialSeed=cms.untracked.uint32(1234567), engineName=FullSimEngine),
run3_GEM.toModify( RandomNumberGeneratorService, simMuonGEMDigis = cms.PSet( initialSeed = cms.untracked.uint32(1234567), engineName = cms.untracked.string('HepJamesRandom')) ) from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon phase2_muon.toModify( RandomNumberGeneratorService, simMuonME0Digis = cms.PSet( initialSeed = cms.untracked.uint32(1234567), engineName = cms.untracked.string('HepJamesRandom')), simMuonME0PseudoDigis = cms.PSet( initialSeed = cms.untracked.uint32(1234567), engineName = cms.untracked.string('HepJamesRandom')), simMuonME0PseudoReDigis = cms.PSet( initialSeed = cms.untracked.uint32(7654321), engineName = cms.untracked.string('HepJamesRandom')), simMuonME0PseudoReDigisCoarse = cms.PSet( initialSeed = cms.untracked.uint32(2234567), engineName = cms.untracked.string('HepJamesRandom')), ) from Configuration.Eras.Modifier_phase2_timing_cff import phase2_timing phase2_timing.toModify( RandomNumberGeneratorService, trackTimeValueMapProducer = cms.PSet( initialSeed = cms.untracked.uint32(1234567), engineName = cms.untracked.string('HepJamesRandom') ),
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 = cms.bool(True) process.patMuons.computeMuonMVA = cms.bool(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( # configure many IDs as InputTag <someName> = <someTag> you # can comment out those you don't want to save some disk space eidRobustLoose=cms.InputTag("reducedEgamma", "eidRobustLoose"), eidRobustTight=cms.InputTag("reducedEgamma", "eidRobustTight"), eidLoose=cms.InputTag("reducedEgamma", "eidLoose"), eidTight=cms.InputTag("reducedEgamma", "eidTight"), eidRobustHighEnergy=cms.InputTag("reducedEgamma", "eidRobustHighEnergy"), ) process.patElectrons.addPFClusterIso = cms.bool(True) #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.patElectrons.ecalPFClusterIsoMap = cms.InputTag( "reducedEgamma", "eleEcalPFClusIso") process.patElectrons.hcalPFClusterIsoMap = cms.InputTag( "reducedEgamma", "eleHcalPFClusIso") 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 process.patPhotons.addPFClusterIso = cms.bool(True) #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-") process.patPhotons.ecalPFClusterIsoMap = cms.InputTag( "reducedEgamma", "phoEcalPFClusIso") process.patPhotons.hcalPFClusterIsoMap = cms.InputTag( "reducedEgamma", "phoHcalPFClusIso") process.patPhotons.photonSource = cms.InputTag("reducedEgamma", "reducedGedPhotons") process.patPhotons.electronSource = cms.InputTag("reducedEgamma", "reducedGedGsfElectrons") process.patPhotons.photonIDSources = cms.PSet( PhotonCutBasedIDLoose=cms.InputTag('reducedEgamma', 'PhotonCutBasedIDLoose'), PhotonCutBasedIDTight=cms.InputTag('reducedEgamma', 'PhotonCutBasedIDTight')) 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 electron_ids = [ 'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_PHYS14_PU20bx25_V2_cff', 'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Spring15_25ns_V1_cff', 'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Spring15_50ns_V2_cff', 'RecoEgamma.ElectronIdentification.Identification.heepElectronID_HEEPV60_cff', 'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring15_25ns_nonTrig_V1_cff', 'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring15_25ns_Trig_V1_cff', 'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring15_50ns_Trig_V1_cff', 'RecoEgamma.ElectronIdentification.Identification.heepElectronID_HEEPV70_cff', 'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Fall17_94X_V1_cff', 'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Fall17_noIso_V1_cff', 'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Fall17_iso_V1_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') process.electronRegressionValueMapProducer.src = \ cms.InputTag('reducedEgamma','reducedGedGsfElectrons') for idmod in electron_ids: setupAllVIDIdsInModule(process, idmod, setupVIDElectronSelection, None, False, task) #heepIDVarValueMaps only exists if HEEP V6.1 or HEEP 7.0 ID has already been loaded if hasattr(process, 'heepIDVarValueMaps'): process.heepIDVarValueMaps.elesMiniAOD = cms.InputTag( 'reducedEgamma', 'reducedGedGsfElectrons') #force HEEP to use miniAOD (otherwise it'll detect the AOD) process.heepIDVarValueMaps.dataFormat = cms.int32(2) #add the HEEP trk isol to the slimmed electron, add it to the first FromFloatValMap modifier for pset in process.slimmedElectrons.modifierConfig.modifications: if pset.hasParameter( "modifierName") and pset.modifierName == cms.string( 'EGExtraInfoModifierFromFloatValueMaps'): pset.electron_config.heepTrkPtIso = cms.InputTag( "heepIDVarValueMaps", "eleTrkPtIso") break #VID Photon IDs photon_ids = [ 'RecoEgamma.PhotonIdentification.Identification.cutBasedPhotonID_Spring15_25ns_V1_cff', 'RecoEgamma.PhotonIdentification.Identification.cutBasedPhotonID_Spring15_50ns_V1_cff', 'RecoEgamma.PhotonIdentification.Identification.mvaPhotonID_Spring15_25ns_nonTrig_V2p1_cff', 'RecoEgamma.PhotonIdentification.Identification.mvaPhotonID_Spring15_50ns_nonTrig_V2p1_cff', 'RecoEgamma.PhotonIdentification.Identification.cutBasedPhotonID_Fall17_94X_V1_TrueVtx_cff', 'RecoEgamma.PhotonIdentification.Identification.mvaPhotonID_Fall17_94X_V1_cff', 'RecoEgamma.PhotonIdentification.Identification.mvaPhotonID_Fall17_94X_V1p1_cff', 'RecoEgamma.PhotonIdentification.Identification.cutBasedPhotonID_Spring16_V2p2_cff', 'RecoEgamma.PhotonIdentification.Identification.mvaPhotonID_Spring16_nonTrig_V1_cff' ] switchOnVIDPhotonIdProducer(process, DataFormat.AOD, task) process.egmPhotonIsolation.srcToIsolate = \ cms.InputTag("reducedEgamma","reducedGedPhotons") for iPSet in process.egmPhotonIsolation.isolationConeDefinitions: iPSet.particleBasedIsolation = cms.InputTag("reducedEgamma", "reducedPhotonPfCandMap") process.egmPhotonIDs.physicsObjectSrc = \ cms.InputTag("reducedEgamma","reducedGedPhotons") process.photonIDValueMapProducer.src = \ cms.InputTag("reducedEgamma","reducedGedPhotons") process.photonRegressionValueMapProducer.src = \ cms.InputTag("reducedEgamma","reducedGedPhotons") process.photonIDValueMapProducer.particleBasedIsolation = \ cms.InputTag("reducedEgamma","reducedPhotonPfCandMap") 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) run2_miniAOD_94XFall17.toReplaceWith( process.makePatTausTask, _makePatTausTaskWithRetrainedMVATauID) #-- Adding custimization for 80X 2016 legacy reMiniAOD from Configuration.Eras.Modifier_run2_miniAOD_80XLegacy_cff import run2_miniAOD_80XLegacy _makePatTausTaskWithTauReReco = process.makePatTausTask.copy() _makePatTausTaskWithTauReReco.add(process.PFTauTask) run2_miniAOD_80XLegacy.toReplaceWith(process.makePatTausTask, _makePatTausTaskWithTauReReco) #-- Adding LowPt taus from RecoTauTag.Configuration.LowPtHPSPFTaus_cfi import addLowPtTaus addLowPtTaus(process) process.load("RecoTauTag.Configuration.RecoPFTauTag_cff") process.load("RecoTauTag.Configuration.HPSPFTaus_cff") # 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( 'puppi' ), # using Puppi candidates as input for b tagging of Puppi jets algo='AK', rParam=0.4, btagDiscriminators=noDeepFlavourDiscriminators) process.patJetGenJetMatchPuppi.matched = 'slimmedGenJets' process.patJetsPuppi.jetChargeSource = cms.InputTag("patJetPuppiCharge") process.selectedPatJetsPuppi.cut = cms.string("pt > 15") process.load('PhysicsTools.PatAlgos.slimming.slimmedJets_cfi') # update slimmed jets to include DeepFlavour (keep same name) from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection # make clone for DeepFlavour-less slimmed jets, so output name is preserved process.slimmedJetsNoDeepFlavour = process.slimmedJets.clone() task.add(process.slimmedJetsNoDeepFlavour) updateJetCollection( process, jetSource=cms.InputTag('slimmedJetsNoDeepFlavour'), # updateJetCollection defaults to MiniAOD inputs but # here it is made explicit (as in training or MINIAOD redoing) pvSource=cms.InputTag('offlineSlimmedPrimaryVertices'), pfCandidates=cms.InputTag('packedPFCandidates'), svSource=cms.InputTag('slimmedSecondaryVertices'), muSource=cms.InputTag('slimmedMuons'), elSource=cms.InputTag('slimmedElectrons'), jetCorrections=('AK4PFchs', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute']), 'None'), btagDiscriminators=[ 'pfDeepFlavourJetTags:probb', 'pfDeepFlavourJetTags:probbb', 'pfDeepFlavourJetTags:problepb', 'pfDeepFlavourJetTags:probc', 'pfDeepFlavourJetTags:probuds', 'pfDeepFlavourJetTags:probg', ], postfix='SlimmedDeepFlavour', printWarning=False) # slimmedJets with DeepFlavour (remove DeepFlavour-less) delattr(process, 'slimmedJets') process.slimmedJets = process.selectedUpdatedPatJetsSlimmedDeepFlavour.clone( ) # delete module not used anymore (slimmedJets substitutes) delattr(process, 'selectedUpdatedPatJetsSlimmedDeepFlavour') task.add(process.slimmedJets) task.add(process.slimmedJetsAK8) 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 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) ## 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")
import FWCore.ParameterSet.Config as cms from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon # the analyzer configuration from GEMCode.GEMValidation.simTrackMatching_cfi import simTrackPSet MuonNtuplizer = cms.EDAnalyzer( "MuonNtuplizer", simTrackPSet, runSim=cms.bool(True), runDigi=cms.bool(True), runStub=cms.bool(True), runL1=cms.bool(True), runReco=cms.bool(False), verbose=cms.int32(0), minNHitsChamberGEMSimHit=cms.int32(1), minNHitsChamberCSCSimHit=cms.int32(3), minNHitsChamberCSCDigi=cms.int32(4), minNHitsChamberGEMDigi=cms.int32(1), minNHitsChamberCSCStub=cms.int32(3), ) MuonNtuplizer.simTrack.minEta = 0.9 MuonNtuplizer.simTrack.maxEta = 2.4 MuonNtuplizer.simTrack.minPt = 3 MuonNtuplizer.gemStripDigi.matchDeltaStrip = 2 MuonNtuplizer.cscLCT.addGhostLCTs = cms.bool(True) phase2_muon.toModify(MuonNtuplizer, l1Track=dict(run=cms.bool(False))) phase2_muon.toModify(MuonNtuplizer, l1TkMuon=dict(run=cms.bool(False)))
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 = cms.bool(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.electronIDSources = cms.PSet( # configure many IDs as InputTag <someName> = <someTag> you # can comment out those you don't want to save some disk space eidRobustLoose=cms.InputTag("reducedEgamma", "eidRobustLoose"), eidRobustTight=cms.InputTag("reducedEgamma", "eidRobustTight"), eidLoose=cms.InputTag("reducedEgamma", "eidLoose"), eidTight=cms.InputTag("reducedEgamma", "eidTight"), eidRobustHighEnergy=cms.InputTag("reducedEgamma", "eidRobustHighEnergy"), ) process.patElectrons.addPFClusterIso = cms.bool(True) #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.patElectrons.ecalPFClusterIsoMap = cms.InputTag( "reducedEgamma", "eleEcalPFClusIso") process.patElectrons.hcalPFClusterIsoMap = cms.InputTag( "reducedEgamma", "eleHcalPFClusIso") 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 process.patPhotons.addPFClusterIso = cms.bool(True) #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-") process.patPhotons.ecalPFClusterIsoMap = cms.InputTag( "reducedEgamma", "phoEcalPFClusIso") process.patPhotons.hcalPFClusterIsoMap = cms.InputTag( "reducedEgamma", "phoHcalPFClusIso") process.patPhotons.photonSource = cms.InputTag("reducedEgamma", "reducedGedPhotons") process.patPhotons.electronSource = cms.InputTag("reducedEgamma", "reducedGedGsfElectrons") process.patPhotons.photonIDSources = cms.PSet( PhotonCutBasedIDLoose=cms.InputTag('reducedEgamma', 'PhotonCutBasedIDLoose'), PhotonCutBasedIDTight=cms.InputTag('reducedEgamma', 'PhotonCutBasedIDTight')) 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 ## 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'), ] ## 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 electron_ids = [ 'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_PHYS14_PU20bx25_V2_cff', 'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Spring15_25ns_V1_cff', 'RecoEgamma.ElectronIdentification.Identification.cutBasedElectronID_Spring15_50ns_V2_cff', 'RecoEgamma.ElectronIdentification.Identification.heepElectronID_HEEPV60_cff', 'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring15_25ns_nonTrig_V1_cff', 'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring15_25ns_Trig_V1_cff', 'RecoEgamma.ElectronIdentification.Identification.mvaElectronID_Spring15_50ns_Trig_V1_cff' ] switchOnVIDElectronIdProducer(process, DataFormat.MiniAOD, task) process.egmGsfElectronIDs.physicsObjectSrc = \ cms.InputTag("reducedEgamma","reducedGedGsfElectrons") process.electronMVAValueMapProducer.src = \ cms.InputTag('reducedEgamma','reducedGedGsfElectrons') process.electronRegressionValueMapProducer.src = \ cms.InputTag('reducedEgamma','reducedGedGsfElectrons') for idmod in electron_ids: setupAllVIDIdsInModule(process, idmod, setupVIDElectronSelection, None, False, task) #heepIDVarValueMaps only exists if HEEP V6.1 or HEEP 7.0 ID has already been loaded if hasattr(process, 'heepIDVarValueMaps'): process.heepIDVarValueMaps.elesMiniAOD = cms.InputTag( 'reducedEgamma', 'reducedGedGsfElectrons') #force HEEP to use miniAOD (otherwise it'll detect the AOD) process.heepIDVarValueMaps.dataFormat = cms.int32(2) #VID Photon IDs photon_ids = [ 'RecoEgamma.PhotonIdentification.Identification.cutBasedPhotonID_Spring15_25ns_V1_cff', 'RecoEgamma.PhotonIdentification.Identification.cutBasedPhotonID_Spring15_50ns_V1_cff', 'RecoEgamma.PhotonIdentification.Identification.mvaPhotonID_Spring15_25ns_nonTrig_V2p1_cff', 'RecoEgamma.PhotonIdentification.Identification.mvaPhotonID_Spring15_50ns_nonTrig_V2p1_cff', 'RecoEgamma.PhotonIdentification.Identification.cutBasedPhotonID_Spring16_V2p2_cff', 'RecoEgamma.PhotonIdentification.Identification.mvaPhotonID_Spring16_nonTrig_V1_cff' ] switchOnVIDPhotonIdProducer(process, DataFormat.AOD, task) process.egmPhotonIsolation.srcToIsolate = \ cms.InputTag("reducedEgamma","reducedGedPhotons") for iPSet in process.egmPhotonIsolation.isolationConeDefinitions: iPSet.particleBasedIsolation = cms.InputTag("reducedEgamma", "reducedPhotonPfCandMap") process.egmPhotonIDs.physicsObjectSrc = \ cms.InputTag("reducedEgamma","reducedGedPhotons") process.photonIDValueMapProducer.src = \ cms.InputTag("reducedEgamma","reducedGedPhotons") process.photonRegressionValueMapProducer.src = \ cms.InputTag("reducedEgamma","reducedGedPhotons") process.photonIDValueMapProducer.particleBasedIsolation = \ cms.InputTag("reducedEgamma","reducedPhotonPfCandMap") process.photonMVAValueMapProducer.src = \ cms.InputTag('reducedEgamma','reducedGedPhotons') for idmod in photon_ids: setupAllVIDIdsInModule(process, idmod, setupVIDPhotonSelection, None, False, task) #--------------------------------------------------------------------------- #Adding Boosted Subjets taus from RecoTauTag.Configuration.boostedHPSPFTaus_cfi import addBoostedTaus addBoostedTaus(process) #--------------------------------------------------------------------------- # 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) addJetCollection( process, postfix="", labelName='Puppi', jetSource=cms.InputTag('ak4PFJetsPuppi'), jetCorrections=('AK4PFPuppi', ['L2Relative', 'L3Absolute'], ''), pfCandidates=cms.InputTag( 'puppi' ), # using Puppi candidates as input for b tagging of Puppi jets algo='AK', rParam=0.4, btagDiscriminators=map(lambda x: x.value(), process.patJets.discriminatorSources)) process.patJetGenJetMatchPuppi.matched = 'slimmedGenJets' process.patJetsPuppi.jetChargeSource = cms.InputTag("patJetPuppiCharge") process.selectedPatJetsPuppi.cut = cms.string("pt > 15") process.load('PhysicsTools.PatAlgos.slimming.slimmedJets_cfi') task.add(process.slimmedJets) task.add(process.slimmedJetsAK8) addToProcessAndTask('slimmedJetsPuppi', process.slimmedJets.clone(), process, task) process.slimmedJetsPuppi.src = cms.InputTag("selectedPatJetsPuppi") process.slimmedJetsPuppi.packedPFCandidates = cms.InputTag( "packedPFCandidates") ## 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")
'keep *_ancientMuonSeed_*_*', 'keep *_displacedMuonSeeds_*_*', 'keep TrackingRecHitsOwned_globalMuons_*_*', 'keep TrackingRecHitsOwned_tevMuons_*_*', # Cosmics 'keep *_CosmicMuonSeed_*_*', 'keep recoTrackExtras_cosmicMuons_*_*', 'keep TrackingRecHitsOwned_cosmicMuons_*_*', 'keep recoTrackExtras_cosmicMuons1Leg_*_*', 'keep TrackingRecHitsOwned_cosmicMuons1Leg_*_*', 'keep recoTracks_cosmicsVetoTracks_*_*') ) # Full Event content RecoMuonFEVT = cms.PSet( outputCommands = cms.untracked.vstring() ) RecoMuonRECO.outputCommands.extend(RecoMuonAOD.outputCommands) RecoMuonFEVT.outputCommands.extend(RecoMuonRECO.outputCommands) RecoMuonFEVT.outputCommands.extend(RecoMuonIsolationFEVT.outputCommands) RecoMuonRECO.outputCommands.extend(RecoMuonIsolationRECO.outputCommands) RecoMuonAOD.outputCommands.extend(RecoMuonIsolationAOD.outputCommands) def _modifyRecoMuonEventContentForPhase2( object ): object.outputCommands.append('keep *_me0SegmentMatching_*_*') object.outputCommands.append('keep *_me0MuonConverting_*_*') from Configuration.Eras.Modifier_phase2_muon_cff import phase2_muon phase2_muon.toModify( RecoMuonFEVT, func=_modifyRecoMuonEventContentForPhase2 ) phase2_muon.toModify( RecoMuonRECO, func=_modifyRecoMuonEventContentForPhase2 ) phase2_muon.toModify( RecoMuonAOD, func=_modifyRecoMuonEventContentForPhase2 )