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
	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	setAllLinear (bool linear, double lsb8, double lsb11, double lsb11overlap)
void	setFGHFthresholds (const std::vector< uint32_t > &fgthresholds)
void	setLUTGenerationMode (bool gen)
void	setMaskBit (int bit)
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_
int	bitToMask_
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_
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

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

private

Definition at line 83 of file HcaluLUTTPGCoder.h.

typedef unsigned short HcaluLUTTPGCoder::LutElement

private

Definition at line 82 of file HcaluLUTTPGCoder.h.

Constructor & Destructor Documentation

HcaluLUTTPGCoder::HcaluLUTTPGCoder

(

)

Definition at line 40 of file HcaluLUTTPGCoder.cc.

References allLinear_, bitToMask_, cosh_ieta_28_HE_high_depths_, cosh_ieta_28_HE_low_depths_, cosh_ieta_29_HE_, delay_, FG_HF_thresholds_, firstHBEta_, firstHEEta_, firstHFEta_, lastHBEta_, lastHEEta_, lastHFEta_, linearLSB_QIE11_, linearLSB_QIE11Overlap_, linearLSB_QIE8_, LUTGenerationMode_, maxDepthHB_, maxDepthHE_, maxDepthHF_, nHBEta_, nHEEta_, nHFEta_, sizeHB_, sizeHE_, and sizeHF_.

    : 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_{},
      linearLSB_QIE8_{},
      linearLSB_QIE11_{},
      linearLSB_QIE11Overlap_{} {}

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

Definition at line 69 of file HcaluLUTTPGCoder.cc.

References init().

{ init(top, delay); }

HcaluLUTTPGCoder::~HcaluLUTTPGCoder ( )

override

Definition at line 110 of file HcaluLUTTPGCoder.cc.

{}

Member Function Documentation

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

overridevirtual

Implements HcalTPGCoder.

Definition at line 480 of file HcaluLUTTPGCoder.cc.

References ecalMGPA::adc(), getLUTId(), mps_fire::i, HBHEDataFrame::id(), inputLUT_, QIE8_LUT_BITMASK, and HBHEDataFrame::size().

Referenced by HcalTriggerPrimitiveAlgo::addSignal().

                                                                                        {
  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);
  }
}

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

overridevirtual

Implements HcalTPGCoder.

Definition at line 488 of file HcaluLUTTPGCoder.cc.

References ecalMGPA::adc(), getLUTId(), mps_fire::i, HFDataFrame::id(), inputLUT_, QIE8_LUT_BITMASK, and HFDataFrame::size().

                                                                                      {
  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);
  }
}

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

overridevirtual

Implements HcalTPGCoder.

Definition at line 496 of file HcaluLUTTPGCoder.cc.

References ecalMGPA::adc(), getLUTId(), mps_fire::i, QIE10DataFrame::id(), inputLUT_, QIE10_LUT_BITMASK, and QIE10DataFrame::samples().

                                                                                         {
  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);
  }
}

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

overridevirtual

Implements HcalTPGCoder.

Definition at line 504 of file HcaluLUTTPGCoder.cc.

References ecalMGPA::adc(), getLUTId(), mps_fire::i, QIE11DataFrame::id(), inputLUT_, QIE11_LUT_BITMASK, and QIE11DataFrame::samples().

                                                                                         {
  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);
  }
}

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

overridevirtual

Implements HcalTPGCoder.

Definition at line 512 of file HcaluLUTTPGCoder.cc.

References HcalQIESample::adc(), getLUTId(), inputLUT_, and QIE8_LUT_BITMASK.

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

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

overridevirtual

Implements HcalTPGCoder.

Definition at line 104 of file HcaluLUTTPGCoder.cc.

References Exception.

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

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

Definition at line 283 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_, 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];
}

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 527 of file HcaluLUTTPGCoder.cc.

References getLUTId(), and inputLUT_.

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

