ATLAS Offline Software
Public Types | Public Member Functions | Private Types | Private Member Functions | Private Attributes | Static Private Attributes | List of all members
LArLATOMEDecoder::EventProcess Class Reference
Inheritance diagram for LArLATOMEDecoder::EventProcess:
Collaboration 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. More...
 
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 LArLATOMEMapping *map, const LArOnOffIdMapping *onoffmap=nullptr, const LArCalibLineMapping *clmap=nullptr)
 Execute decoding for an event. More...
 
bool msgLvl (const MSG::Level lvl) const
 Test the output level. More...
 
MsgStream & msg () const
 The standard message stream. More...
 
MsgStream & msg (const MSG::Level lvl) const
 The standard message stream. More...
 
void setLevel (MSG::Level lvl)
 Change the current logging level. More...
 

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 LArLATOMEMapping *map)
 Pass ADC values from an event. More...
 
void fillCalib (const LArLATOMEMapping *map, const LArOnOffIdMapping *onoffmap, const LArCalibLineMapping *clmap)
 
void fillHeader ()
 
void initMessaging () const
 Initialize our message level and MessageSvc. More...
 

Private Attributes

std::vector< Wordm_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_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 LArLATOMEDecoderm_decoder {}
 
LArDigitContainerm_adc_coll {}
 
LArDigitContainerm_adc_bas_coll {}
 
LArRawSCContainerm_et_coll {}
 
LArRawSCContainerm_et_id_coll {}
 
LArAccumulatedDigitContainerm_accdigits {}
 
LArAccumulatedCalibDigitContainerm_caccdigits {}
 
LArLATOMEHeaderContainerm_header_coll {}
 
unsigned int m_nthLATOME = 0
 
std::vector< unsigned short > m_BCIDsInEvent
 
std::vector< LatomeRawDatam_rawValuesInEvent
 
std::vector< LatomeAveragedRawDatam_averagedRawValuesInEvent
 
std::vector< LatomeCalibPatternsm_latomeCalibPatternsInEvent
 
std::string m_nm
 Message source name. More...
 
boost::thread_specific_ptr< MsgStream > m_msg_tls
 MsgStream instance (a std::cout like with print-out levels) More...
 
std::atomic< IMessageSvc * > m_imsg { nullptr }
 MessageSvc pointer. More...
 
std::atomic< MSG::Level > m_lvl { MSG::NIL }
 Current logging level. More...
 
std::atomic_flag m_initialized ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
 Messaging initialized (initMessaging) More...
 

Static Private Attributes

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

Detailed Description

Definition at line 129 of file LArLATOMEDecoder.h.

Member Typedef Documentation

◆ NumWord

Definition at line 134 of file LArLATOMEDecoder.h.

◆ Packet

Definition at line 135 of file LArLATOMEDecoder.h.

◆ Path

Definition at line 138 of file LArLATOMEDecoder.h.

◆ Sample

Definition at line 137 of file LArLATOMEDecoder.h.

◆ SuperCell

Definition at line 136 of file LArLATOMEDecoder.h.

◆ 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 133 of file LArLATOMEDecoder.h.

Member Enumeration Documentation

◆ MODE

Enumerator
MON_HEADER 
PAYLOAD 
MON_TRAILER 

Definition at line 174 of file LArLATOMEDecoder.h.

174  {
176  };

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 135 of file LArLATOMEDecoder.cxx.

138  : AthMessaging(Gaudi::svcLocator()->service<IMessageSvc>("MessageSvc"), "LArLATOMEDecoder::EventProcess"),
139  m_decoder(decoderInput),
140  m_adc_coll(adc_coll),
141  m_adc_bas_coll(adc_bas_coll),
142  m_et_coll(et_coll),
143  m_et_id_coll(et_id_coll),
144  m_accdigits(accdigits),
145  m_caccdigits(caccdigits),
146  m_header_coll(header_coll) {
147  m_latomeID = 0;
148  m_l1ID = 0;
149  m_ROBFragSize = 0;
150  m_nPackets = 0;
151  m_iPacket = 0;
152  m_nWordsPerPacket = 0;
153  m_monHeaderSize = 0;
154  m_region = 0;
155  m_nStreams = 0;
156  m_streamNumber = 0;
161  m_at0nBC = 0;
162  m_at1nBC = 0;
163  m_at0BC = 0;
164  m_at1BC = 0;
165  m_activeSC = 0;
166  m_nsc1 = 0;
167  m_nsc2 = 0;
168  m_nsc3 = 0;
169  m_nsc4 = 0;
170  m_nsc5 = 0;
171  m_nsc6 = 0;
172  m_headerDecoded = false;
173 
174  m_nBC_rawADC = 0;
175  m_nBC_ADC = 0;
176  m_nBC_E = 0;
177  m_nBC_EID = 0;
178 
179  m_nBC_Averaged = 0;
180 
181  m_BC_rawADC = 0;
182  m_BC_ADC = 0;
183  m_BC_E = 0;
184  m_BC_EID = 0;
185 
186  m_hasRawAdc = false;
187  m_hasAdc = false;
188  m_hasE = false;
189  m_hasEID = false;
190 
191  m_isAveraged = (m_caccdigits != 0);
192  m_isAutoCorr = (m_accdigits != 0);
193 
194  if (!m_isAveraged && !m_isAutoCorr) {
196  } else {
199  }
200 }

Member Function Documentation

◆ bytesPerChannel()

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

Definition at line 325 of file LArLATOMEDecoder.cxx.

325  {
326  unsigned int b = 0;
327  if (at0 == MonDataType::Averaged || at0 == MonDataType::AutoCorr)
328  return 8;
329 
331  if (at0 != MonDataType::Invalid)
332  b += 2;
333  if (at1 != MonDataType::Invalid)
334  b += 2;
336  ++b;
337  return b;
338 }

◆ compareOrSet()

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

Definition at line 202 of file LArLATOMEDecoder.cxx.

202  {
203  if (!compare) {
204  param = value;
205  return true;
206  }
207  return param == value;
208 }

◆ decodeByte()

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

Definition at line 357 of file LArLATOMEDecoder.cxx.

357  {
358  byte = ((bswap_32(p[wordshift])) >> (8 * (4 - 1 - byteshift))) & 0xff;
359 }

◆ 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 
)
private

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 371 of file LArLATOMEDecoder.cxx.

372  {
373 
374  // the structure of data is always consisting of 2,3,4 or 5 bytes depending on the recipe.
375  // 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.
376  // 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
377  // flexible. use unsigned int everywhere for now since we have 18 bits for energy which does not fit in short, cast later.
378  unsigned int nbytesPerChannel = bytesPerChannel(at0, at1);
379  bool satByte = nbytesPerChannel % 2; // do we have satbyte
380 
381  at0val = false;
382  at1val = false;
383  at0Data = 0;
384  at1Data = 0;
385  unsigned int satData = 0;
386  saturation = 0;
387 
388  unsigned int word1 = 0;
389  unsigned int word2 = 0;
390  decodeWord(word1, wordshift, byteshift, p);
391  if (nbytesPerChannel > 3) {
392  decodeWord(word2, wordshift, byteshift, p);
393  }
394  at0Data = word1 & 0x7fff;
395  at0val = word1 & 0x8000;
396  if (nbytesPerChannel > 3) {
397  at1Data = word2 & 0x7fff;
398  at1val = word2 & 0x8000;
399  }
400  if (satByte) {
401  decodeByte(satData, wordshift, byteshift, p);
402  increaseByteShift(wordshift, byteshift);
403  }
404 
408 
409  if (at0 == MonDataType::Energy && at1 == MonDataType::SelectedEnergy) {
410  at0Data = (at0Data << 3) | (satData & 0x7);
411  at1Data = (at1Data << 3) | ((satData & 0x70) >> 4);
412  saturation = ((satData & 0x88) == 0x88);
413  } else if (at1 == MonDataType::Energy && at0 == MonDataType::SelectedEnergy) {
414  at0Data = (at0Data << 3) | ((satData & 0x70) >> 4);
415  at1Data = (at1Data << 3) | (satData & 0x7);
416  saturation = ((satData & 0x88) == 0x88);
417  } else {
418  if (at0 == MonDataType::Energy || at0 == MonDataType::SelectedEnergy) {
419  at0Data = (at0Data << 3) | (satData & 0x7);
420  saturation = (satData & 0x20);
421  }
422  if (at1 == MonDataType::Energy || at1 == MonDataType::SelectedEnergy) {
423  at1Data = (at1Data << 3) | (satData & 0x7);
424  saturation = (satData & 0x20);
425  }
426  }
427 }

◆ 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 220 of file LArLATOMEDecoder.cxx.

