Accumulator to perform digitisation on the strip tracker sim hits. More...

#include <SiStripDigitizer.h>

Inheritance diagram for SiStripDigitizer:

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

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

PileupMixingContent *	getEventPileupInfo () override

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

	SiStripDigitizer (const edm::ParameterSet &conf, edm::ProducesCollector, edm::ConsumesCollector &iC)

void	StorePileupInformation (std::vector< int > &numInteractionList, std::vector< int > &bunchCrossingList, std::vector< float > &TrueInteractionList, std::vector< edm::EventID > &eventInfoList, int bunchSpacing) override

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

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 void	initializeBunchCrossing (edm::Event const &event, edm::EventSetup const &setup, int bunchCrossing)

virtual	~DigiAccumulatorMixMod ()

Private Types
typedef std::map< unsigned int, std::vector< std::pair< const PSimHit *, int > >, std::less< unsigned int > >	simhit_map

typedef simhit_map::iterator	simhit_map_iterator

typedef std::vector< std::string >	vstring

Private Member Functions
void	accumulateStripHits (edm::Handle< std::vector< PSimHit >>, const TrackerTopology *tTopo, size_t globalSimHitIndex, const unsigned int tofBin)

Private Attributes
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, StripGeomDetUnit const * >	detectorUnits

const double	fracOfEventsToSimAPV_
	Whether or not to create the association to sim truth collection. Set in configuration. More...

const std::string	gainLabel

const std::string	geometryType

const std::string	hitsProducer

const bool	includeAPVSimulation_

const bool	makeDigiSimLinks_

edm::ESHandle< TrackerGeometry >	pDD

std::unique_ptr< PileupMixingContent >	PileupInfo_

const std::string	PRDigi

edm::ESHandle< MagneticField >	pSetup

CLHEP::HepRandomEngine *	randomEngine_ = nullptr

const std::string	SCDigi

std::vector< std::pair< int, std::bitset< 6 > > >	theAffectedAPVvector

std::map< uint32_t, std::vector< int > >	theDetIdList

std::unique_ptr< SiStripDigitizerAlgorithm >	theDigiAlgo

const vstring	trackerContainers

const bool	useConfFromDB

const std::string	VRDigi

const bool	zeroSuppression

const std::string	ZSDigi

Detailed Description

Accumulator to perform digitisation on the strip tracker sim hits.

Author: original author unknown; converted from a producer to a MixingModule accumulator by Bill Tanenbaum; functionality to create digi-sim links moved from Bill's DigiSimLinkProducer into here by Mark Grimes (mark..nosp@m.grim.nosp@m.es@br.nosp@m.isto.nosp@m.l.ac..nosp@m.uk).

Date: original date unknown; moved into a MixingModule accumulator mid to late 2012; digi sim links eventually finished May 2013

Definition at line 45 of file SiStripDigitizer.h.

Member Typedef Documentation

◆ simhit_map

typedef std::map<unsigned int, std::vector<std::pair<const PSimHit*, int> >, std::less<unsigned int> > SiStripDigitizer::simhit_map

private

Definition at line 74 of file SiStripDigitizer.h.

◆ simhit_map_iterator

typedef simhit_map::iterator SiStripDigitizer::simhit_map_iterator

private

Definition at line 75 of file SiStripDigitizer.h.

◆ vstring

typedef std::vector<std::string> SiStripDigitizer::vstring

private

Definition at line 73 of file SiStripDigitizer.h.

Constructor & Destructor Documentation

◆ SiStripDigitizer()

SiStripDigitizer::SiStripDigitizer	(	const edm::ParameterSet &	conf,
		edm::ProducesCollector	producesCollector,
		edm::ConsumesCollector &	iC
	)

explicit

