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
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 (const HcalTopology *topo)
void	lookupMSB (const HBHEDataFrame &df, std::vector< bool > &msb) const
void	lookupMSB (const QIE10DataFrame &df, std::vector< bool > &msb) const
void	lookupMSB (const QIE11DataFrame &df, std::vector< std::bitset< 2 >> &msb) const
void	setAllLinear (bool linear, double lsb8, double lsb11, double lsb11overlap)
void	setFGHFthreshold (unsigned int fgthreshold)
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_
unsigned int	FG_HF_threshold_
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_
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_MSB = 0x1000
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 31 of file HcaluLUTTPGCoder.h.

Member Typedef Documentation

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

private

Definition at line 69 of file HcaluLUTTPGCoder.h.

typedef unsigned short HcaluLUTTPGCoder::LutElement

private

Definition at line 68 of file HcaluLUTTPGCoder.h.

Constructor & Destructor Documentation

HcaluLUTTPGCoder::HcaluLUTTPGCoder

(

const HcalTopology *

topo

)

Definition at line 39 of file HcaluLUTTPGCoder.cc.

References firstHBEta_, HcalTopology::firstHBRing(), firstHEEta_, HcalTopology::firstHERing(), firstHFEta_, HcalTopology::firstHFRing(), gain_, HcalBarrel, HcalEndcap, HcalForward, inputLUT_, lastHBEta_, HcalTopology::lastHBRing(), lastHEEta_, HcalTopology::lastHERing(), lastHFEta_, HcalTopology::lastHFRing(), HcalTopology::maxDepth(), maxDepthHB_, maxDepthHE_, maxDepthHF_, nFi_, nHBEta_, nHEEta_, nHFEta_, ped_, sizeHB_, sizeHE_, sizeHF_, and topo_.

                                                          : topo_(top), LUTGenerationMode_(true), bitToMask_(0), allLinear_(false), linearLSB_QIE8_(1.), linearLSB_QIE11_(1.) {
  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.);
}

HcaluLUTTPGCoder::~HcaluLUTTPGCoder ( )

override

Definition at line 65 of file HcaluLUTTPGCoder.cc.

                                    {
}

Member Function Documentation

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

overridevirtual

Implements HcalTPGCoder.

Definition at line 363 of file HcaluLUTTPGCoder.cc.

References ecalMGPA::adc(), getLUTId(), mps_fire::i, HBHEDataFrame::id(), inputLUT_, lumiPlot::lut, 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 371 of file HcaluLUTTPGCoder.cc.

References ecalMGPA::adc(), getLUTId(), mps_fire::i, HFDataFrame::id(), inputLUT_, lumiPlot::lut, 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 379 of file HcaluLUTTPGCoder.cc.

References ecalMGPA::adc(), getLUTId(), mps_fire::i, QIE10DataFrame::id(), inputLUT_, lumiPlot::lut, 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 387 of file HcaluLUTTPGCoder.cc.

References ecalMGPA::adc(), getLUTId(), mps_fire::i, QIE11DataFrame::id(), inputLUT_, lumiPlot::lut, 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 395 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 61 of file HcaluLUTTPGCoder.cc.

References Exception.

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

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 410 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 405 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 68 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 88 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 93 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 400 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 421 of file HcaluLUTTPGCoder.cc.

References getLUTId(), inputLUT_, lumiPlot::lut, 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::lookupMSB	(	const HBHEDataFrame &	df,
		std::vector< bool > &	msb
	)		const

Definition at line 415 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< bool > &	msb
	)		const

Definition at line 427 of file HcaluLUTTPGCoder.cc.

References ecalMGPA::adc(), getLUTId(), mps_fire::i, QIE10DataFrame::id(), inputLUT_, lumiPlot::lut, QIE10_LUT_MSB, 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] = lut.at(df[i].adc()) & QIE10_LUT_MSB;
    }
}

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

Definition at line 437 of file HcaluLUTTPGCoder.cc.

