#include <TrackCollectionCloner.h>

Public Member Functions
void	operator() (Tokens const &tokens, std::vector< unsigned int > const &selected)
	process one event More...

	Producer (edm::Event &ievt, TrackCollectionCloner const &cloner)

	~Producer ()

Public Attributes
bool	copyExtras_
	copy only the tracks, not extras and rechits (for AOD) More...

bool	copyTrajectories_
	copy also trajectories and trajectory->track associations More...

edm::Event &	evt
	the event More...

std::unique_ptr< TrackingRecHitCollection >	selHits_

std::unique_ptr< reco::TrackExtraCollection >	selTrackExtras_

std::unique_ptr< reco::TrackCollection >	selTracks_

std::unique_ptr< std::vector< Trajectory > >	selTrajs_

std::unique_ptr< TrajTrackAssociationCollection >	selTTAss_

Detailed Description

Definition at line 58 of file TrackCollectionCloner.h.

Constructor & Destructor Documentation

TrackCollectionCloner::Producer::Producer	(	edm::Event &	ievt,
		TrackCollectionCloner const &	cloner
	)

Definition at line 9 of file TrackCollectionCloner.cc.

References copyExtras_, copyTrajectories_, evt, edm::Event::getRefBeforePut(), selHits_, selTrackExtras_, selTracks_, selTrajs_, and selTTAss_.

                                                                                             :
   copyExtras_(cloner.copyExtras_), copyTrajectories_(cloner.copyTrajectories_), evt(ievt)  {
   selTracks_ = std::make_unique<reco::TrackCollection>();
   if (copyExtras_) {
     selTrackExtras_ = std::make_unique<reco::TrackExtraCollection>();
     selHits_ = std::make_unique<TrackingRecHitCollection>();
   }
   if ( copyTrajectories_ ) {
     selTrajs_ = std::make_unique< std::vector<Trajectory> >();
     selTTAss_ = std::make_unique< TrajTrackAssociationCollection >(evt.getRefBeforePut< std::vector<Trajectory> >(), evt.getRefBeforePut<reco::TrackCollection>());
   }
   
 }

TrackCollectionCloner::Producer::~Producer ( )

Definition at line 82 of file TrackCollectionCloner.cc.

References copyExtras_, copyTrajectories_, evt, eostools::move(), edm::Event::put(), selHits_, selTrackExtras_, selTracks_, selTrajs_, and selTTAss_.

                                          {
   selTracks_->shrink_to_fit();
   auto tsize = selTracks_->size();
   evt.put(std::move(selTracks_));
   if (copyExtras_) {
     selTrackExtras_->shrink_to_fit();
     assert(selTrackExtras_->size()==tsize);
     selHits_->shrink_to_fit();
     evt.put(std::move(selTrackExtras_));
     evt.put(std::move(selHits_));
   }
   if ( copyTrajectories_ ) {
     selTrajs_->shrink_to_fit();
     assert(selTrajs_->size()==tsize);
     assert(selTTAss_->size()==tsize);
     evt.put(std::move(selTrajs_));
     evt.put(std::move(selTTAss_));
     
   }
 }

Member Function Documentation

void TrackCollectionCloner::Producer::operator()	(	Tokens const &	tokens,
		std::vector< unsigned int > const &	selected
	)

process one event

Definition at line 25 of file TrackCollectionCloner.cc.

References copyExtras_, copyTrajectories_, evt, edm::Event::getRefBeforePut(), gen::k, selHits_, selTrackExtras_, selTracks_, selTrajs_, selTTAss_, TrackCollectionTokens::tracks(), and TrackCollectionTokens::trajectories().

                                                                                                               {
   
   auto rTracks = evt.getRefBeforePut<reco::TrackCollection>();
   
   TrackingRecHitRefProd rHits;
   reco::TrackExtraRefProd rTrackExtras;
   if (copyExtras_) {
     rHits = evt.getRefBeforePut<TrackingRecHitCollection>();
     rTrackExtras = evt.getRefBeforePut<reco::TrackExtraCollection>();
   }
   
   edm::RefProd< std::vector<Trajectory> > trajRefProd;
   if ( copyTrajectories_ ) {
     trajRefProd = evt.getRefBeforePut< std::vector<Trajectory> >();
   }
 
   std::vector<Trajectory> dummy;
 
   auto const & trajIn =  copyTrajectories_ ? tokens.trajectories(evt) : dummy;
   
   auto const & tracksIn = tokens.tracks(evt);
   for (auto k : selected) {
     auto const & trk = tracksIn[k];
     selTracks_->emplace_back( trk ); // clone and store
     if (copyTrajectories_) {
       // we assume tracks and trajectories are one-to-one and the assocMap is useless 
       selTrajs_->emplace_back(trajIn[k]);
       assert(selTrajs_->back().measurements().size()==trk.recHitsSize());
       selTTAss_->insert ( edm::Ref< std::vector<Trajectory> >(trajRefProd, selTrajs_->size() - 1),
                   reco::TrackRef(rTracks, selTracks_->size() - 1)
                   );
     }
     
     if (!copyExtras_) continue;
     
     // TrackExtras
     selTrackExtras_->emplace_back( trk.outerPosition(), trk.outerMomentum(), trk.outerOk(),
                    trk.innerPosition(), trk.innerMomentum(), trk.innerOk(),
                    trk.outerStateCovariance(), trk.outerDetId(),
                    trk.innerStateCovariance(), trk.innerDetId(),
                    trk.seedDirection(), trk.seedRef()
                    );
     selTracks_->back().setExtra( reco::TrackExtraRef( rTrackExtras, selTrackExtras_->size() - 1) );
     auto & tx = selTrackExtras_->back();
     tx.setResiduals(trk.residuals());
     auto nh1=trk.recHitsSize();
     tx.setHits(rHits,selHits_->size(),nh1);
     tx.setTrajParams(trk.extra()->trajParams(),trk.extra()->chi2sX5());
     assert(tx.trajParams().size()==tx.recHitsSize());
     // TrackingRecHits
     for( auto hit = trk.recHitsBegin(); hit != trk.recHitsEnd(); ++ hit ) {
       selHits_->push_back( (*hit)->clone() );
     }
   }
 
 }