#include <Phase2TrackerDigitizer.h>

Inheritance diagram for cms::Phase2TrackerDigitizer:

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

Public Member Functions
virtual void	accumulate (edm::Event const &e, edm::EventSetup const &c) override

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

virtual void	beginLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &iSetup) override

virtual void	endLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &iSetup) override

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

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

	Phase2TrackerDigitizer (const edm::ParameterSet &iConfig, edm::stream::EDProducerBase &mixMod, edm::ConsumesCollector &iC)

virtual	~Phase2TrackerDigitizer ()

Public Member Functions inherited from DigiAccumulatorMixMod
virtual void	beginRun (edm::Run const &run, edm::EventSetup const &setup)

	DigiAccumulatorMixMod ()

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)

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 edm::ParameterSet &	iconfig_

ModuleTypeCache	moduleTypeCache_

edm::ESHandle< TrackerGeometry >	pDD_

edm::ESHandle< MagneticField >	pSetup_

CLHEP::HepRandomEngine *	rndEngine_

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

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

private

Definition at line 70 of file Phase2TrackerDigitizer.h.

Member Enumeration Documentation

enum cms::Phase2TrackerDigitizer::AlgorithmType

strongprivate

Enumerator
InnerPixel
PixelinPS
StripinPS
TwoStrip
Unknown

Definition at line 73 of file Phase2TrackerDigitizer.h.

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

Constructor & Destructor Documentation

cms::Phase2TrackerDigitizer::Phase2TrackerDigitizer	(	const edm::ParameterSet &	iConfig,
		edm::stream::EDProducerBase &	mixMod,
		edm::ConsumesCollector &	iC
	)

explicit

Definition at line 79 of file Phase2TrackerDigitizer.cc.

References AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                                                                           :
     first_(true),
     hitsProducer_(iConfig.getParameter<std::string>("hitsProducer")),
     trackerContainers_(iConfig.getParameter<std::vector<std::string> >("ROUList")),
     geometryType_(iConfig.getParameter<std::string>("GeometryType")),
     iconfig_(iConfig)
   {
     //edm::LogInfo("Phase2TrackerDigitizer") << "Initialize Digitizer Algorithms";
     const std::string alias1("simSiPixelDigis"); 
     mixMod.produces<edm::DetSetVector<PixelDigi> >("Pixel").setBranchAlias(alias1);
     mixMod.produces<edm::DetSetVector<PixelDigiSimLink> >("Pixel").setBranchAlias(alias1);
 
     const std::string alias2("simSiTrackerDigis"); 
     mixMod.produces<edm::DetSetVector<Phase2TrackerDigi> >("Tracker").setBranchAlias(alias2);
     mixMod.produces<edm::DetSetVector<PixelDigiSimLink> >("Tracker").setBranchAlias(alias2);
 
   }

cms::Phase2TrackerDigitizer::~Phase2TrackerDigitizer ( )

virtual

Definition at line 138 of file Phase2TrackerDigitizer.cc.

                                                   {  
     edm::LogInfo("Phase2TrackerDigitizer") << "Destroying the Digitizer";
   }

Member Function Documentation

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

overridevirtual

Implements DigiAccumulatorMixMod.

Definition at line 185 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 190 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 195 of file Phase2TrackerDigitizer.cc.

References accumulatePixelHits(), crossingSimHitIndexOffset_, edm::InputTag::encode(), PixelDigiSimLink::HighTof, hitsProducer_, edm::HandleBase::isValid(), PixelDigiSimLink::LowTof, trackerHits::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 142 of file Phase2TrackerDigitizer.cc.

References algomap_, detectorUnits_, getAlgoType(), MagneticField::inTesla(), LogDebug, GloballyPositioned< T >::position(), pSetup_, trackerHits::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++;
       }
     }
   }

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

private

Definition at line 303 of file Phase2TrackerDigitizer.cc.

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

Referenced by finalizeEvent().

                                                                                                       {
     const TrackerTopology* tTopo = tTopoHand.product();
     std::vector<edm::DetSet<Phase2TrackerDigi> > 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<Phase2TrackerDigi> 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 = Phase2TrackerDigi::channelToPixel(digi_p.first);
     collector.data.emplace_back(ip.first, ip.second, info.ot_bit);
         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.size() > 0) digiVector.push_back(std::move(collector));      
       if (linkcollector.data.size() > 0) digiLinkVector.push_back(std::move(linkcollector));
     } 
     
     // Step C: create collection with the cache vector of DetSet 
     std::unique_ptr<edm::DetSetVector<Phase2TrackerDigi> >
       output(new edm::DetSetVector<Phase2TrackerDigi>(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");
     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 265 of file Phase2TrackerDigitizer.cc.

References algomap_, PixelDigi::channelToPixel(), TrackerGeometry::detUnits(), getAlgoType(), info(), InnerPixel, eostools::move(), 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.size() > 0) digiVector.push_back(std::move(collector));      
       if (linkcollector.data.size() > 0) 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");
     iEvent.put(std::move(outputlink), "Pixel");
   }

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

