Inheritance diagram for PreMixingTrackingParticleWorker:

Public Member Functions
void	addPileups (PileUpEventPrincipal const &pep, edm::EventSetup const &iSetup) override

void	addSignals (edm::Event const &iEvent, edm::EventSetup const &iSetup) override

void	initializeEvent (edm::Event const &iEvent, edm::EventSetup const &iSetup) override

	PreMixingTrackingParticleWorker (const edm::ParameterSet &ps, edm::ProducesCollector, edm::ConsumesCollector &&iC)

void	put (edm::Event &iEvent, edm::EventSetup const &iSetup, std::vector< PileupSummaryInfo > const &ps, int bunchSpacing) override

	~PreMixingTrackingParticleWorker () override=default

Public Member Functions inherited from PreMixingWorker
virtual void	beginLuminosityBlock (edm::LuminosityBlock const &iLumi, edm::EventSetup const &iSetup)

virtual void	beginRun (edm::Run const &iRun, edm::EventSetup const &iSetup)

virtual void	endRun ()

virtual void	finalizeBunchCrossing (edm::Event &iEvent, edm::EventSetup const &iSetup, int bunchCrossing)

virtual void	initializeBunchCrossing (edm::Event const &iEvent, edm::EventSetup const &iSetup, int bunchCrossing)

	PreMixingWorker ()=default

virtual	~PreMixingWorker ()=default

Private Member Functions
void	add (const std::vector< TrackingParticle > &particles, const std::vector< TrackingVertex > &vertices)

Private Attributes
std::unique_ptr< std::vector< TrackingParticle > >	NewTrackList_

std::unique_ptr< std::vector< TrackingVertex > >	NewVertexList_

std::string	TrackingParticleCollectionDM_

edm::InputTag	TrackingParticlePileInputTag_

TrackingParticleRefProd	TrackListRef_

edm::EDGetTokenT< std::vector< TrackingParticle > >	TrackSigToken_

TrackingVertexRefProd	VertexListRef_

edm::EDGetTokenT< std::vector< TrackingVertex > >	VtxSigToken_

Detailed Description

Definition at line 15 of file PreMixingTrackingParticleWorker.cc.

Constructor & Destructor Documentation

◆ PreMixingTrackingParticleWorker()

PreMixingTrackingParticleWorker::PreMixingTrackingParticleWorker	(	const edm::ParameterSet &	ps,
		edm::ProducesCollector	producesCollector,
		edm::ConsumesCollector &&	iC
	)

Definition at line 45 of file PreMixingTrackingParticleWorker.cc.

     : TrackSigToken_(iC.consumes<std::vector<TrackingParticle>>(ps.getParameter<edm::InputTag>("labelSig"))),
       VtxSigToken_(iC.consumes<std::vector<TrackingVertex>>(ps.getParameter<edm::InputTag>("labelSig"))),
       TrackingParticlePileInputTag_(ps.getParameter<edm::InputTag>("pileInputTag")),
       TrackingParticleCollectionDM_(ps.getParameter<std::string>("collectionDM")) {
   producesCollector.produces<std::vector<TrackingParticle>>(TrackingParticleCollectionDM_);
   producesCollector.produces<std::vector<TrackingVertex>>(TrackingParticleCollectionDM_);
 }

References edm::ProducesCollector::produces(), and TrackingParticleCollectionDM_.

◆ ~PreMixingTrackingParticleWorker()

PreMixingTrackingParticleWorker::~PreMixingTrackingParticleWorker ( )

overridedefault

Member Function Documentation

◆ add()

void PreMixingTrackingParticleWorker::add	(	const std::vector< TrackingParticle > &	particles,
		const std::vector< TrackingVertex > &	vertices
	)

private

Definition at line 96 of file PreMixingTrackingParticleWorker.cc.

                                                                                      {
   const size_t StartingIndexV = NewVertexList_->size();
   const size_t StartingIndexT = NewTrackList_->size();
  
   // grab Vertices, store copy, preserving indices.  Easier to loop over
   // vertices first - fewer links
   for (const auto &vtx : vertices) {
     NewVertexList_->push_back(vtx);
   }
  
   // grab tracks, store copy
   for (const auto &track : particles) {
     const auto &oldRef = track.parentVertex();
     auto newRef = TrackingVertexRef(VertexListRef_, oldRef.index() + StartingIndexV);
     NewTrackList_->push_back(track);
  
     auto &Ntrack = NewTrackList_->back();  // modify copy
  
     Ntrack.setParentVertex(newRef);
     Ntrack.clearDecayVertices();
  
     // next, loop over daughter vertices, same strategy
     for (auto const &vertexRef : track.decayVertices()) {
       auto newRef = TrackingVertexRef(VertexListRef_, vertexRef.index() + StartingIndexV);
       Ntrack.addDecayVertex(newRef);
     }
   }
  
   // Now that tracks are handled, go back and put correct Refs in vertices
   // Operate only on the added pileup vertices, and leave the already-existing
   // vertices untouched
   std::vector<decltype(TrackingParticleRef().index())> sourceTrackIndices;
   std::vector<decltype(TrackingParticleRef().index())> daughterTrackIndices;
   for (size_t iVertex = StartingIndexV; iVertex != NewVertexList_->size(); ++iVertex) {
     auto &vertex = (*NewVertexList_)[iVertex];
  
     // Need to copy the indices before clearing the vectors
     sourceTrackIndices.reserve(vertex.sourceTracks().size());
     daughterTrackIndices.reserve(vertex.daughterTracks().size());
     for (auto const &ref : vertex.sourceTracks())
       sourceTrackIndices.push_back(ref.index());
     for (auto const &ref : vertex.daughterTracks())
       daughterTrackIndices.push_back(ref.index());
  
     vertex.clearParentTracks();
     vertex.clearDaughterTracks();
  
     for (auto index : sourceTrackIndices) {
       auto newRef = TrackingParticleRef(TrackListRef_, index + StartingIndexT);
       vertex.addParentTrack(newRef);
     }
  
     // next, loop over daughter tracks, same strategy
     for (auto index : daughterTrackIndices) {
       auto newRef = TrackingParticleRef(TrackListRef_, index + StartingIndexT);
       vertex.addDaughterTrack(newRef);
     }
  
     sourceTrackIndices.clear();
     daughterTrackIndices.clear();
   }
 }

