#include "MuonToTrackingParticleAssociatorByHitsImpl.h"

Inheritance diagram for MuonToTrackingParticleAssociatorByHitsImpl:

Public Member Functions
void	associateMuons (reco::MuonToSimCollection &recoToSim, reco::SimToMuonCollection &simToReco, const edm::RefToBaseVector< reco::Muon > &muons, reco::MuonTrackType type, const edm::RefVector< TrackingParticleCollection > &tpColl) const override

void	associateMuons (reco::MuonToSimCollection &recoToSim, reco::SimToMuonCollection &simToReco, const edm::Handle< edm::View< reco::Muon > > &muons, reco::MuonTrackType type, const edm::Handle< TrackingParticleCollection > &tpColl) const override

	MuonToTrackingParticleAssociatorByHitsImpl (TrackerMuonHitExtractor const &iHitExtractor, MuonAssociatorByHitsHelper::Resources const &iResources, MuonAssociatorByHitsHelper const *iHelper)

Public Member Functions inherited from reco::MuonToTrackingParticleAssociatorBaseImpl
	MuonToTrackingParticleAssociatorBaseImpl ()

virtual	~MuonToTrackingParticleAssociatorBaseImpl ()

Private Member Functions
	MuonToTrackingParticleAssociatorByHitsImpl (const MuonToTrackingParticleAssociatorByHitsImpl &)=delete

const MuonToTrackingParticleAssociatorByHitsImpl &	operator= (const MuonToTrackingParticleAssociatorByHitsImpl &)=delete

Private Attributes
MuonAssociatorByHitsHelper const *	m_helper

TrackerMuonHitExtractor const *	m_hitExtractor

MuonAssociatorByHitsHelper::Resources	m_resources

Detailed Description

Description: [one line class summary]

Usage: <usage>

Definition at line 30 of file MuonToTrackingParticleAssociatorByHitsImpl.h.

Constructor & Destructor Documentation

MuonToTrackingParticleAssociatorByHitsImpl::MuonToTrackingParticleAssociatorByHitsImpl	(	TrackerMuonHitExtractor const &	iHitExtractor,
		MuonAssociatorByHitsHelper::Resources const &	iResources,
		MuonAssociatorByHitsHelper const *	iHelper
	)

Definition at line 31 of file MuonToTrackingParticleAssociatorByHitsImpl.cc.

                                                                                             :
   m_hitExtractor(&iHitExtractor),
   m_resources(iResources),
   m_helper(iHelper)
 {
 }

MuonToTrackingParticleAssociatorByHitsImpl::MuonToTrackingParticleAssociatorByHitsImpl ( const MuonToTrackingParticleAssociatorByHitsImpl & )

privatedelete

Member Function Documentation

void MuonToTrackingParticleAssociatorByHitsImpl::associateMuons	(	reco::MuonToSimCollection &	recoToSim,
		reco::SimToMuonCollection &	simToReco,
		const edm::RefToBaseVector< reco::Muon > &	muons,
		reco::MuonTrackType	type,
		const edm::RefVector< TrackingParticleCollection > &	tpColl
	)		const

overridevirtual

PART 1: Fill MuonToSimAssociatorByHits::TrackHitsCollection

PART 2: call the association routines

Implements reco::MuonToTrackingParticleAssociatorBaseImpl.

Definition at line 49 of file MuonToTrackingParticleAssociatorByHitsImpl.cc.

References a, MuonAssociatorByHitsHelper::associateRecoToSimIndices(), MuonAssociatorByHitsHelper::associateSimToRecoIndices(), edm::RefToBaseVector< T >::begin(), reco::LeafCandidate::charge(), edm::OwnVector< T, P >::data(), edm::RefToBaseVector< T >::end(), reco::LeafCandidate::eta(), TrackerMuonHitExtractor::getMuonHits(), reco::GlbOrTrk, reco::GlobalTk, reco::Muon::globalTrack(), hfClusterShapes_cfi::hits, reco::InnerTk, reco::Muon::isGEMMuon(), reco::Muon::isGlobalMuon(), reco::Muon::isME0Muon(), reco::Muon::isMuon(), edm::Ref< C, T, F >::isNonnull(), reco::Muon::isPFMuon(), reco::Muon::isRPCMuon(), reco::Muon::isStandAloneMuon(), reco::Muon::isTrackerMuon(), edm::RefToBase< T >::key(), m_helper, m_hitExtractor, m_resources, reco::OuterTk, reco::Muon::outerTrack(), reco::LeafCandidate::p(), reco::LeafCandidate::phi(), reco::LeafCandidate::pt(), edm::RefToBaseVector< T >::push_back(), edm::RefVector< C, T, F >::push_back(), edm::OwnVector< T, P >::push_back(), reco::Segments, particleFlowSimParticle_cfi::sim, edm::RefToBaseVector< T >::size(), edm::OwnVector< T, P >::size(), and reco::Muon::track().

