HcaluLUTTPGCoder Class Reference

#include <HcaluLUTTPGCoder.h>

Inheritance diagram for HcaluLUTTPGCoder:

Public Member Functions
void	adc2Linear (const HBHEDataFrame &df, IntegerCaloSamples &ics) const override
void	adc2Linear (const HFDataFrame &df, IntegerCaloSamples &ics) const override
void	adc2Linear (const QIE10DataFrame &df, IntegerCaloSamples &ics) const override
void	adc2Linear (const QIE11DataFrame &df, IntegerCaloSamples &ics) const override
unsigned short	adc2Linear (HcalQIESample sample, HcalDetId id) const override
void	compress (const IntegerCaloSamples &ics, const std::vector< bool > &featureBits, HcalTriggerPrimitiveDigi &tp) const override
double	cosh_ieta (int ieta, int depth, HcalSubdetector subdet)
std::vector< unsigned short >	getLinearizationLUT (HcalDetId id) const override
	Get the full linearization LUT (128 elements). Default implementation just uses adc2Linear to get all values. More...
float	getLUTGain (HcalDetId id) const override
int	getLUTId (HcalSubdetector id, int ieta, int iphi, int depth) const
int	getLUTId (uint32_t rawid) const
int	getLUTId (const HcalDetId &detid) const
float	getLUTPedestal (HcalDetId id) const override
bool	getMSB (const HcalDetId &id, int adc) const
std::vector< unsigned short >	group0FGbits (const QIE11DataFrame &df) const
	HcaluLUTTPGCoder ()
	HcaluLUTTPGCoder (const HcalTopology *topo, const HcalTimeSlew *delay)
void	init (const HcalTopology *top, const HcalTimeSlew *delay)
void	lookupMSB (const HBHEDataFrame &df, std::vector< bool > &msb) const
void	lookupMSB (const QIE10DataFrame &df, std::vector< std::bitset< 2 >> &msb) const
void	lookupMSB (const QIE11DataFrame &df, std::vector< std::bitset< 2 >> &msb) const
void	make_cosh_ieta_map (void)
void	set1TSContainHB (bool contain1TSHB)
void	set1TSContainHE (bool contain1TSHE)
void	setAllLinear (bool linear, double lsb8, double lsb11, double lsb11overlap)
void	setApplyFixPCC (double applyFixPCC)
void	setContainPhaseHB (double containPhaseNSHB)
void	setContainPhaseHE (double containPhaseNSHE)
void	setFGHFthresholds (const std::vector< uint32_t > &fgthresholds)
void	setLUTGenerationMode (bool gen)
void	setMaskBit (int bit)
void	setOverrideDBweightsAndFilterHB (bool overrideDBweightsAndFilterHB)
void	setOverrideDBweightsAndFilterHE (bool overrideDBweightsAndFilterHE)
void	update (const HcalDbService &conditions)
void	update (const char *filename, bool appendMSB=false)
void	updateXML (const char *filename)
	~HcaluLUTTPGCoder () override
Public Member Functions inherited from HcalTPGCoder
unsigned short	adc2Linear (unsigned char adc, HcalDetId id) const
virtual	~HcalTPGCoder ()=default

Static Public Attributes
static const float	lsb_ = 1. / 16
static const int	QIE10_LUT_BITMASK = 0x7FF
static const int	QIE11_LUT_BITMASK = 0x3FF
static const int	QIE8_LUT_BITMASK = 0x3FF

Private Types
typedef std::vector< LutElement >	Lut
typedef unsigned short	LutElement

Private Attributes
bool	allLinear_
bool	applyFixPCC_
int	bitToMask_
bool	contain1TSHB_
bool	contain1TSHE_
double	containPhaseNSHB_ = 6.0
double	containPhaseNSHE_ = 6.0
std::vector< double >	cosh_ieta_
double	cosh_ieta_28_HE_high_depths_
double	cosh_ieta_28_HE_low_depths_
double	cosh_ieta_29_HE_
const HcalTimeSlew *	delay_
std::vector< uint32_t >	FG_HF_thresholds_
int	firstHBEta_
int	firstHEEta_
int	firstHFEta_
std::vector< float >	gain_
std::vector< Lut >	inputLUT_
int	lastHBEta_
int	lastHEEta_
int	lastHFEta_
double	linearLSB_QIE11_
double	linearLSB_QIE11Overlap_
double	linearLSB_QIE8_
bool	LUTGenerationMode_
int	maxDepthHB_
int	maxDepthHE_
int	maxDepthHF_
int	nHBEta_
int	nHEEta_
int	nHFEta_
bool	overrideDBweightsAndFilterHB_ = false
bool	overrideDBweightsAndFilterHE_ = false
std::vector< float >	ped_
std::unique_ptr< HcalPulseContainmentManager >	pulseCorr_
int	sizeHB_
int	sizeHE_
int	sizeHF_
const HcalTopology *	topo_

Static Private Attributes
static const size_t	INPUT_LUT_SIZE = 128
static const int	nFi_ = 72
static const int	QIE10_LUT_MSB0 = 0x1000
static const int	QIE10_LUT_MSB1 = 0x2000
static const int	QIE11_LUT_MSB0 = 0x400
static const int	QIE11_LUT_MSB1 = 0x800
static const int	QIE8_LUT_MSB = 0x400
static const size_t	UPGRADE_LUT_SIZE = 256

Detailed Description

The nominal coder uses a user-supplied table to linearize the ADC values.

[number of ieta slices]
[low tower 1] [low tower 2] ...
[high tower 1] [ high tower 2] ...
[LUT 1(0)] [LUT 2(0)] ...
[LUT 1(1)] [LUT 2(1)] ...
. . .
[LUT 1(127)] [LUT 2(127)] ...

Author

M. Weinberger – TAMU

Tulika Bose and Greg Landsberg – Brown

Definition at line 32 of file HcaluLUTTPGCoder.h.

Member Typedef Documentation

Lut

typedef std::vector<LutElement> HcaluLUTTPGCoder::Lut

private

Definition at line 95 of file HcaluLUTTPGCoder.h.

LutElement

typedef unsigned short HcaluLUTTPGCoder::LutElement

private

Definition at line 94 of file HcaluLUTTPGCoder.h.

Constructor & Destructor Documentation

HcaluLUTTPGCoder() [1/2]

HcaluLUTTPGCoder::HcaluLUTTPGCoder

(

)

Definition at line 39 of file HcaluLUTTPGCoder.cc.

    : topo_{},
      delay_{},
      LUTGenerationMode_{},
      FG_HF_thresholds_{},
      bitToMask_{},
      firstHBEta_{},
      lastHBEta_{},
      nHBEta_{},
      maxDepthHB_{},
      sizeHB_{},
      firstHEEta_{},
      lastHEEta_{},
      nHEEta_{},
      maxDepthHE_{},
      sizeHE_{},
      firstHFEta_{},
      lastHFEta_{},
      nHFEta_{},
      maxDepthHF_{},
      sizeHF_{},
      cosh_ieta_28_HE_low_depths_{},
      cosh_ieta_28_HE_high_depths_{},
      cosh_ieta_29_HE_{},
      allLinear_{},
      contain1TSHB_{},
      contain1TSHE_{},
      applyFixPCC_{},
      linearLSB_QIE8_{},
      linearLSB_QIE11_{},
      linearLSB_QIE11Overlap_{} {}

HcaluLUTTPGCoder() [2/2]

HcaluLUTTPGCoder::HcaluLUTTPGCoder	(	const HcalTopology *	topo,
		const HcalTimeSlew *	delay
	)

Definition at line 71 of file HcaluLUTTPGCoder.cc.

References phase2TrackerDigitizer_cfi::delay, and init().

{ init(top, delay); }

~HcaluLUTTPGCoder()

HcaluLUTTPGCoder::~HcaluLUTTPGCoder ( )

