diff --git a/SimMuon/MCTruth/interface/MuonAssociatorByHitsHelper.h b/SimMuon/MCTruth/interface/MuonAssociatorByHitsHelper.h index cefeee85dbe22..7cd0ed79d2eff 100644 --- a/SimMuon/MCTruth/interface/MuonAssociatorByHitsHelper.h +++ b/SimMuon/MCTruth/interface/MuonAssociatorByHitsHelper.h @@ -100,6 +100,7 @@ class MuonAssociatorByHitsHelper { const bool includeZeroHitMuons; const bool acceptOneStubMatchings; + const bool rejectBadGlobal; bool UseTracker; bool UseMuon; const bool AbsoluteNumberOfHits_track; diff --git a/SimMuon/MCTruth/plugins/MuonAssociatorEDProducer.cc b/SimMuon/MCTruth/plugins/MuonAssociatorEDProducer.cc index 79a1dd05ed921..645a6d5392b51 100644 --- a/SimMuon/MCTruth/plugins/MuonAssociatorEDProducer.cc +++ b/SimMuon/MCTruth/plugins/MuonAssociatorEDProducer.cc @@ -7,12 +7,16 @@ MuonAssociatorEDProducer::MuonAssociatorEDProducer(const edm::ParameterSet &parset) : tracksTag(parset.getParameter("tracksTag")), tpTag(parset.getParameter("tpTag")), + tpRefVector(parset.getParameter("tpRefVector")), ignoreMissingTrackCollection(parset.getUntrackedParameter("ignoreMissingTrackCollection", false)), parset_(parset) { edm::LogVerbatim("MuonAssociatorEDProducer") << "constructing MuonAssociatorEDProducer"; produces(); produces(); - tpToken_ = consumes(tpTag); + if (tpRefVector) + tpRefVectorToken_ = consumes(tpTag); + else + tpToken_ = consumes(tpTag); tracksToken_ = consumes>(tracksTag); /// Perform some sanity checks of the configuration @@ -20,12 +24,13 @@ MuonAssociatorEDProducer::MuonAssociatorEDProducer(const edm::ParameterSet &pars edm::LogVerbatim("MuonAssociatorEDProducer") << "\n MuonAssociatorByHits will associate reco::Tracks with " << tracksTag << "\n\t\t and TrackingParticles with " << tpTag; const std::string recoTracksLabel = tracksTag.label(); - const std::string recoTracksInstance = tracksTag.instance(); // check and fix inconsistent input settings // tracks with hits only on muon detectors - if (recoTracksLabel == "standAloneMuons" || recoTracksLabel == "standAloneSETMuons" || - recoTracksLabel == "cosmicMuons" || recoTracksLabel == "hltL2Muons") { + if (recoTracksLabel == "seedsOfSTAmuons" || recoTracksLabel == "standAloneMuons" || + recoTracksLabel == "refittedStandAloneMuons" || recoTracksLabel == "seedsOfDisplacedSTAmuons" || + recoTracksLabel == "displacedStandAloneMuons" || recoTracksLabel == "cosmicMuons" || + recoTracksLabel == "cosmicMuons1Leg" || recoTracksLabel == "hltL2Muons") { if (parset_.getParameter("UseTracker")) { edm::LogWarning("MuonAssociatorEDProducer") << "\n*** WARNING : inconsistent input tracksTag = " << tracksTag << "\n with UseTracker = true" @@ -40,9 +45,11 @@ MuonAssociatorEDProducer::MuonAssociatorEDProducer(const edm::ParameterSet &pars } } // tracks with hits only on tracker - if (recoTracksLabel == "generalTracks" || recoTracksLabel == "ctfWithMaterialTracksP5LHCNavigation" || - recoTracksLabel == "hltL3TkTracksFromL2" || - (recoTracksLabel == "hltL3Muons" && recoTracksInstance == "L2Seeded")) { + if (recoTracksLabel == "generalTracks" || recoTracksLabel == "probeTracks" || recoTracksLabel == "displacedTracks" || + recoTracksLabel == "extractGemMuons" || recoTracksLabel == "extractMe0Muons" || + recoTracksLabel == "ctfWithMaterialTracksP5LHCNavigation" || recoTracksLabel == "ctfWithMaterialTracksP5" || + recoTracksLabel == "hltIterL3OIMuonTrackSelectionHighPurity" || recoTracksLabel == "hltIterL3MuonMerged" || + recoTracksLabel == "hltIterL3MuonAndMuonFromL1Merged") { if (parset_.getParameter("UseMuon")) { edm::LogWarning("MuonAssociatorEDProducer") << "\n*** WARNING : inconsistent input tracksTag = " << tracksTag << "\n with UseMuon = true" @@ -71,10 +78,27 @@ void MuonAssociatorEDProducer::endJob() {} void MuonAssociatorEDProducer::produce(edm::Event &event, const edm::EventSetup &setup) { using namespace edm; + TrackingParticleRefVector tmpTP; + const TrackingParticleRefVector *tmpTPptr = nullptr; Handle TPCollection; + Handle TPCollectionRefVector; + + if (tpRefVector) { + event.getByToken(tpRefVectorToken_, TPCollectionRefVector); + tmpTPptr = TPCollectionRefVector.product(); + // + tmpTP = *tmpTPptr; + } else { + event.getByToken(tpToken_, TPCollection); + size_t nTP = TPCollection->size(); + for (size_t i = 0; i < nTP; ++i) { + tmpTP.push_back(TrackingParticleRef(TPCollection, i)); + } + tmpTPptr = &tmpTP; + } + LogTrace("MuonAssociatorEDProducer") << "getting TrackingParticle collection - " << tpTag; - event.getByToken(tpToken_, TPCollection); - LogTrace("MuonAssociatorEDProducer") << "\t... size = " << TPCollection->size(); + LogTrace("MuonAssociatorEDProducer") << "\t... size = " << tmpTPptr->size(); Handle> trackCollection; LogTrace("MuonAssociatorEDProducer") << "getting reco::Track collection - " << tracksTag; @@ -84,6 +108,10 @@ void MuonAssociatorEDProducer::produce(edm::Event &event, const edm::EventSetup else LogTrace("MuonAssociatorEDProducer") << "\t... NOT FOUND."; + edm::RefToBaseVector tmpT; + for (size_t i = 0; i < trackCollection->size(); ++i) + tmpT.push_back(trackCollection->refAt(i)); + std::unique_ptr rts; std::unique_ptr str; @@ -99,20 +127,18 @@ void MuonAssociatorEDProducer::produce(edm::Event &event, const edm::EventSetup << " Track collection : " << tracksTag.label() << ":" << tracksTag.instance() << " (size = " << trackCollection->size() << ") \n" << " TrackingParticle collection : " << tpTag.label() << ":" << tpTag.instance() - << " (size = " << TPCollection->size() << ")"; + << " (size = " << tmpTPptr->size() << ")"; - reco::RecoToSimCollection recSimColl = - associatorByHits->associateRecoToSim(trackCollection, TPCollection, &event, &setup); + reco::RecoToSimCollection recSimColl = associatorByHits->associateRecoToSim(tmpT, tmpTP, &event, &setup); edm::LogVerbatim("MuonAssociatorEDProducer") << "\n >>> SimToReco association <<< \n" << " TrackingParticle collection : " << tpTag.label() << ":" << tpTag.instance() - << " (size = " << TPCollection->size() << ") \n" + << " (size = " << tmpTPptr->size() << ") \n" << " Track collection : " << tracksTag.label() << ":" << tracksTag.instance() << " (size = " << trackCollection->size() << ")"; - reco::SimToRecoCollection simRecColl = - associatorByHits->associateSimToReco(trackCollection, TPCollection, &event, &setup); + reco::SimToRecoCollection simRecColl = associatorByHits->associateSimToReco(tmpT, tmpTP, &event, &setup); rts = std::make_unique(recSimColl); str = std::make_unique(simRecColl); diff --git a/SimMuon/MCTruth/plugins/MuonAssociatorEDProducer.h b/SimMuon/MCTruth/plugins/MuonAssociatorEDProducer.h index 4f6c8447531a1..24d76d1640ebe 100644 --- a/SimMuon/MCTruth/plugins/MuonAssociatorEDProducer.h +++ b/SimMuon/MCTruth/plugins/MuonAssociatorEDProducer.h @@ -23,8 +23,10 @@ class MuonAssociatorEDProducer : public edm::stream::EDProducer<> { edm::InputTag tracksTag; edm::InputTag tpTag; edm::EDGetTokenT tpToken_; + edm::EDGetTokenT tpRefVectorToken_; edm::EDGetTokenT> tracksToken_; + bool tpRefVector; bool ignoreMissingTrackCollection; edm::ParameterSet parset_; MuonAssociatorByHits *associatorByHits; diff --git a/SimMuon/MCTruth/plugins/MuonToTrackingParticleAssociatorEDProducer.cc b/SimMuon/MCTruth/plugins/MuonToTrackingParticleAssociatorEDProducer.cc index 0a436199db3b8..9ef9ff633ba46 100644 --- a/SimMuon/MCTruth/plugins/MuonToTrackingParticleAssociatorEDProducer.cc +++ b/SimMuon/MCTruth/plugins/MuonToTrackingParticleAssociatorEDProducer.cc @@ -221,6 +221,10 @@ MuonToTrackingParticleAssociatorEDProducer::MuonToTrackingParticleAssociatorEDPr DTHitAssociator dttruth(iConfig, consumesCollector()); CSCHitAssociator cscruth(iConfig, consumesCollector()); + edm::LogVerbatim("MuonToTrackingParticleAssociatorEDProducer") + << "\n constructing MuonToTrackingParticleAssociatorEDProducer" + << "\n"; + if (iConfig.getUntrackedParameter("dumpInputCollections")) { diagnostics_ = std::make_unique(iConfig, consumesCollector()); } diff --git a/SimMuon/MCTruth/plugins/MuonTrackProducer.cc b/SimMuon/MCTruth/plugins/MuonTrackProducer.cc index 93beb93b4d988..bbbac57fe1024 100644 --- a/SimMuon/MCTruth/plugins/MuonTrackProducer.cc +++ b/SimMuon/MCTruth/plugins/MuonTrackProducer.cc @@ -209,22 +209,6 @@ void MuonTrackProducer::produce(edm::StreamID, edm::Event &iEvent, const edm::Ev else continue; } else if (trackType == "recomuonTrack") { - if (muon->isGlobalMuon()) - trackref = muon->globalTrack(); - else if (muon->isTrackerMuon()) { - trackref = muon->innerTrack(); - addMatchedMuonSegments = true; - } else if (muon->isStandAloneMuon()) - trackref = muon->outerTrack(); - else if (muon->isRPCMuon()) - trackref = muon->innerTrack(); - else if (muon->isGEMMuon()) - trackref = muon->innerTrack(); - else if (muon->isME0Muon()) - trackref = muon->innerTrack(); - else - trackref = muon->muonBestTrack(); - if (muon->muonBestTrackType() != muon->tunePMuonBestTrackType()) edm::LogVerbatim("MuonTrackProducer") << "\n *** PF != TuneP *** \n" << std::endl; @@ -290,6 +274,24 @@ void MuonTrackProducer::produce(edm::StreamID, edm::Event &iEvent, const edm::Ev << ", phi = " << muon->dytTrack()->phi() << ", N mu hits = " << muon->dytTrack()->hitPattern().numberOfValidMuonHits() << ", N trk hits = " << muon->dytTrack()->hitPattern().numberOfValidTrackerHits() << std::endl; + + if (muon->isGlobalMuon() && muon->globalTrack()->hitPattern().numberOfValidMuonHits() > 0) + trackref = muon->globalTrack(); + else if (muon->isTrackerMuon()) { + trackref = muon->innerTrack(); + addMatchedMuonSegments = true; + } else if (muon->isPFMuon()) + trackref = muon->muonBestTrack(); + else if (muon->isStandAloneMuon()) + trackref = muon->outerTrack(); + else if (muon->isRPCMuon()) + trackref = muon->innerTrack(); + else if (muon->isGEMMuon()) + trackref = muon->innerTrack(); + else if (muon->isME0Muon()) + trackref = muon->innerTrack(); + else + trackref = muon->muonBestTrack(); } edm::LogVerbatim("MuonTrackProducer") << "\t *** Selected *** "; diff --git a/SimMuon/MCTruth/plugins/TrackingParticleRefMuonProducer.cc b/SimMuon/MCTruth/plugins/TrackingParticleRefMuonProducer.cc new file mode 100644 index 0000000000000..e68cfb698eb8e --- /dev/null +++ b/SimMuon/MCTruth/plugins/TrackingParticleRefMuonProducer.cc @@ -0,0 +1,86 @@ +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/MakerMacros.h" +#include "FWCore/Framework/interface/stream/EDProducer.h" +#include "FWCore/PluginManager/interface/ModuleDef.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "DataFormats/Common/interface/EDProductfwd.h" +#include "SimDataFormats/TrackingAnalysis/interface/TrackingParticle.h" +#include "SimDataFormats/TrackingAnalysis/interface/TrackingParticleFwd.h" +#include "FWCore/MessageLogger/interface/MessageLogger.h" + +class TrackingParticleRefMuonProducer : public edm::stream::EDProducer<> { +public: + TrackingParticleRefMuonProducer(const edm::ParameterSet &iConfig); + + void produce(edm::Event &iEvent, const edm::EventSetup &iSetup) override; + +private: + edm::EDGetTokenT tpToken_; + std::string skim_; + double ptmin_; + double pmin_; +}; + +TrackingParticleRefMuonProducer::TrackingParticleRefMuonProducer(const edm::ParameterSet &iConfig) + : tpToken_(consumes(iConfig.getParameter("src"))), + skim_(iConfig.getParameter("skim")), + ptmin_(iConfig.getParameter("ptmin")), + pmin_(iConfig.getParameter("pmin")) { + edm::LogVerbatim("TrackingParticleRefMuonProducer") + << "\n constructing TrackingParticleRefMuonProducer: skim = " << skim_; + if (skim_ == "mu") + edm::LogVerbatim("TrackingParticleRefMuonProducer") << "\t ptmin = " << ptmin_ << ", pmin = " << pmin_ << "\n"; + else if (skim_ == "track") + edm::LogVerbatim("TrackingParticleRefMuonProducer") << "\t ptmin = " << ptmin_ << "\n"; + else if (skim_ == "pf") + edm::LogVerbatim("TrackingParticleRefMuonProducer") << "\t ptmin = " << ptmin_ << ", pmin = " << pmin_ << "\n"; + else + edm::LogError("TrackingParticleRefMuonProducer") << "\t undefined skim = " << skim_ << "\n"; + + produces(); +} + +void TrackingParticleRefMuonProducer::produce(edm::Event &iEvent, const edm::EventSetup &iSetup) { + edm::Handle tpH; + iEvent.getByToken(tpToken_, tpH); + + auto tpskim = std::make_unique(); + + if (skim_ == "mu") { + for (size_t i = 0, end = tpH->size(); i < end; ++i) { + auto tp = TrackingParticleRef(tpH, i); + + // test if the TP is a muon with pt and p above minimum thresholds + bool isMu = (std::abs(tp->pdgId()) == 13); + bool ptpOk = (tp->pt() > ptmin_) && (tp->p() > pmin_); + if (isMu && ptpOk) + tpskim->push_back(tp); + else { + // test if the TP has muon hits + int n_muon_hits = tp->numberOfHits() - tp->numberOfTrackerHits(); + if (n_muon_hits > 0) + tpskim->push_back(tp); + } + } + } else if (skim_ == "track") { + for (size_t i = 0, end = tpH->size(); i < end; ++i) { + auto tp = TrackingParticleRef(tpH, i); + + // test if the pt is above a minimum cut + if (tp->pt() > ptmin_) + tpskim->push_back(tp); + } + } else if (skim_ == "pf") { + for (size_t i = 0, end = tpH->size(); i < end; ++i) { + auto tp = TrackingParticleRef(tpH, i); + + // test if p and pt are above minimum cuts + if ((tp->pt() > ptmin_) && (tp->p() > pmin_)) + tpskim->push_back(tp); + } + } + + iEvent.put(std::move(tpskim)); +} + +DEFINE_FWK_MODULE(TrackingParticleRefMuonProducer); diff --git a/SimMuon/MCTruth/python/MuonAssociatorByHits_cfi.py b/SimMuon/MCTruth/python/MuonAssociatorByHits_cfi.py index 89299cddcbf24..f856b0f6f3580 100644 --- a/SimMuon/MCTruth/python/MuonAssociatorByHits_cfi.py +++ b/SimMuon/MCTruth/python/MuonAssociatorByHits_cfi.py @@ -9,8 +9,10 @@ # include invalid muon hits includeZeroHitMuons = cms.bool(True), # - # accept to match only tracker/muon stub of globalMuons + # accept mismatched association of tracker/muon stub of global hit patterns acceptOneStubMatchings = cms.bool(False), + # reject bad global muons made of only tracker hits + rejectBadGlobal = cms.bool(True), # # switches to be set according to the input Track collection UseTracker = cms.bool(True), @@ -130,27 +132,11 @@ # input collections # # ... reco::Track collection - # tracksTag = cms.InputTag("standAloneMuons"), - # tracksTag = cms.InputTag("standAloneMuons","UpdatedAtVtx"), - # tracksTag = cms.InputTag("standAloneSETMuons"), - # tracksTag = cms.InputTag("standAloneSETMuons","UpdatedAtVtx"), - # tracksTag = cms.InputTag("cosmicMuons"), tracksTag = cms.InputTag("globalMuons"), - # tracksTag = cms.InputTag("tevMuons","firstHit"), - # tracksTag = cms.InputTag("tevMuons","picky"), - # tracksTag = cms.InputTag("globalSETMuons"), - # tracksTag = cms.InputTag("globalCosmicMuons"), - # tracksTag = cms.InputTag("generalTracks"), - # tracksTag = cms.InputTag("ctfWithMaterialTracksP5LHCNavigation"), - # tracksTag = cms.InputTag("hltL2Muons"), - # tracksTag = cms.InputTag("hltL2Muons","UpdatedAtVtx"), - # tracksTag = cms.InputTag("hltL3Muons") - # tracksTag = cms.InputTag("hltL3Muons","L2Seeded") - # tracksTag = cms.InputTag("hltL3TkTracksFromL2") - # + ignoreMissingTrackCollection = cms.untracked.bool(False), # ... TrackingParticle collection tpTag = cms.InputTag("mix","MergedTrackTruth"), - ignoreMissingTrackCollection = cms.untracked.bool(False), + tpRefVector = cms.bool(False) ) premix_stage2.toModify(muonAssociatorByHits, tpTag = "mixData:MergedTrackTruth") diff --git a/SimMuon/MCTruth/python/trackingParticleMuon_cfi.py b/SimMuon/MCTruth/python/trackingParticleMuon_cfi.py new file mode 100644 index 0000000000000..78ede89308e9e --- /dev/null +++ b/SimMuon/MCTruth/python/trackingParticleMuon_cfi.py @@ -0,0 +1,14 @@ +import FWCore.ParameterSet.Config as cms + +trackingParticleMuon = cms.EDProducer("TrackingParticleRefMuonProducer", + mightGet = cms.optional.untracked.vstring, + src = cms.InputTag("mix","MergedTrackTruth"), + skim = cms.string('mu'), +# skim = cms.string('track'), +# skim = cms.string('pf'), + ptmin = cms.double(0.5), + pmin = cms.double(2.5) +) + +from Configuration.ProcessModifiers.premix_stage2_cff import premix_stage2 +premix_stage2.toModify(trackingParticleMuon, src = "mixData:MergedTrackTruth") diff --git a/SimMuon/MCTruth/src/MuonAssociatorByHitsHelper.cc b/SimMuon/MCTruth/src/MuonAssociatorByHitsHelper.cc index b41113a6c7172..b02ff39ba6fe9 100644 --- a/SimMuon/MCTruth/src/MuonAssociatorByHitsHelper.cc +++ b/SimMuon/MCTruth/src/MuonAssociatorByHitsHelper.cc @@ -17,6 +17,7 @@ using namespace std; MuonAssociatorByHitsHelper::MuonAssociatorByHitsHelper(const edm::ParameterSet &conf) : includeZeroHitMuons(conf.getParameter("includeZeroHitMuons")), acceptOneStubMatchings(conf.getParameter("acceptOneStubMatchings")), + rejectBadGlobal(conf.getParameter("rejectBadGlobal")), UseTracker(conf.getParameter("UseTracker")), UseMuon(conf.getParameter("UseMuon")), AbsoluteNumberOfHits_track(conf.getParameter("AbsoluteNumberOfHits_track")), @@ -32,7 +33,7 @@ MuonAssociatorByHitsHelper::MuonAssociatorByHitsHelper(const edm::ParameterSet & UseSplitting(conf.getParameter("UseSplitting")), ThreeHitTracksAreSpecial(conf.getParameter("ThreeHitTracksAreSpecial")), dumpDT(conf.getParameter("dumpDT")) { - edm::LogVerbatim("MuonAssociatorByHitsHelper") << "constructing MuonAssociatorByHitsHelper" << conf.dump(); + edm::LogVerbatim("MuonAssociatorByHitsHelper") << "\n constructing MuonAssociatorByHitsHelper" << conf.dump(); // up to the user in the other cases - print a message if (UseTracker) @@ -97,7 +98,6 @@ MuonAssociatorByHitsHelper::IndexAssociation MuonAssociatorByHitsHelper::associa MapOfMatchedIds tracker_matchedIds_INVALID, muon_matchedIds_INVALID; IndexAssociation outputCollection; - bool printRtS(true); TrackingParticleCollection tPC; tPC.reserve(TPCollectionH.size()); @@ -161,7 +161,7 @@ MuonAssociatorByHitsHelper::IndexAssociation MuonAssociatorByHitsHelper::associa int n_rpc_matched_INVALID = 0; int n_gem_matched_INVALID = 0; - printRtS = true; + bool printRtS = true; getMatchedIds(tracker_matchedIds_valid, muon_matchedIds_valid, tracker_matchedIds_INVALID, @@ -338,9 +338,11 @@ MuonAssociatorByHitsHelper::IndexAssociation MuonAssociatorByHitsHelper::associa // standalone muons, global muons) bool matchOk = trackerOk || muonOk; - // only for global muons: match both tracker and muon stub unless - // (acceptOneStubMatchings==true) - if (!acceptOneStubMatchings && n_tracker_selected_hits != 0 && n_muon_selected_hits != 0) + // only for global tracks: match both tracker and muon stub (if acceptOneStubMatchings==false) + // depending on the muon selection reject tracks with only one stub (if rejectBadGlobal==true) + // + if (UseTracker && UseMuon && !acceptOneStubMatchings && + ((n_tracker_selected_hits != 0 && n_muon_selected_hits != 0) || rejectBadGlobal)) matchOk = trackerOk && muonOk; if (matchOk) { @@ -355,7 +357,7 @@ MuonAssociatorByHitsHelper::IndexAssociation MuonAssociatorByHitsHelper::associa << " N shared hits = " << global_nshared << " (tracker: " << tracker_nshared << " / muon: " << muon_nshared << ")" << "\n" - << " to: TrackingParticle " << tpindex << ", q = " << (*trpart).charge() << ", p = " << (*trpart).p() + << " to TrackingParticle: q = " << (*trpart).charge() << ", p = " << (*trpart).p() << ", pT = " << (*trpart).pt() << ", eta = " << (*trpart).eta() << ", phi = " << (*trpart).phi() << "\n\t" << " pdg code = " << (*trpart).pdgId() << ", made of " << (*trpart).numberOfHits() << " PSimHits" << " from " << (*trpart).g4Tracks().size() << " SimTrack:"; @@ -369,9 +371,9 @@ MuonAssociatorByHitsHelper::IndexAssociation MuonAssociatorByHitsHelper::associa // print something only if this TrackingParticle shares some hits with // the current reco::Track if (global_nshared != 0) - edm::LogVerbatim("MuonAssociatorByHitsHelper") + LogTrace("MuonAssociatorByHitsHelper") << "\n\t" - << " NOT matched to TrackingParticle " << tpindex << " with quality = " << global_quality + << " NOT matched to TrackingParticle, with quality = " << global_quality << " (tracker: " << tracker_quality << " / muon: " << muon_quality << ")" << "\n" << " N shared hits = " << global_nshared << " (tracker: " << tracker_nshared @@ -443,7 +445,7 @@ MuonAssociatorByHitsHelper::IndexAssociation MuonAssociatorByHitsHelper::associa IndexAssociation outputCollection; - bool printRtS(true); + bool printRtS = false; TrackingParticleCollection tPC; tPC.reserve(TPCollectionH.size()); @@ -506,7 +508,6 @@ MuonAssociatorByHitsHelper::IndexAssociation MuonAssociatorByHitsHelper::associa int n_rpc_matched_INVALID = 0; int n_gem_matched_INVALID = 0; - printRtS = false; getMatchedIds(tracker_matchedIds_valid, muon_matchedIds_valid, tracker_matchedIds_INVALID, @@ -628,7 +629,6 @@ MuonAssociatorByHitsHelper::IndexAssociation MuonAssociatorByHitsHelper::associa int n_tracker_recounted_simhits = 0; int n_muon_simhits = 0; int n_global_simhits = 0; - // std::vector tphits; int n_tracker_selected_simhits = 0; int n_muon_selected_simhits = 0; @@ -646,70 +646,6 @@ MuonAssociatorByHitsHelper::IndexAssociation MuonAssociatorByHitsHelper::associa continue; // if this TP shares no hits with the current reco::Track // loop over - // This does not work with the new TP interface - /* - for(std::vector::const_iterator TPhit = - trpart->pSimHit_begin(); TPhit != trpart->pSimHit_end(); TPhit++) { - DetId dId = DetId(TPhit->detUnitId()); - DetId::Detector detector = dId.det(); - - if (detector == DetId::Tracker) { - n_tracker_simhits++; - - unsigned int subdetId = static_cast(dId.subdetId()); - if (!UsePixels && (subdetId==PixelSubdetector::PixelBarrel || - subdetId==PixelSubdetector::PixelEndcap) ) continue; - - SiStripDetId* stripDetId = 0; - if (subdetId==SiStripDetId::TIB||subdetId==SiStripDetId::TOB|| - subdetId==SiStripDetId::TID||subdetId==SiStripDetId::TEC) - stripDetId= new SiStripDetId(dId); - - bool newhit = true; - for(std::vector::const_iterator TPhitOK = tphits.begin(); - TPhitOK != tphits.end(); TPhitOK++) { DetId dIdOK = - DetId(TPhitOK->detUnitId()); - //no grouped, no splitting - if (!UseGrouped && !UseSplitting) - if (tTopo->layer(dId)==tTopo->layer(dIdOK) && - dId.subdetId()==dIdOK.subdetId()) newhit = false; - //no grouped, splitting - if (!UseGrouped && UseSplitting) - if (tTopo->layer(dId)==tTopo->layer(dIdOK) && - dId.subdetId()==dIdOK.subdetId() && - (stripDetId==0 || - stripDetId->partnerDetId()!=dIdOK.rawId())) newhit = false; - //grouped, no splitting - if (UseGrouped && !UseSplitting) - if ( tTopo->layer(dId)== tTopo->layer(dIdOK) && - dId.subdetId()==dIdOK.subdetId() && - stripDetId!=0 && stripDetId->partnerDetId()==dIdOK.rawId()) - newhit = false; - //grouped, splitting - if (UseGrouped && UseSplitting) - newhit = true; - } - if (newhit) { - tphits.push_back(*TPhit); - } - delete stripDetId; - } - else if (detector == DetId::Muon) { - n_muon_simhits++; - - // discard BAD CSC chambers (ME4/2) from hit counting - if (dId.subdetId() == MuonSubdetId::CSC) { - if (csctruth.cscBadChambers->isInBadChamber(CSCDetId(dId))) { - // edm::LogVerbatim("MuonAssociatorByHitsHelper")<<"This PSimHit - is in a BAD CSC chamber, CSCDetId = "< TPCollectionHeff; - event.getByToken(tp_effic_Token, TPCollectionHeff); - TrackingParticleCollection const& tPCeff = *(TPCollectionHeff.product()); - - edm::Handle TPCollectionHfake; - event.getByToken(tp_fake_Token, TPCollectionHfake); + TrackingParticleRefVector TPrefV; + const TrackingParticleRefVector* ptr_TPrefV = nullptr; + edm::Handle TPCollection_H; + edm::Handle TPCollectionRefVector_H; + + if (label_tp_refvector) { + event.getByToken(tp_refvector_Token, TPCollectionRefVector_H); + ptr_TPrefV = TPCollectionRefVector_H.product(); + } else { + event.getByToken(tp_Token, TPCollection_H); + size_t nTP = TPCollection_H->size(); + for (size_t i = 0; i < nTP; ++i) { + TPrefV.push_back(TrackingParticleRef(TPCollection_H, i)); + } + ptr_TPrefV = &TPrefV; + } + TrackingParticleRefVector const& tPC = *ptr_TPrefV; edm::Handle recoBeamSpotHandle; event.getByToken(bsSrc_Token, recoBeamSpotHandle); @@ -451,10 +462,10 @@ void MuonTrackValidator::analyze(const edm::Event& event, const edm::EventSetup& LogTrace("MuonTrackValidator") << "Calling associateRecoToSim method" << "\n"; - recSimColl = associator[ww]->associateRecoToSim(trackCollection, TPCollectionHfake); + recSimColl = associator[ww]->associateRecoToSim(trackCollection, TPCollection_H); LogTrace("MuonTrackValidator") << "Calling associateSimToReco method" << "\n"; - simRecColl = associator[ww]->associateSimToReco(trackCollection, TPCollectionHeff); + simRecColl = associator[ww]->associateSimToReco(trackCollection, TPCollection_H); } else { edm::LogVerbatim("MuonTrackValidator") << "Analyzing " << label[www].process() << ":" << label[www].label() << ":" << label[www].instance() @@ -474,16 +485,17 @@ void MuonTrackValidator::analyze(const edm::Event& event, const edm::EventSetup& // //fill simulation histograms // - edm::LogVerbatim("MuonTrackValidator") << "\n# of TrackingParticles: " << tPCeff.size() << "\n"; + edm::LogVerbatim("MuonTrackValidator") << "\n# of TrackingParticles: " << tPC.size() << "\n"; int ats = 0; int st = 0; - for (TrackingParticleCollection::size_type i = 0; i < tPCeff.size(); i++) { + + for (size_t i = 0; i < tPC.size(); i++) { bool TP_is_matched = false; bool isChargeOK = true; double quality = 0.; - TrackingParticleRef tpr(TPCollectionHeff, i); - TrackingParticle* tp = const_cast(tpr.get()); + const TrackingParticleRef& tpr = tPC[i]; + const TrackingParticle& tp = *tpr; TrackingParticle::Vector momentumTP; TrackingParticle::Point vertexTP; @@ -494,10 +506,10 @@ void MuonTrackValidator::analyze(const edm::Event& event, const edm::EventSetup& //and the impact parameters w.r.t. PCA if (parametersDefiner == "LhcParametersDefinerForTP") { LogTrace("MuonTrackValidator") << "TrackingParticle " << i; - if (!tpSelector(*tp)) + if (!tpSelector(tp)) continue; - momentumTP = tp->momentum(); - vertexTP = tp->vertex(); + momentumTP = tp.momentum(); + vertexTP = tp.vertex(); TrackingParticle::Vector momentum = Lhc_parametersDefinerTP->momentum(event, setup, tpr); TrackingParticle::Point vertex = Lhc_parametersDefinerTP->vertex(event, setup, tpr); dxySim = TrackingParticleIP::dxy(vertex, momentum, bs.position()); @@ -513,10 +525,22 @@ void MuonTrackValidator::analyze(const edm::Event& event, const edm::EventSetup& dxySim = TrackingParticleIP::dxy(vertexTP, momentumTP, bs.position()); dzSim = TrackingParticleIP::dz(vertexTP, momentumTP, bs.position()); } - edm::LogVerbatim("MuonTrackValidator") << "--------------------Selected TrackingParticle #" << tpr.key(); + + // Number of counted SimHits depend on the selection of tracker and muon detectors (via cfg parameters) + int nSimHits = 0; + if (usetracker && usemuon) { + nSimHits = tpr.get()->numberOfHits(); + } else if (!usetracker && usemuon) { + nSimHits = tpr.get()->numberOfHits() - tpr.get()->numberOfTrackerHits(); + } else if (usetracker && !usemuon) { + nSimHits = tpr.get()->numberOfTrackerHits(); + } + + edm::LogVerbatim("MuonTrackValidator") << "--------------------Selected TrackingParticle #" << tpr.key() + << " (N counted simhits = " << nSimHits << ")"; edm::LogVerbatim("MuonTrackValidator") << "momentumTP: pt = " << sqrt(momentumTP.perp2()) << ", pz = " << momentumTP.z() - << ", \t vertexTP: radius = " << sqrt(vertexTP.perp2()) << ", z = " << vertexTP.z() << "\n"; + << ", \t vertexTP: radius = " << sqrt(vertexTP.perp2()) << ", z = " << vertexTP.z(); st++; double TPeta = momentumTP.eta(); @@ -527,33 +551,19 @@ void MuonTrackValidator::analyze(const edm::Event& event, const edm::EventSetup& double TPrpos = sqrt(vertexTP.perp2()); double TPzpos = vertexTP.z(); - // Number of counted SimHits depend on the selection of tracker and muon detectors (via cfg parameters) - int nSimHits = 0; - if (usetracker && usemuon) { - nSimHits = tpr.get()->numberOfHits(); - } else if (!usetracker && usemuon) { - nSimHits = tpr.get()->numberOfHits() - tpr.get()->numberOfTrackerHits(); - } else if (usetracker && !usemuon) { - nSimHits = tpr.get()->numberOfTrackerHits(); - } - edm::LogVerbatim("MuonTrackValidator") << "\t N simhits = " << nSimHits << "\n"; - int assoc_recoTrack_NValidHits = 0; if (simRecColl.find(tpr) != simRecColl.end()) { auto const& rt = simRecColl[tpr]; if (!rt.empty()) { RefToBase assoc_recoTrack = rt.begin()->first; - edm::LogVerbatim("MuonTrackValidator") - << "-----------------------------associated Track #" << assoc_recoTrack.key(); TP_is_matched = true; ats++; if (assoc_recoTrack->charge() != tpr->charge()) isChargeOK = false; quality = rt.begin()->second; assoc_recoTrack_NValidHits = assoc_recoTrack->numberOfValidHits(); - edm::LogVerbatim("MuonTrackValidator") - << "TrackingParticle #" << tpr.key() << " with pt=" << sqrt(momentumTP.perp2()) - << " associated with quality:" << quality << "\n"; + edm::LogVerbatim("MuonTrackValidator") << "-----------------------------associated to Track #" + << assoc_recoTrack.key() << " with quality:" << quality << "\n"; } } else { edm::LogVerbatim("MuonTrackValidator") @@ -564,7 +574,6 @@ void MuonTrackValidator::analyze(const edm::Event& event, const edm::EventSetup& } // histos for efficiency vs eta - fillPlotNoFlow(h_simuleta[w], xTPeta); if (TP_is_matched) { fillPlotNoFlow(h_assoceta[w], xTPeta); @@ -632,7 +641,7 @@ void MuonTrackValidator::analyze(const edm::Event& event, const edm::EventSetup& fillPlotNoFlow(h_misidpu[w], PU_NumInteractions); } - } // End for (TrackingParticleCollection::size_type i=0; i track(trackCollection, i); + int nRecHits = track->numberOfValidHits(); rT++; std::vector > tp; @@ -654,7 +664,8 @@ void MuonTrackValidator::analyze(const edm::Event& event, const edm::EventSetup& // new logic (bidirectional) if (BiDirectional_RecoToSim_association) { - edm::LogVerbatim("MuonTrackValidator") << "----------------------------------------Track #" << track.key(); + edm::LogVerbatim("MuonTrackValidator") << "----------------------------------------Track #" << track.key() + << " (N valid rechits = " << nRecHits << ")"; if (recSimColl.find(track) != recSimColl.end()) { tp = recSimColl[track]; @@ -665,16 +676,15 @@ void MuonTrackValidator::analyze(const edm::Event& event, const edm::EventSetup& auto const& assoc_track_checkback = simRecColl[tpr].begin()->first; if (assoc_track_checkback.key() == track.key()) { - edm::LogVerbatim("MuonTrackValidator") - << "------------------associated TrackingParticle #" << tpr.key(); Track_is_matched = true; at++; if (track->charge() != tpr->charge()) isChargeOK = false; double Purity = tp.begin()->second; double Quality = simRecColl[tpr].begin()->second; - edm::LogVerbatim("MuonTrackValidator") << "reco::Track #" << track.key() << " with pt=" << track->pt() - << " associated with purity:" << Purity << "\n"; + edm::LogVerbatim("MuonTrackValidator") + << "with pt=" << track->pt() << " associated with purity:" << Purity << " to TrackingParticle #" + << tpr.key() << "\n"; if (MABH) h_PurityVsQuality[w]->Fill(Quality, Purity); } @@ -683,9 +693,9 @@ void MuonTrackValidator::analyze(const edm::Event& event, const edm::EventSetup& } if (!Track_is_matched) - edm::LogVerbatim("MuonTrackValidator") << "reco::Track #" << track.key() << " with pt=" << track->pt() - << " NOT associated to any TrackingParticle" - << "\n"; + edm::LogVerbatim("MuonTrackValidator") + << "with pt=" << track->pt() << " NOT associated to any TrackingParticle" + << "\n"; } // old logic, valid for cosmics 2-legs reco (bugged for collision scenario) else { @@ -707,10 +717,6 @@ void MuonTrackValidator::analyze(const edm::Event& event, const edm::EventSetup& } } - // - int nRecHits = track->numberOfValidHits(); - edm::LogVerbatim("MuonTrackValidator") << "\t N valid rechits = " << nRecHits << "\n"; - double etaRec = track->eta(); double xetaRec = getEta(etaRec); @@ -910,36 +916,36 @@ void MuonTrackValidator::analyze(const edm::Event& event, const edm::EventSetup& double contrib_phi = phiPull * phiPull / 5; double assoChi2 = contrib_Qoverp + contrib_dxy + contrib_dz + contrib_theta + contrib_phi; - edm::LogVerbatim("MuonTrackValidator") << "normalized Chi2 (track 5-dofs matching) = " << assoChi2 << "\n" - << "\t contrib_Qoverp = " << contrib_Qoverp << "\n" - << "\t contrib_theta = " << contrib_theta << "\n" - << "\t contrib_phi = " << contrib_phi << "\n" - << "\t contrib_dxy = " << contrib_dxy << "\n" - << "\t contrib_dz = " << contrib_dz << "\n"; - - edm::LogVerbatim("MuonTrackValidator") << "ptRec = " << ptRec << "\n" - << "etaRec = " << etaRec << "\n" - << "qoverpRec = " << qoverpRec << "\n" - << "thetaRec = " << thetaRec << "\n" - << "phiRec = " << phiRec << "\n" - << "dxyRec = " << dxyRec << "\n" - << "dzRec = " << dzRec << "\n" - << "" - << "\n" - << "qoverpError = " << qoverpError << "\n" - << "thetaError = " << thetaError << "\n" - << "phiError = " << phiError << "\n" - << "dxyError = " << dxyError << "\n" - << "dzError = " << dzError << "\n" - << "" - << "\n" - << "ptSim = " << ptSim << "\n" - << "etaSim = " << etaSim << "\n" - << "qoverpSim = " << qoverpSim << "\n" - << "thetaSim = " << thetaSim << "\n" - << "phiSim = " << phiSim << "\n" - << "dxySim = " << dxySim << "\n" - << "dzSim = " << dzSim << "\n"; + LogTrace("MuonTrackValidator") << "normalized Chi2 (track 5-dofs matching) = " << assoChi2 << "\n" + << "\t contrib_Qoverp = " << contrib_Qoverp << "\n" + << "\t contrib_theta = " << contrib_theta << "\n" + << "\t contrib_phi = " << contrib_phi << "\n" + << "\t contrib_dxy = " << contrib_dxy << "\n" + << "\t contrib_dz = " << contrib_dz << "\n"; + + LogTrace("MuonTrackValidator") << "ptRec = " << ptRec << "\n" + << "etaRec = " << etaRec << "\n" + << "qoverpRec = " << qoverpRec << "\n" + << "thetaRec = " << thetaRec << "\n" + << "phiRec = " << phiRec << "\n" + << "dxyRec = " << dxyRec << "\n" + << "dzRec = " << dzRec << "\n" + << "" + << "\n" + << "qoverpError = " << qoverpError << "\n" + << "thetaError = " << thetaError << "\n" + << "phiError = " << phiError << "\n" + << "dxyError = " << dxyError << "\n" + << "dzError = " << dzError << "\n" + << "" + << "\n" + << "ptSim = " << ptSim << "\n" + << "etaSim = " << etaSim << "\n" + << "qoverpSim = " << qoverpSim << "\n" + << "thetaSim = " << thetaSim << "\n" + << "phiSim = " << phiSim << "\n" + << "dxySim = " << dxySim << "\n" + << "dzSim = " << dzSim << "\n"; } // End of for(edm::View::size_type i=0; iFill(at); diff --git a/Validation/RecoMuon/plugins/MuonTrackValidator.h b/Validation/RecoMuon/plugins/MuonTrackValidator.h index 03e52419af9f0..d23f98f022cb4 100644 --- a/Validation/RecoMuon/plugins/MuonTrackValidator.h +++ b/Validation/RecoMuon/plugins/MuonTrackValidator.h @@ -53,8 +53,10 @@ class MuonTrackValidator : public DQMEDAnalyzer, protected MuonTrackValidatorBas // Declare consumes (also for the base class) bsSrc_Token = consumes(bsSrc); - tp_effic_Token = consumes(label_tp_effic); - tp_fake_Token = consumes(label_tp_fake); + if (label_tp_refvector) + tp_refvector_Token = consumes(label_tp); + else + tp_Token = consumes(label_tp); pileupinfo_Token = consumes >(label_pileupinfo); for (unsigned int www = 0; www < label.size(); www++) { track_Collection_Token.push_back(consumes >(label[www])); @@ -96,33 +98,42 @@ class MuonTrackValidator : public DQMEDAnalyzer, protected MuonTrackValidatorBas std::string recoTracksInstance = label[www].instance(); // tracks with hits only on tracker - if (recoTracksLabel == "generalTracks" || (recoTracksLabel.find("cutsRecoTracks") != std::string::npos) || - recoTracksLabel == "ctfWithMaterialTracksP5LHCNavigation" || recoTracksLabel == "hltL3TkTracksFromL2" || - (recoTracksLabel == "hltL3Muons" && recoTracksInstance == "L2Seeded")) { + if (recoTracksLabel == "generalTracks" || recoTracksLabel == "probeTracks" || + recoTracksLabel == "displacedTracks" || recoTracksLabel == "extractGemMuons" || + recoTracksLabel == "extractMe0Muons" || recoTracksLabel == "ctfWithMaterialTracksP5LHCNavigation" || + recoTracksLabel == "ctfWithMaterialTracksP5" || + recoTracksLabel == "hltIterL3OIMuonTrackSelectionHighPurity" || recoTracksLabel == "hltIterL3MuonMerged" || + recoTracksLabel == "hltIterL3MuonAndMuonFromL1Merged") { if (usemuon) { edm::LogWarning("MuonTrackValidator") << "\n*** WARNING : inconsistent input tracksTag = " << label[www] << "\n with usemuon == true" - << "\n ---> please change to usemuon == false "; + << "\n ---> resetting to usemuon == false "; + usemuon = false; } if (!usetracker) { edm::LogWarning("MuonTrackValidator") << "\n*** WARNING : inconsistent input tracksTag = " << label[www] << "\n with usetracker == false" - << "\n ---> please change to usetracker == true "; + << "\n ---> resetting to usetracker == true "; + usetracker = true; } } // tracks with hits only on muon detectors - else if (recoTracksLabel == "standAloneMuons" || recoTracksLabel == "standAloneSETMuons" || - recoTracksLabel == "cosmicMuons" || recoTracksLabel == "hltL2Muons") { + else if (recoTracksLabel == "seedsOfSTAmuons" || recoTracksLabel == "standAloneMuons" || + recoTracksLabel == "seedsOfDisplacedSTAmuons" || recoTracksLabel == "displacedStandAloneMuons" || + recoTracksLabel == "refittedStandAloneMuons" || recoTracksLabel == "cosmicMuons" || + recoTracksLabel == "cosmicMuons1Leg" || recoTracksLabel == "hltL2Muons") { if (usetracker) { edm::LogWarning("MuonTrackValidator") << "\n*** WARNING : inconsistent input tracksTag = " << label[www] << "\n with usetracker == true" - << "\n ---> please change to usetracker == false "; + << "\n ---> resetting to usetracker == false "; + usetracker = false; } if (!usemuon) { edm::LogWarning("MuonTrackValidator") << "\n*** WARNING : inconsistent input tracksTag = " << label[www] << "\n with usemuon == false" - << "\n ---> please change to usemuon == true "; + << "\n ---> resetting to usemuon == true "; + usemuon = true; } } @@ -132,12 +143,7 @@ class MuonTrackValidator : public DQMEDAnalyzer, protected MuonTrackValidatorBas /// Destructor ~MuonTrackValidator() override {} - /// Method called before the event loop - // void beginRun(edm::Run const&, edm::EventSetup const&); - /// Method called once per event void analyze(const edm::Event&, const edm::EventSetup&) override; - /// Method called at the end of the event loop - // void dqmEndRun(edm::Run const&, edm::EventSetup const&) override; void bookHistograms(DQMEDAnalyzer::DQMStore::IBooker&, edm::Run const&, edm::EventSetup const&) override; private: diff --git a/Validation/RecoMuon/plugins/MuonTrackValidatorBase.h b/Validation/RecoMuon/plugins/MuonTrackValidatorBase.h index fa396dc2af7e3..d33ba31048fcf 100644 --- a/Validation/RecoMuon/plugins/MuonTrackValidatorBase.h +++ b/Validation/RecoMuon/plugins/MuonTrackValidatorBase.h @@ -42,8 +42,10 @@ class MuonTrackValidatorBase { /// Constructor MuonTrackValidatorBase(const edm::ParameterSet& pset, edm::ConsumesCollector iC) : MuonTrackValidatorBase(pset) { bsSrc_Token = iC.consumes(bsSrc); - tp_effic_Token = iC.consumes(label_tp_effic); - tp_fake_Token = iC.consumes(label_tp_fake); + if (label_tp_refvector) + tp_refvector_Token = iC.consumes(label_tp); + else + tp_Token = iC.consumes(label_tp); pileupinfo_Token = iC.consumes >(label_pileupinfo); for (unsigned int www = 0; www < label.size(); www++) { track_Collection_Token[www] = iC.consumes >(label[www]); @@ -53,8 +55,8 @@ class MuonTrackValidatorBase { MuonTrackValidatorBase(const edm::ParameterSet& pset) : label(pset.getParameter >("label")), bsSrc(pset.getParameter("beamSpot")), - label_tp_effic(pset.getParameter("label_tp_effic")), - label_tp_fake(pset.getParameter("label_tp_fake")), + label_tp(pset.getParameter("label_tp")), + label_tp_refvector(pset.getParameter("label_tp_refvector")), label_pileupinfo(pset.getParameter("label_pileupinfo")), associators(pset.getParameter >("associators")), out(pset.getParameter("outputFile")), @@ -205,16 +207,16 @@ class MuonTrackValidatorBase { protected: std::vector label; edm::InputTag bsSrc; - edm::InputTag label_tp_effic; - edm::InputTag label_tp_fake; + edm::InputTag label_tp; + bool label_tp_refvector; edm::InputTag label_pileupinfo; std::vector associators; std::string out; std::string parametersDefiner; std::vector > > track_Collection_Token; edm::EDGetTokenT bsSrc_Token; - edm::EDGetTokenT tp_effic_Token; - edm::EDGetTokenT tp_fake_Token; + edm::EDGetTokenT tp_Token; + edm::EDGetTokenT tp_refvector_Token; edm::EDGetTokenT > pileupinfo_Token; edm::ESHandle theMF; diff --git a/Validation/RecoMuon/python/MuonTrackValidator_cfi.py b/Validation/RecoMuon/python/MuonTrackValidator_cfi.py index 5f7f879c169fb..4785a51f4cb74 100644 --- a/Validation/RecoMuon/python/MuonTrackValidator_cfi.py +++ b/Validation/RecoMuon/python/MuonTrackValidator_cfi.py @@ -10,8 +10,8 @@ # define the TrackingParticleSelector for evaluation of efficiency muonTPSelector = cms.PSet(muonTPSet), # input TrackingParticle collections - label_tp_effic = cms.InputTag("mix","MergedTrackTruth"), - label_tp_fake = cms.InputTag("mix","MergedTrackTruth"), + label_tp = cms.InputTag("mix","MergedTrackTruth"), + label_tp_refvector = cms.bool(False), label_pileupinfo = cms.InputTag("addPileupInfo"), # # input reco::Track collection @@ -59,6 +59,5 @@ from Configuration.ProcessModifiers.premix_stage2_cff import premix_stage2 premix_stage2.toModify(muonTrackValidator, - label_tp_effic = "mixData:MergedTrackTruth", - label_tp_fake = "mixData:MergedTrackTruth", + label_tp = "mixData:MergedTrackTruth" ) diff --git a/Validation/RecoMuon/python/RecoMuonValidator_cff.py b/Validation/RecoMuon/python/RecoMuonValidator_cff.py index 847bbf38c3dae..e7b73aed865d7 100644 --- a/Validation/RecoMuon/python/RecoMuonValidator_cff.py +++ b/Validation/RecoMuon/python/RecoMuonValidator_cff.py @@ -7,7 +7,6 @@ from RecoMuon.TrackingTools.MuonServiceProxy_cff import * from Validation.RecoMuon.RecoMuonValidator_cfi import * # -##import SimGeneral.MixingModule.mixNoPU_cfi from SimMuon.MCTruth.muonAssociatorByHitsNoSimHitsHelper_cfi import * from SimMuon.MCTruth.MuonAssociatorByHits_cfi import muonAssociatorByHitsCommonParameters @@ -20,17 +19,9 @@ recoMuonVMuAssoc_trk.muAssocLabel = 'muonAssociatorByHitsNoSimHitsHelperTrk' recoMuonVMuAssoc_trk.trackType = 'inner' recoMuonVMuAssoc_trk.selection = "isTrackerMuon" - -#tracker and PF -muonAssociatorByHitsNoSimHitsHelperTrkPF = muonAssociatorByHitsNoSimHitsHelper.clone() -muonAssociatorByHitsNoSimHitsHelperTrkPF.UseTracker = True -muonAssociatorByHitsNoSimHitsHelperTrkPF.UseMuon = False -recoMuonVMuAssoc_trkPF = recoMuonValidator.clone() -recoMuonVMuAssoc_trkPF.subDir = 'Muons/RecoMuonV/RecoMuon_MuonAssoc_TrkPF' -recoMuonVMuAssoc_trkPF.usePFMuon = True -recoMuonVMuAssoc_trkPF.muAssocLabel = 'muonAssociatorByHitsNoSimHitsHelperTrkPF' -recoMuonVMuAssoc_trkPF.trackType = 'inner' -recoMuonVMuAssoc_trkPF.selection = "isTrackerMuon & isPFMuon" +recoMuonVMuAssoc_trk.simLabel = ("TPmu") +recoMuonVMuAssoc_trk.tpRefVector = True +recoMuonVMuAssoc_trk.tpSelector.src = ("TPmu") #standalone muonAssociatorByHitsNoSimHitsHelperStandalone = muonAssociatorByHitsNoSimHitsHelper.clone() @@ -41,27 +32,9 @@ recoMuonVMuAssoc_sta.muAssocLabel = 'muonAssociatorByHitsNoSimHitsHelperStandalone' recoMuonVMuAssoc_sta.trackType = 'outer' recoMuonVMuAssoc_sta.selection = "isStandAloneMuon" - -#seed of StandAlone -muonAssociatorByHitsNoSimHitsHelperSeedStandalone = muonAssociatorByHitsNoSimHitsHelper.clone() -muonAssociatorByHitsNoSimHitsHelperSeedStandalone.UseTracker = False -muonAssociatorByHitsNoSimHitsHelperSeedStandalone.UseMuon = True -recoMuonVMuAssoc_seedSta = recoMuonValidator.clone() -recoMuonVMuAssoc_seedSta.subDir = 'Muons/RecoMuonV/RecoMuon_MuonAssoc_SeedSta' -recoMuonVMuAssoc_seedSta.muAssocLabel = 'muonAssociatorByHitsNoSimHitsHelperStandalone' -recoMuonVMuAssoc_seedSta.trackType = 'outer' -recoMuonVMuAssoc_seedSta.selection = "" - -#standalone and PF -muonAssociatorByHitsNoSimHitsHelperStandalonePF = muonAssociatorByHitsNoSimHitsHelper.clone() -muonAssociatorByHitsNoSimHitsHelperStandalonePF.UseTracker = False -muonAssociatorByHitsNoSimHitsHelperStandalonePF.UseMuon = True -recoMuonVMuAssoc_staPF = recoMuonValidator.clone() -recoMuonVMuAssoc_staPF.subDir = 'Muons/RecoMuonV/RecoMuon_MuonAssoc_StaPF' -recoMuonVMuAssoc_staPF.usePFMuon = True -recoMuonVMuAssoc_staPF.muAssocLabel = 'muonAssociatorByHitsNoSimHitsHelperStandalonePF' -recoMuonVMuAssoc_staPF.trackType = 'outer' -recoMuonVMuAssoc_staPF.selection = "isStandAloneMuon & isPFMuon" +recoMuonVMuAssoc_sta.simLabel = ("TPmu") +recoMuonVMuAssoc_sta.tpRefVector = True +recoMuonVMuAssoc_sta.tpSelector.src = ("TPmu") #global muonAssociatorByHitsNoSimHitsHelperGlobal = muonAssociatorByHitsNoSimHitsHelper.clone() @@ -72,17 +45,9 @@ recoMuonVMuAssoc_glb.muAssocLabel = 'muonAssociatorByHitsNoSimHitsHelperGlobal' recoMuonVMuAssoc_glb.trackType = 'global' recoMuonVMuAssoc_glb.selection = "isGlobalMuon" - -#global and PF -muonAssociatorByHitsNoSimHitsHelperGlobalPF = muonAssociatorByHitsNoSimHitsHelper.clone() -muonAssociatorByHitsNoSimHitsHelperGlobalPF.UseTracker = True -muonAssociatorByHitsNoSimHitsHelperGlobalPF.UseMuon = True -recoMuonVMuAssoc_glbPF = recoMuonValidator.clone() -recoMuonVMuAssoc_glbPF.subDir = 'Muons/RecoMuonV/RecoMuon_MuonAssoc_GlbPF' -recoMuonVMuAssoc_glbPF.usePFMuon = True -recoMuonVMuAssoc_glbPF.muAssocLabel = 'muonAssociatorByHitsNoSimHitsHelperGlobalPF' -recoMuonVMuAssoc_glbPF.trackType = 'global' -recoMuonVMuAssoc_glbPF.selection = "isGlobalMuon & isPFMuon" +recoMuonVMuAssoc_glb.simLabel = ("TPmu") +recoMuonVMuAssoc_glb.tpRefVector = True +recoMuonVMuAssoc_glb.tpSelector.src = ("TPmu") #tight muonAssociatorByHitsNoSimHitsHelperTight = muonAssociatorByHitsNoSimHitsHelper.clone() @@ -96,6 +61,9 @@ recoMuonVMuAssoc_tgt.wantTightMuon = True recoMuonVMuAssoc_tgt.beamSpot = 'offlineBeamSpot' recoMuonVMuAssoc_tgt.primaryVertex = 'offlinePrimaryVertices' +recoMuonVMuAssoc_tgt.simLabel = ("TPmu") +recoMuonVMuAssoc_tgt.tpRefVector = True +recoMuonVMuAssoc_tgt.tpSelector.src = ("TPmu") ########################################################################## # Muon validation sequence using RecoMuonValidator @@ -106,9 +74,61 @@ +muonAssociatorByHitsNoSimHitsHelperStandalone +recoMuonVMuAssoc_sta +muonAssociatorByHitsNoSimHitsHelperGlobal +recoMuonVMuAssoc_glb +muonAssociatorByHitsNoSimHitsHelperTight +recoMuonVMuAssoc_tgt - # - # +muonAssociatorByHitsNoSimHitsHelperTrkPF +recoMuonVMuAssoc_trkPF - # +muonAssociatorByHitsNoSimHitsHelperStandalonePF +recoMuonVMuAssoc_staPF - # +muonAssociatorByHitsNoSimHitsHelperGlobalPF +recoMuonVMuAssoc_glbPF ) +# not used +# +#tracker and PF +#muonAssociatorByHitsNoSimHitsHelperTrkPF = muonAssociatorByHitsNoSimHitsHelper.clone() +#muonAssociatorByHitsNoSimHitsHelperTrkPF.UseTracker = True +#muonAssociatorByHitsNoSimHitsHelperTrkPF.UseMuon = False +#recoMuonVMuAssoc_trkPF = recoMuonValidator.clone() +#recoMuonVMuAssoc_trkPF.subDir = 'Muons/RecoMuonV/RecoMuon_MuonAssoc_TrkPF' +#recoMuonVMuAssoc_trkPF.usePFMuon = True +#recoMuonVMuAssoc_trkPF.muAssocLabel = 'muonAssociatorByHitsNoSimHitsHelperTrkPF' +#recoMuonVMuAssoc_trkPF.trackType = 'inner' +#recoMuonVMuAssoc_trkPF.selection = "isTrackerMuon & isPFMuon" +# +#seed of StandAlone +#muonAssociatorByHitsNoSimHitsHelperSeedStandalone = muonAssociatorByHitsNoSimHitsHelper.clone() +#muonAssociatorByHitsNoSimHitsHelperSeedStandalone.UseTracker = False +#muonAssociatorByHitsNoSimHitsHelperSeedStandalone.UseMuon = True +#recoMuonVMuAssoc_seedSta = recoMuonValidator.clone() +#recoMuonVMuAssoc_seedSta.subDir = 'Muons/RecoMuonV/RecoMuon_MuonAssoc_SeedSta' +#recoMuonVMuAssoc_seedSta.muAssocLabel = 'muonAssociatorByHitsNoSimHitsHelperStandalone' +#recoMuonVMuAssoc_seedSta.trackType = 'outer' +#recoMuonVMuAssoc_seedSta.selection = "" +# +#standalone and PF +#muonAssociatorByHitsNoSimHitsHelperStandalonePF = muonAssociatorByHitsNoSimHitsHelper.clone() +#muonAssociatorByHitsNoSimHitsHelperStandalonePF.UseTracker = False +#muonAssociatorByHitsNoSimHitsHelperStandalonePF.UseMuon = True +#recoMuonVMuAssoc_staPF = recoMuonValidator.clone() +#recoMuonVMuAssoc_staPF.subDir = 'Muons/RecoMuonV/RecoMuon_MuonAssoc_StaPF' +#recoMuonVMuAssoc_staPF.usePFMuon = True +#recoMuonVMuAssoc_staPF.muAssocLabel = 'muonAssociatorByHitsNoSimHitsHelperStandalonePF' +#recoMuonVMuAssoc_staPF.trackType = 'outer' +#recoMuonVMuAssoc_staPF.selection = "isStandAloneMuon & isPFMuon" +# +#global and PF +#muonAssociatorByHitsNoSimHitsHelperGlobalPF = muonAssociatorByHitsNoSimHitsHelper.clone() +#muonAssociatorByHitsNoSimHitsHelperGlobalPF.UseTracker = True +#muonAssociatorByHitsNoSimHitsHelperGlobalPF.UseMuon = True +#recoMuonVMuAssoc_glbPF = recoMuonValidator.clone() +#recoMuonVMuAssoc_glbPF.subDir = 'Muons/RecoMuonV/RecoMuon_MuonAssoc_GlbPF' +#recoMuonVMuAssoc_glbPF.usePFMuon = True +#recoMuonVMuAssoc_glbPF.muAssocLabel = 'muonAssociatorByHitsNoSimHitsHelperGlobalPF' +#recoMuonVMuAssoc_glbPF.trackType = 'global' +#recoMuonVMuAssoc_glbPF.selection = "isGlobalMuon & isPFMuon" +# +#muonValidationRMV_seq = cms.Sequence( +# muonAssociatorByHitsNoSimHitsHelperTrk +recoMuonVMuAssoc_trk +# +muonAssociatorByHitsNoSimHitsHelperStandalone +recoMuonVMuAssoc_sta +# +muonAssociatorByHitsNoSimHitsHelperGlobal +recoMuonVMuAssoc_glb +# +muonAssociatorByHitsNoSimHitsHelperTight +recoMuonVMuAssoc_tgt +# +# +muonAssociatorByHitsNoSimHitsHelperTrkPF +recoMuonVMuAssoc_trkPF +# +muonAssociatorByHitsNoSimHitsHelperStandalonePF +recoMuonVMuAssoc_staPF +# +muonAssociatorByHitsNoSimHitsHelperGlobalPF +recoMuonVMuAssoc_glbPF +# ) +# diff --git a/Validation/RecoMuon/python/RecoMuonValidator_cfi.py b/Validation/RecoMuon/python/RecoMuonValidator_cfi.py index 5f0db2196dff6..392caeede8d82 100644 --- a/Validation/RecoMuon/python/RecoMuonValidator_cfi.py +++ b/Validation/RecoMuon/python/RecoMuonValidator_cfi.py @@ -10,6 +10,7 @@ usePFMuon = cms.untracked.bool(False), simLabel = cms.InputTag("mix","MergedTrackTruth"), + tpRefVector = cms.bool(False), muonLabel = cms.InputTag("muons"), muAssocLabel = cms.InputTag("muonAssociatorByHitsHelper"), diff --git a/Validation/RecoMuon/python/associators_cff.py b/Validation/RecoMuon/python/associators_cff.py index 3f12993f0a50e..ce553c1d4793b 100644 --- a/Validation/RecoMuon/python/associators_cff.py +++ b/Validation/RecoMuon/python/associators_cff.py @@ -28,19 +28,25 @@ # PurityCut_muon = cms.double(0.), # includeZeroHitMuons = cms.bool(True), # acceptOneStubMatchings = cms.bool(False), +# rejectBadGlobal = cms.bool(True), +# tpTag = cms.InputTag("mix","MergedTrackTruth") +# tpRefVector = cms.bool(False) ############################################## MABH.EfficiencyCut_track = 0.5 MABH.PurityCut_track = 0.75 MABH.EfficiencyCut_muon = 0.5 MABH.PurityCut_muon = 0.75 MABH.includeZeroHitMuons = False -################################################ +MABH.tpTag = ("TPmu") +MABH.tpRefVector = True +############################################## tpToTkMuonAssociation = MABH.clone() #tpToTkMuonAssociation.tracksTag = 'generalTracks' tpToTkMuonAssociation.tracksTag ='probeTracks' tpToTkMuonAssociation.UseTracker = True tpToTkMuonAssociation.UseMuon = False +tpToTkMuonAssociation.tpTag = ("TPtrack") tpToStaSeedAssociation = MABH.clone() tpToStaSeedAssociation.tracksTag = 'seedsOfSTAmuons' @@ -77,6 +83,7 @@ tpToDisplacedTrkMuonAssociation.tracksTag = 'displacedTracks' tpToDisplacedTrkMuonAssociation.UseTracker = True tpToDisplacedTrkMuonAssociation.UseMuon = False +tpToDisplacedTrkMuonAssociation.tpTag = ("TPtrack") tpToDisplacedStaSeedAssociation = MABH.clone() tpToDisplacedStaSeedAssociation.tracksTag = 'seedsOfDisplacedSTAmuons' @@ -111,6 +118,7 @@ tpToTevDytMuonAssociation.UseTracker = True tpToTevDytMuonAssociation.UseMuon = True tpToTevDytMuonAssociation.EfficiencyCut_muon = 0. +tpToTevDytMuonAssociation.rejectBadGlobal = False # tuneP (GlobalMuons with TuneP definition) tpToTunePMuonAssociation = MABH.clone() @@ -118,24 +126,31 @@ tpToTunePMuonAssociation.UseTracker = True tpToTunePMuonAssociation.UseMuon = True tpToTunePMuonAssociation.EfficiencyCut_muon = 0. +tpToTunePMuonAssociation.rejectBadGlobal = False # PFMuons tpToPFMuonAssociation = MABH.clone() tpToPFMuonAssociation.tracksTag = 'pfMuonTracks' tpToPFMuonAssociation.UseTracker = True tpToPFMuonAssociation.UseMuon = True +tpToPFMuonAssociation.tpTag = ("TPpfmu") tpToPFMuonAssociation.EfficiencyCut_muon = 0. +tpToPFMuonAssociation.rejectBadGlobal = False # all offline reco::Muons with loose cuts +# note in this case muons can be of any type: set UseTracker=UseMuon=true and rejectBadGlobal=false, +# then define the logic in the muon track producer, run beforehand. tpTorecoMuonMuonAssociation = MABH.clone() tpTorecoMuonMuonAssociation.tracksTag = 'recoMuonTracks' tpTorecoMuonMuonAssociation.UseTracker = True tpTorecoMuonMuonAssociation.UseMuon = True tpTorecoMuonMuonAssociation.EfficiencyCut_track = 0. -tpTorecoMuonMuonAssociation.PurityCut_track = 0. tpTorecoMuonMuonAssociation.EfficiencyCut_muon = 0. -tpTorecoMuonMuonAssociation.PurityCut_muon = 0. +# matching to a skimmed TP collection needs a purity cut to avoid pathological cases +#tpTorecoMuonMuonAssociation.PurityCut_track = 0. +#tpTorecoMuonMuonAssociation.PurityCut_muon = 0. tpTorecoMuonMuonAssociation.includeZeroHitMuons = True +tpTorecoMuonMuonAssociation.rejectBadGlobal = False # ME0Muons tpToME0MuonMuonAssociation = MABH.clone() @@ -152,14 +167,20 @@ # === HLT muon tracks # MABHhlt = SimMuon.MCTruth.MuonAssociatorByHits_cfi.muonAssociatorByHits.clone() +# DEFAULTS ################################### +# EfficiencyCut_track = cms.double(0.), # backup solution as UseGrouped/UseSplitting are always assumed to be true +# EfficiencyCut_muon = cms.double(0.), # | loose matching requests for triggering +# includeZeroHitMuons = cms.bool(True), # | +# acceptOneStubMatchings = cms.bool(False), +# rejectBadGlobal = cms.bool(True), +############################################## MABHhlt.PurityCut_track = 0.75 MABHhlt.PurityCut_muon = 0.75 MABHhlt.DTrechitTag = 'hltDt1DRecHits' MABHhlt.ignoreMissingTrackCollection = True -# N.B. for HLT these default settings are implicitly applied : -#MABHhlt.EfficiencyCut_track = 0. # backup solution as UseGrouped/UseSplitting are always assumed to be true -#MABHhlt.EfficiencyCut_muon = 0. # | loose matching requests for triggering -#MABHhlt.includeZeroHitMuons = True # | +MABHhlt.tpTag = ("TPmu") +MABHhlt.tpRefVector = True +############################################## tpToL2MuonAssociation = MABHhlt.clone() tpToL2MuonAssociation.tracksTag = 'hltL2Muons' @@ -195,33 +216,48 @@ tpToL3NoIDMuonAssociation.tracksTag = 'hltIterL3MuonsNoIDTracks' tpToL3NoIDMuonAssociation.UseTracker = True tpToL3NoIDMuonAssociation.UseMuon = True +tpToL3NoIDMuonAssociation.rejectBadGlobal = False tpToL3MuonAssociation = MABHhlt.clone() tpToL3MuonAssociation.tracksTag = 'hltIterL3MuonsTracks' tpToL3MuonAssociation.UseTracker = True tpToL3MuonAssociation.UseMuon = True +tpToL3MuonAssociation.rejectBadGlobal = False # === # # COSMICS reco +MABHcosmic = SimMuon.MCTruth.MuonAssociatorByHits_cfi.muonAssociatorByHits.clone() +# DEFAULTS ################################### +# acceptOneStubMatchings = cms.bool(False), +# rejectBadGlobal = cms.bool(True), +# tpTag = cms.InputTag("mix","MergedTrackTruth") +# tpRefVector = cms.bool(False) +############################################### +MABHcosmic.EfficiencyCut_track = 0.5 +MABHcosmic.PurityCut_track = 0.75 +MABHcosmic.EfficiencyCut_muon = 0.5 +MABHcosmic.PurityCut_muon = 0.75 +MABHcosmic.includeZeroHitMuons = False +################################################ # # 2-legs cosmics reco: simhits can be twice the reconstructed ones in any single leg # (Quality cut have to be set at 0.25, purity cuts can stay at default value 0.75) # T.B.D. upper and lower leg should be analyzed separately # -tpToTkCosmicSelMuonAssociation = MABH.clone() +tpToTkCosmicSelMuonAssociation = MABHcosmic.clone() tpToTkCosmicSelMuonAssociation.tracksTag = 'ctfWithMaterialTracksP5LHCNavigation' tpToTkCosmicSelMuonAssociation.UseTracker = True tpToTkCosmicSelMuonAssociation.UseMuon = False tpToTkCosmicSelMuonAssociation.EfficiencyCut_track = 0.25 -tpToStaCosmicSelMuonAssociation = MABH.clone() +tpToStaCosmicSelMuonAssociation = MABHcosmic.clone() tpToStaCosmicSelMuonAssociation.tracksTag = 'cosmicMuons' tpToStaCosmicSelMuonAssociation.UseTracker = False tpToStaCosmicSelMuonAssociation.UseMuon = True tpToStaCosmicSelMuonAssociation.EfficiencyCut_muon = 0.25 -tpToGlbCosmicSelMuonAssociation = MABH.clone() +tpToGlbCosmicSelMuonAssociation = MABHcosmic.clone() tpToGlbCosmicSelMuonAssociation.tracksTag = 'globalCosmicMuons' tpToGlbCosmicSelMuonAssociation.UseTracker = True tpToGlbCosmicSelMuonAssociation.UseMuon = True @@ -229,17 +265,17 @@ tpToGlbCosmicSelMuonAssociation.EfficiencyCut_muon = 0.25 # 1-leg cosmics reco -tpToTkCosmic1LegSelMuonAssociation = MABH.clone() +tpToTkCosmic1LegSelMuonAssociation = MABHcosmic.clone() tpToTkCosmic1LegSelMuonAssociation.tracksTag = 'ctfWithMaterialTracksP5' tpToTkCosmic1LegSelMuonAssociation.UseTracker = True tpToTkCosmic1LegSelMuonAssociation.UseMuon = False -tpToStaCosmic1LegSelMuonAssociation = MABH.clone() +tpToStaCosmic1LegSelMuonAssociation = MABHcosmic.clone() tpToStaCosmic1LegSelMuonAssociation.tracksTag = 'cosmicMuons1Leg' tpToStaCosmic1LegSelMuonAssociation.UseTracker = False tpToStaCosmic1LegSelMuonAssociation.UseMuon = True -tpToGlbCosmic1LegSelMuonAssociation = MABH.clone() +tpToGlbCosmic1LegSelMuonAssociation = MABHcosmic.clone() tpToGlbCosmic1LegSelMuonAssociation.tracksTag = 'globalCosmicMuons1Leg' tpToGlbCosmic1LegSelMuonAssociation.UseTracker = True tpToGlbCosmic1LegSelMuonAssociation.UseMuon = True diff --git a/Validation/RecoMuon/python/muonValidationHLT_cff.py b/Validation/RecoMuon/python/muonValidationHLT_cff.py index 7b135353f8a49..28a2470dc8355 100644 --- a/Validation/RecoMuon/python/muonValidationHLT_cff.py +++ b/Validation/RecoMuon/python/muonValidationHLT_cff.py @@ -4,70 +4,60 @@ from Validation.RecoMuon.track_selectors_cff import * from Validation.RecoMuon.associators_cff import * from Validation.RecoMuon.histoParameters_cff import * + import Validation.RecoMuon.MuonTrackValidator_cfi +MTVhlt = Validation.RecoMuon.MuonTrackValidator_cfi.muonTrackValidator.clone() +# DEFAULTS ################################### +# label_tp = cms.InputTag("mix","MergedTrackTruth"), +# label_tp_refvector = cms.bool(False), +# muonTPSelector = cms.PSet(muonTPSet), +############################################## +MTVhlt.label_tp = ("TPmu") +MTVhlt.label_tp_refvector = True +MTVhlt.muonTPSelector.src = ("TPmu") +MTVhlt.dirName = 'HLT/Muon/MuonTrack/' +#MTVhlt.beamSpot = 'hltOfflineBeamSpot' +MTVhlt.ignoremissingtrackcollection=True +################################################ -l2MuonMuTrackV = Validation.RecoMuon.MuonTrackValidator_cfi.muonTrackValidator.clone() +l2MuonMuTrackV = MTVhlt.clone() l2MuonMuTrackV.associatormap = 'tpToL2MuonAssociation' l2MuonMuTrackV.label = ('hltL2Muons',) -l2MuonMuTrackV.dirName = 'HLT/Muon/MuonTrack/' -#l2MuonMuTrackV.beamSpot = 'hltOfflineBeamSpot' -l2MuonMuTrackV.ignoremissingtrackcollection=True l2MuonMuTrackV.muonHistoParameters = staMuonHistoParameters -l2UpdMuonMuTrackV = Validation.RecoMuon.MuonTrackValidator_cfi.muonTrackValidator.clone() +l2UpdMuonMuTrackV = MTVhlt.clone() l2UpdMuonMuTrackV.associatormap = 'tpToL2UpdMuonAssociation' l2UpdMuonMuTrackV.label = ('hltL2Muons:UpdatedAtVtx',) -l2UpdMuonMuTrackV.dirName = 'HLT/Muon/MuonTrack/' -#l2UpdMuonMuTrackV.beamSpot = 'hltOfflineBeamSpot' -l2UpdMuonMuTrackV.ignoremissingtrackcollection=True l2UpdMuonMuTrackV.muonHistoParameters = staUpdMuonHistoParameters -l3OITkMuonMuTrackV = Validation.RecoMuon.MuonTrackValidator_cfi.muonTrackValidator.clone() +l3OITkMuonMuTrackV = MTVhlt.clone() l3OITkMuonMuTrackV.associatormap = 'tpToL3OITkMuonAssociation' l3OITkMuonMuTrackV.label = ('hltIterL3OIMuonTrackSelectionHighPurity:',) -l3OITkMuonMuTrackV.dirName = 'HLT/Muon/MuonTrack/' -#lOI3TkMuonMuTrackV.beamSpot = 'hltOfflineBeamSpot' -l3OITkMuonMuTrackV.ignoremissingtrackcollection=True l3OITkMuonMuTrackV.muonHistoParameters = trkMuonHistoParameters -l3TkMuonMuTrackV = Validation.RecoMuon.MuonTrackValidator_cfi.muonTrackValidator.clone() +l3TkMuonMuTrackV = MTVhlt.clone() l3TkMuonMuTrackV.associatormap = 'tpToL3TkMuonAssociation' l3TkMuonMuTrackV.label = ('hltIterL3MuonMerged:',) -l3TkMuonMuTrackV.dirName = 'HLT/Muon/MuonTrack/' -#l3TkMuonMuTrackV.beamSpot = 'hltOfflineBeamSpot' -l3TkMuonMuTrackV.ignoremissingtrackcollection=True l3TkMuonMuTrackV.muonHistoParameters = trkMuonHistoParameters -l3IOFromL1TkMuonMuTrackV = Validation.RecoMuon.MuonTrackValidator_cfi.muonTrackValidator.clone() +l3IOFromL1TkMuonMuTrackV = MTVhlt.clone() l3IOFromL1TkMuonMuTrackV.associatormap = 'tpToL3FromL1TkMuonAssociation' l3IOFromL1TkMuonMuTrackV.label = ('hltIterL3MuonAndMuonFromL1Merged:',) -l3IOFromL1TkMuonMuTrackV.dirName = 'HLT/Muon/MuonTrack/' -#lIOFromL13TkMuonMuTrackV.beamSpot = 'hltOfflineBeamSpot' -l3IOFromL1TkMuonMuTrackV.ignoremissingtrackcollection=True l3IOFromL1TkMuonMuTrackV.muonHistoParameters = trkMuonHistoParameters -l3GlbMuonMuTrackV = Validation.RecoMuon.MuonTrackValidator_cfi.muonTrackValidator.clone() +l3GlbMuonMuTrackV = MTVhlt.clone() l3GlbMuonMuTrackV.associatormap = 'tpToL3GlbMuonAssociation' l3GlbMuonMuTrackV.label = ('hltIterL3GlbMuon:',) -l3GlbMuonMuTrackV.dirName = 'HLT/Muon/MuonTrack/' -#lGlb3MuonMuTrackV.beamSpot = 'hltOfflineBeamSpot' -l3GlbMuonMuTrackV.ignoremissingtrackcollection=True l3GlbMuonMuTrackV.muonHistoParameters = glbMuonHistoParameters -l3NoIDMuonMuTrackV = Validation.RecoMuon.MuonTrackValidator_cfi.muonTrackValidator.clone() +l3NoIDMuonMuTrackV = MTVhlt.clone() l3NoIDMuonMuTrackV.associatormap = 'tpToL3NoIDMuonAssociation' l3NoIDMuonMuTrackV.label = ('hltIterL3MuonsNoIDTracks:',) -l3NoIDMuonMuTrackV.dirName = 'HLT/Muon/MuonTrack/' -#lNoID3MuonMuTrackV.beamSpot = 'hltOfflineBeamSpot' -l3NoIDMuonMuTrackV.ignoremissingtrackcollection=True l3NoIDMuonMuTrackV.muonHistoParameters = glbMuonHistoParameters -l3MuonMuTrackV = Validation.RecoMuon.MuonTrackValidator_cfi.muonTrackValidator.clone() +l3MuonMuTrackV = MTVhlt.clone() l3MuonMuTrackV.associatormap = 'tpToL3MuonAssociation' l3MuonMuTrackV.label = ('hltIterL3MuonsTracks:',) -l3MuonMuTrackV.dirName = 'HLT/Muon/MuonTrack/' -#l3MuonMuTrackV.beamSpot = 'hltOfflineBeamSpot' -l3MuonMuTrackV.ignoremissingtrackcollection=True l3MuonMuTrackV.muonHistoParameters = glbMuonHistoParameters # @@ -85,5 +75,6 @@ ) recoMuonValidationHLT_seq = cms.Sequence( + cms.SequencePlaceholder("TPmu") + muonValidationHLT_seq ) diff --git a/Validation/RecoMuon/python/muonValidation_cff.py b/Validation/RecoMuon/python/muonValidation_cff.py index 79d283bb38729..315e6b118c09c 100644 --- a/Validation/RecoMuon/python/muonValidation_cff.py +++ b/Validation/RecoMuon/python/muonValidation_cff.py @@ -7,174 +7,192 @@ from Validation.RecoMuon.track_selectors_cff import * from Validation.RecoMuon.associators_cff import * from Validation.RecoMuon.histoParameters_cff import * -import Validation.RecoMuon.MuonTrackValidator_cfi from SimTracker.TrackAssociation.LhcParametersDefinerForTP_cfi import * from SimTracker.TrackAssociation.CosmicParametersDefinerForTP_cfi import * from Validation.RecoMuon.RecoMuonValidator_cff import * -# quickTrackAssociatorByHits on probeTracks used as monitor wrt MuonAssociatorByHits - -trkMuonTrackVTrackAssoc = Validation.RecoMuon.MuonTrackValidator_cfi.muonTrackValidator.clone() +import Validation.RecoMuon.MuonTrackValidator_cfi +MTV = Validation.RecoMuon.MuonTrackValidator_cfi.muonTrackValidator.clone() +# DEFAULTS ################################### +# label_tp = cms.InputTag("mix","MergedTrackTruth"), +# label_tp_refvector = cms.bool(False), +# muonTPSelector = cms.PSet(muonTPSet), +############################################## +MTV.label_tp = ("TPmu") +MTV.label_tp_refvector = True +MTV.muonTPSelector.src = ("TPmu") +############################################## + +trkMuonTrackVTrackAssoc = MTV.clone() trkMuonTrackVTrackAssoc.associatormap = 'tpToTkmuTrackAssociation' trkMuonTrackVTrackAssoc.associators = ('trackAssociatorByHits',) #trkMuonTrackVTrackAssoc.label = ('generalTracks',) trkMuonTrackVTrackAssoc.label = ('probeTracks',) +trkMuonTrackVTrackAssoc.label_tp = ("TPtrack") +trkMuonTrackVTrackAssoc.muonTPSelector.src = ("TPtrack") trkMuonTrackVTrackAssoc.muonHistoParameters = trkMuonHistoParameters # MuonAssociatorByHits used for all track collections -trkProbeTrackVMuonAssoc = Validation.RecoMuon.MuonTrackValidator_cfi.muonTrackValidator.clone() +trkProbeTrackVMuonAssoc = MTV.clone() trkProbeTrackVMuonAssoc.associatormap = 'tpToTkMuonAssociation' #trkProbeTrackVMuonAssoc.label = ('generalTracks',) trkProbeTrackVMuonAssoc.label = ('probeTracks',) +trkProbeTrackVMuonAssoc.label_tp = ("TPtrack") +trkProbeTrackVMuonAssoc.muonTPSelector.src = ("TPtrack") trkProbeTrackVMuonAssoc.muonHistoParameters = trkMuonHistoParameters -staSeedTrackVMuonAssoc = Validation.RecoMuon.MuonTrackValidator_cfi.muonTrackValidator.clone() +staSeedTrackVMuonAssoc = MTV.clone() staSeedTrackVMuonAssoc.associatormap = 'tpToStaSeedAssociation' staSeedTrackVMuonAssoc.label = ('seedsOfSTAmuons',) staSeedTrackVMuonAssoc.muonHistoParameters = staSeedMuonHistoParameters -staMuonTrackVMuonAssoc = Validation.RecoMuon.MuonTrackValidator_cfi.muonTrackValidator.clone() +staMuonTrackVMuonAssoc = MTV.clone() staMuonTrackVMuonAssoc.associatormap = 'tpToStaMuonAssociation' staMuonTrackVMuonAssoc.label = ('standAloneMuons',) staMuonTrackVMuonAssoc.muonHistoParameters = staMuonHistoParameters -staUpdMuonTrackVMuonAssoc = Validation.RecoMuon.MuonTrackValidator_cfi.muonTrackValidator.clone() +staUpdMuonTrackVMuonAssoc = MTV.clone() staUpdMuonTrackVMuonAssoc.associatormap = 'tpToStaUpdMuonAssociation' staUpdMuonTrackVMuonAssoc.label = ('standAloneMuons:UpdatedAtVtx',) staUpdMuonTrackVMuonAssoc.muonHistoParameters = staUpdMuonHistoParameters -glbMuonTrackVMuonAssoc = Validation.RecoMuon.MuonTrackValidator_cfi.muonTrackValidator.clone() +glbMuonTrackVMuonAssoc = MTV.clone() glbMuonTrackVMuonAssoc.associatormap = 'tpToGlbMuonAssociation' glbMuonTrackVMuonAssoc.label = ('globalMuons',) glbMuonTrackVMuonAssoc.muonHistoParameters = glbMuonHistoParameters -staRefitMuonTrackVMuonAssoc = Validation.RecoMuon.MuonTrackValidator_cfi.muonTrackValidator.clone() +staRefitMuonTrackVMuonAssoc = MTV.clone() staRefitMuonTrackVMuonAssoc.associatormap = 'tpToStaRefitMuonAssociation' staRefitMuonTrackVMuonAssoc.label = ('refittedStandAloneMuons',) staRefitMuonTrackVMuonAssoc.muonHistoParameters = staMuonHistoParameters -staRefitUpdMuonTrackVMuonAssoc = Validation.RecoMuon.MuonTrackValidator_cfi.muonTrackValidator.clone() +staRefitUpdMuonTrackVMuonAssoc = MTV.clone() staRefitUpdMuonTrackVMuonAssoc.associatormap = 'tpToStaRefitUpdMuonAssociation' staRefitUpdMuonTrackVMuonAssoc.label = ('refittedStandAloneMuons:UpdatedAtVtx',) staRefitUpdMuonTrackVMuonAssoc.muonHistoParameters = staUpdMuonHistoParameters -displacedTrackVMuonAssoc = Validation.RecoMuon.MuonTrackValidator_cfi.muonTrackValidator.clone() +displacedTrackVMuonAssoc = MTV.clone() displacedTrackVMuonAssoc.associatormap = 'tpToDisplacedTrkMuonAssociation' displacedTrackVMuonAssoc.label = ('displacedTracks',) +displacedTrackVMuonAssoc.label_tp = ("TPtrack") displacedTrackVMuonAssoc.muonTPSelector = displacedMuonTPSet +displacedTrackVMuonAssoc.muonTPSelector.src = ("TPtrack") displacedTrackVMuonAssoc.muonHistoParameters = displacedTrkMuonHistoParameters -displacedStaSeedTrackVMuonAssoc = Validation.RecoMuon.MuonTrackValidator_cfi.muonTrackValidator.clone() +displacedStaSeedTrackVMuonAssoc = MTV.clone() displacedStaSeedTrackVMuonAssoc.associatormap = 'tpToDisplacedStaSeedAssociation' displacedStaSeedTrackVMuonAssoc.label = ('seedsOfDisplacedSTAmuons',) displacedStaSeedTrackVMuonAssoc.muonTPSelector = displacedMuonTPSet +displacedStaSeedTrackVMuonAssoc.muonTPSelector.src = ("TPmu") displacedStaSeedTrackVMuonAssoc.muonHistoParameters = displacedStaSeedMuonHistoParameters -displacedStaMuonTrackVMuonAssoc = Validation.RecoMuon.MuonTrackValidator_cfi.muonTrackValidator.clone() +displacedStaMuonTrackVMuonAssoc = MTV.clone() displacedStaMuonTrackVMuonAssoc.associatormap = 'tpToDisplacedStaMuonAssociation' displacedStaMuonTrackVMuonAssoc.label = ('displacedStandAloneMuons',) displacedStaMuonTrackVMuonAssoc.muonTPSelector = displacedMuonTPSet +displacedStaMuonTrackVMuonAssoc.muonTPSelector.src = ("TPmu") displacedStaMuonTrackVMuonAssoc.muonHistoParameters = displacedStaMuonHistoParameters -displacedGlbMuonTrackVMuonAssoc = Validation.RecoMuon.MuonTrackValidator_cfi.muonTrackValidator.clone() +displacedGlbMuonTrackVMuonAssoc = MTV.clone() displacedGlbMuonTrackVMuonAssoc.associatormap = 'tpToDisplacedGlbMuonAssociation' displacedGlbMuonTrackVMuonAssoc.label = ('displacedGlobalMuons',) displacedGlbMuonTrackVMuonAssoc.muonTPSelector = displacedMuonTPSet +displacedGlbMuonTrackVMuonAssoc.muonTPSelector.src = ("TPmu") displacedGlbMuonTrackVMuonAssoc.muonHistoParameters = displacedGlbMuonHistoParameters -tevMuonFirstTrackVMuonAssoc = Validation.RecoMuon.MuonTrackValidator_cfi.muonTrackValidator.clone() +tevMuonFirstTrackVMuonAssoc = MTV.clone() tevMuonFirstTrackVMuonAssoc.associatormap = 'tpToTevFirstMuonAssociation' tevMuonFirstTrackVMuonAssoc.label = ('tevMuons:firstHit',) tevMuonFirstTrackVMuonAssoc.muonHistoParameters = glbMuonHistoParameters -tevMuonPickyTrackVMuonAssoc = Validation.RecoMuon.MuonTrackValidator_cfi.muonTrackValidator.clone() +tevMuonPickyTrackVMuonAssoc = MTV.clone() tevMuonPickyTrackVMuonAssoc.associatormap = 'tpToTevPickyMuonAssociation' tevMuonPickyTrackVMuonAssoc.label = ('tevMuons:picky',) tevMuonPickyTrackVMuonAssoc.muonHistoParameters = glbMuonHistoParameters -tevMuonDytTrackVMuonAssoc = Validation.RecoMuon.MuonTrackValidator_cfi.muonTrackValidator.clone() +tevMuonDytTrackVMuonAssoc = MTV.clone() tevMuonDytTrackVMuonAssoc.associatormap = 'tpToTevDytMuonAssociation' tevMuonDytTrackVMuonAssoc.label = ('tevMuons:dyt',) tevMuonDytTrackVMuonAssoc.muonHistoParameters = glbMuonHistoParameters -tunepMuonTrackVMuonAssoc = Validation.RecoMuon.MuonTrackValidator_cfi.muonTrackValidator.clone() +tunepMuonTrackVMuonAssoc = MTV.clone() tunepMuonTrackVMuonAssoc.associatormap = 'tpToTunePMuonAssociation' tunepMuonTrackVMuonAssoc.label = ('tunepMuonTracks',) tunepMuonTrackVMuonAssoc.muonHistoParameters = glbMuonHistoParameters -pfMuonTrackVMuonAssoc = Validation.RecoMuon.MuonTrackValidator_cfi.muonTrackValidator.clone() +pfMuonTrackVMuonAssoc = MTV.clone() pfMuonTrackVMuonAssoc.associatormap = 'tpToPFMuonAssociation' pfMuonTrackVMuonAssoc.label = ('pfMuonTracks',) +pfMuonTrackVMuonAssoc.label_tp = ("TPpfmu") +pfMuonTrackVMuonAssoc.muonTPSelector.src = ("TPpfmu") pfMuonTrackVMuonAssoc.muonHistoParameters = glbMuonHistoParameters -recomuMuonTrackVMuonAssoc = Validation.RecoMuon.MuonTrackValidator_cfi.muonTrackValidator.clone() +recomuMuonTrackVMuonAssoc = MTV.clone() recomuMuonTrackVMuonAssoc.associatormap = 'tpTorecoMuonMuonAssociation' recomuMuonTrackVMuonAssoc.label = ('recoMuonTracks',) recomuMuonTrackVMuonAssoc.muonHistoParameters = glbMuonHistoParameters -gemMuonTrackVMuonAssoc = Validation.RecoMuon.MuonTrackValidator_cfi.muonTrackValidator.clone() +gemMuonTrackVMuonAssoc = MTV.clone() gemMuonTrackVMuonAssoc.associatormap = 'tpToGEMMuonMuonAssociation' gemMuonTrackVMuonAssoc.label = ('extractGemMuons',) gemMuonTrackVMuonAssoc.muonHistoParameters = gemMuonHistoParameters -me0MuonTrackVMuonAssoc = Validation.RecoMuon.MuonTrackValidator_cfi.muonTrackValidator.clone() +me0MuonTrackVMuonAssoc = MTV.clone() me0MuonTrackVMuonAssoc.associatormap = 'tpToME0MuonMuonAssociation' me0MuonTrackVMuonAssoc.label = ('extractMe0Muons',) me0MuonTrackVMuonAssoc.muonTPSelector = me0MuonTPSet +me0MuonTrackVMuonAssoc.muonTPSelector.src = ("TPmu") me0MuonTrackVMuonAssoc.muonHistoParameters = me0MuonHistoParameters + +MTVcosmic = Validation.RecoMuon.MuonTrackValidator_cfi.muonTrackValidator.clone() +# DEFAULTS ################################### +# label_tp = cms.InputTag("mix","MergedTrackTruth"), +# label_tp_refvector = cms.bool(False), +############################################## +MTVcosmic.parametersDefiner = cms.string('CosmicParametersDefinerForTP') +MTVcosmic.muonTPSelector = cosmicMuonTPSet +############################################## + # cosmics 2-leg reco -trkCosmicMuonTrackVSelMuonAssoc = Validation.RecoMuon.MuonTrackValidator_cfi.muonTrackValidator.clone() +trkCosmicMuonTrackVSelMuonAssoc = MTVcosmic.clone() trkCosmicMuonTrackVSelMuonAssoc.associatormap = 'tpToTkCosmicSelMuonAssociation' trkCosmicMuonTrackVSelMuonAssoc.label = ('ctfWithMaterialTracksP5LHCNavigation',) -trkCosmicMuonTrackVSelMuonAssoc.parametersDefiner = cms.string('CosmicParametersDefinerForTP') -trkCosmicMuonTrackVSelMuonAssoc.muonTPSelector = cosmicMuonTPSet trkCosmicMuonTrackVSelMuonAssoc.BiDirectional_RecoToSim_association = False trkCosmicMuonTrackVSelMuonAssoc.muonHistoParameters = trkCosmicMuonHistoParameters -staCosmicMuonTrackVSelMuonAssoc = Validation.RecoMuon.MuonTrackValidator_cfi.muonTrackValidator.clone() +staCosmicMuonTrackVSelMuonAssoc = MTVcosmic.clone() staCosmicMuonTrackVSelMuonAssoc.associatormap = 'tpToStaCosmicSelMuonAssociation' staCosmicMuonTrackVSelMuonAssoc.label = ('cosmicMuons',) -staCosmicMuonTrackVSelMuonAssoc.parametersDefiner = cms.string('CosmicParametersDefinerForTP') -staCosmicMuonTrackVSelMuonAssoc.muonTPSelector = cosmicMuonTPSet staCosmicMuonTrackVSelMuonAssoc.BiDirectional_RecoToSim_association = False staCosmicMuonTrackVSelMuonAssoc.muonHistoParameters = staCosmicMuonHistoParameters -glbCosmicMuonTrackVSelMuonAssoc = Validation.RecoMuon.MuonTrackValidator_cfi.muonTrackValidator.clone() +glbCosmicMuonTrackVSelMuonAssoc = MTVcosmic.clone() glbCosmicMuonTrackVSelMuonAssoc.associatormap = 'tpToGlbCosmicSelMuonAssociation' glbCosmicMuonTrackVSelMuonAssoc.label = ('globalCosmicMuons',) -glbCosmicMuonTrackVSelMuonAssoc.parametersDefiner = cms.string('CosmicParametersDefinerForTP') -glbCosmicMuonTrackVSelMuonAssoc.muonTPSelector = cosmicMuonTPSet glbCosmicMuonTrackVSelMuonAssoc.BiDirectional_RecoToSim_association = False glbCosmicMuonTrackVSelMuonAssoc.muonHistoParameters = glbCosmicMuonHistoParameters # cosmics 1-leg reco -trkCosmic1LegMuonTrackVSelMuonAssoc = Validation.RecoMuon.MuonTrackValidator_cfi.muonTrackValidator.clone() +trkCosmic1LegMuonTrackVSelMuonAssoc = MTVcosmic.clone() trkCosmic1LegMuonTrackVSelMuonAssoc.associatormap = 'tpToTkCosmic1LegSelMuonAssociation' trkCosmic1LegMuonTrackVSelMuonAssoc.label = ('ctfWithMaterialTracksP5',) -trkCosmic1LegMuonTrackVSelMuonAssoc.parametersDefiner = cms.string('CosmicParametersDefinerForTP') -trkCosmic1LegMuonTrackVSelMuonAssoc.muonTPSelector = cosmicMuonTPSet trkCosmic1LegMuonTrackVSelMuonAssoc.muonHistoParameters = trkCosmic1LegMuonHistoParameters -staCosmic1LegMuonTrackVSelMuonAssoc = Validation.RecoMuon.MuonTrackValidator_cfi.muonTrackValidator.clone() +staCosmic1LegMuonTrackVSelMuonAssoc = MTVcosmic.clone() staCosmic1LegMuonTrackVSelMuonAssoc.associatormap = 'tpToStaCosmic1LegSelMuonAssociation' staCosmic1LegMuonTrackVSelMuonAssoc.label = ('cosmicMuons1Leg',) -staCosmic1LegMuonTrackVSelMuonAssoc.parametersDefiner = cms.string('CosmicParametersDefinerForTP') -staCosmic1LegMuonTrackVSelMuonAssoc.muonTPSelector = cosmicMuonTPSet staCosmic1LegMuonTrackVSelMuonAssoc.muonHistoParameters = staCosmic1LegMuonHistoParameters -glbCosmic1LegMuonTrackVSelMuonAssoc = Validation.RecoMuon.MuonTrackValidator_cfi.muonTrackValidator.clone() +glbCosmic1LegMuonTrackVSelMuonAssoc = MTVcosmic.clone() glbCosmic1LegMuonTrackVSelMuonAssoc.associatormap = 'tpToGlbCosmic1LegSelMuonAssociation' glbCosmic1LegMuonTrackVSelMuonAssoc.label = ('globalCosmicMuons1Leg',) -glbCosmic1LegMuonTrackVSelMuonAssoc.parametersDefiner = cms.string('CosmicParametersDefinerForTP') -glbCosmic1LegMuonTrackVSelMuonAssoc.muonTPSelector = cosmicMuonTPSet glbCosmic1LegMuonTrackVSelMuonAssoc.muonHistoParameters = glbCosmic1LegMuonHistoParameters - ########################################################################## ### Customization for Phase II samples ### @@ -233,6 +251,16 @@ +recoMuonTracks_seq + tpTorecoMuonMuonAssociation + recomuMuonTrackVMuonAssoc ) +muonValidation_noTABH_seq = cms.Sequence( + probeTracks_seq + tpToTkMuonAssociation + trkProbeTrackVMuonAssoc + +seedsOfSTAmuons_seq + tpToStaSeedAssociation + staSeedTrackVMuonAssoc + +tpToStaMuonAssociation + staMuonTrackVMuonAssoc + +tpToStaUpdMuonAssociation + staUpdMuonTrackVMuonAssoc + +tpToGlbMuonAssociation + glbMuonTrackVMuonAssoc + +pfMuonTracks_seq + tpToPFMuonAssociation + pfMuonTrackVMuonAssoc + +recoMuonTracks_seq + tpTorecoMuonMuonAssociation + recomuMuonTrackVMuonAssoc +) + muonValidationTEV_seq = cms.Sequence( tpToTevFirstMuonAssociation + tevMuonFirstTrackVMuonAssoc +tpToTevPickyMuonAssociation + tevMuonPickyTrackVMuonAssoc @@ -252,15 +280,6 @@ +tpToDisplacedGlbMuonAssociation + displacedGlbMuonTrackVMuonAssoc ) -muonValidationCosmic_seq = cms.Sequence( - tpToTkCosmicSelMuonAssociation + trkCosmicMuonTrackVSelMuonAssoc - +tpToTkCosmic1LegSelMuonAssociation + trkCosmic1LegMuonTrackVSelMuonAssoc - +tpToStaCosmicSelMuonAssociation + staCosmicMuonTrackVSelMuonAssoc - +tpToStaCosmic1LegSelMuonAssociation + staCosmic1LegMuonTrackVSelMuonAssoc - +tpToGlbCosmicSelMuonAssociation + glbCosmicMuonTrackVSelMuonAssoc - +tpToGlbCosmic1LegSelMuonAssociation + glbCosmic1LegMuonTrackVSelMuonAssoc -) - recoMuonValidation_reduced_seq = cms.Sequence( probeTracks_seq + tpToTkMuonAssociation + trkProbeTrackVMuonAssoc_phase2 +tpToStaUpdMuonAssociation + staUpdMuonTrackVMuonAssoc_phase2 @@ -273,6 +292,15 @@ +tpToDisplacedGlbMuonAssociation + displacedGlbMuonTrackVMuonAssoc_phase2 ) +muonValidationCosmic_seq = cms.Sequence( + tpToTkCosmicSelMuonAssociation + trkCosmicMuonTrackVSelMuonAssoc + +tpToTkCosmic1LegSelMuonAssociation + trkCosmic1LegMuonTrackVSelMuonAssoc + +tpToStaCosmicSelMuonAssociation + staCosmicMuonTrackVSelMuonAssoc + +tpToStaCosmic1LegSelMuonAssociation + staCosmic1LegMuonTrackVSelMuonAssoc + +tpToGlbCosmicSelMuonAssociation + glbCosmicMuonTrackVSelMuonAssoc + +tpToGlbCosmic1LegSelMuonAssociation + glbCosmic1LegMuonTrackVSelMuonAssoc +) + gemMuonValidation = cms.Sequence(extractGemMuonsTracks_seq + tpToGEMMuonMuonAssociation + gemMuonTrackVMuonAssoc) me0MuonValidation = cms.Sequence(extractMe0MuonsTracks_seq + tpToME0MuonMuonAssociation + me0MuonTrackVMuonAssoc) @@ -281,13 +309,23 @@ ########################################################################## # The full offline muon validation sequence # -recoMuonValidation = cms.Sequence( +recoMuonValidation = cms.Sequence( TPtrack_seq + TPmu_seq + TPpfmu_seq + muonValidation_seq + muonValidationTEV_seq + muonValidationRefit_seq + muonValidationDisplaced_seq + muonValidationRMV_seq ) +# optionally omit TABH +recoMuonValidation_noTABH = cms.Sequence( TPtrack_seq + TPmu_seq + TPpfmu_seq + + muonValidation_noTABH_seq + muonValidationTEV_seq + muonValidationRefit_seq + muonValidationDisplaced_seq + muonValidationRMV_seq + ) + +# ... and also displaced muons +recoMuonValidation_noTABH_noDisplaced = cms.Sequence( TPtrack_seq + TPmu_seq + TPpfmu_seq + + muonValidation_noTABH_seq + muonValidationTEV_seq + muonValidationRefit_seq + muonValidationRMV_seq + ) + # no displaced muons in fastsim from Configuration.Eras.Modifier_fastSim_cff import fastSim -fastSim.toReplaceWith(recoMuonValidation, cms.Sequence(muonValidation_seq + muonValidationTEV_seq + muonValidationRefit_seq + muonValidationRMV_seq)) +fastSim.toReplaceWith(recoMuonValidation, cms.Sequence(cms.SequencePlaceholder("TPtrack") + cms.SequencePlaceholder("TPmu") + cms.SequencePlaceholder("TPpfmu") + muonValidation_seq + muonValidationTEV_seq + muonValidationRefit_seq + muonValidationRMV_seq)) # sequence for cosmic muons recoCosmicMuonValidation = cms.Sequence( @@ -296,17 +334,14 @@ # sequences for muon upgrades # -_run3_muonValidation = recoMuonValidation.copy() #For full validation -#_run3_muonValidation = recoMuonValidation_reduced_seq.copy() +_run3_muonValidation = recoMuonValidation.copy() _run3_muonValidation += gemMuonValidation -#_phase2_muonValidation = recoMuonValidation.copy() #For full validation -_phase2_muonValidation = recoMuonValidation_reduced_seq.copy() +_phase2_muonValidation = cms.Sequence(TPtrack_seq + TPmu_seq + TPpfmu_seq + recoMuonValidation_reduced_seq) _phase2_muonValidation += gemMuonValidation_phase2 _phase2_muonValidation += me0MuonValidation -#_phase2_ge0_muonValidation = recoMuonValidation.copy() #For full validation -_phase2_ge0_muonValidation = recoMuonValidation_reduced_seq.copy() +_phase2_ge0_muonValidation = cms.Sequence(TPtrack_seq + TPmu_seq + TPpfmu_seq + recoMuonValidation_reduced_seq) _phase2_ge0_muonValidation += gemMuonValidation_phase2 from Configuration.Eras.Modifier_run3_GEM_cff import run3_GEM diff --git a/Validation/RecoMuon/python/selectors_cff.py b/Validation/RecoMuon/python/selectors_cff.py index 9a3caf3e3eb19..243dc3fe7b725 100644 --- a/Validation/RecoMuon/python/selectors_cff.py +++ b/Validation/RecoMuon/python/selectors_cff.py @@ -1,6 +1,24 @@ import FWCore.ParameterSet.Config as cms -# TrackingParticle (MC truth) selectors +# TrackingParticle skims used in muon validation + +import SimMuon.MCTruth.trackingParticleMuon_cfi +TPrefs = SimMuon.MCTruth.trackingParticleMuon_cfi.trackingParticleMuon.clone() + +TPmu = TPrefs.clone() +TPmu_seq = cms.Sequence( TPmu ) + +TPpfmu = TPrefs.clone() +TPpfmu.skim = 'pf' +TPpfmu_seq = cms.Sequence( TPpfmu ) + +TPtrack = TPrefs.clone() +TPtrack.skim = 'track' +TPtrack.ptmin = 2. +TPtrack_seq = cms.Sequence( TPtrack ) + +# TrackingParticle selectors for signal efficiencies + muonTPSet = cms.PSet( src = cms.InputTag("mix", "MergedTrackTruth"), pdgId = cms.vint32(13, -13), @@ -16,10 +34,9 @@ stableOnly = cms.bool(True), # discard decays in flight from the signal event chargedOnly = cms.bool(True) ) -from Configuration.ProcessModifiers.premix_stage2_cff import premix_stage2 -premix_stage2.toModify(muonTPSet, src = "mixData:MergedTrackTruth") -me0MuonTPSet = muonTPSet.clone( +me0MuonTPSet = cms.PSet( + src = cms.InputTag("mix", "MergedTrackTruth"), pdgId = cms.vint32(13, -13), tip = cms.double(3.5), lip = cms.double(30.0), @@ -34,7 +51,8 @@ chargedOnly = cms.bool(True) ) -displacedMuonTPSet = muonTPSet.clone( +displacedMuonTPSet = cms.PSet( + src = cms.InputTag("mix", "MergedTrackTruth"), pdgId = cms.vint32(13, -13), tip = cms.double(85.), # radius to have at least the 3 outermost TOB layers lip = cms.double(210.), # z to have at least the 3 outermost TEC layers @@ -63,7 +81,12 @@ stableOnly = cms.bool(True), # accept only TP from the Generator (linked to GenParticles) chargedOnly = cms.bool(True) ) + +from Configuration.ProcessModifiers.premix_stage2_cff import premix_stage2 +premix_stage2.toModify(muonTPSet, src = "mixData:MergedTrackTruth") premix_stage2.toModify(cosmicMuonTPSet, src = "mixData:MergedTrackTruth") +premix_stage2.toModify(displacedMuonTPSet, src = "mixData:MergedTrackTruth") +premix_stage2.toModify(me0MuonTPSet, src = "mixData:MergedTrackTruth") #muonTP = cms.EDFilter("TrackingParticleSelector", # muonTPSet diff --git a/Validation/RecoMuon/python/track_selectors_cff.py b/Validation/RecoMuon/python/track_selectors_cff.py index f303388b3d84d..66cdebef11ea5 100644 --- a/Validation/RecoMuon/python/track_selectors_cff.py +++ b/Validation/RecoMuon/python/track_selectors_cff.py @@ -7,7 +7,7 @@ #probeTracks.quality = cms.vstring('loose') # default probeTracks.tip = cms.double(3.5) probeTracks.lip = cms.double(30.) -probeTracks.ptMin = cms.double(4.0) +probeTracks.ptMin = cms.double(3.0) probeTracks.minRapidity = cms.double(-2.4) probeTracks.maxRapidity = cms.double(2.4) probeTracks_seq = cms.Sequence( probeTracks ) diff --git a/Validation/RecoMuon/src/RecoMuonValidator.cc b/Validation/RecoMuon/src/RecoMuonValidator.cc index a92ea1998ae56..ed473528e2491 100644 --- a/Validation/RecoMuon/src/RecoMuonValidator.cc +++ b/Validation/RecoMuon/src/RecoMuonValidator.cc @@ -554,7 +554,8 @@ struct RecoMuonValidator::CommonME { // RecoMuonValidator::RecoMuonValidator(const edm::ParameterSet& pset) : selector_(pset.getParameter("selection")) { - // pset=ps; + // dump cfg parameters + edm::LogVerbatim("RecoMuonValidator") << "constructing RecoMuonValidator: " << pset.dump(); verbose_ = pset.getUntrackedParameter("verbose", 0); outputFileName_ = pset.getUntrackedParameter("outputFileName", ""); @@ -625,8 +626,13 @@ RecoMuonValidator::RecoMuonValidator(const edm::ParameterSet& pset) // Labels for simulation and reconstruction tracks simLabel_ = pset.getParameter("simLabel"); + tpRefVector = pset.getParameter("tpRefVector"); + if (tpRefVector) + tpRefVectorToken_ = consumes(simLabel_); + else + simToken_ = consumes(simLabel_); + muonLabel_ = pset.getParameter("muonLabel"); - simToken_ = consumes(simLabel_); muonToken_ = consumes >(muonLabel_); // Labels for sim-reco association @@ -839,9 +845,23 @@ void RecoMuonValidator::analyze(const Event& event, const EventSetup& eventSetup const reco::Vertex thePrimaryVertex(posVtx, errVtx); // Get TrackingParticles + TrackingParticleRefVector TPrefV; + const TrackingParticleRefVector* ptr_TPrefV = nullptr; Handle simHandle; - event.getByToken(simToken_, simHandle); - const TrackingParticleCollection simColl = *(simHandle.product()); + Handle TPCollectionRefVector_H; + + if (tpRefVector) { + event.getByToken(tpRefVectorToken_, TPCollectionRefVector_H); + ptr_TPrefV = TPCollectionRefVector_H.product(); + TPrefV = *ptr_TPrefV; + } else { + event.getByToken(simToken_, simHandle); + size_t nTP = simHandle->size(); + for (size_t i = 0; i < nTP; ++i) { + TPrefV.push_back(TrackingParticleRef(simHandle, i)); + } + ptr_TPrefV = &TPrefV; + } // Get Muons Handle > muonHandle; @@ -855,18 +875,13 @@ void RecoMuonValidator::analyze(const Event& event, const EventSetup& eventSetup assoByHits = associatorBase.product(); } - const TrackingParticleCollection::size_type nSim = simColl.size(); + const size_t nSim = ptr_TPrefV->size(); edm::RefToBaseVector Muons; for (size_t i = 0; i < muonHandle->size(); ++i) { Muons.push_back(muonHandle->refAt(i)); } - edm::RefVector allTPs; - for (size_t i = 0; i < nSim; ++i) { - allTPs.push_back(TrackingParticleRef(simHandle, i)); - } - muonME_->hNSim_->Fill(nSim); muonME_->hNMuon_->Fill(muonColl.size()); @@ -874,7 +889,12 @@ void RecoMuonValidator::analyze(const Event& event, const EventSetup& eventSetup reco::SimToMuonCollection simToMuonColl; if (doAssoc_) { - assoByHits->associateMuons(muonToSimColl, simToMuonColl, Muons, trackType_, allTPs); + edm::LogVerbatim("RecoMuonValidator") + << "\n >>> MuonToSim association : " << muAssocLabel_ << " <<< \n" + << " muon collection : " << muonLabel_ << " (size = " << muonHandle->size() << ") \n" + << " TrackingParticle collection : " << simLabel_ << " (size = " << nSim << ")"; + + assoByHits->associateMuons(muonToSimColl, simToMuonColl, Muons, trackType_, TPrefV); } else { /* // SimToMuon associations @@ -1018,8 +1038,8 @@ void RecoMuonValidator::analyze(const Event& event, const EventSetup& eventSetup } //end of reco muon loop // Associate by hits - for (TrackingParticleCollection::size_type i = 0; i < nSim; i++) { - TrackingParticleRef simRef(simHandle, i); + for (size_t i = 0; i < nSim; i++) { + TrackingParticleRef simRef = TPrefV[i]; const TrackingParticle* simTP = simRef.get(); if (!tpSelector_(*simTP)) continue; @@ -1095,4 +1115,3 @@ int RecoMuonValidator::countTrackerHits(const reco::Track& track) const { } return count; } -/* vim:set ts=2 sts=2 sw=2 expandtab: */ diff --git a/Validation/RecoMuon/src/RecoMuonValidator.h b/Validation/RecoMuon/src/RecoMuonValidator.h index 8b7a723a47862..c192527be271e 100644 --- a/Validation/RecoMuon/src/RecoMuonValidator.h +++ b/Validation/RecoMuon/src/RecoMuonValidator.h @@ -45,6 +45,9 @@ class RecoMuonValidator : public DQMOneEDAnalyzer<> { edm::InputTag muonLabel_; std::string muonSelection_; edm::EDGetTokenT simToken_; + edm::EDGetTokenT tpRefVectorToken_; + bool tpRefVector; + edm::EDGetTokenT > muonToken_; edm::InputTag muAssocLabel_; @@ -128,4 +131,3 @@ class RecoMuonValidator : public DQMOneEDAnalyzer<> { }; #endif -/* vim:set ts=2 sts=2 sw=2 expandtab: */