#include <Phase2TrackerDigitizer.h>

Inheritance diagram for cms::Phase2TrackerDigitizer:

Public Types
using	ModuleTypeCache = std::unordered_map< uint32_t, TrackerGeometry::ModuleType >

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

template<class T >
void	accumulate_local (T const &iEvent, edm::EventSetup const &iSetup)

virtual void	beginJob ()

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

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

void	loadAccumulator (const std::map< uint32_t, std::map< int, float > > &accumulator)

	Phase2TrackerDigitizer (const edm::ParameterSet &iConfig, edm::ProducesCollector, edm::ConsumesCollector &iC)

	~Phase2TrackerDigitizer () 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 ()

	DigiAccumulatorMixMod (DigiAccumulatorMixMod const &)=delete

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)

DigiAccumulatorMixMod const &	operator= (DigiAccumulatorMixMod const &)=delete

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 Types
enum	AlgorithmType { AlgorithmType::InnerPixel, AlgorithmType::InnerPixel3D, AlgorithmType::PixelinPS, AlgorithmType::StripinPS, AlgorithmType::TwoStrip, AlgorithmType::Unknown }

using	vstring = std::vector< std::string >

Private Member Functions
void	accumulatePixelHits (edm::Handle< std::vector< PSimHit > >, size_t globalSimHitIndex, const uint32_t tofBin)

template<typename DigiType >
void	addOuterTrackerCollection (edm::Event &iEvent, const edm::EventSetup &iSetup)

void	addPixelCollection (edm::Event &iEvent, const edm::EventSetup &iSetup, const bool ot_analog)

AlgorithmType	getAlgoType (uint32_t idet)

Private Attributes
std::map< AlgorithmType, std::unique_ptr< Phase2TrackerDigitizerAlgorithm > >	algomap_

std::map< std::string, size_t >	crossingSimHitIndexOffset_
	Offset to add to the index of each sim hit to account for which crossing it's in. More...

std::map< uint32_t, const Phase2TrackerGeomDetUnit * >	detectorUnits_

bool	first_

const std::string	hitsProducer_

const bool	isOuterTrackerReadoutAnalog_

const bool	makeDigiSimLinks_

ModuleTypeCache	moduleTypeCache_

const TrackerGeometry *	pDD_ = nullptr

const edm::ESGetToken< TrackerGeometry, TrackerDigiGeometryRecord >	pDDToken_

const bool	premixStage1_

const MagneticField *	pSetup_ = nullptr

const edm::ESGetToken< MagneticField, IdealMagneticFieldRecord >	pSetupToken_

edm::ESWatcher< TrackerDigiGeometryRecord >	theTkDigiGeomWatcher_

const vstring	trackerContainers_

const TrackerTopology *	tTopo_ = nullptr

const edm::ESGetToken< TrackerTopology, TrackerTopologyRcd >	tTopoToken_

Detailed Description

Definition at line 51 of file Phase2TrackerDigitizer.h.

Member Typedef Documentation

◆ ModuleTypeCache

using cms::Phase2TrackerDigitizer::ModuleTypeCache = std::unordered_map<uint32_t, TrackerGeometry::ModuleType>

Definition at line 53 of file Phase2TrackerDigitizer.h.

◆ vstring

using cms::Phase2TrackerDigitizer::vstring = std::vector<std::string>

private

Definition at line 73 of file Phase2TrackerDigitizer.h.

Member Enumeration Documentation

◆ AlgorithmType

enum cms::Phase2TrackerDigitizer::AlgorithmType

strongprivate

Enumerator
InnerPixel
InnerPixel3D
PixelinPS
StripinPS
TwoStrip
Unknown

Definition at line 76 of file Phase2TrackerDigitizer.h.

76 { InnerPixel, InnerPixel3D, PixelinPS, StripinPS, TwoStrip, Unknown };

HitType::Unknown

Constructor & Destructor Documentation

◆ Phase2TrackerDigitizer()

cms::Phase2TrackerDigitizer::Phase2TrackerDigitizer	(	const edm::ParameterSet &	iConfig,
		edm::ProducesCollector	producesCollector,
		edm::ConsumesCollector &	iC
	)

explicit

Definition at line 61 of file Phase2TrackerDigitizer.cc.

