#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 29 of file MuonSelector.h.

Member Typedef Documentation

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

Definition at line 31 of file MuonSelector.h.

Constructor & Destructor Documentation

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

Definition at line 18 of file MuonSelector.cc.

References processMuon().

       :
       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 113 of file MuonSelector.h.

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

Referenced by size().

   {
       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 41 of file MuonSelector.h.

References cloneClusters_.

Referenced by processMuon(), and put().

41 {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 164 of file MuonSelector.cc.

References SiStripRecHit2D::cluster(), DetId::det(), TrackingRecHit::geographicalId(), edm::Ref< C, T, F >::isAvailable(), TrackingRecHit::isValid(), SiStripMatchedRecHit2D::monoHit(), ProjectedSiStripRecHit2D::originalHit(), put(), 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 49 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(), nanoDQM_cfi::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(), and MuonCollectionStoreManager().

   {
         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 201 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_.

Referenced by clusterRefsOK(), and setCloneClusters().

                           {
       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; 
      
     }