#include <TrackFullCloneSelectorBase.h>

Inheritance diagram for reco::modules::TrackFullCloneSelectorBase< Selector >:

Public Member Functions
	TrackFullCloneSelectorBase (const edm::ParameterSet &cfg)
	constructor
virtual	~TrackFullCloneSelectorBase ()
	destructor
Private Member Functions
void	produce (edm::Event &evt, const edm::EventSetup &es)
	process one event
Private Attributes
bool	copyExtras_
	copy only the tracks, not extras and rechits (for AOD)
bool	copyTrajectories_
	copy also trajectories and trajectory->track associations
Selector	selector_
	filter event
std::auto_ptr < TrackingRecHitCollection >	selHits_
std::auto_ptr < reco::TrackExtraCollection >	selTrackExtras_
std::auto_ptr < reco::TrackCollection >	selTracks_
std::auto_ptr< std::vector < Trajectory > >	selTrajs_
std::auto_ptr < TrajTrackAssociationCollection >	selTTAss_
edm::InputTag	src_
	source collection label

Detailed Description

template<typename Selector>
class reco::modules::TrackFullCloneSelectorBase< Selector >

Definition at line 35 of file TrackFullCloneSelectorBase.h.

Constructor & Destructor Documentation

template<typename Selector >

reco::modules::TrackFullCloneSelectorBase< Selector >::TrackFullCloneSelectorBase ( const edm::ParameterSet & cfg ) [inline, explicit]

constructor

Definition at line 38 of file TrackFullCloneSelectorBase.h.

References reco::modules::TrackFullCloneSelectorBase< Selector >::copyExtras_, reco::modules::TrackFullCloneSelectorBase< Selector >::copyTrajectories_, and edm::ParameterSet::getParameter().

                                                                     :
    src_( cfg.template getParameter<edm::InputTag>( "src" ) ),
    copyExtras_(cfg.template getUntrackedParameter<bool>("copyExtras", false)),
    copyTrajectories_(cfg.template getUntrackedParameter<bool>("copyTrajectories", false)),
    selector_( cfg ) {
      std::string alias( cfg.getParameter<std::string>( "@module_label" ) );
      produces<reco::TrackCollection>().setBranchAlias( alias + "Tracks" );
      if (copyExtras_) {
          produces<reco::TrackExtraCollection>().setBranchAlias( alias + "TrackExtras" );
          produces<TrackingRecHitCollection>().setBranchAlias( alias + "RecHits" );
          if (copyTrajectories_) {
              produces< std::vector<Trajectory> >().setBranchAlias( alias + "Trajectories" );
              produces< TrajTrackAssociationCollection >().setBranchAlias( alias + "TrajectoryTrackAssociations" );
          }
      }
   }

template<typename Selector >

virtual reco::modules::TrackFullCloneSelectorBase< Selector >::~TrackFullCloneSelectorBase ( ) [inline, virtual]

destructor

Definition at line 55 of file TrackFullCloneSelectorBase.h.

{ }

Member Function Documentation

template<typename Selector >

void reco::modules::TrackFullCloneSelectorBase< Selector >::produce	(	edm::Event &	evt,
		const edm::EventSetup &	es
	)		`[inline, private, virtual]`

process one event

Implements edm::EDProducer.

Definition at line 59 of file TrackFullCloneSelectorBase.h.

                                                         {
      edm::Handle<reco::TrackCollection> hSrcTrack;
      edm::Handle< std::vector<Trajectory> > hTraj;
      edm::Handle< TrajTrackAssociationCollection > hTTAss;
      evt.getByLabel( src_, hSrcTrack );

      selTracks_ = std::auto_ptr<reco::TrackCollection>(new reco::TrackCollection());
      if (copyExtras_) {
          selTrackExtras_ = std::auto_ptr<reco::TrackExtraCollection>(new reco::TrackExtraCollection());
          selHits_ = std::auto_ptr<TrackingRecHitCollection>(new TrackingRecHitCollection());
      }

      TrackRefProd rTracks = evt.template getRefBeforePut<TrackCollection>();      

      TrackingRecHitRefProd rHits;
      TrackExtraRefProd rTrackExtras;
      if (copyExtras_) {
          rHits = evt.template getRefBeforePut<TrackingRecHitCollection>();
          rTrackExtras = evt.template getRefBeforePut<TrackExtraCollection>();
      }

      typedef reco::TrackRef::key_type TrackRefKey;
      std::map<TrackRefKey, reco::TrackRef  > goodTracks;
      TrackRefKey current = 0;

      for (reco::TrackCollection::const_iterator it = hSrcTrack->begin(), ed = hSrcTrack->end(); it != ed; ++it, ++current) {
          const reco::Track & trk = * it;
          if (!selector_(trk, evt)) continue;

          selTracks_->push_back( Track( trk ) ); // clone and store
          if (!copyExtras_) continue;

          // TrackExtras
          selTrackExtras_->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() ) );
          selTracks_->back().setExtra( TrackExtraRef( rTrackExtras, selTrackExtras_->size() - 1) );
          TrackExtra & tx = selTrackExtras_->back();
          // TrackingRecHits
          for( trackingRecHit_iterator hit = trk.recHitsBegin(); hit != trk.recHitsEnd(); ++ hit ) {
              selHits_->push_back( (*hit)->clone() );
              tx.add( TrackingRecHitRef( rHits, selHits_->size() - 1) );
          }
          if (copyTrajectories_) {
              goodTracks[current] = reco::TrackRef(rTracks, selTracks_->size() - 1);
          }
      }
      if ( copyTrajectories_ ) {
          edm::Handle< std::vector<Trajectory> > hTraj;
          edm::Handle< TrajTrackAssociationCollection > hTTAss;
          evt.getByLabel(src_, hTTAss);
          evt.getByLabel(src_, hTraj);
          edm::RefProd< std::vector<Trajectory> > TrajRefProd = evt.template getRefBeforePut< std::vector<Trajectory> >();
          selTrajs_ = std::auto_ptr< std::vector<Trajectory> >(new std::vector<Trajectory>()); 
          selTTAss_ = std::auto_ptr< TrajTrackAssociationCollection >(new TrajTrackAssociationCollection());
          for (size_t i = 0, n = hTraj->size(); i < n; ++i) {
              edm::Ref< std::vector<Trajectory> > trajRef(hTraj, i);
              TrajTrackAssociationCollection::const_iterator match = hTTAss->find(trajRef);
              if (match != hTTAss->end()) {
                  const edm::Ref<reco::TrackCollection> &trkRef = match->val; 
                  TrackRefKey oldKey = trkRef.key();
                  std::map<TrackRefKey, reco::TrackRef>::iterator getref = goodTracks.find(oldKey);        
                  if (getref != goodTracks.end()) {
                      // do the clone
                      selTrajs_->push_back( Trajectory(*trajRef) );
                      selTTAss_->insert ( edm::Ref< std::vector<Trajectory> >(TrajRefProd, selTrajs_->size() - 1),
                                          getref->second );
                  }
              }
          }
      }
      
      evt.put(selTracks_);
      if (copyExtras_) {
            evt.put(selTrackExtras_); 
            evt.put(selHits_);
            if ( copyTrajectories_ ) {
                evt.put(selTrajs_);
                evt.put(selTTAss_);
            }
      }
  }