References ecalMGPA::adc(), getLUTId(), mps_fire::i, QIE11DataFrame::id(), inputLUT_, lumiPlot::lut, 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::setAllLinear ( bool  linear, double  lsb8, double  lsb11, double  lsb11overlap  )

inline

Definition at line 53 of file HcaluLUTTPGCoder.h.

References ecalMGPA::adc(), allLinear_, particleFlowClusterECALTimeSelected_cfi::depth, getLUTId(), getMSB(), 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::setFGHFthreshold ( unsigned int  fgthreshold )

inline

Definition at line 51 of file HcaluLUTTPGCoder.h.

References FG_HF_threshold_.

Referenced by HcalTPGCoderULUT::buildCoder().

{ FG_HF_threshold_ = fgthreshold; };

void HcaluLUTTPGCoder::setLUTGenerationMode ( bool  gen )

inline

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

References bitToMask_.

Referenced by HcalTPGCoderULUT::buildCoder().

{ bitToMask_ = bit; };

void HcaluLUTTPGCoder::update

(

const HcalDbService &

conditions

)

Definition at line 227 of file HcaluLUTTPGCoder.cc.

References ecalMGPA::adc(), hcaldqm::constants::adc2fC, allLinear_, bitToMask_, AlignmentProducer_cff::calibrations, HcalQIECoder::charge(), corr, HcalTopology::dddConstants(), HcalTopology::etaRange(), EnergyCorrector::etas, FG_HF_threshold_, firstHFEta_, muonCSCDigis_cfi::gain, gain_, HcalCondObjectContainer< Item >::getAllChannels(), HcalTPChannelParameter::getFGBitInfo(), HcalL1TriggerObject::getFlag(), HcalDbService::getHcalCalibrations(), HcalDbService::getHcalChannelStatus(), HcalDbService::getHcalCoder(), HcalDbService::getHcalL1TriggerObject(), HcalDbService::getHcalLutMetadata(), HcalDbService::getHcalQIEType(), 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, mps_fire::i, HcalDetId::ietaAbs(), INPUT_LUT_SIZE, inputLUT_, HcalDDDRecConstants::isPlan1(), HcalTopology::lastHBRing(), lastHFEta_, linearLSB_QIE11_, linearLSB_QIE11Overlap_, linearLSB_QIE8_, lsb_, lumiPlot::lut, LUTGenerationMode_, HcalCalibrations::LUTrespcorrgain(), SiStripPI::max, min(), or, ped_, HcalCalibrations::pedestal(), QIE10, QIE10_LUT_BITMASK, QIE10_LUT_MSB, QIE11, QIE11_LUT_BITMASK, QIE11_LUT_MSB0, QIE11_LUT_MSB1, QIE8, QIE8_LUT_BITMASK, SIZE, mps_update::status, HcalDetId::subdet(), topo_, HcalTrigTowerGeometry::towerEtaBounds(), 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(), HcalTPGCoderULUT::dbRecordCallback(), 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().

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

    HcalTrigTowerGeometry triggeo(topo_);
    std::map<int, float> cosh_ieta;
    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] = fabs(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.);
    }

    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;
     
    if (topo_->triggerMode() >= HcalTopologyMode::TriggerMode_2018 or
        topo_->triggerMode() == HcalTopologyMode::TriggerMode_2018legacy 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.pedestal(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();

        for (unsigned int adc = 0; adc < SIZE; ++adc) {
        if (isMasked) lut[adc] = 0;
        else {
            double nonlinearityCorrection = 1.0;
            if(qieType==QIE11) {
              const HcalSiPMParameter& siPMParameter(*conditions.getHcalSiPMParameter(cell));
              HcalSiPMnonlinearity corr(conditions.getHcalSiPMCharacteristics()->getNonLinearities(siPMParameter.getType()));
              const double fcByPE = siPMParameter.getFCByPE();
              const double effectivePixelsFired = adc2fC(adc)/fcByPE;
              nonlinearityCorrection = corr.getRecoCorrectionFactor(effectivePixelsFired);
            }
                    if (allLinear_)
                       lut[adc] = (LutElement) std::min(std::max(0, int((adc2fC(adc) - ped) * gain * rcalib * nonlinearityCorrection / linearLSB / cosh_ieta[cell.ietaAbs()])), MASK);
                    else
                       lut[adc] = (LutElement) std::min(std::max(0, int((adc2fC(adc) - ped) * gain * rcalib * nonlinearityCorrection / 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_threshold_) lut[adc] |= QIE10_LUT_MSB;
        }
        }
        }
    } 
}

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

Definition at line 97 of file HcaluLUTTPGCoder.cc.

References ecalMGPA::adc(), edmScanValgrind::buffer, particleFlowClusterECALTimeSelected_cfi::depth, FrontierConditions_GlobalTag_cff::file, getLUTId(), HcalBarrel, HcalEndcap, HcalForward, mps_fire::i, triggerObjects_cff::id, recoMuon::in, diffTreeTool::index, INPUT_LUT_SIZE, inputLUT_, 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 203 of file HcaluLUTTPGCoder.cc.

References LutXml::create_lut_map(), particleFlowClusterECALTimeSelected_cfi::depth, Exception, XMLProcessor::getInstance(), LutXml::getLutFast(), getLUTId(), HcalBarrel, HcalEndcap, HcalForward, mps_fire::i, INPUT_LUT_SIZE, inputLUT_, HcalDetId::kHcalDepthMask2, HcalDetId::kHcalEtaMask2, HcalDetId::kHcalPhiMask2, lumiPlot::lut, 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 <= HcalDetId::kHcalEtaMask2; ++ieta) {
    for (int iphi = 0; iphi <= HcalDetId::kHcalPhiMask2; ++iphi) {
      for (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 92 of file HcaluLUTTPGCoder.h.

Referenced by setAllLinear(), and update().

int HcaluLUTTPGCoder::bitToMask_

private

Definition at line 85 of file HcaluLUTTPGCoder.h.

Referenced by setMaskBit(), and update().

unsigned int HcaluLUTTPGCoder::FG_HF_threshold_

private

Definition at line 84 of file HcaluLUTTPGCoder.h.

Referenced by setFGHFthreshold(), and update().

int HcaluLUTTPGCoder::firstHBEta_

private

Definition at line 86 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and HcaluLUTTPGCoder().

int HcaluLUTTPGCoder::firstHEEta_

private

Definition at line 87 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and HcaluLUTTPGCoder().

int HcaluLUTTPGCoder::firstHFEta_

private

Definition at line 88 of file HcaluLUTTPGCoder.h.

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

std::vector<float> HcaluLUTTPGCoder::gain_

private

Definition at line 90 of file HcaluLUTTPGCoder.h.

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

const size_t HcaluLUTTPGCoder::INPUT_LUT_SIZE = 128

staticprivate

Definition at line 72 of file HcaluLUTTPGCoder.h.

Referenced by update(), and updateXML().

std::vector< Lut > HcaluLUTTPGCoder::inputLUT_

private

Definition at line 89 of file HcaluLUTTPGCoder.h.

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

int HcaluLUTTPGCoder::lastHBEta_

private

Definition at line 86 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and HcaluLUTTPGCoder().

int HcaluLUTTPGCoder::lastHEEta_

private

Definition at line 87 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and HcaluLUTTPGCoder().

int HcaluLUTTPGCoder::lastHFEta_

private

Definition at line 88 of file HcaluLUTTPGCoder.h.

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

double HcaluLUTTPGCoder::linearLSB_QIE11_

private

Definition at line 93 of file HcaluLUTTPGCoder.h.

Referenced by setAllLinear(), and update().

double HcaluLUTTPGCoder::linearLSB_QIE11Overlap_

private

Definition at line 93 of file HcaluLUTTPGCoder.h.

Referenced by setAllLinear(), and update().

double HcaluLUTTPGCoder::linearLSB_QIE8_

private

Definition at line 93 of file HcaluLUTTPGCoder.h.

Referenced by setAllLinear(), and update().

const float HcaluLUTTPGCoder::lsb_ =1./16

static

Definition at line 33 of file HcaluLUTTPGCoder.h.

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

bool HcaluLUTTPGCoder::LUTGenerationMode_

private

Definition at line 83 of file HcaluLUTTPGCoder.h.

Referenced by setLUTGenerationMode(), and update().

int HcaluLUTTPGCoder::maxDepthHB_

private

Definition at line 86 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and HcaluLUTTPGCoder().

int HcaluLUTTPGCoder::maxDepthHE_

private

Definition at line 87 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and HcaluLUTTPGCoder().

int HcaluLUTTPGCoder::maxDepthHF_

private

Definition at line 88 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and HcaluLUTTPGCoder().

const int HcaluLUTTPGCoder::nFi_ = 72

staticprivate

Definition at line 74 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and HcaluLUTTPGCoder().

int HcaluLUTTPGCoder::nHBEta_

private

Definition at line 86 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and HcaluLUTTPGCoder().

int HcaluLUTTPGCoder::nHEEta_

private

Definition at line 87 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and HcaluLUTTPGCoder().

int HcaluLUTTPGCoder::nHFEta_

private

Definition at line 88 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and HcaluLUTTPGCoder().

std::vector<float> HcaluLUTTPGCoder::ped_

private

Definition at line 91 of file HcaluLUTTPGCoder.h.

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

const int HcaluLUTTPGCoder::QIE10_LUT_BITMASK = 0x7FF

static

Definition at line 63 of file HcaluLUTTPGCoder.h.

Referenced by adc2Linear(), and update().

const int HcaluLUTTPGCoder::QIE10_LUT_MSB = 0x1000

staticprivate

Definition at line 79 of file HcaluLUTTPGCoder.h.

Referenced by lookupMSB(), and update().

const int HcaluLUTTPGCoder::QIE11_LUT_BITMASK = 0x3FF

static

Definition at line 64 of file HcaluLUTTPGCoder.h.

Referenced by adc2Linear(), and update().

const int HcaluLUTTPGCoder::QIE11_LUT_MSB0 = 0x400

staticprivate

Definition at line 77 of file HcaluLUTTPGCoder.h.

Referenced by lookupMSB(), and update().

const int HcaluLUTTPGCoder::QIE11_LUT_MSB1 = 0x800

staticprivate

Definition at line 78 of file HcaluLUTTPGCoder.h.

Referenced by lookupMSB(), and update().

const int HcaluLUTTPGCoder::QIE8_LUT_BITMASK = 0x3FF

static

Definition at line 62 of file HcaluLUTTPGCoder.h.

Referenced by adc2Linear(), and update().

const int HcaluLUTTPGCoder::QIE8_LUT_MSB = 0x400

staticprivate

Definition at line 76 of file HcaluLUTTPGCoder.h.

Referenced by getMSB(), and update().

int HcaluLUTTPGCoder::sizeHB_

private

Definition at line 86 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and HcaluLUTTPGCoder().

int HcaluLUTTPGCoder::sizeHE_

private

Definition at line 87 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and HcaluLUTTPGCoder().

int HcaluLUTTPGCoder::sizeHF_

private

Definition at line 88 of file HcaluLUTTPGCoder.h.

Referenced by HcaluLUTTPGCoder().

const HcalTopology* HcaluLUTTPGCoder::topo_

private

Definition at line 82 of file HcaluLUTTPGCoder.h.

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

const size_t HcaluLUTTPGCoder::UPGRADE_LUT_SIZE = 256

staticprivate

Definition at line 73 of file HcaluLUTTPGCoder.h.

Referenced by update().