#include <RecoTrackAccumulator.h>

Inheritance diagram for RecoTrackAccumulator:

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

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

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

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

	RecoTrackAccumulator (const edm::ParameterSet &conf, edm::ProducesCollector, edm::ConsumesCollector &iC)

	~RecoTrackAccumulator () override

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::unique_ptr< TrackingRecHitCollection >	newHits_

std::unique_ptr< reco::TrackExtraCollection >	newTrackExtras_

std::unique_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 33 of file RecoTrackAccumulator.h.

Constructor & Destructor Documentation

RecoTrackAccumulator::RecoTrackAccumulator	(	const edm::ParameterSet &	conf,
		edm::ProducesCollector	producesCollector,
		edm::ConsumesCollector &	iC
	)

explicit

Definition at line 7 of file RecoTrackAccumulator.cc.

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

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

RecoTrackAccumulator::~RecoTrackAccumulator ( )

override

Definition at line 22 of file RecoTrackAccumulator.cc.

22 {}

Member Function Documentation

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

overridevirtual

Implements DigiAccumulatorMixMod.

Definition at line 35 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 39 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 54 of file RecoTrackAccumulator.cc.

References DEFINE_DIGI_ACCUMULATOR, Exception, reco::Track::extra(), hfClusterShapes_cfi::hits, mps_fire::i, edm::HandleBase::isValid(), edm::Ref< C, T, F >::key(), newHits_, newTrackExtras_, newTracks_, rNewHits, rNewTrackExtras, OrderedSet::t, HLT_2018_cff::track, and PDWG_EXOHSCP_cff::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);
     newExtra.setTrajParams(extra.trajParams(), extra.chi2sX5());
     assert(newExtra.recHitsSize() == newExtra.trajParams().size());
   }
 }

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

overridevirtual

Implements DigiAccumulatorMixMod.

Definition at line 47 of file RecoTrackAccumulator.cc.

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

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

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

overridevirtual

Implements DigiAccumulatorMixMod.

Definition at line 24 of file RecoTrackAccumulator.cc.

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

                                                                                          {
   newTracks_ = std::unique_ptr<reco::TrackCollection>(new reco::TrackCollection);
   newHits_ = std::unique_ptr<TrackingRecHitCollection>(new TrackingRecHitCollection);
   newTrackExtras_ = std::unique_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);
 }