#include <RecoTrackAccumulator.h>

Inheritance diagram for RecoTrackAccumulator:

Public Member Functions
virtual void	accumulate (edm::Event const &e, edm::EventSetup const &c)

virtual void	accumulate (PileUpEventPrincipal const &e, edm::EventSetup const &c, edm::StreamID const &) override

virtual void	finalizeEvent (edm::Event &e, edm::EventSetup const &c)

virtual void	initializeEvent (edm::Event const &e, edm::EventSetup const &c)

	RecoTrackAccumulator (const edm::ParameterSet &conf, edm::stream::EDProducerBase &mixMod, edm::ConsumesCollector &iC)

virtual	~RecoTrackAccumulator ()

Public Member Functions inherited from DigiAccumulatorMixMod
virtual void	beginLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup)

virtual void	beginRun (edm::Run const &run, edm::EventSetup const &setup)

	DigiAccumulatorMixMod ()

virtual void	endLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup)

virtual void	endRun (edm::Run const &run, edm::EventSetup const &setup)

virtual void	finalizeBunchCrossing (edm::Event &event, edm::EventSetup const &setup, int bunchCrossing)

virtual PileupMixingContent *	getEventPileupInfo ()

virtual void	initializeBunchCrossing (edm::Event const &event, edm::EventSetup const &setup, int bunchCrossing)

virtual void	StorePileupInformation (std::vector< int > &numInteractionList, std::vector< int > &bunchCrossingList, std::vector< float > &TrueInteractionList, std::vector< edm::EventID > &eventList, int bunchSpace)

virtual	~DigiAccumulatorMixMod ()

Private Member Functions
template<class T >
void	accumulateEvent (const T &e, edm::EventSetup const &c, const edm::InputTag &label)

Private Attributes
std::auto_ptr < TrackingRecHitCollection >	newHits_

std::auto_ptr < reco::TrackExtraCollection >	newTrackExtras_

std::auto_ptr < reco::TrackCollection >	newTracks_

std::string	outputLabel

edm::InputTag	pileUpTracksTag

TrackingRecHitRefProd	rNewHits

reco::TrackExtraRefProd	rNewTrackExtras

reco::TrackRefProd	rNewTracks

edm::InputTag	signalTracksTag

Detailed Description

RecoTrackAccumulator accumulates generalTracks from the hard and the pileup events

Author: Andrea Giammanco

Version: Mar 11 2013

Definition at line 36 of file RecoTrackAccumulator.h.

Constructor & Destructor Documentation

RecoTrackAccumulator::RecoTrackAccumulator	(	const edm::ParameterSet &	conf,
		edm::stream::EDProducerBase &	mixMod,
		edm::ConsumesCollector &	iC
	)

explicit

Definition at line 9 of file RecoTrackAccumulator.cc.

References edm::ConsumesCollector::consumes(), outputLabel, and signalTracksTag.

                                                                                                                                  :
   signalTracksTag(conf.getParameter<edm::InputTag>("signalTracks")),
   pileUpTracksTag(conf.getParameter<edm::InputTag>("pileUpTracks")),
   outputLabel(conf.getParameter<std::string>("outputLabel"))
 {
   mixMod.produces<reco::TrackCollection>(outputLabel);
   mixMod.produces<TrackingRecHitCollection>(outputLabel);
   mixMod.produces<reco::TrackExtraCollection>(outputLabel); 
   
   iC.consumes<reco::TrackCollection>(signalTracksTag);
   iC.consumes<TrackingRecHitCollection>(signalTracksTag);
   iC.consumes<reco::TrackExtraCollection>(signalTracksTag);
 }

RecoTrackAccumulator::~RecoTrackAccumulator ( )

virtual

Definition at line 23 of file RecoTrackAccumulator.cc.

                                             {
     
 }

Member Function Documentation

void RecoTrackAccumulator::accumulate	(	edm::Event const &	e,
		edm::EventSetup const &	c
	)

virtual

Implements DigiAccumulatorMixMod.

Definition at line 39 of file RecoTrackAccumulator.cc.

References accumulateEvent(), and signalTracksTag.

                                                                                     {
   accumulateEvent( e, iSetup,signalTracksTag);
 }

void RecoTrackAccumulator::accumulate	(	PileUpEventPrincipal const &	e,
		edm::EventSetup const &	c,
		edm::StreamID const &
	)

overridevirtual

Implements DigiAccumulatorMixMod.

Definition at line 43 of file RecoTrackAccumulator.cc.

References accumulateEvent(), PileUpEventPrincipal::bunchCrossing(), and pileUpTracksTag.

                                                                                                                     {
   if (e.bunchCrossing()==0) {
       accumulateEvent( e, iSetup,pileUpTracksTag);
   }
 }

template<class T >