float HcaluLUTTPGCoder::getLUTGain ( HcalDetId  id ) const

overridevirtual

Implements HcalTPGCoder.

Definition at line 522 of file HcaluLUTTPGCoder.cc.

References gain_, and getLUTId().

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

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

Definition at line 112 of file HcaluLUTTPGCoder.cc.

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

Referenced by adc2Linear(), getLinearizationLUT(), getLUTGain(), getLUTId(), getLUTPedestal(), getMSB(), lookupMSB(), setAllLinear(), 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;
}

int HcaluLUTTPGCoder::getLUTId

(

uint32_t

rawid

)

const

Definition at line 138 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());
}

int HcaluLUTTPGCoder::getLUTId

(

const HcalDetId &

detid

)

const

Definition at line 143 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());
}

float HcaluLUTTPGCoder::getLUTPedestal ( HcalDetId  id ) const

overridevirtual

Implements HcalTPGCoder.

Definition at line 517 of file HcaluLUTTPGCoder.cc.

References getLUTId(), and ped_.

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

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

Definition at line 538 of file HcaluLUTTPGCoder.cc.

References getLUTId(), inputLUT_, and QIE8_LUT_MSB.

Referenced by lookupMSB(), and setAllLinear().

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

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

Definition at line 71 of file HcaluLUTTPGCoder.cc.

References allLinear_, bitToMask_, 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;
  linearLSB_QIE8_ = 1.;
  linearLSB_QIE11_ = 1.;
  linearLSB_QIE11Overlap_ = 1.;
  pulseCorr_ = std::make_unique<HcalPulseContainmentManager>(MaximumFractionalError);
  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();
}

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

Definition at line 532 of file HcaluLUTTPGCoder.cc.

References HcalQIESample::adc(), getMSB(), mps_fire::i, HBHEDataFrame::id(), HBHEDataFrame::sample(), and HBHEDataFrame::size().

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

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

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

Definition at line 544 of file HcaluLUTTPGCoder.cc.

References ecalMGPA::adc(), getLUTId(), mps_fire::i, QIE10DataFrame::id(), inputLUT_, QIE10_LUT_MSB0, QIE10_LUT_MSB1, and QIE10DataFrame::samples().

                                                                                             {
  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;
  }
}

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

Definition at line 554 of file HcaluLUTTPGCoder.cc.

References ecalMGPA::adc(), getLUTId(), mps_fire::i, QIE11DataFrame::id(), inputLUT_, QIE11_LUT_MSB0, QIE11_LUT_MSB1, and QIE11DataFrame::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()) & QIE11_LUT_MSB0;
    msb[i][1] = lut.at(df[i].adc()) & QIE11_LUT_MSB1;
  }
}

void HcaluLUTTPGCoder::make_cosh_ieta_map

(

void

)

Definition at line 301 of file HcaluLUTTPGCoder.cc.

References cosh_ieta_, cosh_ieta_28_HE_high_depths_, cosh_ieta_28_HE_low_depths_, cosh_ieta_29_HE_, HLT_2018_cff::eta1, HLT_2018_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.);
}

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

inline

Definition at line 62 of file HcaluLUTTPGCoder.h.

References ecalMGPA::adc(), allLinear_, LEDCalibrationChannels::depth, getLUTId(), getMSB(), LEDCalibrationChannels::ieta, LEDCalibrationChannels::iphi, linear(), linearLSB_QIE11_, linearLSB_QIE11Overlap_, linearLSB_QIE8_, and lookupMSB().

Referenced by HcalTPGCoderULUT::buildCoder().

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

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

inline

Definition at line 60 of file HcaluLUTTPGCoder.h.

References FG_HF_thresholds_.

Referenced by HcalTPGCoderULUT::buildCoder().

{ FG_HF_thresholds_ = fgthresholds; };

void HcaluLUTTPGCoder::setLUTGenerationMode ( bool  gen )

inline

Definition at line 59 of file HcaluLUTTPGCoder.h.

