#include <Phase2TrackerDigitizer.h>

Inheritance diagram for cms::Phase2TrackerDigitizer:

Public Types
typedef std::unordered_map< unsigned, TrackerGeometry::ModuleType >	ModuleTypeCache

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	beginLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &iSetup) override

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< unsigned int, 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	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 Types
enum	AlgorithmType { AlgorithmType::InnerPixel, 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 unsigned int 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 (unsigned int 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< unsigned int, const Phase2TrackerGeomDetUnit * >	detectorUnits_

bool	first_

const std::string	geometryType_

const std::string	hitsProducer_

const bool	isOuterTrackerReadoutAnalog

const bool	makeDigiSimLinks_

ModuleTypeCache	moduleTypeCache_

edm::ESHandle< TrackerGeometry >	pDD_

const bool	premixStage1_

edm::ESHandle< MagneticField >	pSetup_

edm::ESWatcher< TrackerDigiGeometryRecord >	theTkDigiGeomWatcher

const vstring	trackerContainers_

edm::ESHandle< TrackerTopology >	tTopoHand

Detailed Description

Definition at line 50 of file Phase2TrackerDigitizer.h.

Member Typedef Documentation

typedef std::unordered_map<unsigned, TrackerGeometry::ModuleType> cms::Phase2TrackerDigitizer::ModuleTypeCache

Definition at line 52 of file Phase2TrackerDigitizer.h.

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

private

Definition at line 72 of file Phase2TrackerDigitizer.h.

Member Enumeration Documentation

enum cms::Phase2TrackerDigitizer::AlgorithmType

strongprivate

Enumerator
InnerPixel
PixelinPS
StripinPS
TwoStrip
Unknown

Definition at line 75 of file Phase2TrackerDigitizer.h.

75 { InnerPixel, PixelinPS, StripinPS, TwoStrip, Unknown };

reco::Unknown

Definition: MuonSimInfo.h:32

Constructor & Destructor Documentation

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

explicit

Definition at line 79 of file Phase2TrackerDigitizer.cc.

References algomap_, edm::ParameterSet::getParameter(), InnerPixel, 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")),
         geometryType_(iConfig.getParameter<std::string>("GeometryType")),
         isOuterTrackerReadoutAnalog(iConfig.getParameter<bool>("isOTreadoutAnalog")),
         premixStage1_(iConfig.getParameter<bool>("premixStage1")),
         makeDigiSimLinks_(
             iConfig.getParameter<edm::ParameterSet>("AlgorithmCommon").getUntrackedParameter<bool>("makeDigiSimLinks")) {
     //edm::LogInfo("Phase2TrackerDigitizer") << "Initialize Digitizer Algorithms";
     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);
     algomap_[AlgorithmType::PixelinPS] = std::make_unique<PSPDigitizerAlgorithm>(iConfig);
     algomap_[AlgorithmType::StripinPS] = std::make_unique<PSSDigitizerAlgorithm>(iConfig);
     algomap_[AlgorithmType::TwoStrip] = std::make_unique<SSDigitizerAlgorithm>(iConfig);
   }

cms::Phase2TrackerDigitizer::~Phase2TrackerDigitizer ( )

override

Definition at line 138 of file Phase2TrackerDigitizer.cc.

138 {}

Member Function Documentation

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

overridevirtual

Implements DigiAccumulatorMixMod.

Definition at line 191 of file Phase2TrackerDigitizer.cc.

References iEvent.

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

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

overridevirtual

Implements DigiAccumulatorMixMod.

Definition at line 195 of file Phase2TrackerDigitizer.cc.

References iEvent.

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

template<class T >

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

Definition at line 202 of file Phase2TrackerDigitizer.cc.

References accumulatePixelHits(), crossingSimHitIndexOffset_, edm::InputTag::encode(), PixelDigiSimLink::HighTof, hitsProducer_, edm::HandleBase::isValid(), PixelDigiSimLink::LowTof, FastTrackerRecHitCombiner_cfi::simHits, AlCaHLTBitMon_QueryRunRegistry::string, GlobalPosition_Frontier_DevDB_cff::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);
 
       unsigned int 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();
     }
   }

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

private

