#include <DataMixingTrackingParticleWorker.h>

Public Member Functions
void	addTrackingParticlePileups (const int bcr, const edm::EventPrincipal , unsigned int EventId, ModuleCallingContext const )

void	addTrackingParticleSignals (const edm::Event &e)

	DataMixingTrackingParticleWorker ()

	DataMixingTrackingParticleWorker (const edm::ParameterSet &ps, edm::ConsumesCollector &&iC)

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

void	putTrackingParticle (edm::Event &e)

virtual	~DataMixingTrackingParticleWorker ()

Private Attributes
std::string	CSCStripLinkCollectionDM_

edm::InputTag	CSCStripLinkPileInputTag_

edm::EDGetTokenT< edm::DetSetVector< StripDigiSimLink > >	CSCStripLinkPileToken_

edm::EDGetTokenT< edm::DetSetVector< StripDigiSimLink > >	CSCStripLinkSigToken_

std::string	CSCWireLinkCollectionDM_

edm::InputTag	CSCWireLinkPileInputTag_

edm::EDGetTokenT< edm::DetSetVector< StripDigiSimLink > >	CSCWireLinkPileToken_

edm::EDGetTokenT< edm::DetSetVector< StripDigiSimLink > >	CSCWireLinkSigToken_

std::string	DTLinkCollectionDM_

edm::InputTag	DTLinkPileInputTag_

edm::EDGetTokenT< MuonDigiCollection< DTLayerId, DTDigiSimLink > >	DTLinkPileToken_

edm::EDGetTokenT< MuonDigiCollection< DTLayerId, DTDigiSimLink > >	DTLinkSigToken_

std::unique_ptr< edm::DetSetVector< StripDigiSimLink > >	NewCSCStripLinkList_

std::unique_ptr< edm::DetSetVector< StripDigiSimLink > >	NewCSCWireLinkList_

std::unique_ptr< MuonDigiCollection< DTLayerId, DTDigiSimLink > >	NewDTLinkList_

std::unique_ptr< edm::DetSetVector< PixelDigiSimLink > >	NewPixelLinkList_

std::unique_ptr< edm::DetSetVector< RPCDigiSimLink > >	NewRPCLinkList_

std::unique_ptr< edm::DetSetVector< StripDigiSimLink > >	NewStripLinkList_

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

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

std::string	PixelLinkCollectionDM_

edm::InputTag	PixelLinkPileInputTag_

edm::EDGetTokenT< edm::DetSetVector< PixelDigiSimLink > >	PixelLinkPileToken_

edm::EDGetTokenT< edm::DetSetVector< PixelDigiSimLink > >	PixelLinkSigToken_

std::string	RPCLinkCollectionDM_

edm::InputTag	RPCLinkPileInputTag_

edm::EDGetTokenT< edm::DetSetVector< RPCDigiSimLink > >	RPCLinkPileToken_

edm::EDGetTokenT< edm::DetSetVector< RPCDigiSimLink > >	RPCLinkSigToken_

std::string	StripLinkCollectionDM_

edm::InputTag	StripLinkPileInputTag_

edm::EDGetTokenT< edm::DetSetVector< StripDigiSimLink > >	StripLinkPileToken_

edm::EDGetTokenT< edm::DetSetVector< StripDigiSimLink > >	StripLinkSigToken_

std::vector< TrackingVertex >	TempVertexList_

std::string	TrackingParticleCollectionDM_

edm::InputTag	TrackingParticlecollectionSig_

edm::InputTag	TrackingParticleLabelSig_

edm::InputTag	TrackingParticlePileInputTag_

TrackingParticleRefProd	TrackListRef_

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

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

TrackingVertexRefProd	VertexListRef_

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

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

Detailed Description

Definition at line 44 of file DataMixingTrackingParticleWorker.h.

Constructor & Destructor Documentation

DataMixingTrackingParticleWorker::DataMixingTrackingParticleWorker ( )

Definition at line 38 of file DataMixingTrackingParticleWorker.cc.

38 { }

DataMixingTrackingParticleWorker::DataMixingTrackingParticleWorker	(	const edm::ParameterSet &	ps,
		edm::ConsumesCollector &&	iC
	)

explicit

standard constructor

Definition at line 41 of file DataMixingTrackingParticleWorker.cc.