References relval_steps::gen(), and LUTGenerationMode_.

Referenced by HcalTPGCoderULUT::buildCoder().

{ LUTGenerationMode_ = gen; };

void HcaluLUTTPGCoder::setMaskBit ( int  bit )

inline

Definition at line 61 of file HcaluLUTTPGCoder.h.

References bitToMask_.

Referenced by HcalTPGCoderULUT::buildCoder().

{ bitToMask_ = bit; };

void HcaluLUTTPGCoder::update

(

const HcalDbService &

conditions

)

Definition at line 328 of file HcaluLUTTPGCoder.cc.

References ecalMGPA::adc(), hcaldqm::constants::adc2fC, allLinear_, bitToMask_, AlignmentProducer_cff::calibrations, HcalQIECoder::charge(), corr, HcalRecoParam::correctionPhaseNS(), castor_dqm_sourceclient-live_cfg::correctionPhaseNS, cosh_ieta(), cosh_ieta_, HcalTopology::dddConstants(), delay_, HcalDetId::depth(), HcalCalibrations::effpedestal(), FG_HF_thresholds_, PedestalClient_cfi::gain, gain_, HcalCondObjectContainer< Item >::getAllChannels(), HcalTPChannelParameter::getFGBitInfo(), HcalL1TriggerObject::getFlag(), HcalDbService::getHcalCalibrations(), HcalDbService::getHcalChannelStatus(), HcalDbService::getHcalCoder(), HcalDbService::getHcalL1TriggerObject(), HcalDbService::getHcalLutMetadata(), HcalDbService::getHcalQIEType(), HcalDbService::getHcalRecoParam(), HcalDbService::getHcalShape(), HcalDbService::getHcalSiPMCharacteristics(), HcalDbService::getHcalSiPMParameter(), HcalDbService::getHcalTPChannelParameter(), HcalLutMetadatum::getLutGranularity(), getLUTId(), HcalLutMetadata::getNominalGain(), HcalSiPMCharacteristics::getNonLinearities(), HcalL1TriggerObject::getPedestal(), HcalLutMetadatum::getRCalib(), HcalL1TriggerObject::getRespGain(), HcalQIEType::getValue(), HcalChannelStatus::getValue(), HcalCondObjectContainer< Item >::getValues(), DetId::Hcal, HcalBarrel, HcalEndcap, HcalForward, HcalDetId::ietaAbs(), INPUT_LUT_SIZE, inputLUT_, HcalDDDRecConstants::isPlan1(), HcalTopology::lastHBRing(), linearLSB_QIE11_, linearLSB_QIE11Overlap_, linearLSB_QIE8_, lsb_, LUTGenerationMode_, HcalCalibrations::LUTrespcorrgain(), make_cosh_ieta_map(), SiStripPI::max, min(), or, 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, UPGRADE_LUT_SIZE, and HcalTopology::valid().

