#include <HGCDigitizer.h>

Public Types
typedef std::tuple< int, uint32_t, float >	HGCCaloHitTuple_t

Public Member Functions
void	accumulate (edm::Event const &e, edm::EventSetup const &c, CLHEP::HepRandomEngine *hre)
	handle SimHit accumulation More...

void	accumulate (PileUpEventPrincipal const &e, edm::EventSetup const &c, CLHEP::HepRandomEngine *hre)

void	accumulate (edm::Handle< edm::PCaloHitContainer > const &hits, int bxCrossing, const HGCalGeometry geom, CLHEP::HepRandomEngine hre)

void	accumulate_forPreMix (edm::Event const &e, edm::EventSetup const &c, CLHEP::HepRandomEngine *hre)

void	accumulate_forPreMix (PileUpEventPrincipal const &e, edm::EventSetup const &c, CLHEP::HepRandomEngine *hre)

void	accumulate_forPreMix (edm::Handle< edm::PCaloHitContainer > const &hits, int bxCrossing, const HGCalGeometry geom, CLHEP::HepRandomEngine hre)

void	accumulate_forPreMix (const PHGCSimAccumulator &simAccumulator, const bool minbiasFlag)

std::string	digiCollection ()

void	finalizeEvent (edm::Event &e, edm::EventSetup const &c, CLHEP::HepRandomEngine *hre)

	HGCDigitizer (const edm::ParameterSet &ps, edm::ConsumesCollector &iC)

void	initializeEvent (edm::Event const &e, edm::EventSetup const &c)
	actions at the start/end of event More...

	~HGCDigitizer ()=default

Static Public Member Functions
static bool	orderByDetIdThenTime (const HGCCaloHitTuple_t &a, const HGCCaloHitTuple_t &b)

Private Member Functions
void	checkPosition (const HGCalDigiCollection *digis) const

uint32_t	getType () const

void	resetPUSimHitDataAccumulator ()

void	resetSimHitDataAccumulator ()

Private Attributes
std::array< double, 4 >	averageOccupancies_

const double	bxTime_

std::vector< float >	cce_

const std::string	digiCollection_

const int	digitizationType_

double	ev_per_eh_pair_

const edm::ESGetToken< CaloGeometry, CaloGeometryRecord >	geomToken_

edm::ESWatcher< CaloGeometryRecord >	geomWatcher_

const HGCalGeometry *	gHGCal_ = nullptr

const std::string	hitCollection_

std::unordered_map< uint32_t, bool >	hitOrder_monitor

std::unordered_map< uint32_t, std::vector< std::pair< float, float > > >	hitRefs_bx0

const std::string	hitsProducer_

const edm::EDGetTokenT< std::vector< PCaloHit > >	hitToken_

const int	maxSimHitsAccTime_

uint32_t	nEvents_

std::unordered_map< uint32_t, std::vector< std::tuple< float, float, float > > >	PhitRefs_bx0

const bool	premixStage1_

const double	premixStage1MaxCharge_

const double	premixStage1MinCharge_

std::unique_ptr< hgc::HGCPUSimHitDataAccumulator >	pusimHitAccumulator_

std::unique_ptr< hgc::HGCSimHitDataAccumulator >	simHitAccumulator_

std::unique_ptr< HGCDigitizerBase >	theDigitizer_

const float	tofDelay_

std::unordered_set< DetId >	validIds_

const uint32_t	verbosity_

Static Private Attributes
static const unsigned int	maxBx_ = 14

static const unsigned int	thisBx_ = 9

Detailed Description

Definition at line 29 of file HGCDigitizer.h.

Member Typedef Documentation

◆ HGCCaloHitTuple_t

typedef std::tuple<int, uint32_t, float> HGCDigitizer::HGCCaloHitTuple_t

Definition at line 35 of file HGCDigitizer.h.

Constructor & Destructor Documentation

◆ HGCDigitizer()

HGCDigitizer::HGCDigitizer	(	const edm::ParameterSet &	ps,
		edm::ConsumesCollector &	iC
	)

Definition at line 227 of file HGCDigitizer.cc.

References cce_, get, edm::ParameterSet::getParameter(), crabTemplate::pluginName, AlCaHLTBitMon_QueryRunRegistry::string, edm::swap(), groupFilesInBlocks::temp, and theDigitizer_.

     : simHitAccumulator_(new HGCSimHitDataAccumulator()),
       pusimHitAccumulator_(new HGCPUSimHitDataAccumulator()),
       digiCollection_(ps.getParameter<std::string>("digiCollection")),
       digitizationType_(ps.getParameter<uint32_t>("digitizationType")),
       premixStage1_(ps.getParameter<bool>("premixStage1")),
       premixStage1MinCharge_(ps.getParameter<double>("premixStage1MinCharge")),
       premixStage1MaxCharge_(ps.getParameter<double>("premixStage1MaxCharge")),
       maxSimHitsAccTime_(ps.getParameter<uint32_t>("maxSimHitsAccTime")),
       bxTime_(ps.getParameter<double>("bxTime")),
       hitsProducer_(ps.getParameter<std::string>("hitsProducer")),
       hitCollection_(ps.getParameter<std::string>("hitCollection")),
       hitToken_(iC.consumes<std::vector<PCaloHit>>(edm::InputTag(hitsProducer_, hitCollection_))),
       geomToken_(iC.esConsumes()),
       verbosity_(ps.getUntrackedParameter<uint32_t>("verbosity", 0)),
       tofDelay_(ps.getParameter<double>("tofDelay")),
       averageOccupancies_(occupancyGuesses),
       nEvents_(1) {
   //configure from cfg
 
   const auto& myCfg_ = ps.getParameter<edm::ParameterSet>("digiCfg");
 
   if (myCfg_.existsAs<edm::ParameterSet>("chargeCollectionEfficiencies")) {
     cce_.clear();
     const auto& temp = myCfg_.getParameter<edm::ParameterSet>("chargeCollectionEfficiencies")
                            .getParameter<std::vector<double>>("values");
     for (double cce : temp) {
       cce_.emplace_back(cce);
     }
   } else {
     std::vector<float>().swap(cce_);
   }
 
   auto const& pluginName = ps.getParameter<std::string>("digitizer");
   theDigitizer_ = HGCDigitizerPluginFactory::get()->create(pluginName, ps);
 }