220  {
221 
223  int monheadererror = 0;
224  int monheadererrorbit = 0;
225  if (!compareOrSet(m_latomeID, bswap_32(p[0 + offset]), m_headerDecoded))
226  monheadererror |= (1 << monheadererrorbit++);
227  Word l1IDtmp = m_l1ID;
228  if (!compareOrSet(l1IDtmp, bswap_32(p[1 + offset]), m_headerDecoded))
229  monheadererror |= (1 << monheadererrorbit++);
230  if (l1IDtmp != m_l1ID) {
231  ATH_MSG_DEBUG("Mon header L1ID " << l1IDtmp << " different from rod header L1ID " << m_l1ID);
232  }
233  ATH_MSG_DEBUG(" latomeID: " << m_latomeID << " l1ID: " << m_l1ID);
234 
235  Word monHeaderMarker = bswap_32(p[2 + offset]);
236  Word monCheckPoint = bswap_32(p[4 + offset]);
237  if (s_monHeaderMarker != monHeaderMarker) {
238  monheadererror |= (1 << monheadererrorbit++);
239  ATH_MSG_WARNING("Problem in monHeaderMarker: " << monHeaderMarker);
240  }
241  if (s_monCheckPoint != monCheckPoint) {
242  monheadererror |= (1 << monheadererrorbit++);
243  ATH_MSG_WARNING("Problem in monCheckPoint: " << monCheckPoint);
244  }
245 
246  if (!compareOrSet(m_nPackets, bswap_32(p[3 + offset]) >> 24, m_headerDecoded))
247  monheadererror |= (1 << monheadererrorbit++);
248 
249  if (m_nPackets == 0xFF) {
250  m_nPackets = 1;
251  m_iPacket = 0;
252  m_nWordsPerPacket = (bswap_32(p[3 + offset]) & 0xffffff) / 4.;
253  } else {
254  if (m_headerDecoded)
255  ++m_iPacket;
256  else
257  m_iPacket = 0;
258  if (!compareOrSet(m_iPacket, (bswap_32(p[3 + offset]) >> 16) & 0xf, m_headerDecoded))
259  monheadererror |= (1 << monheadererrorbit++);
260  m_nWordsPerPacket = (bswap_32(p[3 + offset]) & 0xffff) / 4.;
261  }
262 
263  if (!compareOrSet(m_monHeaderSize, bswap_32(p[5 + offset]), m_headerDecoded))
264  monheadererror |= (1 << monheadererrorbit++);
265 
268  if (m_monHeaderSize < 18) {
269  ATH_MSG_WARNING(" Mon header size should not be less that 18 : =" << m_monHeaderSize << " are you reading old data file?");
270  return 0;
271  }
272 
273  ATH_MSG_DEBUG(" nPackets: " << m_nPackets << " iPacket: " << m_iPacket << " nWordsPerPacket: " << m_nWordsPerPacket << " monHeaderSize: " << m_monHeaderSize);
274 
276  if (!compareOrSet(m_at0typeRec, bswap_32(p[9 + offset]), m_headerDecoded))
277  monheadererror |= (1 << monheadererrorbit++);
278  if (!compareOrSet(m_at1typeRec, bswap_32(p[12 + offset]), m_headerDecoded))
279  monheadererror |= (1 << monheadererrorbit++);
280  monheadererrorbit += 2;
281 
282  if (!compareOrSet(m_at0nBC, bswap_32(p[10 + offset]), m_headerDecoded))
283  monheadererror |= (1 << monheadererrorbit++);
284  if (!compareOrSet(m_at1nBC, bswap_32(p[13 + offset]), m_headerDecoded))
285  monheadererror |= (1 << monheadererrorbit++);
286  if (!compareOrSet(m_at0BC, bswap_32(p[11 + offset]), m_headerDecoded))
287  monheadererror |= (1 << monheadererrorbit++);
288  if (!compareOrSet(m_at1BC, bswap_32(p[14 + offset]), m_headerDecoded))
289  monheadererror |= (1 << monheadererrorbit++);
290  if (!compareOrSet(m_activeSC, bswap_32(p[15 + offset]), m_headerDecoded))
291  monheadererror |= (1 << monheadererrorbit++);
292  if (!compareOrSet(m_nsc1, bswap_32(p[16]) >> 24, m_headerDecoded))
293  monheadererror |= (1 << monheadererrorbit++);
294  if (!compareOrSet(m_nsc2, (bswap_32(p[16]) >> 16) & 0xff, m_headerDecoded))
295  monheadererror |= (1 << monheadererrorbit++);
296  if (!compareOrSet(m_nsc3, (bswap_32(p[16]) >> 8) & 0xff, m_headerDecoded))
297  monheadererror |= (1 << monheadererrorbit++);
298  if (!compareOrSet(m_nsc4, (bswap_32(p[16])) & 0xff, m_headerDecoded))
299  monheadererror |= (1 << monheadererrorbit++);
300  if (!compareOrSet(m_nsc5, bswap_32(p[17]) >> 24, m_headerDecoded))
301  monheadererror |= (1 << monheadererrorbit++);
302  if (!compareOrSet(m_nsc6, (bswap_32(p[17]) >> 16) & 0xff, m_headerDecoded))
303  monheadererror |= (1 << monheadererrorbit++);
304 
305  ATH_MSG_DEBUG(" at0type " << m_at0typeRec << " at1type " << m_at1typeRec << " at0nBC " << m_at0nBC << " at1nBC " << m_at1nBC << " at0BC " << m_at0BC
306  << " at1BC " << m_at1BC << " nsc1 " << m_nsc1 << " nsc2 " << m_nsc2 << " nsc3 " << m_nsc3 << " nsc4 " << m_nsc4 << " nsc5 "
307  << m_nsc5 << " nsc6 " << m_nsc6);
308 
309  if (monheadererror) {
310  ATH_MSG_WARNING(" consistency error in mon checker at packet " << m_iPacket << " errorbits " << std::hex << monheadererror << std::dec);
311  }
312 
313  m_headerDecoded = true;
315 }

◆ 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 210 of file LArLATOMEDecoder.cxx.

210  {
212  if (bswap_32(p[offset]) != 0xc0ffee00 || bswap_32(p[offset + 1] != 0xaaaaaaaa)) {
213  ATH_MSG_WARNING("Problem in trailer at packet " << m_iPacket << " words " << std::hex << bswap_32(p[offset]) << ", " << bswap_32(p[offset + 1])
214  << std::dec);
215  }
217  return offset + m_monTrailerSize;
218 }

◆ decodeWord()

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

Definition at line 361 of file LArLATOMEDecoder.cxx.

361  {
362  unsigned int msb = 0;
363  unsigned int lsb = 0;
364  decodeByte(msb, wordshift, byteshift, p);
365  increaseByteShift(wordshift, byteshift);
366  decodeByte(lsb, wordshift, byteshift, p);
367  increaseByteShift(wordshift, byteshift);
368  word = lsb | (msb << 8);
369 }

◆ fillCalib()

