#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	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< 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	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::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	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 49 of file Phase2TrackerDigitizer.h.

Member Typedef Documentation

◆ ModuleTypeCache

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

Definition at line 51 of file Phase2TrackerDigitizer.h.

◆ vstring

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

private

Definition at line 72 of file Phase2TrackerDigitizer.h.

Member Enumeration Documentation

◆ AlgorithmType

enum cms::Phase2TrackerDigitizer::AlgorithmType

strongprivate

Enumerator
InnerPixel
InnerPixel3D
PixelinPS
StripinPS
TwoStrip
Unknown

Definition at line 75 of file Phase2TrackerDigitizer.h.

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

Constructor & Destructor Documentation

◆ Phase2TrackerDigitizer()

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

explicit

Definition at line 64 of file Phase2TrackerDigitizer.cc.

       : 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")) {
     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::InnerPixel3D] = std::make_unique<Pixel3DDigitizerAlgorithm>(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);
   }

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

◆ ~Phase2TrackerDigitizer()

cms::Phase2TrackerDigitizer::~Phase2TrackerDigitizer ( )

override

Definition at line 121 of file Phase2TrackerDigitizer.cc.

121 {}

Member Function Documentation

◆ accumulate() [1/2]

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

overridevirtual

Implements DigiAccumulatorMixMod.

Definition at line 176 of file Phase2TrackerDigitizer.cc.

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

References iEvent.

◆ accumulate() [2/2]

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

overridevirtual

Implements DigiAccumulatorMixMod.

Definition at line 180 of file Phase2TrackerDigitizer.cc.

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

References iEvent.

◆ accumulate_local()

template<class T >

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

Definition at line 187 of file Phase2TrackerDigitizer.cc.

                                                                                             {
     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();
     }
   }

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

◆ accumulatePixelHits()

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

private

Definition at line 122 of file Phase2TrackerDigitizer.cc.

                                                                           {
     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: ";
         }
       }
     }
   }

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

Referenced by accumulate_local().

◆ addOuterTrackerCollection()

template<typename DigiType >

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

private

Definition at line 344 of file Phase2TrackerDigitizer.cc.

                                                                                                       {
     const TrackerTopology* tTopo = tTopoHand_.product();
  
     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");
   }

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

◆ addPixelCollection()

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

private

Definition at line 274 of file Phase2TrackerDigitizer.cc.

                                                                         {
     const TrackerTopology* tTopo = tTopoHand_.product();
  
     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");
   }

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

Referenced by finalizeEvent().

◆ beginJob()

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

inlinevirtual

Definition at line 62 of file Phase2TrackerDigitizer.h.

62 {}

◆ beginLuminosityBlock()

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

overridevirtual

Reimplemented from DigiAccumulatorMixMod.

Definition at line 100 of file Phase2TrackerDigitizer.cc.

                                                                                                                {
     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()) {
         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);
         }
       }
     }
   }

References cms::cuda::assert(), edm::ESWatcher< T >::check(), detectorUnits_, TrackerGeometry::detUnits(), geometryType_, edm::EventSetup::get(), get, moduleTypeCache_, pDD_, pSetup_, theTkDigiGeomWatcher_, align::Tracker, and tTopoHand_.

Referenced by PreMixingPhase2TrackerWorker::beginLuminosityBlock().

◆ finalizeEvent()

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

overridevirtual

Implements DigiAccumulatorMixMod.

Definition at line 218 of file Phase2TrackerDigitizer.cc.

                                                                                           {
     //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);
     }
   }

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

Referenced by PreMixingPhase2TrackerWorker::put().

◆ getAlgoType()

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

private

Definition at line 228 of file Phase2TrackerDigitizer.cc.

                                                                                             {
     // 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;
   }

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().

◆ initializeEvent()

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

overridevirtual

Implements DigiAccumulatorMixMod.

Definition at line 153 of file Phase2TrackerDigitizer.cc.

                                                                                              {
     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();
   }

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

Referenced by PreMixingPhase2TrackerWorker::initializeEvent().

◆ loadAccumulator()

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

Definition at line 210 of file Phase2TrackerDigitizer.cc.

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

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

Referenced by PreMixingPhase2TrackerWorker::put().

Member Data Documentation

◆ algomap_

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().

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

Referenced by accumulate_local(), and initializeEvent().

