MuonToTrackingParticleAssociatorByHitsImpl.cc

Go to the documentation of this file.

// -*- C++ -*-
//
// Package:     SimMuon/MCTruth
// Class  :     MuonToTrackingParticleAssociatorByHitsImpl
//
// Implementation:
//     [Notes on implementation]
//
// Original Author:  Christopher Jones
//         Created:  Wed, 07 Jan 2015 21:35:56 GMT
//
 
// system include files
 
// user include files
#include "MuonToTrackingParticleAssociatorByHitsImpl.h"
#include "SimMuon/MCTruth/interface/TrackerMuonHitExtractor.h"
 
//
// constants, enums and typedefs
//
 
//
// static data member definitions
//
 
//
// constructors and destructor
//
MuonToTrackingParticleAssociatorByHitsImpl::MuonToTrackingParticleAssociatorByHitsImpl(
    TrackerMuonHitExtractor const &iHitExtractor,
    MuonAssociatorByHitsHelper::Resources const &iResources,
    MuonAssociatorByHitsHelper const *iHelper)
    : m_hitExtractor(&iHitExtractor), m_resources(iResources), m_helper(iHelper) {}
 
//
// member functions
//
 
//
// const member functions
//
void MuonToTrackingParticleAssociatorByHitsImpl::associateMuons(
    reco::MuonToSimCollection &recToSim,
    reco::SimToMuonCollection &simToRec,
    const edm::RefToBaseVector<reco::Muon> &muons,
    reco::MuonTrackType type,
    const edm::RefVector<TrackingParticleCollection> &tPC) const {
  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 &recToSim,
    reco::SimToMuonCollection &simToRec,
    const edm::Handle<edm::View<reco::Muon>> &tCH,
    reco::MuonTrackType type,
    const edm::Handle<TrackingParticleCollection> &tPCH) const {
  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);
}
 
//
// static member functions
//