TrackSelector.h

Go to the documentation of this file.

#ifndef RecoAlgos_TrackSelector_h
#define RecoAlgos_TrackSelector_h

#include "FWCore/Framework/interface/stream/EDFilter.h"
#include "DataFormats/TrackReco/interface/Track.h"
#include "DataFormats/TrackReco/interface/TrackFwd.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 TrackCollectionStoreManager {
  public:
    typedef reco::TrackCollection collection;

    TrackCollectionStoreManager(const edm::Handle<reco::TrackCollection> & );

    //------------------------------------------------------------------
    //------------------------------------------------------------------
    inline bool cloneClusters() {return cloneClusters_ ; } 
    inline void setCloneClusters(bool w) { cloneClusters_ = w; }

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

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

    //------------------------------------------------------------------
    //------------------------------------------------------------------
    template<typename I>
    void cloneAndStore( const I & begin, const I & end, edm::Event & evt ) ;
    
  private:
    //--- Collections to store:
    std::auto_ptr<reco::TrackCollection>                   selTracks_;
    std::auto_ptr<reco::TrackExtraCollection>              selTrackExtras_;
    std::auto_ptr<TrackingRecHitCollection>                selHits_;
    std::auto_ptr< edmNew::DetSetVector<SiStripCluster> >  selStripClusters_;
    std::auto_ptr< edmNew::DetSetVector<SiPixelCluster> >  selPixelClusters_;

    //--- References to products (i.e. to collections):
    reco::TrackRefProd           rTracks_ ;
    reco::TrackExtraRefProd      rTrackExtras_ ;
    TrackingRecHitRefProd        rHits_ ;
    ClusterStorer clusterStorer_;

    //--- Indices into collections handled with RefProd
    size_t idx_   ;      
    size_t hidx_  ;      

    //--- Switches 
    bool   cloneClusters_ ;  
    
    //--- Methods
    //------------------------------------------------------------------
    //------------------------------------------------------------------
    void processTrack( const reco::Track & trk );
  };
  // (end of struct TrackCollectionStoreManager)

  
  template<typename I>
  void 
  TrackCollectionStoreManager::cloneAndStore( const I & begin, const I & end, edm::Event & evt ) 
  {
      using namespace reco;

      rTracks_       = evt.template getRefBeforePut<TrackCollection>();      
      rTrackExtras_  = evt.template getRefBeforePut<TrackExtraCollection>();
      rHits_         = evt.template getRefBeforePut<TrackingRecHitCollection>();
      //--- New: save clusters too
      edm::RefProd<edmNew::DetSetVector<SiPixelCluster> > rPixelClusters
    = evt.template getRefBeforePut<edmNew::DetSetVector<SiPixelCluster> >();
      edm::RefProd<edmNew::DetSetVector<SiStripCluster> > rStripClusters 
    = evt.template getRefBeforePut<edmNew::DetSetVector<SiStripCluster> >();

      //--- Indices into collections handled with RefProd
      idx_ = 0;         
      hidx_ = 0;        
      clusterStorer_.clear();

      //--- Loop over tracks
      for( I i = begin; i != end; ++ i ) {
          //--- Whatever type the iterator i is, deref to reco::Track &
          const reco::Track & trk = * * i;
          //--- Clone this track, and store references aside
          processTrack( trk );
      }
      //--- Clone the clusters and fixup refs
      clusterStorer_.processAllClusters(*selPixelClusters_, rPixelClusters,
                    *selStripClusters_, rStripClusters);
  }


  //----------------------------------------------------------------------
  class TrackSelectorBase : public edm::stream::EDFilter<> {
  public:
    TrackSelectorBase( const edm::ParameterSet & cfg ) {
      std::string alias( cfg.getParameter<std::string>( "@module_label" ) );
      produces<reco::TrackCollection>().setBranchAlias( alias + "Tracks" );
      produces<reco::TrackExtraCollection>().setBranchAlias( alias + "TrackExtras" );
      produces<TrackingRecHitCollection>().setBranchAlias( alias + "RecHits" );
      //--- New: save clusters too
      produces< edmNew::DetSetVector<SiPixelCluster> >().setBranchAlias( alias + "PixelClusters" );
      produces< edmNew::DetSetVector<SiStripCluster> >().setBranchAlias( alias + "StripClusters" );
    }
  };  // (end of class TrackSelectorBase)


  template<>
  struct StoreManagerTrait< reco::TrackCollection, edm::stream::EDFilter<> > {
    typedef TrackCollectionStoreManager type;
    typedef TrackSelectorBase base;
  };

}

#endif