MuonSelector.h

Go to the documentation of this file.

#ifndef RecoAlgos_MuonSelector_h
#define RecoAlgos_MuonSelector_h

#include "DataFormats/MuonReco/interface/Muon.h"
#include "DataFormats/MuonReco/interface/MuonFwd.h"
#include "DataFormats/TrackReco/interface/Track.h"
#include "DataFormats/TrackReco/interface/TrackExtra.h"
#include "DataFormats/TrackingRecHit/interface/TrackingRecHit.h"
#include "DataFormats/SiStripCluster/interface/SiStripCluster.h"
#include "DataFormats/SiPixelCluster/interface/SiPixelCluster.h"
#include "DataFormats/Common/interface/DetSetVectorNew.h"
#include "CommonTools/RecoAlgos/interface/ClusterStorer.h"
#include "CommonTools/UtilAlgos/interface/ObjectSelector.h"

namespace helper {
  struct MuonCollectionStoreManager {
   public:
    typedef reco::MuonCollection collection;

    MuonCollectionStoreManager(const edm::Handle<reco::MuonCollection>&) ;
    
    //------------------------------------------------------------------
    //------------------------------------------------------------------
    inline bool cloneClusters() {return cloneClusters_ ; } 
    inline void setCloneClusters(bool w) { cloneClusters_ = w; }

    //------------------------------------------------------------------
    //------------------------------------------------------------------
    edm::OrphanHandle<reco::MuonCollection> put( edm::Event & evt );

    //------------------------------------------------------------------
    //------------------------------------------------------------------
    inline size_t size() const { return selMuons_->size(); }
    

    //------------------------------------------------------------------
    //------------------------------------------------------------------
    template<typename I>
    void cloneAndStore( const I & begin, const I & end, edm::Event & evt ) ;
    
  private:
     //--- Collections to store:
    std::auto_ptr<reco::MuonCollection> selMuons_;
    std::auto_ptr<reco::TrackCollection> selTracks_;
    std::auto_ptr<reco::TrackExtraCollection> selTracksExtras_;
    std::auto_ptr<TrackingRecHitCollection> selTracksHits_;
    std::auto_ptr<reco::TrackCollection> selGlobalMuonTracks_;
    std::auto_ptr<reco::TrackExtraCollection> selGlobalMuonTracksExtras_;
    std::auto_ptr<TrackingRecHitCollection> selGlobalMuonTracksHits_;
    std::auto_ptr<reco::TrackCollection> selStandAloneTracks_;
    std::auto_ptr<reco::TrackExtraCollection> selStandAloneTracksExtras_;
    std::auto_ptr<TrackingRecHitCollection> selStandAloneTracksHits_;
    std::auto_ptr< edmNew::DetSetVector<SiStripCluster> >  selStripClusters_;
    std::auto_ptr< edmNew::DetSetVector<SiPixelCluster> >  selPixelClusters_;

    reco::MuonRefProd rMuons_;      
    reco::TrackRefProd rTracks_;      
    reco::TrackExtraRefProd rTrackExtras_;
    TrackingRecHitRefProd rHits_;

    reco::TrackRefProd rGBTracks_;      
    reco::TrackExtraRefProd rGBTrackExtras_;
    TrackingRecHitRefProd rGBHits_;
    
    reco::TrackRefProd rSATracks_;      
    reco::TrackExtraRefProd rSATrackExtras_;
    TrackingRecHitRefProd rSAHits_;

    ClusterStorer clusterStorer_;

    //--- Indices into collections handled with RefProd
    size_t id_, igbd_, isad_, idx_, igbdx_, isadx_, hidx_, higbdx_, hisadx_;

    //--- Switches 
    bool   cloneClusters_ ;  
    
    //--- Methods
    //------------------------------------------------------------------
    //------------------------------------------------------------------
    void processMuon( const reco::Muon & mu );

    bool clusterRefsOK(const reco::Track &track) const;
  };
  // (end of struct MuonCollectionStoreManager)
 
  template<typename I>
  void 
  MuonCollectionStoreManager::cloneAndStore( const I & begin, const I & end, edm::Event & evt ) 
  {
      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);
   }
    
  //----------------------------------------------------------------------
  class MuonSelectorBase : public edm::EDFilter {
  public:
    MuonSelectorBase( const edm::ParameterSet & cfg ) {
      std::string alias( cfg.getParameter<std::string>( "@module_label" ) );


      produces<reco::MuonCollection>("SelectedMuons").setBranchAlias( alias + "SelectedMuons" );
      produces<reco::TrackCollection>("TrackerOnly").setBranchAlias( alias + "TrackerOnlyTracks" );
      produces<reco::TrackExtraCollection>("TrackerOnly").setBranchAlias( alias + "TrackerOnlyExtras" );
      produces<TrackingRecHitCollection>("TrackerOnly").setBranchAlias( alias + "TrackerOnlyHits" );
      //--- New: save clusters too
      produces< edmNew::DetSetVector<SiPixelCluster> >().setBranchAlias( alias + "PixelClusters" );
      produces< edmNew::DetSetVector<SiStripCluster> >().setBranchAlias( alias + "StripClusters" );
      produces<reco::TrackCollection>("GlobalMuon").setBranchAlias( alias + "GlobalMuonTracks" );
      produces<reco::TrackExtraCollection>("GlobalMuon").setBranchAlias( alias + "GlobalMuonExtras" );
      produces<TrackingRecHitCollection>("GlobalMuon").setBranchAlias( alias + "GlobalMuonHits" );
      produces<reco::TrackCollection>("StandAlone").setBranchAlias( alias + "StandAloneTracks" );
      produces<reco::TrackExtraCollection>("StandAlone").setBranchAlias( alias + "StandAloneExtras" );
      produces<TrackingRecHitCollection>("StandAlone").setBranchAlias( alias + "StandAloneHits" );

    }
   }; // (end of class MuonSelectorBase)


  template<>
  struct StoreManagerTrait<reco::MuonCollection> {
    typedef MuonCollectionStoreManager type;
    typedef MuonSelectorBase base;
  };

}

#endif