From e90cc2ea1b3bdbe5eceb8a8c19cd14b36db6853d Mon Sep 17 00:00:00 2001 From: CeliaFernandez Date: Mon, 31 Jan 2022 12:53:50 +0100 Subject: [PATCH 1/5] Add sequences to process displacedTracks, displacedGlobalMuons and displacedStandAloneMuons to create a recoMuon collection with MuonReducedTrackExtras --- .../python/RecoMuonPPonly_cff.py | 17 +- .../python/RecoMuon_EventContent_cff.py | 12 +- RecoMuon/Configuration/python/RecoMuon_cff.py | 4 +- .../displacedMuonReducedTrackExtras_cfi.py | 15 + .../python/displacedMuons_cfi.py | 103 +++ .../displacedMuonPFIsolationDeposits_cff.py | 20 + .../displacedMuonPFIsolationValues_cff.py | 618 ++++++++++++++++++ .../python/muonPFIsolation_cff.py | 9 + .../python/isoDepositProducerIOBlocks_cff.py | 14 + .../python/muIsoDepositCopies_cfi.py | 14 + .../python/muIsoDeposits_cff.py | 3 + .../python/muIsolation_cff.py | 4 + 12 files changed, 829 insertions(+), 4 deletions(-) create mode 100644 RecoMuon/MuonIdentification/python/displacedMuonReducedTrackExtras_cfi.py create mode 100644 RecoMuon/MuonIdentification/python/displacedMuons_cfi.py create mode 100644 RecoMuon/MuonIsolation/python/displacedMuonPFIsolationDeposits_cff.py create mode 100644 RecoMuon/MuonIsolation/python/displacedMuonPFIsolationValues_cff.py diff --git a/RecoMuon/Configuration/python/RecoMuonPPonly_cff.py b/RecoMuon/Configuration/python/RecoMuonPPonly_cff.py index 7d05060ffbc85..f1add3b267d05 100644 --- a/RecoMuon/Configuration/python/RecoMuonPPonly_cff.py +++ b/RecoMuon/Configuration/python/RecoMuonPPonly_cff.py @@ -40,6 +40,16 @@ from RecoMuon.MuonIdentification.muonIdProducerSequence_cff import * muons1stStep.fillGlobalTrackQuality = True +displacedMuons1stStep = muons1stStep.clone( + inputCollectionLabels = ['displacedTracks', + 'displacedGlobalMuons', + 'displacedStandAloneMuons'], + inputCollectionTypes = ['inner tracks', + 'links', + 'outer tracks'], + fillGlobalTrackQuality = False +) + #Muon Id isGood flag ValueMap producer sequence from RecoMuon.MuonIdentification.muonSelectionTypeValueMapProducer_cff import * @@ -70,7 +80,8 @@ muontrackingTask = cms.Task(standalonemuontrackingTask,globalmuontrackingTask) muontracking = cms.Sequence(muontrackingTask) # Muon Reconstruction -muonrecoTask = cms.Task(muontrackingTask,muonIdProducerTask) +displacedMuonIdProducerTask = cms.Task(displacedMuons1stStep) +muonrecoTask = cms.Task(muontrackingTask,muonIdProducerTask, displacedMuonIdProducerTask) muonreco = cms.Sequence(muonrecoTask) # Muon Reconstruction plus Isolation muonreco_plus_isolationTask = cms.Task(muonrecoTask,muIsolationTask) @@ -90,8 +101,10 @@ muonGlobalRecoTask = cms.Task(globalmuontrackingTask, muonIdProducerTask, + displacedMuonIdProducerTask, muonSelectionTypeTask, - muIsolationTask) + muIsolationTask, + muIsolationDisplacedTask) muonGlobalReco = cms.Sequence(muonGlobalRecoTask) # ... instead, the sequences will be run in the following order: diff --git a/RecoMuon/Configuration/python/RecoMuon_EventContent_cff.py b/RecoMuon/Configuration/python/RecoMuon_EventContent_cff.py index 9463e22dfcec5..b16103a5971e3 100644 --- a/RecoMuon/Configuration/python/RecoMuon_EventContent_cff.py +++ b/RecoMuon/Configuration/python/RecoMuon_EventContent_cff.py @@ -36,6 +36,15 @@ #'drop *_muons_muons1stStep2muonsMap_*', #'drop recoIsoDepositedmValueMap_muons_*_*', #not really used #'drop doubleedmValueMap_muons_muPFIso*_*', #already inside the muon + # displacedMuons collection + 'keep recoMuons_displacedMuons_*_*', + 'keep booledmValueMap_displacedMuons_*_*', + 'keep doubleedmValueMap_displacedMuons_dispMuPFMean*_*', + 'keep doubleedmValueMap_displacedMuons_dispMuPFSum*_*', + 'keep recoMuonTimeExtraedmValueMap_displacedMuons_*_*', + 'keep uintedmValueMap_displacedMuons_*_*', + 'keep *_particleFlow_displacedMuons_*', + 'keep recoIsoDepositedmValueMap_*Displaced_*_*', # Tracks known by the Muon obj 'keep recoTracks_standAloneMuons_*_*', 'keep recoTrackExtras_standAloneMuons_*_*', @@ -64,7 +73,8 @@ 'keep recoTracks_displacedStandAloneMuons__*', 'keep recoTrackExtras_displacedStandAloneMuons_*_*', 'keep TrackingRecHitsOwned_displacedStandAloneMuons_*_*', - 'keep *_muonReducedTrackExtras_*_*') + 'keep *_muonReducedTrackExtras_*_*', + 'keep *_displacedMuonReducedTrackExtras_*_*') ) RecoMuonAOD.outputCommands.extend(RecoMuonIsolationAOD.outputCommands) diff --git a/RecoMuon/Configuration/python/RecoMuon_cff.py b/RecoMuon/Configuration/python/RecoMuon_cff.py index a2d0f63e6863a..a141290af78b7 100644 --- a/RecoMuon/Configuration/python/RecoMuon_cff.py +++ b/RecoMuon/Configuration/python/RecoMuon_cff.py @@ -71,8 +71,10 @@ #### High level sequence (i.e., post PF reconstruction) ### from RecoMuon.MuonIdentification.muons_cfi import * +from RecoMuon.MuonIdentification.displacedMuons_cfi import * from RecoMuon.MuonIsolation.muonPFIsolation_cff import * from RecoMuon.MuonIdentification.muonReducedTrackExtras_cfi import * +from RecoMuon.MuonIdentification.displacedMuonReducedTrackExtras_cfi import * # clusters are not present in fastsim from Configuration.Eras.Modifier_fastSim_cff import fastSim @@ -82,5 +84,5 @@ from Configuration.Eras.Modifier_phase2_tracker_cff import phase2_tracker phase2_tracker.toModify(muonReducedTrackExtras, outputClusters = False) -muonshighlevelrecoTask = cms.Task(muonPFIsolationTask,muons,muonReducedTrackExtras) +muonshighlevelrecoTask = cms.Task(muonPFIsolationTask,displacedMuonPFIsolationTask,muons,displacedMuons,muonReducedTrackExtras, displacedMuonReducedTrackExtras) muonshighlevelreco = cms.Sequence(muonshighlevelrecoTask) diff --git a/RecoMuon/MuonIdentification/python/displacedMuonReducedTrackExtras_cfi.py b/RecoMuon/MuonIdentification/python/displacedMuonReducedTrackExtras_cfi.py new file mode 100644 index 0000000000000..ed60cab92dd15 --- /dev/null +++ b/RecoMuon/MuonIdentification/python/displacedMuonReducedTrackExtras_cfi.py @@ -0,0 +1,15 @@ +import FWCore.ParameterSet.Config as cms + +displacedMuonReducedTrackExtras = cms.EDProducer('MuonReducedTrackExtraProducer', + muonTag = cms.InputTag('displacedMuons'), + trackExtraTags = cms.VInputTag( + 'displacedTracks', + 'displacedGlobalMuons' + ), + trackExtraAssocs = cms.VInputTag(), + pixelClusterTag = cms.InputTag('siPixelClusters'), + stripClusterTag = cms.InputTag('siStripClusters'), + cut = cms.string('pt > 3.0'), + outputClusters = cms.bool(True), + mightGet = cms.optional.untracked.vstring +) diff --git a/RecoMuon/MuonIdentification/python/displacedMuons_cfi.py b/RecoMuon/MuonIdentification/python/displacedMuons_cfi.py new file mode 100644 index 0000000000000..653f820ae7d2d --- /dev/null +++ b/RecoMuon/MuonIdentification/python/displacedMuons_cfi.py @@ -0,0 +1,103 @@ +# This file name is temporary and ment for development only. +# The content of this file will be moved to displacedMuons_cfi as soon as the complete work flow is in place. + +import FWCore.ParameterSet.Config as cms + +displacedMuons = cms.EDProducer("MuonProducer", + ActivateDebug = cms.untracked.bool(False), + InputMuons = cms.InputTag("displacedMuons1stStep"), + + FillPFMomentumAndAssociation = cms.bool(True), + PFCandidates = cms.InputTag("particleFlowTmp"), + + FillTimingInfo = cms.bool(True), + + FillDetectorBasedIsolation = cms.bool(True), + EcalIsoDeposits = cms.InputTag("muIsoDepositCalByAssociatorTowersDisplaced","ecal"), + HcalIsoDeposits = cms.InputTag("muIsoDepositCalByAssociatorTowersDisplaced","hcal"), + HoIsoDeposits = cms.InputTag("muIsoDepositCalByAssociatorTowersDisplaced","ho"), + TrackIsoDeposits = cms.InputTag("muIsoDepositTkDisplaced"), + JetIsoDeposits = cms.InputTag("muIsoDepositJetsDisplaced"), + + FillPFIsolation = cms.bool(True), + PFIsolation = cms.PSet( + pfIsolationR03 = cms.PSet(chargedParticle = cms.InputTag("dispMuPFIsoValueChargedAll03"), + chargedHadron = cms.InputTag("dispMuPFIsoValueCharged03"), + neutralHadron = cms.InputTag("dispMuPFIsoValueNeutral03"), + neutralHadronHighThreshold = cms.InputTag("dispMuPFIsoValueNeutralHighThreshold03"), + photon = cms.InputTag("dispMuPFIsoValueGamma03"), + photonHighThreshold = cms.InputTag("dispMuPFIsoValueGammaHighThreshold03"), + pu = cms.InputTag("dispMuPFIsoValuePU03")), + pfIsolationR04 = cms.PSet(chargedParticle = cms.InputTag("dispMuPFIsoValueChargedAll04"), + chargedHadron = cms.InputTag("dispMuPFIsoValueCharged04"), + neutralHadron = cms.InputTag("dispMuPFIsoValueNeutral04"), + neutralHadronHighThreshold = cms.InputTag("dispMuPFIsoValueNeutralHighThreshold04"), + photon = cms.InputTag("dispMuPFIsoValueGamma04"), + photonHighThreshold = cms.InputTag("dispMuPFIsoValueGammaHighThreshold04"), + pu = cms.InputTag("dispMuPFIsoValuePU04")), + pfIsoMeanDRProfileR03 = cms.PSet(chargedParticle = cms.InputTag("dispMuPFMeanDRIsoValueChargedAll03"), + chargedHadron = cms.InputTag("dispMuPFMeanDRIsoValueCharged03"), + neutralHadron = cms.InputTag("dispMuPFMeanDRIsoValueNeutral03"), + neutralHadronHighThreshold = cms.InputTag("dispMuPFMeanDRIsoValueNeutralHighThreshold03"), + photon = cms.InputTag("dispMuPFMeanDRIsoValueGamma03"), + photonHighThreshold = cms.InputTag("dispMuPFMeanDRIsoValueGammaHighThreshold03"), + pu = cms.InputTag("dispMuPFMeanDRIsoValuePU03")), + pfIsoMeanDRProfileR04 = cms.PSet(chargedParticle = cms.InputTag("dispMuPFMeanDRIsoValueChargedAll04"), + chargedHadron = cms.InputTag("dispMuPFMeanDRIsoValueCharged04"), + neutralHadron = cms.InputTag("dispMuPFMeanDRIsoValueNeutral04"), + neutralHadronHighThreshold = cms.InputTag("dispMuPFMeanDRIsoValueNeutralHighThreshold04"), + photon = cms.InputTag("dispMuPFMeanDRIsoValueGamma04"), + photonHighThreshold = cms.InputTag("dispMuPFMeanDRIsoValueGammaHighThreshold04"), + pu = cms.InputTag("dispMuPFMeanDRIsoValuePU04")), + pfIsoSumDRProfileR03 = cms.PSet(chargedParticle = cms.InputTag("dispMuPFSumDRIsoValueChargedAll03"), + chargedHadron = cms.InputTag("dispMuPFSumDRIsoValueCharged03"), + neutralHadron = cms.InputTag("dispMuPFSumDRIsoValueNeutral03"), + neutralHadronHighThreshold = cms.InputTag("dispMuPFSumDRIsoValueNeutralHighThreshold03"), + photon = cms.InputTag("dispMuPFSumDRIsoValueGamma03"), + photonHighThreshold = cms.InputTag("dispMuPFSumDRIsoValueGammaHighThreshold03"), + pu = cms.InputTag("dispMuPFSumDRIsoValuePU03")), + pfIsoSumDRProfileR04 = cms.PSet(chargedParticle = cms.InputTag("dispMuPFSumDRIsoValueChargedAll04"), + chargedHadron = cms.InputTag("dispMuPFSumDRIsoValueCharged04"), + neutralHadron = cms.InputTag("dispMuPFSumDRIsoValueNeutral04"), + neutralHadronHighThreshold = cms.InputTag("dispMuPFSumDRIsoValueNeutralHighThreshold04"), + photon = cms.InputTag("dispMuPFSumDRIsoValueGamma04"), + photonHighThreshold = cms.InputTag("dispMuPFSumDRIsoValueGammaHighThreshold04"), + pu = cms.InputTag("dispMuPFSumDRIsoValuePU04")) + ), + + FillSelectorMaps = cms.bool(False), + SelectorMaps = cms.VInputTag(cms.InputTag("muidTMLastStationOptimizedLowPtLoose"), + cms.InputTag("muidTMLastStationOptimizedLowPtTight"), + cms.InputTag("muidTM2DCompatibilityLoose"), + cms.InputTag("muidTM2DCompatibilityTight"), + cms.InputTag("muidTrackerMuonArbitrated"), + cms.InputTag("muidTMLastStationAngLoose"), + cms.InputTag("muidGlobalMuonPromptTight"), + cms.InputTag("muidGMStaChiCompatibility"), + cms.InputTag("muidTMLastStationAngTight"), + cms.InputTag("muidGMTkChiCompatibility"), + cms.InputTag("muidTMOneStationAngTight"), + cms.InputTag("muidTMOneStationAngLoose"), + cms.InputTag("muidTMLastStationLoose"), + cms.InputTag("muidTMLastStationTight"), + cms.InputTag("muidTMOneStationTight"), + cms.InputTag("muidTMOneStationLoose"), + cms.InputTag("muidAllArbitrated"), + cms.InputTag("muidGMTkKinkTight"), + cms.InputTag("muidRPCMuLoose") + ), + + FillShoweringInfo = cms.bool(False), + ShowerInfoMap = cms.InputTag("muonShowerInformation"), + + FillCosmicsIdMap = cms.bool(False), + CosmicIdMap = cms.InputTag("cosmicsVeto"), + + ComputeStandardSelectors = cms.bool(True), + vertices = cms.InputTag("offlinePrimaryVertices") + + ) + +# not commisoned and not relevant in FastSim (?): +from Configuration.Eras.Modifier_fastSim_cff import fastSim +fastSim.toModify(displacedMuons, FillCosmicsIdMap = False, FillSelectorMaps = False) diff --git a/RecoMuon/MuonIsolation/python/displacedMuonPFIsolationDeposits_cff.py b/RecoMuon/MuonIsolation/python/displacedMuonPFIsolationDeposits_cff.py new file mode 100644 index 0000000000000..53f5cd53a737e --- /dev/null +++ b/RecoMuon/MuonIsolation/python/displacedMuonPFIsolationDeposits_cff.py @@ -0,0 +1,20 @@ +import FWCore.ParameterSet.Config as cms + +from CommonTools.ParticleFlow.Isolation.tools_cfi import * + + +#Now prepare the iso deposits for displacedMuons +dispMuPFIsoDepositCharged=isoDepositReplace('displacedMuons1stStep','pfAllChargedHadrons') +dispMuPFIsoDepositChargedAll=isoDepositReplace('displacedMuons1stStep','pfAllChargedParticles') +dispMuPFIsoDepositNeutral=isoDepositReplace('displacedMuons1stStep','pfAllNeutralHadrons') +dispMuPFIsoDepositGamma=isoDepositReplace('displacedMuons1stStep','pfAllPhotons') +dispMuPFIsoDepositPU=isoDepositReplace('displacedMuons1stStep','pfPileUpAllChargedParticles') + +displacedMuonPFIsolationDepositsTask = cms.Task( + dispMuPFIsoDepositCharged, + dispMuPFIsoDepositChargedAll, + dispMuPFIsoDepositGamma, + dispMuPFIsoDepositNeutral, + dispMuPFIsoDepositPU + ) +displacedMuonPFIsolationDepositsSequence = cms.Sequence(displacedMuonPFIsolationDepositsTask) diff --git a/RecoMuon/MuonIsolation/python/displacedMuonPFIsolationValues_cff.py b/RecoMuon/MuonIsolation/python/displacedMuonPFIsolationValues_cff.py new file mode 100644 index 0000000000000..8206fc284948b --- /dev/null +++ b/RecoMuon/MuonIsolation/python/displacedMuonPFIsolationValues_cff.py @@ -0,0 +1,618 @@ +import FWCore.ParameterSet.Config as cms + + + +dispMuPFIsoValueCharged03 = cms.EDProducer("CandIsolatorFromDeposits", + deposits = cms.VPSet( + cms.PSet( + src = cms.InputTag("dispMuPFIsoDepositCharged"), + deltaR = cms.double(0.3), + weight = cms.string('1'), + vetos = cms.vstring('0.0001','Threshold(0.0)'), + skipDefaultVeto = cms.bool(True), + mode = cms.string('sum') + ) + ) +) + + +dispMuPFSumDRIsoValueCharged03 = cms.EDProducer("CandIsolatorFromDeposits", + deposits = cms.VPSet( + cms.PSet( + src = cms.InputTag("dispMuPFIsoDepositCharged"), + deltaR = cms.double(0.3), + weight = cms.string('1'), + vetos = cms.vstring('0.0001','Threshold(0.0)'), + skipDefaultVeto = cms.bool(True), + mode = cms.string('sumDR') + ) + ) +) + +dispMuPFMeanDRIsoValueCharged03 = cms.EDProducer("CandIsolatorFromDeposits", + deposits = cms.VPSet( + cms.PSet( + src = cms.InputTag("dispMuPFIsoDepositCharged"), + deltaR = cms.double(0.3), + weight = cms.string('1'), + vetos = cms.vstring('0.0001','Threshold(0.0)'), + skipDefaultVeto = cms.bool(True), + mode = cms.string('meanDR') + ) + ) +) + + +dispMuPFIsoValueChargedAll03 = cms.EDProducer("CandIsolatorFromDeposits", + deposits = cms.VPSet( + cms.PSet( + src = cms.InputTag("dispMuPFIsoDepositChargedAll"), + deltaR = cms.double(0.3), + weight = cms.string('1'), + vetos = cms.vstring('0.0001','Threshold(0.0)'), + skipDefaultVeto = cms.bool(True), + mode = cms.string('sum') + ) + ) +) + +dispMuPFSumDRIsoValueChargedAll03 = cms.EDProducer("CandIsolatorFromDeposits", + deposits = cms.VPSet( + cms.PSet( + src = cms.InputTag("dispMuPFIsoDepositChargedAll"), + deltaR = cms.double(0.3), + weight = cms.string('1'), + vetos = cms.vstring('0.0001','Threshold(0.0)'), + skipDefaultVeto = cms.bool(True), + mode = cms.string('sumDR') + ) + ) +) + +dispMuPFMeanDRIsoValueChargedAll03 = cms.EDProducer("CandIsolatorFromDeposits", + deposits = cms.VPSet( + cms.PSet( + src = cms.InputTag("dispMuPFIsoDepositChargedAll"), + deltaR = cms.double(0.3), + weight = cms.string('1'), + vetos = cms.vstring('0.0001','Threshold(0.0)'), + skipDefaultVeto = cms.bool(True), + mode = cms.string('meanDR') + ) + ) +) + + +dispMuPFIsoValueGamma03 = cms.EDProducer("CandIsolatorFromDeposits", + deposits = cms.VPSet( + cms.PSet( + src = cms.InputTag("dispMuPFIsoDepositGamma"), + deltaR = cms.double(0.3), + weight = cms.string('1'), + vetos = cms.vstring('0.01','Threshold(0.5)'), + skipDefaultVeto = cms.bool(True), + mode = cms.string('sum') + ) + ) +) +dispMuPFSumDRIsoValueGamma03 = cms.EDProducer("CandIsolatorFromDeposits", + deposits = cms.VPSet( + cms.PSet( + src = cms.InputTag("dispMuPFIsoDepositGamma"), + deltaR = cms.double(0.3), + weight = cms.string('1'), + vetos = cms.vstring('0.01','Threshold(0.5)'), + skipDefaultVeto = cms.bool(True), + mode = cms.string('sumDR') + ) + ) +) + +dispMuPFMeanDRIsoValueGamma03 = cms.EDProducer("CandIsolatorFromDeposits", + deposits = cms.VPSet( + cms.PSet( + src = cms.InputTag("dispMuPFIsoDepositGamma"), + deltaR = cms.double(0.3), + weight = cms.string('1'), + vetos = cms.vstring('0.01','Threshold(0.5)'), + skipDefaultVeto = cms.bool(True), + mode = cms.string('meanDR') + ) + ) +) + + +dispMuPFIsoValueNeutral03 = cms.EDProducer("CandIsolatorFromDeposits", + deposits = cms.VPSet( + cms.PSet( + src = cms.InputTag("dispMuPFIsoDepositNeutral"), + deltaR = cms.double(0.3), + weight = cms.string('1'), + vetos = cms.vstring('0.01','Threshold(0.5)'), + skipDefaultVeto = cms.bool(True), + mode = cms.string('sum') + ) + ) +) +dispMuPFSumDRIsoValueNeutral03 = cms.EDProducer("CandIsolatorFromDeposits", + deposits = cms.VPSet( + cms.PSet( + src = cms.InputTag("dispMuPFIsoDepositNeutral"), + deltaR = cms.double(0.3), + weight = cms.string('1'), + vetos = cms.vstring('0.01','Threshold(0.5)'), + skipDefaultVeto = cms.bool(True), + mode = cms.string('sumDR') + ) + ) +) + +dispMuPFMeanDRIsoValueNeutral03 = cms.EDProducer("CandIsolatorFromDeposits", + deposits = cms.VPSet( + cms.PSet( + src = cms.InputTag("dispMuPFIsoDepositNeutral"), + deltaR = cms.double(0.3), + weight = cms.string('1'), + vetos = cms.vstring('0.01','Threshold(0.5)'), + skipDefaultVeto = cms.bool(True), + mode = cms.string('meanDR') + ) + ) +) + + + +dispMuPFIsoValueGammaHighThreshold03 = cms.EDProducer("CandIsolatorFromDeposits", + deposits = cms.VPSet( + cms.PSet( + src = cms.InputTag("dispMuPFIsoDepositGamma"), + deltaR = cms.double(0.3), + weight = cms.string('1'), + vetos = cms.vstring('0.01','Threshold(1.0)'), + skipDefaultVeto = cms.bool(True), + mode = cms.string('sum') + ) + ) +) +dispMuPFSumDRIsoValueGammaHighThreshold03 = cms.EDProducer("CandIsolatorFromDeposits", + deposits = cms.VPSet( + cms.PSet( + src = cms.InputTag("dispMuPFIsoDepositGamma"), + deltaR = cms.double(0.3), + weight = cms.string('1'), + vetos = cms.vstring('0.01','Threshold(1.0)'), + skipDefaultVeto = cms.bool(True), + mode = cms.string('sumDR') + ) + ) +) + +dispMuPFMeanDRIsoValueGammaHighThreshold03 = cms.EDProducer("CandIsolatorFromDeposits", + deposits = cms.VPSet( + cms.PSet( + src = cms.InputTag("dispMuPFIsoDepositGamma"), + deltaR = cms.double(0.3), + weight = cms.string('1'), + vetos = cms.vstring('0.01','Threshold(1.0)'), + skipDefaultVeto = cms.bool(True), + mode = cms.string('meanDR') + ) + ) +) + + +dispMuPFIsoValueNeutralHighThreshold03 = cms.EDProducer("CandIsolatorFromDeposits", + deposits = cms.VPSet( + cms.PSet( + src = cms.InputTag("dispMuPFIsoDepositNeutral"), + deltaR = cms.double(0.3), + weight = cms.string('1'), + vetos = cms.vstring('0.01','Threshold(1.0)'), + skipDefaultVeto = cms.bool(True), + mode = cms.string('sum') + ) + ) +) + +dispMuPFMeanDRIsoValueNeutralHighThreshold03 = cms.EDProducer("CandIsolatorFromDeposits", + deposits = cms.VPSet( + cms.PSet( + src = cms.InputTag("dispMuPFIsoDepositNeutral"), + deltaR = cms.double(0.3), + weight = cms.string('1'), + vetos = cms.vstring('0.01','Threshold(1.0)'), + skipDefaultVeto = cms.bool(True), + mode = cms.string('meanDR') + ) + ) +) + +dispMuPFSumDRIsoValueNeutralHighThreshold03 = cms.EDProducer("CandIsolatorFromDeposits", + deposits = cms.VPSet( + cms.PSet( + src = cms.InputTag("dispMuPFIsoDepositNeutral"), + deltaR = cms.double(0.3), + weight = cms.string('1'), + vetos = cms.vstring('0.01','Threshold(1.0)'), + skipDefaultVeto = cms.bool(True), + mode = cms.string('sumDR') + ) + ) +) + +dispMuPFIsoValuePU03 = cms.EDProducer("CandIsolatorFromDeposits", + deposits = cms.VPSet( + cms.PSet( + src = cms.InputTag("dispMuPFIsoDepositPU"), + deltaR = cms.double(0.3), + weight = cms.string('1'), + vetos = cms.vstring('0.01','Threshold(0.5)'), + skipDefaultVeto = cms.bool(True), + mode = cms.string('sum') + ) + ) +) + +dispMuPFSumDRIsoValuePU03 = cms.EDProducer("CandIsolatorFromDeposits", + deposits = cms.VPSet( + cms.PSet( + src = cms.InputTag("dispMuPFIsoDepositPU"), + deltaR = cms.double(0.3), + weight = cms.string('1'), + vetos = cms.vstring('0.01','Threshold(0.5)'), + skipDefaultVeto = cms.bool(True), + mode = cms.string('sumDR') + ) + ) +) + +dispMuPFMeanDRIsoValuePU03 = cms.EDProducer("CandIsolatorFromDeposits", + deposits = cms.VPSet( + cms.PSet( + src = cms.InputTag("dispMuPFIsoDepositPU"), + deltaR = cms.double(0.3), + weight = cms.string('1'), + vetos = cms.vstring('0.01','Threshold(0.5)'), + skipDefaultVeto = cms.bool(True), + mode = cms.string('meanDR') + ) + ) +) + + + +dispMuPFIsoValueCharged04 = cms.EDProducer("CandIsolatorFromDeposits", + deposits = cms.VPSet( + cms.PSet( + src = cms.InputTag("dispMuPFIsoDepositCharged"), + deltaR = cms.double(0.4), + weight = cms.string('1'), + vetos = cms.vstring('0.0001','Threshold(0.0)'), + skipDefaultVeto = cms.bool(True), + mode = cms.string('sum') + ) + ) +) + +dispMuPFSumDRIsoValueCharged04 = cms.EDProducer("CandIsolatorFromDeposits", + deposits = cms.VPSet( + cms.PSet( + src = cms.InputTag("dispMuPFIsoDepositCharged"), + deltaR = cms.double(0.4), + weight = cms.string('1'), + vetos = cms.vstring('0.0001','Threshold(0.0)'), + skipDefaultVeto = cms.bool(True), + mode = cms.string('sumDR') + ) + ) +) + +dispMuPFMeanDRIsoValueCharged04 = cms.EDProducer("CandIsolatorFromDeposits", + deposits = cms.VPSet( + cms.PSet( + src = cms.InputTag("dispMuPFIsoDepositCharged"), + deltaR = cms.double(0.4), + weight = cms.string('1'), + vetos = cms.vstring('0.0001','Threshold(0.0)'), + skipDefaultVeto = cms.bool(True), + mode = cms.string('meanDR') + ) + ) +) + + + + +dispMuPFIsoValueChargedAll04 = cms.EDProducer("CandIsolatorFromDeposits", + deposits = cms.VPSet( + cms.PSet( + src = cms.InputTag("dispMuPFIsoDepositChargedAll"), + deltaR = cms.double(0.4), + weight = cms.string('1'), + vetos = cms.vstring('0.0001','Threshold(0.0)'), + skipDefaultVeto = cms.bool(True), + mode = cms.string('sum') + ) + ) +) + +dispMuPFSumDRIsoValueChargedAll04 = cms.EDProducer("CandIsolatorFromDeposits", + deposits = cms.VPSet( + cms.PSet( + src = cms.InputTag("dispMuPFIsoDepositChargedAll"), + deltaR = cms.double(0.4), + weight = cms.string('1'), + vetos = cms.vstring('0.0001','Threshold(0.0)'), + skipDefaultVeto = cms.bool(True), + mode = cms.string('sumDR') + ) + ) +) + +dispMuPFMeanDRIsoValueChargedAll04 = cms.EDProducer("CandIsolatorFromDeposits", + deposits = cms.VPSet( + cms.PSet( + src = cms.InputTag("dispMuPFIsoDepositChargedAll"), + deltaR = cms.double(0.4), + weight = cms.string('1'), + vetos = cms.vstring('0.0001','Threshold(0.0)'), + skipDefaultVeto = cms.bool(True), + mode = cms.string('meanDR') + ) + ) +) + + + + + +dispMuPFIsoValueGamma04 = cms.EDProducer("CandIsolatorFromDeposits", + deposits = cms.VPSet( + cms.PSet( + src = cms.InputTag("dispMuPFIsoDepositGamma"), + deltaR = cms.double(0.4), + weight = cms.string('1'), + vetos = cms.vstring('0.01','Threshold(0.5)'), + skipDefaultVeto = cms.bool(True), + mode = cms.string('sum') + ) + ) +) + +dispMuPFSumDRIsoValueGamma04 = cms.EDProducer("CandIsolatorFromDeposits", + deposits = cms.VPSet( + cms.PSet( + src = cms.InputTag("dispMuPFIsoDepositGamma"), + deltaR = cms.double(0.4), + weight = cms.string('1'), + vetos = cms.vstring('0.01','Threshold(0.5)'), + skipDefaultVeto = cms.bool(True), + mode = cms.string('sumDR') + ) + ) +) + +dispMuPFMeanDRIsoValueGamma04 = cms.EDProducer("CandIsolatorFromDeposits", + deposits = cms.VPSet( + cms.PSet( + src = cms.InputTag("dispMuPFIsoDepositGamma"), + deltaR = cms.double(0.4), + weight = cms.string('1'), + vetos = cms.vstring('0.01','Threshold(0.5)'), + skipDefaultVeto = cms.bool(True), + mode = cms.string('meanDR') + ) + ) +) + + +dispMuPFIsoValueNeutral04 = cms.EDProducer("CandIsolatorFromDeposits", + deposits = cms.VPSet( + cms.PSet( + src = cms.InputTag("dispMuPFIsoDepositNeutral"), + deltaR = cms.double(0.4), + weight = cms.string('1'), + vetos = cms.vstring('0.01','Threshold(0.5)'), + skipDefaultVeto = cms.bool(True), + mode = cms.string('sum') + ) + ) + +) + +dispMuPFSumDRIsoValueNeutral04 = cms.EDProducer("CandIsolatorFromDeposits", + deposits = cms.VPSet( + cms.PSet( + src = cms.InputTag("dispMuPFIsoDepositNeutral"), + deltaR = cms.double(0.4), + weight = cms.string('1'), + vetos = cms.vstring('0.01','Threshold(0.5)'), + skipDefaultVeto = cms.bool(True), + mode = cms.string('sumDR') + ) + ) + +) + +dispMuPFMeanDRIsoValueNeutral04 = cms.EDProducer("CandIsolatorFromDeposits", + deposits = cms.VPSet( + cms.PSet( + src = cms.InputTag("dispMuPFIsoDepositNeutral"), + deltaR = cms.double(0.4), + weight = cms.string('1'), + vetos = cms.vstring('0.01','Threshold(0.5)'), + skipDefaultVeto = cms.bool(True), + mode = cms.string('meanDR') + ) + ) + +) + + +dispMuPFIsoValueGammaHighThreshold04 = cms.EDProducer("CandIsolatorFromDeposits", + deposits = cms.VPSet( + cms.PSet( + src = cms.InputTag("dispMuPFIsoDepositGamma"), + deltaR = cms.double(0.4), + weight = cms.string('1'), + vetos = cms.vstring('0.01','Threshold(1.0)'), + skipDefaultVeto = cms.bool(True), + mode = cms.string('sum') + ) + ) +) + +dispMuPFMeanDRIsoValueGammaHighThreshold04 = cms.EDProducer("CandIsolatorFromDeposits", + deposits = cms.VPSet( + cms.PSet( + src = cms.InputTag("dispMuPFIsoDepositGamma"), + deltaR = cms.double(0.4), + weight = cms.string('1'), + vetos = cms.vstring('0.01','Threshold(1.0)'), + skipDefaultVeto = cms.bool(True), + mode = cms.string('meanDR') + ) + ) +) + +dispMuPFSumDRIsoValueGammaHighThreshold04 = cms.EDProducer("CandIsolatorFromDeposits", + deposits = cms.VPSet( + cms.PSet( + src = cms.InputTag("dispMuPFIsoDepositGamma"), + deltaR = cms.double(0.4), + weight = cms.string('1'), + vetos = cms.vstring('0.01','Threshold(1.0)'), + skipDefaultVeto = cms.bool(True), + mode = cms.string('sumDR') + ) + ) +) + + +dispMuPFIsoValueNeutralHighThreshold04 = cms.EDProducer("CandIsolatorFromDeposits", + deposits = cms.VPSet( + cms.PSet( + src = cms.InputTag("dispMuPFIsoDepositNeutral"), + deltaR = cms.double(0.4), + weight = cms.string('1'), + vetos = cms.vstring('0.01','Threshold(1.0)'), + skipDefaultVeto = cms.bool(True), + mode = cms.string('sum') + ) + ) + +) + +dispMuPFMeanDRIsoValueNeutralHighThreshold04 = cms.EDProducer("CandIsolatorFromDeposits", + deposits = cms.VPSet( + cms.PSet( + src = cms.InputTag("dispMuPFIsoDepositNeutral"), + deltaR = cms.double(0.4), + weight = cms.string('1'), + vetos = cms.vstring('0.01','Threshold(1.0)'), + skipDefaultVeto = cms.bool(True), + mode = cms.string('meanDR') + ) + ) + +) + +dispMuPFSumDRIsoValueNeutralHighThreshold04 = cms.EDProducer("CandIsolatorFromDeposits", + deposits = cms.VPSet( + cms.PSet( + src = cms.InputTag("dispMuPFIsoDepositNeutral"), + deltaR = cms.double(0.4), + weight = cms.string('1'), + vetos = cms.vstring('0.01','Threshold(1.0)'), + skipDefaultVeto = cms.bool(True), + mode = cms.string('sumDR') + ) + ) + +) + +dispMuPFIsoValuePU04 = cms.EDProducer("CandIsolatorFromDeposits", + deposits = cms.VPSet( + cms.PSet( + src = cms.InputTag("dispMuPFIsoDepositPU"), + deltaR = cms.double(0.4), + weight = cms.string('1'), + vetos = cms.vstring('0.01','Threshold(0.5)'), + skipDefaultVeto = cms.bool(True), + mode = cms.string('sum') + ) + ) +) + +dispMuPFMeanDRIsoValuePU04 = cms.EDProducer("CandIsolatorFromDeposits", + deposits = cms.VPSet( + cms.PSet( + src = cms.InputTag("dispMuPFIsoDepositPU"), + deltaR = cms.double(0.4), + weight = cms.string('1'), + vetos = cms.vstring('0.01','Threshold(0.5)'), + skipDefaultVeto = cms.bool(True), + mode = cms.string('meanDR') + ) + ) +) + +dispMuPFSumDRIsoValuePU04 = cms.EDProducer("CandIsolatorFromDeposits", + deposits = cms.VPSet( + cms.PSet( + src = cms.InputTag("dispMuPFIsoDepositPU"), + deltaR = cms.double(0.4), + weight = cms.string('1'), + vetos = cms.vstring('0.01','Threshold(0.5)'), + skipDefaultVeto = cms.bool(True), + mode = cms.string('sumDR') + ) + ) +) + +displacedMuonPFIsolationValuesTask = cms.Task( + dispMuPFIsoValueCharged03, + dispMuPFMeanDRIsoValueCharged03, + dispMuPFSumDRIsoValueCharged03, + dispMuPFIsoValueChargedAll03, + dispMuPFMeanDRIsoValueChargedAll03, + dispMuPFSumDRIsoValueChargedAll03, + dispMuPFIsoValueGamma03, + dispMuPFMeanDRIsoValueGamma03, + dispMuPFSumDRIsoValueGamma03, + dispMuPFIsoValueNeutral03, + dispMuPFMeanDRIsoValueNeutral03, + dispMuPFSumDRIsoValueNeutral03, + dispMuPFIsoValueGammaHighThreshold03, + dispMuPFMeanDRIsoValueGammaHighThreshold03, + dispMuPFSumDRIsoValueGammaHighThreshold03, + dispMuPFIsoValueNeutralHighThreshold03, + dispMuPFMeanDRIsoValueNeutralHighThreshold03, + dispMuPFSumDRIsoValueNeutralHighThreshold03, + dispMuPFIsoValuePU03, + dispMuPFMeanDRIsoValuePU03, + dispMuPFSumDRIsoValuePU03, + ############################## + dispMuPFIsoValueCharged04, + dispMuPFMeanDRIsoValueCharged04, + dispMuPFSumDRIsoValueCharged04, + dispMuPFIsoValueChargedAll04, + dispMuPFMeanDRIsoValueChargedAll04, + dispMuPFSumDRIsoValueChargedAll04, + dispMuPFIsoValueGamma04, + dispMuPFMeanDRIsoValueGamma04, + dispMuPFSumDRIsoValueGamma04, + dispMuPFIsoValueNeutral04, + dispMuPFMeanDRIsoValueNeutral04, + dispMuPFSumDRIsoValueNeutral04, + dispMuPFIsoValueGammaHighThreshold04, + dispMuPFMeanDRIsoValueGammaHighThreshold04, + dispMuPFSumDRIsoValueGammaHighThreshold04, + dispMuPFIsoValueNeutralHighThreshold04, + dispMuPFMeanDRIsoValueNeutralHighThreshold04, + dispMuPFSumDRIsoValueNeutralHighThreshold04, + dispMuPFIsoValuePU04, + dispMuPFMeanDRIsoValuePU04, + dispMuPFSumDRIsoValuePU04 + ) +displacedMuonPFIsolationValuesSequence = cms.Sequence(displacedMuonPFIsolationValuesTask) diff --git a/RecoMuon/MuonIsolation/python/muonPFIsolation_cff.py b/RecoMuon/MuonIsolation/python/muonPFIsolation_cff.py index 72d8b3e1274da..59e645fd86b73 100644 --- a/RecoMuon/MuonIsolation/python/muonPFIsolation_cff.py +++ b/RecoMuon/MuonIsolation/python/muonPFIsolation_cff.py @@ -9,3 +9,12 @@ muonPFIsolationValuesTask ) muonPFIsolationSequence = cms.Sequence(muonPFIsolationTask) + +from RecoMuon.MuonIsolation.displacedMuonPFIsolationDeposits_cff import * +from RecoMuon.MuonIsolation.displacedMuonPFIsolationValues_cff import * + +displacedMuonPFIsolationTask = cms.Task( + displacedMuonPFIsolationDepositsTask, + displacedMuonPFIsolationValuesTask +) +displacedMuonPFIsolationSequence = cms.Sequence(displacedMuonPFIsolationTask) diff --git a/RecoMuon/MuonIsolationProducers/python/isoDepositProducerIOBlocks_cff.py b/RecoMuon/MuonIsolationProducers/python/isoDepositProducerIOBlocks_cff.py index 712bcda522156..134c8e4ab3b2f 100644 --- a/RecoMuon/MuonIsolationProducers/python/isoDepositProducerIOBlocks_cff.py +++ b/RecoMuon/MuonIsolationProducers/python/isoDepositProducerIOBlocks_cff.py @@ -15,6 +15,20 @@ InputType = cms.string('MuonCollection'), MuonTrackRefType = cms.string('bestTrkSta') ) +MIsoDepositDisplacedViewMultiIOBlock = cms.PSet( + ExtractForCandidate = cms.bool(False), + inputMuonCollection = cms.InputTag("displacedMuons1stStep"), + MultipleDepositsFlag = cms.bool(True), + InputType = cms.string('MuonCollection'), + MuonTrackRefType = cms.string('bestTrkSta') +) +MIsoDepositDisplacedViewIOBlock = cms.PSet( + ExtractForCandidate = cms.bool(False), + inputMuonCollection = cms.InputTag("displacedMuons1stStep"), + MultipleDepositsFlag = cms.bool(False), + InputType = cms.string('MuonCollection'), + MuonTrackRefType = cms.string('bestTrkSta') +) MIsoDepositParamGlobalViewMultiIOBlock = cms.PSet( ExtractForCandidate = cms.bool(False), inputMuonCollection = cms.InputTag("paramMuons","ParamGlobalMuons"), diff --git a/RecoMuon/MuonIsolationProducers/python/muIsoDepositCopies_cfi.py b/RecoMuon/MuonIsolationProducers/python/muIsoDepositCopies_cfi.py index fed75c5caeaec..cf95ff86f022d 100644 --- a/RecoMuon/MuonIsolationProducers/python/muIsoDepositCopies_cfi.py +++ b/RecoMuon/MuonIsolationProducers/python/muIsoDepositCopies_cfi.py @@ -5,14 +5,28 @@ depositNames = cms.vstring('') ) +muIsoDepositTkDisplaced = cms.EDProducer("MuIsoDepositCopyProducer", + inputTags = cms.VInputTag(cms.InputTag("displacedMuons1stStep:tracker")), + depositNames = cms.vstring('') +) + muIsoDepositJets = cms.EDProducer("MuIsoDepositCopyProducer", inputTags = cms.VInputTag(cms.InputTag("muons1stStep:jets")), depositNames = cms.vstring('') ) +muIsoDepositJetsDisplaced = cms.EDProducer("MuIsoDepositCopyProducer", + inputTags = cms.VInputTag(cms.InputTag("displacedMuons1stStep:jets")), + depositNames = cms.vstring('') +) + muIsoDepositCalByAssociatorTowers = cms.EDProducer("MuIsoDepositCopyProducer", inputTags = cms.VInputTag(cms.InputTag("muons1stStep:ecal"), cms.InputTag("muons1stStep:hcal"), cms.InputTag("muons1stStep:ho")), depositNames = cms.vstring('ecal', 'hcal', 'ho') ) +muIsoDepositCalByAssociatorTowersDisplaced = cms.EDProducer("MuIsoDepositCopyProducer", + inputTags = cms.VInputTag(cms.InputTag("displacedMuons1stStep:ecal"), cms.InputTag("displacedMuons1stStep:hcal"), cms.InputTag("displacedMuons1stStep:ho")), + depositNames = cms.vstring('ecal', 'hcal', 'ho') +) diff --git a/RecoMuon/MuonIsolationProducers/python/muIsoDeposits_cff.py b/RecoMuon/MuonIsolationProducers/python/muIsoDeposits_cff.py index 404884c074e18..7c5e64f0e1324 100644 --- a/RecoMuon/MuonIsolationProducers/python/muIsoDeposits_cff.py +++ b/RecoMuon/MuonIsolationProducers/python/muIsoDeposits_cff.py @@ -32,6 +32,9 @@ # "standard sequences" muIsoDeposits_muonsTask = cms.Task(muIsoDepositTk,muIsoDepositCalByAssociatorTowers,muIsoDepositJets) muIsoDeposits_muons = cms.Sequence(muIsoDeposits_muonsTask) +# "displaced sequences" +muIsoDeposits_displacedMuonsTask = cms.Task(muIsoDepositTkDisplaced,muIsoDepositCalByAssociatorTowersDisplaced,muIsoDepositJetsDisplaced) +muIsoDeposits_displacedMuons = cms.Sequence(muIsoDeposits_displacedMuonsTask) #old one, using a reduced config set muIsoDeposits_ParamGlobalMuonsOldTask = cms.Task(muParamGlobalIsoDepositGsTk,muParamGlobalIsoDepositCalEcal,muParamGlobalIsoDepositCalHcal) muIsoDeposits_ParamGlobalMuonsOld = cms.Sequence(muIsoDeposits_ParamGlobalMuonsOldTask) diff --git a/RecoMuon/MuonIsolationProducers/python/muIsolation_cff.py b/RecoMuon/MuonIsolationProducers/python/muIsolation_cff.py index 1d69b8046550f..7ba50afec4a2b 100644 --- a/RecoMuon/MuonIsolationProducers/python/muIsolation_cff.py +++ b/RecoMuon/MuonIsolationProducers/python/muIsolation_cff.py @@ -6,6 +6,8 @@ # sequences suggested for reco (only isoDeposits are produced at this point) muIsolation_muonsTask = cms.Task(muIsoDeposits_muonsTask) muIsolation_muons = cms.Sequence(muIsolation_muonsTask) +muIsolation_displacedMuonsTask = cms.Task(muIsoDeposits_displacedMuonsTask) +muIsolation_displacedMuons = cms.Sequence(muIsolation_displacedMuonsTask) muIsolation_ParamGlobalMuonsTask = cms.Task(muIsoDeposits_ParamGlobalMuonsTask) muIsolation_ParamGlobalMuons = cms.Sequence(muIsolation_ParamGlobalMuonsTask) muIsolation_ParamGlobalMuonsOldTask = cms.Task(muIsoDeposits_ParamGlobalMuonsOldTask) @@ -13,4 +15,6 @@ #standard sequence muIsolationTask = cms.Task(muIsolation_muonsTask) muIsolation = cms.Sequence(muIsolationTask) +muIsolationDisplacedTask = cms.Task(muIsolation_displacedMuonsTask) +muIsolationDisplaced = cms.Sequence(muIsolationDisplacedTask) From 25764cec6623f00b8c969ca25375b0e76ca0889b Mon Sep 17 00:00:00 2001 From: CeliaFernandez Date: Tue, 1 Feb 2022 10:44:36 +0100 Subject: [PATCH 2/5] Modify detector based isolation processing: Deposits only saved in RECO now but not in AOD, remove unecessary producers. --- .../python/RecoMuon_EventContent_cff.py | 2 +- .../python/isoDepositProducerIOBlocks_cff.py | 14 -------------- .../python/muIsolation_EventContent_cff.py | 4 ++++ 3 files changed, 5 insertions(+), 15 deletions(-) diff --git a/RecoMuon/Configuration/python/RecoMuon_EventContent_cff.py b/RecoMuon/Configuration/python/RecoMuon_EventContent_cff.py index b16103a5971e3..b56b04cb1bc1d 100644 --- a/RecoMuon/Configuration/python/RecoMuon_EventContent_cff.py +++ b/RecoMuon/Configuration/python/RecoMuon_EventContent_cff.py @@ -44,7 +44,7 @@ 'keep recoMuonTimeExtraedmValueMap_displacedMuons_*_*', 'keep uintedmValueMap_displacedMuons_*_*', 'keep *_particleFlow_displacedMuons_*', - 'keep recoIsoDepositedmValueMap_*Displaced_*_*', + #'keep recoIsoDepositedmValueMap_*Displaced_*_*', # saved in RECO # Tracks known by the Muon obj 'keep recoTracks_standAloneMuons_*_*', 'keep recoTrackExtras_standAloneMuons_*_*', diff --git a/RecoMuon/MuonIsolationProducers/python/isoDepositProducerIOBlocks_cff.py b/RecoMuon/MuonIsolationProducers/python/isoDepositProducerIOBlocks_cff.py index 134c8e4ab3b2f..712bcda522156 100644 --- a/RecoMuon/MuonIsolationProducers/python/isoDepositProducerIOBlocks_cff.py +++ b/RecoMuon/MuonIsolationProducers/python/isoDepositProducerIOBlocks_cff.py @@ -15,20 +15,6 @@ InputType = cms.string('MuonCollection'), MuonTrackRefType = cms.string('bestTrkSta') ) -MIsoDepositDisplacedViewMultiIOBlock = cms.PSet( - ExtractForCandidate = cms.bool(False), - inputMuonCollection = cms.InputTag("displacedMuons1stStep"), - MultipleDepositsFlag = cms.bool(True), - InputType = cms.string('MuonCollection'), - MuonTrackRefType = cms.string('bestTrkSta') -) -MIsoDepositDisplacedViewIOBlock = cms.PSet( - ExtractForCandidate = cms.bool(False), - inputMuonCollection = cms.InputTag("displacedMuons1stStep"), - MultipleDepositsFlag = cms.bool(False), - InputType = cms.string('MuonCollection'), - MuonTrackRefType = cms.string('bestTrkSta') -) MIsoDepositParamGlobalViewMultiIOBlock = cms.PSet( ExtractForCandidate = cms.bool(False), inputMuonCollection = cms.InputTag("paramMuons","ParamGlobalMuons"), diff --git a/RecoMuon/MuonIsolationProducers/python/muIsolation_EventContent_cff.py b/RecoMuon/MuonIsolationProducers/python/muIsolation_EventContent_cff.py index d8ef478a30458..a7df782f4cac0 100644 --- a/RecoMuon/MuonIsolationProducers/python/muIsolation_EventContent_cff.py +++ b/RecoMuon/MuonIsolationProducers/python/muIsolation_EventContent_cff.py @@ -27,6 +27,10 @@ 'keep *_muIsoDepositCalByAssociatorTowers_*_*', 'keep *_muIsoDepositCalByAssociatorHits_*_*', 'keep *_muIsoDepositJets_*_*', + 'keep *_muIsoDepositTkDisplaced_*_*', + 'keep *_muIsoDepositCalByAssociatorTowersDisplaced_*_*', + 'keep *_muIsoDepositCalByAssociatorHitsDisplaced_*_*', + 'keep *_muIsoDepositJetsDisplaced_*_*', 'keep *_muGlobalIsoDepositCtfTk_*_*', 'keep *_muGlobalIsoDepositCalByAssociatorTowers_*_*', 'keep *_muGlobalIsoDepositCalByAssociatorHits_*_*', From 0c974b066690e8a2b885fe41359acd5ca19a267b Mon Sep 17 00:00:00 2001 From: CeliaFernandez Date: Fri, 11 Feb 2022 15:14:22 +0100 Subject: [PATCH 3/5] Remove displacedMuons sequences from fastsim since displacedTrack reconstruction is not available there --- RecoMuon/Configuration/python/RecoMuonPPonly_cff.py | 3 ++- RecoMuon/Configuration/python/RecoMuon_cff.py | 3 +++ 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/RecoMuon/Configuration/python/RecoMuonPPonly_cff.py b/RecoMuon/Configuration/python/RecoMuonPPonly_cff.py index f1add3b267d05..f390d73b97017 100644 --- a/RecoMuon/Configuration/python/RecoMuonPPonly_cff.py +++ b/RecoMuon/Configuration/python/RecoMuonPPonly_cff.py @@ -82,6 +82,7 @@ # Muon Reconstruction displacedMuonIdProducerTask = cms.Task(displacedMuons1stStep) muonrecoTask = cms.Task(muontrackingTask,muonIdProducerTask, displacedMuonIdProducerTask) +fastSim.toReplaceWith(muonrecoTask,muonrecoTask.copyAndExclude([displacedMuonIdProducerTask])) muonreco = cms.Sequence(muonrecoTask) # Muon Reconstruction plus Isolation muonreco_plus_isolationTask = cms.Task(muonrecoTask,muIsolationTask) @@ -117,4 +118,4 @@ ######################################################## # not commisoned and not relevant in FastSim (?): -fastSim.toReplaceWith(muonGlobalRecoTask, muonGlobalRecoTask.copyAndExclude([muonreco_with_SET_Task,muonSelectionTypeTask])) +fastSim.toReplaceWith(muonGlobalRecoTask, muonGlobalRecoTask.copyAndExclude([muonreco_with_SET_Task,muonSelectionTypeTask,displacedMuonIdProducerTask,muIsolationDisplacedTask])) diff --git a/RecoMuon/Configuration/python/RecoMuon_cff.py b/RecoMuon/Configuration/python/RecoMuon_cff.py index a141290af78b7..82f3fabb2309c 100644 --- a/RecoMuon/Configuration/python/RecoMuon_cff.py +++ b/RecoMuon/Configuration/python/RecoMuon_cff.py @@ -86,3 +86,6 @@ muonshighlevelrecoTask = cms.Task(muonPFIsolationTask,displacedMuonPFIsolationTask,muons,displacedMuons,muonReducedTrackExtras, displacedMuonReducedTrackExtras) muonshighlevelreco = cms.Sequence(muonshighlevelrecoTask) + +# displaced sequences do not run in fastsim +fastSim.toReplaceWith(muonshighlevelrecoTask,muonshighlevelrecoTask.copyAndExclude([displacedMuonPFIsolationTask,displacedMuons,displacedMuonReducedTrackExtras])) From 0e2664c86879c8b98318323355a34b5bfaa004c2 Mon Sep 17 00:00:00 2001 From: CeliaFernandez Date: Fri, 11 Feb 2022 16:09:10 +0100 Subject: [PATCH 4/5] Remove outdated lines --- RecoMuon/MuonIdentification/python/displacedMuons_cfi.py | 3 --- 1 file changed, 3 deletions(-) diff --git a/RecoMuon/MuonIdentification/python/displacedMuons_cfi.py b/RecoMuon/MuonIdentification/python/displacedMuons_cfi.py index 653f820ae7d2d..b82eb11a0fa70 100644 --- a/RecoMuon/MuonIdentification/python/displacedMuons_cfi.py +++ b/RecoMuon/MuonIdentification/python/displacedMuons_cfi.py @@ -1,6 +1,3 @@ -# This file name is temporary and ment for development only. -# The content of this file will be moved to displacedMuons_cfi as soon as the complete work flow is in place. - import FWCore.ParameterSet.Config as cms displacedMuons = cms.EDProducer("MuonProducer", From 4d2de56674c12e6e7dfbbcb8adeeee2f92e289bc Mon Sep 17 00:00:00 2001 From: CeliaFernandez Date: Mon, 14 Feb 2022 08:20:38 +0100 Subject: [PATCH 5/5] Do not use clusters in displacedMuonReducedTrackExtras since clusters are different there --- RecoMuon/Configuration/python/RecoMuon_cff.py | 1 + 1 file changed, 1 insertion(+) diff --git a/RecoMuon/Configuration/python/RecoMuon_cff.py b/RecoMuon/Configuration/python/RecoMuon_cff.py index 82f3fabb2309c..2363b949eeba2 100644 --- a/RecoMuon/Configuration/python/RecoMuon_cff.py +++ b/RecoMuon/Configuration/python/RecoMuon_cff.py @@ -83,6 +83,7 @@ # cluster collections are different in phase 2 from Configuration.Eras.Modifier_phase2_tracker_cff import phase2_tracker phase2_tracker.toModify(muonReducedTrackExtras, outputClusters = False) +phase2_tracker.toModify(displacedMuonReducedTrackExtras, outputClusters = False) muonshighlevelrecoTask = cms.Task(muonPFIsolationTask,displacedMuonPFIsolationTask,muons,displacedMuons,muonReducedTrackExtras, displacedMuonReducedTrackExtras) muonshighlevelreco = cms.Sequence(muonshighlevelrecoTask)