TileBchDecoder Class Reference

Class providing the association between TileCal problems and status word bits. More...

#include <TileBchDecoder.h>

Collaboration diagram for TileBchDecoder:

Public Types
enum	BitPatVer { BitPat_ofl01 , BitPat_onl01 , MaxVersion }

Public Member Functions
	TileBchDecoder (BitPatVer bitPatVer)
	Ctor.
void	printBitAssignment () const
	Print status bits and their assigned problem.
void	printBitAssignment (std::ostream &stm) const
	Print status bits and their assigned problem.
TileBchStatus	decode (uint32_t status_channel, uint32_t status_adc=0) const
	Decode the status word.
TileBchStatus	decode (const TileBchWords &words) const
	Decode the status word.
TileBchWords	encode (const TileBchStatus &status) const
	Encode an ADC status into channel and adc status word bits.

Private Member Functions
void	init_BitPat_ofl01 ()
	Initializes bit pattern version "ofl01".
void	init_BitPat_onl01 ()
	Initializes bit pattern version "ofl01".
void	initPrbToBit ()
	Initializes the problem to bit map.

Private Attributes
std::vector< TileBchPrbs::Prb >	m_bitToPrbChn
	Bit to problem association for the channel word.
std::vector< TileBchPrbs::Prb >	m_bitToPrbAdc
	Bit to problem association for the ADC word.
std::map< TileBchPrbs::Prb, std::pair< unsigned int, unsigned int > >	m_prbToBit
	Problem to status word and bit association.

Detailed Description

Class providing the association between TileCal problems and status word bits.

Author

Nils Gollub nils..nosp@m.goll.nosp@m.ub@ce.nosp@m.rn.c.nosp@m.h

The status of each TileCal ADC is stored in the database as a combination of two 32 bit integers: One 32 bit word encodes channel problems common to both ADCs (stored in gain=2), and one 32 bit word encodes ADC specific problems (gain=0 or 1).

Each bit is assigned to a specific problem. The association between bits and problems is generally not static and could change over time. This class provides a flexible mechanism to translate between problems and current bit pattern implementation. The different problems are encoded as enums (see TileBchPrbs class).

One TileBchDecoder object should be instanciated for each bitPatternVersion.

Definition at line 36 of file TileBchDecoder.h.

Member Enumeration Documentation

BitPatVer

enum TileBchDecoder::BitPatVer

Enumerator
BitPat_ofl01
BitPat_onl01
MaxVersion

Definition at line 40 of file TileBchDecoder.h.

                {
    BitPat_ofl01,
    BitPat_onl01,
    MaxVersion
  };

Constructor & Destructor Documentation

TileBchDecoder()

TileBchDecoder::TileBchDecoder

(

BitPatVer

bitPatVer

)

Ctor.

Definition at line 10 of file TileBchDecoder.cxx.

{
  if(     bitPatVer==TileBchDecoder::BitPat_ofl01){ init_BitPat_ofl01(); }
  else if(bitPatVer==TileBchDecoder::BitPat_onl01){ init_BitPat_onl01(); }
  else{
    throw TileCalib::InvalidBitPattern("TileBchDecoder::Ctor", bitPatVer);
  }
}

Member Function Documentation

decode() [1/2]

TileBchStatus TileBchDecoder::decode ( const TileBchWords & words ) const

inline

Decode the status word.

Definition at line 59 of file TileBchDecoder.h.

    { return decode(words[0],words[1]); }

decode() [2/2]

TileBchStatus TileBchDecoder::decode	(	uint32_t	status_channel,
		uint32_t	status_adc = 0 ) const

Decode the status word.

Definition at line 22 of file TileBchDecoder.cxx.

{
  TileBchStatus status;
  for(unsigned int i = 0; i < 32; ++i){
    //=== decode channel problems
    if(status_channel & 0x00000001){ status += m_bitToPrbChn[i]; }
    //=== decode adc problems
    if(status_adc     & 0x00000001){ status += m_bitToPrbAdc[i]; }
    //=== shift the status words by one bit
    status_channel >>= 1;
    status_adc     >>= 1;
  }
  return status;
}

encode()

TileBchWords TileBchDecoder::encode

(

const TileBchStatus &

status

)

const

Encode an ADC status into channel and adc status word bits.

The returned vector is of length 2, where the first word encodes the common channel problems and the second word the specific adc problems.

Parameters

status

The ADC status

Definition at line 40 of file TileBchDecoder.cxx.

