HcaluLUTTPGCoder Class Reference

#include <HcaluLUTTPGCoder.h>

Inheritance diagram for HcaluLUTTPGCoder:

Public Member Functions
virtual void	adc2Linear (const HBHEDataFrame &df, IntegerCaloSamples &ics) const override
virtual void	adc2Linear (const HFDataFrame &df, IntegerCaloSamples &ics) const override
virtual void	adc2Linear (const QIE10DataFrame &df, IntegerCaloSamples &ics) const override
virtual void	adc2Linear (const QIE11DataFrame &df, IntegerCaloSamples &ics) const override
virtual unsigned short	adc2Linear (HcalQIESample sample, HcalDetId id) const override
virtual void	compress (const IntegerCaloSamples &ics, const std::vector< bool > &featureBits, HcalTriggerPrimitiveDigi &tp) const override
std::vector< unsigned short >	getLinearizationLUTWithMSB (const HcalDetId &id) const
virtual 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
virtual 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 QIE11DataFrame &df, std::vector< std::bitset< 2 >> &msb) const
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)
virtual	~HcaluLUTTPGCoder ()
Public Member Functions inherited from HcalTPGCoder
unsigned short	adc2Linear (unsigned char adc, HcalDetId id) const
virtual std::vector< unsigned short >	getLinearizationLUT (HcalDetId id) const
	Get the full linearization LUT (128 elements). Default implementation just uses adc2Linear to get all values. More...
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
int	bitToMask_
int	firstHBEta_
int	firstHEEta_
int	firstHFEta_
std::vector< float >	gain_
std::vector< Lut >	inputLUT_
int	lastHBEta_
int	lastHEEta_
int	lastHFEta_
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_
std::vector< Lut >	upgradeQIE10LUT_
std::vector< Lut >	upgradeQIE11LUT_

Static Private Attributes
static const size_t	INPUT_LUT_SIZE = 128
static const int	nFi_ = 72
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 66 of file HcaluLUTTPGCoder.h.

typedef unsigned short HcaluLUTTPGCoder::LutElement

private

Definition at line 65 of file HcaluLUTTPGCoder.h.

Constructor & Destructor Documentation

HcaluLUTTPGCoder::HcaluLUTTPGCoder

(

const HcalTopology *

topo

)

Definition at line 36 of file HcaluLUTTPGCoder.cc.

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

                                                          : topo_(top), LUTGenerationMode_(true), bitToMask_(0) {
  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,HcaluLUTTPGCoder::Lut(INPUT_LUT_SIZE, 0));
  upgradeQIE10LUT_ = std::vector<HcaluLUTTPGCoder::Lut>(nluts,HcaluLUTTPGCoder::Lut(UPGRADE_LUT_SIZE, 0));
  upgradeQIE11LUT_ = std::vector<HcaluLUTTPGCoder::Lut>(nluts,HcaluLUTTPGCoder::Lut(UPGRADE_LUT_SIZE, 0));
  gain_       = std::vector<float>(nluts, 0.);
  ped_        = std::vector<float>(nluts, 0.);
}

HcaluLUTTPGCoder::~HcaluLUTTPGCoder ( )

virtual

Definition at line 64 of file HcaluLUTTPGCoder.cc.

                                    {
}

Member Function Documentation

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

overridevirtual

Implements HcalTPGCoder.

