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

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

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

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

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

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

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

void	beginRun (const edm::EventSetup &es)
	actions at the start/end of run More...

std::string	digiCollection ()

void	endRun ()

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

int	geometryType ()

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

bool	producesEEDigis ()

bool	producesHEbackDigis ()

bool	producesHEfrontDigis ()

bool	producesHFNoseDigis ()

	~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

bool	getWeight (std::array< float, 3 > &tdcForToAOnset, float &keV2fC) 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_

int	geometryType_

const HcalGeometry *	gHcal_

const HGCalGeometry *	gHGCal_

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_

DetId::Detector	myDet_

ForwardSubdetector	mySubDet_

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< HFNoseDigitizer >	theHFNoseDigitizer_

std::unique_ptr< HGCEEDigitizer >	theHGCEEDigitizer_

std::unique_ptr< HGCHEbackDigitizer >	theHGCHEbackDigitizer_

std::unique_ptr< HGCHEfrontDigitizer >	theHGCHEfrontDigitizer_

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 30 of file HGCDigitizer.h.

Member Typedef Documentation

◆ HGCCaloHitTuple_t

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

Definition at line 36 of file HGCDigitizer.h.

Constructor & Destructor Documentation

◆ HGCDigitizer()

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

Definition at line 264 of file HGCDigitizer.cc.

     : simHitAccumulator_(new HGCSimHitDataAccumulator()),
       pusimHitAccumulator_(new HGCPUSimHitDataAccumulator()),
       myDet_(DetId::Forward),
       mySubDet_(ForwardSubdetector::ForwardEmpty),
       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");
   geometryType_ = ps.getParameter<uint32_t>("geometryType");
   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");
   std::unordered_set<DetId>().swap(validIds_);
   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_);
   }
  
   if (hitCollection_.find("HitsEE") != std::string::npos) {
     if (geometryType_ == 0) {
       mySubDet_ = ForwardSubdetector::HGCEE;
     } else {
       myDet_ = DetId::HGCalEE;
     }
     theHGCEEDigitizer_ = std::make_unique<HGCEEDigitizer>(ps);
   }
   if (hitCollection_.find("HitsHEfront") != std::string::npos) {
     if (geometryType_ == 0) {
       mySubDet_ = ForwardSubdetector::HGCHEF;
     } else {
       myDet_ = DetId::HGCalHSi;
     }
     theHGCHEfrontDigitizer_ = std::make_unique<HGCHEfrontDigitizer>(ps);
   }
   if (hitCollection_.find("HcalHits") != std::string::npos and geometryType_ == 0) {
     mySubDet_ = ForwardSubdetector::HGCHEB;
     theHGCHEbackDigitizer_ = std::make_unique<HGCHEbackDigitizer>(ps);
   }
   if (hitCollection_.find("HitsHEback") != std::string::npos and geometryType_ == 1) {
     myDet_ = DetId::HGCalHSc;
     theHGCHEbackDigitizer_ = std::make_unique<HGCHEbackDigitizer>(ps);
   }
   if (hitCollection_.find("HFNoseHits") != std::string::npos) {
     mySubDet_ = ForwardSubdetector::HFNose;
     myDet_ = DetId::Forward;
     theHFNoseDigitizer_ = std::make_unique<HFNoseDigitizer>(ps);
   }
 }

References bxTime_, cce_, edm::ConsumesCollector::consumes(), digiCollection_, digitizationType_, DetId::Forward, geometryType_, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), HFNose, DetId::HGCalEE, DetId::HGCalHSc, DetId::HGCalHSi, HGCEE, HGCHEB, HGCHEF, hitCollection_, HLT_FULL_cff::InputTag, maxSimHitsAccTime_, myDet_, mySubDet_, premixStage1_, premixStage1MaxCharge_, premixStage1MinCharge_, AlCaHLTBitMon_QueryRunRegistry::string, groupFilesInBlocks::temp, theHFNoseDigitizer_, theHGCEEDigitizer_, theHGCHEbackDigitizer_, theHGCHEfrontDigitizer_, tofDelay_, validIds_, and verbosity_.

◆ ~HGCDigitizer()

HGCDigitizer::~HGCDigitizer ( )

inline

Definition at line 33 of file HGCDigitizer.h.