◆ ~HGCDigitizer()

HGCDigitizer::~HGCDigitizer ( )

default

Member Function Documentation

◆ accumulate() [1/3]

void HGCDigitizer::accumulate	(	edm::Event const &	e,
		edm::EventSetup const &	c,
		CLHEP::HepRandomEngine *	hre
	)

handle SimHit accumulation

Definition at line 360 of file HGCDigitizer.cc.

References MillePedeFileConverter_cfg::e, Exception, gHGCal_, hitCollection_, hfClusterShapes_cfi::hits, hitsProducer_, and hitToken_.

Referenced by HGCDigiProducer::accumulate(), and accumulate().

                                                                                                            {
   //get inputs
   const edm::Handle<edm::PCaloHitContainer>& hits = e.getHandle(hitToken_);
   if (!hits.isValid()) {
     edm::LogError("HGCDigitizer") << " @ accumulate : can't find " << hitCollection_ << " collection of "
                                   << hitsProducer_;
     return;
   }
 
   //accumulate in-time the main event
   if (nullptr != gHGCal_) {
     accumulate(hits, 0, gHGCal_, hre);
   } else {
     throw cms::Exception("BadConfiguration") << "HGCDigitizer is not producing EE, FH, or BH digis!";
   }
 }

◆ accumulate() [2/3]

void HGCDigitizer::accumulate	(	PileUpEventPrincipal const &	e,
		edm::EventSetup const &	c,
		CLHEP::HepRandomEngine *	hre
	)

Definition at line 399 of file HGCDigitizer.cc.

References accumulate(), MillePedeFileConverter_cfg::e, Exception, gHGCal_, hitCollection_, hfClusterShapes_cfi::hits, and hitsProducer_.

                                                          {
   //get inputs
   edm::InputTag hitTag(hitsProducer_, hitCollection_);
   edm::Handle<edm::PCaloHitContainer> hits;
   e.getByLabel(hitTag, hits);
 
   if (!hits.isValid()) {
     edm::LogError("HGCDigitizer") << " @ accumulate : can't find " << hitCollection_ << " collection of "
                                   << hitsProducer_;
     return;
   }
 
   //accumulate for the simulated bunch crossing
   if (nullptr != gHGCal_) {
     accumulate(hits, e.bunchCrossing(), gHGCal_, hre);
   } else {
     throw cms::Exception("BadConfiguration") << "HGCDigitizer is not producing EE, FH, or BH digis!";
   }
 }

◆ accumulate() [3/3]

void HGCDigitizer::accumulate	(	edm::Handle< edm::PCaloHitContainer > const &	hits,
		int	bxCrossing,
		const HGCalGeometry *	geom,
		CLHEP::HepRandomEngine *	hre
	)

Definition at line 543 of file HGCDigitizer.cc.

