cms::Phase2TrackerDigitizer Class Reference

#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	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	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 PileupMixingContent *	getEventPileupInfo ()
virtual void	initializeBunchCrossing (edm::Event const &event, edm::EventSetup const &setup, int bunchCrossing)
DigiAccumulatorMixMod const &	operator= (DigiAccumulatorMixMod const &)=delete
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::InnerPixelBricked, 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	hitsProducer_
const bool	isOuterTrackerReadoutAnalog_
const bool	makeDigiSimLinks_
ModuleTypeCache	moduleTypeCache_
const TrackerGeometry *	pDD_ = nullptr
const edm::ESGetToken < TrackerGeometry, TrackerDigiGeometryRecord >	pDDToken_
const bool	premixStage1_
const MagneticField *	pSetup_ = nullptr
const edm::ESGetToken < MagneticField, IdealMagneticFieldRecord >	pSetupToken_
edm::ESWatcher < TrackerDigiGeometryRecord >	theTkDigiGeomWatcher_
const vstring	trackerContainers_
const TrackerTopology *	tTopo_ = nullptr
const edm::ESGetToken < TrackerTopology, TrackerTopologyRcd >	tTopoToken_

Detailed Description

Definition at line 51 of file Phase2TrackerDigitizer.h.

Member Typedef Documentation

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

Definition at line 53 of file Phase2TrackerDigitizer.h.

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

private

Definition at line 73 of file Phase2TrackerDigitizer.h.

Member Enumeration Documentation

enum cms::Phase2TrackerDigitizer::AlgorithmType

strongprivate

Enumerator
InnerPixel
InnerPixelBricked
InnerPixel3D
PixelinPS
StripinPS
TwoStrip
Unknown

Definition at line 76 of file Phase2TrackerDigitizer.h.

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

Constructor & Destructor Documentation

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

explicit

Definition at line 63 of file Phase2TrackerDigitizer.cc.

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

      : first_(true),
        hitsProducer_(iConfig.getParameter<std::string>("hitsProducer")),
        trackerContainers_(iConfig.getParameter<std::vector<std::string> >("ROUList")),
        pDDToken_(iC.esConsumes(edm::ESInputTag("", iConfig.getParameter<std::string>("GeometryType")))),
        pSetupToken_(iC.esConsumes()),
        tTopoToken_(iC.esConsumes()),
        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, iC);
    algomap_[AlgorithmType::InnerPixelBricked] = std::make_unique<PixelBrickedDigitizerAlgorithm>(iConfig, iC);
    algomap_[AlgorithmType::InnerPixel3D] = std::make_unique<Pixel3DDigitizerAlgorithm>(iConfig, iC);
    algomap_[AlgorithmType::PixelinPS] = std::make_unique<PSPDigitizerAlgorithm>(iConfig, iC);
    algomap_[AlgorithmType::StripinPS] = std::make_unique<PSSDigitizerAlgorithm>(iConfig, iC);
    algomap_[AlgorithmType::TwoStrip] = std::make_unique<SSDigitizerAlgorithm>(iConfig, iC);
  }

cms::Phase2TrackerDigitizer::~Phase2TrackerDigitizer ( )

override

Definition at line 102 of file Phase2TrackerDigitizer.cc.

{}

Member Function Documentation

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

overridevirtual

Implements DigiAccumulatorMixMod.

Definition at line 176 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 180 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 187 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);

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

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

private

Definition at line 103 of file Phase2TrackerDigitizer.cc.

References algomap_, SplitLinear::begin, detectorUnits_, dataset::end, getAlgoType(), MagneticField::inTesla(), LogDebug, GloballyPositioned< T >::position(), pSetup_, trackerHits::simHits, and GeomDet::surface().

Referenced by accumulate_local().

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

template<typename DigiType >

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

private

Definition at line 352 of file Phase2TrackerDigitizer.cc.

References algomap_, edm::DetSet< T >::data, TrackerGeometry::detUnits(), getAlgoType(), InnerPixel, InnerPixel3D, InnerPixelBricked, makeDigiSimLinks_, eostools::move(), convertSQLitetoXML_cfg::output, pDD_, edm::Event::put(), DigitizerUtility::DigiSimInfo::simInfoList, and tTopo_.

                                                                                                      {
    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 ||
          algotype == AlgorithmType::InnerPixelBricked)
        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");
  }

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

