#include <MuonSelector.h>

Public Types
typedef reco::MuonCollection	collection

Public Member Functions
template<typename I >
void	cloneAndStore (const I &begin, const I &end, edm::Event &evt)
	Method to clone tracks, track extras and their hits and clusters. typename I = this is an interator over a Muon collection, **I needs to dereference into a Muon. More...

bool	cloneClusters ()

	MuonCollectionStoreManager (const edm::Handle< reco::MuonCollection > &)

edm::OrphanHandle < reco::MuonCollection >	put (edm::Event &evt)
	Put tracks, track extras and hits+clusters into the event. More...

void	setCloneClusters (bool w)

size_t	size () const
	Get the size. More...

Private Member Functions
bool	clusterRefsOK (const reco::Track &track) const
	Check if all references to silicon strip/pixel clusters are available. More...

void	processMuon (const reco::Muon &mu)
	Process a single muon. More...

Private Attributes
bool	cloneClusters_
	Clone clusters, or not? Default: true. More...

ClusterStorer	clusterStorer_

size_t	hidx_

size_t	higbdx_

size_t	hisadx_

size_t	id_

size_t	idx_

size_t	igbd_

size_t	igbdx_

size_t	isad_

size_t	isadx_

TrackingRecHitRefProd	rGBHits_

reco::TrackExtraRefProd	rGBTrackExtras_

reco::TrackRefProd	rGBTracks_

TrackingRecHitRefProd	rHits_

reco::MuonRefProd	rMuons_

TrackingRecHitRefProd	rSAHits_

reco::TrackExtraRefProd	rSATrackExtras_

reco::TrackRefProd	rSATracks_

reco::TrackExtraRefProd	rTrackExtras_

reco::TrackRefProd	rTracks_

std::unique_ptr < reco::TrackCollection >	selGlobalMuonTracks_

std::unique_ptr < reco::TrackExtraCollection >	selGlobalMuonTracksExtras_

std::unique_ptr < TrackingRecHitCollection >	selGlobalMuonTracksHits_

std::unique_ptr < reco::MuonCollection >	selMuons_

std::unique_ptr < edmNew::DetSetVector < SiPixelCluster > >	selPixelClusters_

std::unique_ptr < reco::TrackCollection >	selStandAloneTracks_

std::unique_ptr < reco::TrackExtraCollection >	selStandAloneTracksExtras_

std::unique_ptr < TrackingRecHitCollection >	selStandAloneTracksHits_

std::unique_ptr < edmNew::DetSetVector < SiStripCluster > >	selStripClusters_

std::unique_ptr < reco::TrackCollection >	selTracks_

std::unique_ptr < reco::TrackExtraCollection >	selTracksExtras_

std::unique_ptr < TrackingRecHitCollection >	selTracksHits_

Detailed Description

Definition at line 30 of file MuonSelector.h.

Member Typedef Documentation

typedef reco::MuonCollection helper::MuonCollectionStoreManager::collection

Definition at line 32 of file MuonSelector.h.

Constructor & Destructor Documentation

helper::MuonCollectionStoreManager::MuonCollectionStoreManager ( const edm::Handle< reco::MuonCollection > & )

Definition at line 16 of file MuonSelector.cc.

       : selMuons_(new reco::MuonCollection),
         selTracks_(new reco::TrackCollection),
         selTracksExtras_(new reco::TrackExtraCollection),
         selTracksHits_(new TrackingRecHitCollection),
         selGlobalMuonTracks_(new reco::TrackCollection),
         selGlobalMuonTracksExtras_(new reco::TrackExtraCollection),
         selGlobalMuonTracksHits_(new TrackingRecHitCollection),
         selStandAloneTracks_(new reco::TrackCollection),
         selStandAloneTracksExtras_(new reco::TrackExtraCollection),
         selStandAloneTracksHits_(new TrackingRecHitCollection),
         selStripClusters_(new edmNew::DetSetVector<SiStripCluster>),
         selPixelClusters_(new edmNew::DetSetVector<SiPixelCluster>),
         rMuons_(),
         rTracks_(),
         rTrackExtras_(),
         rHits_(),
         rGBTracks_(),
         rGBTrackExtras_(),
         rGBHits_(),
         rSATracks_(),
         rSATrackExtras_(),
         rSAHits_(),
         clusterStorer_(),
         id_(0),
         igbd_(0),
         isad_(0),
         idx_(0),
         igbdx_(0),
         isadx_(0),
         hidx_(0),
         higbdx_(0),
         hisadx_(0),
         cloneClusters_(true) {}

