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, bool ootpu_lut) 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...
std::vector< unsigned short >	getLinearizationLUT (HcalZDCDetId id, bool ootpu_lut) const override
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
int	getLUTId (const HcalZDCDetId &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	QIE10_ZDC_LUT_BITMASK = 0x3FF
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_
int	sizeZDC_
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 98 of file HcaluLUTTPGCoder.h.

LutElement

typedef unsigned short HcaluLUTTPGCoder::LutElement

private

Definition at line 97 of file HcaluLUTTPGCoder.h.

Constructor & Destructor Documentation

HcaluLUTTPGCoder() [1/2]

HcaluLUTTPGCoder::HcaluLUTTPGCoder

(

)

Definition at line 41 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_{},
      sizeZDC_{},
      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 74 of file HcaluLUTTPGCoder.cc.

References phase2TrackerDigitizer_cfi::delay, and init().

{ init(top, delay); }

~HcaluLUTTPGCoder()

HcaluLUTTPGCoder::~HcaluLUTTPGCoder ( )

override

Definition at line 119 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 682 of file HcaluLUTTPGCoder.cc.

References gpuClustering::adc, isotrackApplyRegressor::df, getLUTId(), mps_fire::i, unpacker2007h4_cff::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 690 of file HcaluLUTTPGCoder.cc.

References gpuClustering::adc, isotrackApplyRegressor::df, getLUTId(), mps_fire::i, unpacker2007h4_cff::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, bool  ootpu_lut  ) const

overridevirtual

Implements HcalTPGCoder.

Definition at line 698 of file HcaluLUTTPGCoder.cc.

References gpuClustering::adc, hcalRecHitTable_cff::detId, isotrackApplyRegressor::df, getLUTId(), DetId::Hcal, mps_fire::i, unpacker2007h4_cff::ics, inputLUT_, QIE10_LUT_BITMASK, QIE10_ZDC_LUT_BITMASK, and sizeZDC_.

                                                                                                         {
  DetId detId = DetId(df.detid());
  if (detId.det() == DetId::Hcal) {
    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);
    }
  } else {
    int lutId = getLUTId(HcalZDCDetId(df.id()));
    if (ootpu_lut)
      lutId = lutId + sizeZDC_;
    const Lut& lut = inputLUT_.at(lutId);
    for (int i = 0; i < df.samples(); i++) {
      ics[i] = (lut.at(df[i].adc()) & QIE10_ZDC_LUT_BITMASK);
    }
  }
}

adc2Linear() [4/5]

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

overridevirtual

Implements HcalTPGCoder.

Definition at line 717 of file HcaluLUTTPGCoder.cc.

References gpuClustering::adc, isotrackApplyRegressor::df, getLUTId(), mps_fire::i, unpacker2007h4_cff::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 725 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 113 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 313 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_, hcalRecHitTable_cff::depth, HcalEndcap, and hcalRecHitTable_cff::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() [1/2]

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

References getLUTId(), and inputLUT_.

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

getLinearizationLUT() [2/2]

std::vector< unsigned short > HcaluLUTTPGCoder::getLinearizationLUT ( HcalZDCDetId  id, bool  ootpu_lut  ) const

overridevirtual

Reimplemented from HcalTPGCoder.

Definition at line 757 of file HcaluLUTTPGCoder.cc.

References getLUTId(), inputLUT_, and sizeZDC_.

                                                                                                     {
  int lutId = getLUTId(id);
  if (ootpu_lut)
    return inputLUT_.at(lutId + sizeZDC_);
  else
    return inputLUT_.at(lutId);
}

getLUTGain()

float HcaluLUTTPGCoder::getLUTGain ( HcalDetId  id ) const

overridevirtual

Implements HcalTPGCoder.

Definition at line 747 of file HcaluLUTTPGCoder.cc.

References gain_, and getLUTId().

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

getLUTId() [1/4]

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

Definition at line 121 of file HcaluLUTTPGCoder.cc.

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

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_);
  } else if (id == HcalOther) {
    retval = sizeHB_ + sizeHE_ + sizeHF_;
    retval += depth;
    if (iphi != 1)
      retval += 5;
    if (ieta <= 0)
      retval += 9;
  }
  return retval;
}

getLUTId() [2/4]

int HcaluLUTTPGCoder::getLUTId

(

uint32_t

rawid

)

const

Definition at line 154 of file HcaluLUTTPGCoder.cc.

References ALCARECOPPSCalTrackBasedSel_cff::detid, and getLUTId().

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

getLUTId() [3/4]

int HcaluLUTTPGCoder::getLUTId

(

const HcalDetId &

detid

)

const