private

Definition at line 283 of file Phase2TrackerDigitizer.cc.

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

Referenced by finalizeEvent().

                                                                        {
    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 &&
          algotype != AlgorithmType::InnerPixelBricked)
        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");
  }

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

inlinevirtual

Definition at line 64 of file Phase2TrackerDigitizer.h.

{}

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

overridevirtual

Implements DigiAccumulatorMixMod.

Definition at line 218 of file Phase2TrackerDigitizer.cc.

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

Referenced by PreMixingPhase2TrackerWorker::put().

                                                                                          {
    //Decide if we want analog readout for Outer Tracker.
    addPixelCollection(iEvent, iSetup, isOuterTrackerReadoutAnalog_);
    if (!isOuterTrackerReadoutAnalog_) {
      if (premixStage1_)
        addOuterTrackerCollection<PixelDigi>(iEvent, iSetup);
      else
        addOuterTrackerCollection<Phase2TrackerDigi>(iEvent, iSetup);
    }
  }

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

private

Definition at line 228 of file Phase2TrackerDigitizer.cc.

References detectorUnits_, TrackerGeometry::getDetectorType(), InnerPixel, InnerPixel3D, InnerPixelBricked, PixelTopology::isBricked(), moduleTypeCache_, pDD_, TrackerGeometry::Ph1PXB, TrackerGeometry::Ph1PXF, TrackerGeometry::Ph2PSP, TrackerGeometry::Ph2PSS, TrackerGeometry::Ph2PXB, TrackerGeometry::Ph2PXB3D, TrackerGeometry::Ph2PXF, TrackerGeometry::Ph2PXF3D, TrackerGeometry::Ph2SS, PixelinPS, PixelGeomDetUnit::specificTopology(), StripinPS, TwoStrip, TrackerGeometry::UNKNOWN, and Unknown.

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

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

    auto detUnit = detectorUnits_.find(detId_raw);
    const Phase2TrackerGeomDetUnit* pixdet = dynamic_cast<const Phase2TrackerGeomDetUnit*>(detUnit->second);
    const Phase2TrackerTopology* topol = &pixdet->specificTopology();
    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:
        if (topol->isBricked())
          algotype = AlgorithmType::InnerPixelBricked;
        else
          algotype = AlgorithmType::InnerPixel;
        break;
      case TrackerGeometry::ModuleType::Ph2PXF:
        if (topol->isBricked())
          algotype = AlgorithmType::InnerPixelBricked;
        else
          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;
  }

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

overridevirtual

Implements DigiAccumulatorMixMod.

Definition at line 134 of file Phase2TrackerDigitizer.cc.

References algomap_, cms::cuda::assert(), edm::ESWatcher< T >::check(), crossingSimHitIndexOffset_, detectorUnits_, TrackerGeometry::detUnits(), Exception, first_, edm::EventSetup::getData(), edm::RandomNumberGenerator::getEngine(), edm::Service< T >::isAvailable(), moduleTypeCache_, pDD_, pDDToken_, pSetup_, pSetupToken_, edm::Event::streamID(), theTkDigiGeomWatcher_, align::Tracker, tTopo_, and tTopoToken_.