33 {}

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 442 of file HGCDigitizer.cc.

                                                                                                            {
   //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 if (nullptr != gHcal_) {
     accumulate(hits, 0, gHcal_, hre);
   } else {
     throw cms::Exception("BadConfiguration") << "HGCDigitizer is not producing EE, FH, or BH digis!";
   }
 }

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

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

◆ accumulate() [2/3]

template<typename GEOM >

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

Definition at line 632 of file HGCDigitizer.cc.

                                                          {
   if (nullptr == geom)
     return;
  
   //configuration to apply for the computation of time-of-flight
   std::array<float, 3> tdcForToAOnset{{0.f, 0.f, 0.f}};
   float keV2fC(0.f);
   bool weightToAbyEnergy = getWeight(tdcForToAOnset, 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) {
       if (producesEEDigis())
         edm::LogVerbatim("HGCDigitizer") << "HGCDigitizer::i/p " << std::hex << the_hit.id() << " o/p " << id.rawId()
                                          << std::dec;
       else
         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();
 }

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

◆ accumulate() [3/3]

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

Definition at line 483 of file HGCDigitizer.cc.

                                                          {
   //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 if (nullptr != gHcal_) {
     accumulate(hits, e.bunchCrossing(), gHcal_, hre);
   } else {
     throw cms::Exception("BadConfiguration") << "HGCDigitizer is not producing EE, FH, or BH digis!";
   }
 }

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

◆ accumulate_forPreMix() [1/4]

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

Definition at line 783 of file HGCDigitizer.cc.

                                                                                                         {
   //configuration to apply for the computation of time-of-flight
   std::array<float, 3> tdcForToAOnset{{0.f, 0.f, 0.f}};
   float keV2fC(0.f);
   bool weightToAbyEnergy = getWeight(tdcForToAOnset, keV2fC);
  
   if (nullptr != gHGCal_) {
     loadSimHitAccumulator_forPreMix(*simHitAccumulator_,
                                     *pusimHitAccumulator_,
                                     gHGCal_,
                                     hitRefs_bx0,
                                     simAccumulator,
                                     premixStage1MinCharge_,
                                     premixStage1MaxCharge_,
                                     !weightToAbyEnergy,
                                     tdcForToAOnset,
                                     minbiasFlag,
                                     hitOrder_monitor,
                                     thisBx_);
   } else if (nullptr != gHcal_) {
     loadSimHitAccumulator_forPreMix(*simHitAccumulator_,
                                     *pusimHitAccumulator_,
                                     gHcal_,
                                     hitRefs_bx0,
                                     simAccumulator,
                                     premixStage1MinCharge_,
                                     premixStage1MaxCharge_,
                                     !weightToAbyEnergy,
                                     tdcForToAOnset,
                                     minbiasFlag,
                                     hitOrder_monitor,
                                     thisBx_);
   }
 }

References f, getWeight(), gHcal_, gHGCal_, hitOrder_monitor, hitRefs_bx0, hgcalTriggerNtuples_cfi::keV2fC, premixStage1MaxCharge_, premixStage1MinCharge_, pusimHitAccumulator_, simHitAccumulator_, and thisBx_.

◆ accumulate_forPreMix() [2/4]

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

Definition at line 418 of file HGCDigitizer.cc.

                                                                    {
   //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 if (nullptr != gHcal_) {
     accumulate_forPreMix(hits, 0, gHcal_, hre);
   } else {
     throw cms::Exception("BadConfiguration") << "HGCDigitizer is not producing EE, FH, or BH digis!";
   }
 }

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

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

◆ accumulate_forPreMix() [3/4]

template<typename GEOM >

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

Definition at line 507 of file HGCDigitizer.cc.

                                                                    {
   if (nullptr == geom)
     return;
  
   float keV2fC(0.f);
   //configuration to apply for the computation of time-of-flight
   std::array<float, 3> tdcForToAOnset{{0.f, 0.f, 0.f}};
  
   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
         hitRec_itr 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); });
  
         hitRec_itr 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 (hitRec_itr 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();
 }

References bxTime_, ALCARECOTkAlJpsiMuMu_cff::charge, relativeConstraints::empty, mps_fire::end, f, relativeConstraints::geom, egammaRechitFilter_cfi::hitCollection, hfClusterShapes_cfi::hits, mps_fire::i, triggerObjects_cff::id, createfilelist::int, dqmiolumiharvest::j, hgcalTriggerNtuples_cfi::keV2fC, maxBx_, orderByDetIdThenTime(), PhitRefs_bx0, pusimHitAccumulator_, refSpeed_, thisBx_, tofDelay_, pfDeepBoostedJetPreprocessParams_cfi::upper_bound, and validIds_.

