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

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_

double	bxTime_

std::vector< float >	cce_

std::string	digiCollection_

int	digitizationType_

double	ev_per_eh_pair_

const edm::ESGetToken < CaloGeometry, CaloGeometryRecord >	geomToken_

edm::ESWatcher < CaloGeometryRecord >	geomWatcher_

const HGCalGeometry *	gHGCal_ = nullptr

std::string	hitCollection_

std::unordered_map< uint32_t, bool >	hitOrder_monitor

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

int	maxSimHitsAccTime_

uint32_t	nEvents_

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

bool	premixStage1_

double	premixStage1MaxCharge_

double	premixStage1MinCharge_

std::unique_ptr < hgc::HGCPUSimHitDataAccumulator >	pusimHitAccumulator_

float	refSpeed_

std::unique_ptr < hgc::HGCSimHitDataAccumulator >	simHitAccumulator_

std::unique_ptr< HGCDigitizerBase >	theDigitizer_

float	tofDelay_

std::unordered_set< DetId >	validIds_

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

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

Definition at line 35 of file HGCDigitizer.h.

Constructor & Destructor Documentation

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

Definition at line 231 of file HGCDigitizer.cc.

References bxTime_, cce_, edm::ConsumesCollector::consumes(), digiCollection_, digitizationType_, get, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), hitCollection_, HLT_FULL_cff::InputTag, maxSimHitsAccTime_, premixStage1_, premixStage1MaxCharge_, premixStage1MinCharge_, AlCaHLTBitMon_QueryRunRegistry::string, edm::swap(), groupFilesInBlocks::temp, theDigitizer_, tofDelay_, and verbosity_.

     : simHitAccumulator_(new HGCSimHitDataAccumulator()),
       pusimHitAccumulator_(new HGCPUSimHitDataAccumulator()),
       geomToken_(iC.esConsumes()),
       refSpeed_(0.1 * CLHEP::c_light),  //[CLHEP::c_light]=mm/ns convert to cm/ns
       averageOccupancies_(occupancyGuesses),
       nEvents_(1) {
   //configure from cfg
 
   hitCollection_ = ps.getParameter<std::string>("hitCollection");
   digiCollection_ = ps.getParameter<std::string>("digiCollection");
   maxSimHitsAccTime_ = ps.getParameter<uint32_t>("maxSimHitsAccTime");
   bxTime_ = ps.getParameter<double>("bxTime");
   digitizationType_ = ps.getParameter<uint32_t>("digitizationType");
   verbosity_ = ps.getUntrackedParameter<uint32_t>("verbosity", 0);
   tofDelay_ = ps.getParameter<double>("tofDelay");
   premixStage1_ = ps.getParameter<bool>("premixStage1");
   premixStage1MinCharge_ = ps.getParameter<double>("premixStage1MinCharge");
   premixStage1MaxCharge_ = ps.getParameter<double>("premixStage1MaxCharge");
   iC.consumes<std::vector<PCaloHit>>(edm::InputTag("g4SimHits", hitCollection_));
   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 ( )

inline

Definition at line 32 of file HGCDigitizer.h.

32 {}

Member Function Documentation

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

handle SimHit accumulation

Definition at line 365 of file HGCDigitizer.cc.

References Exception, edm::Event::getByLabel(), gHGCal_, hitCollection_, and edm::HandleBase::isValid().

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

                                                                                                            {
   //get inputs
   edm::Handle<edm::PCaloHitContainer> hits;
   e.getByLabel(edm::InputTag("g4SimHits", hitCollection_), hits);
   if (!hits.isValid()) {
     edm::LogError("HGCDigitizer") << " @ accumulate : can't find " << hitCollection_ << " collection of g4SimHits";
     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!";
   }
 }

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

Definition at line 402 of file HGCDigitizer.cc.

References accumulate(), PileUpEventPrincipal::bunchCrossing(), Exception, PileUpEventPrincipal::getByLabel(), gHGCal_, hitCollection_, and edm::HandleBase::isValid().

                                                          {
   //get inputs
   edm::Handle<edm::PCaloHitContainer> hits;
   e.getByLabel(edm::InputTag("g4SimHits", hitCollection_), hits);
 
   if (!hits.isValid()) {
     edm::LogError("HGCDigitizer") << " @ accumulate : can't find " << hitCollection_ << " collection of g4SimHits";
     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!";
   }
 }

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

Definition at line 545 of file HGCDigitizer.cc.

References SplitLinear::begin, bxTime_, RecoTauCleanerPlugins::charge, TauDecayModes::dec, relativeConstraints::empty, dataset::end, validate-o2o-wbm::f, first, hitRefs_bx0, mps_fire::i, gpuClustering::id, dqmiolumiharvest::j, hgcalTriggerNtuples_cfi::keV2fC, maxBx_, orderByDetIdThenTime(), refSpeed_, edm::second(), simHitAccumulator_, findQualityFiles::size, theDigitizer_, thisBx_, tofDelay_, cuda_std::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;
 
     //distance to the center of the detector
     const float dist2center(getPositionDistance(geom, id));
 
     //hit time: [time()]=ns  [centerDist]=cm [refSpeed_]=cm/ns + delay by 1ns
     //accumulate in 15 buckets of 25ns (9 pre-samples, 1 in-time, 5 post-samples)
     const float tof = toa - dist2center / refSpeed_ + 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();
 }

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

