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

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

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

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
edm::ESGetToken< SiStripApvSimulationParameters, SiStripApvSimulationParametersRcd >	apvSimulationParametersToken_

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

unsigned long long	ddCacheID_ = 0

unsigned long long	deadChannelCacheID_ = 0
	Whether or not to create the association to sim truth collection. Set in configuration. More...

const edm::ESGetToken< SiStripBadStrip, SiStripBadChannelRcd >	deadChannelToken_

edm::ESGetToken< SiStripDetCabling, SiStripDetCablingRcd >	detCablingToken_

std::map< unsigned int, StripGeomDetUnit const * >	detectorUnits

const double	fracOfEventsToSimAPV_

const edm::ESGetToken< SiStripGain, SiStripGainSimRcd >	gainToken_

const std::string	hitsProducer

const bool	includeAPVSimulation_

const bool	makeDigiSimLinks_

const edm::ESGetToken< SiStripNoises, SiStripNoisesRcd >	noiseToken_

const TrackerGeometry *	pDD = nullptr

const edm::ESGetToken< TrackerGeometry, TrackerDigiGeometryRecord >	pDDToken_

const edm::ESGetToken< SiStripPedestals, SiStripPedestalsRcd >	pedestalToken_

std::unique_ptr< PileupMixingContent >	PileupInfo_

const std::string	PRDigi

const MagneticField *	pSetup = nullptr

const edm::ESGetToken< MagneticField, IdealMagneticFieldRecord >	pSetupToken_

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 edm::ESGetToken< SiStripThreshold, SiStripThresholdRcd >	thresholdToken_

const vstring	trackerContainers

const edm::ESGetToken< TrackerTopology, TrackerTopologyRcd >	tTopoToken_

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 57 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 86 of file SiStripDigitizer.h.

◆ simhit_map_iterator

typedef simhit_map::iterator SiStripDigitizer::simhit_map_iterator

private

Definition at line 87 of file SiStripDigitizer.h.

◆ vstring

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

private

Definition at line 85 of file SiStripDigitizer.h.

Constructor & Destructor Documentation

◆ SiStripDigitizer()

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

explicit

Definition at line 53 of file SiStripDigitizer.cc.

References SiStripOfflineCRack_cfg::alias, apvSimulationParametersToken_, edm::ConsumesCollector::consumes(), detCablingToken_, edm::ConsumesCollector::esConsumes(), Exception, hitsProducer, includeAPVSimulation_, HLT_2022v15_cff::InputTag, edm::Service< T >::isAvailable(), PRDigi, edm::ProducesCollector::produces(), SCDigi, AlCaHLTBitMon_QueryRunRegistry::string, makeGlobalPositionRcd_cfg::tag, theDigiAlgo, trackerContainers, useConfFromDB, VRDigi, and ZSDigi.

     : 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")),
       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")),
       tTopoToken_(iC.esConsumes()),
       pDDToken_(iC.esConsumes(edm::ESInputTag("", conf.getParameter<std::string>("GeometryType")))),
       pSetupToken_(iC.esConsumes()),
       gainToken_(iC.esConsumes(edm::ESInputTag("", conf.getParameter<std::string>("Gain")))),
       noiseToken_(iC.esConsumes()),
       thresholdToken_(iC.esConsumes()),
       pedestalToken_(iC.esConsumes()),
       deadChannelToken_(iC.esConsumes()) {
   if (useConfFromDB) {
     detCablingToken_ = iC.esConsumes();
   }
   if (includeAPVSimulation_) {
     apvSimulationParametersToken_ = iC.esConsumes();
   }
 
   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, iC);
 }

◆ ~SiStripDigitizer()

SiStripDigitizer::~SiStripDigitizer ( )

override

Definition at line 113 of file SiStripDigitizer.cc.

113 {}

Member Function Documentation

◆ accumulate() [1/2]

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

overridevirtual

Implements DigiAccumulatorMixMod.

Definition at line 146 of file SiStripDigitizer.cc.

References accumulateStripHits(), crossingSimHitIndexOffset_, edm::EventSetup::getData(), StripDigiSimLink::HighTof, hitsProducer, iEvent, StripDigiSimLink::LowTof, FastTrackerRecHitCombiner_cfi::simHits, AlCaHLTBitMon_QueryRunRegistry::string, makeGlobalPositionRcd_cfg::tag, trackerContainers, and tTopoToken_.

                                                                                      {
   //Retrieve tracker topology from geometry
   const TrackerTopology* tTopo = &iSetup.getData(tTopoToken_);
 
   // 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();
   }
 }

◆ accumulate() [2/2]

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

overridevirtual

Implements DigiAccumulatorMixMod.

Definition at line 169 of file SiStripDigitizer.cc.

References accumulateStripHits(), crossingSimHitIndexOffset_, edm::EventSetup::getData(), StripDigiSimLink::HighTof, hitsProducer, iEvent, StripDigiSimLink::LowTof, PileupInfo_, FastTrackerRecHitCombiner_cfi::simHits, AlCaHLTBitMon_QueryRunRegistry::string, makeGlobalPositionRcd_cfg::tag, theDigiAlgo, trackerContainers, and tTopoToken_.

                                                                {
   const TrackerTopology* tTopo = &iSetup.getData(tTopoToken_);
 
   //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();
   }
 }

