#include <HGCalVFELinearizationImpl.h>

Public Member Functions
	HGCalVFELinearizationImpl (const edm::ParameterSet &conf)

void	linearize (const std::vector< HGCDataFrame< DetId, HGCSample >> &, std::vector< std::pair< DetId, uint32_t >> &)

uint32_t	linnBits () const

Private Attributes
double	adcLSB_sc_

double	adcLSB_si_

uint32_t	adcnBits_sc_

uint32_t	adcnBits_si_

double	adcsaturation_sc_

double	adcsaturation_si_

double	linLSB_sc_

double	linLSB_si_

uint32_t	linMax_

uint32_t	linnBits_

double	tdcLSB_sc_

double	tdcLSB_si_

uint32_t	tdcnBits_sc_

uint32_t	tdcnBits_si_

double	tdcOnset_sc_

double	tdcOnset_si_

double	tdcsaturation_sc_

double	tdcsaturation_si_

Detailed Description

Definition at line 12 of file HGCalVFELinearizationImpl.h.

Constructor & Destructor Documentation

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

Definition at line 3 of file HGCalVFELinearizationImpl.cc.

References adcLSB_sc_, adcLSB_si_, adcnBits_sc_, adcnBits_si_, adcsaturation_sc_, adcsaturation_si_, linMax_, linnBits_, funct::pow(), tdcLSB_sc_, tdcLSB_si_, tdcnBits_sc_, tdcnBits_si_, tdcsaturation_sc_, and tdcsaturation_si_.

     : linLSB_si_(conf.getParameter<double>("linLSB_si")),
       adcsaturation_si_(conf.getParameter<double>("adcsaturation_si")),
       tdcnBits_si_(conf.getParameter<uint32_t>("tdcnBits_si")),
       tdcOnset_si_(conf.getParameter<double>("tdcOnset_si")),
       adcnBits_si_(conf.getParameter<uint32_t>("adcnBits_si")),
       tdcsaturation_si_(conf.getParameter<double>("tdcsaturation_si")),
       linLSB_sc_(conf.getParameter<double>("linLSB_sc")),
       adcsaturation_sc_(conf.getParameter<double>("adcsaturation_sc")),
       tdcnBits_sc_(conf.getParameter<uint32_t>("tdcnBits_sc")),
       tdcOnset_sc_(conf.getParameter<double>("tdcOnset_sc")),
       adcnBits_sc_(conf.getParameter<uint32_t>("adcnBits_sc")),
       tdcsaturation_sc_(conf.getParameter<double>("tdcsaturation_sc")),
       linnBits_(conf.getParameter<uint32_t>("linnBits")) {
   adcLSB_si_ = adcsaturation_si_ / pow(2., adcnBits_si_);
   tdcLSB_si_ = tdcsaturation_si_ / pow(2., tdcnBits_si_);
   adcLSB_sc_ = adcsaturation_sc_ / pow(2., adcnBits_sc_);
   tdcLSB_sc_ = tdcsaturation_sc_ / pow(2., tdcnBits_sc_);
   linMax_ = (0x1 << linnBits_) - 1;
 }

Member Function Documentation

void HGCalVFELinearizationImpl::linearize	(	const std::vector< HGCDataFrame< DetId, HGCSample >> &	dataframes,
		std::vector< std::pair< DetId, uint32_t >> &	linearized_dataframes
	)

Definition at line 24 of file HGCalVFELinearizationImpl.cc.

References adcLSB_sc_, adcLSB_si_, CustomPhysics_cfi::amplitude, data, DetId::Forward, amptDefault_cfi::frame, DetId::Hcal, DetId::HGCalEE, DetId::HGCalHSc, DetId::HGCalHSi, linLSB_sc_, linLSB_si_, linMax_, ALCARECOPromptCalibProdSiPixelAli0T_cff::mode, tdcLSB_sc_, tdcLSB_si_, HGCalUncalibRecHit_cfi::tdcOnset, tdcOnset_sc_, and tdcOnset_si_.

                                                                                                       {
   double amplitude = 0.;
   uint32_t amplitude_int = 0;
   const int kIntimeSample = 2;
 
   for (const auto& frame : dataframes) {  //loop on DIGI
     unsigned det = frame.id().det();
     double adcLSB = 0.;
     double tdcLSB = 0.;
     double tdcOnset = 0.;
     double linLSB = 0.;
     if (det == DetId::Forward || det == DetId::HGCalEE || det == DetId::HGCalHSi) {
       adcLSB = adcLSB_si_;
       tdcLSB = tdcLSB_si_;
       tdcOnset = tdcOnset_si_;
       linLSB = linLSB_si_;
     } else if (det == DetId::Hcal || det == DetId::HGCalHSc) {
       adcLSB = adcLSB_sc_;
       tdcLSB = tdcLSB_sc_;
       tdcOnset = tdcOnset_sc_;
       linLSB = linLSB_sc_;
     }
     if (frame[kIntimeSample].mode()) {  //TOT mode
       amplitude = (floor(tdcOnset / adcLSB) + 1.0) * adcLSB + double(frame[kIntimeSample].data()) * tdcLSB;
     } else {  //ADC mode
       amplitude = double(frame[kIntimeSample].data()) * adcLSB;
     }
 
     amplitude_int = uint32_t(floor(amplitude / linLSB + 0.5));
     if (amplitude_int > linMax_)
       amplitude_int = linMax_;
 
     linearized_dataframes.push_back(std::make_pair(frame.id(), amplitude_int));
   }
 }