#include <MuonToSimAssociatorByHits.h>

Inheritance diagram for MuonToSimAssociatorByHits:

Public Member Functions
void	associateMuons (MuonToSimCollection &recoToSim, SimToMuonCollection &simToReco, const edm::RefToBaseVector< reco::Muon > &, MuonTrackType, const edm::RefVector< TrackingParticleCollection > &, const edm::Event event=0, const edm::EventSetup setup=0) const override

void	associateMuons (MuonToSimCollection &recoToSim, SimToMuonCollection &simToReco, const edm::Handle< edm::View< reco::Muon >> &, MuonTrackType, const edm::Handle< TrackingParticleCollection > &, const edm::Event event=0, const edm::EventSetup setup=0) const override

	MuonToSimAssociatorByHits (const edm::ParameterSet &conf, edm::ConsumesCollector &&iC)

	~MuonToSimAssociatorByHits () override

Public Member Functions inherited from MuonToSimAssociatorBase
	MuonToSimAssociatorBase ()

virtual	~MuonToSimAssociatorBase ()

Private Attributes
edm::ParameterSet const	conf_

MuonAssociatorByHitsHelper	helper_

TrackerHitAssociator::Config	trackerHitAssociatorConfig_

Additional Inherited Members
Public Types inherited from MuonToSimAssociatorBase
typedef std::map< edm::RefToBase< reco::Muon >, std::vector< std::pair< TrackingParticleRef, double > >, RefToBaseSort >	MuonToSimCollection

enum	MuonTrackType { InnerTk, OuterTk, GlobalTk, Segments }

typedef std::map< TrackingParticleRef, std::vector< std::pair< edm::RefToBase< reco::Muon >, double > > >	SimToMuonCollection

Detailed Description

Definition at line 11 of file MuonToSimAssociatorByHits.h.

Constructor & Destructor Documentation

MuonToSimAssociatorByHits::MuonToSimAssociatorByHits	(	const edm::ParameterSet &	conf,
		edm::ConsumesCollector &&	iC
	)

Definition at line 19 of file MuonToSimAssociatorByHits.cc.

References conf_, and eostools::move().

     : helper_(conf), conf_(conf), trackerHitAssociatorConfig_(conf, std::move(iC)) {
   TrackerMuonHitExtractor hitExtractor(conf_, std::move(iC));
 
   // hack for consumes
   RPCHitAssociator rpctruth(conf, std::move(iC));
   GEMHitAssociator gemtruth(conf, std::move(iC));
   DTHitAssociator dttruth(conf, std::move(iC));
   CSCHitAssociator muonTruth(conf, std::move(iC));
 }

MuonToSimAssociatorByHits::~MuonToSimAssociatorByHits ( )

override

Definition at line 30 of file MuonToSimAssociatorByHits.cc.

30 {}

Member Function Documentation

void MuonToSimAssociatorByHits::associateMuons	(	MuonToSimCollection &	recoToSim,
		SimToMuonCollection &	simToReco,
		const edm::RefToBaseVector< reco::Muon > &	muons,
		MuonTrackType	trackType,
		const edm::RefVector< TrackingParticleCollection > &	tPC,
		const edm::Event *	event = `0`,
		const edm::EventSetup *	setup = `0`
	)		const

overridevirtual

PART 1: Fill MuonToSimAssociatorByHits::TrackHitsCollection

PART 2: call the association routines

Implements MuonToSimAssociatorBase.

Definition at line 50 of file MuonToSimAssociatorByHits.cc.

References a, MuonAssociatorByHitsHelper::associateRecoToSimIndices(), MuonAssociatorByHitsHelper::associateSimToRecoIndices(), edm::RefToBaseVector< T >::begin(), conf_, edm::OwnVector< T, P >::data(), edm::RefToBaseVector< T >::end(), edm::EventSetup::get(), TrackerMuonHitExtractor::getMuonHits(), MuonToSimAssociatorBase::GlobalTk, reco::Muon::globalTrack(), helper_, hfClusterShapes_cfi::hits, TrackerMuonHitExtractor::init(), MuonToSimAssociatorBase::InnerTk, edm::Ref< C, T, F >::isNonnull(), reco::Muon::isTrackerMuon(), MuonToSimAssociatorBase::OuterTk, reco::Muon::outerTrack(), edm::ESHandle< T >::product(), edm::RefToBaseVector< T >::push_back(), edm::RefVector< C, T, F >::push_back(), edm::OwnVector< T, P >::push_back(), mps_fire::resources, MuonToSimAssociatorBase::Segments, particleFlowSimParticle_cfi::sim, edm::OwnVector< T, P >::size(), reco::Muon::track(), and trackerHitAssociatorConfig_.

Referenced by associateMuons().

                                                                                  {
   MuonAssociatorByHitsHelper::TrackHitsCollection muonHitRefs;
   edm::OwnVector<TrackingRecHit> allTMRecHits;  // this I will fill in only for tracker muon hits from
                                                 // segments
   switch (trackType) {
     case 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 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 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 Segments: {
       TrackerMuonHitExtractor hitExtractor(conf_);
       hitExtractor.init(*event, *setup);
       // 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 = 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;
   }
 
   // Retrieve tracker topology from geometry
   edm::ESHandle<TrackerTopology> tTopoHand;
   setup->get<TrackerTopologyRcd>().get(tTopoHand);
   const TrackerTopology *tTopo = tTopoHand.product();
 
   // Tracker hit association
   TrackerHitAssociator trackertruth(*event, trackerHitAssociatorConfig_);
   // CSC hit association
   CSCHitAssociator csctruth(*event, *setup, conf_);
   // DT hit association
   bool printRtS = true;
   DTHitAssociator dttruth(*event, *setup, conf_, printRtS);
   // RPC hit association
   RPCHitAssociator rpctruth(*event, *setup, conf_);
   // GEM hit association
   GEMHitAssociator gemtruth(*event, *setup, conf_);
 
   MuonAssociatorByHitsHelper::Resources resources = {tTopo, &trackertruth, &csctruth, &dttruth, &rpctruth, &gemtruth};
 
   auto recSimColl = helper_.associateRecoToSimIndices(muonHitRefs, tPC, 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 = helper_.associateSimToRecoIndices(muonHitRefs, tPC, 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 MuonToSimAssociatorByHits::associateMuons	(	MuonToSimCollection &	recoToSim,
		SimToMuonCollection &	simToReco,
		const edm::Handle< edm::View< reco::Muon >> &	tCH,
		MuonTrackType	type,
		const edm::Handle< TrackingParticleCollection > &	tPCH,
		const edm::Event *	event = `0`,
		const edm::EventSetup *	setup = `0`
	)		const

overridevirtual

Implements MuonToSimAssociatorBase.

Definition at line 32 of file MuonToSimAssociatorByHits.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, event, setup);
 }