HGCDigitizer Class Reference

#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 229 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 362 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 401 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 545 of file HGCDigitizer.cc.

References bxTime_, ALCARECOTkAlJpsiMuMu_cff::charge, TauDecayModes::dec, relativeConstraints::empty, mps_fire::end, f, 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, jetsAK4_CHS_cff::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 341 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 380 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 424 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_, jetsAK4_CHS_cff::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 689 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 739 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().

{ return digiCollection_; }

finalizeEvent()

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

Definition at line 297 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 718 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 267 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 711 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().