Definition at line 343 of file HGCDigitizer.cc.

References Exception, edm::Event::getByLabel(), gHGCal_, hitCollection_, and edm::HandleBase::isValid().

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

                                                                    {
   //get inputs
 
   edm::Handle<edm::PCaloHitContainer> hits;
   e.getByLabel(edm::InputTag("g4SimHits", hitCollection_), hits);
   if (!hits.isValid()) {
     edm::LogError("HGCDigitizer") << " @ accumulate_minbias : can't find " << hitCollection_
                                   << " collection of g4SimHits";
     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!";
   }
 }

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

Definition at line 383 of file HGCDigitizer.cc.

References accumulate_forPreMix(), PileUpEventPrincipal::bunchCrossing(), Exception, PileUpEventPrincipal::getByLabel(), gHGCal_, hitCollection_, and edm::HandleBase::isValid().

                                                                    {
   edm::Handle<edm::PCaloHitContainer> hits;
   e.getByLabel(edm::InputTag("g4SimHits", hitCollection_), hits);
 
   if (!hits.isValid()) {
     edm::LogError("HGCDigitizer") << " @ accumulate : can't find " << hitCollection_ << " collection of g4SimHits";
     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!";
   }
 }

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

Definition at line 423 of file HGCDigitizer.cc.

References SplitLinear::begin, bxTime_, RecoTauCleanerPlugins::charge, relativeConstraints::empty, dataset::end, validate-o2o-wbm::f, reco_application_2006_simpleTBanalysis_cfg::hitCollection, mps_fire::i, gpuClustering::id, dqmiolumiharvest::j, hgcalTriggerNtuples_cfi::keV2fC, maxBx_, orderByDetIdThenTime(), PhitRefs_bx0, push_back(), pusimHitAccumulator_, refSpeed_, theDigitizer_, thisBx_, tofDelay_, cuda_std::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 dist2center(getPositionDistance(geom, id));
     const float tof = toa - dist2center / refSpeed_ + 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();
 }

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

Definition at line 692 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_);
   }
 }

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

private

Definition at line 742 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(), hgcalPerformanceValidation::val, HGCalTopology::valid(), z, and PV3DBase< T, PVType, FrameType >::z().

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

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_

std::string digiCollection_

Definition: HGCDigitizer.h:80

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

Definition at line 299 of file HGCDigitizer.cc.

References averageOccupancies_, checkPosition(), digiCollection(), digitizationType_, getType(), gHGCal_, hitOrder_monitor, hitRefs_bx0, eostools::move(), nEvents_, PhitRefs_bx0, premixStage1_, premixStage1MaxCharge_, premixStage1MinCharge_, pusimHitAccumulator_, edm::Event::put(), 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_);
 }

uint32_t HGCDigitizer::getType ( void ) const

private

Definition at line 721 of file HGCDigitizer.cc.

References DetId::Forward, DetId::HGCalEE, DetId::HGCalHSc, DetId::HGCalHSi, 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;
 }

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

actions at the start/end of event

Definition at line 269 of file HGCDigitizer.cc.

References averageOccupancies_, edm::ESWatcher< T >::check(), Exception, relativeConstraints::geom, geomToken_, geomWatcher_, edm::EventSetup::getData(), CaloGeometry::getSubdetectorGeometry(), getType(), gHGCal_, hitCollection_, 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());
 }

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

inlinestatic

Definition at line 36 of file HGCDigitizer.h.

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

void HGCDigitizer::resetPUSimHitDataAccumulator ( )

private

void HGCDigitizer::resetSimHitDataAccumulator ( )

private

Definition at line 714 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.);
   }
 }