{
  TileBchWords words;
  const std::set<TileBchPrbs::Prb>& prbs = status.getPrbs();
  for(std::set<TileBchPrbs::Prb>::const_iterator iPrb = prbs.begin();
      iPrb!=prbs.end(); ++iPrb)
    {
      std::map<TileBchPrbs::Prb,std::pair<unsigned int,unsigned int> >::const_iterator 
    iMap = m_prbToBit.find(*iPrb);
      if(iMap == m_prbToBit.end()){
    //=== throw an exception if we can not encode the problem
    throw TileCalib::InvalidBchProblem("TileBchDecoder::encode", *iPrb);
      }
      words[iMap->second.first] |= (1 << iMap->second.second);
    }
  return words;
}

init_BitPat_ofl01()

void TileBchDecoder::init_BitPat_ofl01 ( )

private

Initializes bit pattern version "ofl01".

Definition at line 61 of file TileBchDecoder.cxx.

{
  //=== assign decoder to channel problems
  m_bitToPrbChn.clear();
  m_bitToPrbChn.resize(32,TileBchPrbs::Invalid);
  m_bitToPrbChn[ 0] = TileBchPrbs::GeneralMaskChannel;
  m_bitToPrbChn[ 1] = TileBchPrbs::NoPmt;
  m_bitToPrbChn[ 2] = TileBchPrbs::NoHV;
  m_bitToPrbChn[ 3] = TileBchPrbs::WrongHV;
  m_bitToPrbChn[ 4] = TileBchPrbs::NoLaser;
  m_bitToPrbChn[ 5] = TileBchPrbs::BadLaser;
  m_bitToPrbChn[ 6] = TileBchPrbs::NoCesium;
  m_bitToPrbChn[ 7] = TileBchPrbs::BadCesium;
  m_bitToPrbChn[ 8] = TileBchPrbs::NoTiming;
  m_bitToPrbChn[ 9] = TileBchPrbs::BadTiming;
  m_bitToPrbChn[10] = TileBchPrbs::TrigGeneralMask;
  m_bitToPrbChn[11] = TileBchPrbs::TrigNoGain;
  m_bitToPrbChn[12] = TileBchPrbs::TrigHalfGain;
  m_bitToPrbChn[13] = TileBchPrbs::TrigNoisy;
  m_bitToPrbChn[14] = TileBchPrbs::Emergency;
  m_bitToPrbChn[15] = TileBchPrbs::HVReadoutPb;
  m_bitToPrbChn[16] = TileBchPrbs::BrokenClearFibre;
  m_bitToPrbChn[17] = TileBchPrbs::IgnoreCs;
  m_bitToPrbChn[18] = TileBchPrbs::UnstableCs;
  m_bitToPrbChn[19] = TileBchPrbs::WrongBCID;
  m_bitToPrbChn[20] = TileBchPrbs::TimingDmuBcOffsetPos;
  m_bitToPrbChn[21] = TileBchPrbs::TimingDmuBcOffsetNeg;
  m_bitToPrbChn[22] = TileBchPrbs::BurntIntegrator;
  
  //=== assign decoder to adc problems
  m_bitToPrbAdc.clear();
  m_bitToPrbAdc.resize(32,TileBchPrbs::Invalid);
  m_bitToPrbAdc[ 0] = TileBchPrbs::GeneralMaskAdc;
  m_bitToPrbAdc[ 1] = TileBchPrbs::AdcDead;
  m_bitToPrbAdc[ 2] = TileBchPrbs::StuckBit;
  m_bitToPrbAdc[ 3] = TileBchPrbs::DataCorruption;
  m_bitToPrbAdc[ 4] = TileBchPrbs::VeryLargeHfNoise;
  m_bitToPrbAdc[ 5] = TileBchPrbs::NoData;
  m_bitToPrbAdc[ 6] = TileBchPrbs::WrongDspConfig;
  m_bitToPrbAdc[ 7] = TileBchPrbs::LargeHfNoise;
  m_bitToPrbAdc[ 8] = TileBchPrbs::CorrelatedNoise;
  m_bitToPrbAdc[ 9] = TileBchPrbs::LargeLfNoise;
  m_bitToPrbAdc[10] = TileBchPrbs::NoCis;
  m_bitToPrbAdc[11] = TileBchPrbs::BadCis;
  m_bitToPrbAdc[12] = TileBchPrbs::SevereStuckBit;
  m_bitToPrbAdc[13] = TileBchPrbs::SevereDataCorruption;
  m_bitToPrbAdc[14] = TileBchPrbs::IgnoredByDQV;
  m_bitToPrbAdc[15] = TileBchPrbs::HalfGain;
 
  //=== initialize problem to word/bit map
  initPrbToBit();
}

init_BitPat_onl01()

void TileBchDecoder::init_BitPat_onl01 ( )

private

Initializes bit pattern version "ofl01".

Definition at line 117 of file TileBchDecoder.cxx.