override

Definition at line 115 of file HcaluLUTTPGCoder.cc.

{}

Member Function Documentation

adc2Linear() [1/5]

void HcaluLUTTPGCoder::adc2Linear ( const HBHEDataFrame &  df, IntegerCaloSamples &  ics  ) const

overridevirtual

Implements HcalTPGCoder.

Definition at line 572 of file HcaluLUTTPGCoder.cc.

References gpuClustering::adc, hgcalPerformanceValidation::df, getLUTId(), mps_fire::i, Ecal07UnpackerData_cfi::ics, inputLUT_, and QIE8_LUT_BITMASK.

Referenced by HcalTriggerPrimitiveAlgo::addSignal(), and HcalTriggerPrimitiveAlgo::addUpgradeTDCFG().

                                                                                        {
  int lutId = getLUTId(df.id());
  const Lut& lut = inputLUT_.at(lutId);
  for (int i = 0; i < df.size(); i++) {
    ics[i] = (lut.at(df[i].adc()) & QIE8_LUT_BITMASK);
  }
}

adc2Linear() [2/5]

void HcaluLUTTPGCoder::adc2Linear ( const HFDataFrame &  df, IntegerCaloSamples &  ics  ) const

overridevirtual

Implements HcalTPGCoder.

Definition at line 580 of file HcaluLUTTPGCoder.cc.

References gpuClustering::adc, hgcalPerformanceValidation::df, getLUTId(), mps_fire::i, Ecal07UnpackerData_cfi::ics, inputLUT_, and QIE8_LUT_BITMASK.

                                                                                      {
  int lutId = getLUTId(df.id());
  const Lut& lut = inputLUT_.at(lutId);
  for (int i = 0; i < df.size(); i++) {
    ics[i] = (lut.at(df[i].adc()) & QIE8_LUT_BITMASK);
  }
}

adc2Linear() [3/5]

void HcaluLUTTPGCoder::adc2Linear ( const QIE10DataFrame &  df, IntegerCaloSamples &  ics  ) const

overridevirtual

Implements HcalTPGCoder.

Definition at line 588 of file HcaluLUTTPGCoder.cc.

References gpuClustering::adc, hgcalPerformanceValidation::df, getLUTId(), mps_fire::i, Ecal07UnpackerData_cfi::ics, inputLUT_, and QIE10_LUT_BITMASK.

                                                                                         {
  int lutId = getLUTId(HcalDetId(df.id()));
  const Lut& lut = inputLUT_.at(lutId);
  for (int i = 0; i < df.samples(); i++) {
    ics[i] = (lut.at(df[i].adc()) & QIE10_LUT_BITMASK);
  }
}

adc2Linear() [4/5]

void HcaluLUTTPGCoder::adc2Linear ( const QIE11DataFrame &  df, IntegerCaloSamples &  ics  ) const

overridevirtual

Implements HcalTPGCoder.

Definition at line 596 of file HcaluLUTTPGCoder.cc.

References gpuClustering::adc, hgcalPerformanceValidation::df, getLUTId(), mps_fire::i, Ecal07UnpackerData_cfi::ics, inputLUT_, and QIE11_LUT_BITMASK.

                                                                                         {
  int lutId = getLUTId(HcalDetId(df.id()));
  const Lut& lut = inputLUT_.at(lutId);
  for (int i = 0; i < df.samples(); i++) {
    ics[i] = (lut.at(df[i].adc()) & QIE11_LUT_BITMASK);
  }
}

adc2Linear() [5/5]

unsigned short HcaluLUTTPGCoder::adc2Linear ( HcalQIESample  sample, HcalDetId  id  ) const

overridevirtual

Implements HcalTPGCoder.

Definition at line 604 of file HcaluLUTTPGCoder.cc.

References getLUTId(), inputLUT_, QIE8_LUT_BITMASK, and ecalGpuTask_cfi::sample.

                                                                                    {
  int lutId = getLUTId(id);
  return ((inputLUT_.at(lutId)).at(sample.adc()) & QIE8_LUT_BITMASK);
}

compress()

void HcaluLUTTPGCoder::compress ( const IntegerCaloSamples &  ics, const std::vector< bool > &  featureBits, HcalTriggerPrimitiveDigi &  tp  ) const

overridevirtual

Implements HcalTPGCoder.

Definition at line 109 of file HcaluLUTTPGCoder.cc.

References Exception.

                                                                    {
  throw cms::Exception("PROBLEM: This method should never be invoked!");
}

cosh_ieta()

double HcaluLUTTPGCoder::cosh_ieta	(	int	ieta,
		int	depth,
		HcalSubdetector	subdet
	)

Definition at line 288 of file HcaluLUTTPGCoder.cc.

References funct::abs(), allLinear_, cosh_ieta_, cosh_ieta_28_HE_high_depths_, cosh_ieta_28_HE_low_depths_, cosh_ieta_29_HE_, LEDCalibrationChannels::depth, HcalEndcap, and LEDCalibrationChannels::ieta.

Referenced by update().

                                                                              {
  // ieta = 28 and 29 are both associated with trigger tower 28
  // so special handling is required. HF ieta=29 channels included in TT30
  // are already handled correctly in cosh_ieta_
  if (abs(ieta) >= 28 && subdet == HcalEndcap && allLinear_) {
    if (abs(ieta) == 29)
      return cosh_ieta_29_HE_;
    if (abs(ieta) == 28) {
      if (depth <= 3)
        return cosh_ieta_28_HE_low_depths_;
      else
        return cosh_ieta_28_HE_high_depths_;
    }
  }

  return cosh_ieta_[ieta];
}

getLinearizationLUT()

std::vector< unsigned short > HcaluLUTTPGCoder::getLinearizationLUT ( HcalDetId  id ) const

overridevirtual

Get the full linearization LUT (128 elements). Default implementation just uses adc2Linear to get all values.

Reimplemented from HcalTPGCoder.

Definition at line 631 of file HcaluLUTTPGCoder.cc.

References getLUTId(), and inputLUT_.

                                                                                  {
  int lutId = getLUTId(id);
  return inputLUT_.at(lutId);
}

getLUTGain()

float HcaluLUTTPGCoder::getLUTGain ( HcalDetId  id ) const

overridevirtual

Implements HcalTPGCoder.

Definition at line 626 of file HcaluLUTTPGCoder.cc.

References gain_, and getLUTId().

                                                     {
  int lutId = getLUTId(id);
  return gain_.at(lutId);
}

getLUTId() [1/3]

int HcaluLUTTPGCoder::getLUTId	(	HcalSubdetector	id,
		int	ieta,
		int	iphi,
		int	depth
	)		const

Definition at line 117 of file HcaluLUTTPGCoder.cc.

References LEDCalibrationChannels::depth, firstHBEta_, firstHEEta_, firstHFEta_, HcalBarrel, HcalEndcap, HcalForward, LEDCalibrationChannels::ieta, LEDCalibrationChannels::iphi, lastHBEta_, lastHEEta_, lastHFEta_, maxDepthHB_, maxDepthHE_, maxDepthHF_, nFi_, nHBEta_, nHEEta_, nHFEta_, sizeHB_, and sizeHE_.

Referenced by adc2Linear(), getLinearizationLUT(), getLUTGain(), getLUTId(), getLUTPedestal(), getMSB(), group0FGbits(), lookupMSB(), update(), and updateXML().

                                                                                      {
  int retval(0);
  if (id == HcalBarrel) {
    retval = (depth - 1) + maxDepthHB_ * (iphi - 1);
    if (ieta > 0)
      retval += maxDepthHB_ * nFi_ * (ieta - firstHBEta_);
    else
      retval += maxDepthHB_ * nFi_ * (ieta + lastHBEta_ + nHBEta_);
  } else if (id == HcalEndcap) {
    retval = sizeHB_;
    retval += (depth - 1) + maxDepthHE_ * (iphi - 1);
    if (ieta > 0)
      retval += maxDepthHE_ * nFi_ * (ieta - firstHEEta_);
    else
      retval += maxDepthHE_ * nFi_ * (ieta + lastHEEta_ + nHEEta_);
  } else if (id == HcalForward) {
    retval = sizeHB_ + sizeHE_;
    retval += (depth - 1) + maxDepthHF_ * (iphi - 1);
    if (ieta > 0)
      retval += maxDepthHF_ * nFi_ * (ieta - firstHFEta_);
    else
      retval += maxDepthHF_ * nFi_ * (ieta + lastHFEta_ + nHFEta_);
  }
  return retval;
}

getLUTId() [2/3]

int HcaluLUTTPGCoder::getLUTId

(

uint32_t

rawid

)

const

Definition at line 143 of file HcaluLUTTPGCoder.cc.

References HcalDetId::depth(), getLUTId(), HcalDetId::ieta(), HcalDetId::iphi(), and HcalDetId::subdet().

                                                   {
  HcalDetId detid(rawid);
  return getLUTId(detid.subdet(), detid.ieta(), detid.iphi(), detid.depth());
}

getLUTId() [3/3]

int HcaluLUTTPGCoder::getLUTId

(

const HcalDetId &

detid

)

const

Definition at line 148 of file HcaluLUTTPGCoder.cc.

References HcalDetId::depth(), getLUTId(), HcalDetId::ieta(), HcalDetId::iphi(), and HcalDetId::subdet().

                                                           {
  return getLUTId(detid.subdet(), detid.ieta(), detid.iphi(), detid.depth());
}

getLUTPedestal()

float HcaluLUTTPGCoder::getLUTPedestal ( HcalDetId  id ) const

overridevirtual

Implements HcalTPGCoder.

Definition at line 621 of file HcaluLUTTPGCoder.cc.

References getLUTId(), and ped_.

                                                         {
  int lutId = getLUTId(id);
  return ped_.at(lutId);
}

getMSB()

bool HcaluLUTTPGCoder::getMSB	(	const HcalDetId &	id,
		int	adc
	)		const

Definition at line 642 of file HcaluLUTTPGCoder.cc.

References gpuClustering::adc, getLUTId(), inputLUT_, and QIE8_LUT_MSB.

Referenced by lookupMSB().

                                                                {
  int lutId = getLUTId(id);
  const Lut& lut = inputLUT_.at(lutId);
  return (lut.at(adc) & QIE8_LUT_MSB);
}

group0FGbits()

std::vector< unsigned short > HcaluLUTTPGCoder::group0FGbits

(

const QIE11DataFrame &

df

)

const

Definition at line 609 of file HcaluLUTTPGCoder.cc.

References hgcalPerformanceValidation::df, getLUTId(), mps_fire::i, and inputLUT_.

Referenced by HcalTriggerPrimitiveAlgo::addUpgradeTDCFG().

                                                                                       {
  int lutId = getLUTId(HcalDetId(df.id()));
  const Lut& lut = inputLUT_.at(lutId);
  std::vector<unsigned short> group0LLPbits;
  group0LLPbits.reserve(df.samples());
  for (int i = 0; i < df.samples(); i++) {
    group0LLPbits.push_back((lut.at(df[i].adc()) >> 12) &
                            0xF);  // four bits (12-15) of LUT used to set 6 finegrain bits from uHTR
  }
  return group0LLPbits;
}

init()

void HcaluLUTTPGCoder::init	(	const HcalTopology *	top,
		const HcalTimeSlew *	delay
	)

Definition at line 73 of file HcaluLUTTPGCoder.cc.

References allLinear_, applyFixPCC_, bitToMask_, contain1TSHB_, contain1TSHE_, phase2TrackerDigitizer_cfi::delay, delay_, FG_HF_thresholds_, firstHBEta_, HcalTopology::firstHBRing(), firstHEEta_, HcalTopology::firstHERing(), firstHFEta_, HcalTopology::firstHFRing(), gain_, HcalBarrel, HcalEndcap, HcalForward, inputLUT_, lastHBEta_, HcalTopology::lastHBRing(), lastHEEta_, HcalTopology::lastHERing(), lastHFEta_, HcalTopology::lastHFRing(), linearLSB_QIE11_, linearLSB_QIE11Overlap_, linearLSB_QIE8_, LUTGenerationMode_, make_cosh_ieta_map(), HcalTopology::maxDepth(), maxDepthHB_, maxDepthHE_, maxDepthHF_, MaximumFractionalError, nFi_, nHBEta_, nHEEta_, nHFEta_, ped_, pulseCorr_, sizeHB_, sizeHE_, sizeHF_, and topo_.

Referenced by HcalTPGCoderULUT::buildCoder(), and HcaluLUTTPGCoder().

                                                                              {
  topo_ = top;
  delay_ = delay;
  LUTGenerationMode_ = true;
  FG_HF_thresholds_ = {0, 0};
  bitToMask_ = 0;
  allLinear_ = false;
  contain1TSHB_ = false;
  contain1TSHE_ = false;
  applyFixPCC_ = false;
  linearLSB_QIE8_ = 1.;
  linearLSB_QIE11_ = 1.;
  linearLSB_QIE11Overlap_ = 1.;
  pulseCorr_ = std::make_unique<HcalPulseContainmentManager>(MaximumFractionalError, false);
  firstHBEta_ = topo_->firstHBRing();
  lastHBEta_ = topo_->lastHBRing();
  nHBEta_ = (lastHBEta_ - firstHBEta_ + 1);
  maxDepthHB_ = topo_->maxDepth(HcalBarrel);
  sizeHB_ = 2 * nHBEta_ * nFi_ * maxDepthHB_;
  firstHEEta_ = topo_->firstHERing();
  lastHEEta_ = topo_->lastHERing();
  nHEEta_ = (lastHEEta_ - firstHEEta_ + 1);
  maxDepthHE_ = topo_->maxDepth(HcalEndcap);
  sizeHE_ = 2 * nHEEta_ * nFi_ * maxDepthHE_;
  firstHFEta_ = topo_->firstHFRing();
  lastHFEta_ = topo_->lastHFRing();
  nHFEta_ = (lastHFEta_ - firstHFEta_ + 1);
  maxDepthHF_ = topo_->maxDepth(HcalForward);
  sizeHF_ = 2 * nHFEta_ * nFi_ * maxDepthHF_;
  size_t nluts = (size_t)(sizeHB_ + sizeHE_ + sizeHF_ + 1);
  inputLUT_ = std::vector<HcaluLUTTPGCoder::Lut>(nluts);
  gain_ = std::vector<float>(nluts, 0.);
  ped_ = std::vector<float>(nluts, 0.);
  make_cosh_ieta_map();
}

lookupMSB() [1/3]

void HcaluLUTTPGCoder::lookupMSB	(	const HBHEDataFrame &	df,
		std::vector< bool > &	msb
	)		const

Definition at line 636 of file HcaluLUTTPGCoder.cc.

References hgcalPerformanceValidation::df, getMSB(), and mps_fire::i.

Referenced by HcalTriggerPrimitiveAlgo::addSignal().

                                                                                    {
  msb.resize(df.size());
  for (int i = 0; i < df.size(); ++i)
    msb[i] = getMSB(df.id(), df.sample(i).adc());
}

lookupMSB() [2/3]

void HcaluLUTTPGCoder::lookupMSB	(	const QIE10DataFrame &	df,
		std::vector< std::bitset< 2 >> &	msb
	)		const

Definition at line 648 of file HcaluLUTTPGCoder.cc.