Definition at line 360 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 368 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 376 of file HcaluLUTTPGCoder.cc.

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

                                                                                         {
  int lutId = getLUTId(HcalDetId(df.id()));
  const Lut& lut = upgradeQIE10LUT_.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 384 of file HcaluLUTTPGCoder.cc.

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

                                                                                         {
  int lutId = getLUTId(HcalDetId(df.id()));
  const Lut& lut = upgradeQIE11LUT_.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 392 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 60 of file HcaluLUTTPGCoder.cc.

References Exception.

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

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

(

const HcalDetId &

id

)

const

Definition at line 407 of file HcaluLUTTPGCoder.cc.

References getLUTId(), and inputLUT_.

Referenced by setMaskBit().

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

float HcaluLUTTPGCoder::getLUTGain ( HcalDetId  id ) const

overridevirtual

Implements HcalTPGCoder.

Definition at line 402 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 67 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(), getLinearizationLUTWithMSB(), getLUTGain(), getLUTId(), getLUTPedestal(), getMSB(), lookupMSB(), setMaskBit(), 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 87 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 92 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 397 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 418 of file HcaluLUTTPGCoder.cc.

References getLUTId(), inputLUT_, lumiPlot::lut, and QIE8_LUT_MSB.

Referenced by lookupMSB(), and setMaskBit().

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

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

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

                                                                                   {
  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 QIE11DataFrame &	df,
		std::vector< std::bitset< 2 >> &	msb
	)		const

Definition at line 425 of file HcaluLUTTPGCoder.cc.

References ecalMGPA::adc(), getLUTId(), mps_fire::i, QIE11DataFrame::id(), lumiPlot::lut, QIE11_LUT_MSB0, QIE11_LUT_MSB1, QIE11DataFrame::samples(), and upgradeQIE11LUT_.

{
   int lutId = getLUTId(HcalDetId(df.id()));
   const Lut& lut = upgradeQIE11LUT_.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::setLUTGenerationMode ( bool  gen )

inline

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

References ecalMGPA::adc(), bitToMask_, particleFlowClusterECALTimeSelected_cfi::depth, getLinearizationLUTWithMSB(), getLUTId(), getMSB(), and lookupMSB().

Referenced by HcalTPGCoderULUT::buildCoder().

{ bitToMask_ = bit; };

void HcaluLUTTPGCoder::update

(

const HcalDbService &

conditions

)

Definition at line 226 of file HcaluLUTTPGCoder.cc.

References ecalMGPA::adc(), HcalCoderDb::adc2fC(), hcaldqm::constants::adc2fC, bitToMask_, AlignmentProducer_cff::calibrations, data, HcalTopology::dddConstants(), HcalTopology::etaRange(), EnergyCorrector::etas, firstHFEta_, muonCSCDigis_cfi::gain, gain_, HcalCondObjectContainer< Item >::getAllChannels(), HcalTPChannelParameter::getFGBitInfo(), HcalL1TriggerObject::getFlag(), HcalDbService::getHcalCalibrations(), HcalDbService::getHcalChannelStatus(), HcalDbService::getHcalCoder(), HcalDbService::getHcalL1TriggerObject(), HcalDbService::getHcalLutMetadata(), HcalDbService::getHcalShape(), HcalDbService::getHcalTPChannelParameter(), HcalLutMetadatum::getLutGranularity(), getLUTId(), HcalLutMetadata::getNominalGain(), HcalL1TriggerObject::getPedestal(), HcalLutMetadatum::getRCalib(), HcalL1TriggerObject::getRespGain(), HcalChannelStatus::getValue(), HcalCondObjectContainer< Item >::getValues(), DetId::Hcal, HcalBarrel, HcalEndcap, HcalForward, mps_fire::i, HcalDetId::ietaAbs(), INPUT_LUT_SIZE, inputLUT_, HcalDDDRecConstants::isPlan1(), lastHFEta_, lsb_, LUTGenerationMode_, HcalCalibrations::LUTrespcorrgain(), hpstanc_transforms::max, min(), or, ped_, HcalCalibrations::pedestal(), QIE10_LUT_BITMASK, QIE11_LUT_BITMASK, QIE11_LUT_MSB0, QIE11_LUT_MSB1, QIE8_LUT_BITMASK, hcalTTPDigis_cfi::samples, HFDataFrame::setSample(), HBHEDataFrame::setSample(), QIE11DataFrame::setSample(), QIE10DataFrame::setSample(), HBHEDataFrame::setSize(), HFDataFrame::setSize(), mps_update::status, HcalDetId::subdet(), topo_, HcalTopology::triggerMode(), HcalTopologyMode::TriggerMode_2018, HcalTopologyMode::TriggerMode_2018legacy, UPGRADE_LUT_SIZE, upgradeQIE10LUT_, upgradeQIE11LUT_, 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 !=0);
  float nominalgain_ = metadata->getNominalGain();

  std::map<int, float> cosh_ieta;
  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);
     float ped = 0;
     float gain = 0;
     uint32_t status = 0;

     if (LUTGenerationMode_){
        const HcalCalibrations& calibrations = conditions.getHcalCalibrations(cell);
        for (int capId = 0; capId < 4; ++capId){
           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();

     // Input LUT for HB/HE/HF
     if (subdet == HcalBarrel || subdet == HcalEndcap){
        HBHEDataFrame frame(cell);
        frame.setSize(1);
        CaloSamples samples(cell, 1);

        int granularity = meta->getLutGranularity();

        for (unsigned int adc = 0; adc < INPUT_LUT_SIZE; ++adc) {
           frame.setSample(0,HcalQIESample(adc));
           coder.adc2fC(frame,samples);
           float adc2fC = samples[0];

           if (isMasked) inputLUT_[lutId][adc] = 0;
           else inputLUT_[lutId][adc] = (LutElement) std::min(std::max(0, int((adc2fC -ped) * gain * rcalib / nominalgain_ / granularity)), QIE8_LUT_BITMASK);
        }

        unsigned short data[] = {0, 0, 0};
        QIE11DataFrame upgradeFrame(edm::DataFrame(0, data, 3));
        CaloSamples upgradeSamples(cell, 1);
        for (unsigned int adc = 0; adc < UPGRADE_LUT_SIZE; ++adc) {
           upgradeFrame.setSample(0, adc, 0, true);
           coder.adc2fC(upgradeFrame, upgradeSamples);
           float adc2fC = upgradeSamples[0];

           if (isMasked) {
              upgradeQIE11LUT_[lutId][adc] = 0;
           } else {
              upgradeQIE11LUT_[lutId][adc] = (LutElement) std::min(std::max(0, int((adc2fC -ped) * gain * rcalib / nominalgain_ / granularity)), QIE11_LUT_BITMASK);
              if (adc >= mipMin and adc < mipMax)
                 upgradeQIE11LUT_[lutId][adc] |= QIE11_LUT_MSB0;
              else if (adc >= mipMax)
                 upgradeQIE11LUT_[lutId][adc] |= QIE11_LUT_MSB1;
           }
        }
     }  // endif HBHE
     else if (subdet == HcalForward){
        HFDataFrame frame(cell);
        frame.setSize(1);
        CaloSamples samples(cell, 1);

        for (unsigned int adc = 0; adc < INPUT_LUT_SIZE; ++adc) {
           frame.setSample(0,HcalQIESample(adc));
           coder.adc2fC(frame,samples);
           float adc2fC = samples[0];
           if (isMasked) inputLUT_[lutId][adc] = 0;
           else inputLUT_[lutId][adc] = std::min(std::max(0,int((adc2fC - ped) * gain * rcalib / lsb_ / cosh_ieta[cell.ietaAbs()] )), QIE8_LUT_BITMASK);
        }

        unsigned short data[] = {0, 0, 0, 0};
        QIE10DataFrame upgradeFrame(edm::DataFrame(0, data, 4));
        CaloSamples upgradeSamples(cell, 1);
        for (unsigned int adc = 0; adc < UPGRADE_LUT_SIZE; ++adc) {
           upgradeFrame.setSample(0, adc, 0, 0, 0, true);
           coder.adc2fC(upgradeFrame, upgradeSamples);
           float adc2fC = upgradeSamples[0];

           if (isMasked)
              upgradeQIE10LUT_[lutId][adc] = 0;
           else
              upgradeQIE10LUT_[lutId][adc] = std::min(std::max(0,int((adc2fC - ped) * gain * rcalib / lsb_ / cosh_ieta[cell.ietaAbs()] )), QIE10_LUT_BITMASK);
        }
     } // endif HF
  }// for cell
}

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

Definition at line 96 of file HcaluLUTTPGCoder.cc.

References ecalMGPA::adc(), edmScanValgrind::buffer, particleFlowClusterECALTimeSelected_cfi::depth, FrontierConditions_GlobalTag_cff::file, getLUTId(), HcalBarrel, HcalEndcap, HcalForward, mps_fire::i, hcalTTPDigis_cfi::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 202 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==0) 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

