#include <PixelChargeCalibCondData.h>

Collaboration diagram for PixelChargeCalibCondData:

Public Types
enum	CalibrationStrategy { CalibrationStrategy::RUN1PIX, CalibrationStrategy::RUN3PIX, CalibrationStrategy::LUTFEI4, CalibrationStrategy::RD53 }

using	IBLCalibration = std::array< float, IBLCalibrationSize >

using	IBLModule = std::vector< IBLCalibration >

Public Member Functions
	PixelChargeCalibCondData ()=default

	PixelChargeCalibCondData (std::size_t max_module_hash)

void	setAllFromBundle (unsigned int moduleHash, const PixelChargeCalib::ChargeCalibrationBundle &b)

void	setAllFromConfigData (unsigned int moduleHash, const PixelModuleData *configData, const std::pair< int, int > &becLayer, unsigned int numFE)

void	setThresholds (InDetDD::PixelDiodeType type, unsigned int moduleHash, const std::vector< PixelChargeCalib::Thresholds > &thresholds)

void	setAnalogThreshold (InDetDD::PixelDiodeType type, unsigned int moduleHash, std::vector< int > &&value)

void	setLegacyFitParameters (InDetDD::PixelDiodeType type, unsigned int moduleHash, const std::vector< PixelChargeCalib::LegacyFitParameters > &parameters)

void	setLinearFitParameters (InDetDD::PixelDiodeType type, unsigned int moduleHash, const std::vector< PixelChargeCalib::LinearFitParameters > &parameters)

void	setTotResolutions (unsigned int moduleHash, const std::vector< PixelChargeCalib::Resolutions > &value)

PixelChargeCalib::Thresholds	getThresholds (InDetDD::PixelDiodeType type, unsigned int moduleHash, unsigned int FE) const

PixelChargeCalib::LegacyFitParameters	getLegacyFitParameters (InDetDD::PixelDiodeType type, unsigned int moduleHash, unsigned int FE) const

PixelChargeCalib::LinearFitParameters	getLinearFitParameters (InDetDD::PixelDiodeType type, unsigned int moduleHash, unsigned int FE) const

float	getQ2TotF (InDetDD::PixelDiodeType type, unsigned int moduleHash, unsigned int FE) const

float	getQ2TotG (InDetDD::PixelDiodeType type, unsigned int moduleHash, unsigned int FE) const

float	getTotRes (unsigned int moduleHash, unsigned int FE, float Q) const

float	getToT (InDetDD::PixelDiodeType type, unsigned int moduleHash, unsigned int FE, float Q) const

float	getCharge (InDetDD::PixelDiodeType type, unsigned int moduleHash, unsigned int FE, float ToT) const

void	setCalibrationStrategy (unsigned int moduleHash, CalibrationStrategy strategy)

void	setTot2Charges (unsigned int moduleHash, IBLModule charges)

const IBLCalibration &	getTot2Charges (unsigned int moduleHash, unsigned int FE) const

CalibrationStrategy	getCalibrationStrategy (unsigned int moduleHash) const

float	getChargeLUTFEI4 (unsigned int moduleHash, unsigned int FE, unsigned int ToT) const

float	getToTLUTFEI4 (unsigned int moduleHash, unsigned int FE, float Q) const

constexpr int	getFEI4OverflowToT () const

Static Public Attributes
static constexpr size_t	IBLCalibrationSize {16}

Private Attributes
std::size_t	m_sizeOfHashVector = 0

std::array< std::vector< std::vector< PixelChargeCalib::Thresholds > >, s_NPixelDiodes >	m_thresholds

std::array< std::vector< std::vector< PixelChargeCalib::LegacyFitParameters > >, s_NPixelDiodes >	m_legacyFit

std::array< std::vector< std::vector< PixelChargeCalib::LinearFitParameters > >, s_NPixelDiodes >	m_linFit

std::vector< std::vector< PixelChargeCalib::Resolutions > >	m_totRes

std::map< int, CalibrationStrategy >	m_calibrationStrategy

std::map< int, IBLModule >	m_tot2Charges