Definition at line 139 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<unsigned int> detIds;
       std::vector<PSimHit> const& simHits = *hSimHits.product();
       int indx = 0;
       for (auto it = simHits.begin(), itEnd = simHits.end(); it != itEnd; ++it, ++globalSimHitIndex) {
         unsigned int detId_raw = (*it).detUnitId();
         if (detectorUnits_.find(detId_raw) == detectorUnits_.end())
           continue;
         if (detIds.insert(detId_raw).second) {
           // The insert succeeded, so this detector element has not yet been processed.
           AlgorithmType algotype = getAlgoType(detId_raw);
           const Phase2TrackerGeomDetUnit* phase2det = detectorUnits_[detId_raw];
           // 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());
           if (algomap_.find(algotype) != algomap_.end()) {
             algomap_[algotype]->accumulateSimHits(it, itEnd, globalSimHitIndex, tofBin, phase2det, bfield);
           } else
             edm::LogInfo("Phase2TrackerDigitizer") << "Unsupported algorithm: ";
         }
         indx++;
       }
     }
   }

template<typename DigiType >

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

private

Definition at line 355 of file Phase2TrackerDigitizer.cc.

References algomap_, DEFINE_DIGI_ACCUMULATOR, TrackerGeometry::detUnits(), getAlgoType(), info(), InnerPixel, makeDigiSimLinks_, eostools::move(), convertSQLitetoXML_cfg::output, pDD_, edm::ESHandle< T >::product(), edm::Event::put(), DigitizerUtility::DigiSimInfo::simInfoList, and tTopoHand.

                                                                                                       {
     const TrackerTopology* tTopo = tTopoHand.product();
     std::vector<edm::DetSet<DigiType> > digiVector;
     std::vector<edm::DetSet<PixelDigiSimLink> > digiLinkVector;
     for (auto const& det_u : pDD_->detUnits()) {
       DetId detId_raw = DetId(det_u->geographicalId().rawId());
       AlgorithmType algotype = getAlgoType(detId_raw);
 
       if (algomap_.find(algotype) == algomap_.end() || algotype == AlgorithmType::InnerPixel)
         continue;
 
       std::map<int, DigitizerUtility::DigiSimInfo> digi_map;
       algomap_[algotype]->digitize(dynamic_cast<const Phase2TrackerGeomDetUnit*>(det_u), digi_map, tTopo);
       edm::DetSet<DigiType> collector(det_u->geographicalId().rawId());
       edm::DetSet<PixelDigiSimLink> linkcollector(det_u->geographicalId().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
     std::unique_ptr<edm::DetSetVector<DigiType> > output(new edm::DetSetVector<DigiType>(digiVector));
     std::unique_ptr<edm::DetSetVector<PixelDigiSimLink> > outputlink(
         new edm::DetSetVector<PixelDigiSimLink>(digiLinkVector));
 
     // Step D: write output to file
     iEvent.put(std::move(output), "Tracker");
     if (makeDigiSimLinks_) {
       iEvent.put(std::move(outputlink), "Tracker");
     }
   }

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

private

Definition at line 287 of file Phase2TrackerDigitizer.cc.

References algomap_, Phase2TrackerDigi::channelToPixel(), PixelDigi::channelToPixel(), edm::DetSet< T >::data, TrackerGeometry::detUnits(), getAlgoType(), info(), InnerPixel, makeDigiSimLinks_, eostools::move(), DigitizerUtility::DigiSimInfo::ot_bit, convertSQLitetoXML_cfg::output, pDD_, edm::ESHandle< T >::product(), edm::Event::put(), DigitizerUtility::DigiSimInfo::sig_tot, DigitizerUtility::DigiSimInfo::simInfoList, and tTopoHand.

Referenced by finalizeEvent().

                                                                         {
     const TrackerTopology* tTopo = tTopoHand.product();
     std::vector<edm::DetSet<PixelDigi> > digiVector;
     std::vector<edm::DetSet<PixelDigiSimLink> > digiLinkVector;
     for (auto const& det_u : pDD_->detUnits()) {
       DetId detId_raw = DetId(det_u->geographicalId().rawId());
       AlgorithmType algotype = getAlgoType(detId_raw);
       if (algomap_.find(algotype) == algomap_.end())
         continue;
 
       //Decide if we want analog readout for Outer Tracker.
       if (!ot_analog && algotype != AlgorithmType::InnerPixel)
         continue;
       std::map<int, DigitizerUtility::DigiSimInfo> digi_map;
       algomap_[algotype]->digitize(dynamic_cast<const Phase2TrackerGeomDetUnit*>(det_u), digi_map, tTopo);
       edm::DetSet<PixelDigi> collector(det_u->geographicalId().rawId());
       edm::DetSet<PixelDigiSimLink> linkcollector(det_u->geographicalId().rawId());
       for (auto const& digi_p : digi_map) {
         DigitizerUtility::DigiSimInfo info = digi_p.second;
         std::pair<int, int> 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
     std::unique_ptr<edm::DetSetVector<PixelDigi> > output(new edm::DetSetVector<PixelDigi>(digiVector));
     std::unique_ptr<edm::DetSetVector<PixelDigiSimLink> > outputlink(
         new edm::DetSetVector<PixelDigiSimLink>(digiLinkVector));
 
     // Step D: write output to file
     iEvent.put(std::move(output), "Pixel");
     if (makeDigiSimLinks_) {
       iEvent.put(std::move(outputlink), "Pixel");
     }
   }

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

inlinevirtual

Definition at line 62 of file Phase2TrackerDigitizer.h.

References mixOne_premix_on_sim_cfi::accumulator, iEvent, and genParticles_cff::map.

62 {}

void cms::Phase2TrackerDigitizer::beginLuminosityBlock	(	edm::LuminosityBlock const &	lumi,
		edm::EventSetup const &	iSetup
	)

overridevirtual

Reimplemented from DigiAccumulatorMixMod.

Definition at line 117 of file Phase2TrackerDigitizer.cc.

References edm::ESWatcher< T >::check(), detectorUnits_, TrackerGeometry::detUnits(), geometryType_, edm::EventSetup::get(), moduleTypeCache_, pDD_, pSetup_, theTkDigiGeomWatcher, align::Tracker, and tTopoHand.

Referenced by PreMixingPhase2TrackerWorker::beginLuminosityBlock().

                                                                                                                {
     iSetup.get<IdealMagneticFieldRecord>().get(pSetup_);
     iSetup.get<TrackerTopologyRcd>().get(tTopoHand);
 
     if (theTkDigiGeomWatcher.check(iSetup)) {
       iSetup.get<TrackerDigiGeometryRecord>().get(geometryType_, pDD_);
       //reset cache
       ModuleTypeCache().swap(moduleTypeCache_);
       detectorUnits_.clear();
       for (auto const& det_u : pDD_->detUnits()) {
         unsigned int detId_raw = det_u->geographicalId().rawId();
         DetId detId = DetId(detId_raw);
         if (DetId(detId).det() == DetId::Detector::Tracker) {
           const Phase2TrackerGeomDetUnit* pixdet = dynamic_cast<const Phase2TrackerGeomDetUnit*>(det_u);
           assert(pixdet);
           detectorUnits_.insert(std::make_pair(detId_raw, pixdet));
         }
       }
     }
   }

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

overridevirtual

Implements DigiAccumulatorMixMod.

Definition at line 233 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);
       }
     }
   }