Definition at line 159 of file HcaluLUTTPGCoder.cc.

References ALCARECOPPSCalTrackBasedSel_cff::detid, and getLUTId().

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

getLUTId() [4/4]

int HcaluLUTTPGCoder::getLUTId

(

const HcalZDCDetId &

detid

)

const

Definition at line 163 of file HcaluLUTTPGCoder.cc.

References ALCARECOPPSCalTrackBasedSel_cff::detid, HcalZDCDetId::EM, getLUTId(), HcalZDCDetId::HAD, HcalOther, and HcalZDCDetId::LUM.

                                                              {
  if (detid.section() == HcalZDCDetId::EM) {
    return getLUTId(HcalOther, detid.zside(), 1, detid.channel());
  } else if (detid.section() == HcalZDCDetId::HAD) {
    return getLUTId(HcalOther, detid.zside(), 2, detid.channel());
  } else if (detid.section() == HcalZDCDetId::LUM) {
    return getLUTId(HcalOther, detid.zside(), 3, detid.channel());
  } else {
    return getLUTId(HcalOther, detid.zside(), 4, detid.channel());
  }
}

getLUTPedestal()

float HcaluLUTTPGCoder::getLUTPedestal ( HcalDetId  id ) const

overridevirtual

Implements HcalTPGCoder.

Definition at line 742 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 771 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 730 of file HcaluLUTTPGCoder.cc.