References bxTime_, ALCARECOTkAlJpsiMuMu_cff::charge, TauDecayModes::dec, relativeConstraints::empty, mps_fire::end, f, dqmdumpme::first, relativeConstraints::geom, hitRefs_bx0, hfClusterShapes_cfi::hits, mps_fire::i, l1ctLayer2EG_cff::id, createfilelist::int, dqmiolumiharvest::j, hgceeDigitizer_cfi::keV2fC, maxBx_, orderByDetIdThenTime(), edm::second(), simHitAccumulator_, findQualityFiles::size, jetUpdater_cfi::sort, theDigitizer_, thisBx_, tofDelay_, pfDeepBoostedJetPreprocessParams_cfi::upper_bound, validIds_, trackerHitRTTI::vector, and verbosity_.

                                                          {
   if (nullptr == geom)
     return;
 
   //configuration to apply for the computation of time-of-flight
   auto weightToAbyEnergy = theDigitizer_->toaModeByEnergy();
   auto tdcForToAOnset = theDigitizer_->tdcForToAOnset();
   auto keV2fC = theDigitizer_->keV2fC();
 
   //create list of tuples (pos in container, RECO DetId, time) to be sorted first
   int nchits = (int)hits->size();
 
   std::vector<HGCCaloHitTuple_t> hitRefs;
   hitRefs.reserve(nchits);
   for (int i = 0; i < nchits; ++i) {
     const auto& the_hit = hits->at(i);
     DetId id = simToReco(geom, the_hit.id());
 
     if (verbosity_ > 0) {
       edm::LogVerbatim("HGCDigitizer") << "HGCDigitizer::i/p " << std::hex << the_hit.id() << " o/p " << id.rawId()
                                        << std::dec;
     }
 
     if (0 != id.rawId()) {
       hitRefs.emplace_back(i, id.rawId(), (float)the_hit.time());
     }
   }
 
   std::sort(hitRefs.begin(), hitRefs.end(), this->orderByDetIdThenTime);
   //loop over sorted hits
   nchits = hitRefs.size();
   for (int i = 0; i < nchits; ++i) {
     const int hitidx = std::get<0>(hitRefs[i]);
     const uint32_t id = std::get<1>(hitRefs[i]);
 
     //get the data for this cell, if not available then we skip it
 
     if (!validIds_.count(id))
       continue;
     HGCSimHitDataAccumulator::iterator simHitIt = simHitAccumulator_->emplace(id, HGCCellInfo()).first;
 
     if (id == 0)
       continue;  // to be ignored at RECO level
 
     const float toa = std::get<2>(hitRefs[i]);
     const PCaloHit& hit = hits->at(hitidx);
     const float charge = hit.energy() * 1e6 * keV2fC;
 
     //hit time: [time()]=ns + delay
     //accumulate in 15 buckets of 25ns (9 pre-samples, 1 in-time, 5 post-samples)
     const float tof = toa + tofDelay_;
     const int itime = std::floor(tof / bxTime_) + 9;
 
     //no need to add bx crossing - tof comes already corrected from the mixing module
     //itime += bxCrossing;
     //itime += 9;
 
     if (itime < 0 || itime > (int)maxBx_)
       continue;
 
     //check if time index is ok and store energy
     if (itime >= (int)simHitIt->second.hit_info[0].size())
       continue;
 
     (simHitIt->second).hit_info[0][itime] += charge;
 
     //for time-of-arrival: save the time-sorted list of timestamps with cumulative charge just above threshold
     //working version with pileup only for in-time hits
     int waferThickness = getCellThickness(geom, id);
     bool orderChanged = false;
     if (itime == (int)thisBx_) {
       //if start empty => just add charge and time
       if (hitRefs_bx0[id].empty()) {
         hitRefs_bx0[id].emplace_back(charge, tof);
 
       } else if (tof <= hitRefs_bx0[id].back().second) {
         //find position to insert new entry preserving time sorting
         std::vector<std::pair<float, float>>::iterator findPos =
             std::upper_bound(hitRefs_bx0[id].begin(),
                              hitRefs_bx0[id].end(),
                              std::pair<float, float>(0.f, tof),
                              [](const auto& i, const auto& j) { return i.second <= j.second; });
 
         std::vector<std::pair<float, float>>::iterator insertedPos = findPos;
         if (findPos->second == tof) {
           //just merge timestamps with exact timing
           findPos->first += charge;
         } else {
           //insert new element cumulating the charge
           insertedPos = hitRefs_bx0[id].insert(findPos,
                                                (findPos == hitRefs_bx0[id].begin())
                                                    ? std::pair<float, float>(charge, tof)
                                                    : std::pair<float, float>((findPos - 1)->first + charge, tof));
         }
 
         //cumulate the charge of new entry for all elements that follow in the sorted list
         //and resize list accounting for cases when the inserted element itself crosses the threshold
         for (std::vector<std::pair<float, float>>::iterator step = insertedPos; step != hitRefs_bx0[id].end(); ++step) {
           if (step != insertedPos)
             step->first += charge;
           // resize the list stopping with the first timeStamp with cumulative charge above threshold
           if (step->first > tdcForToAOnset[waferThickness - 1] && step->second != hitRefs_bx0[id].back().second) {
             hitRefs_bx0[id].resize(std::upper_bound(hitRefs_bx0[id].begin(),
                                                     hitRefs_bx0[id].end(),
                                                     std::pair<float, float>(0.f, step->second),
                                                     [](const auto& i, const auto& j) { return i.second < j.second; }) -
                                    hitRefs_bx0[id].begin());
             for (auto stepEnd = step + 1; stepEnd != hitRefs_bx0[id].end(); ++stepEnd)
               stepEnd->first += charge;
             break;
           }
         }
 
         orderChanged = true;
       } else {
         //add new entry at the end of the list
         if (hitRefs_bx0[id].back().first <= tdcForToAOnset[waferThickness - 1]) {
           hitRefs_bx0[id].emplace_back(hitRefs_bx0[id].back().first + charge, tof);
         }
       }
     }
     float accChargeForToA = hitRefs_bx0[id].empty() ? 0.f : hitRefs_bx0[id].back().first;
     //now compute the firing ToA through the interpolation of the consecutive time-stamps at threshold
     if (weightToAbyEnergy)
       (simHitIt->second).hit_info[1][itime] += charge * tof;
     else if (accChargeForToA > tdcForToAOnset[waferThickness - 1] &&
              ((simHitIt->second).hit_info[1][itime] == 0 || orderChanged == true)) {
       float fireTDC = hitRefs_bx0[id].back().second;
       if (hitRefs_bx0[id].size() > 1) {
         float chargeBeforeThr = (hitRefs_bx0[id].end() - 2)->first;
         float tofchargeBeforeThr = (hitRefs_bx0[id].end() - 2)->second;
 
         float deltaQ = accChargeForToA - chargeBeforeThr;
         float deltaTOF = fireTDC - tofchargeBeforeThr;
         fireTDC = (tdcForToAOnset[waferThickness - 1] - chargeBeforeThr) * deltaTOF / deltaQ + tofchargeBeforeThr;
       }
       (simHitIt->second).hit_info[1][itime] = fireTDC;
     }
   }
   hitRefs.clear();
 }

◆ accumulate_forPreMix() [1/4]

void HGCDigitizer::accumulate_forPreMix	(	edm::Event const &	e,
		edm::EventSetup const &	c,
		CLHEP::HepRandomEngine *	hre
	)

Definition at line 339 of file HGCDigitizer.cc.

References MillePedeFileConverter_cfg::e, Exception, gHGCal_, hitCollection_, hfClusterShapes_cfi::hits, hitsProducer_, and hitToken_.