References NewTrackList_, NewVertexList_, ecalTrigSettings_cff::particles, HLT_FULL_cff::track, TrackListRef_, trackerHitRTTI::vector, bphysicsOniaDQM_cfi::vertex, VertexListRef_, pwdgSkimBPark_cfi::vertices, and extraflags_cff::vtx.

Referenced by addPileups(), addSignals(), and counter.Counter::register().

◆ addPileups()

void PreMixingTrackingParticleWorker::addPileups	(	PileUpEventPrincipal const &	pep,
		edm::EventSetup const &	iSetup
	)

overridevirtual

Implements PreMixingWorker.

Definition at line 81 of file PreMixingTrackingParticleWorker.cc.

                                                                                                              {
   LogDebug("PreMixingTrackingParticleWorker") << "\n===============> adding pileups from event  "
                                               << pep.principal().id() << " for bunchcrossing " << pep.bunchCrossing();
  
   edm::Handle<std::vector<TrackingParticle>> inputHandle;
   pep.getByLabel(TrackingParticlePileInputTag_, inputHandle);
  
   edm::Handle<std::vector<TrackingVertex>> inputVHandle;
   pep.getByLabel(TrackingParticlePileInputTag_, inputVHandle);
  
   if (inputHandle.isValid() && inputVHandle.isValid()) {
     add(*inputHandle, *inputVHandle);
   }
 }

References add(), PileUpEventPrincipal::bunchCrossing(), PileUpEventPrincipal::getByLabel(), edm::EventPrincipal::id(), edm::HandleBase::isValid(), LogDebug, PileUpEventPrincipal::principal(), and TrackingParticlePileInputTag_.

◆ addSignals()

void PreMixingTrackingParticleWorker::addSignals	(	edm::Event const &	iEvent,
		edm::EventSetup const &	iSetup
	)

overridevirtual

Implements PreMixingWorker.

Definition at line 69 of file PreMixingTrackingParticleWorker.cc.

                                                                                                     {
   edm::Handle<std::vector<TrackingParticle>> tracks;
   iEvent.getByToken(TrackSigToken_, tracks);
  
   edm::Handle<std::vector<TrackingVertex>> vtxs;
   iEvent.getByToken(VtxSigToken_, vtxs);
  
   if (tracks.isValid() && vtxs.isValid()) {
     add(*tracks, *vtxs);
   }
 }

References add(), iEvent, edm::HandleBase::isValid(), tracks, TrackSigToken_, and VtxSigToken_.

◆ initializeEvent()

void PreMixingTrackingParticleWorker::initializeEvent	(	edm::Event const &	iEvent,
		edm::EventSetup const &	iSetup
	)

overridevirtual

Implements PreMixingWorker.

Definition at line 56 of file PreMixingTrackingParticleWorker.cc.

                                                                                                          {
   NewTrackList_ = std::make_unique<std::vector<TrackingParticle>>();
   NewVertexList_ = std::make_unique<std::vector<TrackingVertex>>();
  
   // need RefProds in order to re-key the particle<->vertex refs
   // TODO: try to remove const_cast, requires making Event non-const in
   // BMixingModule::initializeEvent
   TrackListRef_ =
       const_cast<edm::Event &>(iEvent).getRefBeforePut<std::vector<TrackingParticle>>(TrackingParticleCollectionDM_);
   VertexListRef_ =
       const_cast<edm::Event &>(iEvent).getRefBeforePut<std::vector<TrackingVertex>>(TrackingParticleCollectionDM_);
 }

References iEvent, NewTrackList_, NewVertexList_, TrackingParticleCollectionDM_, TrackListRef_, and VertexListRef_.

◆ put()

void PreMixingTrackingParticleWorker::put	(	edm::Event &	iEvent,
		edm::EventSetup const &	iSetup,
		std::vector< PileupSummaryInfo > const &	ps,
		int	bunchSpacing
	)

overridevirtual

Implements PreMixingWorker.

Definition at line 160 of file PreMixingTrackingParticleWorker.cc.

                                                             {
   edm::LogInfo("PreMixingTrackingParticleWorker") << "total # Merged Tracks: " << NewTrackList_->size();
   iEvent.put(std::move(NewTrackList_), TrackingParticleCollectionDM_);
   iEvent.put(std::move(NewVertexList_), TrackingParticleCollectionDM_);
 }