Phase2TrackerDigitizer::AlgorithmType cms::Phase2TrackerDigitizer::getAlgoType ( unsigned int idet )

private

Definition at line 244 of file Phase2TrackerDigitizer.cc.

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

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

                                                                                                 {
     DetId detId(detId_raw);
 
     AlgorithmType algotype = AlgorithmType::Unknown;
 
     //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);
       moduleTypeCache_.emplace(detId_raw, mType);
     }
 
     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::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;
   }

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

overridevirtual

Implements DigiAccumulatorMixMod.

Definition at line 168 of file Phase2TrackerDigitizer.cc.

References algomap_, crossingSimHitIndexOffset_, Exception, first_, edm::RandomNumberGenerator::getEngine(), edm::Service< T >::isAvailable(), and edm::Event::streamID().

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.";
     }
 
     // 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();
   }

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

Definition at line 225 of file Phase2TrackerDigitizer.cc.

References mixOne_premix_on_sim_cfi::accumulator, ecalcalib_dqm_sourceclient-live_cfg::algo, 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

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

private

Definition at line 96 of file Phase2TrackerDigitizer.h.

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

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 95 of file Phase2TrackerDigitizer.h.

Referenced by accumulate_local(), and initializeEvent().

std::map<unsigned int, const Phase2TrackerGeomDetUnit*> cms::Phase2TrackerDigitizer::detectorUnits_

private

Definition at line 102 of file Phase2TrackerDigitizer.h.

Referenced by accumulatePixelHits(), and beginLuminosityBlock().

bool cms::Phase2TrackerDigitizer::first_

private

Definition at line 85 of file Phase2TrackerDigitizer.h.

Referenced by initializeEvent().

const std::string cms::Phase2TrackerDigitizer::geometryType_

private