References edm::ParameterSet::getParameter(), and AlCaHLTBitMon_QueryRunRegistry::string.

   {                                                         
 
     // get the subdetector names
     //    this->getSubdetectorNames();  //something like this may be useful to check what we are supposed to do...
 
     // declare the products to produce
 
     TrackingParticleLabelSig_  = ps.getParameter<edm::InputTag>("TrackingParticleLabelSig");
 
     TrackingParticlePileInputTag_ = ps.getParameter<edm::InputTag>("TrackingParticlePileInputTag");
 
     TrackingParticleCollectionDM_  = ps.getParameter<std::string>("TrackingParticleCollectionDM");
 
     TrackSigToken_ = iC.consumes<std::vector<TrackingParticle> >(TrackingParticleLabelSig_);
     TrackPileToken_ = iC.consumes<std::vector<TrackingParticle> >(TrackingParticlePileInputTag_);
 
     VtxSigToken_ = iC.consumes<std::vector<TrackingVertex> >(TrackingParticleLabelSig_);
     VtxPileToken_ = iC.consumes<std::vector<TrackingVertex> >(TrackingParticlePileInputTag_);
 
     // Pixel and Strip DigiSimlinks
 
     StripLinkPileInputTag_ = ps.getParameter<edm::InputTag>("StripDigiSimLinkPileInputTag");
     PixelLinkPileInputTag_ = ps.getParameter<edm::InputTag>("PixelDigiSimLinkPileInputTag");
     StripLinkCollectionDM_ = ps.getParameter<std::string>("StripDigiSimLinkCollectionDM");
     PixelLinkCollectionDM_ = ps.getParameter<std::string>("PixelDigiSimLinkCollectionDM");
 
     StripLinkSigToken_ = iC.consumes<edm::DetSetVector<StripDigiSimLink> >(ps.getParameter<edm::InputTag>("StripDigiSimLinkLabelSig"));
     StripLinkPileToken_ = iC.consumes<edm::DetSetVector<StripDigiSimLink> >(StripLinkPileInputTag_);
     PixelLinkSigToken_ = iC.consumes<edm::DetSetVector<PixelDigiSimLink> >(ps.getParameter<edm::InputTag>("PixelDigiSimLinkLabelSig"));
     PixelLinkPileToken_ = iC.consumes<edm::DetSetVector<PixelDigiSimLink> >(PixelLinkPileInputTag_);
 
     // Muon DigiSimLinks
 
     DTLinkPileInputTag_ = ps.getParameter<edm::InputTag>("DTDigiSimLinkPileInputTag");
     RPCLinkPileInputTag_ = ps.getParameter<edm::InputTag>("RPCDigiSimLinkPileInputTag");
     CSCWireLinkPileInputTag_ = ps.getParameter<edm::InputTag>("CSCWireDigiSimLinkPileInputTag");
     CSCStripLinkPileInputTag_ = ps.getParameter<edm::InputTag>("CSCStripDigiSimLinkPileInputTag");
 
     DTLinkCollectionDM_ = ps.getParameter<std::string>("DTDigiSimLinkDM");
     RPCLinkCollectionDM_ = ps.getParameter<std::string>("RPCDigiSimLinkDM");
     CSCWireLinkCollectionDM_ = ps.getParameter<std::string>("CSCWireDigiSimLinkDM");
     CSCStripLinkCollectionDM_ = ps.getParameter<std::string>("CSCStripDigiSimLinkDM");
 
     CSCWireLinkSigToken_ = iC.consumes<edm::DetSetVector<StripDigiSimLink> >(ps.getParameter<edm::InputTag>("CSCWireDigiSimLinkLabelSig"));
     CSCWireLinkPileToken_ = iC.consumes<edm::DetSetVector<StripDigiSimLink> >(CSCWireLinkPileInputTag_);
     CSCStripLinkSigToken_ = iC.consumes<edm::DetSetVector<StripDigiSimLink> >(ps.getParameter<edm::InputTag>("CSCStripDigiSimLinkLabelSig"));
     CSCStripLinkPileToken_ = iC.consumes<edm::DetSetVector<StripDigiSimLink> >(CSCStripLinkPileInputTag_);
     DTLinkSigToken_ = iC.consumes< MuonDigiCollection<DTLayerId, DTDigiSimLink> >(ps.getParameter<edm::InputTag>("DTDigiSimLinkLabelSig"));
     DTLinkPileToken_ = iC.consumes< MuonDigiCollection<DTLayerId, DTDigiSimLink> >(DTLinkPileInputTag_);
     RPCLinkSigToken_ = iC.consumes<edm::DetSetVector<RPCDigiSimLink> >(ps.getParameter<edm::InputTag>("RPCDigiSimLinkLabelSig"));
     RPCLinkPileToken_ = iC.consumes<edm::DetSetVector<RPCDigiSimLink> >(RPCLinkPileInputTag_);
 
   }