References algomap_, edm::ParameterSet::getParameter(), InnerPixel, InnerPixel3D, makeDigiSimLinks_, PixelinPS, premixStage1_, edm::ProducesCollector::produces(), AlCaHLTBitMon_QueryRunRegistry::string, StripinPS, and TwoStrip.

       : first_(true),
         hitsProducer_(iConfig.getParameter<std::string>("hitsProducer")),
         trackerContainers_(iConfig.getParameter<std::vector<std::string> >("ROUList")),
         pDDToken_(iC.esConsumes(edm::ESInputTag("", iConfig.getParameter<std::string>("GeometryType")))),
         pSetupToken_(iC.esConsumes()),
         tTopoToken_(iC.esConsumes()),
         isOuterTrackerReadoutAnalog_(iConfig.getParameter<bool>("isOTreadoutAnalog")),
         premixStage1_(iConfig.getParameter<bool>("premixStage1")),
         makeDigiSimLinks_(
             iConfig.getParameter<edm::ParameterSet>("AlgorithmCommon").getUntrackedParameter<bool>("makeDigiSimLinks")) {
     const std::string alias1("simSiPixelDigis");
     producesCollector.produces<edm::DetSetVector<PixelDigi> >("Pixel").setBranchAlias(alias1);
     if (makeDigiSimLinks_)
       producesCollector.produces<edm::DetSetVector<PixelDigiSimLink> >("Pixel").setBranchAlias(alias1);
 
     if (!iConfig.getParameter<bool>("isOTreadoutAnalog")) {
       const std::string alias2("simSiTrackerDigis");
       if (premixStage1_) {
         // Premixing exploits the ADC field of PixelDigi to store the collected charge
         // But we still want everything else to be treated like for Phase2TrackerDigi
         producesCollector.produces<edm::DetSetVector<PixelDigi> >("Tracker").setBranchAlias(alias2);
       } else {
         producesCollector.produces<edm::DetSetVector<Phase2TrackerDigi> >("Tracker").setBranchAlias(alias2);
       }
       if (makeDigiSimLinks_)
         producesCollector.produces<edm::DetSetVector<PixelDigiSimLink> >("Tracker").setBranchAlias(alias2);
     }
     // creating algorithm objects and pushing them into the map
     algomap_[AlgorithmType::InnerPixel] = std::make_unique<PixelDigitizerAlgorithm>(iConfig, iC);
     algomap_[AlgorithmType::InnerPixel3D] = std::make_unique<Pixel3DDigitizerAlgorithm>(iConfig, iC);
     algomap_[AlgorithmType::PixelinPS] = std::make_unique<PSPDigitizerAlgorithm>(iConfig, iC);
     algomap_[AlgorithmType::StripinPS] = std::make_unique<PSSDigitizerAlgorithm>(iConfig, iC);
     algomap_[AlgorithmType::TwoStrip] = std::make_unique<SSDigitizerAlgorithm>(iConfig, iC);
   }

◆ ~Phase2TrackerDigitizer()

cms::Phase2TrackerDigitizer::~Phase2TrackerDigitizer ( )

override

Definition at line 99 of file Phase2TrackerDigitizer.cc.

99 {}

Member Function Documentation

◆ accumulate() [1/2]

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

overridevirtual

Implements DigiAccumulatorMixMod.

Definition at line 173 of file Phase2TrackerDigitizer.cc.

References iEvent.

                                                                                              {
     accumulate_local<edm::Event>(iEvent, iSetup);
   }

◆ accumulate() [2/2]

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

overridevirtual

Implements DigiAccumulatorMixMod.

Definition at line 177 of file Phase2TrackerDigitizer.cc.

References iEvent.

                                                               {
     accumulate_local<PileUpEventPrincipal>(iEvent, iSetup);
   }

◆ accumulate_local()

template<class T >

void cms::Phase2TrackerDigitizer::accumulate_local	(	T const &	iEvent,
		edm::EventSetup const &	iSetup
	)

Definition at line 184 of file Phase2TrackerDigitizer.cc.

References accumulatePixelHits(), crossingSimHitIndexOffset_, PixelDigiSimLink::HighTof, hitsProducer_, iEvent, PixelDigiSimLink::LowTof, FastTrackerRecHitCombiner_cfi::simHits, AlCaHLTBitMon_QueryRunRegistry::string, makeGlobalPositionRcd_cfg::tag, trackerContainers_, and findQualityFiles::v.

                                                                                             {
     for (auto const& v : trackerContainers_) {
       edm::Handle<std::vector<PSimHit> > simHits;
       edm::InputTag tag(hitsProducer_, v);
       iEvent.getByLabel(tag, simHits);
 
       //edm::EDGetTokenT< std::vector<PSimHit> > simHitToken_(consumes< std::vector<PSimHit>(tag));
       //iEvent.getByToken(simHitToken_, simHits);
 
       uint32_t tofBin = PixelDigiSimLink::LowTof;
       if (v.find(std::string("HighTof")) != std::string::npos)
         tofBin = PixelDigiSimLink::HighTof;
       accumulatePixelHits(simHits, crossingSimHitIndexOffset_[tag.encode()], tofBin);
       // Now that the hits have been processed, I'll add the amount of hits in this crossing on to
       // the global counter. Next time accumulateStripHits() is called it will count the sim hits
       // as though they were on the end of this collection.
       // Note that this is only used for creating digi-sim links (if configured to do so).
       if (simHits.isValid())
         crossingSimHitIndexOffset_[tag.encode()] += simHits->size();
     }
   }

◆ accumulatePixelHits()

void cms::Phase2TrackerDigitizer::accumulatePixelHits	(	edm::Handle< std::vector< PSimHit > >	hSimHits,
		size_t	globalSimHitIndex,
		const uint32_t	tofBin
	)

private

Definition at line 100 of file Phase2TrackerDigitizer.cc.

References algomap_, detectorUnits_, getAlgoType(), MagneticField::inTesla(), LogDebug, GloballyPositioned< T >::position(), pSetup_, FastTrackerRecHitCombiner_cfi::simHits, and GeomDet::surface().

Referenced by accumulate_local().

                                                                           {
     if (hSimHits.isValid()) {
       std::set<uint32_t> detIds;
       auto const& simHits = *(hSimHits.product());
       for (auto it = std::begin(simHits), itEnd = std::end(simHits); it != itEnd; ++it, ++globalSimHitIndex) {
         uint32_t detId_raw = (*it).detUnitId();
         auto fiter = detectorUnits_.find(detId_raw);
         if (fiter == detectorUnits_.end())
           continue;
 
         if (detIds.insert(detId_raw).second) {
           // The insert succeeded, so this detector element has not yet been processed.
           const Phase2TrackerGeomDetUnit* phase2det = fiter->second;
 
           // access to magnetic field in global coordinates
           GlobalVector bfield = pSetup_->inTesla(phase2det->surface().position());
           LogDebug("PixelDigitizer") << "B-field(T) at " << phase2det->surface().position()
                                      << " (cm): " << pSetup_->inTesla(phase2det->surface().position());
 
           auto kiter = algomap_.find(getAlgoType(detId_raw));
           if (kiter != algomap_.end())
             kiter->second->accumulateSimHits(it, itEnd, globalSimHitIndex, tofBin, phase2det, bfield);
           else
             edm::LogInfo("Phase2TrackerDigitizer") << "Unsupported algorithm: ";
         }
       }
     }
   }

◆ addOuterTrackerCollection()

template<typename DigiType >

void cms::Phase2TrackerDigitizer::addOuterTrackerCollection	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

private

Definition at line 339 of file Phase2TrackerDigitizer.cc.