void LArLATOMEDecoder::EventProcess::fillCalib ( const LArLATOMEMapping map,
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 889 of file LArLATOMEDecoder.cxx.

889  {
890 
892  uint32_t DAC_value=0;
893  uint16_t delay_value=0;
894  uint16_t isPulsed_value=false;
895  std::unique_ptr<LArCalibParams> calibParams1;
896  std::unique_ptr<LArCalibParams> calibParams2;
897 
898  int pattype = m_nthLATOME >> 16;
899  const LArOnOffIdMapping* cabling = 0;
900  if (m_caccdigits) {
901  m_caccdigits->setDelayScale(25. / 240.);
902 
904  cabling = {*cablingHdl};
905  if (!cabling) {
906  ATH_MSG_ERROR("Do not have mapping object " << m_decoder->m_cablingKeySC.key());
907  return;
908  }
909 
910  calibParams1=std::make_unique<LArCalibParams>();
911  calibParams2=std::make_unique<LArCalibParams>();
912 
913  if (pattype > 0x48) {
914  StatusCode sc1 = calibParams1->initialize();
915  StatusCode sc2 = calibParams2->initialize();
916  if (sc1 != StatusCode::SUCCESS || sc2 != StatusCode::SUCCESS) {
917  ATH_MSG_WARNING("could not initialize LArCalibParams, acc calib will not be filled ");
918  return;
919  }
920  if (pattype == 0x49 || pattype == 0x4a) {
921 
923 
925  } else {
926 
928 
930  }
931  } else {
932  StatusCode sc1 = calibParams1->initialize();
933  if (sc1 != StatusCode::SUCCESS) {
934  ATH_MSG_WARNING("could not initialize LArCalibParams, acc calib will not be filled ");
935  return;
936  }
938  }
939  }
940 
941  const HWIdentifier hwidEmpty;
942  unsigned nWarnings = 0;
943  for (SuperCell ch = 0; ch < N_LATOME_CHANNELS; ++ch) {
944  LArCalibParams* calibParams = 0;
945  auto SCID = map ? map->getChannelID(m_nthLATOME, ch) : hwidEmpty;
946  if (SCID == hwidEmpty) {
947  ATH_MSG_DEBUG("No mapping for ch: " << std::dec << ch);
948  continue;
949  }
951  continue;
953  continue;
954 
955  std::vector<uint64_t> sum;
956  std::vector<uint64_t> sum2;
957  unsigned int ntmin = 9999999;
959  for (auto nt : m_averagedRawValuesInEvent[ch].nTrigValid) {
960  if (nt < ntmin) {
961  ntmin = nt;
962  }
963  }
964  sum.resize(m_averagedRawValuesInEvent[ch].sum.size());
965  sum2.resize(m_averagedRawValuesInEvent[ch].sum.size());
966 
967  if (ntmin > 0) {
968  for (unsigned int is = 0; is < m_averagedRawValuesInEvent[ch].sum.size(); ++is) {
969  double fsum = (double)m_averagedRawValuesInEvent[ch].sum[is] / m_averagedRawValuesInEvent[ch].nTrigValid[is] * ntmin;
970  double fsum2 = (double)m_averagedRawValuesInEvent[ch].sumSq[is] / m_averagedRawValuesInEvent[ch].nTrigValid[is] * ntmin;
971  sum[is] = round(fsum);
972  sum2[is] = round(fsum2);
973  }
974  } else {
975  std::fill(sum.begin(), sum.end(), 0);
976  std::fill(sum2.begin(), sum2.end(), 0);
977  if (++nWarnings < 64) {
978  ATH_MSG_WARNING("No valid triggers for supercell " << SCID.getString());
979  }
980  }
981  if (m_accdigits) {
982  LArAccumulatedDigit* accdigi = new LArAccumulatedDigit(SCID, gain, sum, sum2, ntmin);
983  m_accdigits->push_back(accdigi);
984  }
985  if (m_caccdigits) {
986  if (pattype == 0x49 || pattype == 0x4a) {
987  if (m_decoder->m_onlineId->barrel_ec(SCID) == 0) {
988  calibParams = calibParams1.get();
989  } else {
990  calibParams = calibParams2.get();
991  }
992  } else if (pattype == 0x4b || pattype == 0x4c) {
993  if (m_decoder->m_onlineId->isHECchannel(SCID)) {
994  calibParams = calibParams1.get();
995  } else {
996  calibParams = calibParams2.get();
997  }
998  } else {
999  calibParams = calibParams1.get();
1000  }
1001  unsigned int eventNb = 0;
1002  unsigned int numCL = 0;
1003  unsigned int numPulsedLeg = 0;
1004  std::vector<Identifier> ccellIds(0);
1005  Identifier myofflineID = cabling->cnvToIdentifier(SCID);
1006  ccellIds = m_decoder->m_sc2ccMappingTool->superCellToOfflineID(myofflineID);
1007  for (Identifier id : ccellIds) { // loop cells in sc
1008  HWIdentifier cellLegHWID = cablingLeg->createSignalChannelID(id);
1009  const std::vector<HWIdentifier>& calibLineLeg = clcabling->calibSlotLine(cellLegHWID);
1010  numCL += calibLineLeg.size();
1011  for (HWIdentifier calibLineHWID : calibLineLeg) { // loop legacy calib lines
1012  if (calibParams->isPulsed(eventNb, calibLineHWID)) {
1013  numPulsedLeg += 1;
1014  }
1015  }
1016  }
1017 
1018  isPulsed_value = true;
1019  if (numPulsedLeg != numCL) {
1020  if (m_decoder->m_keepPulsed)
1021  continue;
1022  isPulsed_value = false;
1023  }
1024  DAC_value = calibParams->DAC(eventNb, SCID) * numPulsedLeg;
1025  // 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
1026  // which came from averaging over many cells
1027  int ft = m_decoder->m_onlineId->feedthrough(SCID);
1028  int slot = m_decoder->m_onlineId->slot(SCID);
1029  int channel = m_decoder->m_onlineId->channel(SCID);
1030  if (m_decoder->m_onlineId->barrel_ec(SCID) == 1 && (ft == 3 || ft == 10 || ft == 16 || ft == 22)) {
1031  // if it's HEC
1032  if (slot == 1) {
1033  if (channel >= 16 && channel <= 31) { // eta 1.65 bin
1034  //DAC_value = DAC_value / 1.363; // measured value
1035  DAC_value = DAC_value / 1.2; // computed from geometry
1036  m_decoder->msg(MSG::DEBUG) << "Multiplying DAC for channel " << SCID << "by 1/1.2" << endmsg;
1037  } else if (channel >= 32 && channel <= 47) { // eta 1.75 bin
1038  //DAC_value = DAC_value / 1.206; // measured value
1039  DAC_value = DAC_value * 7. / 8.; // computed from geometry
1040  m_decoder->msg(MSG::DEBUG) << "Multiplying DAC for channel " << SCID << "by 7./8." << endmsg;
1041  }
1042  }
1043  }
1044 
1045  delay_value = calibParams->Delay(eventNb, SCID);
1046  LArAccumulatedCalibDigit* accdigi = new LArAccumulatedCalibDigit(SCID, gain, sum, sum2, ntmin, DAC_value, delay_value, isPulsed_value);
1047 
1048  m_caccdigits->push_back(accdigi);
1049  }
1050 
1051  }
1052  if (nWarnings > 16) {
1053  ATH_MSG_WARNING("Found " << nWarnings << " supercells with no valid triggers");
1054  }
1055 }

◆ fillCollection()

void LArLATOMEDecoder::EventProcess::fillCollection ( const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment pROB,
const LArLATOMEMapping map,
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 429 of file LArLATOMEDecoder.cxx.

430  {
431  // Mon* mon = new Mon;
432 
434  // const unsigned int rod_Size_words = robFrag->rod_ndata();
435  // const unsigned int rob_Size_words = robFrag->payload_size_word();
436  const unsigned int sourceID = robFrag->rob_source_id();
437  // const unsigned int rod_fragment_size_word = robFrag->rod_fragment_size_word();
438  // const unsigned int rod_header_size_word = robFrag->rod_header_size_word();
439  // const unsigned int rod_trailer_size_word = robFrag->rod_trailer_size_word();
440  // const unsigned int rod_bc_id = robFrag->rod_bc_id();
441  // const unsigned int rod_nstatus = robFrag->rod_nstatus();
442  // const unsigned int rod_status_position = robFrag->rod_status_position();
443  // const uint32_t* rod_start = robFrag->rod_start();
444  m_l1ID = robFrag->rod_lvl1_id();
445  m_ROBFragSize = robFrag->rod_ndata();
446  const uint32_t* p = robFrag->rod_data();
447  const unsigned int n = robFrag->rod_ndata();
448  if (0 == n) {
450  ATH_MSG_DEBUG("Empty fragment, skip ");
451  return;
452  }
453  m_latomeBCID = robFrag->rod_bc_id();
454  const uint32_t* rod_status = robFrag->rod_status();
455  const unsigned int rod_nstatus = robFrag->rod_nstatus();
456  if (rod_nstatus != 27) {
457  ATH_MSG_WARNING("Inconsistent number of rod header status elements: nstatus= " << rod_nstatus);
458  return;
459  }
460  if (rod_nstatus > 8) {
461  uint32_t status8 = rod_status[8];
462  m_at0type = status8 & 0x3;
463  m_at1type = (status8 >> 2) & 0x3;
464  }
465  m_nthLATOME = robFrag->rod_source_id();
466  m_LATOMEFW = rod_status[3] & 0x0fff;
467 
468  LatomeCalibPatterns pat1, pat2, pat3;
469  pat1.DAC = rod_status[9];
470  pat1.delay = rod_status[10];
471  pat1.patterns.resize(4);
472  for (unsigned int i = 0; i < 4; ++i)
473  pat1.patterns[i] = rod_status[i + 11];
474 
475  pat2.DAC = rod_status[15];
476  pat2.delay = rod_status[16];
477  pat2.patterns.resize(4);
478  for (unsigned int i = 0; i < 4; ++i)
479  pat2.patterns[i] = rod_status[i + 17];
480 
481  pat3.DAC = rod_status[21];
482  pat3.delay = rod_status[22];
483  pat3.patterns.resize(4);
484  for (unsigned int i = 0; i < 4; ++i)
485  pat3.patterns[i] = rod_status[i + 23];
486 
487  m_latomeCalibPatternsInEvent = {pat1, pat2, pat3};
488 
489  const HWIdentifier hwidEmpty;
490 
492 
493  unsigned int offset = decodeHeader(p, 0);
494  if (offset > m_ROBFragSize) {
495  ATH_MSG_WARNING("Data corruption, offset found at pos 0 (" << offset << ") is larger than the ROB fragment size (" << m_ROBFragSize << "). Ignoring data.");
496  return;
497  }
498 
499  if (m_isAveraged) {
500  m_at0type = m_at0typeRec >> 24;
502  if (m_at0type != (int)MonDataType::Averaged) {
503  ATH_MSG_WARNING(" inconsistant data type with requested averaged decoding at0 type " << m_at0type << " " << m_at0typeRec << " " << std::hex << m_l1ID
504  << " " << sourceID << std::dec);
505  return;
506  }
507  }
508  if (m_isAutoCorr) {
509  m_at0type = m_at0typeRec >> 24;
511  if (m_at0type != (int)MonDataType::AutoCorr) {
512  ATH_MSG_WARNING(" inconsistant data type with requested averaged decoding at0 type " << m_at0type << " " << m_at0typeRec << " " << std::hex << m_l1ID
513  << " " << sourceID << std::dec);
514  return;
515  }
516  }
517 
518  m_packetEnd.push_back(offset);
522  for (unsigned int ip = 1; ip < m_nPackets; ++ip) {
523  if (offset > m_ROBFragSize) {
524  ATH_MSG_WARNING("Data corruption, offset found at pos 0 (" << offset << ") is larger than the ROB fragment size (" << m_ROBFragSize << "). Ignoring data.");
525  return;
526  }
528  if (offset > m_ROBFragSize) {
529  ATH_MSG_WARNING("Data corruption, offset found at pos 0 (" << offset << ") is larger than the ROB fragment size (" << m_ROBFragSize << "). Ignoring data.");
530  return;
531  }
532  m_packetEnd.push_back(offset);
534  }
535 
536  ATH_MSG_DEBUG(" end of header check computed offset=" << std::dec << offset << " nwords in payload=" << n);
537 
539  m_iPacket = 0;
540  if (m_nPackets==0) {
541  ATH_MSG_WARNING("Data corruption, nPackets=0");
542  return;
543  }
544 
545  if (m_nPackets>m_packetEnd.size()) {
546  ATH_MSG_WARNING("Data corruption, nPackets " << m_nPackets << " exceeds size " << m_packetEnd.size());
547  return;
548  }
549 
550  if (m_packetEnd[m_nPackets - 1] + m_monTrailerSize != n) {
551  ATH_MSG_WARNING("problem in packet size loop " << m_packetEnd[m_nPackets - 1] << " != " << n);
552  }
553 
554  std::vector<unsigned int> timeslot_nsc = {m_nsc1, m_nsc2, m_nsc3, m_nsc4, m_nsc5, m_nsc6};
555  std::vector<unsigned int> bc_size;
558 
559  short nBC = 0;
560  short nBC1 = 0;
561  short startBC1 = 0;
564 
565  if (m_isAveraged || m_isAutoCorr) {
566  nBC = m_at0nBC;
567  nBC1 = m_at1nBC;
568  m_nBC_Averaged = nBC;
569  startBC1 = 0;
570  type0 = static_cast<MonDataType>(m_at0type);
571  type1 = static_cast<MonDataType>(m_at1type);
572  for (auto& val : m_averagedRawValuesInEvent) {
573  val.sum.resize(m_nBC_Averaged);
574  val.sumSq.resize(m_nBC_Averaged);
575  val.nTrigValid.resize(m_nBC_Averaged);
576  val.latomeChannel = 99999;
577  }
578  } else {
579  if (m_at1nBC == 0) {
581  }
582 
584  if (m_at0nBC >= m_at1nBC) {
585  nBC = m_at0nBC;
586  nBC1 = m_at1nBC;
587  startBC1 = m_at1BC - m_at0BC;
588  type0 = static_cast<MonDataType>(m_at0type);
589  type1 = static_cast<MonDataType>(m_at1type);
590  } else {
591  nBC1 = m_at0nBC;
592  nBC = m_at1nBC;
593  startBC1 = m_at0BC - m_at1BC;
594  type1 = static_cast<MonDataType>(m_at0type);
595  type0 = static_cast<MonDataType>(m_at1type);
596  }
597  } else if (m_at0type != (Word)MonDataType::Invalid) {
598  nBC = m_at0nBC;
599  type0 = static_cast<MonDataType>(m_at0type);
600  } else if (m_at1type != (Word)MonDataType::Invalid) {
601  nBC = m_at1nBC;
602  type0 = static_cast<MonDataType>(m_at1type);
603  } else {
604  ATH_MSG_ERROR("No valid data type in Mon Header");
605  return;
606  }
607 
608  switch (type0) {
609  case MonDataType::RawADC:
610  m_hasRawAdc = true;
611  m_nBC_rawADC = nBC;
612  break;
613  case MonDataType::ADC:
614  m_hasAdc = true;
615  m_nBC_ADC = nBC;
616  break;
617  case MonDataType::Energy:
618  m_hasE = true;
619  m_nBC_E = nBC;
620  break;
622  m_hasEID = true;
623  m_nBC_EID = nBC;
624  break;
626  break;
627  default:
628  ATH_MSG_ERROR("wrong mux0 value " << (Word)type0);
629  return;
630  }
631 
632  switch (type1) {
633  case MonDataType::RawADC:
634  m_hasRawAdc = true;
635  m_nBC_rawADC = nBC1;
636  m_BC_rawADC = startBC1;
637  break;
638  case MonDataType::ADC:
639  m_hasAdc = true;
640  m_nBC_ADC = nBC1;
641  m_BC_ADC = startBC1;
642  break;
643  case MonDataType::Energy:
644  m_hasE = true;
645  m_nBC_E = nBC1;
646  m_BC_E = startBC1;
647  break;
649  m_hasEID = true;
650  m_nBC_EID = nBC1;
651  m_BC_EID = startBC1;
652  break;
654  break;
655  default:
656  ATH_MSG_ERROR("wrong mux1 value " << (Word)type1);
657  return;
658  }
659 
660  for (auto& val : m_rawValuesInEvent) {
661  if (m_hasRawAdc)
662  val.adc.resize(m_nBC_rawADC);
663  if (m_hasAdc)
664  val.adc_bas.resize(m_nBC_ADC);
665  if (m_hasE)
666  val.et.resize(m_nBC_E);
667  if (m_hasEID)
668  val.et_id.resize(m_nBC_EID);
669  if (m_hasEID || m_hasE) {
670  val.saturation.resize(std::max(m_nBC_EID, m_nBC_E));
671  }
672 
673  val.latomeChannel = 99999;
674  }
675  }
676 
677  m_BCIDsInEvent.resize(nBC);
678 
679  unsigned int s = m_monHeaderSize;
680  unsigned int bcid = s_nBunches;
681 
682  for (short iBC = 0; iBC < nBC; ++iBC) {
683  MonDataType at0 = type0;
684  MonDataType at1 = type1;
685  if (type1 != MonDataType::Invalid) {
686  if (iBC < startBC1 || iBC >= startBC1 + nBC1)
687  at1 = MonDataType::Invalid;
688  }
689  unsigned int nbytesPerChannel = bytesPerChannel(at0, at1);
690 
691  int nsc = 0;
692  unsigned int oldipacket = 0;
693  for (unsigned int itimeslot = 0; itimeslot < 6; ++itimeslot) {
694  unsigned int l_bcid = (bswap_32(p[s]))>>16;
695  if(itimeslot!=0){
696  if(l_bcid!=bcid){
697  ATH_MSG_WARNING( "ERROR: inconsistent BCID between time slots" );
698  }
699  }
700  else{
701  if(bcid!=s_nBunches){
702  unsigned int bcid_c = bcid+1;
704  if(bcid_c==s_nBunches){
705  bcid=0;
706  bcid_c = 0;
707  }
708  if(bcid_c != l_bcid){
709  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 );
710  }
711  }
712  m_BCIDsInEvent[iBC] = l_bcid;
713  }
714  bcid=l_bcid;
715 
716  unsigned int mux = ((bswap_32(p[s])) >> 8) & 0xff;
720  if (s >= n)
721  break;
722 
723  unsigned int timeslotsize = timeslot_nsc[itimeslot];
724  unsigned int nbytes = timeslotsize * nbytesPerChannel;
725  unsigned int n64word = nbytes / 8;
726  if (nbytes % 8)
727  ++n64word;
728  ATH_MSG_DEBUG(" at BC " << iBC << " timeslot " << itimeslot << " " << bcid << " " << mux << " n64word " << n64word << " at0 " << (int)at0 << " at1 "
729  << (int)at1 << " l_bcid " << bcid);
730 
731  unsigned int wordshift = s;
732  unsigned int byteshift = 0;
733 
735  oldipacket = m_iPacket;
736  for (unsigned int ichan = 0; ichan < timeslotsize; ++ichan) {
737  unsigned int at0Data = 0, at1Data = 0, satData = 0;
738  bool at0val = false, at1val = false;
739 
740  // protection against corrupted bytestream data
741  if (nsc > N_LATOME_CHANNELS - 1) {
742  break;
743  // FIXME: should fill some default data to all channels, because clearly this block is corrupted
744  }
745  if (!m_isAveraged && !m_isAutoCorr) {
746  decodeChannel(wordshift, byteshift, p, at0, at1, at0Data, at1Data, satData, at0val, at1val);
747  ATH_MSG_DEBUG(" wordshift " << wordshift << " byteshift " << byteshift << " at0data " << at0Data << " at1Data " << at1Data << " satData " << satData
748  << " at0val " << at0val << " at1val " << at1val << " nsc " << nsc);
749 
751  const auto SCID = map ? map->getChannelID(m_nthLATOME, nsc) : hwidEmpty;
752  if (SCID == hwidEmpty) {
753  ATH_MSG_DEBUG("No mapping for ch: " << std::dec << nsc);
754  }
755  int RAWValue0 = -999;
756  if (!at0val && SCID != hwidEmpty && at0 != MonDataType::Invalid) {
757  ATH_MSG_DEBUG("at0 bad quality bit for SC:" << nsc << " BC " << iBC << " latome " << robFrag->rod_source_id());
758  } else {
760  RAWValue0 = at0Data;
761  }
762  int defaultADCValue = -1;
763  int defaultEValue = -99999;
764  auto& rawValuesInEvent = m_rawValuesInEvent[nsc];
765  switch (at0) {
766  case MonDataType::RawADC:
767  if ((unsigned)iBC < rawValuesInEvent.adc.size()) {
768  rawValuesInEvent.adc[iBC] = (at0val) ? RAWValue0 : defaultADCValue;
769  }
770  break;
771  case MonDataType::ADC:
772  if ((unsigned)iBC < rawValuesInEvent.adc_bas.size()) {
773  rawValuesInEvent.adc_bas[iBC] = (at0val) ? RAWValue0 : defaultADCValue;
774  }
775  break;
776  case MonDataType::Energy:
777  if ((unsigned)iBC < rawValuesInEvent.et.size()) {
778  rawValuesInEvent.et[iBC] = (at0val) ? signEnergy(RAWValue0) : defaultEValue;
779  rawValuesInEvent.saturation[iBC] = satData;
780  }
781  break;
783  if ((unsigned)iBC < rawValuesInEvent.et_id.size()) {
784  rawValuesInEvent.et_id[iBC] = (at0val) ? signEnergy(RAWValue0) : defaultEValue;
785  rawValuesInEvent.saturation[iBC] = satData;
786  }
787  break;
789  break;
790  default:
791  ATH_MSG_ERROR("wrong at0 value " << (Word)at0);
792  return;
793  }
794 
795  int RAWValue1 = -999;
796  if (!at1val && SCID != hwidEmpty && at1 != MonDataType::Invalid) {
797  ATH_MSG_DEBUG("at1 bad quality bit for SC:" << nsc << " BC " << iBC << " latome " << robFrag->rod_source_id());
798  } else {
800  RAWValue1 = at1Data;
801  }
802 
803  const size_t BCidx = iBC - startBC1;
804  switch (at1) {
805  case MonDataType::RawADC:
806  if (BCidx < rawValuesInEvent.adc.size()) {
807  rawValuesInEvent.adc[BCidx] = (at1val) ? RAWValue1 : defaultADCValue;
808  }
809  break;
810  case MonDataType::ADC:
811  if (BCidx < rawValuesInEvent.adc_bas.size()) {
812  rawValuesInEvent.adc_bas[BCidx] = (at1val) ? RAWValue1 : defaultADCValue;
813  }
814  break;
815  case MonDataType::Energy:
816  if (BCidx < rawValuesInEvent.et.size()) {
817  rawValuesInEvent.et[BCidx] = (at1val) ? signEnergy(RAWValue1) : defaultEValue;
818  rawValuesInEvent.saturation[BCidx] = satData;
819  }
820  break;
822  if (BCidx < rawValuesInEvent.et_id.size()) {
823  m_rawValuesInEvent[nsc].et_id[BCidx] = (at1val) ? signEnergy(RAWValue1) : defaultEValue;
824  m_rawValuesInEvent[nsc].saturation[BCidx] = satData;
825  }
826  break;
828  break;
829  default:
830  ATH_MSG_ERROR("wrong at1 value " << (Word)at1);
831  return;
832  }
833 
834  m_rawValuesInEvent[nsc].latomeChannel = nsc;
835 
836  } else {
837  if (wordshift % 2) {
838  ATH_MSG_ERROR("inconsistant wordshift in decoding everaged data");
839  return;
840  }
841  unsigned int averageword = bswap_32(p[wordshift]);
842  wordshift += 1;
843  unsigned int sumSq = bswap_32(p[wordshift]);
844  wordshift += 1;
845  unsigned long long sumsqMSB = averageword >> 28;
846  sumsqMSB = sumsqMSB << 32;
847 
848  m_averagedRawValuesInEvent[nsc].sum[iBC] = averageword & 0xFFFFF;
849  m_averagedRawValuesInEvent[nsc].sumSq[iBC] = sumSq | sumsqMSB;
850  m_averagedRawValuesInEvent[nsc].nTrigValid[iBC] = (averageword >> 20) & 0xFF;
851  m_averagedRawValuesInEvent[nsc].latomeChannel = nsc;
852  }
853 
854  ++nsc;
855 
856  }
857 
859  if(byteshift!=0){
860  increaseWordShift(wordshift);
861  byteshift=0;
862  }
863  ATH_MSG_DEBUG("wordshift before: " << wordshift << ", s: " << s);
864  if ((wordshift - s) % 2)
865  increaseWordShift(wordshift);
866  ATH_MSG_DEBUG("wordshift after : " << wordshift << ", s: " << s);
867  if ((wordshift - s - ((m_iPacket - oldipacket) * (m_monHeaderSize + m_monTrailerSize))) != n64word * 2) {
868  ATH_MSG_WARNING(" ERROR: time slice end is not padded properly " << (wordshift - s - m_iPacket * (m_monHeaderSize + m_monTrailerSize))
869  << "!=" << n64word * 2 << " m_ipacket " << m_iPacket);
870  }
871  s = wordshift;
872  oldipacket = m_iPacket;
873  }
874 
875  }
876 
877  if (!m_isAveraged && !m_isAutoCorr) {
878  fillRaw(map);
879  } else {
880  if (onoffmap && clmap) {
881  fillCalib(map, onoffmap, clmap);
882  } else {
883  ATH_MSG_ERROR("Do not have mapping !!!");
884  }
885  }
886  fillHeader();
887 }

