#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 52 of file TrackCollectionCloner.h.

Constructor & Destructor Documentation

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

Definition at line 8 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 84 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 23 of file TrackCollectionCloner.cc.

References copyExtras_, copyTrajectories_, evt, edm::Event::getRefBeforePut(), dqmdumpme::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());
     }
   }
 }