Static Private Attributes
constexpr static std::size_t	s_NPixelDiodes = enum2uint(InDetDD::PixelDiodeType::N_DIODETYPES)

Detailed Description

Definition at line 23 of file PixelChargeCalibCondData.h.

Member Typedef Documentation

◆ IBLCalibration

using PixelChargeCalibCondData::IBLCalibration = std::array<float, IBLCalibrationSize>

Definition at line 30 of file PixelChargeCalibCondData.h.

◆ IBLModule

using PixelChargeCalibCondData::IBLModule = std::vector<IBLCalibration>

Definition at line 31 of file PixelChargeCalibCondData.h.

Member Enumeration Documentation

◆ CalibrationStrategy

enum PixelChargeCalibCondData::CalibrationStrategy

strong

Enumerator
RUN1PIX
RUN3PIX
LUTFEI4
RD53

Definition at line 33 of file PixelChargeCalibCondData.h.

     {
       RUN1PIX,
       RUN3PIX,
       LUTFEI4,
       RD53
     };

Constructor & Destructor Documentation

◆ PixelChargeCalibCondData() [1/2]

PixelChargeCalibCondData::PixelChargeCalibCondData ( )

default

◆ PixelChargeCalibCondData() [2/2]

PixelChargeCalibCondData::PixelChargeCalibCondData ( std::size_t max_module_hash )

Definition at line 46 of file PixelChargeCalibCondData.cxx.

                                                                             : m_sizeOfHashVector(max_module_hash){
   //nop
 }

Member Function Documentation

◆ getCalibrationStrategy()

PixelChargeCalibCondData::CalibrationStrategy PixelChargeCalibCondData::getCalibrationStrategy ( unsigned int moduleHash ) const

Definition at line 223 of file PixelChargeCalibCondData.cxx.

                                                                              {
   if (moduleHash >= m_sizeOfHashVector){
     throw generateError(__func__, moduleHash);
   }
   auto itr = m_calibrationStrategy.find(moduleHash);
   if (itr != m_calibrationStrategy.end()) {
     return itr->second;
   }
   return CalibrationStrategy::RUN1PIX;
 }

◆ getCharge()

float PixelChargeCalibCondData::getCharge	(	InDetDD::PixelDiodeType	type,
		unsigned int	moduleHash,
		unsigned int	FE,
		float	ToT
	)		const

Definition at line 192 of file PixelChargeCalibCondData.cxx.

                                                                                                                         {
   if (getCalibrationStrategy(moduleHash) == CalibrationStrategy::LUTFEI4) {
     return getChargeLUTFEI4(moduleHash, FE, ToT);
   }
   if (type == InDetDD::PixelDiodeType::NONE) return 0.f;
   const LegacyFitParameters & legacy = getLegacyFitParameters(type, moduleHash, FE);
  
   float charge = legacy.Q(ToT);
  
   // Protection for small charge
   const auto & thresholds = getThresholds(type,moduleHash,FE);
   const auto  analogueThreshold = thresholds.value;
   if (charge<analogueThreshold && getCalibrationStrategy(moduleHash)==CalibrationStrategy::RUN3PIX) { charge=analogueThreshold; }
   // Protection for large charge
   float exth = 1e5f;    // the calibration function is analytically connected at threshold exth.
   if (charge>exth && getCalibrationStrategy(moduleHash)==CalibrationStrategy::RUN3PIX) {
     const LinearFitParameters & lin  = getLinearFitParameters(type, moduleHash, FE);
     if (float charge1 = lin.Q(ToT); charge1 != 0.f) return charge1;
   }
   return charge;
 }

◆ getChargeLUTFEI4()

float PixelChargeCalibCondData::getChargeLUTFEI4	(	unsigned int	moduleHash,
		unsigned int	FE,
		unsigned int	ToT
	)		const

Definition at line 252 of file PixelChargeCalibCondData.cxx.

                                                                                                           {
   if (ToT < 1 || ToT > IBLCalibrationSize) {
     throw generateError(__func__, moduleHash,FE, ToT);
   }
  
   const IBLCalibration &charges = getTot2Charges(moduleHash,FE);
   return charges[ToT - 1];
 }