◆ fillHeader()

void LArLATOMEDecoder::EventProcess::fillHeader ( )
private

Definition at line 1134 of file LArLATOMEDecoder.cxx.

1134  {
1135 
1136  if (m_header_coll) {
1138  m_header_coll->push_back(latome);
1139  }
1140 }

◆ fillRaw()

void LArLATOMEDecoder::EventProcess::fillRaw ( const LArLATOMEMapping map)
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 1058 of file LArLATOMEDecoder.cxx.

1058  {
1059  // const CaloGain::CaloGain dummyGain = CaloGain::LARHIGHGAIN;
1060  const HWIdentifier hwidEmpty;
1061  for (SuperCell ch = 0; ch < N_LATOME_CHANNELS; ++ch) {
1062  const auto SCID = map ? map->getChannelID(m_nthLATOME, ch) : hwidEmpty;
1063  if (SCID == hwidEmpty) {
1064  ATH_MSG_DEBUG("No mapping for ch: " << std::dec << ch);
1065  continue;
1066  }
1068  continue;
1070  continue;
1071 
1072  std::vector<short> adcValues_inChannel_inEvent;
1073 
1074  if (m_hasRawAdc) {
1075  adcValues_inChannel_inEvent = m_rawValuesInEvent[ch].adc;
1076  }
1077 
1078  if (m_hasRawAdc && m_adc_coll) {
1081 
1082  std::vector<unsigned short> bcid_in_event;
1083  for (short b = m_BC_rawADC; b < m_BC_rawADC + m_nBC_rawADC; ++b) {
1084  bcid_in_event.push_back(m_BCIDsInEvent[b]);
1085  }
1086 
1087  LArSCDigit* scDigit = new LArSCDigit(SCID, m_rawValuesInEvent[ch].latomeChannel, m_nthLATOME, adcValues_inChannel_inEvent, bcid_in_event);
1088  m_adc_coll->push_back(scDigit);
1089  }
1090 
1091  if (m_hasAdc && m_adc_bas_coll) {
1092  std::vector<unsigned short> bcid_in_event;
1093  if (m_nBC_ADC == (short)m_BCIDsInEvent.size()) {
1094  bcid_in_event = m_BCIDsInEvent;
1095  } else {
1096  for (short b = m_BC_ADC; b < m_BC_ADC + m_nBC_ADC; ++b) {
1097  bcid_in_event.push_back(m_BCIDsInEvent[b]);
1098  }
1099  }
1100  LArSCDigit* scDigit = new LArSCDigit(SCID, m_rawValuesInEvent[ch].latomeChannel, m_nthLATOME, m_rawValuesInEvent[ch].adc_bas, bcid_in_event);
1101  m_adc_bas_coll->push_back(scDigit);
1102  }
1103 
1104  if (m_hasE && m_et_coll) {
1105  std::vector<unsigned short> bcid_in_event;
1106  if (m_nBC_E == (unsigned short)m_BCIDsInEvent.size()) {
1107  bcid_in_event = m_BCIDsInEvent;
1108  } else {
1109  for (short b = m_BC_E; b < m_BC_E + m_nBC_E; ++b) {
1110  bcid_in_event.push_back(m_BCIDsInEvent[b]);
1111  }
1112  }
1113  LArRawSC* scDigit =
1114  new LArRawSC(SCID, m_rawValuesInEvent[ch].latomeChannel, m_nthLATOME, m_rawValuesInEvent[ch].et, bcid_in_event, m_rawValuesInEvent[ch].saturation);
1115  m_et_coll->push_back(scDigit);
1116  }
1117 
1118  if (m_hasEID && m_et_id_coll) {
1119  std::vector<unsigned short> bcid_in_event;
1120  if (m_nBC_EID == (short)m_BCIDsInEvent.size()) {
1121  bcid_in_event = m_BCIDsInEvent;
1122  } else {
1123  for (short b = m_BC_EID; b < m_BC_EID + m_nBC_EID; ++b) {
1124  bcid_in_event.push_back(m_BCIDsInEvent[b]);
1125  }
1126  }
1127  LArRawSC* scDigit =
1128  new LArRawSC(SCID, m_rawValuesInEvent[ch].latomeChannel, m_nthLATOME, m_rawValuesInEvent[ch].et_id, bcid_in_event, m_rawValuesInEvent[ch].saturation);
1129  m_et_id_coll->push_back(scDigit);
1130  }
1131  }
1132 }

◆ increaseByteShift()

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

Definition at line 349 of file LArLATOMEDecoder.cxx.

349  {
350  ++byteshift;
351  if (byteshift == 4) {
352  increaseWordShift(wordshift);
353  byteshift = 0;
354  }
355 }

◆ increaseWordShift()

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

Definition at line 340 of file LArLATOMEDecoder.cxx.

340  {
341  ++wordshift;
342  if (m_packetEnd[m_iPacket] == wordshift) {
343  ++m_iPacket;
344  wordshift += (m_monHeaderSize + m_monTrailerSize);
345  ATH_MSG_DEBUG("switch packet " << m_iPacket << " " << wordshift);
346  }
347 }

◆ 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.

40 {
42  m_lvl = m_imsg ?
43  static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
44  MSG::INFO;
45 }

◆ 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 164 of file AthMessaging.h.

165 {
166  MsgStream* ms = m_msg_tls.get();
167  if (!ms) {
168  if (!m_initialized.test_and_set()) initMessaging();
169  ms = new MsgStream(m_imsg,m_nm);
170  m_msg_tls.reset( ms );
171  }
172 
173  ms->setLevel (m_lvl);
174  return *ms;
175 }

◆ 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 179 of file AthMessaging.h.

180 { return msg() << lvl; }

◆ msgLvl()

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

Test the output level.

Parameters
lvlThe message level to test against
Returns
boolean Indicating if messages at given level will be printed
Return values
trueMessages at level "lvl" will be printed

Definition at line 151 of file AthMessaging.h.

152 {
153  if (!m_initialized.test_and_set()) initMessaging();
154  if (m_lvl <= lvl) {
155  msg() << lvl;
156  return true;
157  } else {
158  return false;
159  }
160 }

◆ 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.

29 {
30  m_lvl = lvl;
31 }

◆ signEnergy()

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

Definition at line 317 of file LArLATOMEDecoder.cxx.

317  {
318 
319  if (energy & (1 << 17))
320  return energy - pow(2, 18);
321  else
322  return energy;
323 }

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 240 of file LArLATOMEDecoder.h.

◆ m_activeSC

Word LArLATOMEDecoder::EventProcess::m_activeSC {}
private

Definition at line 208 of file LArLATOMEDecoder.h.

◆ m_adc_bas_coll

LArDigitContainer* LArLATOMEDecoder::EventProcess::m_adc_bas_coll {}
private

Definition at line 237 of file LArLATOMEDecoder.h.

◆ m_adc_coll

LArDigitContainer* LArLATOMEDecoder::EventProcess::m_adc_coll {}
private

Definition at line 236 of file LArLATOMEDecoder.h.

◆ m_at0BC

Word LArLATOMEDecoder::EventProcess::m_at0BC {}
private

Definition at line 206 of file LArLATOMEDecoder.h.

◆ m_at0nBC

Word LArLATOMEDecoder::EventProcess::m_at0nBC {}
private

Definition at line 204 of file LArLATOMEDecoder.h.

◆ m_at0type

Word LArLATOMEDecoder::EventProcess::m_at0type {}
private

Definition at line 202 of file LArLATOMEDecoder.h.

◆ m_at0typeRec

Word LArLATOMEDecoder::EventProcess::m_at0typeRec {}
private

Definition at line 200 of file LArLATOMEDecoder.h.

◆ m_at1BC

Word LArLATOMEDecoder::EventProcess::m_at1BC {}
private

Definition at line 207 of file LArLATOMEDecoder.h.

◆ m_at1nBC

Word LArLATOMEDecoder::EventProcess::m_at1nBC {}
private

Definition at line 205 of file LArLATOMEDecoder.h.

◆ m_at1type

Word LArLATOMEDecoder::EventProcess::m_at1type {}
private

Definition at line 203 of file LArLATOMEDecoder.h.

◆ m_at1typeRec

Word LArLATOMEDecoder::EventProcess::m_at1typeRec {}
private

Definition at line 201 of file LArLATOMEDecoder.h.

◆ m_averagedRawValuesInEvent

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

Definition at line 249 of file LArLATOMEDecoder.h.

◆ m_BC_ADC

short LArLATOMEDecoder::EventProcess::m_BC_ADC {}
private

Definition at line 224 of file LArLATOMEDecoder.h.

◆ m_BC_E

short LArLATOMEDecoder::EventProcess::m_BC_E {}
private

Definition at line 225 of file LArLATOMEDecoder.h.

◆ m_BC_EID

short LArLATOMEDecoder::EventProcess::m_BC_EID {}
private

Definition at line 226 of file LArLATOMEDecoder.h.

◆ m_BC_rawADC

short LArLATOMEDecoder::EventProcess::m_BC_rawADC {}
private

Definition at line 223 of file LArLATOMEDecoder.h.

◆ m_BCIDsInEvent

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

Definition at line 247 of file LArLATOMEDecoder.h.

◆ m_caccdigits

LArAccumulatedCalibDigitContainer* LArLATOMEDecoder::EventProcess::m_caccdigits {}
private

Definition at line 241 of file LArLATOMEDecoder.h.

◆ m_decoder

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

Definition at line 235 of file LArLATOMEDecoder.h.

◆ m_et_coll

LArRawSCContainer* LArLATOMEDecoder::EventProcess::m_et_coll {}
private

Definition at line 238 of file LArLATOMEDecoder.h.

◆ m_et_id_coll

LArRawSCContainer* LArLATOMEDecoder::EventProcess::m_et_id_coll {}
private

Definition at line 239 of file LArLATOMEDecoder.h.

◆ m_hasAdc

bool LArLATOMEDecoder::EventProcess::m_hasAdc {}
private

Definition at line 229 of file LArLATOMEDecoder.h.

◆ m_hasE

bool LArLATOMEDecoder::EventProcess::m_hasE {}
private

Definition at line 230 of file LArLATOMEDecoder.h.

◆ m_hasEID

bool LArLATOMEDecoder::EventProcess::m_hasEID {}
private

Definition at line 231 of file LArLATOMEDecoder.h.

◆ m_hasRawAdc

bool LArLATOMEDecoder::EventProcess::m_hasRawAdc {}
private

Definition at line 228 of file LArLATOMEDecoder.h.

◆ m_header_coll

LArLATOMEHeaderContainer* LArLATOMEDecoder::EventProcess::m_header_coll {}
private

Definition at line 242 of file LArLATOMEDecoder.h.

◆ m_headerDecoded

bool LArLATOMEDecoder::EventProcess::m_headerDecoded {}
private

Definition at line 215 of file LArLATOMEDecoder.h.

◆ m_imsg

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

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

◆ m_iPacket

Word LArLATOMEDecoder::EventProcess::m_iPacket {}
private

Definition at line 194 of file LArLATOMEDecoder.h.

◆ m_isAutoCorr

bool LArLATOMEDecoder::EventProcess::m_isAutoCorr {}
private

Definition at line 233 of file LArLATOMEDecoder.h.

◆ m_isAveraged

bool LArLATOMEDecoder::EventProcess::m_isAveraged {}
private

Definition at line 232 of file LArLATOMEDecoder.h.

◆ m_l1ID

Word LArLATOMEDecoder::EventProcess::m_l1ID {}
private

Definition at line 190 of file LArLATOMEDecoder.h.

◆ m_latomeBCID

Word LArLATOMEDecoder::EventProcess::m_latomeBCID {}
private

Definition at line 187 of file LArLATOMEDecoder.h.

◆ m_latomeCalibPatternsInEvent

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

Definition at line 250 of file LArLATOMEDecoder.h.

◆ m_LATOMEFW

Word LArLATOMEDecoder::EventProcess::m_LATOMEFW {}
private

Definition at line 192 of file LArLATOMEDecoder.h.

◆ m_latomeID

Word LArLATOMEDecoder::EventProcess::m_latomeID {}
private

Definition at line 189 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.

◆ m_monHeaderSize

Word LArLATOMEDecoder::EventProcess::m_monHeaderSize {}
private

Definition at line 196 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 181 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 218 of file LArLATOMEDecoder.h.

◆ m_nBC_Averaged

short LArLATOMEDecoder::EventProcess::m_nBC_Averaged {}
private

Definition at line 221 of file LArLATOMEDecoder.h.

◆ m_nBC_E

short LArLATOMEDecoder::EventProcess::m_nBC_E {}
private

Definition at line 219 of file LArLATOMEDecoder.h.

◆ m_nBC_EID

short LArLATOMEDecoder::EventProcess::m_nBC_EID {}
private

Definition at line 220 of file LArLATOMEDecoder.h.

◆ m_nBC_rawADC

short LArLATOMEDecoder::EventProcess::m_nBC_rawADC {}
private

Definition at line 217 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 193 of file LArLATOMEDecoder.h.

◆ m_nsc1

Word LArLATOMEDecoder::EventProcess::m_nsc1 {}
private

Definition at line 209 of file LArLATOMEDecoder.h.

◆ m_nsc2

Word LArLATOMEDecoder::EventProcess::m_nsc2 {}
private

Definition at line 210 of file LArLATOMEDecoder.h.

◆ m_nsc3

Word LArLATOMEDecoder::EventProcess::m_nsc3 {}
private

Definition at line 211 of file LArLATOMEDecoder.h.

◆ m_nsc4

Word LArLATOMEDecoder::EventProcess::m_nsc4 {}
private

Definition at line 212 of file LArLATOMEDecoder.h.

◆ m_nsc5

Word LArLATOMEDecoder::EventProcess::m_nsc5 {}
private

Definition at line 213 of file LArLATOMEDecoder.h.

◆ m_nsc6

Word LArLATOMEDecoder::EventProcess::m_nsc6 {}
private

Definition at line 214 of file LArLATOMEDecoder.h.

◆ m_nStreams

Word LArLATOMEDecoder::EventProcess::m_nStreams {}
private

Definition at line 198 of file LArLATOMEDecoder.h.

◆ m_nthLATOME

unsigned int LArLATOMEDecoder::EventProcess::m_nthLATOME = 0
private

Definition at line 245 of file LArLATOMEDecoder.h.

◆ m_nWordsPerPacket

Word LArLATOMEDecoder::EventProcess::m_nWordsPerPacket {}
private

Definition at line 195 of file LArLATOMEDecoder.h.

◆ m_packetEnd

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

Definition at line 184 of file LArLATOMEDecoder.h.

◆ m_rawValuesInEvent

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

Definition at line 248 of file LArLATOMEDecoder.h.

◆ m_region

Word LArLATOMEDecoder::EventProcess::m_region {}
private

Definition at line 197 of file LArLATOMEDecoder.h.

◆ m_ROBFragSize

Word LArLATOMEDecoder::EventProcess::m_ROBFragSize {}
private

Definition at line 191 of file LArLATOMEDecoder.h.

◆ m_streamNumber

Word LArLATOMEDecoder::EventProcess::m_streamNumber {}
private

Definition at line 199 of file LArLATOMEDecoder.h.

◆ s_monCheckPoint

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

Definition at line 183 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 182 of file LArLATOMEDecoder.h.