Referenced by HGCDigiProducer::accumulate(), accumulate_forPreMix(), PreMixingHGCalWorker::addPileups(), and PreMixingHGCalWorker::addSignals().

                                                                    {
   //get inputs
 
   const edm::Handle<edm::PCaloHitContainer>& hits = e.getHandle(hitToken_);
   if (!hits.isValid()) {
     edm::LogError("HGCDigitizer") << " @ accumulate_minbias : can't find " << hitCollection_ << " collection of "
                                   << hitsProducer_;
     return;
   }
 
   //accumulate in-time the main event
   if (nullptr != gHGCal_) {
     accumulate_forPreMix(hits, 0, gHGCal_, hre);
   } else {
     throw cms::Exception("BadConfiguration") << "HGCDigitizer is not producing EE, FH, or BH digis!";
   }
 }

◆ accumulate_forPreMix() [2/4]

void HGCDigitizer::accumulate_forPreMix	(	PileUpEventPrincipal const &	e,
		edm::EventSetup const &	c,
		CLHEP::HepRandomEngine *	hre
	)

Definition at line 378 of file HGCDigitizer.cc.

References accumulate_forPreMix(), MillePedeFileConverter_cfg::e, Exception, gHGCal_, hitCollection_, hfClusterShapes_cfi::hits, and hitsProducer_.

                                                                    {
   edm::InputTag hitTag(hitsProducer_, hitCollection_);
   edm::Handle<edm::PCaloHitContainer> hits;
   e.getByLabel(hitTag, hits);
 
   if (!hits.isValid()) {
     edm::LogError("HGCDigitizer") << " @ accumulate : can't find " << hitCollection_ << " collection of "
                                   << hitsProducer_;
     return;
   }
 
   if (nullptr != gHGCal_) {
     accumulate_forPreMix(hits, e.bunchCrossing(), gHGCal_, hre);
   } else {
     throw cms::Exception("BadConfiguration") << "HGCDigitizer is not producing EE, FH, or BH digis!";
   }
 }

◆ accumulate_forPreMix() [3/4]

void HGCDigitizer::accumulate_forPreMix	(	edm::Handle< edm::PCaloHitContainer > const &	hits,
		int	bxCrossing,
		const HGCalGeometry *	geom,
		CLHEP::HepRandomEngine *	hre
	)

Definition at line 422 of file HGCDigitizer.cc.

References bxTime_, ALCARECOTkAlJpsiMuMu_cff::charge, relativeConstraints::empty, mps_fire::end, f, relativeConstraints::geom, hgceeDigitizer_cfi::hitCollection, hfClusterShapes_cfi::hits, mps_fire::i, l1ctLayer2EG_cff::id, createfilelist::int, dqmiolumiharvest::j, hgceeDigitizer_cfi::keV2fC, maxBx_, orderByDetIdThenTime(), PhitRefs_bx0, push_back(), pusimHitAccumulator_, jetUpdater_cfi::sort, theDigitizer_, thisBx_, tofDelay_, pfDeepBoostedJetPreprocessParams_cfi::upper_bound, and validIds_.

                                                                    {
   if (nullptr == geom)
     return;
 
   auto keV2fC = theDigitizer_->keV2fC();
   auto tdcForToAOnset = theDigitizer_->tdcForToAOnset();
 
   int nchits = (int)hits->size();
   int count_thisbx = 0;
   std::vector<HGCCaloHitTuple_t> hitRefs;
   hitRefs.reserve(nchits);
   for (int i = 0; i < nchits; ++i) {
     const auto& the_hit = hits->at(i);
     DetId id = simToReco(geom, the_hit.id());
     // to be written the verbosity block
     if (id.rawId() != 0) {
       hitRefs.emplace_back(i, id.rawId(), (float)the_hit.time());
     }
   }
   std::sort(hitRefs.begin(), hitRefs.end(), this->orderByDetIdThenTime);
 
   nchits = hitRefs.size();
   for (int i = 0; i < nchits; ++i) {
     const int hitidx = std::get<0>(hitRefs[i]);
     const uint32_t id = std::get<1>(hitRefs[i]);
     if (!validIds_.count(id))
       continue;
 
     if (id == 0)
       continue;
 
     const float toa = std::get<2>(hitRefs[i]);
     const PCaloHit& hit = hits->at(hitidx);
     const float charge = hit.energy() * 1e6 * keV2fC;  // * getCCE(geom, id, cce_);
 
     const float tof = toa + tofDelay_;
     const int itime = std::floor(tof / bxTime_) + 9;
 
     if (itime < 0 || itime > (int)maxBx_)
       continue;
 
     if (itime >= (int)(maxBx_ + 1))
       continue;
 
     int waferThickness = getCellThickness(geom, id);
     if (itime == (int)thisBx_) {
       ++count_thisbx;
       if (PhitRefs_bx0[id].empty()) {
         PhitRefs_bx0[id].emplace_back(charge, charge, tof);
       } else if (tof > std::get<2>(PhitRefs_bx0[id].back())) {
         PhitRefs_bx0[id].emplace_back(charge, charge + std::get<1>(PhitRefs_bx0[id].back()), tof);
       } else if (tof == std::get<2>(PhitRefs_bx0[id].back())) {
         std::get<0>(PhitRefs_bx0[id].back()) += charge;
         std::get<1>(PhitRefs_bx0[id].back()) += charge;
       } else {
         //find position to insert new entry preserving time sorting
         auto findPos = std::upper_bound(PhitRefs_bx0[id].begin(),
                                         PhitRefs_bx0[id].end(),
                                         hit_timeStamp(charge, 0.f, tof),
                                         [](const auto& i, const auto& j) { return std::get<2>(i) <= std::get<2>(j); });
 
         auto insertedPos = findPos;
 
         if (tof == std::get<2>(*(findPos - 1))) {
           std::get<0>(*(findPos - 1)) += charge;
           std::get<1>(*(findPos - 1)) += charge;
 
         } else {
           insertedPos = PhitRefs_bx0[id].insert(findPos,
                                                 (findPos == PhitRefs_bx0[id].begin())
                                                     ? hit_timeStamp(charge, charge, tof)
                                                     : hit_timeStamp(charge, charge + std::get<1>(*(findPos - 1)), tof));
         }
         //cumulate the charge of new entry for all elements that follow in the sorted list
         //and resize list accounting for cases when the inserted element itself crosses the threshold
 
         for (auto step = insertedPos; step != PhitRefs_bx0[id].end(); ++step) {
           if (step != insertedPos)
             std::get<1>(*(step)) += charge;
 
           // resize the list stopping with the first timeStamp with cumulative charge above threshold
           if (std::get<1>(*step) > tdcForToAOnset[waferThickness - 1] &&
               std::get<2>(*step) != std::get<2>(PhitRefs_bx0[id].back())) {
             PhitRefs_bx0[id].resize(
                 std::upper_bound(PhitRefs_bx0[id].begin(),
                                  PhitRefs_bx0[id].end(),
                                  hit_timeStamp(charge, 0.f, std::get<2>(*step)),
                                  [](const auto& i, const auto& j) { return std::get<2>(i) < std::get<2>(j); }) -
                 PhitRefs_bx0[id].begin());
             for (auto stepEnd = step + 1; stepEnd != PhitRefs_bx0[id].end(); ++stepEnd)
               std::get<1>(*stepEnd) += charge;
             break;
           }
         }
       }
     }
   }
 
   for (const auto& hitCollection : PhitRefs_bx0) {
     const uint32_t detectorId = hitCollection.first;
     auto simHitIt = pusimHitAccumulator_->emplace(detectorId, HGCCellHitInfo()).first;
 
     for (const auto& hit_timestamp : PhitRefs_bx0[detectorId]) {
       (simHitIt->second).PUhit_info[1][thisBx_].push_back(std::get<2>(hit_timestamp));
       (simHitIt->second).PUhit_info[0][thisBx_].push_back(std::get<0>(hit_timestamp));
     }
   }
 
   if (nchits == 0) {
     HGCPUSimHitDataAccumulator::iterator simHitIt = pusimHitAccumulator_->emplace(0, HGCCellHitInfo()).first;
     (simHitIt->second).PUhit_info[1][9].push_back(0.0);
     (simHitIt->second).PUhit_info[0][9].push_back(0.0);
   }
   hitRefs.clear();
   PhitRefs_bx0.clear();
 }

