LArLATOMEDecoder::EventProcess Class Reference

Inheritance diagram for LArLATOMEDecoder::EventProcess:

Public Types
typedef unsigned int	Word
	this should be the same as how we get the data, otherwise we will have bugs.
typedef int	NumWord
typedef int	Packet
typedef int	SuperCell
typedef int	Sample
typedef std::string	Path

Public Member Functions
	EventProcess (const LArLATOMEDecoder *decoderInput, LArDigitContainer *adc_coll, LArDigitContainer *adc_bas_coll, LArRawSCContainer *et_coll, LArRawSCContainer *et_id_coll, LArAccumulatedDigitContainer *accdigits, LArAccumulatedCalibDigitContainer *caccdigits, LArLATOMEHeaderContainer *header_coll)
void	fillCollection (const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment *pROB, const std::vector< HWIdentifier > *LATOME_Channels, const LArOnOffIdMapping *onoffmap=nullptr, const LArCalibLineMapping *clmap=nullptr)
	Execute decoding for an event.
bool	msgLvl (const MSG::Level lvl) const
	Test the output level.
MsgStream &	msg () const
	The standard message stream.
MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream.
void	setLevel (MSG::Level lvl)
	Change the current logging level.

Private Types
enum	MODE { MON_HEADER , PAYLOAD , MON_TRAILER }

Private Member Functions
bool	compareOrSet (Word &param, Word value, bool compare)
unsigned int	decodeTrailer (const uint32_t *p, unsigned int offset)
unsigned int	decodeHeader (const uint32_t *p, unsigned int offset)
unsigned int	bytesPerChannel (MonDataType at0, MonDataType at1)
void	increaseWordShift (unsigned int &wordshift)
void	increaseByteShift (unsigned int &wordshift, unsigned int &byteshift)
void	decodeByte (unsigned int &byte, unsigned int wordshift, unsigned int byteshift, const uint32_t *p)
void	decodeWord (unsigned int &word, unsigned int &wordshift, unsigned int &byteshift, const uint32_t *p)
void	decodeChannel (unsigned int &wordshift, unsigned int &byteshift, const uint32_t *p, MonDataType at0, MonDataType at1, unsigned int &at0Data, unsigned int &at1Data, unsigned int &satData, bool &at0val, bool &at1val)
int	signEnergy (unsigned int energy)
void	fillRaw (const std::vector< HWIdentifier > *LATOME_Channels)
	Pass ADC values from an event.
void	fillCalib (const std::vector< HWIdentifier > *LATOME_Channels, const LArOnOffIdMapping *onoffmap, const LArCalibLineMapping *clmap)
void	fillHeader ()
void	initMessaging () const
	Initialize our message level and MessageSvc.

Private Attributes
std::vector< Word >	m_packetEnd
Word	m_latomeBCID {}
Word	m_latomeID {}
Word	m_l1ID {}
Word	m_ROBFragSize {}
Word	m_LATOMEFW {}
Word	m_nPackets {}
Word	m_iPacket {}
Word	m_nWordsPerPacket {}
Word	m_monHeaderSize {}
Word	m_region {}
Word	m_nStreams {}
Word	m_streamNumber {}
Word	m_at0at1Swap {}
Word	m_at0typeRec {}
Word	m_at1typeRec {}
Word	m_at0type {}
Word	m_at1type {}
Word	m_at0nBC {}
Word	m_at1nBC {}
Word	m_at0BC {}
Word	m_at1BC {}
Word	m_activeSC {}
Word	m_nsc1 {}
Word	m_nsc2 {}
Word	m_nsc3 {}
Word	m_nsc4 {}
Word	m_nsc5 {}
Word	m_nsc6 {}
bool	m_headerDecoded {}
short	m_nBC_rawADC {}
short	m_nBC_ADC {}
short	m_nBC_E {}
short	m_nBC_EID {}
short	m_nBC_Averaged {}
short	m_BC_rawADC {}
short	m_BC_ADC {}
short	m_BC_E {}
short	m_BC_EID {}
bool	m_hasRawAdc {}
bool	m_hasAdc {}
bool	m_hasE {}
bool	m_hasEID {}
bool	m_isAveraged {}
bool	m_isAutoCorr {}
const LArLATOMEDecoder *	m_decoder {}
LArDigitContainer *	m_adc_coll {}
LArDigitContainer *	m_adc_bas_coll {}
LArRawSCContainer *	m_et_coll {}
LArRawSCContainer *	m_et_id_coll {}
LArAccumulatedDigitContainer *	m_accdigits {}
LArAccumulatedCalibDigitContainer *	m_caccdigits {}
LArLATOMEHeaderContainer *	m_header_coll {}
unsigned int	m_nthLATOME = 0
std::vector< unsigned short >	m_BCIDsInEvent
std::vector< LatomeRawData >	m_rawValuesInEvent
std::vector< LatomeAveragedRawData >	m_averagedRawValuesInEvent
std::vector< LatomeCalibPatterns >	m_latomeCalibPatternsInEvent
std::string	m_nm
	Message source name.
boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels).
std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer.
std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level.
std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging).

Static Private Attributes
static const Word	m_monTrailerSize =2
	some cached info to ease processing reading from data header
static const Word	s_monHeaderMarker =0xff1234ff
	this is fixed and not read from data
static const Word	s_monCheckPoint =0xdeadbeef

Detailed Description

Definition at line 126 of file LArLATOMEDecoder.h.

Member Typedef Documentation

NumWord

typedef int LArLATOMEDecoder::EventProcess::NumWord

Definition at line 131 of file LArLATOMEDecoder.h.

Packet

typedef int LArLATOMEDecoder::EventProcess::Packet

Definition at line 132 of file LArLATOMEDecoder.h.

Path

typedef std::string LArLATOMEDecoder::EventProcess::Path

Definition at line 135 of file LArLATOMEDecoder.h.

Sample

typedef int LArLATOMEDecoder::EventProcess::Sample

Definition at line 134 of file LArLATOMEDecoder.h.

SuperCell

typedef int LArLATOMEDecoder::EventProcess::SuperCell

Definition at line 133 of file LArLATOMEDecoder.h.

Word

typedef unsigned int LArLATOMEDecoder::EventProcess::Word

this should be the same as how we get the data, otherwise we will have bugs.

use reinterpret_cast later to properly interpret the bit in other format if needed.

Definition at line 130 of file LArLATOMEDecoder.h.

Member Enumeration Documentation

MODE

enum LArLATOMEDecoder::EventProcess::MODE

private

Enumerator
MON_HEADER
PAYLOAD
MON_TRAILER

Definition at line 171 of file LArLATOMEDecoder.h.

              {
      MON_HEADER, PAYLOAD, MON_TRAILER
    };

Constructor & Destructor Documentation

EventProcess()

LArLATOMEDecoder::EventProcess::EventProcess	(	const LArLATOMEDecoder *	decoderInput,
		LArDigitContainer *	adc_coll,
		LArDigitContainer *	adc_bas_coll,
		LArRawSCContainer *	et_coll,
		LArRawSCContainer *	et_id_coll,
		LArAccumulatedDigitContainer *	accdigits,
		LArAccumulatedCalibDigitContainer *	caccdigits,
		LArLATOMEHeaderContainer *	header_coll )

Definition at line 152 of file LArLATOMEDecoder.cxx.

    : AthMessaging(Gaudi::svcLocator()->service<IMessageSvc>("MessageSvc"), "LArLATOMEDecoder::EventProcess"),
      m_decoder(decoderInput),
      m_adc_coll(adc_coll),
      m_adc_bas_coll(adc_bas_coll),
      m_et_coll(et_coll),
      m_et_id_coll(et_id_coll),
      m_accdigits(accdigits),
      m_caccdigits(caccdigits),
      m_header_coll(header_coll) {
  m_latomeID = 0;
  m_l1ID = 0;
  m_ROBFragSize = 0;
  m_nPackets = 0;
  m_iPacket = 0;
  m_nWordsPerPacket = 0;
  m_monHeaderSize = 0;
  m_region = 0;
  m_nStreams = 0;
  m_streamNumber = 0;
  m_at0at1Swap = 0;
  m_at0typeRec = (Word)MonDataType::Invalid;
  m_at1typeRec = (Word)MonDataType::Invalid;
  m_at0type = (Word)MonDataType::Invalid;
  m_at1type = (Word)MonDataType::Invalid;
  m_at0nBC = 0;
  m_at1nBC = 0;
  m_at0BC = 0;
  m_at1BC = 0;
  m_activeSC = 0;
  m_nsc1 = 0;
  m_nsc2 = 0;
  m_nsc3 = 0;
  m_nsc4 = 0;
  m_nsc5 = 0;
  m_nsc6 = 0;
  m_headerDecoded = false;
 
  m_nBC_rawADC = 0;
  m_nBC_ADC = 0;
  m_nBC_E = 0;
  m_nBC_EID = 0;
 
  m_nBC_Averaged = 0;
 
  m_BC_rawADC = 0;
  m_BC_ADC = 0;
  m_BC_E = 0;
  m_BC_EID = 0;
 
  m_hasRawAdc = false;
  m_hasAdc = false;
  m_hasE = false;
  m_hasEID = false;
 
  m_isAveraged = (m_caccdigits != 0);
  m_isAutoCorr = (m_accdigits != 0);
 
  if (!m_isAveraged && !m_isAutoCorr) {
    m_rawValuesInEvent.resize(N_LATOME_CHANNELS);
  } else {
    m_averagedRawValuesInEvent.resize(N_LATOME_CHANNELS);
    m_latomeCalibPatternsInEvent.resize(2);
  }
}