DataMixingTrackingParticleWorker::~DataMixingTrackingParticleWorker ( )

virtual

Default destructor

Definition at line 98 of file DataMixingTrackingParticleWorker.cc.

98 {

99 }

Member Function Documentation

void DataMixingTrackingParticleWorker::addTrackingParticlePileups	(	const int	bcr,
		const edm::EventPrincipal *	ep,
		unsigned int	EventId,
		ModuleCallingContext const *	mcc
	)

Definition at line 245 of file DataMixingTrackingParticleWorker.cc.

References MuonDigiCollection< IndexType, DigiType >::begin(), MuonDigiCollection< IndexType, DigiType >::end(), edm::EventPrincipal::id(), diffTreeTool::index, LogDebug, HiIsolationCommonParameters_cff::track, and l1t::tracks.

Referenced by edm::DataMixingModule::pileWorker().

                                                                      {
 
     LogDebug("DataMixingTrackingParticleWorker") <<"\n===============> adding pileups from event  "<<ep->id()<<" for bunchcrossing "<<bcr;
 
     const size_t StartingIndexV = TempVertexList_.size();  // keep track of offsets
     const size_t StartingIndexT = NewTrackList_->size();  // keep track of offsets
 
     std::shared_ptr<Wrapper<std::vector<TrackingVertex> >  const> inputVPTR =
       getProductByTag<std::vector<TrackingVertex> >(*ep, TrackingParticlePileInputTag_, mcc);
 
     if(inputVPTR ) {
 
       const std::vector<TrackingVertex>  *vtxs = const_cast< std::vector<TrackingVertex> * >(inputVPTR->product());
 
       // grab vertices, store copy
 
       for (std::vector<TrackingVertex>::const_iterator vtx = vtxs->begin();  vtx != vtxs->end();  ++vtx) {
     TempVertexList_.push_back(*vtx);
       }
     }
 
 
     std::shared_ptr<Wrapper<std::vector<TrackingParticle> >  const> inputPTR =
       getProductByTag<std::vector<TrackingParticle> >(*ep, TrackingParticlePileInputTag_, mcc);
 
     if(inputPTR ) {
 
       const std::vector<TrackingParticle>  *tracks = const_cast< std::vector<TrackingParticle> * >(inputPTR->product());
 
       // grab tracks, store copy
       for (std::vector<TrackingParticle>::const_iterator track = tracks->begin();  track != tracks->end();  ++track) {
     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 != TempVertexList_.size(); ++iVertex) {
       auto& vertex = TempVertexList_[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();
     }
 
 
     // Accumulate DigiSimLinks
     std::shared_ptr<Wrapper<edm::DetSetVector<StripDigiSimLink> > const> inputStripPtr =
       getProductByTag<edm::DetSetVector<StripDigiSimLink> >(*ep, StripLinkPileInputTag_, mcc);
     if(inputStripPtr) {
       appendDetSetVector(*NewStripLinkList_, *(inputStripPtr->product()));
     }
 
     std::shared_ptr<Wrapper<edm::DetSetVector<PixelDigiSimLink> > const> inputPixelPtr =
       getProductByTag<edm::DetSetVector<PixelDigiSimLink> >(*ep, PixelLinkPileInputTag_, mcc);
     if(inputPixelPtr) {
       appendDetSetVector(*NewPixelLinkList_, *(inputPixelPtr->product()));
     }
 
     std::shared_ptr<Wrapper<edm::DetSetVector<StripDigiSimLink> > const> CSCinputStripPtr =
       getProductByTag<edm::DetSetVector<StripDigiSimLink> >(*ep, CSCStripLinkPileInputTag_, mcc);
     if(CSCinputStripPtr) {
       appendDetSetVector(*NewCSCStripLinkList_, *(CSCinputStripPtr->product()));
     }
 
     std::shared_ptr<Wrapper<edm::DetSetVector<StripDigiSimLink> > const> CSCinputWirePtr =
       getProductByTag<edm::DetSetVector<StripDigiSimLink> >(*ep, CSCWireLinkPileInputTag_, mcc);
     if(CSCinputWirePtr) {
       appendDetSetVector(*NewCSCWireLinkList_, *(CSCinputWirePtr->product()));
     }
 
     std::shared_ptr<Wrapper<edm::DetSetVector<RPCDigiSimLink> > const> inputRPCPtr =
       getProductByTag<edm::DetSetVector<RPCDigiSimLink> >(*ep, RPCLinkPileInputTag_, mcc);
     if(inputRPCPtr) {
       appendDetSetVector(*NewRPCLinkList_, *(inputRPCPtr->product()));
     }
 
     std::shared_ptr<Wrapper< DTDigiSimLinkCollection > const> inputDTPtr =
       getProductByTag< DTDigiSimLinkCollection >(*ep, DTLinkPileInputTag_, mcc);
     if(inputDTPtr) {      
       const DTDigiSimLinkCollection*  DTLinks = const_cast< DTDigiSimLinkCollection * >(inputDTPtr->product());
       for (DTDigiSimLinkCollection::DigiRangeIterator detUnit=DTLinks->begin(); detUnit !=DTLinks->end(); ++detUnit) {
     const DTLayerId& layerid = (*detUnit).first;
     const DTDigiSimLinkCollection::Range& range = (*detUnit).second;
     NewDTLinkList_->put(range,layerid);
       }
     }
 
   } // end of addPileups

void DataMixingTrackingParticleWorker::addTrackingParticleSignals ( const edm::Event & e )

Definition at line 129 of file DataMixingTrackingParticleWorker.cc.

References MuonDigiCollection< IndexType, DigiType >::begin(), MuonDigiCollection< IndexType, DigiType >::end(), edm::Event::getByToken(), diffTreeTool::index, edm::HandleBase::isValid(), HiIsolationCommonParameters_cff::track, and l1t::tracks.

Referenced by edm::DataMixingModule::addSignals().

                                                                                      { 
 
     // grab Vertices, store copy, preserving indices.  Easier to loop over vertices first - fewer links
 
     edm::Handle<std::vector<TrackingVertex>> vtxs;
     e.getByToken(VtxSigToken_, vtxs);
 
     const size_t StartingIndexV = TempVertexList_.size();  // should be zero here, but keep for consistency
     const size_t StartingIndexT = NewTrackList_->size();  // should be zero here, but keep for consistency
 
     if (vtxs.isValid()) {
 
       for (std::vector<TrackingVertex>::const_iterator vtx = vtxs->begin();  vtx != vtxs->end();  ++vtx) {
     TempVertexList_.push_back(*vtx);
       }
     }
 
     // grab tracks, store copy
 
     edm::Handle<std::vector<TrackingParticle>> tracks;
     e.getByToken(TrackSigToken_, tracks);
 
     if (tracks.isValid()) {
       for (std::vector<TrackingParticle>::const_iterator track = tracks->begin();  track != tracks->end();  ++track) {
     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
     std::vector<decltype(TrackingParticleRef().index())> sourceTrackIndices;
     std::vector<decltype(TrackingParticleRef().index())> daughterTrackIndices;
     for (auto & vertex : TempVertexList_ ) {
 
       // 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();
     }
 
     // Accumulate DigiSimLinks
     edm::Handle<edm::DetSetVector<StripDigiSimLink> > stripLinks;
     e.getByToken(StripLinkSigToken_, stripLinks);
     if(stripLinks.isValid()) {
       appendDetSetVector(*NewStripLinkList_, *stripLinks);
     }
 
     edm::Handle<edm::DetSetVector<PixelDigiSimLink> > pixelLinks;
     e.getByToken(PixelLinkSigToken_, pixelLinks);
     if(pixelLinks.isValid()) {
       appendDetSetVector(*NewPixelLinkList_, *pixelLinks);
     }
 
     edm::Handle<edm::DetSetVector<StripDigiSimLink> > CSCstripLinks;
     e.getByToken(CSCStripLinkSigToken_, CSCstripLinks);
     if(CSCstripLinks.isValid()) {
       appendDetSetVector(*NewCSCStripLinkList_, *CSCstripLinks);
     }
 
     edm::Handle<edm::DetSetVector<StripDigiSimLink> > CSCwireLinks;
     e.getByToken(CSCWireLinkSigToken_, CSCwireLinks);
     if(CSCwireLinks.isValid()) {
       appendDetSetVector(*NewCSCWireLinkList_, *CSCwireLinks);
     }
 
     edm::Handle<edm::DetSetVector<RPCDigiSimLink> > RPCLinks;
     e.getByToken(RPCLinkSigToken_, RPCLinks);
     if(RPCLinks.isValid()) {
       appendDetSetVector(*NewRPCLinkList_, *RPCLinks);
     }
 
     edm::Handle< DTDigiSimLinkCollection > DTLinks;
     e.getByToken(DTLinkSigToken_, DTLinks);
     if(DTLinks.isValid()) {
       for (DTDigiSimLinkCollection::DigiRangeIterator detUnit=DTLinks->begin(); detUnit !=DTLinks->end(); ++detUnit) {
     const DTLayerId& layerid = (*detUnit).first;
     const DTDigiSimLinkCollection::Range& range = (*detUnit).second;
     NewDTLinkList_->put(range,layerid);
       }
     }
 
   } // end of addTrackingParticleSignals

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

virtual

Definition at line 103 of file DataMixingTrackingParticleWorker.cc.

References MillePedeFileConverter_cfg::e.

Referenced by edm::DataMixingModule::initializeEvent().

                                                                                                        {    
 
     // Create new track/vertex lists, getting references, too, so that we can cross-link everything
 
     NewTrackList_ = std::unique_ptr<std::vector<TrackingParticle>>(new std::vector<TrackingParticle>());
     //NewVertexList_ = std::unique_ptr<std::vector<TrackingVertex>>(new std::vector<TrackingVertex>());
     TempVertexList_ = std::vector<TrackingVertex>();
 
     TrackListRef_  =const_cast<edm::Event&>( e ).getRefBeforePut< std::vector<TrackingParticle> >(TrackingParticleCollectionDM_); 
     VertexListRef_ =const_cast<edm::Event&>( e ).getRefBeforePut< std::vector<TrackingVertex> >(TrackingParticleCollectionDM_);    
 
     // tracker
 
     NewStripLinkList_ = std::make_unique<edm::DetSetVector<StripDigiSimLink> >();
     NewPixelLinkList_ = std::make_unique<edm::DetSetVector<PixelDigiSimLink> >();
 
     // muons
 
     NewCSCStripLinkList_ = std::make_unique<edm::DetSetVector<StripDigiSimLink> >();
     NewCSCWireLinkList_ = std::make_unique<edm::DetSetVector<StripDigiSimLink> >();
     NewRPCLinkList_ = std::make_unique<edm::DetSetVector<RPCDigiSimLink> >();
     NewDTLinkList_ = std::make_unique< MuonDigiCollection<DTLayerId, DTDigiSimLink> >();
 
   }                    

void DataMixingTrackingParticleWorker::putTrackingParticle ( edm::Event & e )

Definition at line 373 of file DataMixingTrackingParticleWorker.cc.

References eostools::move(), and edm::Event::put().

Referenced by edm::DataMixingModule::put().

                                                                         {
 
     // collection of Vertices to put in the event
 
     NewVertexList_ = std::unique_ptr<std::vector<TrackingVertex>>(new std::vector<TrackingVertex>(TempVertexList_));
 
     // put the collection of digis in the event   
     LogInfo("DataMixingTrackingParticleWorker") << "total # Merged Tracks: " << NewTrackList_->size() ;
 
     // put collections
 
     e.put(std::move(NewTrackList_), TrackingParticleCollectionDM_ );
     e.put(std::move(NewVertexList_), TrackingParticleCollectionDM_ );
 
     e.put(std::move(NewStripLinkList_), StripLinkCollectionDM_ );
     e.put(std::move(NewPixelLinkList_), PixelLinkCollectionDM_ );
 
     e.put(std::move(NewCSCStripLinkList_), CSCStripLinkCollectionDM_ );
     e.put(std::move(NewCSCWireLinkList_), CSCWireLinkCollectionDM_ );
     e.put(std::move(NewRPCLinkList_), RPCLinkCollectionDM_ );
     e.put(std::move(NewDTLinkList_), DTLinkCollectionDM_ );
 
 
     // clear local storage for this event
     //NewTrackList_.clear();
     TempVertexList_.clear();
   }

Member Data Documentation

std::string edm::DataMixingTrackingParticleWorker::CSCStripLinkCollectionDM_

private

Definition at line 83 of file DataMixingTrackingParticleWorker.h.

edm::InputTag edm::DataMixingTrackingParticleWorker::CSCStripLinkPileInputTag_

private

Definition at line 76 of file DataMixingTrackingParticleWorker.h.

edm::EDGetTokenT<edm::DetSetVector<StripDigiSimLink> > edm::DataMixingTrackingParticleWorker::CSCStripLinkPileToken_

private

Definition at line 97 of file DataMixingTrackingParticleWorker.h.

edm::EDGetTokenT<edm::DetSetVector<StripDigiSimLink> > edm::DataMixingTrackingParticleWorker::CSCStripLinkSigToken_

private

Definition at line 96 of file DataMixingTrackingParticleWorker.h.

std::string edm::DataMixingTrackingParticleWorker::CSCWireLinkCollectionDM_

private

Definition at line 82 of file DataMixingTrackingParticleWorker.h.

edm::InputTag edm::DataMixingTrackingParticleWorker::CSCWireLinkPileInputTag_

private

Definition at line 75 of file DataMixingTrackingParticleWorker.h.

edm::EDGetTokenT<edm::DetSetVector<StripDigiSimLink> > edm::DataMixingTrackingParticleWorker::CSCWireLinkPileToken_

private

Definition at line 95 of file DataMixingTrackingParticleWorker.h.

edm::EDGetTokenT<edm::DetSetVector<StripDigiSimLink> > edm::DataMixingTrackingParticleWorker::CSCWireLinkSigToken_

private

Definition at line 94 of file DataMixingTrackingParticleWorker.h.

std::string edm::DataMixingTrackingParticleWorker::DTLinkCollectionDM_

private

Definition at line 80 of file DataMixingTrackingParticleWorker.h.

edm::InputTag edm::DataMixingTrackingParticleWorker::DTLinkPileInputTag_

private

Definition at line 73 of file DataMixingTrackingParticleWorker.h.

edm::EDGetTokenT< MuonDigiCollection<DTLayerId, DTDigiSimLink> > edm::DataMixingTrackingParticleWorker::DTLinkPileToken_

private

Definition at line 99 of file DataMixingTrackingParticleWorker.h.

edm::EDGetTokenT< MuonDigiCollection<DTLayerId, DTDigiSimLink> > edm::DataMixingTrackingParticleWorker::DTLinkSigToken_

private

Definition at line 98 of file DataMixingTrackingParticleWorker.h.

std::unique_ptr< edm::DetSetVector<StripDigiSimLink> > edm::DataMixingTrackingParticleWorker::NewCSCStripLinkList_

private

Definition at line 114 of file DataMixingTrackingParticleWorker.h.

std::unique_ptr< edm::DetSetVector<StripDigiSimLink> > edm::DataMixingTrackingParticleWorker::NewCSCWireLinkList_

private

Definition at line 113 of file DataMixingTrackingParticleWorker.h.

std::unique_ptr< MuonDigiCollection<DTLayerId,DTDigiSimLink> > edm::DataMixingTrackingParticleWorker::NewDTLinkList_

private

Definition at line 111 of file DataMixingTrackingParticleWorker.h.

std::unique_ptr<edm::DetSetVector<PixelDigiSimLink> > edm::DataMixingTrackingParticleWorker::NewPixelLinkList_

private

Definition at line 110 of file DataMixingTrackingParticleWorker.h.

std::unique_ptr< edm::DetSetVector<RPCDigiSimLink> > edm::DataMixingTrackingParticleWorker::NewRPCLinkList_

private

Definition at line 112 of file DataMixingTrackingParticleWorker.h.

std::unique_ptr<edm::DetSetVector<StripDigiSimLink> > edm::DataMixingTrackingParticleWorker::NewStripLinkList_

private

Definition at line 109 of file DataMixingTrackingParticleWorker.h.

std::unique_ptr<std::vector<TrackingParticle> > edm::DataMixingTrackingParticleWorker::NewTrackList_

private

Definition at line 105 of file DataMixingTrackingParticleWorker.h.

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

private

Definition at line 106 of file DataMixingTrackingParticleWorker.h.

std::string edm::DataMixingTrackingParticleWorker::PixelLinkCollectionDM_

private

Definition at line 79 of file DataMixingTrackingParticleWorker.h.

edm::InputTag edm::DataMixingTrackingParticleWorker::PixelLinkPileInputTag_

private

Definition at line 72 of file DataMixingTrackingParticleWorker.h.

edm::EDGetTokenT<edm::DetSetVector<PixelDigiSimLink> > edm::DataMixingTrackingParticleWorker::PixelLinkPileToken_

private

Definition at line 93 of file DataMixingTrackingParticleWorker.h.

edm::EDGetTokenT<edm::DetSetVector<PixelDigiSimLink> > edm::DataMixingTrackingParticleWorker::PixelLinkSigToken_

private

Definition at line 92 of file DataMixingTrackingParticleWorker.h.

std::string edm::DataMixingTrackingParticleWorker::RPCLinkCollectionDM_

private

Definition at line 81 of file DataMixingTrackingParticleWorker.h.

edm::InputTag edm::DataMixingTrackingParticleWorker::RPCLinkPileInputTag_

private

Definition at line 74 of file DataMixingTrackingParticleWorker.h.

edm::EDGetTokenT<edm::DetSetVector<RPCDigiSimLink> > edm::DataMixingTrackingParticleWorker::RPCLinkPileToken_

private

Definition at line 101 of file DataMixingTrackingParticleWorker.h.

edm::EDGetTokenT<edm::DetSetVector<RPCDigiSimLink> > edm::DataMixingTrackingParticleWorker::RPCLinkSigToken_

private

Definition at line 100 of file DataMixingTrackingParticleWorker.h.

std::string edm::DataMixingTrackingParticleWorker::StripLinkCollectionDM_

private

Definition at line 78 of file DataMixingTrackingParticleWorker.h.

edm::InputTag edm::DataMixingTrackingParticleWorker::StripLinkPileInputTag_

private

Definition at line 71 of file DataMixingTrackingParticleWorker.h.

edm::EDGetTokenT<edm::DetSetVector<StripDigiSimLink> > edm::DataMixingTrackingParticleWorker::StripLinkPileToken_

private

Definition at line 91 of file DataMixingTrackingParticleWorker.h.

edm::EDGetTokenT<edm::DetSetVector<StripDigiSimLink> > edm::DataMixingTrackingParticleWorker::StripLinkSigToken_

private

Definition at line 90 of file DataMixingTrackingParticleWorker.h.

std::vector<TrackingVertex> edm::DataMixingTrackingParticleWorker::TempVertexList_

private

Definition at line 107 of file DataMixingTrackingParticleWorker.h.

std::string edm::DataMixingTrackingParticleWorker::TrackingParticleCollectionDM_

private

Definition at line 69 of file DataMixingTrackingParticleWorker.h.

edm::InputTag edm::DataMixingTrackingParticleWorker::TrackingParticlecollectionSig_

private

Definition at line 66 of file DataMixingTrackingParticleWorker.h.

edm::InputTag edm::DataMixingTrackingParticleWorker::TrackingParticleLabelSig_

private

Definition at line 67 of file DataMixingTrackingParticleWorker.h.

edm::InputTag edm::DataMixingTrackingParticleWorker::TrackingParticlePileInputTag_

private

Definition at line 68 of file DataMixingTrackingParticleWorker.h.

TrackingParticleRefProd edm::DataMixingTrackingParticleWorker::TrackListRef_

private

Definition at line 116 of file DataMixingTrackingParticleWorker.h.

edm::EDGetTokenT<std::vector<TrackingParticle> > edm::DataMixingTrackingParticleWorker::TrackPileToken_

private

Definition at line 86 of file DataMixingTrackingParticleWorker.h.

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

private

Definition at line 85 of file DataMixingTrackingParticleWorker.h.

TrackingVertexRefProd edm::DataMixingTrackingParticleWorker::VertexListRef_

private

Definition at line 117 of file DataMixingTrackingParticleWorker.h.

edm::EDGetTokenT<std::vector<TrackingVertex> > edm::DataMixingTrackingParticleWorker::VtxPileToken_

private

Definition at line 88 of file DataMixingTrackingParticleWorker.h.

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

private

Definition at line 87 of file DataMixingTrackingParticleWorker.h.

Public Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation