HcaluLUTTPGCoder Class Reference

#include <HcaluLUTTPGCoder.h>

Inheritance diagram for HcaluLUTTPGCoder:

Public Member Functions
virtual void	adc2Linear (const HBHEDataFrame &df, IntegerCaloSamples &ics) const
virtual void	adc2Linear (const HFDataFrame &df, IntegerCaloSamples &ics) const
virtual unsigned short	adc2Linear (HcalQIESample sample, HcalDetId id) const
virtual void	compress (const IntegerCaloSamples &ics, const std::vector< bool > &featureBits, HcalTriggerPrimitiveDigi &tp) const
std::vector< unsigned short >	getLinearizationLUTWithMSB (const HcalDetId &id) const
virtual float	getLUTGain (HcalDetId id) const
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
bool	getMSB (const HcalDetId &id, int adc) const
	HcaluLUTTPGCoder (const HcalTopology *topo)
void	lookupMSB (const HBHEDataFrame &df, std::vector< bool > &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...

Static Public Attributes
static const float	lsb_ =1./16

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_

Static Private Attributes
static const size_t	INPUT_LUT_SIZE = 128
static const int	nFi_ = 72

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 29 of file HcaluLUTTPGCoder.h.

Member Typedef Documentation

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

private

Definition at line 57 of file HcaluLUTTPGCoder.h.

typedef unsigned short HcaluLUTTPGCoder::LutElement

private

Definition at line 56 of file HcaluLUTTPGCoder.h.

Constructor & Destructor Documentation

HcaluLUTTPGCoder::HcaluLUTTPGCoder

(

const HcalTopology *

topo

)

Definition at line 29 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_, and topo_.

                                                          : 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));
  gain_       = std::vector<float>(nluts, 0.);
  ped_        = std::vector<float>(nluts, 0.);
}

HcaluLUTTPGCoder::~HcaluLUTTPGCoder ( )

virtual

Definition at line 55 of file HcaluLUTTPGCoder.cc.

                                    {
}

Member Function Documentation

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

virtual

Implements HcalTPGCoder.

Definition at line 314 of file HcaluLUTTPGCoder.cc.

References ecalMGPA::adc(), getLUTId(), i, HBHEDataFrame::id(), inputLUT_, lumiPlot::lut, 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()) & 0x3FF);
  }
}

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

virtual

Implements HcalTPGCoder.

Definition at line 322 of file HcaluLUTTPGCoder.cc.

References ecalMGPA::adc(), getLUTId(), i, HFDataFrame::id(), inputLUT_, lumiPlot::lut, 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()) & 0x3FF);
  }
}

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

virtual

Implements HcalTPGCoder.

Definition at line 330 of file HcaluLUTTPGCoder.cc.

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

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

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

virtual

Implements HcalTPGCoder.

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

References getLUTId(), and inputLUT_.

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

float HcaluLUTTPGCoder::getLUTGain ( HcalDetId  id ) const

virtual

Implements HcalTPGCoder.

Definition at line 340 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 58 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(), 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 78 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 83 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

virtual

Implements HcalTPGCoder.

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

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

Referenced by lookupMSB().

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

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

Definition at line 350 of file HcaluLUTTPGCoder.cc.

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

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

void HcaluLUTTPGCoder::setLUTGenerationMode ( bool  gen )

inline

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

References bitToMask_.

Referenced by HcalTPGCoderULUT::buildCoder().

{ bitToMask_ = bit; };

void HcaluLUTTPGCoder::update

(

const HcalDbService &

conditions

)

Definition at line 217 of file HcaluLUTTPGCoder.cc.

References funct::abs(), ecalMGPA::adc(), HcalCoderDb::adc2fC(), adc2fC, assert(), bitToMask_, HLT_FULL_cff::depth, HcalTopology::etaRange(), EnergyCorrector::etas, firstHFEta_, gain_, HcalL1TriggerObject::getFlag(), HcalDbService::getHcalCalibrations(), HcalDbService::getHcalChannelStatus(), HcalDbService::getHcalCoder(), HcalDbService::getHcalL1TriggerObject(), HcalDbService::getHcalLutMetadata(), HcalDbService::getHcalShape(), HcalLutMetadatum::getLutGranularity(), getLUTId(), HcalLutMetadata::getNominalGain(), HcalL1TriggerObject::getPedestal(), HcalLutMetadatum::getRCalib(), HcalL1TriggerObject::getRespGain(), HcalChannelStatus::getValue(), HcalCondObjectContainer< Item >::getValues(), HcalBarrel, HcalEndcap, HcalForward, i, inputLUT_, HcalDetId::kHcalDepthMask2, HcalDetId::kHcalEtaMask2, HcalDetId::kHcalPhiMask2, lastHFEta_, lsb_, LUTGenerationMode_, HcalCalibrations::LUTrespcorrgain(), bookConverter::max, min(), ped_, HcalCalibrations::pedestal(), HBHEDataFrame::setSample(), HFDataFrame::setSample(), HFDataFrame::setSize(), HBHEDataFrame::setSize(), mps_update::status, subdets, topo_, 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.);
  }

  HcalSubdetector subdets[] = {HcalBarrel, HcalEndcap, HcalForward};
  for (int isub = 0; isub < 3; ++isub){
    HcalSubdetector subdet = subdets[isub];
    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) {
      HcalDetId cell(subdet, ieta, iphi, depth);
      if (!topo_->valid(cell)) continue;

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

      int lutId = getLUTId(subdet, ieta, iphi, depth);
      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 (int adc = 0; adc <= 0x7F; ++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)), 0x3FF);
        }
      }  // endif HBHE
      else if (subdet == HcalForward){
        HFDataFrame frame(cell);
        frame.setSize(1);
        CaloSamples samples(cell, 1);

        for (int adc = 0; adc <= 0x7F; ++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[abs(ieta)] )), 0x3FF);
        }
      } // endif HF

    } // for depth
      } // for iphi
    } // for iphi
  }// for subdet
}

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