Member Function Documentation

bytesPerChannel()

unsigned int LArLATOMEDecoder::EventProcess::bytesPerChannel ( MonDataType at0, MonDataType at1 )

private

Definition at line 344 of file LArLATOMEDecoder.cxx.

                                                                                           {
  unsigned int b = 0;
  if (at0 == MonDataType::Averaged || at0 == MonDataType::AutoCorr)
    return 8;

  if (at0 != MonDataType::Invalid)
    b += 2;
  if (at1 != MonDataType::Invalid)
    b += 2;
  if (at0 == MonDataType::Energy || at1 == MonDataType::Energy || at0 == MonDataType::SelectedEnergy || at1 == MonDataType::SelectedEnergy)
    ++b;
  return b;
}

compareOrSet()

bool LArLATOMEDecoder::EventProcess::compareOrSet ( Word & param, Word value, bool compare )

inlineprivate

Definition at line 220 of file LArLATOMEDecoder.cxx.

                                                                                            {
  if (!compare) {
    param = value;
    return true;
  }
  return param == value;
}

decodeByte()

void LArLATOMEDecoder::EventProcess::decodeByte ( unsigned int & byte, unsigned int wordshift, unsigned int byteshift, const uint32_t * p )

inlineprivate

Definition at line 376 of file LArLATOMEDecoder.cxx.

                                                                                                                                          {
  byte = ((std::byteswap(p[wordshift])) >> (8 * (4 - 1 - byteshift))) & 0xff;
}

decodeChannel()

void LArLATOMEDecoder::EventProcess::decodeChannel ( unsigned int & wordshift, unsigned int & byteshift, const uint32_t * p, MonDataType at0, MonDataType at1, unsigned int & at0Data, unsigned int & at1Data, unsigned int & satData, bool & at0val, bool & at1val )

inlineprivate

now that we have the basic words we can rearrange the bits in case it is energy, ADC do not need further arrangement this is assuming energy lsb is at bit[0-2] and energy-id at [5-7]. Make sure this is the case for all recipe in the firmware. assumptions are in https://its.cern.ch/jira/browse/LDPBFW-2976

Definition at line 390 of file LArLATOMEDecoder.cxx.

                                                                                                                                                       {
 
  // the structure of data is always consisting of 2,3,4 or 5 bytes depending on the recipe.
  // If there is an energy it means there is the quality/saturation byte thus odd number of bytes. Otherwise ADC or Energy spans <mostly> over 2 bytes.
  // avoid vectors and loops and bitsets to make it faster (can change later if needed but there is only few configurations so no need to make it infinitely
  // flexible. use unsigned int everywhere for now since we have 18 bits for energy which does not fit in short, cast later.
  unsigned int nbytesPerChannel = bytesPerChannel(at0, at1);
  bool satByte = nbytesPerChannel % 2;  // do we have satbyte
 
  at0val = false;
  at1val = false;
  at0Data = 0;
  at1Data = 0;
  unsigned int satData = 0;
  saturation = 0;
 
  unsigned int word1 = 0;
  unsigned int word2 = 0;
  decodeWord(word1, wordshift, byteshift, p);
  if (nbytesPerChannel > 3) {
    decodeWord(word2, wordshift, byteshift, p);
  }
  at0Data = word1 & 0x7fff;
  at0val = word1 & 0x8000;
  if (nbytesPerChannel > 3) {
    at1Data = word2 & 0x7fff;
    at1val = word2 & 0x8000;
  }
  if (satByte) {
    decodeByte(satData, wordshift, byteshift, p);
    increaseByteShift(wordshift, byteshift);
  }

 
  if (at0 == MonDataType::Energy && at1 == MonDataType::SelectedEnergy) {
    at0Data = (at0Data << 3) | (satData & 0x7);
    at1Data = (at1Data << 3) | ((satData & 0x70) >> 4);
    saturation = ((satData & 0x88) == 0x88);
  } else if (at1 == MonDataType::Energy && at0 == MonDataType::SelectedEnergy) {
    at0Data = (at0Data << 3) | ((satData & 0x70) >> 4);
    at1Data = (at1Data << 3) | (satData & 0x7);
    saturation = ((satData & 0x88) == 0x88);
  } else {
    if (at0 == MonDataType::Energy || at0 == MonDataType::SelectedEnergy) {
      at0Data = (at0Data << 3) | (satData & 0x7);
      saturation = (satData & 0x20);
    }
    if (at1 == MonDataType::Energy || at1 == MonDataType::SelectedEnergy) {
      at1Data = (at1Data << 3) | (satData & 0x7);
      saturation = (satData & 0x20);
    }
  }
}

decodeHeader()

unsigned int LArLATOMEDecoder::EventProcess::decodeHeader ( const uint32_t * p, unsigned int offset )

private

now these are taken from the ROD header but the word are still here (maybe we will use them for something else)