Definition at line 59 of file SiStripDigitizer.cc.

     : gainLabel(conf.getParameter<std::string>("Gain")),
       hitsProducer(conf.getParameter<std::string>("hitsProducer")),
       trackerContainers(conf.getParameter<std::vector<std::string>>("ROUList")),
       ZSDigi(conf.getParameter<edm::ParameterSet>("DigiModeList").getParameter<std::string>("ZSDigi")),
       SCDigi(conf.getParameter<edm::ParameterSet>("DigiModeList").getParameter<std::string>("SCDigi")),
       VRDigi(conf.getParameter<edm::ParameterSet>("DigiModeList").getParameter<std::string>("VRDigi")),
       PRDigi(conf.getParameter<edm::ParameterSet>("DigiModeList").getParameter<std::string>("PRDigi")),
       geometryType(conf.getParameter<std::string>("GeometryType")),
       useConfFromDB(conf.getParameter<bool>("TrackerConfigurationFromDB")),
       zeroSuppression(conf.getParameter<bool>("ZeroSuppression")),
       makeDigiSimLinks_(conf.getUntrackedParameter<bool>("makeDigiSimLinks", false)),
       includeAPVSimulation_(conf.getParameter<bool>("includeAPVSimulation")),
       fracOfEventsToSimAPV_(conf.getParameter<double>("fracOfEventsToSimAPV")) {
   const std::string alias("simSiStripDigis");
  
   producesCollector.produces<edm::DetSetVector<SiStripDigi>>(ZSDigi).setBranchAlias(ZSDigi);
   producesCollector.produces<edm::DetSetVector<SiStripRawDigi>>(SCDigi).setBranchAlias(alias + SCDigi);
   producesCollector.produces<edm::DetSetVector<SiStripRawDigi>>(VRDigi).setBranchAlias(alias + VRDigi);
   producesCollector.produces<edm::DetSetVector<SiStripRawDigi>>("StripAmplitudes")
       .setBranchAlias(alias + "StripAmplitudes");
   producesCollector.produces<edm::DetSetVector<SiStripRawDigi>>("StripAmplitudesPostAPV")
       .setBranchAlias(alias + "StripAmplitudesPostAPV");
   producesCollector.produces<edm::DetSetVector<SiStripRawDigi>>("StripAPVBaselines")
       .setBranchAlias(alias + "StripAPVBaselines");
   producesCollector.produces<edm::DetSetVector<SiStripRawDigi>>(PRDigi).setBranchAlias(alias + PRDigi);
   producesCollector.produces<edm::DetSetVector<StripDigiSimLink>>().setBranchAlias(alias + "siStripDigiSimLink");
   producesCollector.produces<bool>("SimulatedAPVDynamicGain").setBranchAlias(alias + "SimulatedAPVDynamicGain");
   producesCollector.produces<std::vector<std::pair<int, std::bitset<6>>>>("AffectedAPVList")
       .setBranchAlias(alias + "AffectedAPV");
   for (auto const& trackerContainer : trackerContainers) {
     edm::InputTag tag(hitsProducer, trackerContainer);
     iC.consumes<std::vector<PSimHit>>(edm::InputTag(hitsProducer, trackerContainer));
   }
   edm::Service<edm::RandomNumberGenerator> rng;
   if (!rng.isAvailable()) {
     throw cms::Exception("Configuration")
         << "SiStripDigitizer 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.";
   }
   theDigiAlgo = std::make_unique<SiStripDigitizerAlgorithm>(conf);
 }

References SiStripOfflineCRack_cfg::alias, edm::ConsumesCollector::consumes(), Exception, hitsProducer, HLT_FULL_cff::InputTag, edm::Service< T >::isAvailable(), PRDigi, edm::ProducesCollector::produces(), SCDigi, AlCaHLTBitMon_QueryRunRegistry::string, GlobalPosition_Frontier_DevDB_cff::tag, theDigiAlgo, trackerContainers, VRDigi, and ZSDigi.

◆ ~SiStripDigitizer()

SiStripDigitizer::~SiStripDigitizer ( )

override

Definition at line 106 of file SiStripDigitizer.cc.

106 {}

Member Function Documentation

◆ accumulate() [1/2]

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

overridevirtual

Implements DigiAccumulatorMixMod.