◆ accumulate_forPreMix() [4/4]

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

Definition at line 462 of file HGCDigitizer.cc.

                                                                    {
   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 if (nullptr != gHcal_) {
     accumulate_forPreMix(hits, e.bunchCrossing(), gHcal_, hre);
   } else {
     throw cms::Exception("BadConfiguration") << "HGCDigitizer is not producing EE, FH, or BH digis!";
   }
 }

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

◆ beginRun()

void HGCDigitizer::beginRun ( const edm::EventSetup & es )

actions at the start/end of run

Definition at line 819 of file HGCDigitizer.cc.

                                                    {
   //get geometry
   edm::ESHandle<CaloGeometry> geom;
   es.get<CaloGeometryRecord>().get(geom);
  
   gHGCal_ = nullptr;
   gHcal_ = nullptr;
  
   if (producesEEDigis())
     gHGCal_ = dynamic_cast<const HGCalGeometry*>(geom->getSubdetectorGeometry(myDet_, mySubDet_));
   if (producesHEfrontDigis())
     gHGCal_ = dynamic_cast<const HGCalGeometry*>(geom->getSubdetectorGeometry(myDet_, mySubDet_));
   if (producesHFNoseDigis())
     gHGCal_ = dynamic_cast<const HGCalGeometry*>(geom->getSubdetectorGeometry(myDet_, mySubDet_));
  
   if (producesHEbackDigis()) {
     if (geometryType_ == 0) {
       gHcal_ = dynamic_cast<const HcalGeometry*>(geom->getSubdetectorGeometry(DetId::Hcal, HcalEndcap));
     } else {
       gHGCal_ = dynamic_cast<const HGCalGeometry*>(geom->getSubdetectorGeometry(myDet_, mySubDet_));
     }
   }
  
   int nadded(0);
   //valid ID lists
   if (nullptr != gHGCal_) {
     getValidDetIds(gHGCal_, validIds_);
   } else if (nullptr != gHcal_) {
     getValidDetIds(gHcal_, 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;
 }

References Exception, relativeConstraints::geom, geometryType_, edm::EventSetup::get(), get, gHcal_, gHGCal_, DetId::Hcal, HcalEndcap, hitCollection_, myDet_, mySubDet_, producesEEDigis(), producesHEbackDigis(), producesHEfrontDigis(), producesHFNoseDigis(), validIds_, and verbosity_.

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

◆ checkPosition()

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

private

Definition at line 964 of file HGCDigitizer.cc.

                                                                        {
   const double tol(0.5);
   if (geometryType_ != 0 && 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;
         }
       }
     }
   }
 }

References funct::abs(), HGCalTopology::dddConstants(), TauDecayModes::dec, DetId::Forward, geometryType_, 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().

◆ digiCollection()

std::string HGCDigitizer::digiCollection ( )

inline

Definition at line 85 of file HGCDigitizer.h.

85 { return digiCollection_; }

References digiCollection_.

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

◆ endRun()

void HGCDigitizer::endRun ( )

Definition at line 858 of file HGCDigitizer.cc.

858 { std::unordered_set<DetId>().swap(validIds_); }

References validIds_.

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

◆ finalizeEvent()

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