◆ accumulate_forPreMix() [4/4]

void HGCDigitizer::accumulate_forPreMix	(	const PHGCSimAccumulator &	simAccumulator,
		const bool	minbiasFlag
	)

Definition at line 687 of file HGCDigitizer.cc.

References gHGCal_, hitOrder_monitor, hitRefs_bx0, premixStage1MaxCharge_, premixStage1MinCharge_, pusimHitAccumulator_, simHitAccumulator_, theDigitizer_, and thisBx_.

                                                                                                         {
   //configuration to apply for the computation of time-of-flight
   auto weightToAbyEnergy = theDigitizer_->toaModeByEnergy();
   auto tdcForToAOnset = theDigitizer_->tdcForToAOnset();
 
   if (nullptr != gHGCal_) {
     loadSimHitAccumulator_forPreMix(*simHitAccumulator_,
                                     *pusimHitAccumulator_,
                                     gHGCal_,
                                     hitRefs_bx0,
                                     simAccumulator,
                                     premixStage1MinCharge_,
                                     premixStage1MaxCharge_,
                                     !weightToAbyEnergy,
                                     tdcForToAOnset,
                                     minbiasFlag,
                                     hitOrder_monitor,
                                     thisBx_);
   }
 }

◆ checkPosition()

void HGCDigitizer::checkPosition ( const HGCalDigiCollection * digis ) const

private

Definition at line 737 of file HGCDigitizer.cc.

References funct::abs(), HGCalTopology::dddConstants(), TauDecayModes::dec, DetId::Forward, HGCalGeometry::getPosition(), gHGCal_, HFNose, DetId::HGCalEE, DetId::HGCalHSc, DetId::HGCalHSi, convertSQLiteXML::ok, PV3DBase< T, PVType, FrameType >::perp(), alignCSCRings::r, HGCalDDDConstants::rangeR(), HGCalDDDConstants::rangeZ(), AlCaHLTBitMon_QueryRunRegistry::string, HGCalGeometry::topology(), heppy_batch::val, HGCalTopology::valid(), z, PV3DBase< T, PVType, FrameType >::z(), and TkClusParameters_cff::zrange.