◆ getFEI4OverflowToT()

constexpr int PixelChargeCalibCondData::getFEI4OverflowToT ( ) const

inlineconstexpr

Definition at line 106 of file PixelChargeCalibCondData.h.

                                {
       return 16;
     }

◆ getLegacyFitParameters()

PixelChargeCalib::LegacyFitParameters PixelChargeCalibCondData::getLegacyFitParameters	(	InDetDD::PixelDiodeType	type,
		unsigned int	moduleHash,
		unsigned int	FE
	)		const

Definition at line 120 of file PixelChargeCalibCondData.cxx.

                                                                                                                           {
   if (moduleHash >= m_sizeOfHashVector) throw generateError(__func__, type, moduleHash, FE);
   auto idx = enum2uint(type,__func__);
   const auto & thisVector = m_legacyFit.at(idx);
   const auto &v = thisVector.at(moduleHash);
   if (FE < v.size()) {
     return v[FE];
   }
   throw generateError(__func__, type, moduleHash, FE);
 }

◆ getLinearFitParameters()

PixelChargeCalib::LinearFitParameters PixelChargeCalibCondData::getLinearFitParameters	(	InDetDD::PixelDiodeType	type,
		unsigned int	moduleHash,
		unsigned int	FE
	)		const

Definition at line 143 of file PixelChargeCalibCondData.cxx.

                                                                                                                           {
   if (type==InDetDD::PixelDiodeType::NONE) throw generateError(__func__, type, moduleHash, FE);
   auto idx = enum2uint(type,__func__);
   const auto &typeMap = m_linFit.at(idx);
   //
   const auto &linFit = typeMap.at(moduleHash);
   if (FE < linFit.size()) {
     return typeMap.at(moduleHash).at(FE);
   }
   throw generateError(__func__, type, moduleHash, FE);
 }

◆ getQ2TotF()

float PixelChargeCalibCondData::getQ2TotF	(	InDetDD::PixelDiodeType	type,
		unsigned int	moduleHash,
		unsigned int	FE
	)		const

◆ getQ2TotG()

float PixelChargeCalibCondData::getQ2TotG	(	InDetDD::PixelDiodeType	type,
		unsigned int	moduleHash,
		unsigned int	FE
	)		const

◆ getThresholds()

PixelChargeCalib::Thresholds PixelChargeCalibCondData::getThresholds	(	InDetDD::PixelDiodeType	type,
		unsigned int	moduleHash,
		unsigned int	FE
	)		const

Definition at line 99 of file PixelChargeCalibCondData.cxx.

                                                                                                                  {
   auto idx = enum2uint(type,__func__);
   const auto & hashIndexedVector = m_thresholds[idx];
   const auto &feIndexedVector = hashIndexedVector.at(moduleHash);
   if (FE < feIndexedVector.size()) {
     return feIndexedVector[FE];
   }
   throw generateError(__func__, type, moduleHash, FE);
 }

◆ getToT()

float PixelChargeCalibCondData::getToT	(	InDetDD::PixelDiodeType	type,
		unsigned int	moduleHash,
		unsigned int	FE,
		float	Q
	)		const

Definition at line 174 of file PixelChargeCalibCondData.cxx.

                                                                                                                    {
   if (getCalibrationStrategy(moduleHash) == CalibrationStrategy::LUTFEI4) {
     return getToTLUTFEI4(moduleHash, FE, Q);
   }
   if (type == InDetDD::PixelDiodeType::NONE) return 0.f;
   const LegacyFitParameters & legacy = getLegacyFitParameters(type, moduleHash, FE);
   float tot = legacy.ToT(Q);
  
   // Protection for large charge
   float exth = 1e5f;    // the calibration function is analytically connected at threshold exth.
   if (Q>exth && getCalibrationStrategy(moduleHash)==CalibrationStrategy::RUN3PIX) {
     const LinearFitParameters & lin = getLinearFitParameters(type, moduleHash, FE);
     if ( float tot1 = lin.ToT(Q); tot1 != 0.f) return tot1;
   }
   return tot;
 }

◆ getTot2Charges()