Member Function Documentation

template<typename I >

void helper::MuonCollectionStoreManager::cloneAndStore	(	const I &	begin,
		const I &	end,
		edm::Event &	evt
	)

Method to clone tracks, track extras and their hits and clusters. typename I = this is an interator over a Muon collection, **I needs to dereference into a Muon.

Definition at line 112 of file MuonSelector.h.

References helper::ClusterStorer::clear(), clusterStorer_, dataset::end, hidx_, higbdx_, hisadx_, Exhume::I, mps_fire::i, id_, idx_, igbd_, igbdx_, isad_, isadx_, RPCpg::mu, helper::ClusterStorer::processAllClusters(), processMuon(), dt_dqm_sourceclient_common_cff::reco, rGBHits_, rGBTrackExtras_, rGBTracks_, rHits_, rMuons_, rSAHits_, rSATrackExtras_, rSATracks_, rTrackExtras_, rTracks_, selPixelClusters_, and selStripClusters_.

                                                                                             {
     using namespace reco;
     rHits_ = evt.template getRefBeforePut<TrackingRecHitCollection>("TrackerOnly");
     rGBHits_ = evt.template getRefBeforePut<TrackingRecHitCollection>("GlobalMuon");
     rSAHits_ = evt.template getRefBeforePut<TrackingRecHitCollection>("StandAlone");
     rTrackExtras_ = evt.template getRefBeforePut<TrackExtraCollection>("TrackerOnly");
     rGBTrackExtras_ = evt.template getRefBeforePut<TrackExtraCollection>("GlobalMuon");
     rSATrackExtras_ = evt.template getRefBeforePut<TrackExtraCollection>("StandAlone");
     rTracks_ = evt.template getRefBeforePut<TrackCollection>("TrackerOnly");
     rGBTracks_ = evt.template getRefBeforePut<TrackCollection>("GlobalMuon");
     rSATracks_ = evt.template getRefBeforePut<TrackCollection>("StandAlone");
     rMuons_ = evt.template getRefBeforePut<MuonCollection>("SelectedMuons");
     //--- New: save clusters too
     edm::RefProd<edmNew::DetSetVector<SiStripCluster>> rStripClusters =
         evt.template getRefBeforePut<edmNew::DetSetVector<SiStripCluster>>();
 
     edm::RefProd<edmNew::DetSetVector<SiPixelCluster>> rPixelClusters =
         evt.template getRefBeforePut<edmNew::DetSetVector<SiPixelCluster>>();
 
     id_ = 0;
     igbd_ = 0;
     isad_ = 0;
     idx_ = 0;
     igbdx_ = 0;
     isadx_ = 0;
     hidx_ = 0;
     higbdx_ = 0;
     hisadx_ = 0;
     clusterStorer_.clear();
 
     for (I i = begin; i != end; ++i) {
       const Muon &mu = **i;
       //--- Clone this track, and store references aside
       processMuon(mu);
     }
     //--- Clone the clusters and fixup refs
     clusterStorer_.processAllClusters(*selPixelClusters_, rPixelClusters, *selStripClusters_, rStripClusters);
   }

bool helper::MuonCollectionStoreManager::cloneClusters ( )

inline