Referenced by associateMuons().

                                                                                                                       {
     MuonAssociatorByHitsHelper::TrackHitsCollection muonHitRefs;
     edm::OwnVector<TrackingRecHit> allTMRecHits;  // this I will fill in only for tracker muon hits from segments
 
     std::vector<edm::OwnVector<TrackingRecHit> > TMRecHits; // used for case GlbOrTrk
     edm::OwnVector<TrackingRecHit> noTM;
 
     switch (type) {
         
         case reco::InnerTk: 
             for (edm::RefToBaseVector<reco::Muon>::const_iterator it = muons.begin(), ed = muons.end(); it != ed; ++it) {
                 edm::RefToBase<reco::Muon> mur = *it;
                 if (mur->track().isNonnull()) { 
                     muonHitRefs.push_back(std::make_pair(mur->track()->recHitsBegin(), mur->track()->recHitsEnd()));
                 } else {
           muonHitRefs.push_back(std::make_pair(allTMRecHits.data().end(), allTMRecHits.data().end()));
                 }
             }
         break;
         case reco::OuterTk: 
             for (edm::RefToBaseVector<reco::Muon>::const_iterator it = muons.begin(), ed = muons.end(); it != ed; ++it) {
                 edm::RefToBase<reco::Muon> mur = *it;
                 if (mur->outerTrack().isNonnull()) { 
                     muonHitRefs.push_back(std::make_pair(mur->outerTrack()->recHitsBegin(), mur->outerTrack()->recHitsEnd()));
                 } else {
           muonHitRefs.push_back(std::make_pair(allTMRecHits.data().end(), allTMRecHits.data().end()));
                 }
             }
             break;
         case reco::GlobalTk: 
             for (edm::RefToBaseVector<reco::Muon>::const_iterator it = muons.begin(), ed = muons.end(); it != ed; ++it) {
                 edm::RefToBase<reco::Muon> mur = *it;
                 if (mur->globalTrack().isNonnull()) { 
                     muonHitRefs.push_back(std::make_pair(mur->globalTrack()->recHitsBegin(), mur->globalTrack()->recHitsEnd()));
                 } else {
           muonHitRefs.push_back(std::make_pair(allTMRecHits.data().end(), allTMRecHits.data().end()));
         }
             }
             break;
         case reco::Segments: {
                 // puts hits in the vector, and record indices
                 std::vector<std::pair<size_t, size_t> >   muonHitIndices;
                 for (edm::RefToBaseVector<reco::Muon>::const_iterator it = muons.begin(), ed = muons.end(); it != ed; ++it) {
                     edm::RefToBase<reco::Muon> mur = *it;
                     std::pair<size_t, size_t> indices(allTMRecHits.size(), allTMRecHits.size());
                     if (mur->isTrackerMuon()) {
                         std::vector<const TrackingRecHit *> hits = m_hitExtractor->getMuonHits(*mur);
                         for (std::vector<const TrackingRecHit *>::const_iterator ith = hits.begin(), edh = hits.end(); ith != edh; ++ith) {
                             allTMRecHits.push_back(**ith);
                         }
                         indices.second += hits.size();
                     }
                     muonHitIndices.push_back(indices);  
                 }
                 // convert indices into pairs of iterators to references
                 typedef std::pair<size_t, size_t> index_pair;
                 trackingRecHit_iterator hitRefBegin = allTMRecHits.data().begin();
                 for (std::vector<std::pair<size_t, size_t> >::const_iterator idxs = muonHitIndices.begin(), idxend = muonHitIndices.end(); idxs != idxend; ++idxs) {
                     muonHitRefs.push_back(std::make_pair(hitRefBegin+idxs->first, 
                                                          hitRefBegin+idxs->second));
                 }
                 
             }
             break;
         case reco::GlbOrTrk: {
        edm::LogVerbatim("MuonToTrackingParticleAssociatorByHitsImpl") 
          <<"\n"<<"There are "<<muons.size()<<" selected reco::Muons.";
 
        int isel = 0;
        for (edm::RefToBaseVector<reco::Muon>::const_iterator it = muons.begin(), ed = muons.end(); it != ed; ++it) {
          edm::RefToBase<reco::Muon> mur = *it;
 
         edm::LogVerbatim("MuonToTrackingParticleAssociatorByHitsImpl") 
           <<" #"<<isel<<", reco::Muon key = " <<mur.key()
           <<", q*p = "<<mur->charge()*mur->p()<<", pT = "<<mur->pt()<<", eta = "<<mur->eta()<<", phi = "<<mur->phi();
 
          // Global muon with valid muon hits
          if (mur->isGlobalMuon() && mur->globalTrack()->hitPattern().numberOfValidMuonHits()>0) {
            edm::LogVerbatim("MuonToTrackingParticleAssociatorByHitsImpl") 
          <<"\t this is a Global Muon with valid muon hits";
            muonHitRefs.push_back(std::make_pair(mur->globalTrack()->recHitsBegin(), mur->globalTrack()->recHitsEnd()));
          }
 
          // Tracker Muon
          else if (mur->isTrackerMuon()) {
            edm::LogVerbatim("MuonToTrackingParticleAssociatorByHitsImpl") 
          <<"\t this is a Tracker Muon";
            edm::OwnVector<TrackingRecHit> TMvec;
 
            std::vector<const TrackingRecHit *> hits = m_hitExtractor->getMuonHits(*mur); 
            for (std::vector<const TrackingRecHit *>::const_iterator ith = hits.begin(), edh = hits.end(); ith != edh; ++ith) {
          TMvec.push_back(**ith);
            }
            
            TMRecHits.push_back(TMvec);
            
            muonHitRefs.push_back(std::make_pair(TMRecHits.rbegin()->data().begin(), TMRecHits.rbegin()->data().end()));
          }
 
          // Standalone muon or Global without valid muon hits
          else if (mur->outerTrack().isNonnull()) {
            edm::LogVerbatim("MuonToTrackingParticleAssociatorByHitsImpl") 
          <<"\t this is a Standalone muon";
            muonHitRefs.push_back(std::make_pair(mur->outerTrack()->recHitsBegin(), mur->outerTrack()->recHitsEnd()));
          }
 
          else {
            edm::LogVerbatim("MuonToTrackingParticleAssociatorByHitsImpl") 
          <<"\t what muon is this ?";
            edm::LogVerbatim("MuonToTrackingParticleAssociatorByHitsImpl") 
          <<"isMuon : "<<mur->isMuon()<<", isPFMuon : "<<mur->isPFMuon()<<", isTrackerMuon : "<<mur->isTrackerMuon()
          <<", isStandAloneMuon : "<<mur->isStandAloneMuon()<<", isGlobalMuon : "<<mur->isGlobalMuon()
          <<", isRPCMuon : "<<mur->isRPCMuon()<<", isGEMMuon : "<<mur->isGEMMuon()<<", isME0Muon : "<<mur->isME0Muon();
            muonHitRefs.push_back(std::make_pair(noTM.data().end(), noTM.data().end()));
          }
          
          isel++;
        } // loop on muons
        
         }
     break;
     }
 
     auto recSimColl = m_helper->associateRecoToSimIndices(muonHitRefs,tPC, m_resources);
     for (auto it = recSimColl.begin(), ed = recSimColl.end(); it != ed; ++it) {
         edm::RefToBase<reco::Muon> rec = muons[it->first];
         std::vector<std::pair<TrackingParticleRef, double> > & tpAss  = recToSim[rec];
         for ( auto const & a : it->second) {
             tpAss.push_back(std::make_pair(tPC[a.idx], a.quality));
         }
     }
     auto simRecColl = m_helper->associateSimToRecoIndices(muonHitRefs,tPC,m_resources);
     for (auto it = simRecColl.begin(), ed = simRecColl.end(); it != ed; ++it) {
         TrackingParticleRef sim = tPC[it->first];
         std::vector<std::pair<edm::RefToBase<reco::Muon>, double> > & recAss = simToRec[sim];
         for ( auto const & a: it->second ) {
             recAss.push_back(std::make_pair(muons[a.idx], a.quality));
         }
     }
 }