Referenced by progressbar.ProgressBar::__next__(), MatrixUtil.Matrix::__setitem__(), MatrixUtil.Steps::__setitem__(), Vispa.Gui.VispaWidget.VispaWidget::autosize(), HcalTPGCoderULUT::buildCoder(), Vispa.Views.LineDecayView.LineDecayContainer::createObject(), Vispa.Views.LineDecayView.LineDecayContainer::deselectAllObjects(), Vispa.Gui.VispaWidgetOwner.VispaWidgetOwner::deselectAllWidgets(), Vispa.Gui.VispaWidget.VispaWidget::enableAutosizing(), dqm-mbProfile.Profile::finish(), progressbar.ProgressBar::finish(), Vispa.Gui.MenuWidget.MenuWidget::leaveEvent(), Vispa.Gui.VispaWidgetOwner.VispaWidgetOwner::mouseMoveEvent(), Vispa.Gui.MenuWidget.MenuWidget::mouseMoveEvent(), Vispa.Views.LineDecayView.LineDecayContainer::mouseMoveEvent(), Vispa.Gui.VispaWidgetOwner.VispaWidgetOwner::mouseReleaseEvent(), Vispa.Views.LineDecayView.LineDecayContainer::objectMoved(), MatrixUtil.Steps::overwrite(), Vispa.Views.LineDecayView.LineDecayContainer::removeObject(), Vispa.Gui.ConnectableWidget.ConnectableWidget::removePorts(), Vispa.Gui.FindDialog.FindDialog::reset(), Vispa.Gui.PortConnection.PointToPointConnection::select(), Vispa.Gui.VispaWidget.VispaWidget::select(), Vispa.Views.LineDecayView.LineDecayContainer::select(), Vispa.Gui.VispaWidget.VispaWidget::setText(), Vispa.Gui.VispaWidget.VispaWidget::setTitle(), Vispa.Gui.ZoomableWidget.ZoomableWidget::setZoom(), Vispa.Views.LineDecayView.LineDecayContainer::setZoom(), and Vispa.Gui.PortConnection.PointToPointConnection::updateConnection().

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

  pulseCorr_->beginRun(&conditions, delay_);

  make_cosh_ieta_map();

  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;

    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;
    }

    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();
      for (unsigned int adc = 0; adc < SIZE; ++adc) {
        if (isMasked)
          lut[adc] = 0;
        else {
          double nonlinearityCorrection = 1.0;
          double containmentCorrection2TSCorrected = 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);
            containmentCorrection2TSCorrected = pulseCorr_->correction(cell, 2, correctionPhaseNS, correctedCharge);
            if (qieType == QIE11) {
              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);
            }
          }
          if (allLinear_)
            lut[adc] = (LutElement)std::min(std::max(0,
                                                     int((adc2fC(adc) - ped) * gain * rcalib * nonlinearityCorrection *
                                                         containmentCorrection2TSCorrected / 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 *
                                                  containmentCorrection2TSCorrected / nominalgain_ / granularity)),
                                     MASK);

          if (qieType == QIE11) {
            if (adc >= mipMin and adc < mipMax)
              lut[adc] |= QIE11_LUT_MSB0;
            else if (adc >= mipMax)
              lut[adc] |= QIE11_LUT_MSB1;
          }
        }
      }
    } 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;
        }
      }
    }
  }
}

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

Definition at line 147 of file HcaluLUTTPGCoder.cc.

References ecalMGPA::adc(), edmScanValgrind::buffer, LEDCalibrationChannels::depth, FrontierConditions_GlobalTag_cff::file, 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__(), Vispa.Gui.VispaWidget.VispaWidget::autosize(), Vispa.Views.LineDecayView.LineDecayContainer::createObject(), Vispa.Views.LineDecayView.LineDecayContainer::deselectAllObjects(), Vispa.Gui.VispaWidgetOwner.VispaWidgetOwner::deselectAllWidgets(), Vispa.Gui.VispaWidget.VispaWidget::enableAutosizing(), dqm-mbProfile.Profile::finish(), progressbar.ProgressBar::finish(), Vispa.Gui.MenuWidget.MenuWidget::leaveEvent(), Vispa.Gui.VispaWidgetOwner.VispaWidgetOwner::mouseMoveEvent(), Vispa.Gui.MenuWidget.MenuWidget::mouseMoveEvent(), Vispa.Views.LineDecayView.LineDecayContainer::mouseMoveEvent(), Vispa.Gui.VispaWidgetOwner.VispaWidgetOwner::mouseReleaseEvent(), Vispa.Views.LineDecayView.LineDecayContainer::objectMoved(), MatrixUtil.Steps::overwrite(), Vispa.Views.LineDecayView.LineDecayContainer::removeObject(), Vispa.Gui.ConnectableWidget.ConnectableWidget::removePorts(), Vispa.Gui.FindDialog.FindDialog::reset(), Vispa.Gui.PortConnection.PointToPointConnection::select(), Vispa.Gui.VispaWidget.VispaWidget::select(), Vispa.Views.LineDecayView.LineDecayContainer::select(), Vispa.Gui.VispaWidget.VispaWidget::setText(), Vispa.Gui.VispaWidget.VispaWidget::setTitle(), Vispa.Gui.ZoomableWidget.ZoomableWidget::setZoom(), Vispa.Views.LineDecayView.LineDecayContainer::setZoom(), and Vispa.Gui.PortConnection.PointToPointConnection::updateConnection().

                                                                  {
  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
}