const PixelChargeCalibCondData::IBLCalibration & PixelChargeCalibCondData::getTot2Charges	(	unsigned int	moduleHash,
		unsigned int	FE
	)		const

Definition at line 243 of file PixelChargeCalibCondData.cxx.

                                                                                       {
   auto it = m_tot2Charges.find(moduleHash);
   if (it != m_tot2Charges.end() && FE < it->second.size()) {
     return it->second.at(FE);
   }
   throw generateError(__func__, moduleHash,FE);
 }

◆ getToTLUTFEI4()

float PixelChargeCalibCondData::getToTLUTFEI4	(	unsigned int	moduleHash,
		unsigned int	FE,
		float	Q
	)		const

Definition at line 262 of file PixelChargeCalibCondData.cxx.

                                                                                               {
   int tot = -1;
   float minDiff = FLT_MAX;
   for (size_t t = 0; t < IBLCalibrationSize; t++) {
     float charge = getChargeLUTFEI4(moduleHash, FE, t + 1);
     float diff = std::fabs(charge - Q);
     if (diff < minDiff) {
       minDiff = diff;
       tot = t + 1;
     }
   }
   return tot;
 }

◆ getTotRes()

float PixelChargeCalibCondData::getTotRes	(	unsigned int	moduleHash,
		unsigned int	FE,
		float	Q
	)		const

Definition at line 163 of file PixelChargeCalibCondData.cxx.

                                                                                           {
   Resolutions r;
   if (const auto &res = m_totRes.at(moduleHash); FE < res.size()) {
     r = res[FE];
   } else {
     throw generateError(__func__, moduleHash, FE);
   }
   return r.total(Q);
 }

◆ setAllFromBundle()

void PixelChargeCalibCondData::setAllFromBundle	(	unsigned int	moduleHash,
		const PixelChargeCalib::ChargeCalibrationBundle &	b
	)

Definition at line 51 of file PixelChargeCalibCondData.cxx.

                                                                                                    {
   //calibration strategy
   setCalibrationStrategy(moduleHash, b.calibrationType);
   // Normal pixel
   setThresholds(InDetDD::PixelDiodeType::NORMAL, moduleHash, b.threshold);
   setLegacyFitParameters(InDetDD::PixelDiodeType::NORMAL, moduleHash, b.params); 
   setLinearFitParameters(InDetDD::PixelDiodeType::NORMAL, moduleHash, b.lin); 
   setTotResolutions(moduleHash, b.totRes);
   // Long pixel
   setThresholds(InDetDD::PixelDiodeType::LONG, moduleHash, b.thresholdLong);
   setLegacyFitParameters(InDetDD::PixelDiodeType::LONG, moduleHash, b.params); 
   setLinearFitParameters(InDetDD::PixelDiodeType::LONG, moduleHash, b.lin); 
   // Ganged/large pixel
   setThresholds(InDetDD::PixelDiodeType::GANGED, moduleHash, b.thresholdGanged);
   setLegacyFitParameters(InDetDD::PixelDiodeType::GANGED, moduleHash, b.paramsGanged);
   setLinearFitParameters(InDetDD::PixelDiodeType::GANGED, moduleHash, b.linGanged);
 }

◆ setAllFromConfigData()

void PixelChargeCalibCondData::setAllFromConfigData	(	unsigned int	moduleHash,
		const PixelModuleData *	configData,
		const std::pair< int, int > &	becLayer,
		unsigned int	numFE
	)