◆ detectorUnits_

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

private

Definition at line 102 of file Phase2TrackerDigitizer.h.

Referenced by accumulatePixelHits(), and beginLuminosityBlock().

◆ first_

bool cms::Phase2TrackerDigitizer::first_

private

Definition at line 85 of file Phase2TrackerDigitizer.h.

Referenced by initializeEvent().

◆ geometryType_

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

private

Definition at line 99 of file Phase2TrackerDigitizer.h.

Referenced by beginLuminosityBlock().

◆ hitsProducer_

const std::string cms::Phase2TrackerDigitizer::hitsProducer_

private

Definition at line 97 of file Phase2TrackerDigitizer.h.

Referenced by accumulate_local().

◆ isOuterTrackerReadoutAnalog_

const bool cms::Phase2TrackerDigitizer::isOuterTrackerReadoutAnalog_

private

Definition at line 105 of file Phase2TrackerDigitizer.h.

Referenced by finalizeEvent().

◆ makeDigiSimLinks_

const bool cms::Phase2TrackerDigitizer::makeDigiSimLinks_

private

Definition at line 107 of file Phase2TrackerDigitizer.h.

Referenced by addOuterTrackerCollection(), addPixelCollection(), and Phase2TrackerDigitizer().

◆ moduleTypeCache_

ModuleTypeCache cms::Phase2TrackerDigitizer::moduleTypeCache_

private

Definition at line 109 of file Phase2TrackerDigitizer.h.

Referenced by beginLuminosityBlock(), and getAlgoType().

◆ pDD_

edm::ESHandle<TrackerGeometry> cms::Phase2TrackerDigitizer::pDD_

private

Definition at line 100 of file Phase2TrackerDigitizer.h.

Referenced by addOuterTrackerCollection(), addPixelCollection(), beginLuminosityBlock(), and getAlgoType().

◆ premixStage1_

const bool cms::Phase2TrackerDigitizer::premixStage1_

private

Definition at line 106 of file Phase2TrackerDigitizer.h.

Referenced by finalizeEvent(), and Phase2TrackerDigitizer().

◆ pSetup_

edm::ESHandle<MagneticField> cms::Phase2TrackerDigitizer::pSetup_

private

Definition at line 101 of file Phase2TrackerDigitizer.h.

Referenced by accumulatePixelHits(), and beginLuminosityBlock().

◆ theTkDigiGeomWatcher_

edm::ESWatcher<TrackerDigiGeometryRecord> cms::Phase2TrackerDigitizer::theTkDigiGeomWatcher_

private

Definition at line 104 of file Phase2TrackerDigitizer.h.

Referenced by beginLuminosityBlock().

◆ trackerContainers_

const vstring cms::Phase2TrackerDigitizer::trackerContainers_

private

Definition at line 98 of file Phase2TrackerDigitizer.h.

Referenced by accumulate_local().

◆ tTopoHand_

edm::ESHandle<TrackerTopology> cms::Phase2TrackerDigitizer::tTopoHand_

private

Definition at line 103 of file Phase2TrackerDigitizer.h.

Referenced by addOuterTrackerCollection(), addPixelCollection(), and beginLuminosityBlock().

Public Types

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ ModuleTypeCache

◆ vstring

Member Enumeration Documentation

◆ AlgorithmType

Constructor & Destructor Documentation

◆ Phase2TrackerDigitizer()

◆ ~Phase2TrackerDigitizer()

Member Function Documentation

◆ accumulate() [1/2]

◆ accumulate() [2/2]

◆ accumulate_local()

◆ accumulatePixelHits()

◆ addOuterTrackerCollection()

◆ addPixelCollection()

◆ beginJob()

◆ beginLuminosityBlock()

◆ finalizeEvent()

◆ getAlgoType()

◆ initializeEvent()

◆ loadAccumulator()

Member Data Documentation

◆ algomap_

◆ crossingSimHitIndexOffset_

◆ detectorUnits_

◆ first_

◆ geometryType_

◆ hitsProducer_

◆ isOuterTrackerReadoutAnalog_

◆ makeDigiSimLinks_

◆ moduleTypeCache_

◆ pDD_

◆ premixStage1_

◆ pSetup_

◆ theTkDigiGeomWatcher_

◆ trackerContainers_

◆ tTopoHand_