Use these to turn off/on the cloning of clusters. The default is to clone them. To not clone (and save space in a quick local job, do: setCloneClusters(false);

Definition at line 42 of file MuonSelector.h.

References cloneClusters_.

Referenced by processMuon(), and put().

42 { return cloneClusters_; }

helper::MuonCollectionStoreManager::cloneClusters_

bool cloneClusters_

Clone clusters, or not? Default: true.

Definition: MuonSelector.h:99

bool helper::MuonCollectionStoreManager::clusterRefsOK ( const reco::Track & track ) const

private

Check if all references to silicon strip/pixel clusters are available.

Definition at line 178 of file MuonSelector.cc.

References SiStripRecHit2D::cluster(), DetId::det(), TrackingRecHit::geographicalId(), edm::Ref< C, T, F >::isAvailable(), TrackingRecHit::isValid(), SiStripMatchedRecHit2D::monoHit(), ProjectedSiStripRecHit2D::originalHit(), reco::Track::recHitsBegin(), reco::Track::recHitsEnd(), SiStripMatchedRecHit2D::stereoHit(), and DetId::Tracker.

Referenced by processMuon().

                                                                              {
     for (trackingRecHit_iterator hitIt = track.recHitsBegin(); hitIt != track.recHitsEnd(); ++hitIt) {
       const TrackingRecHit &hit = **hitIt;
       if (!hit.isValid() || hit.geographicalId().det() != DetId::Tracker)
         continue;
 
       // So we are in the tracker - now check hit types and availability of cluster refs:
       const std::type_info &hit_type = typeid(hit);
       if (hit_type == typeid(SiPixelRecHit)) {
         if (!static_cast<const SiPixelRecHit &>(hit).cluster().isAvailable())
           return false;
       } else if (hit_type == typeid(SiStripRecHit2D)) {
         if (!static_cast<const SiStripRecHit2D &>(hit).cluster().isAvailable())
           return false;
       } else if (hit_type == typeid(SiStripRecHit1D)) {
         if (!static_cast<const SiStripRecHit1D &>(hit).cluster().isAvailable())
           return false;
       } else if (hit_type == typeid(SiStripMatchedRecHit2D)) {
         const SiStripMatchedRecHit2D &mHit = static_cast<const SiStripMatchedRecHit2D &>(hit);
         if (!mHit.monoHit().cluster().isAvailable())
           return false;
         if (!mHit.stereoHit().cluster().isAvailable())
           return false;
       } else if (hit_type == typeid(ProjectedSiStripRecHit2D)) {
         const ProjectedSiStripRecHit2D &pHit = static_cast<const ProjectedSiStripRecHit2D &>(hit);
         if (!pHit.originalHit().cluster().isAvailable())
           return false;
       } else {
         // std::cout << "|   It is a " << hit_type.name() << " hit !?" << std::endl;
         // Do nothing. We might end up here for FastSim hits.
       }  // end 'switch' on hit type
     }
 
     // No tracker hit with bad cluster found, so all fine:
     return true;
   }

void helper::MuonCollectionStoreManager::processMuon ( const reco::Muon & mu )

private

Process a single muon.

Definition at line 54 of file MuonSelector.cc.

References helper::ClusterStorer::addCluster(), cloneClusters(), clusterRefsOK(), clusterStorer_, reco::Muon::combinedMuon(), reco::Muon::globalTrack(), hidx_, higbdx_, hisadx_, id_, idx_, igbd_, igbdx_, reco::Track::innerDetId(), reco::Track::innerMomentum(), reco::Track::innerOk(), reco::Track::innerPosition(), reco::Track::innerStateCovariance(), reco::Muon::innerTrack(), isad_, isadx_, edm::Ref< C, T, F >::isNonnull(), TrackingRecHit::isValid(), dumpRecoGeometry_cfg::Muon, reco::Track::outerDetId(), reco::Track::outerMomentum(), reco::Track::outerOk(), reco::Track::outerPosition(), reco::Track::outerStateCovariance(), reco::Track::recHitsBegin(), reco::Track::recHitsEnd(), rGBHits_, rGBTrackExtras_, rGBTracks_, rHits_, rSAHits_, rSATrackExtras_, rSATracks_, rTrackExtras_, rTracks_, reco::Track::seedDirection(), selGlobalMuonTracks_, selGlobalMuonTracksExtras_, selGlobalMuonTracksHits_, selMuons_, selStandAloneTracks_, selStandAloneTracksExtras_, selStandAloneTracksHits_, selTracks_, selTracksExtras_, selTracksHits_, reco::Track::setExtra(), reco::TrackExtraBase::setHits(), reco::Muon::standAloneMuon(), reco::Muon::track(), and DetId::Tracker.

Referenced by cloneAndStore().

                                                              {
     if (this->cloneClusters() && ((mu.globalTrack().isNonnull() && !this->clusterRefsOK(*mu.globalTrack())) ||
                                   (mu.innerTrack().isNonnull() && !this->clusterRefsOK(*mu.innerTrack()))
                                   // || (mu.outerTrack(). isNonnull() && !this->clusterRefsOK(*mu.outerTrack() ))
                                   )) {  // outer track is muon only and has no strip clusters...
       // At least until CMSSW_2_1_8, global muon track reconstruction assigns wrong hits in
       // case of a track from iterative tracking. These hits are fetched from Trajectories
       // instead of from Tracks and therefore reference temporary cluster collections.
       // As a hack we skip these muons here - they can anyway not be refitted.
       edm::LogError("BadRef") << "@SUB=MuonCollectionStoreManager::processMuon"
                               << "Skip muon: One of its tracks references "
                               << "non-available clusters!";
       return;
     }
 
     selMuons_->push_back(Muon(mu));
     // only tracker Muon Track
     selMuons_->back().setInnerTrack(TrackRef(rTracks_, id_++));
     TrackRef trkRef = mu.track();
     if (trkRef.isNonnull()) {
       selTracks_->push_back(Track(*trkRef));
 
       Track &trk = selTracks_->back();
 
       selTracksExtras_->push_back(TrackExtra(trk.outerPosition(),
                                              trk.outerMomentum(),
                                              trk.outerOk(),
                                              trk.innerPosition(),
                                              trk.innerMomentum(),
                                              trk.innerOk(),
                                              trk.outerStateCovariance(),
                                              trk.outerDetId(),
                                              trk.innerStateCovariance(),
                                              trk.innerDetId(),
                                              trk.seedDirection()));
 
       TrackExtra &tx = selTracksExtras_->back();
 
       auto const firstHitIndex = hidx_;
       unsigned int nHitsAdded = 0;
       for (trackingRecHit_iterator hit = trk.recHitsBegin(); hit != trk.recHitsEnd(); ++hit, ++hidx_) {
         selTracksHits_->push_back((*hit)->clone());
         TrackingRecHit *newHit = &(selTracksHits_->back());
         ++nHitsAdded;
         if (cloneClusters() && newHit->isValid() && ((*hit)->geographicalId().det() == DetId::Tracker)) {
           clusterStorer_.addCluster(*selTracksHits_, hidx_);
         }
       }  // end of for loop over tracking rec hits on this track
       tx.setHits(rHits_, firstHitIndex, nHitsAdded);
 
       trk.setExtra(TrackExtraRef(rTrackExtras_, idx_++));
 
     }  // TO trkRef.isNonnull
 
     // global Muon Track
     selMuons_->back().setGlobalTrack(TrackRef(rGBTracks_, igbd_++));
     trkRef = mu.combinedMuon();
     if (trkRef.isNonnull()) {
       selGlobalMuonTracks_->push_back(Track(*trkRef));
       Track &trk = selGlobalMuonTracks_->back();
 
       selGlobalMuonTracksExtras_->push_back(TrackExtra(trk.outerPosition(),
                                                        trk.outerMomentum(),
                                                        trk.outerOk(),
                                                        trk.innerPosition(),
                                                        trk.innerMomentum(),
                                                        trk.innerOk(),
                                                        trk.outerStateCovariance(),
                                                        trk.outerDetId(),
                                                        trk.innerStateCovariance(),
                                                        trk.innerDetId(),
                                                        trk.seedDirection()));
       TrackExtra &tx = selGlobalMuonTracksExtras_->back();
       auto const firstHitIndex = higbdx_;
       unsigned int nHitsAdded = 0;
       for (trackingRecHit_iterator hit = trk.recHitsBegin(); hit != trk.recHitsEnd(); ++hit, ++higbdx_) {
         selGlobalMuonTracksHits_->push_back((*hit)->clone());
         TrackingRecHit *newHit = &(selGlobalMuonTracksHits_->back());
         ++nHitsAdded;
         if (cloneClusters() && newHit->isValid() && ((*hit)->geographicalId().det() == DetId::Tracker)) {
           clusterStorer_.addCluster(*selGlobalMuonTracksHits_, higbdx_);
         }
       }
       tx.setHits(rGBHits_, firstHitIndex, nHitsAdded);
 
       trk.setExtra(TrackExtraRef(rGBTrackExtras_, igbdx_++));
 
     }  // GB trkRef.isNonnull()
 
     // stand alone Muon Track
     selMuons_->back().setOuterTrack(TrackRef(rSATracks_, isad_++));
     trkRef = mu.standAloneMuon();
     if (trkRef.isNonnull()) {
       selStandAloneTracks_->push_back(Track(*trkRef));
       Track &trk = selStandAloneTracks_->back();
 
       selStandAloneTracksExtras_->push_back(TrackExtra(trk.outerPosition(),
                                                        trk.outerMomentum(),
                                                        trk.outerOk(),
                                                        trk.innerPosition(),
                                                        trk.innerMomentum(),
                                                        trk.innerOk(),
                                                        trk.outerStateCovariance(),
                                                        trk.outerDetId(),
                                                        trk.innerStateCovariance(),
                                                        trk.innerDetId(),
                                                        trk.seedDirection()));
       TrackExtra &tx = selStandAloneTracksExtras_->back();
       auto const firstHitIndex = hisadx_;
       unsigned int nHitsAdded = 0;
       for (trackingRecHit_iterator hit = trk.recHitsBegin(); hit != trk.recHitsEnd(); ++hit) {
         selStandAloneTracksHits_->push_back((*hit)->clone());
         ++nHitsAdded;
         hisadx_++;
       }
       tx.setHits(rSAHits_, firstHitIndex, nHitsAdded);
       trk.setExtra(TrackExtraRef(rSATrackExtras_, isadx_++));
 
     }  // SA trkRef.isNonnull()
   }    // end of track, and function

edm::OrphanHandle< reco::MuonCollection > helper::MuonCollectionStoreManager::put ( edm::Event & evt )

Put tracks, track extras and hits+clusters into the event.

Put Muons, tracks, track extras and hits+clusters into the event.

Definition at line 218 of file MuonSelector.cc.

References cloneClusters(), h, eostools::move(), edm::Event::put(), selGlobalMuonTracks_, selGlobalMuonTracksExtras_, selGlobalMuonTracksHits_, selMuons_, selPixelClusters_, selStandAloneTracks_, selStandAloneTracksExtras_, selStandAloneTracksHits_, selStripClusters_, selTracks_, selTracksExtras_, and selTracksHits_.

                                                                                    {
     edm::OrphanHandle<reco::MuonCollection> h;
     h = evt.put(std::move(selMuons_), "SelectedMuons");
     evt.put(std::move(selTracks_), "TrackerOnly");
     evt.put(std::move(selTracksExtras_), "TrackerOnly");
     evt.put(std::move(selTracksHits_), "TrackerOnly");
     evt.put(std::move(selGlobalMuonTracks_), "GlobalMuon");
     evt.put(std::move(selGlobalMuonTracksExtras_), "GlobalMuon");
     evt.put(std::move(selGlobalMuonTracksHits_), "GlobalMuon");
     evt.put(std::move(selStandAloneTracks_), "StandAlone");
     evt.put(std::move(selStandAloneTracksExtras_), "StandAlone");
     evt.put(std::move(selStandAloneTracksHits_), "StandAlone");
     if (cloneClusters()) {
       evt.put(std::move(selStripClusters_));
       evt.put(std::move(selPixelClusters_));
     }
     return h;
   }