void HcaluLUTTPGCoder::updateXML

(

const char *

filename

)

Definition at line 256 of file HcaluLUTTPGCoder.cc.

References LutXml::create_lut_map(), LEDCalibrationChannels::depth, Exception, 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

bool HcaluLUTTPGCoder::allLinear_

private

Definition at line 111 of file HcaluLUTTPGCoder.h.

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

int HcaluLUTTPGCoder::bitToMask_

private

Definition at line 101 of file HcaluLUTTPGCoder.h.

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

std::vector<double> HcaluLUTTPGCoder::cosh_ieta_

private

Definition at line 108 of file HcaluLUTTPGCoder.h.

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

double HcaluLUTTPGCoder::cosh_ieta_28_HE_high_depths_

private

Definition at line 110 of file HcaluLUTTPGCoder.h.

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

double HcaluLUTTPGCoder::cosh_ieta_28_HE_low_depths_

private

Definition at line 110 of file HcaluLUTTPGCoder.h.

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

double HcaluLUTTPGCoder::cosh_ieta_29_HE_

private

Definition at line 110 of file HcaluLUTTPGCoder.h.

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

const HcalTimeSlew* HcaluLUTTPGCoder::delay_

private

Definition at line 98 of file HcaluLUTTPGCoder.h.

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

std::vector<uint32_t> HcaluLUTTPGCoder::FG_HF_thresholds_

private

Definition at line 100 of file HcaluLUTTPGCoder.h.

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

int HcaluLUTTPGCoder::firstHBEta_

private

Definition at line 102 of file HcaluLUTTPGCoder.h.

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

int HcaluLUTTPGCoder::firstHEEta_

private

Definition at line 103 of file HcaluLUTTPGCoder.h.

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

int HcaluLUTTPGCoder::firstHFEta_

private

Definition at line 104 of file HcaluLUTTPGCoder.h.

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

std::vector<float> HcaluLUTTPGCoder::gain_

private

Definition at line 106 of file HcaluLUTTPGCoder.h.

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

const size_t HcaluLUTTPGCoder::INPUT_LUT_SIZE = 128

staticprivate

Definition at line 86 of file HcaluLUTTPGCoder.h.

Referenced by update(), and updateXML().

std::vector<Lut> HcaluLUTTPGCoder::inputLUT_

private

Definition at line 105 of file HcaluLUTTPGCoder.h.

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

int HcaluLUTTPGCoder::lastHBEta_

private

Definition at line 102 of file HcaluLUTTPGCoder.h.

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

int HcaluLUTTPGCoder::lastHEEta_

private

Definition at line 103 of file HcaluLUTTPGCoder.h.

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

int HcaluLUTTPGCoder::lastHFEta_

private

Definition at line 104 of file HcaluLUTTPGCoder.h.

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

double HcaluLUTTPGCoder::linearLSB_QIE11_

private

Definition at line 112 of file HcaluLUTTPGCoder.h.

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

double HcaluLUTTPGCoder::linearLSB_QIE11Overlap_

private

Definition at line 112 of file HcaluLUTTPGCoder.h.

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

double HcaluLUTTPGCoder::linearLSB_QIE8_

private

Definition at line 112 of file HcaluLUTTPGCoder.h.

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

const float HcaluLUTTPGCoder::lsb_ = 1. / 16

static

Definition at line 34 of file HcaluLUTTPGCoder.h.

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