int HcaluLUTTPGCoder::bitToMask_

private

Definition at line 80 of file HcaluLUTTPGCoder.h.

Referenced by setMaskBit(), and update().

int HcaluLUTTPGCoder::firstHBEta_

private

Definition at line 81 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and HcaluLUTTPGCoder().

int HcaluLUTTPGCoder::firstHEEta_

private

Definition at line 82 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and HcaluLUTTPGCoder().

int HcaluLUTTPGCoder::firstHFEta_

private

Definition at line 83 of file HcaluLUTTPGCoder.h.

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

std::vector<float> HcaluLUTTPGCoder::gain_

private

Definition at line 87 of file HcaluLUTTPGCoder.h.

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

const size_t HcaluLUTTPGCoder::INPUT_LUT_SIZE = 128

staticprivate

Definition at line 69 of file HcaluLUTTPGCoder.h.

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

std::vector< Lut > HcaluLUTTPGCoder::inputLUT_

private

Definition at line 84 of file HcaluLUTTPGCoder.h.

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

int HcaluLUTTPGCoder::lastHBEta_

private

Definition at line 81 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and HcaluLUTTPGCoder().

int HcaluLUTTPGCoder::lastHEEta_

private

Definition at line 82 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and HcaluLUTTPGCoder().

int HcaluLUTTPGCoder::lastHFEta_