Definition at line 70 of file PixelChargeCalibCondData.cxx.

                                                                                                                                                                 {
   const auto & [barrel_ec, layer] = becLayer;
   for (size_t i{}; i != s_NPixelDiodes; ++i) {
     const auto t = static_cast<InDetDD::PixelDiodeType>(i);
     const Thresholds thresholds{configData->getDefaultAnalogThreshold(barrel_ec, layer), configData->getDefaultAnalogThresholdSigma(barrel_ec, layer),
       configData->getDefaultAnalogThresholdNoise(barrel_ec, layer), configData->getDefaultInTimeThreshold(barrel_ec, layer)};
     setThresholds(t, moduleHash, std::vector<Thresholds>(numFE, thresholds));
     //
     const LegacyFitParameters defaultParams{configData->getDefaultQ2TotA(), configData->getDefaultQ2TotE(), configData->getDefaultQ2TotC()};
     setLegacyFitParameters(t, moduleHash, std::vector<LegacyFitParameters>(numFE, defaultParams));
     //
     const auto zeroLinFit = PixelChargeCalib::LinearFitParameters();
     setLinearFitParameters(t, moduleHash, std::vector<PixelChargeCalib::LinearFitParameters>(numFE, zeroLinFit));
   }
   const auto zeroResolution = PixelChargeCalib::Resolutions();
   setTotResolutions(moduleHash, std::vector<PixelChargeCalib::Resolutions>(numFE, zeroResolution));
 }

◆ setAnalogThreshold()

void PixelChargeCalibCondData::setAnalogThreshold	(	InDetDD::PixelDiodeType	type,
		unsigned int	moduleHash,
		std::vector< int > &&	value
	)

◆ setCalibrationStrategy()

void PixelChargeCalibCondData::setCalibrationStrategy	(	unsigned int	moduleHash,
		CalibrationStrategy	strategy
	)

Definition at line 215 of file PixelChargeCalibCondData.cxx.

                                                                                                      { 
   if (moduleHash >= m_sizeOfHashVector) {
     throw generateError(__func__, moduleHash, static_cast<int>(strategy));
   }
   m_calibrationStrategy[moduleHash] = strategy;
 }

◆ setLegacyFitParameters()

void PixelChargeCalibCondData::setLegacyFitParameters	(	InDetDD::PixelDiodeType	type,
		unsigned int	moduleHash,
		const std::vector< PixelChargeCalib::LegacyFitParameters > &	parameters
	)

Definition at line 110 of file PixelChargeCalibCondData.cxx.

                                                                                                                                                                      {
   if (moduleHash >= m_sizeOfHashVector) throw generateError(__func__, moduleHash);
   auto & thisVector = m_legacyFit.at(enum2uint(type,__func__));
   if (thisVector.size()<=moduleHash){
     thisVector.resize(m_sizeOfHashVector);
   }
   thisVector[moduleHash] = parameters;
 }

◆ setLinearFitParameters()

void PixelChargeCalibCondData::setLinearFitParameters	(	InDetDD::PixelDiodeType	type,
		unsigned int	moduleHash,
		const std::vector< PixelChargeCalib::LinearFitParameters > &	parameters
	)

Definition at line 132 of file PixelChargeCalibCondData.cxx.

                                                                                                                                                                      {
   if (moduleHash >= m_sizeOfHashVector) throw generateError(__func__, moduleHash);
   auto & thisVector = m_linFit.at(enum2uint(type,__func__));
   if ( thisVector.size()<=moduleHash){
     thisVector.resize(m_sizeOfHashVector);
   }
   thisVector[moduleHash] =  parameters;
 }

◆ setThresholds()

void PixelChargeCalibCondData::setThresholds	(	InDetDD::PixelDiodeType	type,
		unsigned int	moduleHash,
		const std::vector< PixelChargeCalib::Thresholds > &	thresholds
	)

Definition at line 89 of file PixelChargeCalibCondData.cxx.

                                                                                                                                                     {
   if (moduleHash >= m_sizeOfHashVector) throw generateError(__func__, moduleHash);
   auto & hashIndexedVector = m_thresholds[enum2uint(type,__func__)];
   if (hashIndexedVector.size()<=moduleHash){
     hashIndexedVector.resize(m_sizeOfHashVector);
   }
   hashIndexedVector[moduleHash] = thresholds;
 }

◆ setTot2Charges()

void PixelChargeCalibCondData::setTot2Charges	(	unsigned int	moduleHash,
		IBLModule	charges
	)

Definition at line 235 of file PixelChargeCalibCondData.cxx.

                                                                                   { 
   if (moduleHash >= m_sizeOfHashVector){
     throw generateError(__func__, moduleHash);
   }
   m_tot2Charges[moduleHash] = std::move(charges);
 }