References isotrackApplyRegressor::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 76 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_, sizeZDC_, 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_;
  sizeZDC_ = 2 * 9;
  size_t nluts = (size_t)(sizeHB_ + sizeHE_ + sizeHF_ + sizeZDC_ * 2 + 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 765 of file HcaluLUTTPGCoder.cc.

References isotrackApplyRegressor::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 777 of file HcaluLUTTPGCoder.cc.

References gpuClustering::adc, isotrackApplyRegressor::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 787 of file HcaluLUTTPGCoder.cc.

References gpuClustering::adc, isotrackApplyRegressor::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 331 of file HcaluLUTTPGCoder.cc.

References cosh_ieta_, cosh_ieta_28_HE_high_depths_, cosh_ieta_28_HE_low_depths_, cosh_ieta_29_HE_, HLT_2024v14_cff::eta1, HLT_2024v14_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 70 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 71 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 64 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 74 of file HcaluLUTTPGCoder.h.

References Hcal_PCCUpdate_cff::applyFixPCC, and applyFixPCC_.

Referenced by HcalTPGCoderULUT::buildCoder().

{ applyFixPCC_ = applyFixPCC; }

setContainPhaseHB()

void HcaluLUTTPGCoder::setContainPhaseHB ( double  containPhaseNSHB )

inline

Definition at line 72 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 73 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 62 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 61 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 63 of file HcaluLUTTPGCoder.h.

References triggerObjects_cff::bit, and bitToMask_.

Referenced by HcalTPGCoderULUT::buildCoder().

{ bitToMask_ = bit; };

setOverrideDBweightsAndFilterHB()

void HcaluLUTTPGCoder::setOverrideDBweightsAndFilterHB ( bool  overrideDBweightsAndFilterHB )

inline

Definition at line 75 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 78 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 358 of file HcaluLUTTPGCoder.cc.

References funct::abs(), gpuClustering::adc, adc2fC, HcalElectronicsMap::allElectronicsIdTrigger(), allLinear_, applyFixPCC_, cms::cuda::assert(), bitToMask_, AlignmentProducer_cff::calibrations, DetId::Calo, HcalZDCDetId::channel(), HcalQIECoder::charge(), PixelBaryCentreAnalyzer_cfg::conditions, contain1TSHB_, contain1TSHE_, containPhaseNSHB_, containPhaseNSHE_, alignCSCRings::corr, ecalCosmicsHists_cfg::correctionPhaseNS, cosh_ieta(), cosh_ieta_, HcalTopology::dddConstants(), delay_, HcalDetId::depth(), HcalZDCDetId::EM, FG_HF_thresholds_, Hcal_Conditions_forGlobalTag_cff::gain, gain_, HcalL1TriggerObject::getFlag(), HcalLutMetadatum::getLutGranularity(), getLUTId(), HcalL1TriggerObject::getPedestal(), HcalLutMetadatum::getRCalib(), HcalL1TriggerObject::getRespGain(), HcalChannelStatus::getValue(), HcalPedestal::getWidth(), HcalZDCDetId::HAD, DetId::Hcal, HcalBarrel, HcalEndcap, HcalForward, HcalOther, 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(), WZElectronSkims53X_cff::max, MaximumFractionalError, OccupancyTask_cfi::metadata, SiStripPI::min, or, overrideDBweightsAndFilterHB_, overrideDBweightsAndFilterHE_, QIE10Task_cfi::ped, ped_, pulseCorr_, QIE10, QIE10_LUT_BITMASK, QIE10_LUT_MSB0, QIE10_LUT_MSB1, QIE10_ZDC_LUT_BITMASK, QIE11, QIE11_LUT_BITMASK, QIE8, QIE8_LUT_BITMASK, Hcal_Conditions_forGlobalTag_cff::qieType, nano_mu_digi_cff::rawId, HcalZDCDetId::section(), l1trig_cff::shape, SIZE, sizeZDC_, mps_update::status, HcalDetId::subdet(), HcalZDCDetId::SubdetectorId, topo_, HcalTopology::triggerMode(), HcalTopologyMode::TriggerMode_2018, HcalTopologyMode::TriggerMode_2018legacy, HcalTopologyMode::TriggerMode_2021, UPGRADE_LUT_SIZE, HcalTopology::valid(), and HcalZDCDetId::zside().

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 (id.det() == DetId::Hcal and topo_->valid(id)) {
      HcalDetId cell(id);
      HcalSubdetector subdet = cell.subdet();

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

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

      // defaults for energy requirement for bits 12-15 are high / low to avoid FG bit 0-4 being set when not intended
      unsigned int bit12_energy = 0;
      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)) {
        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 (subdet == HcalBarrel) {  // edit since bits 12-15 not supported in HE yet
                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;
              }
            }

            //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;
          }
        }
      }
    } else if (id.det() == DetId::Calo && id.subdetId() == HcalZDCDetId::SubdetectorId) {
      HcalZDCDetId cell(id.rawId());

      if (cell.section() != HcalZDCDetId::EM && cell.section() != HcalZDCDetId::HAD)
        continue;

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

      auto tpParam = conditions.getHcalTPChannelParameter(cell, false);
      const int weight = tpParam->getauxi1();
      int factorGeVPerCount = tpParam->getauxi2();
      if (factorGeVPerCount == 0) {
        edm::LogWarning("HcaluLUTTPGCoder")
            << "WARNING: ZDC trigger spacing factor, taken from auxi2 field of HCALTPChannelParameters for the cell "
               "with (zside, section, channel) =  ("
            << cell.zside() << " , " << cell.section() << " , " << cell.channel()
            << ") is set to the "
               "default value of 0, which is an incompatible value for a spacing factor. Setting the value to 50 and "
               "continuing.";
        factorGeVPerCount = 50;
      }

      const int lutId = getLUTId(cell);
      const int lutId_ootpu = lutId + sizeZDC_;
      Lut& lut = inputLUT_[lutId];
      Lut& lut_ootpu = inputLUT_[lutId_ootpu];
      float ped = 0;
      float gain = 0;
      float pedWidth = 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);
          pedWidth += effPedestals->getWidth(capId);
        }
        ped /= 4.0;
        gain /= 4.0;
        pedWidth /= 4.0;

        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 = QIE10_ZDC_LUT_BITMASK;

      lut.resize(SIZE, 0);
      lut_ootpu.resize(SIZE, 0);

      for (unsigned int adc = 0; adc < SIZE; ++adc) {
        if (isMasked) {
          lut[adc] = 0;
          lut_ootpu[adc] = 0;
        } else {
          if ((adc2fC(adc) - ped) < pedWidth) {
            lut[adc] = 0;
            lut_ootpu[adc] = 0;
          } else {
            auto lut_term = (adc2fC(adc) - ped) * gain * rcalib / factorGeVPerCount;
            lut[adc] = std::clamp(int(lut_term), 0, MASK);
            lut_ootpu[adc] = std::clamp(int(lut_term * weight / 256), 0, MASK);
          }
        }
      }
    } else {
      continue;
    }
  }
}

update() [2/2]

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

Definition at line 175 of file HcaluLUTTPGCoder.cc.

References gpuClustering::adc, cms::cuda::assert(), edmScanValgrind::buffer, hcalRecHitTable_cff::depth, geometryDiff::file, corrVsCorr::filename, getLUTId(), HcalBarrel, HcalEndcap, HcalForward, mps_fire::i, EcalPhiSymFlatTableProducers_cfi::id, hcalRecHitTable_cff::ieta, recoMuon::in, INPUT_LUT_SIZE, inputLUT_, hcalRecHitTable_cff::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 284 of file HcaluLUTTPGCoder.cc.