Definition at line 238 of file LArLATOMEDecoder.cxx.

                                                                                              {

  int monheadererror = 0;
  int monheadererrorbit = 0;
  if (!compareOrSet(m_latomeID, std::byteswap(p[0 + offset]), m_headerDecoded))
    monheadererror |= (1 << monheadererrorbit++);
  Word l1IDtmp = m_l1ID;
  if (!compareOrSet(l1IDtmp, std::byteswap(p[1 + offset]), m_headerDecoded))
    monheadererror |= (1 << monheadererrorbit++);
  if (l1IDtmp != m_l1ID) {
    ATH_MSG_DEBUG("Mon header L1ID " << l1IDtmp << " different from rod header L1ID " << m_l1ID);
  }
  ATH_MSG_DEBUG(" latomeID: " << m_latomeID << " l1ID: " << m_l1ID);
 
  Word monHeaderMarker = std::byteswap(p[2 + offset]);
  Word monCheckPoint = std::byteswap(p[4 + offset]);
  if (s_monHeaderMarker != monHeaderMarker) {
    monheadererror |= (1 << monheadererrorbit++);
    ATH_MSG_WARNING("Problem in monHeaderMarker: " << monHeaderMarker);
  }
  if (s_monCheckPoint != monCheckPoint) {
    monheadererror |= (1 << monheadererrorbit++);
    ATH_MSG_WARNING("Problem in monCheckPoint: " << monCheckPoint);
  }
 
  if (!compareOrSet(m_nPackets, std::byteswap(p[3 + offset]) >> 24, m_headerDecoded))
    monheadererror |= (1 << monheadererrorbit++);
 
  if (m_nPackets == 0xFF) {
    m_nPackets = 1;
    m_iPacket = 0;
    m_nWordsPerPacket = (std::byteswap(p[3 + offset]) & 0xffffff) / 4.;
  } else {
    if (m_headerDecoded)
      ++m_iPacket;
    else
      m_iPacket = 0;
    if (!compareOrSet(m_iPacket, (std::byteswap(p[3 + offset]) >> 16) & 0xf, m_headerDecoded))
      monheadererror |= (1 << monheadererrorbit++);
    m_nWordsPerPacket = (std::byteswap(p[3 + offset]) & 0xffff) / 4.;
  }
 
  if (!compareOrSet(m_monHeaderSize, std::byteswap(p[5 + offset]), m_headerDecoded))
    monheadererror |= (1 << monheadererrorbit++);

  if (m_monHeaderSize < 18) {
    ATH_MSG_WARNING(" Mon header size should not be less that 18 : =" << m_monHeaderSize << " are you reading old data file?");
    return 0;
  }
 
  ATH_MSG_DEBUG(" nPackets: " << m_nPackets << " iPacket: " << m_iPacket << " nWordsPerPacket: " << m_nWordsPerPacket << " monHeaderSize: " << m_monHeaderSize);

  std::ignore = compareOrSet(m_at0at1Swap, (std::byteswap(p[8 + offset])>>30) & 0x1, m_headerDecoded);
  if (!compareOrSet(m_at0typeRec, std::byteswap(p[9 + offset]), m_headerDecoded))
    monheadererror |= (1 << monheadererrorbit++);
  if (!compareOrSet(m_at1typeRec, std::byteswap(p[12 + offset]), m_headerDecoded))
    monheadererror |= (1 << monheadererrorbit++);
  monheadererrorbit += 2;
 
  if (!compareOrSet(m_at0nBC, std::byteswap(p[10 + offset]), m_headerDecoded))
    monheadererror |= (1 << monheadererrorbit++);
  if (!compareOrSet(m_at1nBC, std::byteswap(p[13 + offset]), m_headerDecoded))
    monheadererror |= (1 << monheadererrorbit++);
  if (!compareOrSet(m_at0BC, std::byteswap(p[11 + offset]), m_headerDecoded))
    monheadererror |= (1 << monheadererrorbit++);
  if (!compareOrSet(m_at1BC, std::byteswap(p[14 + offset]), m_headerDecoded))
    monheadererror |= (1 << monheadererrorbit++);
  if (!compareOrSet(m_activeSC, std::byteswap(p[15 + offset]), m_headerDecoded))
    monheadererror |= (1 << monheadererrorbit++);
  if (!compareOrSet(m_nsc1, std::byteswap(p[16]) >> 24, m_headerDecoded))
    monheadererror |= (1 << monheadererrorbit++);
  if (!compareOrSet(m_nsc2, (std::byteswap(p[16]) >> 16) & 0xff, m_headerDecoded))
    monheadererror |= (1 << monheadererrorbit++);
  if (!compareOrSet(m_nsc3, (std::byteswap(p[16]) >> 8) & 0xff, m_headerDecoded))
    monheadererror |= (1 << monheadererrorbit++);
  if (!compareOrSet(m_nsc4, (std::byteswap(p[16])) & 0xff, m_headerDecoded))
    monheadererror |= (1 << monheadererrorbit++);
  if (!compareOrSet(m_nsc5, std::byteswap(p[17]) >> 24, m_headerDecoded))
    monheadererror |= (1 << monheadererrorbit++);
  if (!compareOrSet(m_nsc6, (std::byteswap(p[17]) >> 16) & 0xff, m_headerDecoded))
    monheadererror |= (1 << monheadererrorbit++);
 
  ATH_MSG_DEBUG("m_at0at1Swap: " << m_at0at1Swap << " at0type " << m_at0typeRec << " at1type " << m_at1typeRec << " at0nBC " << m_at0nBC << " at1nBC " << m_at1nBC << " at0BC " << m_at0BC                          
  << " at1BC " << m_at1BC << " nsc1 " << m_nsc1 << " nsc2 " << m_nsc2 << " nsc3 " << m_nsc3 << " nsc4 " << m_nsc4 << " nsc5 "
                            << m_nsc5 << " nsc6 " << m_nsc6);
 
  if (monheadererror) {
    ATH_MSG_WARNING(" consistency error in mon checker at packet " << m_iPacket << " errorbits " << std::hex << monheadererror << std::dec);
  }
 
  m_headerDecoded = true;
  return m_monHeaderSize + m_nWordsPerPacket + offset;
}

decodeTrailer()

unsigned int LArLATOMEDecoder::EventProcess::decodeTrailer ( const uint32_t * p, unsigned int offset )

private

for now the trailerhas only 2 fixed words, just check them

fixed shift for now but in case we get a dynamic trailer (hopefully not)

Definition at line 228 of file LArLATOMEDecoder.cxx.

                                                                                               {
  if (std::byteswap(p[offset]) != 0xc0ffee00 || std::byteswap(p[offset + 1] != 0xaaaaaaaa)) {
    ATH_MSG_WARNING("Problem in trailer at packet " << m_iPacket << " words " << std::hex << std::byteswap(p[offset]) << ", " << std::byteswap(p[offset + 1])
                                                    << std::dec);
  }
  return offset + m_monTrailerSize;
}

decodeWord()

void LArLATOMEDecoder::EventProcess::decodeWord ( unsigned int & word, unsigned int & wordshift, unsigned int & byteshift, const uint32_t * p )

inlineprivate

Definition at line 380 of file LArLATOMEDecoder.cxx.

                                                                                                                                            {
  unsigned int msb = 0;
  unsigned int lsb = 0;
  decodeByte(msb, wordshift, byteshift, p);
  increaseByteShift(wordshift, byteshift);
  decodeByte(lsb, wordshift, byteshift, p);
  increaseByteShift(wordshift, byteshift);
  word = lsb | (msb << 8);
}

fillCalib()

void LArLATOMEDecoder::EventProcess::fillCalib ( const std::vector< HWIdentifier > * LATOME_Channels, const LArOnOffIdMapping * onoffmap, const LArCalibLineMapping * clmap )

private

accumulated calib digits requested so decode dac and delay from headers

scale to the min nt since we have only one nt per channel and not by sample as with raw data

for loop on SCs