Referenced by finalizeEvent().

                                                                        {
   const double tol(0.5);
   if (nullptr != gHGCal_) {
     for (const auto& digi : *(digis)) {
       const DetId& id = digi.id();
       const GlobalPoint& global = gHGCal_->getPosition(id);
       double r = global.perp();
       double z = std::abs(global.z());
       std::pair<double, double> zrange = gHGCal_->topology().dddConstants().rangeZ(true);
       std::pair<double, double> rrange = gHGCal_->topology().dddConstants().rangeR(z, true);
       bool ok = ((r >= rrange.first) && (r <= rrange.second) && (z >= zrange.first) && (z <= zrange.second));
       std::string ck = (((r < rrange.first - tol) || (r > rrange.second + tol) || (z < zrange.first - tol) ||
                          (z > zrange.second + tol))
                             ? "***** ERROR *****"
                             : "");
       bool val = gHGCal_->topology().valid(id);
       if ((!ok) || (!val)) {
         if (id.det() == DetId::HGCalEE || id.det() == DetId::HGCalHSi) {
           edm::LogVerbatim("HGCDigitizer") << "Check " << HGCSiliconDetId(id) << " " << global << " R " << r << ":"
                                            << rrange.first << ":" << rrange.second << " Z " << z << ":" << zrange.first
                                            << ":" << zrange.second << " Flag " << ok << ":" << val << " " << ck;
         } else if (id.det() == DetId::HGCalHSc) {
           edm::LogVerbatim("HGCDigitizer") << "Check " << HGCScintillatorDetId(id) << " " << global << " R " << r << ":"
                                            << rrange.first << ":" << rrange.second << " Z " << z << ":" << zrange.first
                                            << ":" << zrange.second << " Flag " << ok << ":" << val << " " << ck;
         } else if ((id.det() == DetId::Forward) && (id.subdetId() == static_cast<int>(HFNose))) {
           edm::LogVerbatim("HGCDigitizer") << "Check " << HFNoseDetId(id) << " " << global << " R " << r << ":"
                                            << rrange.first << ":" << rrange.second << " Z " << z << ":" << zrange.first
                                            << ":" << zrange.second << " Flag " << ok << ":" << val << " " << ck;
         } else {
           edm::LogVerbatim("HGCDigitizer")
               << "Check " << std::hex << id.rawId() << std::dec << " " << id.det() << ":" << id.subdetId() << " "
               << global << " R " << r << ":" << rrange.first << ":" << rrange.second << " Z " << z << ":"
               << zrange.first << ":" << zrange.second << " Flag " << ok << ":" << val << " " << ck;
         }
       }
     }
   }
 }

◆ digiCollection()

std::string HGCDigitizer::digiCollection ( )

inline

Definition at line 76 of file HGCDigitizer.h.

References digiCollection_.

Referenced by finalizeEvent(), HGCDigiProducer::HGCDigiProducer(), and PreMixingHGCalWorker::PreMixingHGCalWorker().

76 { return digiCollection_; }

HGCDigitizer::digiCollection_

const std::string digiCollection_

Definition: HGCDigitizer.h:84

◆ finalizeEvent()

void HGCDigitizer::finalizeEvent	(	edm::Event &	e,
		edm::EventSetup const &	c,
		CLHEP::HepRandomEngine *	hre
	)

Definition at line 295 of file HGCDigitizer.cc.

References averageOccupancies_, checkPosition(), digiCollection(), digitizationType_, MillePedeFileConverter_cfg::e, getType(), gHGCal_, hitOrder_monitor, hitRefs_bx0, heavyIonCSV_trainingSettings::idx, eostools::move(), nEvents_, PhitRefs_bx0, premixStage1_, premixStage1MaxCharge_, premixStage1MinCharge_, pusimHitAccumulator_, simHitAccumulator_, theDigitizer_, and validIds_.

Referenced by HGCDigiProducer::finalizeEvent(), and PreMixingHGCalWorker::put().

                                                                                                 {
   hitRefs_bx0.clear();
   PhitRefs_bx0.clear();
   hitOrder_monitor.clear();
 
   const CaloSubdetectorGeometry* theGeom = static_cast<const CaloSubdetectorGeometry*>(gHGCal_);
 
   ++nEvents_;
 
   unsigned idx = getType();
   // release memory for unfilled parts of hash table
   if (validIds_.size() * averageOccupancies_[idx] > simHitAccumulator_->size()) {
     simHitAccumulator_->reserve(simHitAccumulator_->size());
     pusimHitAccumulator_->reserve(simHitAccumulator_->size());
   }
   //update occupancy guess
   const double thisOcc = simHitAccumulator_->size() / ((double)validIds_.size());
   averageOccupancies_[idx] = (averageOccupancies_[idx] * (nEvents_ - 1) + thisOcc) / nEvents_;
 
   if (premixStage1_) {
     auto simRecord = std::make_unique<PHGCSimAccumulator>();
 
     if (!pusimHitAccumulator_->empty()) {
       saveSimHitAccumulator_forPreMix(
           *simRecord, *pusimHitAccumulator_, validIds_, premixStage1MinCharge_, premixStage1MaxCharge_);
     }
 
     e.put(std::move(simRecord), digiCollection());
 
   } else {
     auto digiResult = std::make_unique<HGCalDigiCollection>();
     theDigitizer_->run(digiResult, *simHitAccumulator_, theGeom, validIds_, digitizationType_, hre);
     edm::LogVerbatim("HGCDigitizer") << "HGCDigitizer:: finalize event - produced " << digiResult->size()
                                      << " hits in det/subdet " << theDigitizer_->det() << "/"
                                      << theDigitizer_->subdet();
 #ifdef EDM_ML_DEBUG
     checkPosition(&(*digiResult));
 #endif
     e.put(std::move(digiResult), digiCollection());
   }
 
   hgc::HGCSimHitDataAccumulator().swap(*simHitAccumulator_);
   hgc::HGCPUSimHitDataAccumulator().swap(*pusimHitAccumulator_);
 }

◆ getType()

uint32_t HGCDigitizer::getType ( void ) const

private

Definition at line 716 of file HGCDigitizer.cc.

References DetId::Forward, DetId::HGCalEE, DetId::HGCalHSc, DetId::HGCalHSi, heavyIonCSV_trainingSettings::idx, SiStripPI::max, and theDigitizer_.