bool HcaluLUTTPGCoder::LUTGenerationMode_

private

Definition at line 99 of file HcaluLUTTPGCoder.h.

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

int HcaluLUTTPGCoder::maxDepthHB_

private

Definition at line 102 of file HcaluLUTTPGCoder.h.

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

int HcaluLUTTPGCoder::maxDepthHE_

private

Definition at line 103 of file HcaluLUTTPGCoder.h.

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

int HcaluLUTTPGCoder::maxDepthHF_

private

Definition at line 104 of file HcaluLUTTPGCoder.h.

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

const int HcaluLUTTPGCoder::nFi_ = 72

staticprivate

Definition at line 88 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and init().

int HcaluLUTTPGCoder::nHBEta_

private

Definition at line 102 of file HcaluLUTTPGCoder.h.

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

int HcaluLUTTPGCoder::nHEEta_

private

Definition at line 103 of file HcaluLUTTPGCoder.h.

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

int HcaluLUTTPGCoder::nHFEta_

private

Definition at line 104 of file HcaluLUTTPGCoder.h.

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

std::vector<float> HcaluLUTTPGCoder::ped_

private

Definition at line 107 of file HcaluLUTTPGCoder.h.

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

std::unique_ptr<HcalPulseContainmentManager> HcaluLUTTPGCoder::pulseCorr_

private

Definition at line 113 of file HcaluLUTTPGCoder.h.

Referenced by init(), and update().

const int HcaluLUTTPGCoder::QIE10_LUT_BITMASK = 0x7FF

static

Definition at line 77 of file HcaluLUTTPGCoder.h.

Referenced by adc2Linear(), and update().

const int HcaluLUTTPGCoder::QIE10_LUT_MSB0 = 0x1000

staticprivate

Definition at line 93 of file HcaluLUTTPGCoder.h.

Referenced by lookupMSB(), and update().

const int HcaluLUTTPGCoder::QIE10_LUT_MSB1 = 0x2000

staticprivate

Definition at line 94 of file HcaluLUTTPGCoder.h.

Referenced by lookupMSB(), and update().

const int HcaluLUTTPGCoder::QIE11_LUT_BITMASK = 0x3FF

static

Definition at line 78 of file HcaluLUTTPGCoder.h.

Referenced by adc2Linear(), and update().

const int HcaluLUTTPGCoder::QIE11_LUT_MSB0 = 0x400

staticprivate

Definition at line 91 of file HcaluLUTTPGCoder.h.

Referenced by lookupMSB(), and update().

const int HcaluLUTTPGCoder::QIE11_LUT_MSB1 = 0x800

staticprivate

Definition at line 92 of file HcaluLUTTPGCoder.h.

Referenced by lookupMSB(), and update().

const int HcaluLUTTPGCoder::QIE8_LUT_BITMASK = 0x3FF

static

Definition at line 76 of file HcaluLUTTPGCoder.h.

Referenced by adc2Linear(), and update().

const int HcaluLUTTPGCoder::QIE8_LUT_MSB = 0x400

staticprivate

Definition at line 90 of file HcaluLUTTPGCoder.h.

Referenced by getMSB(), and update().

int HcaluLUTTPGCoder::sizeHB_

private

Definition at line 102 of file HcaluLUTTPGCoder.h.

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

int HcaluLUTTPGCoder::sizeHE_

private

Definition at line 103 of file HcaluLUTTPGCoder.h.

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

int HcaluLUTTPGCoder::sizeHF_

private

Definition at line 104 of file HcaluLUTTPGCoder.h.

Referenced by HcaluLUTTPGCoder(), and init().

const HcalTopology* HcaluLUTTPGCoder::topo_

private

Definition at line 97 of file HcaluLUTTPGCoder.h.

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

const size_t HcaluLUTTPGCoder::UPGRADE_LUT_SIZE = 256

staticprivate

Definition at line 87 of file HcaluLUTTPGCoder.h.

Referenced by update().