Definition at line 908 of file LArLATOMEDecoder.cxx.

                                                                                                                                                                      {
 
  CaloGain::CaloGain gain=CaloGain::LARHIGHGAIN;
  uint32_t DAC_value=0;
  uint16_t delay_value=0;
  uint16_t isPulsed_value=false; 
  std::unique_ptr<LArCalibParams> calibParams1;
  std::unique_ptr<LArCalibParams> calibParams2;
 
  int pattype = m_nthLATOME >> 16;
  const LArOnOffIdMapping* cabling = 0;
  if (m_caccdigits) {  
    m_caccdigits->setDelayScale(25. / 240.);
 
    SG::ReadCondHandle<LArOnOffIdMapping> cablingHdl{m_decoder->m_cablingKeySC};
    cabling = {*cablingHdl};
    if (!cabling) {
      ATH_MSG_ERROR("Do not have mapping object " << m_decoder->m_cablingKeySC.key());
      return;
    }
 
    calibParams1=std::make_unique<LArCalibParams>();
    calibParams2=std::make_unique<LArCalibParams>();
 
    if (pattype > 0x48) {
      StatusCode sc1 = calibParams1->initialize();
      StatusCode sc2 = calibParams2->initialize();
      if (sc1 != StatusCode::SUCCESS || sc2 != StatusCode::SUCCESS) {
        ATH_MSG_WARNING("could not initialize LArCalibParams, acc calib will not be filled ");
        return;
      }
      if (pattype == 0x49 || pattype == 0x4a) {
 
        calibParams1->set(1, m_latomeCalibPatternsInEvent[0].patterns, {m_latomeCalibPatternsInEvent[0].DAC}, {m_latomeCalibPatternsInEvent[0].delay});
 
        calibParams2->set(1, m_latomeCalibPatternsInEvent[2].patterns, {m_latomeCalibPatternsInEvent[2].DAC}, {m_latomeCalibPatternsInEvent[2].delay});
      } else {
 
        calibParams1->set(1, m_latomeCalibPatternsInEvent[1].patterns, {m_latomeCalibPatternsInEvent[1].DAC}, {m_latomeCalibPatternsInEvent[1].delay});
 
        calibParams2->set(1, m_latomeCalibPatternsInEvent[2].patterns, {m_latomeCalibPatternsInEvent[2].DAC}, {m_latomeCalibPatternsInEvent[2].delay});
      }
    } else {
      StatusCode sc1 = calibParams1->initialize();
      if (sc1 != StatusCode::SUCCESS) {
        ATH_MSG_WARNING("could not initialize LArCalibParams, acc calib will not be filled ");
        return;
      }
      calibParams1->set(1, m_latomeCalibPatternsInEvent[0].patterns, {m_latomeCalibPatternsInEvent[0].DAC}, {m_latomeCalibPatternsInEvent[0].delay});
    }
  }
 
  const HWIdentifier hwidEmpty;
  unsigned nWarnings = 0;
  for (SuperCell ch = 0; ch < N_LATOME_CHANNELS; ++ch) {
    LArCalibParams* calibParams = 0;
    HWIdentifier SCID = ch < (int) LATOME_Channels->size() ? (*LATOME_Channels)[ch] : hwidEmpty;
    if (SCID == hwidEmpty) {
      ATH_MSG_DEBUG("No mapping for ch: " << std::dec << ch);
      continue;
    }
    if (m_decoder->m_ignoreBarrelChannels && m_decoder->m_onlineId->barrel_ec(SCID) == 0)
      continue;
    if (m_decoder->m_ignoreEndcapChannels && m_decoder->m_onlineId->barrel_ec(SCID) == 1)
      continue;
 
    std::vector<uint64_t> sum;
    std::vector<uint64_t> sum2;
    unsigned int ntmin = 9999999;
    for (auto nt : m_averagedRawValuesInEvent[ch].nTrigValid) {
      if (nt < ntmin) {
        ntmin = nt;
      }
    }
    sum.resize(m_averagedRawValuesInEvent[ch].sum.size());
    sum2.resize(m_averagedRawValuesInEvent[ch].sum.size());
 
    if (ntmin > 0) {
      for (unsigned int is = 0; is < m_averagedRawValuesInEvent[ch].sum.size(); ++is) {
        double fsum = (double)m_averagedRawValuesInEvent[ch].sum[is] / m_averagedRawValuesInEvent[ch].nTrigValid[is] * ntmin;
        double fsum2 = (double)m_averagedRawValuesInEvent[ch].sumSq[is] / m_averagedRawValuesInEvent[ch].nTrigValid[is] * ntmin;
        sum[is] = round(fsum);
        sum2[is] = round(fsum2);
      }
    } else {
      std::fill(sum.begin(), sum.end(), 0);
      std::fill(sum2.begin(), sum2.end(), 0);
      if (++nWarnings < 64) {
        ATH_MSG_WARNING("No valid triggers for supercell " << SCID.getString());
      }
    }
    if (m_accdigits) {
      LArAccumulatedDigit* accdigi = new LArAccumulatedDigit(SCID, gain, sum, sum2, ntmin);
      m_accdigits->push_back(accdigi);
    }
    if (m_caccdigits) {
      if (pattype == 0x49 || pattype == 0x4a) {
        if (m_decoder->m_onlineId->barrel_ec(SCID) == 0) {
          calibParams = calibParams1.get();
        } else {
          calibParams = calibParams2.get();
        }
      } else if (pattype == 0x4b || pattype == 0x4c) {
        if (m_decoder->m_onlineId->isHECchannel(SCID)) {
          calibParams = calibParams1.get();
        } else {
          calibParams = calibParams2.get();
        }
      } else {
        calibParams = calibParams1.get();
      }
      unsigned int eventNb = 0;  
      unsigned int numCL = 0;
      unsigned int numPulsedLeg = 0;
      std::vector<Identifier> ccellIds(0);
      Identifier myofflineID = cabling->cnvToIdentifier(SCID);
      ccellIds = m_decoder->m_sc2ccMappingTool->superCellToOfflineID(myofflineID);
      for (Identifier id : ccellIds) {  // loop cells in sc
        HWIdentifier cellLegHWID = cablingLeg->createSignalChannelID(id);
        const std::vector<HWIdentifier>& calibLineLeg = clcabling->calibSlotLine(cellLegHWID);
        numCL += calibLineLeg.size();
        for (HWIdentifier calibLineHWID : calibLineLeg) {  // loop legacy calib lines
          if (calibParams->isPulsed(eventNb, calibLineHWID)) {
            numPulsedLeg += 1;
          }
        }
      }
 
      isPulsed_value = true;
      if (numPulsedLeg != numCL) {
        if (m_decoder->m_keepPulsed)
          continue;
        isPulsed_value = false;
      }
      DAC_value = calibParams->DAC(eventNb, SCID) * numPulsedLeg;
      // Here we want to change the DAC value to reflect the incorrect factors applied in HEC, where some of the cells are much smaller yet have DAC2MeV factors
      // which came from averaging over many cells
      int ft = m_decoder->m_onlineId->feedthrough(SCID);
      int slot = m_decoder->m_onlineId->slot(SCID);
      int channel = m_decoder->m_onlineId->channel(SCID);
      if (m_decoder->m_onlineId->barrel_ec(SCID) == 1 && (ft == 3 || ft == 10 || ft == 16 || ft == 22)) {
        // if it's HEC
        if (slot == 1) {
          if (channel >= 16 && channel <= 31) {  // eta 1.65 bin
            //DAC_value = DAC_value / 1.363; // measured value
            DAC_value = DAC_value / 1.2;   // computed from geometry
            m_decoder->msg(MSG::DEBUG) << "Multiplying DAC for channel " << SCID << "by 1/1.2" << endmsg;
          } else if (channel >= 32 && channel <= 47) {  // eta 1.75 bin
            //DAC_value = DAC_value / 1.206; // measured value
            DAC_value = DAC_value * 7. / 8.; // computed from geometry
            m_decoder->msg(MSG::DEBUG) << "Multiplying DAC for channel " << SCID << "by 7./8." << endmsg;
          }
        }
      }
 
      delay_value = calibParams->Delay(eventNb, SCID);
      LArAccumulatedCalibDigit* accdigi = new LArAccumulatedCalibDigit(SCID, gain, sum, sum2, ntmin, DAC_value, delay_value, isPulsed_value);
 
      m_caccdigits->push_back(accdigi);
    }
 
  }  
  if (nWarnings > 16) {
      ATH_MSG_WARNING("Found " << nWarnings << " supercells with no valid triggers");
  }
}

fillCollection()

void LArLATOMEDecoder::EventProcess::fillCollection	(	const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment *	pROB,
		const std::vector< HWIdentifier > *	LATOME_Channels,
		const LArOnOffIdMapping *	onoffmap = nullptr,
		const LArCalibLineMapping *	clmap = nullptr )

Execute decoding for an event.

some of this info should be used in the LatomeHeader class and for cross checks also (same as for the mon header)

this is an empty fragment, skip it

not we have the packet size from the first packet, check all packet headers before decoding we can decide later if we drop decoding if we have inconsistency

OK all headers checked and we have all info we need to decode each packet, so lets start

for now just getting the ADCs from AT0 Change later to add energy as well and use the BC shift to determine at which BC there is energy

recipe does not have at1, set at1 mux to invalid

lets start from here

start of packet, bcid still unvalid / should increase by one but take care of rotation at s_nBunches;

the data is packed with 64 bits words. Will be padded with 0s at the end of the timeslot time slot.

lets fill now, using the older code structure but this should be change to support having energy.

Loop over SC

Loop over time slots

Loop over BC