References algomap_, edm::DetSet< T >::data, TrackerGeometry::detUnits(), getAlgoType(), iEvent, info(), InnerPixel, InnerPixel3D, makeDigiSimLinks_, eostools::move(), pDD_, and tTopo_.

                                                                                                       {
     std::vector<edm::DetSet<DigiType> > digiVector;
     std::vector<edm::DetSet<PixelDigiSimLink> > digiLinkVector;
     for (auto const& det_u : pDD_->detUnits()) {
       uint32_t rawId = det_u->geographicalId().rawId();
       auto algotype = getAlgoType(rawId);
 
       auto fiter = algomap_.find(algotype);
       if (fiter == algomap_.end() || algotype == AlgorithmType::InnerPixel || algotype == AlgorithmType::InnerPixel3D)
         continue;
 
       std::map<int, digitizerUtility::DigiSimInfo> digi_map;
       fiter->second->digitize(dynamic_cast<const Phase2TrackerGeomDetUnit*>(det_u), digi_map, tTopo_);
 
       edm::DetSet<DigiType> collector(rawId);
       edm::DetSet<PixelDigiSimLink> linkcollector(rawId);
       for (auto const& digi_p : digi_map) {
         digitizerUtility::DigiSimInfo info = digi_p.second;
         addToCollector(collector, digi_p.first, info);
         for (auto const& sim_p : info.simInfoList) {
           linkcollector.data.emplace_back(digi_p.first,
                                           sim_p.second->trackId(),
                                           sim_p.second->hitIndex(),
                                           sim_p.second->tofBin(),
                                           sim_p.second->eventId(),
                                           sim_p.first);
         }
       }
 
       if (!collector.data.empty())
         digiVector.push_back(std::move(collector));
       if (!linkcollector.data.empty())
         digiLinkVector.push_back(std::move(linkcollector));
     }
 
     // Step C: create collection with the cache vector of DetSet
     auto output = std::make_unique<edm::DetSetVector<DigiType> >(digiVector);
     auto outputlink = std::make_unique<edm::DetSetVector<PixelDigiSimLink> >(digiLinkVector);
 
     // Step D: write output to file
     iEvent.put(std::move(output), "Tracker");
     if (makeDigiSimLinks_)
       iEvent.put(std::move(outputlink), "Tracker");
   }

◆ addPixelCollection()

void cms::Phase2TrackerDigitizer::addPixelCollection	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup,
		const bool	ot_analog
	)

private

Definition at line 271 of file Phase2TrackerDigitizer.cc.

References algomap_, PixelDigi::channelToPixel(), edm::DetSet< T >::data, TrackerGeometry::detUnits(), getAlgoType(), iEvent, info(), InnerPixel, InnerPixel3D, makeDigiSimLinks_, eostools::move(), pDD_, and tTopo_.

Referenced by finalizeEvent().

                                                                         {
     std::vector<edm::DetSet<PixelDigi> > digiVector;
     std::vector<edm::DetSet<PixelDigiSimLink> > digiLinkVector;
     for (auto const& det_u : pDD_->detUnits()) {
       uint32_t rawId = det_u->geographicalId().rawId();
       auto algotype = getAlgoType(rawId);
       auto fiter = algomap_.find(algotype);
       if (fiter == algomap_.end())
         continue;
 
       // Decide if we want analog readout for Outer Tracker.
       if (!ot_analog && algotype != AlgorithmType::InnerPixel && algotype != AlgorithmType::InnerPixel3D)
         continue;
 
       std::map<int, digitizerUtility::DigiSimInfo> digi_map;
       fiter->second->digitize(dynamic_cast<const Phase2TrackerGeomDetUnit*>(det_u), digi_map, tTopo_);
 
       edm::DetSet<PixelDigi> collector(rawId);
       edm::DetSet<PixelDigiSimLink> linkcollector(rawId);
       for (auto const& digi_p : digi_map) {
         digitizerUtility::DigiSimInfo info = digi_p.second;
         const auto& ip = PixelDigi::channelToPixel(digi_p.first);
         collector.data.emplace_back(ip.first, ip.second, info.sig_tot);
         for (auto const& sim_p : info.simInfoList) {
           linkcollector.data.emplace_back(digi_p.first,
                                           sim_p.second->trackId(),
                                           sim_p.second->hitIndex(),
                                           sim_p.second->tofBin(),
                                           sim_p.second->eventId(),
                                           sim_p.first);
         }
       }
       if (!collector.data.empty())
         digiVector.push_back(std::move(collector));
       if (!linkcollector.data.empty())
         digiLinkVector.push_back(std::move(linkcollector));
     }
 
     // Step C: create collection with the cache vector of DetSet
     auto output = std::make_unique<edm::DetSetVector<PixelDigi> >(digiVector);
     auto outputlink = std::make_unique<edm::DetSetVector<PixelDigiSimLink> >(digiLinkVector);
 
     // Step D: write output to file
     iEvent.put(std::move(output), "Pixel");
     if (makeDigiSimLinks_)
       iEvent.put(std::move(outputlink), "Pixel");
   }