References gpuClustering::adc, hgcalPerformanceValidation::df, getLUTId(), mps_fire::i, inputLUT_, QIE10_LUT_MSB0, and QIE10_LUT_MSB1.

                                                                                             {
  msb.resize(df.samples());
  int lutId = getLUTId(HcalDetId(df.id()));
  const Lut& lut = inputLUT_.at(lutId);
  for (int i = 0; i < df.samples(); ++i) {
    msb[i][0] = lut.at(df[i].adc()) & QIE10_LUT_MSB0;
    msb[i][1] = lut.at(df[i].adc()) & QIE10_LUT_MSB1;
  }
}

lookupMSB() [3/3]

void HcaluLUTTPGCoder::lookupMSB	(	const QIE11DataFrame &	df,
		std::vector< std::bitset< 2 >> &	msb
	)		const

Definition at line 658 of file HcaluLUTTPGCoder.cc.

References gpuClustering::adc, hgcalPerformanceValidation::df, getLUTId(), mps_fire::i, inputLUT_, QIE11_LUT_MSB0, and QIE11_LUT_MSB1.

                                                                                             {
  int lutId = getLUTId(HcalDetId(df.id()));
  const Lut& lut = inputLUT_.at(lutId);
  for (int i = 0; i < df.samples(); ++i) {
    msb[i][0] = lut.at(df[i].adc()) & QIE11_LUT_MSB0;
    msb[i][1] = lut.at(df[i].adc()) & QIE11_LUT_MSB1;
  }
}

make_cosh_ieta_map()

void HcaluLUTTPGCoder::make_cosh_ieta_map

(

void

)

Definition at line 306 of file HcaluLUTTPGCoder.cc.

References cosh_ieta_, cosh_ieta_28_HE_high_depths_, cosh_ieta_28_HE_low_depths_, cosh_ieta_29_HE_, HLT_2022v11_cff::eta1, HLT_2022v11_cff::eta2, HcalTopology::etaRange(), EnergyCorrector::etas, firstHFEta_, HcalEndcap, HcalForward, mps_fire::i, lastHFEta_, topo_, and HcalTrigTowerGeometry::towerEtaBounds().

Referenced by init(), and update().

                                              {
  cosh_ieta_ = std::vector<double>(lastHFEta_ + 1, -1.0);

  HcalTrigTowerGeometry triggeo(topo_);

  for (int i = 1; i <= firstHFEta_; ++i) {
    double eta_low = 0., eta_high = 0.;
    triggeo.towerEtaBounds(i, 0, eta_low, eta_high);
    cosh_ieta_[i] = cosh((eta_low + eta_high) / 2.);
  }
  for (int i = firstHFEta_; i <= lastHFEta_; ++i) {
    std::pair<double, double> etas = topo_->etaRange(HcalForward, i);
    double eta1 = etas.first;
    double eta2 = etas.second;
    cosh_ieta_[i] = cosh((eta1 + eta2) / 2.);
  }

  // trigger tower 28 in HE has a more complicated geometry
  std::pair<double, double> eta28 = topo_->etaRange(HcalEndcap, 28);
  std::pair<double, double> eta29 = topo_->etaRange(HcalEndcap, 29);
  cosh_ieta_29_HE_ = cosh((eta29.first + eta29.second) / 2.);
  cosh_ieta_28_HE_low_depths_ = cosh((eta28.first + eta28.second) / 2.);
  // for higher depths in ieta = 28, the trigger tower extends past
  // the ieta = 29 channels
  cosh_ieta_28_HE_high_depths_ = cosh((eta28.first + eta29.second) / 2.);
}

set1TSContainHB()

void HcaluLUTTPGCoder::set1TSContainHB ( bool  contain1TSHB )

inline

Definition at line 69 of file HcaluLUTTPGCoder.h.

References hcaltpdigi_cff::contain1TSHB, and contain1TSHB_.

Referenced by HcalTPGCoderULUT::buildCoder().

{ contain1TSHB_ = contain1TSHB; }

set1TSContainHE()

void HcaluLUTTPGCoder::set1TSContainHE ( bool  contain1TSHE )

inline

Definition at line 70 of file HcaluLUTTPGCoder.h.

References hcaltpdigi_cff::contain1TSHE, and contain1TSHE_.

Referenced by HcalTPGCoderULUT::buildCoder().

{ contain1TSHE_ = contain1TSHE; }

setAllLinear()

void HcaluLUTTPGCoder::setAllLinear ( bool  linear, double  lsb8, double  lsb11, double  lsb11overlap  )

inline

Definition at line 63 of file HcaluLUTTPGCoder.h.

References allLinear_, linear(), linearLSB_QIE11_, linearLSB_QIE11Overlap_, and linearLSB_QIE8_.

Referenced by HcalTPGCoderULUT::buildCoder().

                                                                                 {
    allLinear_ = linear;
    linearLSB_QIE8_ = lsb8;
    linearLSB_QIE11_ = lsb11;
    linearLSB_QIE11Overlap_ = lsb11overlap;
  };

setApplyFixPCC()

void HcaluLUTTPGCoder::setApplyFixPCC ( double  applyFixPCC )

inline

Definition at line 73 of file HcaluLUTTPGCoder.h.

References HBHEMethod0Parameters_cfi::applyFixPCC, and applyFixPCC_.

Referenced by HcalTPGCoderULUT::buildCoder().

{ applyFixPCC_ = applyFixPCC; }

setContainPhaseHB()

void HcaluLUTTPGCoder::setContainPhaseHB ( double  containPhaseNSHB )

inline

Definition at line 71 of file HcaluLUTTPGCoder.h.

References hcaltpdigi_cff::containPhaseNSHB, and containPhaseNSHB_.

Referenced by HcalTPGCoderULUT::buildCoder().

{ containPhaseNSHB_ = containPhaseNSHB; }

setContainPhaseHE()

void HcaluLUTTPGCoder::setContainPhaseHE ( double  containPhaseNSHE )

inline

Definition at line 72 of file HcaluLUTTPGCoder.h.

References hcaltpdigi_cff::containPhaseNSHE, and containPhaseNSHE_.

Referenced by HcalTPGCoderULUT::buildCoder().

{ containPhaseNSHE_ = containPhaseNSHE; }

setFGHFthresholds()

void HcaluLUTTPGCoder::setFGHFthresholds ( const std::vector< uint32_t > &  fgthresholds )

inline

Definition at line 61 of file HcaluLUTTPGCoder.h.

References FG_HF_thresholds_.

Referenced by HcalTPGCoderULUT::buildCoder().

{ FG_HF_thresholds_ = fgthresholds; };

setLUTGenerationMode()

void HcaluLUTTPGCoder::setLUTGenerationMode ( bool  gen )

inline

Definition at line 60 of file HcaluLUTTPGCoder.h.

References relval_steps::gen(), and LUTGenerationMode_.

Referenced by HcalTPGCoderULUT::buildCoder().

{ LUTGenerationMode_ = gen; };

setMaskBit()

void HcaluLUTTPGCoder::setMaskBit ( int  bit )

inline

Definition at line 62 of file HcaluLUTTPGCoder.h.

References bitToMask_.

Referenced by HcalTPGCoderULUT::buildCoder().

{ bitToMask_ = bit; };

setOverrideDBweightsAndFilterHB()

void HcaluLUTTPGCoder::setOverrideDBweightsAndFilterHB ( bool  overrideDBweightsAndFilterHB )

inline

Definition at line 74 of file HcaluLUTTPGCoder.h.

References hcaltpdigi_cff::overrideDBweightsAndFilterHB, and overrideDBweightsAndFilterHB_.

Referenced by HcalTPGCoderULUT::buildCoder().

                                                                          {
    overrideDBweightsAndFilterHB_ = overrideDBweightsAndFilterHB;
  }

setOverrideDBweightsAndFilterHE()

void HcaluLUTTPGCoder::setOverrideDBweightsAndFilterHE ( bool  overrideDBweightsAndFilterHE )