Definition at line 448 of file LArLATOMEDecoder.cxx.

                                                                                      {
  const unsigned int sourceID = robFrag->rob_source_id();
  m_l1ID = robFrag->rod_lvl1_id();
  m_ROBFragSize = robFrag->rod_ndata();
  const uint32_t* p = robFrag->rod_data();
  const unsigned int n = robFrag->rod_ndata();
  if (0 == n) {
    ATH_MSG_DEBUG("Empty fragment, skip ");
    return;
  }
  unsigned int offset = decodeHeader(p, 0);
 
  m_latomeBCID = robFrag->rod_bc_id();
  const uint32_t* rod_status = robFrag->rod_status();
  const unsigned int rod_nstatus = robFrag->rod_nstatus();
  if (rod_nstatus != 27) {
    ATH_MSG_WARNING("Inconsistent number of rod header status elements: nstatus= " << rod_nstatus);
    return;
  }
  if (rod_nstatus > 8) {
    uint32_t status8 = rod_status[8];
    m_at0type = status8 & 0x3;
    m_at1type = (status8 >> 2) & 0x3;
    ATH_MSG_DEBUG("before swap: m_at0type " << m_at0type << ", m_at1type " << m_at1type << "swap value " << m_at0at1Swap);
    if(m_at0at1Swap==1){
      std::swap(m_at0type, m_at1type);
      ATH_MSG_DEBUG("after swap: m_at0type " << m_at0type << "m_at1type " << m_at1type);
  }
 
  }
  m_nthLATOME = robFrag->rod_source_id();
  m_LATOMEFW = rod_status[3] & 0x0fff;
 
  LatomeCalibPatterns pat1, pat2, pat3;
  pat1.DAC = rod_status[9];
  pat1.delay = rod_status[10];
  pat1.patterns.resize(4);
  for (unsigned int i = 0; i < 4; ++i)
    pat1.patterns[i] = rod_status[i + 11];
 
  pat2.DAC = rod_status[15];
  pat2.delay = rod_status[16];
  pat2.patterns.resize(4);
  for (unsigned int i = 0; i < 4; ++i)
    pat2.patterns[i] = rod_status[i + 17];
 
  pat3.DAC = rod_status[21];
  pat3.delay = rod_status[22];
  pat3.patterns.resize(4);
  for (unsigned int i = 0; i < 4; ++i)
    pat3.patterns[i] = rod_status[i + 23];
 
  m_latomeCalibPatternsInEvent = {std::move(pat1), std::move(pat2), std::move(pat3)};
 
  const HWIdentifier hwidEmpty;

 
 
  //unsigned int offset = decodeHeader(p, 0);
  if (offset > m_ROBFragSize) {
    ATH_MSG_WARNING("Data corruption, offset found at pos 0 (" << offset << ") is larger than the ROB fragment size (" << m_ROBFragSize << "). Ignoring data.");
    return;
  }
 
  if (m_isAveraged) {
    m_at0type = m_at0typeRec >> 24;
    m_at1type = (int)MonDataType::Invalid;
    if (m_at0type != (int)MonDataType::Averaged) {
      ATH_MSG_WARNING(" inconsistant data type with requested averaged decoding at0 type " << m_at0type << " " << m_at0typeRec << " " << std::hex << m_l1ID
                                                                                           << " " << sourceID << std::dec);
      return;
    }
  }
  if (m_isAutoCorr) {
    m_at0type = m_at0typeRec >> 24;
    m_at1type = (int)MonDataType::Invalid;
    if (m_at0type != (int)MonDataType::AutoCorr) {
      ATH_MSG_WARNING(" inconsistant data type with requested averaged decoding at0 type " << m_at0type << " " << m_at0typeRec << " " << std::hex << m_l1ID
                                                                                           << " " << sourceID << std::dec);
      return;
    }
  }
 
  m_packetEnd.push_back(offset);
  offset = decodeTrailer(p, offset);
  for (unsigned int ip = 1; ip < m_nPackets; ++ip) {
    if (offset > m_ROBFragSize) {
      ATH_MSG_WARNING("Data corruption, offset found at pos 0 (" << offset << ") is larger than the ROB fragment size (" << m_ROBFragSize << "). Ignoring data.");
      return;
    }
 
    offset = decodeHeader(p, offset);
    if (offset > m_ROBFragSize) {
      ATH_MSG_WARNING("Data corruption, offset found at pos 0 (" << offset << ") is larger than the ROB fragment size (" << m_ROBFragSize << "). Ignoring data.");
      return;
    }
    m_packetEnd.push_back(offset);
    offset = decodeTrailer(p, offset);
  }
 
  ATH_MSG_DEBUG(" end of header check computed offset=" << std::dec << offset << " nwords in payload=" << n);

  m_iPacket = 0;
  if (m_nPackets==0) {
    ATH_MSG_WARNING("Data corruption, nPackets=0");
    return;
  }
 
  if (m_nPackets>m_packetEnd.size()) {
    ATH_MSG_WARNING("Data corruption, nPackets " << m_nPackets << " exceeds size " << m_packetEnd.size());
    return;
  }
     
  if (m_packetEnd[m_nPackets - 1] + m_monTrailerSize != n) {
    ATH_MSG_WARNING("problem in packet size loop " << m_packetEnd[m_nPackets - 1] << " != " << n);
  }
 
 
  std::vector<unsigned int> timeslot_nsc = {m_nsc1, m_nsc2, m_nsc3, m_nsc4, m_nsc5, m_nsc6};
  std::vector<unsigned int> bc_size;
 
  short nBC = 0;
  short nBC1 = 0;
  short startBC1 = 0;
  MonDataType type0 = MonDataType::Invalid;
  MonDataType type1 = MonDataType::Invalid;
 
  if (m_isAveraged || m_isAutoCorr) {
    nBC = m_at0nBC;
    nBC1 = m_at1nBC;
    m_nBC_Averaged = nBC;
    startBC1 = 0;
    type0 = static_cast<MonDataType>(m_at0type);
    type1 = static_cast<MonDataType>(m_at1type);
    for (auto& val : m_averagedRawValuesInEvent) {
      val.sum.resize(m_nBC_Averaged);
      val.sumSq.resize(m_nBC_Averaged);
      val.nTrigValid.resize(m_nBC_Averaged);
      val.latomeChannel = 99999;
    }
  } else {
    if (m_at1nBC == 0) {  
      m_at1type = (Word)MonDataType::Invalid;
    }
 
    if (m_at0type != (Word)MonDataType::Invalid && m_at1type != (Word)MonDataType::Invalid) {
      if (m_at0nBC >= m_at1nBC) {
        nBC = m_at0nBC;
        nBC1 = m_at1nBC;
        startBC1 = m_at1BC - m_at0BC;
        type0 = static_cast<MonDataType>(m_at0type);
        type1 = static_cast<MonDataType>(m_at1type);
      } else {
        nBC1 = m_at0nBC;
        nBC = m_at1nBC;
        startBC1 = m_at0BC - m_at1BC;
        type1 = static_cast<MonDataType>(m_at0type);
        type0 = static_cast<MonDataType>(m_at1type);
      }
    } else if (m_at0type != (Word)MonDataType::Invalid) {
      nBC = m_at0nBC;
      type0 = static_cast<MonDataType>(m_at0type);
    } else if (m_at1type != (Word)MonDataType::Invalid) {
      nBC = m_at1nBC;
      type0 = static_cast<MonDataType>(m_at1type);
    } else {
      ATH_MSG_ERROR("No valid data type in Mon Header");
      return;
    }
 
    switch (type0) {
      case MonDataType::RawADC:
        m_hasRawAdc = true;
        m_nBC_rawADC = nBC;
        break;
      case MonDataType::ADC:
        m_hasAdc = true;
        m_nBC_ADC = nBC;
        break;
      case MonDataType::Energy:
        m_hasE = true;
        m_nBC_E = nBC;
        break;
      case MonDataType::SelectedEnergy:
        m_hasEID = true;
        m_nBC_EID = nBC;
        break;
      case MonDataType::Invalid:
        break;
      default:
        ATH_MSG_ERROR("wrong mux0 value " << (Word)type0);
        return;
    }
 
    switch (type1) {
      case MonDataType::RawADC:
        m_hasRawAdc = true;
        m_nBC_rawADC = nBC1;
        m_BC_rawADC = startBC1;
        break;
      case MonDataType::ADC:
        m_hasAdc = true;
        m_nBC_ADC = nBC1;
        m_BC_ADC = startBC1;
        break;
      case MonDataType::Energy:
        m_hasE = true;
        m_nBC_E = nBC1;
        m_BC_E = startBC1;
        break;
      case MonDataType::SelectedEnergy:
        m_hasEID = true;
        m_nBC_EID = nBC1;
        m_BC_EID = startBC1;
        break;
      case MonDataType::Invalid:
        break;
      default:
        ATH_MSG_ERROR("wrong mux1 value " << (Word)type1);
        return;
    }
 
    for (auto& val : m_rawValuesInEvent) {
      if (m_hasRawAdc)
        val.adc.resize(m_nBC_rawADC);
      if (m_hasAdc)
        val.adc_bas.resize(m_nBC_ADC);
      if (m_hasE)
        val.et.resize(m_nBC_E);
      if (m_hasEID)
        val.et_id.resize(m_nBC_EID);
      if (m_hasEID || m_hasE) {
        val.saturation.resize(std::max(m_nBC_EID, m_nBC_E));
      }
 
      val.latomeChannel = 99999;
    }
  }
 
  m_BCIDsInEvent.resize(nBC);
 
  unsigned int s = m_monHeaderSize;  
  unsigned int bcid = s_nBunches;
 
  for (short iBC = 0; iBC < nBC; ++iBC) {
    MonDataType at0 = type0;
    MonDataType at1 = type1;
    if (type1 != MonDataType::Invalid) {
      if (iBC < startBC1 || iBC >= startBC1 + nBC1)
        at1 = MonDataType::Invalid;
    }
    unsigned int nbytesPerChannel = bytesPerChannel(at0, at1);
 
    int nsc = 0;
    unsigned int oldipacket = 0;
    for (unsigned int itimeslot = 0; itimeslot < 6; ++itimeslot) {
      unsigned int l_bcid = (std::byteswap(p[s]))>>16;
      if(itimeslot!=0){
    if(l_bcid!=bcid){
      ATH_MSG_WARNING( "ERROR: inconsistent BCID between time slots" );
    }
      }
      else{
    if(bcid!=s_nBunches){ 
      unsigned int bcid_c = bcid+1;
      if(bcid_c==s_nBunches){
            bcid=0;
        bcid_c = 0;
      }
      if(bcid_c != l_bcid){
       ATH_MSG_WARNING( "ERROR: BCID not increasing properly between samples, sourceId: " << m_nthLATOME << " L1ID is: " << m_l1ID << ", BCID is from payload: " << l_bcid << ", expected BCID is: " << bcid_c << ", LATOME channel is: " << nsc );
      }
    }
    m_BCIDsInEvent[iBC] = l_bcid;
      }
      bcid=l_bcid;
 
      unsigned int mux = ((std::byteswap(p[s])) >> 8) & 0xff;
      increaseWordShift(s);
      increaseWordShift(s);
      if (s >= n)
        break;
 
      unsigned int timeslotsize = timeslot_nsc[itimeslot];
      unsigned int nbytes = timeslotsize * nbytesPerChannel;
      unsigned int n64word = nbytes / 8;  
      if (nbytes % 8)
        ++n64word;
      ATH_MSG_DEBUG(" at BC " << iBC << " timeslot " << itimeslot << "  " << bcid << "  " << mux << " n64word " << n64word << " at0 " << (int)at0 << " at1 "
                              << (int)at1 << " l_bcid " << bcid);
 
      unsigned int wordshift = s;
      unsigned int byteshift = 0;

      oldipacket = m_iPacket;
      for (unsigned int ichan = 0; ichan < timeslotsize; ++ichan) {
        unsigned int at0Data = 0, at1Data = 0, satData = 0;
        bool at0val = false, at1val = false;
 
        // protection against corrupted bytestream data
        if (nsc > N_LATOME_CHANNELS - 1) {
          break;
          // FIXME: should fill some default data to all channels, because clearly this block is corrupted
        }
        if (!m_isAveraged && !m_isAutoCorr) {
          decodeChannel(wordshift, byteshift, p, at0, at1, at0Data, at1Data, satData, at0val, at1val);
          ATH_MSG_DEBUG(" wordshift " << wordshift << " byteshift " << byteshift << " at0data " << at0Data << " at1Data " << at1Data << " satData " << satData
                                      << " at0val " << at0val << " at1val " << at1val << " nsc " << nsc);

          const HWIdentifier SCID = nsc < (int) LATOME_Channels->size() ? (*LATOME_Channels)[nsc] : hwidEmpty;
          if (SCID == hwidEmpty) {
            ATH_MSG_DEBUG("No mapping for ch: " << std::dec << nsc);
          }
          int RAWValue0 = -999;
          if (!at0val && SCID != hwidEmpty && at0 != MonDataType::Invalid) {
            ATH_MSG_DEBUG("at0 bad quality bit for SC:" << nsc << " BC " << iBC << " latome " << robFrag->rod_source_id());
          } else {
            RAWValue0 = at0Data;
          }
          int defaultADCValue = -1;
          int defaultEValue = -99999;
          auto& rawValuesInEvent = m_rawValuesInEvent[nsc];
          switch (at0) {
            case MonDataType::RawADC:
              if ((unsigned)iBC < rawValuesInEvent.adc.size()) {
                rawValuesInEvent.adc[iBC] = (at0val) ? RAWValue0 : defaultADCValue;
              }
              break;
            case MonDataType::ADC:
              if ((unsigned)iBC < rawValuesInEvent.adc_bas.size()) {
                rawValuesInEvent.adc_bas[iBC] = (at0val) ? RAWValue0 : defaultADCValue;
              }
              break;
            case MonDataType::Energy:
              if ((unsigned)iBC < rawValuesInEvent.et.size()) {
                rawValuesInEvent.et[iBC] = (at0val) ? signEnergy(RAWValue0) : defaultEValue;
                rawValuesInEvent.saturation[iBC] = satData;
              }
              break;
            case MonDataType::SelectedEnergy:
              if ((unsigned)iBC < rawValuesInEvent.et_id.size()) {
                rawValuesInEvent.et_id[iBC] = (at0val) ? signEnergy(RAWValue0) : defaultEValue;
                rawValuesInEvent.saturation[iBC] = satData;
              }
              break;
            case MonDataType::Invalid:
              break;
            default:
              ATH_MSG_ERROR("wrong at0 value " << (Word)at0);
              return;
          }
 
          int RAWValue1 = -999;
          if (!at1val && SCID != hwidEmpty && at1 != MonDataType::Invalid) {
            ATH_MSG_DEBUG("at1 bad quality bit for SC:" << nsc << " BC " << iBC << " latome " << robFrag->rod_source_id());
          } else {
            RAWValue1 = at1Data;
          }
 
          const size_t BCidx = iBC - startBC1;
          switch (at1) {
            case MonDataType::RawADC:
              if (BCidx < rawValuesInEvent.adc.size()) {
                rawValuesInEvent.adc[BCidx] = (at1val) ? RAWValue1 : defaultADCValue;
              }
              break;
            case MonDataType::ADC:
              if (BCidx < rawValuesInEvent.adc_bas.size()) {
                rawValuesInEvent.adc_bas[BCidx] = (at1val) ? RAWValue1 : defaultADCValue;
              }
              break;
            case MonDataType::Energy:
              if (BCidx < rawValuesInEvent.et.size()) {
                rawValuesInEvent.et[BCidx] = (at1val) ? signEnergy(RAWValue1) : defaultEValue;
                rawValuesInEvent.saturation[BCidx] = satData;
              }
              break;
            case MonDataType::SelectedEnergy:
              if (BCidx < rawValuesInEvent.et_id.size()) {
                m_rawValuesInEvent[nsc].et_id[BCidx] = (at1val) ? signEnergy(RAWValue1) : defaultEValue;
                m_rawValuesInEvent[nsc].saturation[BCidx] = satData;
              }
              break;
            case MonDataType::Invalid:
              break;
            default:
              ATH_MSG_ERROR("wrong at1 value " << (Word)at1);
              return;
          }
 
          m_rawValuesInEvent[nsc].latomeChannel = nsc;
 
        } else {
          if (wordshift % 2) {
            ATH_MSG_ERROR("inconsistant wordshift in decoding everaged data");
            return;
          }
          unsigned int averageword = std::byteswap(p[wordshift]);
          wordshift += 1;
          unsigned int sumSq = std::byteswap(p[wordshift]);
          wordshift += 1;
          unsigned long long sumsqMSB = averageword >> 28;
          sumsqMSB = sumsqMSB << 32;
 
          m_averagedRawValuesInEvent[nsc].sum[iBC] = averageword & 0xFFFFF;
          m_averagedRawValuesInEvent[nsc].sumSq[iBC] = sumSq | sumsqMSB;
          m_averagedRawValuesInEvent[nsc].nTrigValid[iBC] = (averageword >> 20) & 0xFF;
          m_averagedRawValuesInEvent[nsc].latomeChannel = nsc;
        }
 
        ++nsc;
 
      }  

      if(byteshift!=0){
      increaseWordShift(wordshift);
      byteshift=0;
      }
      ATH_MSG_DEBUG("wordshift before: " << wordshift << ", s: " << s);
      if ((wordshift - s) % 2)
        increaseWordShift(wordshift);
      ATH_MSG_DEBUG("wordshift after : " << wordshift << ", s: " << s);
      if ((wordshift - s - ((m_iPacket - oldipacket) * (m_monHeaderSize + m_monTrailerSize))) != n64word * 2) {
        ATH_MSG_WARNING(" ERROR: time slice end is not padded properly " << (wordshift - s - m_iPacket * (m_monHeaderSize + m_monTrailerSize))
                                                                         << "!=" << n64word * 2 << " m_ipacket " << m_iPacket);
      }
      s = wordshift;
      oldipacket = m_iPacket;
    }  
 
  }  
 
  if (!m_isAveraged && !m_isAutoCorr) {
    fillRaw(LATOME_Channels);
  } else {
    if (onoffmap && clmap) {
      fillCalib(LATOME_Channels, onoffmap, clmap);
    } else {
      ATH_MSG_ERROR("Do not have mapping !!!");
    }
  }
  fillHeader();
}