◆ accumulateStripHits()

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

private

Definition at line 115 of file SiStripDigitizer.cc.

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

Referenced by accumulate().

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

◆ finalizeEvent()

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

overridevirtual

Implements DigiAccumulatorMixMod.

Definition at line 239 of file SiStripDigitizer.cc.

References apvSimulationParametersToken_, runTheMatrix::const, TrackerGeometry::detUnits(), fracOfEventsToSimAPV_, PedestalClient_cfi::gain, gainToken_, edm::EventSetup::getData(), iEvent, includeAPVSimulation_, makeDigiSimLinks_, eostools::move(), hgchebackDigitizer_cfi::noise, noiseToken_, convertSQLitetoXML_cfg::output, pDD, EcalCondDBWriter_cfi::pedestal, pedestalToken_, PRDigi, randomEngine_, SCDigi, theAffectedAPVvector, theDetIdList, theDigiAlgo, remoteMonitoring_LASER_era2018_cfg::threshold, thresholdToken_, tTopoToken_, useConfFromDB, trackerHitRTTI::vector, VRDigi, zeroSuppression, and ZSDigi.

                                                                                   {
   auto const& gain = iSetup.getData(gainToken_);
   auto const& noise = iSetup.getData(noiseToken_);
   auto const& threshold = iSetup.getData(thresholdToken_);
   auto const& pedestal = iSetup.getData(pedestalToken_);
   SiStripApvSimulationParameters const* apvSimulationParameters = nullptr;
 
   std::unique_ptr<bool> simulateAPVInThisEvent = std::make_unique<bool>(false);
   if (includeAPVSimulation_) {
     if (CLHEP::RandFlat::shoot(randomEngine_) < fracOfEventsToSimAPV_) {
       *simulateAPVInThisEvent = true;
       apvSimulationParameters = &iSetup.getData(apvSimulationParametersToken_);
     }
   }
   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>);
 
   const TrackerTopology* tTopo = &iSetup.getData(tTopoToken_);
 
   // 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,
                             gain,
                             threshold,
                             noise,
                             pedestal,
                             *simulateAPVInThisEvent,
                             apvSimulationParameters,
                             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
 }

◆ getEventPileupInfo()

PileupMixingContent* SiStripDigitizer::getEventPileupInfo ( )

inlineoverridevirtual

Reimplemented from DigiAccumulatorMixMod.

Definition at line 77 of file SiStripDigitizer.h.

References PileupInfo_.

77 { return PileupInfo_.get(); }

SiStripDigitizer::PileupInfo_

std::unique_ptr< PileupMixingContent > PileupInfo_

Definition: SiStripDigitizer.h:133

◆ initializeEvent()

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

overridevirtual

Implements DigiAccumulatorMixMod.

Definition at line 196 of file SiStripDigitizer.cc.

References cms::cuda::assert(), runTheMatrix::const, crossingSimHitIndexOffset_, ddCacheID_, deadChannelCacheID_, deadChannelToken_, detCablingToken_, detectorUnits, TrackerGeometry::detUnits(), edm::EventSetup::get(), edm::EventSetup::getData(), edm::RandomNumberGenerator::getEngine(), iEvent, or, pDD, pDDToken_, pSetup, pSetupToken_, randomEngine_, theAffectedAPVvector, theDetIdList, theDigiAlgo, and useConfFromDB.

                                                                                           {
   // 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) {
     iSetup.getData(detCablingToken_).addConnected(theDetIdList);
   }
 
   // Cache random number engine
   edm::Service<edm::RandomNumberGenerator> rng;
   randomEngine_ = &rng->getEngine(iEvent.streamID());
 
   theDigiAlgo->initializeEvent(iSetup);
 
   pDD = &iSetup.getData(pDDToken_);
   pSetup = &iSetup.getData(pSetupToken_);
 
   // We only need to clear and (re)fill detectorUnits when the geometry type IOV changes.
   auto ddCache = iSetup.get<TrackerDigiGeometryRecord>().cacheIdentifier();
   auto deadChannelCache = iSetup.get<SiStripBadChannelRcd>().cacheIdentifier();
   if (ddCache != ddCacheID_ or deadChannelCache != deadChannelCacheID_) {
     ddCacheID_ = ddCache;
     deadChannelCacheID_ = deadChannelCache;
     detectorUnits.clear();
 
     auto const& deadChannel = iSetup.getData(deadChannelToken_);
     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);
         detectorUnits.insert(std::make_pair(detId, stripdet));
         theDigiAlgo->initializeDetUnit(stripdet, deadChannel);
       }
     }
   }
 }

◆ 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 68 of file SiStripDigitizer.h.

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

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

Member Data Documentation

◆ apvSimulationParametersToken_

edm::ESGetToken<SiStripApvSimulationParameters, SiStripApvSimulationParametersRcd> SiStripDigitizer::apvSimulationParametersToken_

private

Definition at line 109 of file SiStripDigitizer.h.

Referenced by finalizeEvent(), and SiStripDigitizer().

◆ 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 123 of file SiStripDigitizer.h.

Referenced by accumulate(), and initializeEvent().