References LutXml::create_lut_map(), hcalRecHitTable_cff::depth, ALCARECOPPSCalTrackBasedSel_cff::detid, Exception, corrVsCorr::filename, XMLProcessor::getInstance(), LutXml::getLutFast(), getLUTId(), HcalBarrel, HcalEndcap, HcalForward, mps_fire::i, EcalPhiSymFlatTableProducers_cfi::id, hcalRecHitTable_cff::ieta, inputLUT_, createfilelist::int, hcalRecHitTable_cff::iphi, HcalDetId::kHcalDepthMask2, HcalDetId::kHcalEtaMask2, HcalDetId::kHcalPhiMask2, XMLProcessor::terminate(), topo_, UPGRADE_LUT_SIZE, 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() != UPGRADE_LUT_SIZE)
            throw cms::Exception("PROBLEM: Wrong inputLUT_ size in xml file for ") << detid << std::endl;
          Lut& lutRaw = inputLUT_[id];
          lutRaw.resize(UPGRADE_LUT_SIZE, 0);
          for (unsigned int i = 0; i < UPGRADE_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 127 of file HcaluLUTTPGCoder.h.

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

applyFixPCC_

bool HcaluLUTTPGCoder::applyFixPCC_

private

Definition at line 131 of file HcaluLUTTPGCoder.h.

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

bitToMask_

int HcaluLUTTPGCoder::bitToMask_

private

Definition at line 116 of file HcaluLUTTPGCoder.h.

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

contain1TSHB_

bool HcaluLUTTPGCoder::contain1TSHB_

private

Definition at line 128 of file HcaluLUTTPGCoder.h.

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

contain1TSHE_

bool HcaluLUTTPGCoder::contain1TSHE_

private

Definition at line 128 of file HcaluLUTTPGCoder.h.

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

containPhaseNSHB_

double HcaluLUTTPGCoder::containPhaseNSHB_ = 6.0

private

Definition at line 129 of file HcaluLUTTPGCoder.h.

Referenced by setContainPhaseHB(), and update().

containPhaseNSHE_

double HcaluLUTTPGCoder::containPhaseNSHE_ = 6.0

private

Definition at line 130 of file HcaluLUTTPGCoder.h.

Referenced by setContainPhaseHE(), and update().

cosh_ieta_

std::vector<double> HcaluLUTTPGCoder::cosh_ieta_

private

Definition at line 124 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 126 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 126 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 126 of file HcaluLUTTPGCoder.h.

Referenced by cosh_ieta(), and make_cosh_ieta_map().

delay_

const HcalTimeSlew* HcaluLUTTPGCoder::delay_

private

Definition at line 113 of file HcaluLUTTPGCoder.h.

Referenced by init(), and update().

FG_HF_thresholds_

std::vector<uint32_t> HcaluLUTTPGCoder::FG_HF_thresholds_

private

Definition at line 115 of file HcaluLUTTPGCoder.h.

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

firstHBEta_

int HcaluLUTTPGCoder::firstHBEta_

private

Definition at line 117 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and init().

firstHEEta_

int HcaluLUTTPGCoder::firstHEEta_

private

Definition at line 118 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and init().

firstHFEta_

int HcaluLUTTPGCoder::firstHFEta_

private

Definition at line 119 of file HcaluLUTTPGCoder.h.

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

gain_

std::vector<float> HcaluLUTTPGCoder::gain_

private

Definition at line 122 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 101 of file HcaluLUTTPGCoder.h.

Referenced by update().

inputLUT_

std::vector<Lut> HcaluLUTTPGCoder::inputLUT_

private

Definition at line 121 of file HcaluLUTTPGCoder.h.

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

lastHBEta_

int HcaluLUTTPGCoder::lastHBEta_

private

Definition at line 117 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and init().

lastHEEta_

int HcaluLUTTPGCoder::lastHEEta_

private

Definition at line 118 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and init().

lastHFEta_

int HcaluLUTTPGCoder::lastHFEta_

private

Definition at line 119 of file HcaluLUTTPGCoder.h.

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

linearLSB_QIE11_

double HcaluLUTTPGCoder::linearLSB_QIE11_

private

Definition at line 132 of file HcaluLUTTPGCoder.h.

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

linearLSB_QIE11Overlap_

double HcaluLUTTPGCoder::linearLSB_QIE11Overlap_

private

Definition at line 132 of file HcaluLUTTPGCoder.h.

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

linearLSB_QIE8_

double HcaluLUTTPGCoder::linearLSB_QIE8_

private

Definition at line 132 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 114 of file HcaluLUTTPGCoder.h.

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

maxDepthHB_

int HcaluLUTTPGCoder::maxDepthHB_

private

Definition at line 117 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and init().

maxDepthHE_

int HcaluLUTTPGCoder::maxDepthHE_

private

Definition at line 118 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and init().

maxDepthHF_

int HcaluLUTTPGCoder::maxDepthHF_

private

Definition at line 119 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and init().

nFi_

const int HcaluLUTTPGCoder::nFi_ = 72

staticprivate

Definition at line 103 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and init().

nHBEta_

int HcaluLUTTPGCoder::nHBEta_

private

Definition at line 117 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and init().

nHEEta_

int HcaluLUTTPGCoder::nHEEta_

private

Definition at line 118 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and init().

nHFEta_

int HcaluLUTTPGCoder::nHFEta_

private

Definition at line 119 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and init().

overrideDBweightsAndFilterHB_

bool HcaluLUTTPGCoder::overrideDBweightsAndFilterHB_ = false

private

Definition at line 134 of file HcaluLUTTPGCoder.h.

Referenced by setOverrideDBweightsAndFilterHB(), and update().

overrideDBweightsAndFilterHE_

bool HcaluLUTTPGCoder::overrideDBweightsAndFilterHE_ = false

private

Definition at line 135 of file HcaluLUTTPGCoder.h.

Referenced by setOverrideDBweightsAndFilterHE(), and update().

ped_

std::vector<float> HcaluLUTTPGCoder::ped_

private

Definition at line 123 of file HcaluLUTTPGCoder.h.

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

pulseCorr_

std::unique_ptr<HcalPulseContainmentManager> HcaluLUTTPGCoder::pulseCorr_

private

Definition at line 133 of file HcaluLUTTPGCoder.h.

Referenced by init(), and update().

QIE10_LUT_BITMASK

const int HcaluLUTTPGCoder::QIE10_LUT_BITMASK = 0x7FF

static

Definition at line 91 of file HcaluLUTTPGCoder.h.

Referenced by adc2Linear(), and update().

QIE10_LUT_MSB0

const int HcaluLUTTPGCoder::QIE10_LUT_MSB0 = 0x1000

staticprivate

Definition at line 108 of file HcaluLUTTPGCoder.h.

Referenced by lookupMSB(), and update().

QIE10_LUT_MSB1

const int HcaluLUTTPGCoder::QIE10_LUT_MSB1 = 0x2000

staticprivate

Definition at line 109 of file HcaluLUTTPGCoder.h.

Referenced by lookupMSB(), and update().

QIE10_ZDC_LUT_BITMASK

const int HcaluLUTTPGCoder::QIE10_ZDC_LUT_BITMASK = 0x3FF

static

Definition at line 93 of file HcaluLUTTPGCoder.h.

Referenced by adc2Linear(), and update().

QIE11_LUT_BITMASK

const int HcaluLUTTPGCoder::QIE11_LUT_BITMASK = 0x3FF

static

Definition at line 92 of file HcaluLUTTPGCoder.h.

Referenced by adc2Linear(), and update().

QIE11_LUT_MSB0

const int HcaluLUTTPGCoder::QIE11_LUT_MSB0 = 0x400

staticprivate

Definition at line 106 of file HcaluLUTTPGCoder.h.

Referenced by lookupMSB().

QIE11_LUT_MSB1

const int HcaluLUTTPGCoder::QIE11_LUT_MSB1 = 0x800

staticprivate

Definition at line 107 of file HcaluLUTTPGCoder.h.

Referenced by lookupMSB().

QIE8_LUT_BITMASK

const int HcaluLUTTPGCoder::QIE8_LUT_BITMASK = 0x3FF

static

Definition at line 90 of file HcaluLUTTPGCoder.h.

Referenced by adc2Linear(), and update().

QIE8_LUT_MSB

const int HcaluLUTTPGCoder::QIE8_LUT_MSB = 0x400

staticprivate

Definition at line 105 of file HcaluLUTTPGCoder.h.

Referenced by getMSB(), and update().

sizeHB_

int HcaluLUTTPGCoder::sizeHB_

private

Definition at line 117 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and init().

sizeHE_

int HcaluLUTTPGCoder::sizeHE_

private

Definition at line 118 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and init().

sizeHF_

int HcaluLUTTPGCoder::sizeHF_

private

Definition at line 119 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and init().

sizeZDC_

int HcaluLUTTPGCoder::sizeZDC_

private

Definition at line 120 of file HcaluLUTTPGCoder.h.

Referenced by adc2Linear(), getLinearizationLUT(), init(), and update().

topo_

const HcalTopology* HcaluLUTTPGCoder::topo_

private

Definition at line 112 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 102 of file HcaluLUTTPGCoder.h.

Referenced by update(), and updateXML().