inline

Definition at line 77 of file HcaluLUTTPGCoder.h.

References hcaltpdigi_cff::overrideDBweightsAndFilterHE, and overrideDBweightsAndFilterHE_.

Referenced by HcalTPGCoderULUT::buildCoder().

                                                                          {
    overrideDBweightsAndFilterHE_ = overrideDBweightsAndFilterHE;
  }

update() [1/2]

void HcaluLUTTPGCoder::update

(

const HcalDbService &

conditions

)

Definition at line 333 of file HcaluLUTTPGCoder.cc.

References funct::abs(), gpuClustering::adc, adc2fC, HcalElectronicsMap::allElectronicsIdTrigger(), allLinear_, applyFixPCC_, cms::cuda::assert(), bitToMask_, AlignmentProducer_cff::calibrations, HcalQIECoder::charge(), submitPVValidationJobs::conditions, contain1TSHB_, contain1TSHE_, containPhaseNSHB_, containPhaseNSHE_, alignCSCRings::corr, castor_dqm_sourceclient-live_cfg::correctionPhaseNS, cosh_ieta(), cosh_ieta_, HcalTopology::dddConstants(), delay_, HcalDetId::depth(), FG_HF_thresholds_, PedestalClient_cfi::gain, gain_, HcalTPChannelParameter::getFGBitInfo(), HcalL1TriggerObject::getFlag(), HcalLutMetadatum::getLutGranularity(), getLUTId(), HcalL1TriggerObject::getPedestal(), HcalLutMetadatum::getRCalib(), HcalL1TriggerObject::getRespGain(), HcalChannelStatus::getValue(), DetId::Hcal, HcalBarrel, HcalEndcap, HcalForward, HcalDetId::ieta(), HcalDetId::ietaAbs(), INPUT_LUT_SIZE, inputLUT_, HcalDDDRecConstants::isPlan1(), HcalTopology::lastHBRing(), HcalTopology::lastHERing(), linearLSB_QIE11_, linearLSB_QIE11Overlap_, linearLSB_QIE8_, HcalElectronicsMap::lookupTrigger(), lsb_, LUTGenerationMode_, make_cosh_ieta_map(), SiStripPI::max, MaximumFractionalError, OccupancyTask_cfi::metadata, SiStripPI::min, or, overrideDBweightsAndFilterHB_, overrideDBweightsAndFilterHE_, ped_, pulseCorr_, QIE10, QIE10_LUT_BITMASK, QIE10_LUT_MSB0, QIE10_LUT_MSB1, QIE11, QIE11_LUT_BITMASK, QIE11_LUT_MSB0, QIE11_LUT_MSB1, QIE8, QIE8_LUT_BITMASK, SIZE, mps_update::status, HcalDetId::subdet(), topo_, HcalTopology::triggerMode(), HcalTopologyMode::TriggerMode_2018, HcalTopologyMode::TriggerMode_2018legacy, HcalTopologyMode::TriggerMode_2021, UPGRADE_LUT_SIZE, and HcalTopology::valid().