void RecoTrackAccumulator::accumulateEvent	(	const T &	e,
		edm::EventSetup const &	c,
		const edm::InputTag &	label
	)

private

Definition at line 57 of file RecoTrackAccumulator.cc.

References Exception, reco::Track::extra(), i, edm::HandleBase::isValid(), edm::Ref< C, T, F >::key(), newHits_, newTrackExtras_, newTracks_, rNewHits, rNewTrackExtras, lumiQTWidget::t, and testEve_cfg::tracks.

Referenced by accumulate().

                                                                                                                               {
 
   edm::Handle<reco::TrackCollection> tracks;
   edm::Handle<TrackingRecHitCollection> hits;
   edm::Handle<reco::TrackExtraCollection> trackExtras;
   e.getByLabel(label, tracks);
   e.getByLabel(label, hits);
   e.getByLabel(label, trackExtras);
   
   if(! tracks.isValid())
   {
       throw cms::Exception ("RecoTrackAccumulator") << "Failed to find track collections with inputTag " << label << std::endl;
   }
   if(!hits.isValid())
   {
       throw cms::Exception ("RecoTrackAccumulator") << "Failed to find hit collections with inputTag " << label << std::endl;
   }
   if(!trackExtras.isValid())
   {
       throw cms::Exception ("RecoTrackAccumulator") << "Failed to find trackExtra collections with inputTag " << label << std::endl;
   }
   
   for (size_t t = 0; t < tracks->size();++t){
     const reco::Track & track = (*tracks)[t];
     newTracks_->push_back(track);
     // track extras:
     auto const& extra = trackExtras->at(track.extra().key());
     newTrackExtras_->emplace_back(extra.outerPosition(), extra.outerMomentum(), extra.outerOk(),
                   extra.innerPosition(),extra.innerMomentum(), extra.innerOk(),
                   extra.outerStateCovariance(), extra.outerDetId(),
                   extra.innerStateCovariance(), extra.innerDetId(),
                   extra.seedDirection(),
                   //If TrajectorySeeds are needed, then their list must be gotten from the
                   // secondary event directly and looked up similarly to TrackExtras.
                   //We can't use a default constructed RefToBase due to a bug in RefToBase
                   // which causes an seg fault when calling isAvailable on a default constructed one.
                   edm::RefToBase<TrajectorySeed>{edm::Ref<std::vector<TrajectorySeed>>{}});
     newTracks_->back().setExtra( reco::TrackExtraRef( rNewTrackExtras, newTracks_->size() - 1) );
     // rechits:
     // note: extra.recHit(i) does not work for pileup events
     // probably the Ref does not know its product id applies on a pileup event
     auto & newExtra = newTrackExtras_->back();
     auto const firstTrackIndex = newHits_->size();
     for(unsigned int i = 0;i<extra.recHitsSize();i++){
       newHits_->push_back( (*hits)[extra.recHit(i).key()] );
     }
     newExtra.setHits( rNewHits, firstTrackIndex, newHits_->size() - firstTrackIndex);
   }
 }

void RecoTrackAccumulator::finalizeEvent	(	edm::Event &	e,
		edm::EventSetup const &	c
	)

virtual

Implements DigiAccumulatorMixMod.

Definition at line 49 of file RecoTrackAccumulator.cc.

References newHits_, newTrackExtras_, newTracks_, outputLabel, and edm::Event::put().

                                                                                  {
   
   e.put( newTracks_, outputLabel );
   e.put( newHits_, outputLabel );
   e.put( newTrackExtras_, outputLabel );
 }

void RecoTrackAccumulator::initializeEvent	(	edm::Event const &	e,
		edm::EventSetup const &	c
	)

virtual

Implements DigiAccumulatorMixMod.

Definition at line 27 of file RecoTrackAccumulator.cc.

References alignCSCRings::e, newHits_, newTrackExtras_, newTracks_, outputLabel, rNewHits, rNewTrackExtras, and rNewTracks.

                                                                                          {
     
   newTracks_ = std::auto_ptr<reco::TrackCollection>(new reco::TrackCollection);
   newHits_ = std::auto_ptr<TrackingRecHitCollection>(new TrackingRecHitCollection);
   newTrackExtras_ = std::auto_ptr<reco::TrackExtraCollection>(new reco::TrackExtraCollection);
   
   // this is needed to get the ProductId of the TrackExtra and TrackingRecHit and Track collections
   rNewTracks=const_cast<edm::Event&>( e ).getRefBeforePut<reco::TrackCollection>(outputLabel);
   rNewTrackExtras=const_cast<edm::Event&>( e ).getRefBeforePut<reco::TrackExtraCollection>(outputLabel);
   rNewHits=const_cast<edm::Event&>( e ).getRefBeforePut<TrackingRecHitCollection>(outputLabel);
 }