void MuonToTrackingParticleAssociatorByHitsImpl::associateMuons	(	reco::MuonToSimCollection &	recoToSim,
		reco::SimToMuonCollection &	simToReco,
		const edm::Handle< edm::View< reco::Muon > > &	muons,
		reco::MuonTrackType	type,
		const edm::Handle< TrackingParticleCollection > &	tpColl
	)		const

overridevirtual

Implements reco::MuonToTrackingParticleAssociatorBaseImpl.

Definition at line 197 of file MuonToTrackingParticleAssociatorByHitsImpl.cc.

References associateMuons(), mps_fire::i, edm::HandleBase::id(), edm::RefToBaseVector< T >::push_back(), and edm::RefVector< C, T, F >::push_back().

                                                                                                                     {
 
     edm::RefVector<TrackingParticleCollection> tpc(tPCH.id());
     for (unsigned int j=0; j<tPCH->size();j++)
       tpc.push_back(edm::Ref<TrackingParticleCollection>(tPCH,j));
     
     edm::RefToBaseVector<reco::Muon> muonBaseRefVector;
     for (size_t i = 0; i < tCH->size(); ++i)
       muonBaseRefVector.push_back(tCH->refAt(i));
 
     associateMuons(recToSim, simToRec, muonBaseRefVector,type,tpc);
 }

const MuonToTrackingParticleAssociatorByHitsImpl& MuonToTrackingParticleAssociatorByHitsImpl::operator= ( const MuonToTrackingParticleAssociatorByHitsImpl & )

privatedelete