Referenced by progressbar.ProgressBar::__next__(), MatrixUtil.Matrix::__setitem__(), MatrixUtil.Steps::__setitem__(), HcalTPGCoderULUT::buildCoder(), dqm-mbProfile.Profile::finish(), progressbar.ProgressBar::finish(), and MatrixUtil.Steps::overwrite().

                                                             {
  const HcalLutMetadata* metadata = conditions.getHcalLutMetadata();
  assert(metadata != nullptr);
  float nominalgain_ = metadata->getNominalGain();

  pulseCorr_ = std::make_unique<HcalPulseContainmentManager>(MaximumFractionalError, applyFixPCC_);
  pulseCorr_->beginRun(&conditions, delay_);

  make_cosh_ieta_map();

  // Here we will determine if we are using new version of TPs (1TS)
  // i.e. are we using a new pulse filter scheme.
  const HcalElectronicsMap* emap = conditions.getHcalMapping();

  int lastHBRing = topo_->lastHBRing();
  int lastHERing = topo_->lastHERing();

  // First, determine if we should configure for the filter scheme
  // Check the tp version to make this determination
  bool foundHB = false;
  bool foundHE = false;
  bool newHBtp = false;
  bool newHEtp = false;
  std::vector<HcalElectronicsId> vIds = emap->allElectronicsIdTrigger();
  for (std::vector<HcalElectronicsId>::const_iterator eId = vIds.begin(); eId != vIds.end(); eId++) {
    // The first HB or HE id is enough to tell whether to use new scheme in HB or HE
    if (foundHB and foundHE)
      break;

    HcalTrigTowerDetId hcalTTDetId(emap->lookupTrigger(*eId));
    if (hcalTTDetId.null())
      continue;

    int aieta = abs(hcalTTDetId.ieta());

    // The absence of TT channels in the HcalTPChannelParameters
    // is intepreted as to not use the new filter
    int weight = -1.0;
    auto tpParam = conditions.getHcalTPChannelParameter(hcalTTDetId, false);
    if (tpParam)
      weight = tpParam->getauxi1();

    if (aieta <= lastHBRing) {
      foundHB = true;
      if (weight != -1.0)
        newHBtp = true;
    } else if (aieta > lastHBRing and aieta < lastHERing) {
      foundHE = true;
      if (weight != -1.0)
        newHEtp = true;
    }
  }

  for (const auto& id : metadata->getAllChannels()) {
    if (not(id.det() == DetId::Hcal and topo_->valid(id)))
      continue;

    HcalDetId cell(id);
    HcalSubdetector subdet = cell.subdet();

    if (subdet != HcalBarrel and subdet != HcalEndcap and subdet != HcalForward)
      continue;

    const HcalQIECoder* channelCoder = conditions.getHcalCoder(cell);
    const HcalQIEShape* shape = conditions.getHcalShape(cell);
    HcalCoderDb coder(*channelCoder, *shape);
    const HcalLutMetadatum* meta = metadata->getValues(cell);

    unsigned int mipMax = 0;
    unsigned int mipMin = 0;
    unsigned int bit12_energy =
        0;  // defaults for energy requirement for bits 12-15 are high / low to avoid FG bit 0-4 being set when not intended
    unsigned int bit13_energy = 0;
    unsigned int bit14_energy = 999;
    unsigned int bit15_energy = 999;

    bool is2018OrLater = topo_->triggerMode() >= HcalTopologyMode::TriggerMode_2018 or
                         topo_->triggerMode() == HcalTopologyMode::TriggerMode_2018legacy;
    if (is2018OrLater or topo_->dddConstants()->isPlan1(cell)) {
      const HcalTPChannelParameter* channelParameters = conditions.getHcalTPChannelParameter(cell);
      mipMax = channelParameters->getFGBitInfo() >> 16;
      mipMin = channelParameters->getFGBitInfo() & 0xFFFF;
      bit12_energy = 16;  // depths 1,2 max energy
      bit13_energy = 80;  // depths 3+ min energy
      bit14_energy = 64;  // prompt min energy
      bit15_energy = 64;  // delayed min energy
    }

    int lutId = getLUTId(cell);
    Lut& lut = inputLUT_[lutId];
    float ped = 0;
    float gain = 0;
    uint32_t status = 0;

    if (LUTGenerationMode_) {
      const HcalCalibrations& calibrations = conditions.getHcalCalibrations(cell);
      for (auto capId : {0, 1, 2, 3}) {
        ped += calibrations.effpedestal(capId);
        gain += calibrations.LUTrespcorrgain(capId);
      }
      ped /= 4.0;
      gain /= 4.0;

      //Get Channel Quality
      const HcalChannelStatus* channelStatus = conditions.getHcalChannelStatus(cell);
      status = channelStatus->getValue();

    } else {
      const HcalL1TriggerObject* myL1TObj = conditions.getHcalL1TriggerObject(cell);
      ped = myL1TObj->getPedestal();
      gain = myL1TObj->getRespGain();
      status = myL1TObj->getFlag();
    }  // LUTGenerationMode_

    ped_[lutId] = ped;
    gain_[lutId] = gain;
    bool isMasked = ((status & bitToMask_) > 0);
    float rcalib = meta->getRCalib();

    auto adc2fC = [channelCoder, shape](unsigned int adc) {
      float fC = 0;
      for (auto capId : {0, 1, 2, 3})
        fC += channelCoder->charge(*shape, adc, capId);
      return fC / 4;
    };

    int qieType = conditions.getHcalQIEType(cell)->getValue();

    const size_t SIZE = qieType == QIE8 ? INPUT_LUT_SIZE : UPGRADE_LUT_SIZE;
    const int MASK = qieType == QIE8 ? QIE8_LUT_BITMASK : qieType == QIE10 ? QIE10_LUT_BITMASK : QIE11_LUT_BITMASK;
    double linearLSB = linearLSB_QIE8_;
    if (qieType == QIE11 and cell.ietaAbs() == topo_->lastHBRing())
      linearLSB = linearLSB_QIE11Overlap_;
    else if (qieType == QIE11)
      linearLSB = linearLSB_QIE11_;

    lut.resize(SIZE, 0);

    // Input LUT for HB/HE/HF
    if (subdet == HcalBarrel || subdet == HcalEndcap) {
      int granularity = meta->getLutGranularity();

      double correctionPhaseNS = conditions.getHcalRecoParam(cell)->correctionPhaseNS();

      if (qieType == QIE11) {
        if (overrideDBweightsAndFilterHB_ and cell.ietaAbs() <= lastHBRing)
          correctionPhaseNS = containPhaseNSHB_;
        else if (overrideDBweightsAndFilterHE_ and cell.ietaAbs() > lastHBRing)
          correctionPhaseNS = containPhaseNSHE_;
      }
      for (unsigned int adc = 0; adc < SIZE; ++adc) {
        if (isMasked)
          lut[adc] = 0;
        else {
          double nonlinearityCorrection = 1.0;
          double containmentCorrection = 1.0;
          // SiPM nonlinearity was not corrected in 2017
          // and containment corrections  were not
          // ET-dependent prior to 2018
          if (is2018OrLater) {
            double containmentCorrection1TS = pulseCorr_->correction(cell, 1, correctionPhaseNS, adc2fC(adc));
            // Use the 1-TS containment correction to estimate the charge of the pulse
            // from the individual samples
            double correctedCharge = containmentCorrection1TS * adc2fC(adc);
            double containmentCorrection2TSCorrected =
                pulseCorr_->correction(cell, 2, correctionPhaseNS, correctedCharge);
            if (qieType == QIE11) {
              // When contain1TS_ is set, it should still only apply for QIE11-related things
              if ((((contain1TSHB_ and overrideDBweightsAndFilterHB_) or newHBtp) and cell.ietaAbs() <= lastHBRing) or
                  (((contain1TSHE_ and overrideDBweightsAndFilterHE_) or newHEtp) and cell.ietaAbs() > lastHBRing)) {
                containmentCorrection = containmentCorrection1TS;
              } else {
                containmentCorrection = containmentCorrection2TSCorrected;
              }

              const HcalSiPMParameter& siPMParameter(*conditions.getHcalSiPMParameter(cell));
              HcalSiPMnonlinearity corr(
                  conditions.getHcalSiPMCharacteristics()->getNonLinearities(siPMParameter.getType()));
              const double fcByPE = siPMParameter.getFCByPE();
              const double effectivePixelsFired = correctedCharge / fcByPE;
              nonlinearityCorrection = corr.getRecoCorrectionFactor(effectivePixelsFired);
            } else {
              containmentCorrection = containmentCorrection2TSCorrected;
            }
          }
          if (allLinear_)
            lut[adc] = (LutElement)std::min(
                std::max(0,
                         int((adc2fC(adc) - ped) * gain * rcalib * nonlinearityCorrection * containmentCorrection /
                             linearLSB / cosh_ieta(cell.ietaAbs(), cell.depth(), HcalEndcap))),
                MASK);
          else
            lut[adc] = (LutElement)std::min(std::max(0,
                                                     int((adc2fC(adc) - ped) * gain * rcalib * nonlinearityCorrection *
                                                         containmentCorrection / nominalgain_ / granularity)),
                                            MASK);

          unsigned int linearizedADC =
              lut[adc];  // used for bits 12, 13, 14, 15 for Group 0 LUT for LLP time and depth bits that rely on linearized energies

          if (qieType == QIE11) {
            if ((linearizedADC < bit12_energy and cell.depth() <= 2) or (cell.depth() >= 3))
              lut[adc] |= 1 << 12;
            if (linearizedADC >= bit13_energy and cell.depth() >= 3)
              lut[adc] |= 1 << 13;
            if (linearizedADC >= bit14_energy)
              lut[adc] |= 1 << 14;
            if (linearizedADC >= bit15_energy)
              lut[adc] |= 1 << 15;
            if (adc >= mipMin and adc < mipMax)
              lut[adc] |= QIE11_LUT_MSB0;
            else if (adc >= mipMax)
              lut[adc] |= QIE11_LUT_MSB1;
          }

          //Zeroing the 4th depth in the trigger towers where |ieta| = 16 to match the behavior in the uHTR firmware in Run3, where the 4th depth is not included in the sum over depths when constructing the TP energy for this tower.
          if (abs(cell.ieta()) == 16 && cell.depth() == 4 &&
              topo_->triggerMode() >= HcalTopologyMode::TriggerMode_2021) {
            lut[adc] = 0;
          }
        }
      }
    } else if (subdet == HcalForward) {
      for (unsigned int adc = 0; adc < SIZE; ++adc) {
        if (isMasked)
          lut[adc] = 0;
        else {
          lut[adc] =
              std::min(std::max(0, int((adc2fC(adc) - ped) * gain * rcalib / lsb_ / cosh_ieta_[cell.ietaAbs()])), MASK);
          if (adc > FG_HF_thresholds_[0])
            lut[adc] |= QIE10_LUT_MSB0;
          if (adc > FG_HF_thresholds_[1])
            lut[adc] |= QIE10_LUT_MSB1;
        }
      }
    }
  }
}

update() [2/2]

void HcaluLUTTPGCoder::update	(	const char *	filename,
		bool	appendMSB = false
	)

Definition at line 152 of file HcaluLUTTPGCoder.cc.

References gpuClustering::adc, cms::cuda::assert(), edmScanValgrind::buffer, LEDCalibrationChannels::depth, geometryDiff::file, corrVsCorr::filename, getLUTId(), HcalBarrel, HcalEndcap, HcalForward, mps_fire::i, triggerObjects_cff::id, LEDCalibrationChannels::ieta, recoMuon::in, INPUT_LUT_SIZE, inputLUT_, LEDCalibrationChannels::iphi, QIE8_LUT_BITMASK, QIE8_LUT_MSB, findQualityFiles::size, AlCaHLTBitMon_QueryRunRegistry::string, topo_, and HcalTopology::valid().