◆ beginJob()

virtual void cms::Phase2TrackerDigitizer::beginJob ( void )

inlinevirtual

Definition at line 64 of file Phase2TrackerDigitizer.h.

64 {}

◆ finalizeEvent()

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

overridevirtual

Implements DigiAccumulatorMixMod.

Definition at line 215 of file Phase2TrackerDigitizer.cc.

References addPixelCollection(), iEvent, isOuterTrackerReadoutAnalog_, and premixStage1_.

Referenced by PreMixingPhase2TrackerWorker::put().

                                                                                           {
     //Decide if we want analog readout for Outer Tracker.
     addPixelCollection(iEvent, iSetup, isOuterTrackerReadoutAnalog_);
     if (!isOuterTrackerReadoutAnalog_) {
       if (premixStage1_)
         addOuterTrackerCollection<PixelDigi>(iEvent, iSetup);
       else
         addOuterTrackerCollection<Phase2TrackerDigi>(iEvent, iSetup);
     }
   }

◆ getAlgoType()

Phase2TrackerDigitizer::AlgorithmType cms::Phase2TrackerDigitizer::getAlgoType ( uint32_t idet )

private

Definition at line 225 of file Phase2TrackerDigitizer.cc.

References TrackerGeometry::getDetectorType(), InnerPixel, InnerPixel3D, moduleTypeCache_, pDD_, TrackerGeometry::Ph1PXB, TrackerGeometry::Ph1PXF, TrackerGeometry::Ph2PSP, TrackerGeometry::Ph2PSS, TrackerGeometry::Ph2PXB, TrackerGeometry::Ph2PXB3D, TrackerGeometry::Ph2PXF, TrackerGeometry::Ph2PXF3D, TrackerGeometry::Ph2SS, PixelinPS, StripinPS, TwoStrip, TrackerGeometry::UNKNOWN, and Unknown.

Referenced by accumulatePixelHits(), addOuterTrackerCollection(), addPixelCollection(), and loadAccumulator().

                                                                                             {
     // get mType either from the geometry or from our cache (faster)
     TrackerGeometry::ModuleType mType = TrackerGeometry::ModuleType::UNKNOWN;
     auto itr = moduleTypeCache_.find(detId_raw);
     if (itr != moduleTypeCache_.end()) {
       mType = itr->second;
     } else {
       mType = pDD_->getDetectorType(DetId(detId_raw));
       moduleTypeCache_.emplace(detId_raw, mType);
     }
 
     AlgorithmType algotype = AlgorithmType::Unknown;
     switch (mType) {
       case TrackerGeometry::ModuleType::Ph1PXB:
         algotype = AlgorithmType::InnerPixel;
         break;
       case TrackerGeometry::ModuleType::Ph1PXF:
         algotype = AlgorithmType::InnerPixel;
         break;
       case TrackerGeometry::ModuleType::Ph2PXB:
         algotype = AlgorithmType::InnerPixel;
         break;
       case TrackerGeometry::ModuleType::Ph2PXF:
         algotype = AlgorithmType::InnerPixel;
         break;
       case TrackerGeometry::ModuleType::Ph2PXB3D:
         algotype = AlgorithmType::InnerPixel3D;
         break;
       case TrackerGeometry::ModuleType::Ph2PXF3D:
         algotype = AlgorithmType::InnerPixel3D;
         break;
       case TrackerGeometry::ModuleType::Ph2PSP:
         algotype = AlgorithmType::PixelinPS;
         break;
       case TrackerGeometry::ModuleType::Ph2PSS:
         algotype = AlgorithmType::StripinPS;
         break;
       case TrackerGeometry::ModuleType::Ph2SS:
         algotype = AlgorithmType::TwoStrip;
         break;
       default:
         edm::LogError("Phase2TrackerDigitizer") << "ERROR - Wrong Detector Type, No Algorithm available ";
     }
 
     return algotype;
   }

◆ initializeEvent()

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

overridevirtual

Implements DigiAccumulatorMixMod.

Definition at line 131 of file Phase2TrackerDigitizer.cc.