fillHeader()

void LArLATOMEDecoder::EventProcess::fillHeader ( )

private

Definition at line 1153 of file LArLATOMEDecoder.cxx.

                                              {
 
  if (m_header_coll) {
    LArLATOMEHeader* latome = new LArLATOMEHeader(m_nthLATOME, m_latomeID, m_activeSC, m_latomeBCID, m_l1ID, m_ROBFragSize, m_LATOMEFW);
    m_header_coll->push_back(latome);
  }
}

fillRaw()

void LArLATOMEDecoder::EventProcess::fillRaw ( const std::vector< HWIdentifier > * LATOME_Channels )

private

Pass ADC values from an event.

don't copy vectors for nothing

need to shift the BCID as well do it at the same time

Definition at line 1077 of file LArLATOMEDecoder.cxx.

                                                                                         {
  // const CaloGain::CaloGain dummyGain = CaloGain::LARHIGHGAIN;
  const HWIdentifier hwidEmpty;
  for (SuperCell ch = 0; ch < N_LATOME_CHANNELS; ++ch) {
    const HWIdentifier SCID = ch < (int) LATOME_Channels->size() ? (*LATOME_Channels)[ch] : hwidEmpty;
    if (SCID == hwidEmpty) {
      ATH_MSG_DEBUG("No mapping for ch: " << std::dec << ch);
      continue;
    }
    if (m_decoder->m_ignoreBarrelChannels && m_decoder->m_onlineId->barrel_ec(SCID) == 0)
      continue;
    if (m_decoder->m_ignoreEndcapChannels && m_decoder->m_onlineId->barrel_ec(SCID) == 1)
      continue;
 
    std::vector<short> adcValues_inChannel_inEvent;
 
    if (m_hasRawAdc) {  
      adcValues_inChannel_inEvent = m_rawValuesInEvent[ch].adc;
    }
 
    if (m_hasRawAdc && m_adc_coll) {
 
      std::vector<unsigned short> bcid_in_event;
      for (short b = m_BC_rawADC; b < m_BC_rawADC + m_nBC_rawADC; ++b) {
        bcid_in_event.push_back(m_BCIDsInEvent[b]);
      }
 
      LArSCDigit* scDigit = new LArSCDigit(SCID, m_rawValuesInEvent[ch].latomeChannel, m_nthLATOME, adcValues_inChannel_inEvent, bcid_in_event);
      m_adc_coll->push_back(scDigit);
    }
 
    if (m_hasAdc && m_adc_bas_coll) {
      std::vector<unsigned short> bcid_in_event;
      if (m_nBC_ADC == (short)m_BCIDsInEvent.size()) {
        bcid_in_event = m_BCIDsInEvent;
      } else {
        for (short b = m_BC_ADC; b < m_BC_ADC + m_nBC_ADC; ++b) {
          bcid_in_event.push_back(m_BCIDsInEvent[b]);
        }
      }
      LArSCDigit* scDigit = new LArSCDigit(SCID, m_rawValuesInEvent[ch].latomeChannel, m_nthLATOME, m_rawValuesInEvent[ch].adc_bas, bcid_in_event);
      m_adc_bas_coll->push_back(scDigit);
    }
 
    if (m_hasE && m_et_coll) {
      std::vector<unsigned short> bcid_in_event;
      if (m_nBC_E == (unsigned short)m_BCIDsInEvent.size()) {
        bcid_in_event = m_BCIDsInEvent;
      } else {
        for (short b = m_BC_E; b < m_BC_E + m_nBC_E; ++b) {
          bcid_in_event.push_back(m_BCIDsInEvent[b]);
        }
      }
      LArRawSC* scDigit =
          new LArRawSC(SCID, m_rawValuesInEvent[ch].latomeChannel, m_nthLATOME, m_rawValuesInEvent[ch].et, bcid_in_event, m_rawValuesInEvent[ch].saturation);
      m_et_coll->push_back(scDigit);
    }
 
    if (m_hasEID && m_et_id_coll) {
      std::vector<unsigned short> bcid_in_event;
      if (m_nBC_EID == (short)m_BCIDsInEvent.size()) {
        bcid_in_event = m_BCIDsInEvent;
      } else {
        for (short b = m_BC_EID; b < m_BC_EID + m_nBC_EID; ++b) {
          bcid_in_event.push_back(m_BCIDsInEvent[b]);
        }
      }
      LArRawSC* scDigit =
          new LArRawSC(SCID, m_rawValuesInEvent[ch].latomeChannel, m_nthLATOME, m_rawValuesInEvent[ch].et_id, bcid_in_event, m_rawValuesInEvent[ch].saturation);
      m_et_id_coll->push_back(scDigit);
    }
  }
}