Referenced by PreMixingPhase2TrackerWorker::initializeEvent().

                                                                                             {
    edm::Service<edm::RandomNumberGenerator> rng;
    if (!rng.isAvailable()) {
      throw cms::Exception("Configuration")
          << "Phase2TrackerDigitizer requires the RandomNumberGeneratorService\n"
             "which is not present in the configuration file.  You must add the service\n"
             "in the configuration file or remove the modules that require it.";
    }

    pSetup_ = &iSetup.getData(pSetupToken_);
    tTopo_ = &iSetup.getData(tTopoToken_);

    if (theTkDigiGeomWatcher_.check(iSetup)) {
      pDD_ = &iSetup.getData(pDDToken_);

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

    // Must initialize all the algorithms
    for (auto const& el : algomap_) {
      if (first_)
        el.second->init(iSetup);

      el.second->initializeEvent(rng->getEngine(e.streamID()));
    }
    first_ = false;
    // Make sure that the first crossing processed starts indexing the sim hits from zero.
    // This variable is used so that the sim hits from all crossing frames have sequential
    // indices used to create the digi-sim link (if configured to do so) rather than starting
    // from zero for each crossing.
    crossingSimHitIndexOffset_.clear();
  }

void cms::Phase2TrackerDigitizer::loadAccumulator

(

const std::map< uint32_t, std::map< int, float > > &

accumulator

)

Definition at line 210 of file Phase2TrackerDigitizer.cc.

References algomap_, and getAlgoType().

Referenced by PreMixingPhase2TrackerWorker::put().

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

Member Data Documentation

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

private

Definition at line 97 of file Phase2TrackerDigitizer.h.

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

std::map<std::string, size_t> cms::Phase2TrackerDigitizer::crossingSimHitIndexOffset_

private

Offset to add to the index of each sim hit to account for which crossing it's in.

I need to know what each sim hit index will be when the hits from all crossing frames are merged into one collection (assuming the MixingModule is configured to create the crossing frame for all sim hits). To do this I'll record how many hits were in each crossing, and then add that on to the index for a given hit in a given crossing. This assumes that the crossings are processed in the same order here as they are put into the crossing frame, which I'm pretty sure is true.
The key is the name of the sim hit collection.

Definition at line 96 of file Phase2TrackerDigitizer.h.

Referenced by accumulate_local(), and initializeEvent().

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

private

Definition at line 105 of file Phase2TrackerDigitizer.h.

Referenced by accumulatePixelHits(), getAlgoType(), and initializeEvent().

bool cms::Phase2TrackerDigitizer::first_

private

Definition at line 86 of file Phase2TrackerDigitizer.h.

Referenced by initializeEvent().

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

private

Definition at line 98 of file Phase2TrackerDigitizer.h.

Referenced by accumulate_local().

const bool cms::Phase2TrackerDigitizer::isOuterTrackerReadoutAnalog_

private

Definition at line 108 of file Phase2TrackerDigitizer.h.

Referenced by finalizeEvent().

const bool cms::Phase2TrackerDigitizer::makeDigiSimLinks_

private

Definition at line 110 of file Phase2TrackerDigitizer.h.

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

ModuleTypeCache cms::Phase2TrackerDigitizer::moduleTypeCache_

private

Definition at line 112 of file Phase2TrackerDigitizer.h.

Referenced by getAlgoType(), and initializeEvent().

const TrackerGeometry* cms::Phase2TrackerDigitizer::pDD_ = nullptr

private

Definition at line 103 of file Phase2TrackerDigitizer.h.

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

const edm::ESGetToken<TrackerGeometry, TrackerDigiGeometryRecord> cms::Phase2TrackerDigitizer::pDDToken_

private

Definition at line 100 of file Phase2TrackerDigitizer.h.

Referenced by initializeEvent().

const bool cms::Phase2TrackerDigitizer::premixStage1_

private

Definition at line 109 of file Phase2TrackerDigitizer.h.

Referenced by finalizeEvent(), and Phase2TrackerDigitizer().

const MagneticField* cms::Phase2TrackerDigitizer::pSetup_ = nullptr

private

Definition at line 104 of file Phase2TrackerDigitizer.h.

Referenced by accumulatePixelHits(), and initializeEvent().

const edm::ESGetToken<MagneticField, IdealMagneticFieldRecord> cms::Phase2TrackerDigitizer::pSetupToken_

private

Definition at line 101 of file Phase2TrackerDigitizer.h.

Referenced by initializeEvent().

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

private

Definition at line 107 of file Phase2TrackerDigitizer.h.

Referenced by initializeEvent().

const vstring cms::Phase2TrackerDigitizer::trackerContainers_

private

Definition at line 99 of file Phase2TrackerDigitizer.h.

Referenced by accumulate_local().

const TrackerTopology* cms::Phase2TrackerDigitizer::tTopo_ = nullptr

private

Definition at line 106 of file Phase2TrackerDigitizer.h.

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

const edm::ESGetToken<TrackerTopology, TrackerTopologyRcd> cms::Phase2TrackerDigitizer::tTopoToken_

private

Definition at line 102 of file Phase2TrackerDigitizer.h.

Referenced by initializeEvent().