Definition at line 87 of file HcaluLUTTPGCoder.cc.

References ecalMGPA::adc(), assert(), HLT_FULL_cff::depth, mergeVDriftHistosByStation::file, getLUTId(), HcalBarrel, HcalEndcap, HcalForward, i, recoMuon::in, cmsHarvester::index, INPUT_LUT_SIZE, inputLUT_, 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 ? 0x400 : 0);
          inputLUT_[lutId][adc] = (msb | (inputLUT_[lutId][adc] & 0x3FF));
        }
        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 193 of file HcaluLUTTPGCoder.cc.

References LutXml::create_lut_map(), HLT_FULL_cff::depth, Exception, XMLProcessor::getInstance(), LutXml::getLutFast(), getLUTId(), HcalBarrel, HcalEndcap, HcalForward, i, 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()!=128) throw cms::Exception ("PROBLEM: Wrong inputLUT_ size in xml file for ") << detid << std::endl;
      for (int i=0; i<128; ++i) inputLUT_[id][i] = (LutElement)lut->at(i);
    }
      }
    }
  }
  delete _xml;
  XMLProcessor::getInstance()->terminate();
}

Member Data Documentation

int HcaluLUTTPGCoder::bitToMask_

private

Definition at line 66 of file HcaluLUTTPGCoder.h.

Referenced by setMaskBit(), and update().

int HcaluLUTTPGCoder::firstHBEta_

private

Definition at line 67 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and HcaluLUTTPGCoder().

int HcaluLUTTPGCoder::firstHEEta_

private

Definition at line 68 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and HcaluLUTTPGCoder().

int HcaluLUTTPGCoder::firstHFEta_

private

Definition at line 69 of file HcaluLUTTPGCoder.h.

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

std::vector<float> HcaluLUTTPGCoder::gain_

private

Definition at line 71 of file HcaluLUTTPGCoder.h.

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

const size_t HcaluLUTTPGCoder::INPUT_LUT_SIZE = 128

staticprivate

Definition at line 60 of file HcaluLUTTPGCoder.h.

Referenced by HcaluLUTTPGCoder(), and update().

std::vector< Lut > HcaluLUTTPGCoder::inputLUT_

private

Definition at line 70 of file HcaluLUTTPGCoder.h.

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

int HcaluLUTTPGCoder::lastHBEta_

private

Definition at line 67 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and HcaluLUTTPGCoder().

int HcaluLUTTPGCoder::lastHEEta_

private

Definition at line 68 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and HcaluLUTTPGCoder().

int HcaluLUTTPGCoder::lastHFEta_

private

Definition at line 69 of file HcaluLUTTPGCoder.h.

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

const float HcaluLUTTPGCoder::lsb_ =1./16

static

Definition at line 31 of file HcaluLUTTPGCoder.h.

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

bool HcaluLUTTPGCoder::LUTGenerationMode_

private

Definition at line 65 of file HcaluLUTTPGCoder.h.

Referenced by setLUTGenerationMode(), and update().

int HcaluLUTTPGCoder::maxDepthHB_

private

Definition at line 67 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and HcaluLUTTPGCoder().

int HcaluLUTTPGCoder::maxDepthHE_

private

Definition at line 68 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and HcaluLUTTPGCoder().

int HcaluLUTTPGCoder::maxDepthHF_

private

Definition at line 69 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and HcaluLUTTPGCoder().

const int HcaluLUTTPGCoder::nFi_ = 72

staticprivate

Definition at line 61 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and HcaluLUTTPGCoder().

int HcaluLUTTPGCoder::nHBEta_

private

Definition at line 67 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and HcaluLUTTPGCoder().

int HcaluLUTTPGCoder::nHEEta_

private

Definition at line 68 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and HcaluLUTTPGCoder().

int HcaluLUTTPGCoder::nHFEta_

private

Definition at line 69 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and HcaluLUTTPGCoder().

std::vector<float> HcaluLUTTPGCoder::ped_

private

Definition at line 72 of file HcaluLUTTPGCoder.h.

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

int HcaluLUTTPGCoder::sizeHB_

private

Definition at line 67 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and HcaluLUTTPGCoder().

int HcaluLUTTPGCoder::sizeHE_

private

Definition at line 68 of file HcaluLUTTPGCoder.h.

Referenced by getLUTId(), and HcaluLUTTPGCoder().

int HcaluLUTTPGCoder::sizeHF_

private

Definition at line 69 of file HcaluLUTTPGCoder.h.

Referenced by HcaluLUTTPGCoder().

const HcalTopology* HcaluLUTTPGCoder::topo_

private

Definition at line 64 of file HcaluLUTTPGCoder.h.

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