#include <HGCalVFESummationImpl.h>

Public Member Functions
void	eventSetup (const edm::EventSetup &es)

	HGCalVFESummationImpl (const edm::ParameterSet &conf)

void	triggerCellSums (const HGCalTriggerGeometryBase &, const std::vector< std::pair< DetId, uint32_t > > &, std::unordered_map< uint32_t, uint32_t > &payload)

Private Attributes
double	lsb_scintillator_MIP_

double	lsb_silicon_fC_

std::vector< double >	thickness_corrections_

double	threshold_scintillator_

std::vector< double >	thresholds_silicon_

HGCalTriggerTools	triggerTools_

Detailed Description

Definition at line 14 of file HGCalVFESummationImpl.h.

Constructor & Destructor Documentation

◆ HGCalVFESummationImpl()

HGCalVFESummationImpl::HGCalVFESummationImpl ( const edm::ParameterSet & conf )

Definition at line 3 of file HGCalVFESummationImpl.cc.

     : thickness_corrections_(conf.getParameter<std::vector<double>>("ThicknessCorrections")),
       lsb_silicon_fC_(conf.getParameter<double>("siliconCellLSB_fC")),
       lsb_scintillator_MIP_(conf.getParameter<double>("scintillatorCellLSB_MIP")) {
   const unsigned nThickness = 3;
   if (thickness_corrections_.size() != nThickness) {
     throw cms::Exception("Configuration")
         << thickness_corrections_.size() << " thickness corrections are given instead of " << nThickness
         << " (the number of sensor thicknesses)";
   }
   thresholds_silicon_ =
       conf.getParameter<edm::ParameterSet>("noiseSilicon").getParameter<std::vector<double>>("values");
   if (thresholds_silicon_.size() != nThickness) {
     throw cms::Exception("Configuration") << thresholds_silicon_.size() << " silicon thresholds are given instead of "
                                           << nThickness << " (the number of sensor thicknesses)";
   }
   threshold_scintillator_ = conf.getParameter<edm::ParameterSet>("noiseScintillator").getParameter<double>("noise_MIP");
   const auto threshold = conf.getParameter<double>("noiseThreshold");
   std::transform(
       thresholds_silicon_.begin(), thresholds_silicon_.end(), thresholds_silicon_.begin(), [threshold](auto noise) {
         return noise * threshold;
       });
   threshold_scintillator_ *= threshold;
 }

References Exception, edm::ParameterSet::getParameter(), hgcalDigitizer_cfi::noise, thickness_corrections_, remoteMonitoring_LED_IterMethod_cfg::threshold, threshold_scintillator_, thresholds_silicon_, and HcalDetIdTransform::transform().

Member Function Documentation

◆ eventSetup()

void HGCalVFESummationImpl::eventSetup ( const edm::EventSetup & es )

inline

Definition at line 18 of file HGCalVFESummationImpl.h.

18 { triggerTools_.eventSetup(es); }

References HGCalTriggerTools::eventSetup(), and triggerTools_.

◆ triggerCellSums()

void HGCalVFESummationImpl::triggerCellSums	(	const HGCalTriggerGeometryBase &	,
		const std::vector< std::pair< DetId, uint32_t > > &	,
		std::unordered_map< uint32_t, uint32_t > &	payload
	)

Definition at line 28 of file HGCalVFESummationImpl.cc.

                                                                                            {
   if (linearized_dataframes.empty())
     return;
   // sum energies in trigger cells
   for (const auto& frame : linearized_dataframes) {
     DetId cellid(frame.first);
     uint32_t value = frame.second;
  
     // Apply noise threshold before summing into trigger cells
     if (triggerTools_.isSilicon(cellid)) {
       int thickness = triggerTools_.thicknessIndex(cellid);
       double threshold = thresholds_silicon_.at(thickness);
       value = (value * lsb_silicon_fC_ > threshold ? value : 0);
     } else if (triggerTools_.isScintillator(cellid)) {
       value = (value * lsb_scintillator_MIP_ > threshold_scintillator_ ? value : 0);
     }
     if (value == 0)
       continue;
  
     // find trigger cell associated to cell
     uint32_t tcid = geometry.getTriggerCellFromCell(cellid);
     payload.emplace(tcid, 0);  // do nothing if key exists already
  
     // equalize value among cell thicknesses for Silicon parts
     if (triggerTools_.isSilicon(cellid) && !triggerTools_.isNose(cellid)) {
       int thickness = triggerTools_.thicknessIndex(cellid);
       double thickness_correction = thickness_corrections_.at(thickness);
       value = (double)value * thickness_correction;
     }
  
     // sums energy for the same trigger cell id
     payload[tcid] += value;  // 32 bits integer should be largely enough
   }
 }