Referenced by finalizeEvent(), and initializeEvent().

                                      {
   uint32_t idx = std::numeric_limits<unsigned>::max();
   switch (theDigitizer_->det()) {
     case DetId::HGCalEE:
       idx = 0;
       break;
     case DetId::HGCalHSi:
       idx = 1;
       break;
     case DetId::HGCalHSc:
       idx = 2;
       break;
     case DetId::Forward:
       idx = 3;
       break;
     default:
       break;
   }
   return idx;
 }

◆ initializeEvent()

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

actions at the start/end of event

Definition at line 265 of file HGCDigitizer.cc.

References averageOccupancies_, edm::ESWatcher< T >::check(), Exception, relativeConstraints::geom, geomToken_, geomWatcher_, edm::EventSetup::getData(), getType(), gHGCal_, hitCollection_, heavyIonCSV_trainingSettings::idx, pusimHitAccumulator_, simHitAccumulator_, edm::swap(), theDigitizer_, validIds_, and verbosity_.

Referenced by PreMixingHGCalWorker::initializeEvent(), and HGCDigiProducer::initializeEvent().

                                                                              {
   if (geomWatcher_.check(es)) {
     std::unordered_set<DetId>().swap(validIds_);
 
     //get geometry
     CaloGeometry const& geom = es.getData(geomToken_);
 
     gHGCal_ =
         dynamic_cast<const HGCalGeometry*>(geom.getSubdetectorGeometry(theDigitizer_->det(), theDigitizer_->subdet()));
 
     int nadded(0);
     //valid ID lists
     if (nullptr != gHGCal_) {
       getValidDetIds(gHGCal_, validIds_);
     } else {
       throw cms::Exception("BadConfiguration") << "HGCDigitizer is not producing EE, FH, or BH digis!";
     }
 
     if (verbosity_ > 0)
       edm::LogInfo("HGCDigitizer") << "Added " << nadded << ":" << validIds_.size() << " detIds without "
                                    << hitCollection_ << " in first event processed" << std::endl;
   }
 
   // reserve memory for a full detector
   unsigned idx = getType();
   simHitAccumulator_->reserve(averageOccupancies_[idx] * validIds_.size());
   pusimHitAccumulator_->reserve(averageOccupancies_[idx] * validIds_.size());
 }

◆ orderByDetIdThenTime()

static bool HGCDigitizer::orderByDetIdThenTime	(	const HGCCaloHitTuple_t &	a,
		const HGCCaloHitTuple_t &	b
	)

inlinestatic

Definition at line 36 of file HGCDigitizer.h.

References a, and b.

Referenced by accumulate(), and accumulate_forPreMix().

                                                                                            {
     unsigned int detId_a(std::get<1>(a)), detId_b(std::get<1>(b));
 
     if (detId_a < detId_b)
       return true;
     if (detId_a > detId_b)
       return false;
 
     double time_a(std::get<2>(a)), time_b(std::get<2>(b));
     if (time_a < time_b)
       return true;
 
     return false;
   }

◆ resetPUSimHitDataAccumulator()

void HGCDigitizer::resetPUSimHitDataAccumulator ( )

private

◆ resetSimHitDataAccumulator()

void HGCDigitizer::resetSimHitDataAccumulator ( )

private

Definition at line 709 of file HGCDigitizer.cc.

References simHitAccumulator_.

                                               {
   for (HGCSimHitDataAccumulator::iterator it = simHitAccumulator_->begin(); it != simHitAccumulator_->end(); it++) {
     it->second.hit_info[0].fill(0.);
     it->second.hit_info[1].fill(0.);
   }
 }

Member Data Documentation

◆ averageOccupancies_

std::array<double, 4> HGCDigitizer::averageOccupancies_

private

Definition at line 125 of file HGCDigitizer.h.

Referenced by finalizeEvent(), and initializeEvent().

◆ bxTime_

const double HGCDigitizer::bxTime_

private

Definition at line 99 of file HGCDigitizer.h.

Referenced by accumulate(), and accumulate_forPreMix().

◆ cce_

std::vector<float> HGCDigitizer::cce_

private

Definition at line 131 of file HGCDigitizer.h.

Referenced by HGCDigitizer().

◆ digiCollection_

const std::string HGCDigitizer::digiCollection_

private

Definition at line 84 of file HGCDigitizer.h.

Referenced by digiCollection().

◆ digitizationType_

const int HGCDigitizer::digitizationType_

private

Definition at line 87 of file HGCDigitizer.h.

Referenced by finalizeEvent().

◆ ev_per_eh_pair_

double HGCDigitizer::ev_per_eh_pair_

private

Definition at line 100 of file HGCDigitizer.h.

◆ geomToken_

const edm::ESGetToken<CaloGeometry, CaloGeometryRecord> HGCDigitizer::geomToken_

private

Definition at line 113 of file HGCDigitizer.h.

Referenced by initializeEvent().

◆ geomWatcher_

edm::ESWatcher<CaloGeometryRecord> HGCDigitizer::geomWatcher_

private

Definition at line 114 of file HGCDigitizer.h.

Referenced by initializeEvent().

◆ gHGCal_

const HGCalGeometry* HGCDigitizer::gHGCal_ = nullptr

private

Definition at line 116 of file HGCDigitizer.h.

Referenced by accumulate(), accumulate_forPreMix(), checkPosition(), finalizeEvent(), and initializeEvent().

◆ hitCollection_

const std::string HGCDigitizer::hitCollection_

private

Definition at line 102 of file HGCDigitizer.h.

Referenced by accumulate(), accumulate_forPreMix(), and initializeEvent().

◆ hitOrder_monitor

std::unordered_map<uint32_t, bool> HGCDigitizer::hitOrder_monitor

private

Definition at line 134 of file HGCDigitizer.h.