increaseByteShift()

void LArLATOMEDecoder::EventProcess::increaseByteShift ( unsigned int & wordshift, unsigned int & byteshift )

inlineprivate

Definition at line 368 of file LArLATOMEDecoder.cxx.

                                                                                                            {
  ++byteshift;
  if (byteshift == 4) {
    increaseWordShift(wordshift);
    byteshift = 0;
  }
}

increaseWordShift()

void LArLATOMEDecoder::EventProcess::increaseWordShift ( unsigned int & wordshift )

inlineprivate

Definition at line 359 of file LArLATOMEDecoder.cxx.

                                                                                   {
  ++wordshift;
  if (m_packetEnd[m_iPacket] == wordshift) {
    ++m_iPacket;
    wordshift += (m_monHeaderSize + m_monTrailerSize);
    ATH_MSG_DEBUG("switch packet " << m_iPacket << "  " << wordshift);
  }
}

initMessaging()

void AthMessaging::initMessaging ( ) const

privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

{
  m_imsg = Athena::getMessageSvc();
  // If user did not set an explicit level, set a default
  if (m_lvl == MSG::NIL) {
    m_lvl = m_imsg ?
      static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
      MSG::INFO;
  }
}

msg() [1/2]

MsgStream & AthMessaging::msg ( ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 167 of file AthMessaging.h.

{
  MsgStream* ms = m_msg_tls.get();
  if (!ms) {
    if (!m_initialized.test_and_set()) initMessaging();
    ms = new MsgStream(m_imsg,m_nm);
    m_msg_tls.reset( ms );
  }
 
  ms->setLevel (m_lvl);
  return *ms;
}

msg() [2/2]

MsgStream & AthMessaging::msg ( const MSG::Level lvl ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 182 of file AthMessaging.h.

{ return msg() << lvl; }

msgLvl()

bool AthMessaging::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Test the output level.

Parameters

lvl	The message level to test against

Returns

boolean Indicating if messages at given level will be printed

Return values

true	Messages at level "lvl" will be printed

Definition at line 151 of file AthMessaging.h.

{
  // If user did not set explicit message level we have to initialize
  // the messaging and retrieve the default via the MessageSvc.
  if (m_lvl==MSG::NIL && !m_initialized.test_and_set()) initMessaging();
 
  if (m_lvl <= lvl) {
    msg() << lvl;
    return true;
  } else {
    return false;
  }
}

setLevel()

void AthMessaging::setLevel ( MSG::Level lvl )

inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

{
  m_lvl = lvl;
}

signEnergy()

int LArLATOMEDecoder::EventProcess::signEnergy ( unsigned int energy )

inlineprivate

Definition at line 336 of file LArLATOMEDecoder.cxx.

                                                                       {
 
  if (energy & (1 << 17))
    return energy - pow(2, 18);
  else
    return energy;
}

Member Data Documentation

ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT

mutableprivateinherited

Messaging initialized (initMessaging).

Definition at line 141 of file AthMessaging.h.

m_accdigits

LArAccumulatedDigitContainer* LArLATOMEDecoder::EventProcess::m_accdigits {}

private

Definition at line 238 of file LArLATOMEDecoder.h.

{};

m_activeSC

Word LArLATOMEDecoder::EventProcess::m_activeSC {}

private

Definition at line 206 of file LArLATOMEDecoder.h.

{};

m_adc_bas_coll

LArDigitContainer* LArLATOMEDecoder::EventProcess::m_adc_bas_coll {}

private

Definition at line 235 of file LArLATOMEDecoder.h.

{};

m_adc_coll

LArDigitContainer* LArLATOMEDecoder::EventProcess::m_adc_coll {}

private

Definition at line 234 of file LArLATOMEDecoder.h.

{};

m_at0at1Swap

Word LArLATOMEDecoder::EventProcess::m_at0at1Swap {}

private

Definition at line 197 of file LArLATOMEDecoder.h.

{};

m_at0BC

Word LArLATOMEDecoder::EventProcess::m_at0BC {}

private

Definition at line 204 of file LArLATOMEDecoder.h.

{};

m_at0nBC

Word LArLATOMEDecoder::EventProcess::m_at0nBC {}

private

Definition at line 202 of file LArLATOMEDecoder.h.

{};

m_at0type

Word LArLATOMEDecoder::EventProcess::m_at0type {}

private

Definition at line 200 of file LArLATOMEDecoder.h.

{};

m_at0typeRec

Word LArLATOMEDecoder::EventProcess::m_at0typeRec {}

private

Definition at line 198 of file LArLATOMEDecoder.h.

{};

m_at1BC

Word LArLATOMEDecoder::EventProcess::m_at1BC {}

private

Definition at line 205 of file LArLATOMEDecoder.h.

{};

m_at1nBC

Word LArLATOMEDecoder::EventProcess::m_at1nBC {}

private

Definition at line 203 of file LArLATOMEDecoder.h.

{};

m_at1type

Word LArLATOMEDecoder::EventProcess::m_at1type {}

private

Definition at line 201 of file LArLATOMEDecoder.h.

{};

m_at1typeRec

Word LArLATOMEDecoder::EventProcess::m_at1typeRec {}

private

Definition at line 199 of file LArLATOMEDecoder.h.

{};

m_averagedRawValuesInEvent

std::vector<LatomeAveragedRawData> LArLATOMEDecoder::EventProcess::m_averagedRawValuesInEvent

private

Definition at line 247 of file LArLATOMEDecoder.h.

m_BC_ADC

short LArLATOMEDecoder::EventProcess::m_BC_ADC {}

private

Definition at line 222 of file LArLATOMEDecoder.h.

{};

m_BC_E

short LArLATOMEDecoder::EventProcess::m_BC_E {}

private

Definition at line 223 of file LArLATOMEDecoder.h.

{};

m_BC_EID

short LArLATOMEDecoder::EventProcess::m_BC_EID {}

private

Definition at line 224 of file LArLATOMEDecoder.h.

{};

m_BC_rawADC

short LArLATOMEDecoder::EventProcess::m_BC_rawADC {}

private

Definition at line 221 of file LArLATOMEDecoder.h.

{};

m_BCIDsInEvent

std::vector<unsigned short> LArLATOMEDecoder::EventProcess::m_BCIDsInEvent

private

Definition at line 245 of file LArLATOMEDecoder.h.

m_caccdigits

LArAccumulatedCalibDigitContainer* LArLATOMEDecoder::EventProcess::m_caccdigits {}

private

Definition at line 239 of file LArLATOMEDecoder.h.

{};

m_decoder

const LArLATOMEDecoder* LArLATOMEDecoder::EventProcess::m_decoder {}

private

Definition at line 233 of file LArLATOMEDecoder.h.

{};

m_et_coll

LArRawSCContainer* LArLATOMEDecoder::EventProcess::m_et_coll {}

private

Definition at line 236 of file LArLATOMEDecoder.h.

{};

m_et_id_coll

LArRawSCContainer* LArLATOMEDecoder::EventProcess::m_et_id_coll {}

private

Definition at line 237 of file LArLATOMEDecoder.h.

{};

m_hasAdc

bool LArLATOMEDecoder::EventProcess::m_hasAdc {}

private

Definition at line 227 of file LArLATOMEDecoder.h.

{};

m_hasE

bool LArLATOMEDecoder::EventProcess::m_hasE {}

private

Definition at line 228 of file LArLATOMEDecoder.h.

{};

m_hasEID

bool LArLATOMEDecoder::EventProcess::m_hasEID {}

private

Definition at line 229 of file LArLATOMEDecoder.h.

{};

m_hasRawAdc

bool LArLATOMEDecoder::EventProcess::m_hasRawAdc {}

private

Definition at line 226 of file LArLATOMEDecoder.h.

{};

m_header_coll

LArLATOMEHeaderContainer* LArLATOMEDecoder::EventProcess::m_header_coll {}

private

Definition at line 240 of file LArLATOMEDecoder.h.

{};

m_headerDecoded

bool LArLATOMEDecoder::EventProcess::m_headerDecoded {}

private

Definition at line 213 of file LArLATOMEDecoder.h.

{};

m_imsg

std::atomic<IMessageSvc*> AthMessaging::m_imsg { nullptr }

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

{ nullptr };

m_iPacket

Word LArLATOMEDecoder::EventProcess::m_iPacket {}

private

Definition at line 191 of file LArLATOMEDecoder.h.

{};

m_isAutoCorr

bool LArLATOMEDecoder::EventProcess::m_isAutoCorr {}

private

Definition at line 231 of file LArLATOMEDecoder.h.

{};

m_isAveraged

bool LArLATOMEDecoder::EventProcess::m_isAveraged {}

private

Definition at line 230 of file LArLATOMEDecoder.h.

{};

m_l1ID

Word LArLATOMEDecoder::EventProcess::m_l1ID {}

private

Definition at line 187 of file LArLATOMEDecoder.h.

{};

m_latomeBCID

Word LArLATOMEDecoder::EventProcess::m_latomeBCID {}

private

Definition at line 184 of file LArLATOMEDecoder.h.

{};

m_latomeCalibPatternsInEvent

std::vector<LatomeCalibPatterns> LArLATOMEDecoder::EventProcess::m_latomeCalibPatternsInEvent

private

Definition at line 248 of file LArLATOMEDecoder.h.

m_LATOMEFW

Word LArLATOMEDecoder::EventProcess::m_LATOMEFW {}

private

Definition at line 189 of file LArLATOMEDecoder.h.

{};

m_latomeID

Word LArLATOMEDecoder::EventProcess::m_latomeID {}

private

Definition at line 186 of file LArLATOMEDecoder.h.

{};

m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

{ MSG::NIL };

m_monHeaderSize

Word LArLATOMEDecoder::EventProcess::m_monHeaderSize {}

private

Definition at line 193 of file LArLATOMEDecoder.h.

{};

m_monTrailerSize

const Word LArLATOMEDecoder::EventProcess::m_monTrailerSize =2

staticprivate

some cached info to ease processing reading from data header

Definition at line 178 of file LArLATOMEDecoder.h.

m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls

mutableprivateinherited

MsgStream instance (a std::cout like with print-out levels).

Definition at line 132 of file AthMessaging.h.

m_nBC_ADC

short LArLATOMEDecoder::EventProcess::m_nBC_ADC {}

private

Definition at line 216 of file LArLATOMEDecoder.h.

{};

m_nBC_Averaged

short LArLATOMEDecoder::EventProcess::m_nBC_Averaged {}

private

Definition at line 219 of file LArLATOMEDecoder.h.

{};

m_nBC_E

short LArLATOMEDecoder::EventProcess::m_nBC_E {}

private

Definition at line 217 of file LArLATOMEDecoder.h.

{};

m_nBC_EID

short LArLATOMEDecoder::EventProcess::m_nBC_EID {}

private

Definition at line 218 of file LArLATOMEDecoder.h.

{};

m_nBC_rawADC

short LArLATOMEDecoder::EventProcess::m_nBC_rawADC {}

private

Definition at line 215 of file LArLATOMEDecoder.h.

{};

m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

m_nPackets

Word LArLATOMEDecoder::EventProcess::m_nPackets {}

private

Definition at line 190 of file LArLATOMEDecoder.h.

{};

m_nsc1

Word LArLATOMEDecoder::EventProcess::m_nsc1 {}

private

Definition at line 207 of file LArLATOMEDecoder.h.

{};

m_nsc2

Word LArLATOMEDecoder::EventProcess::m_nsc2 {}

private

Definition at line 208 of file LArLATOMEDecoder.h.

{};

m_nsc3

Word LArLATOMEDecoder::EventProcess::m_nsc3 {}

private

Definition at line 209 of file LArLATOMEDecoder.h.

{};

m_nsc4

Word LArLATOMEDecoder::EventProcess::m_nsc4 {}

private

Definition at line 210 of file LArLATOMEDecoder.h.

{};

m_nsc5

Word LArLATOMEDecoder::EventProcess::m_nsc5 {}

private

Definition at line 211 of file LArLATOMEDecoder.h.

{};

m_nsc6

Word LArLATOMEDecoder::EventProcess::m_nsc6 {}

private

Definition at line 212 of file LArLATOMEDecoder.h.

{};

m_nStreams

Word LArLATOMEDecoder::EventProcess::m_nStreams {}

private

Definition at line 195 of file LArLATOMEDecoder.h.

{};

m_nthLATOME

unsigned int LArLATOMEDecoder::EventProcess::m_nthLATOME = 0

private

Definition at line 243 of file LArLATOMEDecoder.h.

m_nWordsPerPacket

Word LArLATOMEDecoder::EventProcess::m_nWordsPerPacket {}

private

Definition at line 192 of file LArLATOMEDecoder.h.

{};

m_packetEnd

std::vector<Word> LArLATOMEDecoder::EventProcess::m_packetEnd

private

Definition at line 181 of file LArLATOMEDecoder.h.

m_rawValuesInEvent

std::vector<LatomeRawData> LArLATOMEDecoder::EventProcess::m_rawValuesInEvent

private

Definition at line 246 of file LArLATOMEDecoder.h.

m_region

Word LArLATOMEDecoder::EventProcess::m_region {}

private

Definition at line 194 of file LArLATOMEDecoder.h.

{};

m_ROBFragSize

Word LArLATOMEDecoder::EventProcess::m_ROBFragSize {}

private

Definition at line 188 of file LArLATOMEDecoder.h.

{};

m_streamNumber

Word LArLATOMEDecoder::EventProcess::m_streamNumber {}

private

Definition at line 196 of file LArLATOMEDecoder.h.

{};

s_monCheckPoint

const Word LArLATOMEDecoder::EventProcess::s_monCheckPoint =0xdeadbeef

staticprivate

Definition at line 180 of file LArLATOMEDecoder.h.

s_monHeaderMarker

const Word LArLATOMEDecoder::EventProcess::s_monHeaderMarker =0xff1234ff

staticprivate

this is fixed and not read from data

Definition at line 179 of file LArLATOMEDecoder.h.

---

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

• LArLATOMEDecoder.h
• LArLATOMEDecoder.cxx