Referenced by progressbar.ProgressBar::__next__(), MatrixUtil.Matrix::__setitem__(), MatrixUtil.Steps::__setitem__(), dqm-mbProfile.Profile::finish(), progressbar.ProgressBar::finish(), and MatrixUtil.Steps::overwrite().

                                                                  {
  std::ifstream file(filename, std::ios::in);
  assert(file.is_open());

  std::vector<HcalSubdetector> subdet;
  std::string buffer;

  // Drop first (comment) line
  std::getline(file, buffer);
  std::getline(file, buffer);

  unsigned int index = buffer.find('H', 0);
  while (index < buffer.length()) {
    std::string subdetStr = buffer.substr(index, 2);
    if (subdetStr == "HB")
      subdet.push_back(HcalBarrel);
    else if (subdetStr == "HE")
      subdet.push_back(HcalEndcap);
    else if (subdetStr == "HF")
      subdet.push_back(HcalForward);
    //TODO Check subdet
    //else exception
    index += 2;
    index = buffer.find('H', index);
  }

  // Get upper/lower ranges for ieta/iphi/depth
  size_t nCol = subdet.size();
  assert(nCol > 0);

  std::vector<int> ietaU;
  std::vector<int> ietaL;
  std::vector<int> iphiU;
  std::vector<int> iphiL;
  std::vector<int> depU;
  std::vector<int> depL;
  std::vector<Lut> lutFromFile(nCol);
  LutElement lutValue;

  for (size_t i = 0; i < nCol; ++i) {
    int ieta;
    file >> ieta;
    ietaL.push_back(ieta);
  }

  for (size_t i = 0; i < nCol; ++i) {
    int ieta;
    file >> ieta;
    ietaU.push_back(ieta);
  }

  for (size_t i = 0; i < nCol; ++i) {
    int iphi;
    file >> iphi;
    iphiL.push_back(iphi);
  }

  for (size_t i = 0; i < nCol; ++i) {
    int iphi;
    file >> iphi;
    iphiU.push_back(iphi);
  }

  for (size_t i = 0; i < nCol; ++i) {
    int dep;
    file >> dep;
    depL.push_back(dep);
  }

  for (size_t i = 0; i < nCol; ++i) {
    int dep;
    file >> dep;
    depU.push_back(dep);
  }

  // Read Lut Entry
  for (size_t i = 0; file >> lutValue; i = (i + 1) % nCol) {
    lutFromFile[i].push_back(lutValue);
  }

  // Check lut size
  for (size_t i = 0; i < nCol; ++i)
    assert(lutFromFile[i].size() == INPUT_LUT_SIZE);

  for (size_t i = 0; i < nCol; ++i) {
    for (int ieta = ietaL[i]; ieta <= ietaU[i]; ++ieta) {
      for (int iphi = iphiL[i]; iphi <= iphiU[i]; ++iphi) {
        for (int depth = depL[i]; depth <= depU[i]; ++depth) {
          HcalDetId id(subdet[i], ieta, iphi, depth);
          if (!topo_->valid(id))
            continue;

          int lutId = getLUTId(id);
          for (size_t adc = 0; adc < INPUT_LUT_SIZE; ++adc) {
            if (appendMSB) {
              // Append FG bit LUT to MSB
              // MSB = Most Significant Bit = bit 10
              // Overwrite bit 10
              LutElement msb = (lutFromFile[i][adc] != 0 ? QIE8_LUT_MSB : 0);
              inputLUT_[lutId][adc] = (msb | (inputLUT_[lutId][adc] & QIE8_LUT_BITMASK));
            } else
              inputLUT_[lutId][adc] = lutFromFile[i][adc];
          }  // for adc
        }    // for depth
      }      // for iphi
    }        // for ieta
  }          // for nCol
}

updateXML()

void HcaluLUTTPGCoder::updateXML

(

const char *

filename

)

Definition at line 261 of file HcaluLUTTPGCoder.cc.

References LutXml::create_lut_map(), LEDCalibrationChannels::depth, Exception, corrVsCorr::filename, XMLProcessor::getInstance(), LutXml::getLutFast(), getLUTId(), HcalBarrel, HcalEndcap, HcalForward, mps_fire::i, LEDCalibrationChannels::ieta, INPUT_LUT_SIZE, inputLUT_, createfilelist::int, LEDCalibrationChannels::iphi, HcalDetId::kHcalDepthMask2, HcalDetId::kHcalEtaMask2, HcalDetId::kHcalPhiMask2, XMLProcessor::terminate(), topo_, and HcalTopology::valid().

Referenced by HcalTPGCoderULUT::buildCoder().

                                                     {
  LutXml* _xml = new LutXml(filename);
  _xml->create_lut_map();
  HcalSubdetector subdet[3] = {HcalBarrel, HcalEndcap, HcalForward};
  for (int ieta = -HcalDetId::kHcalEtaMask2; ieta <= (int)(HcalDetId::kHcalEtaMask2); ++ieta) {
    for (unsigned int iphi = 0; iphi <= HcalDetId::kHcalPhiMask2; ++iphi) {
      for (unsigned int depth = 1; depth < HcalDetId::kHcalDepthMask2; ++depth) {
        for (int isub = 0; isub < 3; ++isub) {
          HcalDetId detid(subdet[isub], ieta, iphi, depth);
          if (!topo_->valid(detid))
            continue;
          int id = getLUTId(subdet[isub], ieta, iphi, depth);
          std::vector<unsigned int>* lut = _xml->getLutFast(detid);
          if (lut == nullptr)
            throw cms::Exception("PROBLEM: No inputLUT_ in xml file for ") << detid << std::endl;
          if (lut->size() != INPUT_LUT_SIZE)
            throw cms::Exception("PROBLEM: Wrong inputLUT_ size in xml file for ") << detid << std::endl;
          for (unsigned int i = 0; i < INPUT_LUT_SIZE; ++i)
            inputLUT_[id][i] = (LutElement)lut->at(i);
        }
      }
    }
  }
  delete _xml;
  XMLProcessor::getInstance()->terminate();
}

Member Data Documentation

allLinear_

bool HcaluLUTTPGCoder::allLinear_

private

Definition at line 123 of file HcaluLUTTPGCoder.h.

Referenced by cosh_ieta(), init(), setAllLinear(), and update().

applyFixPCC_

bool HcaluLUTTPGCoder::applyFixPCC_

private

Definition at line 127 of file HcaluLUTTPGCoder.h.

Referenced by init(), setApplyFixPCC(), and update().

bitToMask_

int HcaluLUTTPGCoder::bitToMask_

private

Definition at line 113 of file HcaluLUTTPGCoder.h.

Referenced by init(), setMaskBit(), and update().

contain1TSHB_

bool HcaluLUTTPGCoder::contain1TSHB_

private

Definition at line 124 of file HcaluLUTTPGCoder.h.

Referenced by init(), set1TSContainHB(), and update().

contain1TSHE_

bool HcaluLUTTPGCoder::contain1TSHE_

private

Definition at line 124 of file HcaluLUTTPGCoder.h.

Referenced by init(), set1TSContainHE(), and update().

containPhaseNSHB_

double HcaluLUTTPGCoder::containPhaseNSHB_ = 6.0

private

Definition at line 125 of file HcaluLUTTPGCoder.h.

Referenced by setContainPhaseHB(), and update().

containPhaseNSHE_

double HcaluLUTTPGCoder::containPhaseNSHE_ = 6.0

private

Definition at line 126 of file HcaluLUTTPGCoder.h.

Referenced by setContainPhaseHE(), and update().

cosh_ieta_

std::vector<double> HcaluLUTTPGCoder::cosh_ieta_

private

Definition at line 120 of file HcaluLUTTPGCoder.h.

Referenced by cosh_ieta(), make_cosh_ieta_map(), and update().

cosh_ieta_28_HE_high_depths_

double HcaluLUTTPGCoder::cosh_ieta_28_HE_high_depths_

private

Definition at line 122 of file HcaluLUTTPGCoder.h.

Referenced by cosh_ieta(), and make_cosh_ieta_map().

cosh_ieta_28_HE_low_depths_

double HcaluLUTTPGCoder::cosh_ieta_28_HE_low_depths_

private

Definition at line 122 of file HcaluLUTTPGCoder.h.

Referenced by cosh_ieta(), and make_cosh_ieta_map().

cosh_ieta_29_HE_

double HcaluLUTTPGCoder::cosh_ieta_29_HE_