References algomap_, cms::cuda::assert(), edm::ESWatcher< T >::check(), crossingSimHitIndexOffset_, detectorUnits_, TrackerGeometry::detUnits(), MillePedeFileConverter_cfg::e, Exception, first_, edm::EventSetup::getData(), edm::RandomNumberGenerator::getEngine(), edm::Service< T >::isAvailable(), moduleTypeCache_, pDD_, pDDToken_, pSetup_, pSetupToken_, theTkDigiGeomWatcher_, align::Tracker, tTopo_, and tTopoToken_.

Referenced by PreMixingPhase2TrackerWorker::initializeEvent().

                                                                                              {
     edm::Service<edm::RandomNumberGenerator> rng;
     if (!rng.isAvailable()) {
       throw cms::Exception("Configuration")
           << "Phase2TrackerDigitizer requires the RandomNumberGeneratorService\n"
              "which is not present in the configuration file.  You must add the service\n"
              "in the configuration file or remove the modules that require it.";
     }
 
     pSetup_ = &iSetup.getData(pSetupToken_);
     tTopo_ = &iSetup.getData(tTopoToken_);
 
     if (theTkDigiGeomWatcher_.check(iSetup)) {
       pDD_ = &iSetup.getData(pDDToken_);
 
       // reset cache
       ModuleTypeCache().swap(moduleTypeCache_);
       detectorUnits_.clear();
       for (auto const& det_u : pDD_->detUnits()) {
         uint32_t rawId = det_u->geographicalId().rawId();
         if (DetId(rawId).det() == DetId::Detector::Tracker) {
           const Phase2TrackerGeomDetUnit* pixdet = dynamic_cast<const Phase2TrackerGeomDetUnit*>(det_u);
           assert(pixdet);
           detectorUnits_.emplace(rawId, pixdet);
         }
       }
     }
 
     // Must initialize all the algorithms
     for (auto const& el : algomap_) {
       if (first_)
         el.second->init(iSetup);
 
       el.second->initializeEvent(rng->getEngine(e.streamID()));
     }
     first_ = false;
     // Make sure that the first crossing processed starts indexing the sim hits from zero.
     // This variable is used so that the sim hits from all crossing frames have sequential
     // indices used to create the digi-sim link (if configured to do so) rather than starting
     // from zero for each crossing.
     crossingSimHitIndexOffset_.clear();
   }

◆ loadAccumulator()

void cms::Phase2TrackerDigitizer::loadAccumulator ( const std::map< uint32_t, std::map< int, float > > & accumulator )

Definition at line 207 of file Phase2TrackerDigitizer.cc.

References mixOne_premix_on_sim_cfi::accumulator, algomap_, and getAlgoType().

Referenced by PreMixingPhase2TrackerWorker::put().

                                                                                                        {
     for (const auto& detMap : accumulator) {
       AlgorithmType algoType = getAlgoType(detMap.first);
       auto& algo = *(algomap_.at(algoType));
       algo.loadAccumulator(detMap.first, detMap.second);
     }
   }

Member Data Documentation

◆ algomap_

std::map<AlgorithmType, std::unique_ptr<Phase2TrackerDigitizerAlgorithm> > cms::Phase2TrackerDigitizer::algomap_

private

Definition at line 97 of file Phase2TrackerDigitizer.h.

Referenced by accumulatePixelHits(), addOuterTrackerCollection(), addPixelCollection(), initializeEvent(), loadAccumulator(), and Phase2TrackerDigitizer().

◆ crossingSimHitIndexOffset_

std::map<std::string, size_t> cms::Phase2TrackerDigitizer::crossingSimHitIndexOffset_

private

Offset to add to the index of each sim hit to account for which crossing it's in.

I need to know what each sim hit index will be when the hits from all crossing frames are merged into one collection (assuming the MixingModule is configured to create the crossing frame for all sim hits). To do this I'll record how many hits were in each crossing, and then add that on to the index for a given hit in a given crossing. This assumes that the crossings are processed in the same order here as they are put into the crossing frame, which I'm pretty sure is true.
The key is the name of the sim hit collection.

Definition at line 96 of file Phase2TrackerDigitizer.h.

Referenced by accumulate_local(), and initializeEvent().