◆ setTotResolutions()

void PixelChargeCalibCondData::setTotResolutions	(	unsigned int	moduleHash,
		const std::vector< PixelChargeCalib::Resolutions > &	value
	)

Definition at line 156 of file PixelChargeCalibCondData.cxx.

                                                                                                                        {
   if (moduleHash >= m_sizeOfHashVector) throw generateError(__func__, moduleHash);
   if (moduleHash >= m_totRes.size()) m_totRes.resize(m_sizeOfHashVector);
   m_totRes[moduleHash] = value;
 }

Member Data Documentation

◆ IBLCalibrationSize

constexpr size_t PixelChargeCalibCondData::IBLCalibrationSize {16}

staticconstexpr

Definition at line 29 of file PixelChargeCalibCondData.h.

◆ m_calibrationStrategy

std::map<int, CalibrationStrategy> PixelChargeCalibCondData::m_calibrationStrategy

private

Definition at line 120 of file PixelChargeCalibCondData.h.

◆ m_legacyFit

std::array<std::vector<std::vector<PixelChargeCalib::LegacyFitParameters> >, s_NPixelDiodes> PixelChargeCalibCondData::m_legacyFit

private

Definition at line 115 of file PixelChargeCalibCondData.h.

◆ m_linFit

std::array<std::vector<std::vector<PixelChargeCalib::LinearFitParameters> >, s_NPixelDiodes> PixelChargeCalibCondData::m_linFit

private

Definition at line 116 of file PixelChargeCalibCondData.h.

◆ m_sizeOfHashVector

std::size_t PixelChargeCalibCondData::m_sizeOfHashVector = 0

private

Definition at line 111 of file PixelChargeCalibCondData.h.

◆ m_thresholds

std::array<std::vector<std::vector<PixelChargeCalib::Thresholds> >, s_NPixelDiodes> PixelChargeCalibCondData::m_thresholds

private

Definition at line 114 of file PixelChargeCalibCondData.h.

◆ m_tot2Charges

std::map<int, IBLModule> PixelChargeCalibCondData::m_tot2Charges

private

Definition at line 121 of file PixelChargeCalibCondData.h.

◆ m_totRes

std::vector<std::vector<PixelChargeCalib::Resolutions> > PixelChargeCalibCondData::m_totRes

private

Definition at line 117 of file PixelChargeCalibCondData.h.

◆ s_NPixelDiodes

constexpr static std::size_t PixelChargeCalibCondData::s_NPixelDiodes = enum2uint(InDetDD::PixelDiodeType::N_DIODETYPES)

staticconstexprprivate

Definition at line 112 of file PixelChargeCalibCondData.h.

The documentation for this class was generated from the following files:

Public Types

Public Member Functions

Static Public Attributes

Private Attributes

Static Private Attributes

Detailed Description

Member Typedef Documentation

◆ IBLCalibration

◆ IBLModule

Member Enumeration Documentation

◆ CalibrationStrategy

Constructor & Destructor Documentation

◆ PixelChargeCalibCondData() [1/2]

◆ PixelChargeCalibCondData() [2/2]

Member Function Documentation

◆ getCalibrationStrategy()

◆ getCharge()

◆ getChargeLUTFEI4()

◆ getFEI4OverflowToT()

◆ getLegacyFitParameters()

◆ getLinearFitParameters()

◆ getQ2TotF()

◆ getQ2TotG()

◆ getThresholds()

◆ getToT()

◆ getTot2Charges()

◆ getToTLUTFEI4()

◆ getTotRes()

◆ setAllFromBundle()

◆ setAllFromConfigData()

◆ setAnalogThreshold()

◆ setCalibrationStrategy()

◆ setLegacyFitParameters()

◆ setLinearFitParameters()

◆ setThresholds()

◆ setTot2Charges()

◆ setTotResolutions()

Member Data Documentation

◆ IBLCalibrationSize

◆ m_calibrationStrategy

◆ m_legacyFit

◆ m_linFit

◆ m_sizeOfHashVector

◆ m_thresholds

◆ m_tot2Charges

◆ m_totRes

◆ s_NPixelDiodes