Referenced by accumulate_forPreMix(), and finalizeEvent().

◆ hitRefs_bx0

std::unordered_map<uint32_t, std::vector<std::pair<float, float> > > HGCDigitizer::hitRefs_bx0

private

Definition at line 132 of file HGCDigitizer.h.

Referenced by accumulate(), accumulate_forPreMix(), and finalizeEvent().

◆ hitsProducer_

const std::string HGCDigitizer::hitsProducer_

private

Definition at line 101 of file HGCDigitizer.h.

Referenced by accumulate(), and accumulate_forPreMix().

◆ hitToken_

const edm::EDGetTokenT<std::vector<PCaloHit> > HGCDigitizer::hitToken_

private

Definition at line 103 of file HGCDigitizer.h.

Referenced by accumulate(), and accumulate_forPreMix().

◆ maxBx_

const unsigned int HGCDigitizer::maxBx_ = 14

staticprivate

Definition at line 129 of file HGCDigitizer.h.

Referenced by accumulate(), and accumulate_forPreMix().

◆ maxSimHitsAccTime_

const int HGCDigitizer::maxSimHitsAccTime_

private

Definition at line 98 of file HGCDigitizer.h.

◆ nEvents_

uint32_t HGCDigitizer::nEvents_

private

Definition at line 126 of file HGCDigitizer.h.

Referenced by finalizeEvent().

◆ PhitRefs_bx0

std::unordered_map<uint32_t, std::vector<std::tuple<float, float, float> > > HGCDigitizer::PhitRefs_bx0

private

Definition at line 133 of file HGCDigitizer.h.

Referenced by accumulate_forPreMix(), and finalizeEvent().

◆ premixStage1_

const bool HGCDigitizer::premixStage1_

private

Definition at line 90 of file HGCDigitizer.h.

Referenced by finalizeEvent().

◆ premixStage1MaxCharge_

const double HGCDigitizer::premixStage1MaxCharge_

private

Definition at line 95 of file HGCDigitizer.h.

Referenced by accumulate_forPreMix(), and finalizeEvent().

◆ premixStage1MinCharge_

const double HGCDigitizer::premixStage1MinCharge_

private

Definition at line 93 of file HGCDigitizer.h.

Referenced by accumulate_forPreMix(), and finalizeEvent().

◆ pusimHitAccumulator_

std::unique_ptr<hgc::HGCPUSimHitDataAccumulator> HGCDigitizer::pusimHitAccumulator_

private

Definition at line 82 of file HGCDigitizer.h.

Referenced by accumulate_forPreMix(), finalizeEvent(), and initializeEvent().

◆ simHitAccumulator_

std::unique_ptr<hgc::HGCSimHitDataAccumulator> HGCDigitizer::simHitAccumulator_

private

Definition at line 81 of file HGCDigitizer.h.

Referenced by accumulate(), accumulate_forPreMix(), finalizeEvent(), initializeEvent(), and resetSimHitDataAccumulator().

◆ theDigitizer_

std::unique_ptr<HGCDigitizerBase> HGCDigitizer::theDigitizer_

private

Definition at line 110 of file HGCDigitizer.h.

Referenced by accumulate(), accumulate_forPreMix(), finalizeEvent(), getType(), HGCDigitizer(), and initializeEvent().

◆ thisBx_

const unsigned int HGCDigitizer::thisBx_ = 9

staticprivate

Definition at line 130 of file HGCDigitizer.h.

Referenced by accumulate(), and accumulate_forPreMix().

◆ tofDelay_

const float HGCDigitizer::tofDelay_

private

Definition at line 122 of file HGCDigitizer.h.

Referenced by accumulate(), and accumulate_forPreMix().

◆ validIds_

std::unordered_set<DetId> HGCDigitizer::validIds_

private

Definition at line 115 of file HGCDigitizer.h.

Referenced by accumulate(), accumulate_forPreMix(), finalizeEvent(), and initializeEvent().

◆ verbosity_

const uint32_t HGCDigitizer::verbosity_

private

Definition at line 119 of file HGCDigitizer.h.

Referenced by accumulate(), and initializeEvent().

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Member Typedef Documentation

◆ HGCCaloHitTuple_t

Constructor & Destructor Documentation

◆ HGCDigitizer()

◆ ~HGCDigitizer()

Member Function Documentation

◆ accumulate() [1/3]

◆ accumulate() [2/3]

◆ accumulate() [3/3]

◆ accumulate_forPreMix() [1/4]

◆ accumulate_forPreMix() [2/4]

◆ accumulate_forPreMix() [3/4]

◆ accumulate_forPreMix() [4/4]

◆ checkPosition()

◆ digiCollection()

◆ finalizeEvent()

◆ getType()

◆ initializeEvent()

◆ orderByDetIdThenTime()

◆ resetPUSimHitDataAccumulator()

◆ resetSimHitDataAccumulator()

Member Data Documentation

◆ averageOccupancies_

◆ bxTime_

◆ cce_

◆ digiCollection_

◆ digitizationType_

◆ ev_per_eh_pair_

◆ geomToken_

◆ geomWatcher_

◆ gHGCal_

◆ hitCollection_

◆ hitOrder_monitor

◆ hitRefs_bx0

◆ hitsProducer_

◆ hitToken_

◆ maxBx_

◆ maxSimHitsAccTime_

◆ nEvents_

◆ PhitRefs_bx0

◆ premixStage1_

◆ premixStage1MaxCharge_

◆ premixStage1MinCharge_

◆ pusimHitAccumulator_

◆ simHitAccumulator_

◆ theDigitizer_

◆ thisBx_

◆ tofDelay_

◆ validIds_

◆ verbosity_