Definition at line 340 of file HGCDigitizer.cc.

                                                                                                 {
   hitRefs_bx0.clear();
   PhitRefs_bx0.clear();
   hitOrder_monitor.clear();
  
   const CaloSubdetectorGeometry* theGeom = (nullptr == gHGCal_ ? static_cast<const CaloSubdetectorGeometry*>(gHcal_)
                                                                : 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 {
     if (producesEEDigis()) {
       auto digiResult = std::make_unique<HGCalDigiCollection>();
  
       theHGCEEDigitizer_->run(digiResult, *simHitAccumulator_, theGeom, validIds_, digitizationType_, hre);
  
       edm::LogVerbatim("HGCDigitizer") << "HGCDigitizer:: finalize event - produced " << digiResult->size()
                                        << " EE hits";
 #ifdef EDM_ML_DEBUG
       checkPosition(&(*digiResult));
 #endif
       e.put(std::move(digiResult), digiCollection());
     }
     if (producesHEfrontDigis()) {
       auto digiResult = std::make_unique<HGCalDigiCollection>();
       theHGCHEfrontDigitizer_->run(digiResult, *simHitAccumulator_, theGeom, validIds_, digitizationType_, hre);
       edm::LogVerbatim("HGCDigitizer") << "HGCDigitizer:: finalize event - produced " << digiResult->size()
                                        << " HE silicon hits";
 #ifdef EDM_ML_DEBUG
       checkPosition(&(*digiResult));
 #endif
       e.put(std::move(digiResult), digiCollection());
     }
     if (producesHEbackDigis()) {
       auto digiResult = std::make_unique<HGCalDigiCollection>();
       theHGCHEbackDigitizer_->run(digiResult, *simHitAccumulator_, theGeom, validIds_, digitizationType_, hre);
       edm::LogVerbatim("HGCDigitizer") << "HGCDigitizer:: finalize event - produced " << digiResult->size()
                                        << " HE Scintillator hits";
 #ifdef EDM_ML_DEBUG
       checkPosition(&(*digiResult));
 #endif
       e.put(std::move(digiResult), digiCollection());
     }
     if (producesHFNoseDigis()) {
       auto digiResult = std::make_unique<HGCalDigiCollection>();
       theHFNoseDigitizer_->run(digiResult, *simHitAccumulator_, theGeom, validIds_, digitizationType_, hre);
       edm::LogVerbatim("HGCDigitizer") << "HGCDigitizer:: finalize event - produced " << digiResult->size()
                                        << " HFNose hits";
 #ifdef EDM_ML_DEBUG
       checkPosition(&(*digiResult));
 #endif
       e.put(std::move(digiResult), digiCollection());
     }
   }
  
   hgc::HGCSimHitDataAccumulator().swap(*simHitAccumulator_);
   hgc::HGCPUSimHitDataAccumulator().swap(*pusimHitAccumulator_);
 }

References averageOccupancies_, checkPosition(), digiCollection(), digitizationType_, MillePedeFileConverter_cfg::e, getType(), gHcal_, gHGCal_, hitOrder_monitor, hitRefs_bx0, heavyIonCSV_trainingSettings::idx, eostools::move(), nEvents_, PhitRefs_bx0, premixStage1_, premixStage1MaxCharge_, premixStage1MinCharge_, producesEEDigis(), producesHEbackDigis(), producesHEfrontDigis(), producesHFNoseDigis(), pusimHitAccumulator_, simHitAccumulator_, theHFNoseDigitizer_, theHGCEEDigitizer_, theHGCHEbackDigitizer_, theHGCHEfrontDigitizer_, and validIds_.

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

◆ geometryType()

int HGCDigitizer::geometryType ( )

inline

Definition at line 86 of file HGCDigitizer.h.

86 { return geometryType_; }

References geometryType_.

◆ getType()

uint32_t HGCDigitizer::getType ( void ) const

private

Definition at line 868 of file HGCDigitizer.cc.

                                      {
   uint32_t idx = std::numeric_limits<unsigned>::max();
   if (geometryType_ == 0) {
     switch (mySubDet_) {
       case ForwardSubdetector::HGCEE:
         idx = 0;
         break;
       case ForwardSubdetector::HGCHEF:
         idx = 1;
         break;
       case ForwardSubdetector::HGCHEB:
         idx = 2;
         break;
       case ForwardSubdetector::HFNose:
         idx = 3;
         break;
       default:
         break;
     }
   } else {
     switch (myDet_) {
       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;
 }

References DetId::Forward, geometryType_, HFNose, DetId::HGCalEE, DetId::HGCalHSc, DetId::HGCalHSi, HGCEE, HGCHEB, HGCHEF, heavyIonCSV_trainingSettings::idx, SiStripPI::max, myDet_, and mySubDet_.

Referenced by finalizeEvent(), and initializeEvent().

◆ getWeight()

bool HGCDigitizer::getWeight	(	std::array< float, 3 > &	tdcForToAOnset,
		float &	keV2fC
	)		const

private

Definition at line 908 of file HGCDigitizer.cc.

                                                                                     {
   bool weightToAbyEnergy(false);
   if (geometryType_ == 0) {
     switch (mySubDet_) {
       case ForwardSubdetector::HGCEE:
         weightToAbyEnergy = theHGCEEDigitizer_->toaModeByEnergy();
         tdcForToAOnset = theHGCEEDigitizer_->tdcForToAOnset();
         keV2fC = theHGCEEDigitizer_->keV2fC();
         break;
       case ForwardSubdetector::HGCHEF:
         weightToAbyEnergy = theHGCHEfrontDigitizer_->toaModeByEnergy();
         tdcForToAOnset = theHGCHEfrontDigitizer_->tdcForToAOnset();
         keV2fC = theHGCHEfrontDigitizer_->keV2fC();
         break;
       case ForwardSubdetector::HGCHEB:
         weightToAbyEnergy = theHGCHEbackDigitizer_->toaModeByEnergy();
         tdcForToAOnset = theHGCHEbackDigitizer_->tdcForToAOnset();
         keV2fC = theHGCHEbackDigitizer_->keV2fC();
         break;
       case ForwardSubdetector::HFNose:
         weightToAbyEnergy = theHFNoseDigitizer_->toaModeByEnergy();
         tdcForToAOnset = theHFNoseDigitizer_->tdcForToAOnset();
         keV2fC = theHFNoseDigitizer_->keV2fC();
         break;
       default:
         break;
     }
   } else {
     switch (myDet_) {
       case DetId::HGCalEE:
         weightToAbyEnergy = theHGCEEDigitizer_->toaModeByEnergy();
         tdcForToAOnset = theHGCEEDigitizer_->tdcForToAOnset();
         keV2fC = theHGCEEDigitizer_->keV2fC();
         break;
       case DetId::HGCalHSi:
         weightToAbyEnergy = theHGCHEfrontDigitizer_->toaModeByEnergy();
         tdcForToAOnset = theHGCHEfrontDigitizer_->tdcForToAOnset();
         keV2fC = theHGCHEfrontDigitizer_->keV2fC();
         break;
       case DetId::HGCalHSc:
         weightToAbyEnergy = theHGCHEbackDigitizer_->toaModeByEnergy();
         tdcForToAOnset = theHGCHEbackDigitizer_->tdcForToAOnset();
         keV2fC = theHGCHEbackDigitizer_->keV2fC();
         break;
       case DetId::Forward:
         weightToAbyEnergy = theHFNoseDigitizer_->toaModeByEnergy();
         tdcForToAOnset = theHFNoseDigitizer_->tdcForToAOnset();
         keV2fC = theHFNoseDigitizer_->keV2fC();
         break;
       default:
         break;
     }
   }
   return weightToAbyEnergy;
 }

References DetId::Forward, geometryType_, HFNose, DetId::HGCalEE, DetId::HGCalHSc, DetId::HGCalHSi, HGCEE, HGCHEB, HGCHEF, hgcalTriggerNtuples_cfi::keV2fC, myDet_, mySubDet_, theHFNoseDigitizer_, theHGCEEDigitizer_, theHGCHEbackDigitizer_, and theHGCHEfrontDigitizer_.

Referenced by accumulate(), and accumulate_forPreMix().

◆ initializeEvent()

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

actions at the start/end of event

Definition at line 332 of file HGCDigitizer.cc.

                                                                              {
   // reserve memory for a full detector
   unsigned idx = getType();
   simHitAccumulator_->reserve(averageOccupancies_[idx] * validIds_.size());
   pusimHitAccumulator_->reserve(averageOccupancies_[idx] * validIds_.size());
 }

References averageOccupancies_, getType(), heavyIonCSV_trainingSettings::idx, pusimHitAccumulator_, simHitAccumulator_, and validIds_.

Referenced by HGCDigiProducer::initializeEvent().

◆ orderByDetIdThenTime()

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

inlinestatic

Definition at line 37 of file HGCDigitizer.h.

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

References a, and b.

Referenced by accumulate(), and accumulate_forPreMix().

◆ producesEEDigis()

bool HGCDigitizer::producesEEDigis ( )

inline

Definition at line 81 of file HGCDigitizer.h.

81 { return ((mySubDet_ == ForwardSubdetector::HGCEE) || (myDet_ == DetId::HGCalEE)); }

References DetId::HGCalEE, HGCEE, myDet_, and mySubDet_.

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

◆ producesHEbackDigis()

bool HGCDigitizer::producesHEbackDigis ( )

inline

Definition at line 83 of file HGCDigitizer.h.

83 { return ((mySubDet_ == ForwardSubdetector::HGCHEB) || (myDet_ == DetId::HGCalHSc)); }

References DetId::HGCalHSc, HGCHEB, myDet_, and mySubDet_.

Referenced by beginRun(), and finalizeEvent().

◆ producesHEfrontDigis()

bool HGCDigitizer::producesHEfrontDigis ( )

inline

Definition at line 82 of file HGCDigitizer.h.

82 { return ((mySubDet_ == ForwardSubdetector::HGCHEF) || (myDet_ == DetId::HGCalHSi)); }

References DetId::HGCalHSi, HGCHEF, myDet_, and mySubDet_.

Referenced by beginRun(), and finalizeEvent().

◆ producesHFNoseDigis()

bool HGCDigitizer::producesHFNoseDigis ( )

inline

Definition at line 84 of file HGCDigitizer.h.

84 { return ((mySubDet_ == ForwardSubdetector::HFNose) && (myDet_ == DetId::Forward)); }

References DetId::Forward, HFNose, myDet_, and mySubDet_.

Referenced by beginRun(), and finalizeEvent().

◆ resetPUSimHitDataAccumulator()

void HGCDigitizer::resetPUSimHitDataAccumulator ( )

private

◆ resetSimHitDataAccumulator()

void HGCDigitizer::resetSimHitDataAccumulator ( )

private

Definition at line 861 of file HGCDigitizer.cc.

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

References simHitAccumulator_.

Member Data Documentation

◆ averageOccupancies_

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

private

Definition at line 148 of file HGCDigitizer.h.

Referenced by finalizeEvent(), and initializeEvent().

◆ bxTime_

double HGCDigitizer::bxTime_

private

Definition at line 115 of file HGCDigitizer.h.

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

◆ cce_

std::vector<float> HGCDigitizer::cce_

private

Definition at line 154 of file HGCDigitizer.h.

Referenced by HGCDigitizer().

◆ digiCollection_

std::string HGCDigitizer::digiCollection_

private

Definition at line 97 of file HGCDigitizer.h.

Referenced by digiCollection(), and HGCDigitizer().

◆ digitizationType_

int HGCDigitizer::digitizationType_

private

Definition at line 103 of file HGCDigitizer.h.

Referenced by finalizeEvent(), and HGCDigitizer().

◆ ev_per_eh_pair_

double HGCDigitizer::ev_per_eh_pair_

private

Definition at line 115 of file HGCDigitizer.h.

◆ geometryType_

int HGCDigitizer::geometryType_

private

Definition at line 100 of file HGCDigitizer.h.

Referenced by beginRun(), checkPosition(), geometryType(), getType(), getWeight(), and HGCDigitizer().

◆ gHcal_

const HcalGeometry* HGCDigitizer::gHcal_

private

Definition at line 132 of file HGCDigitizer.h.

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

◆ gHGCal_

const HGCalGeometry* HGCDigitizer::gHGCal_

private

Definition at line 131 of file HGCDigitizer.h.

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

◆ hitCollection_

std::string HGCDigitizer::hitCollection_

private

Definition at line 97 of file HGCDigitizer.h.

Referenced by accumulate(), accumulate_forPreMix(), beginRun(), and HGCDigitizer().

◆ hitOrder_monitor

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

private

Definition at line 157 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 155 of file HGCDigitizer.h.

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

◆ maxBx_

const unsigned int HGCDigitizer::maxBx_ = 14

staticprivate

Definition at line 152 of file HGCDigitizer.h.

Referenced by accumulate(), and accumulate_forPreMix().

◆ maxSimHitsAccTime_

int HGCDigitizer::maxSimHitsAccTime_

private

Definition at line 114 of file HGCDigitizer.h.

Referenced by HGCDigitizer().

◆ myDet_

DetId::Detector HGCDigitizer::myDet_

private

Definition at line 135 of file HGCDigitizer.h.

Referenced by beginRun(), getType(), getWeight(), HGCDigitizer(), producesEEDigis(), producesHEbackDigis(), producesHEfrontDigis(), and producesHFNoseDigis().

◆ mySubDet_

ForwardSubdetector HGCDigitizer::mySubDet_

private

Definition at line 136 of file HGCDigitizer.h.

Referenced by beginRun(), getType(), getWeight(), HGCDigitizer(), producesEEDigis(), producesHEbackDigis(), producesHEfrontDigis(), and producesHFNoseDigis().

◆ nEvents_

uint32_t HGCDigitizer::nEvents_

private

Definition at line 149 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 156 of file HGCDigitizer.h.

Referenced by accumulate_forPreMix(), and finalizeEvent().

◆ premixStage1_

bool HGCDigitizer::premixStage1_

private

Definition at line 106 of file HGCDigitizer.h.

Referenced by finalizeEvent(), and HGCDigitizer().

◆ premixStage1MaxCharge_

double HGCDigitizer::premixStage1MaxCharge_

private

Definition at line 111 of file HGCDigitizer.h.

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

◆ premixStage1MinCharge_

double HGCDigitizer::premixStage1MinCharge_

private

Definition at line 109 of file HGCDigitizer.h.

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

◆ pusimHitAccumulator_

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

private

Definition at line 117 of file HGCDigitizer.h.

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

◆ refSpeed_

float HGCDigitizer::refSpeed_

private

Definition at line 142 of file HGCDigitizer.h.

Referenced by accumulate(), and accumulate_forPreMix().

◆ simHitAccumulator_

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

private

Definition at line 116 of file HGCDigitizer.h.

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

◆ theHFNoseDigitizer_

std::unique_ptr<HFNoseDigitizer> HGCDigitizer::theHFNoseDigitizer_

private

Definition at line 127 of file HGCDigitizer.h.

Referenced by finalizeEvent(), getWeight(), and HGCDigitizer().

◆ theHGCEEDigitizer_

std::unique_ptr<HGCEEDigitizer> HGCDigitizer::theHGCEEDigitizer_

private

Definition at line 124 of file HGCDigitizer.h.

Referenced by finalizeEvent(), getWeight(), and HGCDigitizer().

◆ theHGCHEbackDigitizer_

std::unique_ptr<HGCHEbackDigitizer> HGCDigitizer::theHGCHEbackDigitizer_

private

Definition at line 125 of file HGCDigitizer.h.

Referenced by finalizeEvent(), getWeight(), and HGCDigitizer().

◆ theHGCHEfrontDigitizer_

std::unique_ptr<HGCHEfrontDigitizer> HGCDigitizer::theHGCHEfrontDigitizer_

private

Definition at line 126 of file HGCDigitizer.h.

Referenced by finalizeEvent(), getWeight(), and HGCDigitizer().

◆ thisBx_

const unsigned int HGCDigitizer::thisBx_ = 9

staticprivate

Definition at line 153 of file HGCDigitizer.h.

Referenced by accumulate(), and accumulate_forPreMix().

◆ tofDelay_

float HGCDigitizer::tofDelay_

private

Definition at line 145 of file HGCDigitizer.h.

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

◆ validIds_

std::unordered_set<DetId> HGCDigitizer::validIds_

private

Definition at line 130 of file HGCDigitizer.h.

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

◆ verbosity_

uint32_t HGCDigitizer::verbosity_

private

Definition at line 139 of file HGCDigitizer.h.

Referenced by accumulate(), beginRun(), and HGCDigitizer().

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]

◆ beginRun()

◆ checkPosition()

◆ digiCollection()

◆ endRun()

◆ finalizeEvent()

◆ geometryType()

◆ getType()

◆ getWeight()

◆ initializeEvent()

◆ orderByDetIdThenTime()

◆ producesEEDigis()

◆ producesHEbackDigis()

◆ producesHEfrontDigis()

◆ producesHFNoseDigis()

◆ resetPUSimHitDataAccumulator()

◆ resetSimHitDataAccumulator()

Member Data Documentation

◆ averageOccupancies_

◆ bxTime_

◆ cce_

◆ digiCollection_

◆ digitizationType_

◆ ev_per_eh_pair_

◆ geometryType_

◆ gHcal_

◆ gHGCal_

◆ hitCollection_

◆ hitOrder_monitor

◆ hitRefs_bx0

◆ maxBx_

◆ maxSimHitsAccTime_

◆ myDet_

◆ mySubDet_

◆ nEvents_

◆ PhitRefs_bx0

◆ premixStage1_

◆ premixStage1MaxCharge_

◆ premixStage1MinCharge_

◆ pusimHitAccumulator_

◆ refSpeed_

◆ simHitAccumulator_

◆ theHFNoseDigitizer_

◆ theHGCEEDigitizer_

◆ theHGCHEbackDigitizer_

◆ theHGCHEfrontDigitizer_

◆ thisBx_

◆ tofDelay_

◆ validIds_

◆ verbosity_