{
  //=== assign decoder to channel problems
  m_bitToPrbChn.clear();
  m_bitToPrbChn.resize(32,TileBchPrbs::Invalid);
  m_bitToPrbChn[ 0] = TileBchPrbs::IgnoredInDsp;
  m_bitToPrbChn[ 1] = TileBchPrbs::IgnoredInHlt;
  m_bitToPrbChn[ 2] = TileBchPrbs::DisableForL1;
  m_bitToPrbChn[ 3] = TileBchPrbs::TrigGeneralMask;
  m_bitToPrbChn[ 4] = TileBchPrbs::TrigNoGain;
  m_bitToPrbChn[ 5] = TileBchPrbs::TrigHalfGain;
  m_bitToPrbChn[ 6] = TileBchPrbs::TrigNoisy;
  m_bitToPrbChn[ 7] = TileBchPrbs::OnlineBadTiming;
  m_bitToPrbChn[ 8] = TileBchPrbs::OnlineWrongBCID;
  m_bitToPrbChn[ 9] = TileBchPrbs::OnlineTimingDmuBcOffsetPos;
  m_bitToPrbChn[10] = TileBchPrbs::OnlineTimingDmuBcOffsetNeg;
  
  //=== assign decoder to adc problems
  m_bitToPrbAdc.clear();
  m_bitToPrbAdc.resize(32,TileBchPrbs::Invalid);
  m_bitToPrbAdc[ 0] = TileBchPrbs::OnlineGeneralMaskAdc;
 
  //=== initialize problem to word/bit map
  initPrbToBit();
}

initPrbToBit()

void TileBchDecoder::initPrbToBit ( )

private

Initializes the problem to bit map.

Definition at line 146 of file TileBchDecoder.cxx.

{
  m_prbToBit.clear();
  //=== init channel problems
  for(unsigned int i = 0; i < 32; ++i){
    TileBchPrbs::Prb prb = m_bitToPrbChn[i];
    if(prb==TileBchPrbs::Invalid) continue;
    //=== check for duplicates
    if(m_prbToBit.find(prb) != m_prbToBit.end()){
      throw TileCalib::InvalidBitPattern("TileBchDecoder::initPrbToBit(Chn)",i);
    }
    m_prbToBit[prb] = std::make_pair(0,i);
  }
 
  //=== init adc problems
  for(unsigned int i = 0; i < 32; ++i){
    TileBchPrbs::Prb prb = m_bitToPrbAdc[i];
    if(prb==TileBchPrbs::Invalid) continue;
    //=== check for duplicates
    if(m_prbToBit.find(prb)!=m_prbToBit.end()){
      throw TileCalib::InvalidBitPattern("TileBchDecoder::initPrbToBit(Adc)",i);
    }
    m_prbToBit[prb] = std::make_pair(1, i);
  }
}

printBitAssignment() [1/2]

void TileBchDecoder::printBitAssignment ( ) const

inline

Print status bits and their assigned problem.

Definition at line 50 of file TileBchDecoder.h.

{ printBitAssignment(std::cout); }

printBitAssignment() [2/2]

void TileBchDecoder::printBitAssignment

(

std::ostream &

stm

)

const

Print status bits and their assigned problem.

Parameters

stm	The stream to print to

Definition at line 175 of file TileBchDecoder.cxx.

{
  stm << "Current bit to problem assignment" << std::endl;
  stm << "---------------------------------" << std::endl;
  stm << "Channel:"                          << std::endl;
  for(unsigned int i = 0; i < 32; ++i){
    TileBchPrbs::Prb prb = m_bitToPrbChn[i];
    std::string desc = TileBchPrbs::getDescription(prb);
    stm << "bit "<<i<<"\t:\t" << desc << std::endl;
  }
  stm << "Adc:"                              << std::endl;
  for(unsigned int i = 0; i < 32; ++i){
    TileBchPrbs::Prb prb = m_bitToPrbAdc[i];
    std::string desc = TileBchPrbs::getDescription(prb);
    stm << "bit "<<i<<"\t:\t" << desc << std::endl;
  }
}

Member Data Documentation

m_bitToPrbAdc

std::vector<TileBchPrbs::Prb> TileBchDecoder::m_bitToPrbAdc

private

Bit to problem association for the ADC word.

Definition at line 84 of file TileBchDecoder.h.

m_bitToPrbChn

std::vector<TileBchPrbs::Prb> TileBchDecoder::m_bitToPrbChn

private

Bit to problem association for the channel word.

Definition at line 82 of file TileBchDecoder.h.

m_prbToBit

std::map<TileBchPrbs::Prb, std::pair<unsigned int,unsigned int> > TileBchDecoder::m_prbToBit

private

Problem to status word and bit association.

pair.first==0 means channel status word, pair.first==1 means adc status word. pair.second is the bit number.

Definition at line 88 of file TileBchDecoder.h.

---

The documentation for this class was generated from the following files:

• TileBchDecoder.h
• TileBchDecoder.cxx