The documentation for this class was generated from the following files:
LArLATOMEDecoder::EventProcess::m_activeSC
Word m_activeSC
Definition: LArLATOMEDecoder.h:208
LArLATOMEDecoder::EventProcess::m_BC_EID
short m_BC_EID
Definition: LArLATOMEDecoder.h:226
LArLATOMEMapping::getChannelID
HWIdentifier getChannelID(const unsigned int sourceID, const unsigned int chan) const
create a HWIdentifier from an Identifier
Definition: LArLATOMEMapping.h:60
AthMessaging::m_lvl
std::atomic< MSG::Level > m_lvl
Current logging level.
Definition: AthMessaging.h:138
LArRawSC
Liquid Argon SuperCell raw data.
Definition: LArRawSC.h:19
LArLATOMEDecoder::EventProcess::m_nsc5
Word m_nsc5
Definition: LArLATOMEDecoder.h:213
LArAccumulatedCalibDigit
Data class for calibration ADC samples preprocessed by the DSP.
Definition: LArAccumulatedCalibDigit.h:42
et
Extra patterns decribing particle interation process.
Amg::compare
std::pair< int, int > compare(const AmgSymMatrix(N) &m1, const AmgSymMatrix(N) &m2, double precision=1e-9, bool relative=false)
compare two matrices, returns the indices of the first element that fails the condition,...
Definition: EventPrimitivesHelpers.h:109
sendEI_SPB.ch
ch
Definition: sendEI_SPB.py:35
LArLATOMEDecoder::EventProcess::compareOrSet
bool compareOrSet(Word &param, Word value, bool compare)
Definition: LArLATOMEDecoder.cxx:202
PlotCalibFromCool.ft
ft
Definition: PlotCalibFromCool.py:329
LArLATOMEDecoder::m_ignoreBarrelChannels
BooleanProperty m_ignoreBarrelChannels
Definition: LArLATOMEDecoder.h:257
LArLATOMEDecoder::EventProcess::m_et_coll
LArRawSCContainer * m_et_coll
Definition: LArLATOMEDecoder.h:238
MonDataType::ADC
@ ADC
LArAccumulatedCalibDigitContainer::setDelayScale
void setDelayScale(const double scale)
set the delay Scale
Definition: LArAccumulatedCalibDigitContainer.h:35
LArLATOMEDecoder::EventProcess::m_LATOMEFW
Word m_LATOMEFW
Definition: LArLATOMEDecoder.h:192
xAOD::word1
word1
Definition: eFexEMRoI_v1.cxx:87
LArLATOMEDecoder::EventProcess::m_nStreams
Word m_nStreams
Definition: LArLATOMEDecoder.h:198
LArLATOMEDecoder::EventProcess::m_BC_rawADC
short m_BC_rawADC
Definition: LArLATOMEDecoder.h:223
plotting.yearwise_efficiency.channel
channel
Definition: yearwise_efficiency.py:24
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
LArLATOMEDecoder::EventProcess::m_nWordsPerPacket
Word m_nWordsPerPacket
Definition: LArLATOMEDecoder.h:195
LArLATOMEDecoder::EventProcess::m_hasRawAdc
bool m_hasRawAdc
Definition: LArLATOMEDecoder.h:228
LArLATOMEDecoder::EventProcess::m_hasE
bool m_hasE
Definition: LArLATOMEDecoder.h:230
LArLATOMEDecoder::EventProcess::Word
unsigned int Word
this should be the same as how we get the data, otherwise we will have bugs.
Definition: LArLATOMEDecoder.h:133
xAOD::uint32_t
setEventNumber uint32_t
Definition: EventInfo_v1.cxx:127
LArLATOMEDecoder::m_onlineId
const LArOnline_SuperCellID * m_onlineId
Definition: LArLATOMEDecoder.h:254
patterns
std::vector< std::string > patterns
Definition: listroot.cxx:187
max
constexpr double max()
Definition: ap_fixedTest.cxx:33
LArLATOMEDecoder::EventProcess::m_BCIDsInEvent
std::vector< unsigned short > m_BCIDsInEvent
Definition: LArLATOMEDecoder.h:247
LArLATOMEDecoder::EventProcess::PAYLOAD
@ PAYLOAD
Definition: LArLATOMEDecoder.h:175
MonDataType
MonDataType
Definition: LArLATOMEDecoder.h:51
defineDB.ichan
ichan
Definition: JetTagCalibration/share/defineDB.py:28
CaloCondBlobAlgs_fillNoiseFromASCII.gain
gain
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:109
MuonGM::round
float round(const float toRound, const unsigned int decimals)
Definition: Mdt.cxx:27
LArLATOMEDecoder::EventProcess::SuperCell
int SuperCell
Definition: LArLATOMEDecoder.h:136
ReadCellNoiseFromCool.cabling
cabling
Definition: ReadCellNoiseFromCool.py:154
LArLATOMEDecoder::EventProcess::m_region
Word m_region
Definition: LArLATOMEDecoder.h:197
LArLATOMEDecoder::EventProcess::signEnergy
int signEnergy(unsigned int energy)
Definition: LArLATOMEDecoder.cxx:317
LArCalibParams
Definition: LArCalibParams.h:28
MonDataType::SelectedEnergy
@ SelectedEnergy
LArLATOMEDecoder::EventProcess::m_nsc3
Word m_nsc3
Definition: LArLATOMEDecoder.h:211
LArOnlineID_Base::slot
int slot(const HWIdentifier id) const
Return the slot number of a hardware cell identifier: slot = [1,15] Slot-ID in top part of the crat...
Definition: LArOnlineID_Base.cxx:1957
LArLATOMEDecoder::EventProcess::s_monHeaderMarker
static const Word s_monHeaderMarker
this is fixed and not read from data
Definition: LArLATOMEDecoder.h:182
LArLATOMEDecoder::EventProcess::bytesPerChannel
unsigned int bytesPerChannel(MonDataType at0, MonDataType at1)
Definition: LArLATOMEDecoder.cxx:325
LArLATOMEDecoder::EventProcess::m_nsc1
Word m_nsc1
Definition: LArLATOMEDecoder.h:209
athena.value
value
Definition: athena.py:124
LArLATOMEDecoder::EventProcess::m_nsc6
Word m_nsc6
Definition: LArLATOMEDecoder.h:214
LArLATOMEDecoder::EventProcess::m_packetEnd
std::vector< Word > m_packetEnd
Definition: LArLATOMEDecoder.h:184
LArLATOMEDecoder::EventProcess::m_ROBFragSize
Word m_ROBFragSize
Definition: LArLATOMEDecoder.h:191
LArLATOMEDecoder::EventProcess::decodeChannel
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)
Definition: LArLATOMEDecoder.cxx:371
LArLATOMEDecoder::EventProcess::m_BC_E
short m_BC_E
Definition: LArLATOMEDecoder.h:225
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
LArLATOMEDecoder::EventProcess::m_latomeBCID
Word m_latomeBCID
Definition: LArLATOMEDecoder.h:187
LArLATOMEDecoder::EventProcess::decodeWord
void decodeWord(unsigned int &word, unsigned int &wordshift, unsigned int &byteshift, const uint32_t *p)
Definition: LArLATOMEDecoder.cxx:361
LArOnlineID_Base::barrel_ec
int barrel_ec(const HWIdentifier id) const
Return the position barrel or endcap of a hardware cell identifier: barrel_ec = [0,...
Definition: LArOnlineID_Base.cxx:1938
AthMessaging::m_imsg
std::atomic< IMessageSvc * > m_imsg
MessageSvc pointer.
Definition: AthMessaging.h:135
LArLATOMEDecoder::EventProcess::m_at1nBC
Word m_at1nBC
Definition: LArLATOMEDecoder.h:205
Athena::getMessageSvc
IMessageSvc * getMessageSvc(bool quiet=false)
Definition: getMessageSvc.cxx:20
N_LATOME_CHANNELS
#define N_LATOME_CHANNELS
fixed number of channels on one LATOME board
Definition: LArLATOMEMapping.h:22
LArLATOMEDecoder::EventProcess::m_nBC_Averaged
short m_nBC_Averaged
Definition: LArLATOMEDecoder.h:221
LArLATOMEDecoder::EventProcess::m_monHeaderSize
Word m_monHeaderSize
Definition: LArLATOMEDecoder.h:196
LArLATOMEDecoder::EventProcess::m_at1BC
Word m_at1BC
Definition: LArLATOMEDecoder.h:207
LArLATOMEDecoder::EventProcess::m_decoder
const LArLATOMEDecoder * m_decoder
Definition: LArLATOMEDecoder.h:235
MonDataType::AutoCorr
@ AutoCorr
LArLATOMEDecoder::EventProcess::m_nsc4
Word m_nsc4
Definition: LArLATOMEDecoder.h:212
LArLATOMEDecoder::EventProcess::m_isAveraged
bool m_isAveraged
Definition: LArLATOMEDecoder.h:232
LArLATOMEDecoder::EventProcess::m_header_coll
LArLATOMEHeaderContainer * m_header_coll
Definition: LArLATOMEDecoder.h:242
LArLATOMEDecoder::EventProcess::m_adc_coll
LArDigitContainer * m_adc_coll
Definition: LArLATOMEDecoder.h:236
LArLATOMEDecoder::EventProcess::m_at0nBC
Word m_at0nBC
Definition: LArLATOMEDecoder.h:204
AthMessaging::AthMessaging
AthMessaging()
Default constructor:
LArOnline_SuperCellID::isHECchannel
bool isHECchannel(const HWIdentifier id) const override final
Definition: LArOnline_SuperCellID.cxx:362
MonDataType::Invalid
@ Invalid
LArOnlineID_Base::channel
int channel(const HWIdentifier id) const
Return the channel number of a hardware cell identifier channel = [0,127] in all FEB.
Definition: LArOnlineID_Base.cxx:1963
LArAccumulatedDigit
Data class for ADC samples and autocorr preprocessed by the DSP.
Definition: LArAccumulatedDigit.h:32
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:209
LArLATOMEDecoder::EventProcess::m_monTrailerSize
static const Word m_monTrailerSize
some cached info to ease processing reading from data header
Definition: LArLATOMEDecoder.h:181
LArLATOMEDecoder::EventProcess::decodeByte
void decodeByte(unsigned int &byte, unsigned int wordshift, unsigned int byteshift, const uint32_t *p)
Definition: LArLATOMEDecoder.cxx:357
TrigConf::MSGTC::Level
Level
Definition: Trigger/TrigConfiguration/TrigConfBase/TrigConfBase/MsgStream.h:21
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
LArLATOMEDecoder::EventProcess::m_at0BC
Word m_at0BC
Definition: LArLATOMEDecoder.h:206
convertTimingResiduals.sum
sum
Definition: convertTimingResiduals.py:55
ParticleGun_FastCalo_ChargeFlip_Config.energy
energy
Definition: ParticleGun_FastCalo_ChargeFlip_Config.py:78
LArLATOMEDecoder::EventProcess::increaseWordShift
void increaseWordShift(unsigned int &wordshift)
Definition: LArLATOMEDecoder.cxx:340
xAOD::uint16_t
setWord1 uint16_t
Definition: eFexEMRoI_v1.cxx:93
lumiFormat.i
int i
Definition: lumiFormat.py:85
LArLATOMEDecoder::EventProcess::m_caccdigits
LArAccumulatedCalibDigitContainer * m_caccdigits
Definition: LArLATOMEDecoder.h:241
LArLATOMEDecoder::EventProcess::m_nBC_E
short m_nBC_E
Definition: LArLATOMEDecoder.h:219
LArLATOMEDecoder::EventProcess::m_nBC_EID
short m_nBC_EID
Definition: LArLATOMEDecoder.h:220
beamspotman.n
n
Definition: beamspotman.py:729
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
LArLATOMEDecoder::EventProcess::s_monCheckPoint
static const Word s_monCheckPoint
Definition: LArLATOMEDecoder.h:183
LArLATOMEDecoder::EventProcess::m_nBC_ADC
short m_nBC_ADC
Definition: LArLATOMEDecoder.h:218
LArLATOMEDecoder::m_ignoreEndcapChannels
BooleanProperty m_ignoreEndcapChannels
Definition: LArLATOMEDecoder.h:258
LArCalibParams::isPulsed
bool isPulsed(const unsigned event, const HWIdentifier calibLineID) const
Definition: LArCalibParams.cxx:151
LArLATOMEDecoder::m_cablingKeySC
SG::ReadCondHandleKey< LArOnOffIdMapping > m_cablingKeySC
Definition: LArLATOMEDecoder.h:261
LArLATOMEDecoder::EventProcess::increaseByteShift
void increaseByteShift(unsigned int &wordshift, unsigned int &byteshift)
Definition: LArLATOMEDecoder.cxx:349
LArLATOMEDecoder::EventProcess::m_et_id_coll
LArRawSCContainer * m_et_id_coll
Definition: LArLATOMEDecoder.h:239
MonDataType::RawADC
@ RawADC
find_tgc_unfilled_channelids.ip
ip
Definition: find_tgc_unfilled_channelids.py:3
LArLATOMEDecoder::EventProcess::m_streamNumber
Word m_streamNumber
Definition: LArLATOMEDecoder.h:199
LArLATOMEDecoder::EventProcess::m_rawValuesInEvent
std::vector< LatomeRawData > m_rawValuesInEvent
Definition: LArLATOMEDecoder.h:248
xAOD::double
double
Definition: CompositeParticle_v1.cxx:159
LArLATOMEDecoder::EventProcess::decodeTrailer
unsigned int decodeTrailer(const uint32_t *p, unsigned int offset)
Definition: LArLATOMEDecoder.cxx:210
AthMessaging::msg
MsgStream & msg() const
The standard message stream.
Definition: AthMessaging.h:164
LArSCDigit
Base class for LArDigits taken by LATOME.
Definition: LArSCDigit.h:19
fitman.mux
mux
Definition: fitman.py:547
LArLATOMEDecoder::EventProcess::m_at1typeRec
Word m_at1typeRec
Definition: LArLATOMEDecoder.h:201
LArLATOMEDecoder::EventProcess::m_hasEID
bool m_hasEID
Definition: LArLATOMEDecoder.h:231
MonDataType::Energy
@ Energy
LArCalibParams::DAC
unsigned DAC(const unsigned event, const HWIdentifier calibLineID) const
Definition: LArCalibParams.cxx:131
plotBeamSpotMon.b
b
Definition: plotBeamSpotMon.py:76
MonDataType::Averaged
@ Averaged
LArLATOMEDecoder::EventProcess::fillCalib
void fillCalib(const LArLATOMEMapping *map, const LArOnOffIdMapping *onoffmap, const LArCalibLineMapping *clmap)
Definition: LArLATOMEDecoder.cxx:889
LArLATOMEDecoder::EventProcess::fillRaw
void fillRaw(const LArLATOMEMapping *map)
Pass ADC values from an event.
Definition: LArLATOMEDecoder.cxx:1058
LArCalibParams::Delay
unsigned Delay(const unsigned event, const HWIdentifier calibLineID) const
Definition: LArCalibParams.cxx:112
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
xAOD::bcid
setEventNumber setTimeStamp bcid
Definition: EventInfo_v1.cxx:133
LArLATOMEDecoder::EventProcess::m_at1type
Word m_at1type
Definition: LArLATOMEDecoder.h:203
CaloGain::LARHIGHGAIN
@ LARHIGHGAIN
Definition: CaloGain.h:18
LArLATOMEDecoder::EventProcess::m_nPackets
Word m_nPackets
Definition: LArLATOMEDecoder.h:193
LArLATOMEDecoder::EventProcess::m_averagedRawValuesInEvent
std::vector< LatomeAveragedRawData > m_averagedRawValuesInEvent
Definition: LArLATOMEDecoder.h:249
LArLATOMEDecoder::EventProcess::m_accdigits
LArAccumulatedDigitContainer * m_accdigits
Definition: LArLATOMEDecoder.h:240
CaloGain::CaloGain
CaloGain
Definition: CaloGain.h:11
LArLATOMEDecoder::EventProcess::m_latomeCalibPatternsInEvent
std::vector< LatomeCalibPatterns > m_latomeCalibPatternsInEvent
Definition: LArLATOMEDecoder.h:250
LArLATOMEHeader
Holds information from the LATOME Header.
Definition: LArLATOMEHeader.h:19
LArOnlineID_Base::feedthrough
int feedthrough(const HWIdentifier id) const
Return the feedthrough of a hardware cell identifier : feedthrough = [0,31] Barrel - A/C side or H/...
Definition: LArOnlineID_Base.cxx:1944
LArLATOMEDecoder::EventProcess::m_BC_ADC
short m_BC_ADC
Definition: LArLATOMEDecoder.h:224
python.CaloAddPedShiftConfig.int
int
Definition: CaloAddPedShiftConfig.py:45
lumiFormat.fill
fill
Definition: lumiFormat.py:104
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
python.Constants.INFO
int INFO
Definition: Control/AthenaCommon/python/Constants.py:15
LArLATOMEDecoder::EventProcess::m_nthLATOME
unsigned int m_nthLATOME
Definition: LArLATOMEDecoder.h:245
Pythia8_RapidityOrderMPI.val
val
Definition: Pythia8_RapidityOrderMPI.py:14
AthMessaging::m_nm
std::string m_nm
Message source name.
Definition: AthMessaging.h:129
DEBUG
#define DEBUG
Definition: page_access.h:11
LArLATOMEDecoder::EventProcess::MON_HEADER
@ MON_HEADER
Definition: LArLATOMEDecoder.h:175
AthCommonMsg::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
LArLATOMEDecoder::EventProcess::m_at0typeRec
Word m_at0typeRec
Definition: LArLATOMEDecoder.h:200
LArCalibParams::initialize
virtual StatusCode initialize()
Definition: LArCalibParams.cxx:16
LArLATOMEDecoder::EventProcess::fillHeader
void fillHeader()
Definition: LArLATOMEDecoder.cxx:1134
convertTimingResiduals.offset
offset
Definition: convertTimingResiduals.py:71
LArLATOMEDecoder::EventProcess::m_headerDecoded
bool m_headerDecoded
Definition: LArLATOMEDecoder.h:215
python.SystemOfUnits.s
float s
Definition: SystemOfUnits.py:147
LArLATOMEDecoder::EventProcess::m_l1ID
Word m_l1ID
Definition: LArLATOMEDecoder.h:190
LArLATOMEDecoder::EventProcess::m_iPacket
Word m_iPacket
Definition: LArLATOMEDecoder.h:194
LArLATOMEDecoder::EventProcess::MON_TRAILER
@ MON_TRAILER
Definition: LArLATOMEDecoder.h:175
LArLATOMEDecoder::EventProcess::m_at0type
Word m_at0type
Definition: LArLATOMEDecoder.h:202
AthMessaging::initMessaging
void initMessaging() const
Initialize our message level and MessageSvc.
Definition: AthMessaging.cxx:39
beamspotnt.nt
def nt
Definition: bin/beamspotnt.py:1062
LArLATOMEDecoder::EventProcess::m_nBC_rawADC
short m_nBC_rawADC
Definition: LArLATOMEDecoder.h:217
LArLATOMEDecoder::EventProcess::decodeHeader
unsigned int decodeHeader(const uint32_t *p, unsigned int offset)
Definition: LArLATOMEDecoder.cxx:220
AthMessaging::m_msg_tls
boost::thread_specific_ptr< MsgStream > m_msg_tls
MsgStream instance (a std::cout like with print-out levels)
Definition: AthMessaging.h:132
LArLATOMEDecoder::EventProcess::m_hasAdc
bool m_hasAdc
Definition: LArLATOMEDecoder.h:229
pow
constexpr int pow(int base, int exp) noexcept
Definition: ap_fixedTest.cxx:15
LArLATOMEDecoder::EventProcess::m_nsc2
Word m_nsc2
Definition: LArLATOMEDecoder.h:210
LArLATOMEDecoder::s_nBunches
static const int s_nBunches
Maximum value of BCID.
Definition: LArLATOMEDecoder.h:98
LArLATOMEDecoder::EventProcess::m_latomeID
Word m_latomeID
Definition: LArLATOMEDecoder.h:189
LArCalibParams::set
void set(const HWIdentifier CalibModuleID, const unsigned nTrigger, const std::vector< unsigned > &Pattern, const std::vector< unsigned > &DAC, const std::vector< unsigned > &Delay)
Definition: LArCalibParams.cxx:30
LArLATOMEDecoder::m_sc2ccMappingTool
ToolHandle< ICaloSuperCellIDTool > m_sc2ccMappingTool
Definition: LArLATOMEDecoder.h:255
LArLATOMEDecoder::m_keepPulsed
BooleanProperty m_keepPulsed
Definition: LArLATOMEDecoder.h:260
LArLATOMEDecoder::EventProcess::m_isAutoCorr
bool m_isAutoCorr
Definition: LArLATOMEDecoder.h:233
LArLATOMEDecoder::EventProcess::m_adc_bas_coll
LArDigitContainer * m_adc_bas_coll
Definition: LArLATOMEDecoder.h:237
python.SystemOfUnits.ms
float ms
Definition: SystemOfUnits.py:148
Identifier
Definition: IdentifierFieldParser.cxx:14