Definition at line 139 of file SiStripDigitizer.cc.

                                                                                      {
   //Retrieve tracker topology from geometry
   edm::ESHandle<TrackerTopology> tTopoHand;
   iSetup.get<TrackerTopologyRcd>().get(tTopoHand);
   const TrackerTopology* tTopo = tTopoHand.product();
  
   // Step A: Get Inputs
   for (auto const& trackerContainer : trackerContainers) {
     edm::Handle<std::vector<PSimHit>> simHits;
     edm::InputTag tag(hitsProducer, trackerContainer);
     unsigned int tofBin = StripDigiSimLink::LowTof;
     if (trackerContainer.find(std::string("HighTof")) != std::string::npos)
       tofBin = StripDigiSimLink::HighTof;
  
     iEvent.getByLabel(tag, simHits);
     accumulateStripHits(simHits, tTopo, 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 accumulateStripHits(), crossingSimHitIndexOffset_, edm::EventSetup::get(), get, StripDigiSimLink::HighTof, hitsProducer, iEvent, StripDigiSimLink::LowTof, edm::ESHandle< T >::product(), FastTrackerRecHitCombiner_cfi::simHits, AlCaHLTBitMon_QueryRunRegistry::string, GlobalPosition_Frontier_DevDB_cff::tag, and trackerContainers.

◆ accumulate() [2/2]

void SiStripDigitizer::accumulate	(	PileUpEventPrincipal const &	e,
		edm::EventSetup const &	c,
		edm::StreamID const &	streamID
	)

overridevirtual

Implements DigiAccumulatorMixMod.

Definition at line 164 of file SiStripDigitizer.cc.

                                                                {
   edm::ESHandle<TrackerTopology> tTopoHand;
   iSetup.get<TrackerTopologyRcd>().get(tTopoHand);
   const TrackerTopology* tTopo = tTopoHand.product();
  
   //Re-compute luminosity for accumulation for HIP effects
   theDigiAlgo->calculateInstlumiScale(PileupInfo_.get());
  
   // Step A: Get Inputs
   for (auto const& trackerContainer : trackerContainers) {
     edm::Handle<std::vector<PSimHit>> simHits;
     edm::InputTag tag(hitsProducer, trackerContainer);
     unsigned int tofBin = StripDigiSimLink::LowTof;
     if (trackerContainer.find(std::string("HighTof")) != std::string::npos)
       tofBin = StripDigiSimLink::HighTof;
  
     iEvent.getByLabel(tag, simHits);
     accumulateStripHits(simHits, tTopo, 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 accumulateStripHits(), crossingSimHitIndexOffset_, edm::EventSetup::get(), get, StripDigiSimLink::HighTof, hitsProducer, iEvent, StripDigiSimLink::LowTof, PileupInfo_, edm::ESHandle< T >::product(), FastTrackerRecHitCombiner_cfi::simHits, AlCaHLTBitMon_QueryRunRegistry::string, GlobalPosition_Frontier_DevDB_cff::tag, theDigiAlgo, and trackerContainers.

◆ accumulateStripHits()

void SiStripDigitizer::accumulateStripHits	(	edm::Handle< std::vector< PSimHit >>	hSimHits,
		const TrackerTopology *	tTopo,
		size_t	globalSimHitIndex,
		const unsigned int	tofBin
	)

private

Definition at line 108 of file SiStripDigitizer.cc.

                                                                       {
   // globalSimHitIndex is the index the sim hit will have when it is put in a collection
   // of sim hits for all crossings. This is only used when creating digi-sim links if
   // configured to do so.
  
   if (hSimHits.isValid()) {
     std::set<unsigned int> detIds;
     std::vector<PSimHit> const& simHits = *hSimHits.product();
     for (std::vector<PSimHit>::const_iterator it = simHits.begin(), itEnd = simHits.end(); it != itEnd;
          ++it, ++globalSimHitIndex) {
       unsigned int detId = (*it).detUnitId();
       if (detIds.insert(detId).second) {
         // The insert succeeded, so this detector element has not yet been processed.
         assert(detectorUnits[detId]);
         if (detectorUnits[detId]->type().isTrackerStrip()) {  // this test can be removed and replaced by stripdet!=0
           auto stripdet = detectorUnits[detId];
           //access to magnetic field in global coordinates
           GlobalVector bfield = pSetup->inTesla(stripdet->surface().position());
           LogDebug("Digitizer ") << "B-field(T) at " << stripdet->surface().position()
                                  << "(cm): " << pSetup->inTesla(stripdet->surface().position());
           theDigiAlgo->accumulateSimHits(it, itEnd, globalSimHitIndex, tofBin, stripdet, bfield, tTopo, randomEngine_);
         }
       }
     }  // end of loop over sim hits
   }
 }

References cms::cuda::assert(), detectorUnits, MagneticField::inTesla(), GeomDetEnumerators::isTrackerStrip(), LogDebug, pSetup, randomEngine_, FastTrackerRecHitCombiner_cfi::simHits, and theDigiAlgo.

Referenced by accumulate().

◆ finalizeEvent()

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

overridevirtual

Implements DigiAccumulatorMixMod.

Definition at line 235 of file SiStripDigitizer.cc.

                                                                                   {
   edm::ESHandle<SiStripGain> gainHandle;
   edm::ESHandle<SiStripNoises> noiseHandle;
   edm::ESHandle<SiStripThreshold> thresholdHandle;
   edm::ESHandle<SiStripPedestals> pedestalHandle;
   edm::ESHandle<SiStripApvSimulationParameters> apvSimulationParametersHandle;
   iSetup.get<SiStripGainSimRcd>().get(gainLabel, gainHandle);
   iSetup.get<SiStripNoisesRcd>().get(noiseHandle);
   iSetup.get<SiStripThresholdRcd>().get(thresholdHandle);
   iSetup.get<SiStripPedestalsRcd>().get(pedestalHandle);
  
   std::unique_ptr<bool> simulateAPVInThisEvent = std::make_unique<bool>(false);
   if (includeAPVSimulation_) {
     if (CLHEP::RandFlat::shoot(randomEngine_) < fracOfEventsToSimAPV_) {
       *simulateAPVInThisEvent = true;
       iSetup.get<SiStripApvSimulationParametersRcd>().get(apvSimulationParametersHandle);
     }
   }
   std::vector<edm::DetSet<SiStripDigi>> theDigiVector;
   std::vector<edm::DetSet<SiStripRawDigi>> theRawDigiVector;
   std::unique_ptr<edm::DetSetVector<SiStripRawDigi>> theStripAmplitudeVector(new edm::DetSetVector<SiStripRawDigi>());
   std::unique_ptr<edm::DetSetVector<SiStripRawDigi>> theStripAmplitudeVectorPostAPV(
       new edm::DetSetVector<SiStripRawDigi>());
   std::unique_ptr<edm::DetSetVector<SiStripRawDigi>> theStripAPVBaselines(new edm::DetSetVector<SiStripRawDigi>());
   std::unique_ptr<edm::DetSetVector<StripDigiSimLink>> pOutputDigiSimLink(new edm::DetSetVector<StripDigiSimLink>);
  
   edm::ESHandle<TrackerTopology> tTopoHand;
   iSetup.get<TrackerTopologyRcd>().get(tTopoHand);
   const TrackerTopology* tTopo = tTopoHand.product();
  
   // Step B: LOOP on StripGeomDetUnit
   theDigiVector.reserve(10000);
   theDigiVector.clear();
  
   for (const auto& iu : pDD->detUnits()) {
     if (useConfFromDB) {
       //apply the cable map _before_ digitization: consider only the detis that are connected
       if (theDetIdList.find(iu->geographicalId().rawId()) == theDetIdList.end())
         continue;
     }
     auto sgd = dynamic_cast<StripGeomDetUnit const*>(iu);
     if (sgd != nullptr) {
       edm::DetSet<SiStripDigi> collectorZS(iu->geographicalId().rawId());
       edm::DetSet<SiStripRawDigi> collectorRaw(iu->geographicalId().rawId());
       edm::DetSet<SiStripRawDigi> collectorStripAmplitudes(iu->geographicalId().rawId());
       edm::DetSet<SiStripRawDigi> collectorStripAmplitudesPostAPV(iu->geographicalId().rawId());
       edm::DetSet<SiStripRawDigi> collectorStripAPVBaselines(iu->geographicalId().rawId());
       edm::DetSet<StripDigiSimLink> collectorLink(iu->geographicalId().rawId());
  
       unsigned int detID = sgd->geographicalId().rawId();
       DetId detId(detID);
  
       theDigiAlgo->digitize(collectorZS,
                             collectorRaw,
                             collectorStripAmplitudes,
                             collectorStripAmplitudesPostAPV,
                             collectorStripAPVBaselines,
                             collectorLink,
                             sgd,
                             gainHandle,
                             thresholdHandle,
                             noiseHandle,
                             pedestalHandle,
                             *simulateAPVInThisEvent,
                             apvSimulationParametersHandle,
                             theAffectedAPVvector,
                             randomEngine_,
                             tTopo);
  
       if (!collectorStripAmplitudes.data.empty())
         theStripAmplitudeVector->insert(collectorStripAmplitudes);
       if (!collectorStripAmplitudesPostAPV.data.empty())
         theStripAmplitudeVectorPostAPV->insert(collectorStripAmplitudesPostAPV);
       if (!collectorStripAPVBaselines.data.empty())
         theStripAPVBaselines->insert(collectorStripAPVBaselines);
  
       if (zeroSuppression) {
         if (!collectorZS.data.empty()) {
           theDigiVector.push_back(collectorZS);
           if (!collectorLink.data.empty())
             pOutputDigiSimLink->insert(collectorLink);
         }
       } else {
         if (!collectorRaw.data.empty()) {
           theRawDigiVector.push_back(collectorRaw);
           if (!collectorLink.data.empty())
             pOutputDigiSimLink->insert(collectorLink);
         }
       }
     }
   }
   if (zeroSuppression) {
     // Step C: create output collection
     std::unique_ptr<edm::DetSetVector<SiStripRawDigi>> output_virginraw(new edm::DetSetVector<SiStripRawDigi>());
     std::unique_ptr<edm::DetSetVector<SiStripRawDigi>> output_scopemode(new edm::DetSetVector<SiStripRawDigi>());
     std::unique_ptr<edm::DetSetVector<SiStripRawDigi>> output_processedraw(new edm::DetSetVector<SiStripRawDigi>());
     std::unique_ptr<edm::DetSetVector<SiStripDigi>> output(new edm::DetSetVector<SiStripDigi>(theDigiVector));
     std::unique_ptr<std::vector<std::pair<int, std::bitset<6>>>> AffectedAPVList(
         new std::vector<std::pair<int, std::bitset<6>>>(theAffectedAPVvector));
  
     // Step D: write output to file
     iEvent.put(std::move(output), ZSDigi);
     iEvent.put(std::move(output_scopemode), SCDigi);
     iEvent.put(std::move(output_virginraw), VRDigi);
     iEvent.put(std::move(theStripAmplitudeVector), "StripAmplitudes");
     iEvent.put(std::move(theStripAmplitudeVectorPostAPV), "StripAmplitudesPostAPV");
     iEvent.put(std::move(theStripAPVBaselines), "StripAPVBaselines");
     iEvent.put(std::move(output_processedraw), PRDigi);
     iEvent.put(std::move(AffectedAPVList), "AffectedAPVList");
     iEvent.put(std::move(simulateAPVInThisEvent), "SimulatedAPVDynamicGain");
     if (makeDigiSimLinks_)
       iEvent.put(
           std::move(pOutputDigiSimLink));  // The previous EDProducer didn't name this collection so I won't either
   } else {
     // Step C: create output collection
     std::unique_ptr<edm::DetSetVector<SiStripRawDigi>> output_virginraw(
         new edm::DetSetVector<SiStripRawDigi>(theRawDigiVector));
     std::unique_ptr<edm::DetSetVector<SiStripRawDigi>> output_scopemode(new edm::DetSetVector<SiStripRawDigi>());
     std::unique_ptr<edm::DetSetVector<SiStripRawDigi>> output_processedraw(new edm::DetSetVector<SiStripRawDigi>());
     std::unique_ptr<edm::DetSetVector<SiStripDigi>> output(new edm::DetSetVector<SiStripDigi>());
  
     // Step D: write output to file
     iEvent.put(std::move(output), ZSDigi);
     iEvent.put(std::move(output_scopemode), SCDigi);
     iEvent.put(std::move(output_virginraw), VRDigi);
     iEvent.put(std::move(theStripAmplitudeVector), "StripAmplitudes");
     iEvent.put(std::move(theStripAmplitudeVectorPostAPV), "StripAmplitudesPostAPV");
     iEvent.put(std::move(theStripAPVBaselines), "StripAPVBaselines");
     iEvent.put(std::move(output_processedraw), PRDigi);
     iEvent.put(std::move(simulateAPVInThisEvent), "SimulatedAPVDynamicGain");
     if (makeDigiSimLinks_)
       iEvent.put(
           std::move(pOutputDigiSimLink));  // The previous EDProducer didn't name this collection so I won't either
   }
   randomEngine_ = nullptr;  // to prevent access outside event
 }

References TrackerGeometry::detUnits(), fracOfEventsToSimAPV_, gainLabel, edm::EventSetup::get(), get, iEvent, includeAPVSimulation_, makeDigiSimLinks_, eostools::move(), convertSQLitetoXML_cfg::output, pDD, PRDigi, edm::ESHandle< T >::product(), randomEngine_, SCDigi, theAffectedAPVvector, theDetIdList, theDigiAlgo, useConfFromDB, trackerHitRTTI::vector, VRDigi, zeroSuppression, and ZSDigi.

◆ getEventPileupInfo()

PileupMixingContent* SiStripDigitizer::getEventPileupInfo ( )

inlineoverridevirtual

Reimplemented from DigiAccumulatorMixMod.

Definition at line 65 of file SiStripDigitizer.h.

65 { return PileupInfo_.get(); }

References PileupInfo_.

◆ initializeEvent()

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

overridevirtual

Implements DigiAccumulatorMixMod.

Definition at line 193 of file SiStripDigitizer.cc.

                                                                                           {
   // 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();
   theAffectedAPVvector.clear();
   // Step A: Get Inputs
  
   if (useConfFromDB) {
     edm::ESHandle<SiStripDetCabling> detCabling;
     iSetup.get<SiStripDetCablingRcd>().get(detCabling);
     detCabling->addConnected(theDetIdList);
   }
  
   // Cache random number engine
   edm::Service<edm::RandomNumberGenerator> rng;
   randomEngine_ = &rng->getEngine(iEvent.streamID());
  
   theDigiAlgo->initializeEvent(iSetup);
  
   iSetup.get<TrackerDigiGeometryRecord>().get(geometryType, pDD);
   iSetup.get<IdealMagneticFieldRecord>().get(pSetup);
  
   // FIX THIS! We only need to clear and (re)fill detectorUnits when the geometry type IOV changes.  Use ESWatcher to determine this.
   bool changes = true;
   if (changes) {  // Replace with ESWatcher
     detectorUnits.clear();
   }
   for (const auto& iu : pDD->detUnits()) {
     unsigned int detId = iu->geographicalId().rawId();
     if (iu->type().isTrackerStrip()) {
       auto stripdet = dynamic_cast<StripGeomDetUnit const*>(iu);
       assert(stripdet != nullptr);
       if (changes) {  // Replace with ESWatcher
         detectorUnits.insert(std::make_pair(detId, stripdet));
       }
       theDigiAlgo->initializeDetUnit(stripdet, iSetup);
     }
   }
 }

References SiStripDetCabling::addConnected(), cms::cuda::assert(), crossingSimHitIndexOffset_, detectorUnits, TrackerGeometry::detUnits(), geometryType, edm::EventSetup::get(), get, edm::RandomNumberGenerator::getEngine(), iEvent, pDD, pSetup, randomEngine_, theAffectedAPVvector, theDetIdList, theDigiAlgo, and useConfFromDB.

◆ StorePileupInformation()

void SiStripDigitizer::StorePileupInformation	(	std::vector< int > &	numInteractionList,
		std::vector< int > &	bunchCrossingList,
		std::vector< float > &	TrueInteractionList,
		std::vector< edm::EventID > &	eventInfoList,
		int	bunchSpacing
	)

inlineoverridevirtual

Reimplemented from DigiAccumulatorMixMod.

Definition at line 56 of file SiStripDigitizer.h.

                                                          {
     PileupInfo_ = std::make_unique<PileupMixingContent>(
         numInteractionList, bunchCrossingList, TrueInteractionList, eventInfoList, bunchSpacing);
   }

References genPUProtons_cfi::bunchCrossingList, HLTEgPhaseIITestSequence_cff::bunchSpacing, and PileupInfo_.

Member Data Documentation

◆ crossingSimHitIndexOffset_

std::map<std::string, size_t> SiStripDigitizer::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 100 of file SiStripDigitizer.h.

Referenced by accumulate(), and initializeEvent().