private

Definition at line 122 of file HcaluLUTTPGCoder.h.

Referenced by cosh_ieta(), and make_cosh_ieta_map().

delay_

const HcalTimeSlew* HcaluLUTTPGCoder::delay_

private

Definition at line 110 of file HcaluLUTTPGCoder.h.

Referenced by init(), and update().

FG_HF_thresholds_

std::vector<uint32_t> HcaluLUTTPGCoder::FG_HF_thresholds_

private

Definition at line 112 of file HcaluLUTTPGCoder.h.

Referenced by init(), setFGHFthresholds(), and update().

firstHBEta_

int HcaluLUTTPGCoder::firstHBEta_

private

Definition at line 114 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and init().

firstHEEta_

int HcaluLUTTPGCoder::firstHEEta_

private

Definition at line 115 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and init().

firstHFEta_

int HcaluLUTTPGCoder::firstHFEta_

private

Definition at line 116 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), init(), and make_cosh_ieta_map().

gain_

std::vector<float> HcaluLUTTPGCoder::gain_

private

Definition at line 118 of file HcaluLUTTPGCoder.h.

Referenced by getLUTGain(), init(), and update().

INPUT_LUT_SIZE

const size_t HcaluLUTTPGCoder::INPUT_LUT_SIZE = 128

staticprivate

Definition at line 98 of file HcaluLUTTPGCoder.h.

Referenced by update(), and updateXML().

inputLUT_

std::vector<Lut> HcaluLUTTPGCoder::inputLUT_

private

Definition at line 117 of file HcaluLUTTPGCoder.h.

Referenced by adc2Linear(), getLinearizationLUT(), getMSB(), group0FGbits(), init(), lookupMSB(), update(), and updateXML().

lastHBEta_

int HcaluLUTTPGCoder::lastHBEta_

private

Definition at line 114 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and init().

lastHEEta_

int HcaluLUTTPGCoder::lastHEEta_

private

Definition at line 115 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and init().

lastHFEta_

int HcaluLUTTPGCoder::lastHFEta_

private

Definition at line 116 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), init(), and make_cosh_ieta_map().

linearLSB_QIE11_

double HcaluLUTTPGCoder::linearLSB_QIE11_

private

Definition at line 128 of file HcaluLUTTPGCoder.h.

Referenced by init(), setAllLinear(), and update().

linearLSB_QIE11Overlap_

double HcaluLUTTPGCoder::linearLSB_QIE11Overlap_

private

Definition at line 128 of file HcaluLUTTPGCoder.h.

Referenced by init(), setAllLinear(), and update().

linearLSB_QIE8_

double HcaluLUTTPGCoder::linearLSB_QIE8_

private

Definition at line 128 of file HcaluLUTTPGCoder.h.

Referenced by init(), setAllLinear(), and update().

lsb_

const float HcaluLUTTPGCoder::lsb_ = 1. / 16

static

Definition at line 34 of file HcaluLUTTPGCoder.h.

Referenced by CaloTPGTranscoderULUT::setup(), and update().

LUTGenerationMode_

bool HcaluLUTTPGCoder::LUTGenerationMode_

private

Definition at line 111 of file HcaluLUTTPGCoder.h.

Referenced by init(), setLUTGenerationMode(), and update().

maxDepthHB_

int HcaluLUTTPGCoder::maxDepthHB_

private

Definition at line 114 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and init().

maxDepthHE_

int HcaluLUTTPGCoder::maxDepthHE_

private

Definition at line 115 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and init().

maxDepthHF_

int HcaluLUTTPGCoder::maxDepthHF_

private

Definition at line 116 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and init().

nFi_

const int HcaluLUTTPGCoder::nFi_ = 72

staticprivate

Definition at line 100 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and init().

nHBEta_

int HcaluLUTTPGCoder::nHBEta_

private

Definition at line 114 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and init().

nHEEta_

int HcaluLUTTPGCoder::nHEEta_

private

Definition at line 115 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and init().

nHFEta_

int HcaluLUTTPGCoder::nHFEta_

private

Definition at line 116 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and init().

overrideDBweightsAndFilterHB_

bool HcaluLUTTPGCoder::overrideDBweightsAndFilterHB_ = false

private

Definition at line 130 of file HcaluLUTTPGCoder.h.

Referenced by setOverrideDBweightsAndFilterHB(), and update().

overrideDBweightsAndFilterHE_

bool HcaluLUTTPGCoder::overrideDBweightsAndFilterHE_ = false

private

Definition at line 131 of file HcaluLUTTPGCoder.h.

Referenced by setOverrideDBweightsAndFilterHE(), and update().

ped_

std::vector<float> HcaluLUTTPGCoder::ped_

private

Definition at line 119 of file HcaluLUTTPGCoder.h.

Referenced by getLUTPedestal(), init(), and update().

pulseCorr_

std::unique_ptr<HcalPulseContainmentManager> HcaluLUTTPGCoder::pulseCorr_

private

Definition at line 129 of file HcaluLUTTPGCoder.h.

Referenced by init(), and update().

QIE10_LUT_BITMASK

const int HcaluLUTTPGCoder::QIE10_LUT_BITMASK = 0x7FF

static

Definition at line 89 of file HcaluLUTTPGCoder.h.

Referenced by adc2Linear(), and update().

QIE10_LUT_MSB0

const int HcaluLUTTPGCoder::QIE10_LUT_MSB0 = 0x1000

staticprivate

Definition at line 105 of file HcaluLUTTPGCoder.h.

Referenced by lookupMSB(), and update().

QIE10_LUT_MSB1

const int HcaluLUTTPGCoder::QIE10_LUT_MSB1 = 0x2000

staticprivate

Definition at line 106 of file HcaluLUTTPGCoder.h.

Referenced by lookupMSB(), and update().

QIE11_LUT_BITMASK

const int HcaluLUTTPGCoder::QIE11_LUT_BITMASK = 0x3FF

static

Definition at line 90 of file HcaluLUTTPGCoder.h.

Referenced by adc2Linear(), and update().

QIE11_LUT_MSB0

const int HcaluLUTTPGCoder::QIE11_LUT_MSB0 = 0x400

staticprivate

Definition at line 103 of file HcaluLUTTPGCoder.h.

Referenced by lookupMSB(), and update().

QIE11_LUT_MSB1

const int HcaluLUTTPGCoder::QIE11_LUT_MSB1 = 0x800

staticprivate

Definition at line 104 of file HcaluLUTTPGCoder.h.

Referenced by lookupMSB(), and update().

QIE8_LUT_BITMASK

const int HcaluLUTTPGCoder::QIE8_LUT_BITMASK = 0x3FF

static

Definition at line 88 of file HcaluLUTTPGCoder.h.

Referenced by adc2Linear(), and update().

QIE8_LUT_MSB

const int HcaluLUTTPGCoder::QIE8_LUT_MSB = 0x400

staticprivate

Definition at line 102 of file HcaluLUTTPGCoder.h.

Referenced by getMSB(), and update().

sizeHB_

int HcaluLUTTPGCoder::sizeHB_

private

Definition at line 114 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and init().

sizeHE_

int HcaluLUTTPGCoder::sizeHE_

private

Definition at line 115 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and init().

sizeHF_

int HcaluLUTTPGCoder::sizeHF_

private

Definition at line 116 of file HcaluLUTTPGCoder.h.

Referenced by init().

topo_

const HcalTopology* HcaluLUTTPGCoder::topo_

private

Definition at line 109 of file HcaluLUTTPGCoder.h.

Referenced by init(), make_cosh_ieta_map(), update(), and updateXML().

UPGRADE_LUT_SIZE

const size_t HcaluLUTTPGCoder::UPGRADE_LUT_SIZE = 256

staticprivate

Definition at line 99 of file HcaluLUTTPGCoder.h.

Referenced by update().