inlinevirtual

Definition at line 61 of file Phase2TrackerDigitizer.h.

References iEvent.

61 {}

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

overridevirtual

Reimplemented from DigiAccumulatorMixMod.

Definition at line 97 of file Phase2TrackerDigitizer.cc.

References algomap_, edm::ESWatcher< T >::check(), detectorUnits_, TrackerGeometry::detUnits(), Exception, geometryType_, edm::EventSetup::get(), edm::RandomNumberGenerator::getEngine(), iconfig_, edm::LuminosityBlock::index(), InnerPixel, edm::Service< T >::isAvailable(), moduleTypeCache_, pDD_, phase2TrackerDigitizer_cfi::PixelDigitizerAlgorithm, PixelinPS, pSetup_, phase2TrackerDigitizer_cfi::PSPDigitizerAlgorithm, phase2TrackerDigitizer_cfi::PSSDigitizerAlgorithm, rndEngine_, phase2TrackerDigitizer_cfi::SSDigitizerAlgorithm, StripinPS, theTkDigiGeomWatcher, align::Tracker, tTopoHand, and TwoStrip.

                                                                                                                {
     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.";
     }
     rndEngine_ = &(rng->getEngine(lumi.index()));
 
     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));
     }
       }
     }
   
     // one type of Digi and DigiSimLink suffices 
     // changes in future: InnerPixel -> Tracker
     // creating algorithm objects and pushing them into the map
     algomap_[AlgorithmType::InnerPixel] = std::unique_ptr<Phase2TrackerDigitizerAlgorithm>(new PixelDigitizerAlgorithm(iconfig_, (*rndEngine_)));
     algomap_[AlgorithmType::PixelinPS]  = std::unique_ptr<Phase2TrackerDigitizerAlgorithm>(new PSPDigitizerAlgorithm(iconfig_, (*rndEngine_)));
     algomap_[AlgorithmType::StripinPS]  = std::unique_ptr<Phase2TrackerDigitizerAlgorithm>(new PSSDigitizerAlgorithm(iconfig_, (*rndEngine_)));
     algomap_[AlgorithmType::TwoStrip]   = std::unique_ptr<Phase2TrackerDigitizerAlgorithm>(new SSDigitizerAlgorithm(iconfig_, (*rndEngine_)));
   }

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

overridevirtual

Reimplemented from DigiAccumulatorMixMod.

Definition at line 135 of file Phase2TrackerDigitizer.cc.

References algomap_.

                                                                                                              {
     algomap_.clear();
   }

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

overridevirtual

Implements DigiAccumulatorMixMod.

Definition at line 214 of file Phase2TrackerDigitizer.cc.

References addOuterTrackerCollection(), addPixelCollection(), edm::ParameterSet::getParameter(), and iconfig_.

                                                                                           {
     const bool isOuterTrackerReadoutAnalog = iconfig_.getParameter<bool>("isOTreadoutAnalog");
     //Decide if we want analog readout for Outer Tracker.
     addPixelCollection(iEvent, iSetup, isOuterTrackerReadoutAnalog);
     if(!isOuterTrackerReadoutAnalog)
       addOuterTrackerCollection(iEvent, iSetup);
   }

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

private

Definition at line 221 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(), and addPixelCollection().

                                                                                                 {
     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 170 of file Phase2TrackerDigitizer.cc.

References algomap_, crossingSimHitIndexOffset_, and first_.

                                                                                         {
     
     // Must initialize all the algorithms
     for (auto const & el : algomap_) {
       if (first_) el.second->init(iSetup); 
       el.second->initializeEvent(); 
     }
     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();
   }  

Member Data Documentation

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

private

Definition at line 100 of file Phase2TrackerDigitizer.h.

Referenced by accumulatePixelHits(), addOuterTrackerCollection(), addPixelCollection(), beginLuminosityBlock(), endLuminosityBlock(), and initializeEvent().

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

Referenced by accumulate_local(), and initializeEvent().

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

private

Definition at line 106 of file Phase2TrackerDigitizer.h.

Referenced by accumulatePixelHits(), and beginLuminosityBlock().

bool cms::Phase2TrackerDigitizer::first_

private

Definition at line 89 of file Phase2TrackerDigitizer.h.

Referenced by initializeEvent().

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

private