private

Definition at line 83 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), HcaluLUTTPGCoder(), 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 79 of file HcaluLUTTPGCoder.h.

Referenced by setLUTGenerationMode(), and update().

int HcaluLUTTPGCoder::maxDepthHB_

private

Definition at line 81 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and HcaluLUTTPGCoder().

int HcaluLUTTPGCoder::maxDepthHE_

private

Definition at line 82 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and HcaluLUTTPGCoder().

int HcaluLUTTPGCoder::maxDepthHF_

private

Definition at line 83 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and HcaluLUTTPGCoder().

const int HcaluLUTTPGCoder::nFi_ = 72

staticprivate

Definition at line 71 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and HcaluLUTTPGCoder().

int HcaluLUTTPGCoder::nHBEta_

private

Definition at line 81 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and HcaluLUTTPGCoder().

int HcaluLUTTPGCoder::nHEEta_

private

Definition at line 82 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and HcaluLUTTPGCoder().

int HcaluLUTTPGCoder::nHFEta_

private

Definition at line 83 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and HcaluLUTTPGCoder().

std::vector<float> HcaluLUTTPGCoder::ped_

private

Definition at line 88 of file HcaluLUTTPGCoder.h.

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

const int HcaluLUTTPGCoder::QIE10_LUT_BITMASK = 0x7FF

static

Definition at line 60 of file HcaluLUTTPGCoder.h.

Referenced by adc2Linear(), and update().

const int HcaluLUTTPGCoder::QIE11_LUT_BITMASK = 0x3FF

static

Definition at line 61 of file HcaluLUTTPGCoder.h.

Referenced by adc2Linear(), and update().

const int HcaluLUTTPGCoder::QIE11_LUT_MSB0 = 0x400

staticprivate

Definition at line 74 of file HcaluLUTTPGCoder.h.

Referenced by lookupMSB(), and update().

const int HcaluLUTTPGCoder::QIE11_LUT_MSB1 = 0x800

staticprivate

Definition at line 75 of file HcaluLUTTPGCoder.h.

Referenced by lookupMSB(), and update().

const int HcaluLUTTPGCoder::QIE8_LUT_BITMASK = 0x3FF

static

Definition at line 59 of file HcaluLUTTPGCoder.h.

Referenced by adc2Linear(), and update().

const int HcaluLUTTPGCoder::QIE8_LUT_MSB = 0x400

staticprivate

Definition at line 73 of file HcaluLUTTPGCoder.h.

Referenced by getMSB(), and update().

int HcaluLUTTPGCoder::sizeHB_

private

Definition at line 81 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and HcaluLUTTPGCoder().

int HcaluLUTTPGCoder::sizeHE_

private

Definition at line 82 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and HcaluLUTTPGCoder().

int HcaluLUTTPGCoder::sizeHF_

private

Definition at line 83 of file HcaluLUTTPGCoder.h.

Referenced by HcaluLUTTPGCoder().

const HcalTopology* HcaluLUTTPGCoder::topo_

private

Definition at line 78 of file HcaluLUTTPGCoder.h.

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

const size_t HcaluLUTTPGCoder::UPGRADE_LUT_SIZE = 256

staticprivate

Definition at line 70 of file HcaluLUTTPGCoder.h.

Referenced by HcaluLUTTPGCoder(), and update().

std::vector< Lut > HcaluLUTTPGCoder::upgradeQIE10LUT_

private

Definition at line 85 of file HcaluLUTTPGCoder.h.

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

std::vector< Lut > HcaluLUTTPGCoder::upgradeQIE11LUT_

private

Definition at line 86 of file HcaluLUTTPGCoder.h.

Referenced by adc2Linear(), HcaluLUTTPGCoder(), lookupMSB(), and update().