Loading [MathJax]/extensions/tex2jax.js
ATLAS Offline Software
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
LArLATOMEDecoder.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 #define DETAIL_DUMP_ON false
6 #define ADC_DUMP_ON false
7 #define VALIDATE_DUMP_ON false
8 
9 #include "LArByteStream/LArLATOMEDecoder.h"
10 
11 #include <byteswap.h>
12 
13 #include "AthenaKernel/getMessageSvc.h"
14 #include "GaudiKernel/MsgStream.h"
15 #include "LArByteStream/LATOMEMapping.h"
16 #include "LArByteStream/Mon.h"
17 #include "LArIdentifier/LArOnline_SuperCellID.h"
18 #include "LArRawConditions/LArCalibParams.h"
19 
20 static const InterfaceID IID_ILArLATOMEDecoder("LArLATOMEDecoder", 1, 0);
21 
22 using namespace OFFLINE_FRAGMENTS_NAMESPACE;
23 
24 LArLATOMEDecoder::LArLATOMEDecoder(const std::string& type, const std::string& name, const IInterface* parent)
25  : AthAlgTool(type, name, parent), m_sc2ccMappingTool("CaloSuperCellIDTool") {
26  declareInterface<LArLATOMEDecoder>(this);
27 }
28 
29 const InterfaceID& LArLATOMEDecoder::interfaceID() {
30  return IID_ILArLATOMEDecoder;
31 }
32 
33 StatusCode LArLATOMEDecoder::initialize() {
34 
35  ATH_CHECK(detStore()->retrieve(m_onlineId, "LArOnline_SuperCellID"));
36 
37  ATH_CHECK(m_sc2ccMappingTool.retrieve());
38  ATH_CHECK(m_cablingKeySC.initialize());
39 
40  return StatusCode::SUCCESS;
41 }
42 
43 StatusCode LArLATOMEDecoder::convert(const RawEvent* re, const LArLATOMEMapping* map, const LArOnOffIdMapping* onoffmap, const LArCalibLineMapping* clmap,
44  LArAccumulatedDigitContainer* accdigits, LArAccumulatedCalibDigitContainer* caccdigits,
45  LArLATOMEHeaderContainer* header_coll) const {
46 
47  if(!re) return StatusCode::FAILURE;;
48  bool ret = false;
49  // Check fragment validity:
50  try {
51  ret = re->check();
52  } catch (eformat::Issue& ex) {
53  ATH_MSG_WARNING("Exception while checking eformat fragment validity: " << ex.what());
54  ret = false;
55  }
56  if (!ret) {
57  ATH_MSG_ERROR("Got invalid RawEvent fragment");
58  return StatusCode::FAILURE;
59  }
60  // Build TOC
61  std::map<eformat::SubDetectorGroup, std::vector<const uint32_t*> > robIndex;
62  eformat::helper::build_toc(*re, robIndex);
63  for (auto mapit : robIndex)
64  ATH_MSG_DEBUG("Rob Index subdetgroup is " << std::hex << mapit.first);
65  std::map<eformat::SubDetectorGroup, std::vector<const uint32_t*> >::const_iterator robIt = robIndex.find(eformat::LAR);
66  if (robIt != robIndex.end()) {
67  const std::vector<const uint32_t*>& robs = robIt->second;
68  for (const uint32_t* pRob : robs) {
69  try {
70  ROBFragment robFrag(pRob);
71  if (m_protectSourceId) {
72  uint32_t latomeSourceID = robFrag.rod_source_id();
73  if (!(latomeSourceID & 0x1000)) {
74  ATH_MSG_DEBUG(" discarding non latome source ID " << std::hex << latomeSourceID);
75  continue;
76  }
77  ATH_MSG_DEBUG(" found latome source ID " << std::hex << latomeSourceID);
78  }
79  EventProcess ev(this, 0, 0, 0, 0, accdigits, caccdigits, header_coll);
80  ev.fillCollection(&robFrag, map, onoffmap, clmap);
81  } catch (eformat::Issue& ex) {
82  ATH_MSG_WARNING(" exception thrown by ROBFragment, badly corrupted event. Abort decoding ");
83  if (accdigits)
84  accdigits->clear();
85  if (caccdigits)
86  caccdigits->clear();
87  if (header_coll)
88  header_coll->clear();
89  break;
90  }
91  } // end loop over robs
92  } // end if got LAr-RODs
93 
94  return StatusCode::SUCCESS;
95 }
96 
97 StatusCode LArLATOMEDecoder::convert(const std::vector<const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment*>& robFrags, const LArLATOMEMapping* map,
98  LArDigitContainer* adc_coll, LArDigitContainer* adc_bas_coll, LArRawSCContainer* et_coll, LArRawSCContainer* et_id_coll,
99  LArLATOMEHeaderContainer* header_coll) const {
100 
101  // Check fragment validity:
102  // Build TOC
103  if (robFrags.size() > 0) {
104  for (const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment* pRob : robFrags) {
105  try {
106  if (m_protectSourceId) {
107  uint32_t latomeSourceID = pRob->rod_source_id();
108  if (!(latomeSourceID & 0x1000)) {
109  ATH_MSG_DEBUG(" discarding non latome source ID " << std::hex << latomeSourceID);
110  continue;
111  }
112  ATH_MSG_DEBUG(" found latome source ID " << std::hex << latomeSourceID);
113  }
114  EventProcess ev(this, adc_coll, adc_bas_coll, et_coll, et_id_coll, 0, 0, header_coll);
115  ev.fillCollection(pRob, map, nullptr, nullptr);
116  } catch (eformat::Issue& ex) {
117  ATH_MSG_WARNING(" exception thrown by ROBFragment, badly corrupted event. Abort decoding ");
118  if (adc_coll)
119  adc_coll->clear();
120  if (adc_bas_coll)
121  adc_bas_coll->clear();
122  if (et_coll)
123  et_coll->clear();
124  if (et_id_coll)
125  et_id_coll->clear();
126  if (header_coll)
127  header_coll->clear();
128  break;
129  }
130  } // end loop over robs
131  } // end if got LAr-RODs
132  return StatusCode::SUCCESS;
133 }
134 
135 LArLATOMEDecoder::EventProcess::EventProcess(const LArLATOMEDecoder* decoderInput, LArDigitContainer* adc_coll, LArDigitContainer* adc_bas_coll,
136  LArRawSCContainer* et_coll, LArRawSCContainer* et_id_coll, LArAccumulatedDigitContainer* accdigits,
137  LArAccumulatedCalibDigitContainer* caccdigits, LArLATOMEHeaderContainer* header_coll)
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;
157  m_at0typeRec = (Word)MonDataType::Invalid;
158  m_at1typeRec = (Word)MonDataType::Invalid;
159  m_at0type = (Word)MonDataType::Invalid;
160  m_at1type = (Word)MonDataType::Invalid;
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) {
195  m_rawValuesInEvent.resize(N_LATOME_CHANNELS);
196  } else {
197  m_averagedRawValuesInEvent.resize(N_LATOME_CHANNELS);
198  m_latomeCalibPatternsInEvent.resize(2);
199  }
200 }
201 
202 bool LArLATOMEDecoder::EventProcess::compareOrSet(Word& param, Word value, bool compare) {
203  if (!compare) {
204  param = value;
205  return true;
206  }
207  return param == value;
208 }
209 
210 unsigned int LArLATOMEDecoder::EventProcess::decodeTrailer(const uint32_t* p, unsigned int offset) {
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 }
219 
220 unsigned int LArLATOMEDecoder::EventProcess::decodeHeader(const uint32_t* p, unsigned int offset) {
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;
314  return m_monHeaderSize + m_nWordsPerPacket + offset;
315 }
316 
317 int LArLATOMEDecoder::EventProcess::signEnergy(unsigned int energy) {
318 
319  if (energy & (1 << 17))
320  return energy - pow(2, 18);
321  else
322  return energy;
323 }
324 
325 unsigned int LArLATOMEDecoder::EventProcess::bytesPerChannel(MonDataType at0, MonDataType at1) {
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;
335  if (at0 == MonDataType::Energy || at1 == MonDataType::Energy || at0 == MonDataType::SelectedEnergy || at1 == MonDataType::SelectedEnergy)
336  ++b;
337  return b;
338 }
339 
340 void LArLATOMEDecoder::EventProcess::increaseWordShift(unsigned int& wordshift) {
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 }
348 
349 void LArLATOMEDecoder::EventProcess::increaseByteShift(unsigned int& wordshift, unsigned int& byteshift) {
350  ++byteshift;
351  if (byteshift == 4) {
352  increaseWordShift(wordshift);
353  byteshift = 0;
354  }
355 }
356 
357 void LArLATOMEDecoder::EventProcess::decodeByte(unsigned int& byte, unsigned int wordshift, unsigned int byteshift, const uint32_t* p) {
358  byte = ((bswap_32(p[wordshift])) >> (8 * (4 - 1 - byteshift))) & 0xff;
359 }
360 
361 void LArLATOMEDecoder::EventProcess::decodeWord(unsigned int& word, unsigned int& wordshift, unsigned int& byteshift, const uint32_t* p) {
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 }
370 
371 void LArLATOMEDecoder::EventProcess::decodeChannel(unsigned int& wordshift, unsigned int& byteshift, const uint32_t* p, MonDataType at0, MonDataType at1,
372  unsigned int& at0Data, unsigned int& at1Data, unsigned int& saturation, bool& at0val, bool& at1val) {
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 }
428 
429 void LArLATOMEDecoder::EventProcess::fillCollection(const ROBFragment* robFrag, const LArLATOMEMapping* map, const LArOnOffIdMapping* onoffmap,
430  const LArCalibLineMapping* clmap) {
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 
467  LatomeCalibPatterns pat1, pat2, pat3;
468  pat1.DAC = rod_status[9];
469  pat1.delay = rod_status[10];
470  pat1.patterns.resize(4);
471  for (unsigned int i = 0; i < 4; ++i)
472  pat1.patterns[i] = rod_status[i + 11];
473 
474  pat2.DAC = rod_status[15];
475  pat2.delay = rod_status[16];
476  pat2.patterns.resize(4);
477  for (unsigned int i = 0; i < 4; ++i)
478  pat2.patterns[i] = rod_status[i + 17];
479 
480  pat3.DAC = rod_status[21];
481  pat3.delay = rod_status[22];
482  pat3.patterns.resize(4);
483  for (unsigned int i = 0; i < 4; ++i)
484  pat3.patterns[i] = rod_status[i + 23];
485 
486  m_latomeCalibPatternsInEvent = {pat1, pat2, pat3};
487 
488  const HWIdentifier hwidEmpty;
489 
491 
492  unsigned int offset = decodeHeader(p, 0);
493  if (offset > m_ROBFragSize) {
494  ATH_MSG_WARNING("Data corruption, offset found at pos 0 (" << offset << ") is larger than the ROB fragment size (" << m_ROBFragSize << "). Ignoring data.");
495  return;
496  }
497 
498  if (m_isAveraged) {
499  m_at0type = m_at0typeRec >> 24;
500  m_at1type = (int)MonDataType::Invalid;
501  if (m_at0type != (int)MonDataType::Averaged) {
502  ATH_MSG_WARNING(" inconsistant data type with requested averaged decoding at0 type " << m_at0type << " " << m_at0typeRec << " " << std::hex << m_l1ID
503  << " " << sourceID << std::dec);
504  return;
505  }
506  }
507  if (m_isAutoCorr) {
508  m_at0type = m_at0typeRec >> 24;
509  m_at1type = (int)MonDataType::Invalid;
510  if (m_at0type != (int)MonDataType::AutoCorr) {
511  ATH_MSG_WARNING(" inconsistant data type with requested averaged decoding at0 type " << m_at0type << " " << m_at0typeRec << " " << std::hex << m_l1ID
512  << " " << sourceID << std::dec);
513  return;
514  }
515  }
516 
517  m_packetEnd.push_back(offset);
518  offset = decodeTrailer(p, offset);
521  for (unsigned int ip = 1; ip < m_nPackets; ++ip) {
522  offset = decodeHeader(p, offset);
523  m_packetEnd.push_back(offset);
524  offset = decodeTrailer(p, offset);
525  }
526 
527  ATH_MSG_DEBUG(" end of header check computed offset=" << std::dec << offset << " nwords in payload=" << n);
528 
530  m_iPacket = 0;
531  if (m_packetEnd[m_nPackets - 1] + m_monTrailerSize != n) {
532  ATH_MSG_WARNING("problem in packet size loop " << m_packetEnd[m_nPackets - 1] << " != " << n);
533  }
534 
535  std::vector<unsigned int> timeslot_nsc = {m_nsc1, m_nsc2, m_nsc3, m_nsc4, m_nsc5, m_nsc6};
536  std::vector<unsigned int> bc_size;
539 
540  short nBC = 0;
541  short nBC1 = 0;
542  short startBC1 = 0;
543  MonDataType type0 = MonDataType::Invalid;
544  MonDataType type1 = MonDataType::Invalid;
545 
546  if (m_isAveraged || m_isAutoCorr) {
547  nBC = m_at0nBC;
548  nBC1 = m_at1nBC;
549  m_nBC_Averaged = nBC;
550  startBC1 = 0;
551  type0 = static_cast<MonDataType>(m_at0type);
552  type1 = static_cast<MonDataType>(m_at1type);
553  for (auto& val : m_averagedRawValuesInEvent) {
554  val.sum.resize(m_nBC_Averaged);
555  val.sumSq.resize(m_nBC_Averaged);
556  val.nTrigValid.resize(m_nBC_Averaged);
557  val.latomeChannel = 99999;
558  }
559  } else {
560  if (m_at1nBC == 0) {
561  m_at1type = (Word)MonDataType::Invalid;
562  }
563 
564  if (m_at0type != (Word)MonDataType::Invalid && m_at1type != (Word)MonDataType::Invalid) {
565  if (m_at0nBC >= m_at1nBC) {
566  nBC = m_at0nBC;
567  nBC1 = m_at1nBC;
568  startBC1 = m_at1BC - m_at0BC;
569  type0 = static_cast<MonDataType>(m_at0type);
570  type1 = static_cast<MonDataType>(m_at1type);
571  } else {
572  nBC1 = m_at0nBC;
573  nBC = m_at1nBC;
574  startBC1 = m_at0BC - m_at1BC;
575  type1 = static_cast<MonDataType>(m_at0type);
576  type0 = static_cast<MonDataType>(m_at1type);
577  }
578  } else if (m_at0type != (Word)MonDataType::Invalid) {
579  nBC = m_at0nBC;
580  type0 = static_cast<MonDataType>(m_at0type);
581  } else if (m_at1type != (Word)MonDataType::Invalid) {
582  nBC = m_at1nBC;
583  type0 = static_cast<MonDataType>(m_at1type);
584  } else {
585  ATH_MSG_ERROR("No valid data type in Mon Header");
586  return;
587  }
588 
589  switch (type0) {
590  case MonDataType::RawADC:
591  m_hasRawAdc = true;
592  m_nBC_rawADC = nBC;
593  break;
594  case MonDataType::ADC:
595  m_hasAdc = true;
596  m_nBC_ADC = nBC;
597  break;
598  case MonDataType::Energy:
599  m_hasE = true;
600  m_nBC_E = nBC;
601  break;
602  case MonDataType::SelectedEnergy:
603  m_hasEID = true;
604  m_nBC_EID = nBC;
605  break;
606  case MonDataType::Invalid:
607  break;
608  default:
609  ATH_MSG_ERROR("wrong mux0 value " << (Word)type0);
610  return;
611  }
612 
613  switch (type1) {
614  case MonDataType::RawADC:
615  m_hasRawAdc = true;
616  m_nBC_rawADC = nBC1;
617  m_BC_rawADC = startBC1;
618  break;
619  case MonDataType::ADC:
620  m_hasAdc = true;
621  m_nBC_ADC = nBC1;
622  m_BC_ADC = startBC1;
623  break;
624  case MonDataType::Energy:
625  m_hasE = true;
626  m_nBC_E = nBC1;
627  m_BC_E = startBC1;
628  break;
629  case MonDataType::SelectedEnergy:
630  m_hasEID = true;
631  m_nBC_EID = nBC1;
632  m_BC_EID = startBC1;
633  break;
634  case MonDataType::Invalid:
635  break;
636  default:
637  ATH_MSG_ERROR("wrong mux1 value " << (Word)type1);
638  return;
639  }
640 
641  for (auto& val : m_rawValuesInEvent) {
642  if (m_hasRawAdc)
643  val.adc.resize(m_nBC_rawADC);
644  if (m_hasAdc)
645  val.adc_bas.resize(m_nBC_ADC);
646  if (m_hasE)
647  val.et.resize(m_nBC_E);
648  if (m_hasEID)
649  val.et_id.resize(m_nBC_EID);
650  if (m_hasEID || m_hasE) {
651  val.saturation.resize(std::max(m_nBC_EID, m_nBC_E));
652  }
653 
654  val.latomeChannel = 99999;
655  }
656  }
657 
658  m_BCIDsInEvent.resize(nBC);
659 
660  unsigned int s = m_monHeaderSize;
661  unsigned int bcid = s_nBunches;
662 
663  for (short iBC = 0; iBC < nBC; ++iBC) {
664  MonDataType at0 = type0;
665  MonDataType at1 = type1;
666  if (type1 != MonDataType::Invalid) {
667  if (iBC < startBC1 || iBC >= startBC1 + nBC1)
668  at1 = MonDataType::Invalid;
669  }
670  unsigned int nbytesPerChannel = bytesPerChannel(at0, at1);
671 
672  int nsc = 0;
673  unsigned int oldipacket = 0;
674  for (unsigned int itimeslot = 0; itimeslot < 6; ++itimeslot) {
675  unsigned int l_bcid = (bswap_32(p[s]))>>16;
676  if(itimeslot!=0){
677  if(l_bcid!=bcid){
678  ATH_MSG_WARNING( "ERROR: inconsistent BCID between time slots" );
679  }
680  }
681  else{
682  if(bcid!=s_nBunches){
683  unsigned int bcid_c = bcid+1;
685  if(bcid_c==s_nBunches){
686  bcid=0;
687  bcid_c = 0;
688  }
689  if(bcid_c != l_bcid){
690  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 );
691  }
692  }
693  m_BCIDsInEvent[iBC] = l_bcid;
694  }
695  bcid=l_bcid;
696 
697  unsigned int mux = ((bswap_32(p[s])) >> 8) & 0xff;
698  increaseWordShift(s);
700  increaseWordShift(s);
701  if (s >= n)
702  break;
703 
704  unsigned int timeslotsize = timeslot_nsc[itimeslot];
705  unsigned int nbytes = timeslotsize * nbytesPerChannel;
706  unsigned int n64word = nbytes / 8;
707  if (nbytes % 8)
708  ++n64word;
709  ATH_MSG_DEBUG(" at BC " << iBC << " timeslot " << itimeslot << " " << bcid << " " << mux << " n64word " << n64word << " at0 " << (int)at0 << " at1 "
710  << (int)at1 << " l_bcid " << bcid);
711 
712  unsigned int wordshift = s;
713  unsigned int byteshift = 0;
714 
716  oldipacket = m_iPacket;
717  for (unsigned int ichan = 0; ichan < timeslotsize; ++ichan) {
718  unsigned int at0Data = 0, at1Data = 0, satData = 0;
719  bool at0val = false, at1val = false;
720 
721  // protection against corrupted bytestream data
722  if (nsc > N_LATOME_CHANNELS - 1) {
723  break;
724  // FIXME: should fill some default data to all channels, because clearly this block is corrupted
725  }
726  if (!m_isAveraged && !m_isAutoCorr) {
727  decodeChannel(wordshift, byteshift, p, at0, at1, at0Data, at1Data, satData, at0val, at1val);
728  ATH_MSG_DEBUG(" wordshift " << wordshift << " byteshift " << byteshift << " at0data " << at0Data << " at1Data " << at1Data << " satData " << satData
729  << " at0val " << at0val << " at1val " << at1val << " nsc " << nsc);
730 
732  const auto SCID = map ? map->getChannelID(m_nthLATOME, nsc) : hwidEmpty;
733  if (SCID == hwidEmpty) {
734  ATH_MSG_DEBUG("No mapping for ch: " << std::dec << nsc);
735  }
736  int RAWValue0 = -999;
737  if (!at0val && SCID != hwidEmpty && at0 != MonDataType::Invalid) {
738  ATH_MSG_DEBUG("at0 bad quality bit for SC:" << nsc << " BC " << iBC << " latome " << robFrag->rod_source_id());
739  } else {
741  RAWValue0 = at0Data;
742  }
743  int defaultADCValue = -1;
744  int defaultEValue = -99999;
745  auto& rawValuesInEvent = m_rawValuesInEvent[nsc];
746  switch (at0) {
747  case MonDataType::RawADC:
748  if ((unsigned)iBC < rawValuesInEvent.adc.size()) {
749  rawValuesInEvent.adc[iBC] = (at0val) ? RAWValue0 : defaultADCValue;
750  }
751  break;
752  case MonDataType::ADC:
753  if ((unsigned)iBC < rawValuesInEvent.adc_bas.size()) {
754  rawValuesInEvent.adc_bas[iBC] = (at0val) ? RAWValue0 : defaultADCValue;
755  }
756  break;
757  case MonDataType::Energy:
758  if ((unsigned)iBC < rawValuesInEvent.et.size()) {
759  rawValuesInEvent.et[iBC] = (at0val) ? signEnergy(RAWValue0) : defaultEValue;
760  rawValuesInEvent.saturation[iBC] = satData;
761  }
762  break;
763  case MonDataType::SelectedEnergy:
764  if ((unsigned)iBC < rawValuesInEvent.et_id.size()) {
765  rawValuesInEvent.et_id[iBC] = (at0val) ? signEnergy(RAWValue0) : defaultEValue;
766  rawValuesInEvent.saturation[iBC] = satData;
767  }
768  break;
769  case MonDataType::Invalid:
770  break;
771  default:
772  ATH_MSG_ERROR("wrong at0 value " << (Word)at0);
773  return;
774  }
775 
776  int RAWValue1 = -999;
777  if (!at1val && SCID != hwidEmpty && at1 != MonDataType::Invalid) {
778  ATH_MSG_DEBUG("at1 bad quality bit for SC:" << nsc << " BC " << iBC << " latome " << robFrag->rod_source_id());
779  } else {
781  RAWValue1 = at1Data;
782  }
783 
784  const size_t BCidx = iBC - startBC1;
785  switch (at1) {
786  case MonDataType::RawADC:
787  if (BCidx < rawValuesInEvent.adc.size()) {
788  rawValuesInEvent.adc[BCidx] = (at1val) ? RAWValue1 : defaultADCValue;
789  }
790  break;
791  case MonDataType::ADC:
792  if (BCidx < rawValuesInEvent.adc_bas.size()) {
793  rawValuesInEvent.adc_bas[BCidx] = (at1val) ? RAWValue1 : defaultADCValue;
794  }
795  break;
796  case MonDataType::Energy:
797  if (BCidx < rawValuesInEvent.et.size()) {
798  rawValuesInEvent.et[BCidx] = (at1val) ? signEnergy(RAWValue1) : defaultEValue;
799  rawValuesInEvent.saturation[BCidx] = satData;
800  }
801  break;
802  case MonDataType::SelectedEnergy:
803  if (BCidx < rawValuesInEvent.et_id.size()) {
804  m_rawValuesInEvent[nsc].et_id[BCidx] = (at1val) ? signEnergy(RAWValue1) : defaultEValue;
805  m_rawValuesInEvent[nsc].saturation[BCidx] = satData;
806  }
807  break;
808  case MonDataType::Invalid:
809  break;
810  default:
811  ATH_MSG_ERROR("wrong at1 value " << (Word)at1);
812  return;
813  }
814 
815  m_rawValuesInEvent[nsc].latomeChannel = nsc;
816 
817  } else {
818  if (wordshift % 2) {
819  ATH_MSG_ERROR("inconsistant wordshift in decoding everaged data");
820  return;
821  }
822  unsigned int averageword = bswap_32(p[wordshift]);
823  wordshift += 1;
824  unsigned int sumSq = bswap_32(p[wordshift]);
825  wordshift += 1;
826  unsigned long long sumsqMSB = averageword >> 28;
827  sumsqMSB = sumsqMSB << 32;
828 
829  m_averagedRawValuesInEvent[nsc].sum[iBC] = averageword & 0xFFFFF;
830  m_averagedRawValuesInEvent[nsc].sumSq[iBC] = sumSq | sumsqMSB;
831  m_averagedRawValuesInEvent[nsc].nTrigValid[iBC] = (averageword >> 20) & 0xFF;
832  m_averagedRawValuesInEvent[nsc].latomeChannel = nsc;
833  }
834 
835  ++nsc;
836 
837  }
838 
840  if(byteshift!=0){
841  increaseWordShift(wordshift);
842  byteshift=0;
843  }
844  ATH_MSG_DEBUG("wordshift before: " << wordshift << ", s: " << s);
845  if ((wordshift - s) % 2)
846  increaseWordShift(wordshift);
847  ATH_MSG_DEBUG("wordshift after : " << wordshift << ", s: " << s);
848  if ((wordshift - s - ((m_iPacket - oldipacket) * (m_monHeaderSize + m_monTrailerSize))) != n64word * 2) {
849  ATH_MSG_WARNING(" ERROR: time slice end is not padded properly " << (wordshift - s - m_iPacket * (m_monHeaderSize + m_monTrailerSize))
850  << "!=" << n64word * 2 << " m_ipacket " << m_iPacket);
851  }
852  s = wordshift;
853  oldipacket = m_iPacket;
854  }
855 
856  }
857 
858  if (!m_isAveraged && !m_isAutoCorr) {
859  fillRaw(map);
860  } else {
861  if (onoffmap && clmap) {
862  fillCalib(map, onoffmap, clmap);
863  } else {
864  ATH_MSG_ERROR("Do not have mapping !!!");
865  }
866  }
867  fillHeader();
868 }
869 
870 void LArLATOMEDecoder::EventProcess::fillCalib(const LArLATOMEMapping* map, const LArOnOffIdMapping* cablingLeg, const LArCalibLineMapping* clcabling) {
871 
872  CaloGain::CaloGain gain=CaloGain::LARHIGHGAIN;
873  uint32_t DAC_value=0;
874  uint16_t delay_value=0;
875  uint16_t isPulsed_value=false;
876  std::unique_ptr<LArCalibParams> calibParams1;
877  std::unique_ptr<LArCalibParams> calibParams2;
878 
879  int pattype = m_nthLATOME >> 16;
880  const LArOnOffIdMapping* cabling = 0;
881  if (m_caccdigits) {
882  m_caccdigits->setDelayScale(25. / 240.);
883 
884  SG::ReadCondHandle<LArOnOffIdMapping> cablingHdl{m_decoder->m_cablingKeySC};
885  cabling = {*cablingHdl};
886  if (!cabling) {
887  ATH_MSG_ERROR("Do not have mapping object " << m_decoder->m_cablingKeySC.key());
888  return;
889  }
890 
891  calibParams1=std::make_unique<LArCalibParams>();
892  calibParams2=std::make_unique<LArCalibParams>();
893 
894  if (pattype > 0x48) {
895  StatusCode sc1 = calibParams1->initialize();
896  StatusCode sc2 = calibParams2->initialize();
897  if (sc1 != StatusCode::SUCCESS || sc2 != StatusCode::SUCCESS) {
898  ATH_MSG_WARNING("could not initialize LArCalibParams, acc calib will not be filled ");
899  return;
900  }
901  if (pattype == 0x49 || pattype == 0x4a) {
902 
903  calibParams1->set(1, m_latomeCalibPatternsInEvent[0].patterns, {m_latomeCalibPatternsInEvent[0].DAC}, {m_latomeCalibPatternsInEvent[0].delay});
904 
905  calibParams2->set(1, m_latomeCalibPatternsInEvent[2].patterns, {m_latomeCalibPatternsInEvent[2].DAC}, {m_latomeCalibPatternsInEvent[2].delay});
906  } else {
907 
908  calibParams1->set(1, m_latomeCalibPatternsInEvent[1].patterns, {m_latomeCalibPatternsInEvent[1].DAC}, {m_latomeCalibPatternsInEvent[1].delay});
909 
910  calibParams2->set(1, m_latomeCalibPatternsInEvent[2].patterns, {m_latomeCalibPatternsInEvent[2].DAC}, {m_latomeCalibPatternsInEvent[2].delay});
911  }
912  } else {
913  StatusCode sc1 = calibParams1->initialize();
914  if (sc1 != StatusCode::SUCCESS) {
915  ATH_MSG_WARNING("could not initialize LArCalibParams, acc calib will not be filled ");
916  return;
917  }
918  calibParams1->set(1, m_latomeCalibPatternsInEvent[0].patterns, {m_latomeCalibPatternsInEvent[0].DAC}, {m_latomeCalibPatternsInEvent[0].delay});
919  }
920  }
921 
922  const HWIdentifier hwidEmpty;
923  for (SuperCell ch = 0; ch < N_LATOME_CHANNELS; ++ch) {
924  LArCalibParams* calibParams = 0;
925  auto SCID = map ? map->getChannelID(m_nthLATOME, ch) : hwidEmpty;
926  if (SCID == hwidEmpty) {
927  ATH_MSG_DEBUG("No mapping for ch: " << std::dec << ch);
928  continue;
929  }
930  if (m_decoder->m_ignoreBarrelChannels && m_decoder->m_onlineId->barrel_ec(SCID) == 0)
931  continue;
932  if (m_decoder->m_ignoreEndcapChannels && m_decoder->m_onlineId->barrel_ec(SCID) == 1)
933  continue;
934 
935  std::vector<uint64_t> sum;
936  std::vector<uint64_t> sum2;
937  unsigned int ntmin = 9999999;
939  for (auto nt : m_averagedRawValuesInEvent[ch].nTrigValid) {
940  if (nt < ntmin) {
941  ntmin = nt;
942  }
943  }
944  sum.resize(m_averagedRawValuesInEvent[ch].sum.size());
945  sum2.resize(m_averagedRawValuesInEvent[ch].sum.size());
946 
947  for (unsigned int is = 0; is < m_averagedRawValuesInEvent[ch].sum.size(); ++is) {
948  double fsum = (double)m_averagedRawValuesInEvent[ch].sum[is] / m_averagedRawValuesInEvent[ch].nTrigValid[is] * ntmin;
949  double fsum2 = (double)m_averagedRawValuesInEvent[ch].sumSq[is] / m_averagedRawValuesInEvent[ch].nTrigValid[is] * ntmin;
950  sum[is] = round(fsum);
951  sum2[is] = round(fsum2);
952  }
953  if (m_accdigits) {
954 
955  LArAccumulatedDigit* accdigi = new LArAccumulatedDigit(SCID, gain, sum, sum2, ntmin);
956  m_accdigits->push_back(accdigi);
957  }
958  if (m_caccdigits) {
959  if (pattype == 0x49 || pattype == 0x4a) {
960  if (m_decoder->m_onlineId->barrel_ec(SCID) == 0) {
961  calibParams = calibParams1.get();
962  } else {
963  calibParams = calibParams2.get();
964  }
965  } else if (pattype == 0x4b || pattype == 0x4c) {
966  if (m_decoder->m_onlineId->isHECchannel(SCID)) {
967  calibParams = calibParams1.get();
968  } else {
969  calibParams = calibParams2.get();
970  }
971  } else {
972  calibParams = calibParams1.get();
973  }
974  unsigned int eventNb = 0;
975  unsigned int numCL = 0;
976  unsigned int numPulsedLeg = 0;
977  std::vector<Identifier> ccellIds(0);
978  Identifier myofflineID = cabling->cnvToIdentifier(SCID);
979  ccellIds = m_decoder->m_sc2ccMappingTool->superCellToOfflineID(myofflineID);
980  for (Identifier id : ccellIds) { // loop cells in sc
981  HWIdentifier cellLegHWID = cablingLeg->createSignalChannelID(id);
982  const std::vector<HWIdentifier>& calibLineLeg = clcabling->calibSlotLine(cellLegHWID);
983  numCL += calibLineLeg.size();
984  for (HWIdentifier calibLineHWID : calibLineLeg) { // loop legacy calib lines
985  if (calibParams->isPulsed(eventNb, calibLineHWID)) {
986  numPulsedLeg += 1;
987  }
988  }
989  }
990 
991  isPulsed_value = true;
992  if (numPulsedLeg != numCL) {
993  if (m_decoder->m_keepPulsed)
994  continue;
995  isPulsed_value = false;
996  }
997  DAC_value = calibParams->DAC(eventNb, SCID) * numPulsedLeg;
998  // 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
999  // which came from averaging over many cells
1000  int ft = m_decoder->m_onlineId->feedthrough(SCID);
1001  int slot = m_decoder->m_onlineId->slot(SCID);
1002  int channel = m_decoder->m_onlineId->channel(SCID);
1003  if (m_decoder->m_onlineId->barrel_ec(SCID) == 1 && (ft == 3 || ft == 10 || ft == 16 || ft == 22)) {
1004  // if it's HEC
1005  if (slot == 1) {
1006  if (channel >= 16 && channel <= 31) { // eta 1.65 bin
1007  DAC_value = DAC_value / 1.363;
1008  m_decoder->msg(MSG::DEBUG) << "Multiplying DAC for channel " << SCID << "by 1/1.363" << endmsg;
1009  } else if (channel >= 32 && channel <= 47) { // eta 1.75 bin
1010  DAC_value = DAC_value / 1.206;
1011  m_decoder->msg(MSG::DEBUG) << "Multiplying DAC for channel " << SCID << "by 1/1.206" << endmsg;
1012  }
1013  }
1014  }
1015 
1016  delay_value = calibParams->Delay(eventNb, SCID);
1017  LArAccumulatedCalibDigit* accdigi = new LArAccumulatedCalibDigit(SCID, gain, sum, sum2, ntmin, DAC_value, delay_value, isPulsed_value);
1018 
1019  m_caccdigits->push_back(accdigi);
1020  }
1021 
1022  }
1023 }
1024 
1025 // Pass ADC values from an event
1026 void LArLATOMEDecoder::EventProcess::fillRaw(const LArLATOMEMapping* map) {
1027  // const CaloGain::CaloGain dummyGain = CaloGain::LARHIGHGAIN;
1028  const HWIdentifier hwidEmpty;
1029  for (SuperCell ch = 0; ch < N_LATOME_CHANNELS; ++ch) {
1030  const auto SCID = map ? map->getChannelID(m_nthLATOME, ch) : hwidEmpty;
1031  if (SCID == hwidEmpty) {
1032  ATH_MSG_DEBUG("No mapping for ch: " << std::dec << ch);
1033  continue;
1034  }
1035  if (m_decoder->m_ignoreBarrelChannels && m_decoder->m_onlineId->barrel_ec(SCID) == 0)
1036  continue;
1037  if (m_decoder->m_ignoreEndcapChannels && m_decoder->m_onlineId->barrel_ec(SCID) == 1)
1038  continue;
1039 
1040  std::vector<short> adcValues_inChannel_inEvent;
1041 
1042  if (m_hasRawAdc) {
1043  adcValues_inChannel_inEvent = m_rawValuesInEvent[ch].adc;
1044  }
1045 
1046  if (m_hasRawAdc && m_adc_coll) {
1049 
1050  std::vector<unsigned short> bcid_in_event;
1051  for (short b = m_BC_rawADC; b < m_BC_rawADC + m_nBC_rawADC; ++b) {
1052  bcid_in_event.push_back(m_BCIDsInEvent[b]);
1053  }
1054 
1055  LArSCDigit* scDigit = new LArSCDigit(SCID, m_rawValuesInEvent[ch].latomeChannel, m_nthLATOME, adcValues_inChannel_inEvent, bcid_in_event);
1056  m_adc_coll->push_back(scDigit);
1057  }
1058 
1059  if (m_hasAdc && m_adc_bas_coll) {
1060  std::vector<unsigned short> bcid_in_event;
1061  if (m_nBC_ADC == (short)m_BCIDsInEvent.size()) {
1062  bcid_in_event = m_BCIDsInEvent;
1063  } else {
1064  for (short b = m_BC_ADC; b < m_BC_ADC + m_nBC_ADC; ++b) {
1065  bcid_in_event.push_back(m_BCIDsInEvent[b]);
1066  }
1067  }
1068  LArSCDigit* scDigit = new LArSCDigit(SCID, m_rawValuesInEvent[ch].latomeChannel, m_nthLATOME, m_rawValuesInEvent[ch].adc_bas, bcid_in_event);
1069  m_adc_bas_coll->push_back(scDigit);
1070  }
1071 
1072  if (m_hasE && m_et_coll) {
1073  std::vector<unsigned short> bcid_in_event;
1074  if (m_nBC_E == (unsigned short)m_BCIDsInEvent.size()) {
1075  bcid_in_event = m_BCIDsInEvent;
1076  } else {
1077  for (short b = m_BC_E; b < m_BC_E + m_nBC_E; ++b) {
1078  bcid_in_event.push_back(m_BCIDsInEvent[b]);
1079  }
1080  }
1081  LArRawSC* scDigit =
1082  new LArRawSC(SCID, m_rawValuesInEvent[ch].latomeChannel, m_nthLATOME, m_rawValuesInEvent[ch].et, bcid_in_event, m_rawValuesInEvent[ch].saturation);
1083  m_et_coll->push_back(scDigit);
1084  }
1085 
1086  if (m_hasEID && m_et_id_coll) {
1087  std::vector<unsigned short> bcid_in_event;
1088  if (m_nBC_EID == (short)m_BCIDsInEvent.size()) {
1089  bcid_in_event = m_BCIDsInEvent;
1090  } else {
1091  for (short b = m_BC_EID; b < m_BC_EID + m_nBC_EID; ++b) {
1092  bcid_in_event.push_back(m_BCIDsInEvent[b]);
1093  }
1094  }
1095  LArRawSC* scDigit =
1096  new LArRawSC(SCID, m_rawValuesInEvent[ch].latomeChannel, m_nthLATOME, m_rawValuesInEvent[ch].et_id, bcid_in_event, m_rawValuesInEvent[ch].saturation);
1097  m_et_id_coll->push_back(scDigit);
1098  }
1099  }
1100 }
1101 
1102 void LArLATOMEDecoder::EventProcess::fillHeader() {
1103 
1104  if (m_header_coll) {
1105  LArLATOMEHeader* latome = new LArLATOMEHeader(m_nthLATOME, m_latomeID, m_activeSC, m_latomeBCID, m_l1ID, m_ROBFragSize);
1106  m_header_coll->push_back(latome);
1107  }
1108 }
LArLATOMEDecoder::convert
StatusCode convert(const std::vector< const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment * > &robFrags, const LArLATOMEMapping *map, LArDigitContainer *adc_coll, LArDigitContainer *adc_bas_coll, LArRawSCContainer *et_coll, LArRawSCContainer *et_id_coll, LArLATOMEHeaderContainer *header_coll) const
Converter.
Definition: LArLATOMEDecoder.cxx:97
LArLATOMEDecoder::EventProcess::m_activeSC
Word m_activeSC
Definition: LArLATOMEDecoder.h:207
LArLATOMEDecoder::EventProcess::m_BC_EID
short m_BC_EID
Definition: LArLATOMEDecoder.h:225
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
LArLATOMEMapping::getChannelID
HWIdentifier getChannelID(const unsigned int sourceID, const unsigned int chan) const
create a HWIdentifier from an Identifier
Definition: LArLATOMEMapping.h:60
LArLATOMEDecoder
Definition: LArLATOMEDecoder.h:61
LArRawSC
Liquid Argon SuperCell raw data.
Definition: LArRawSC.h:19
LArLATOMEDecoder::EventProcess::m_nsc5
Word m_nsc5
Definition: LArLATOMEDecoder.h:212
LArAccumulatedCalibDigit
Data class for calibration ADC samples preprocessed by the DSP.
Definition: LArAccumulatedCalibDigit.h:42
LArLATOMEDecoder::EventProcess
Definition: LArLATOMEDecoder.h:129
OFFLINE_FRAGMENTS_NAMESPACE
Definition: RawEvent.h:22
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:256
python.SystemOfUnits.s
int s
Definition: SystemOfUnits.py:131
MonDataType::ADC
@ ADC
LArAccumulatedCalibDigitContainer::setDelayScale
void setDelayScale(const double scale)
set the delay Scale
Definition: LArAccumulatedCalibDigitContainer.h:35
xAOD::word1
word1
Definition: eFexEMRoI_v1.cxx:87
LATOMEMapping.h
Tool to get LATOME SC and SCID mapping file and fill std::map variable with it.
LArLATOMEDecoder::EventProcess::m_nStreams
Word m_nStreams
Definition: LArLATOMEDecoder.h:197
LArLATOMEDecoder::EventProcess::m_BC_rawADC
short m_BC_rawADC
Definition: LArLATOMEDecoder.h:222
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:194
getMessageSvc.h
singleton-like access to IMessageSvc via open function and helper
LArAccumulatedDigitContainer
Container class for LArAccumulatedDigit.
Definition: LArAccumulatedDigitContainer.h:22
LArLATOMEDecoder::EventProcess::m_hasRawAdc
bool m_hasRawAdc
Definition: LArLATOMEDecoder.h:227
LArLATOMEDecoder::EventProcess::m_hasE
bool m_hasE
Definition: LArLATOMEDecoder.h:229
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:253
patterns
std::vector< std::string > patterns
Definition: listroot.cxx:187
max
constexpr double max()
Definition: ap_fixedTest.cxx:33
LArRawSCContainer
Container class for LArRawSC.
Definition: LArRawSCContainer.h:17
Issue
Configuration Issue
Definition: PscIssues.h:31
LArCalibLineMapping::calibSlotLine
const std::vector< HWIdentifier > & calibSlotLine(const HWIdentifier id) const
Definition: LArCalibLineMapping.cxx:15
MonDataType
MonDataType
Definition: LArLATOMEDecoder.h:51
defineDB.ichan
ichan
Definition: JetTagCalibration/share/defineDB.py:28
LArCalibLineMapping
Definition: LArCalibLineMapping.h:17
CaloCondBlobAlgs_fillNoiseFromASCII.gain
gain
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:110
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
RawEvent
OFFLINE_FRAGMENTS_NAMESPACE::FullEventFragment RawEvent
data type for reading raw event
Definition: RawEvent.h:37
LArLATOMEDecoder::EventProcess::m_region
Word m_region
Definition: LArLATOMEDecoder.h:196
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:210
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::bytesPerChannel
unsigned int bytesPerChannel(MonDataType at0, MonDataType at1)
Definition: LArLATOMEDecoder.cxx:325
LArLATOMEDecoder::EventProcess::m_nsc1
Word m_nsc1
Definition: LArLATOMEDecoder.h:208
athena.value
value
Definition: athena.py:124
LArLATOMEDecoder::EventProcess::m_nsc6
Word m_nsc6
Definition: LArLATOMEDecoder.h:213
LArLATOMEMapping
class to provide SC mapping
Definition: LArLATOMEMapping.h:28
LArLATOMEHeaderContainer
Container class for LArLATOMEHeader.
Definition: LArLATOMEHeaderContainer.h:19
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:224
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::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
LArLATOMEDecoder::EventProcess::m_at1nBC
Word m_at1nBC
Definition: LArLATOMEDecoder.h:204
python.CaloAddPedShiftConfig.type
type
Definition: CaloAddPedShiftConfig.py:42
LArLATOMEDecoder::LatomeCalibPatterns
Definition: LArLATOMEDecoder.h:121
AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
N_LATOME_CHANNELS
#define N_LATOME_CHANNELS
fixed number of channels on one LATOME board
Definition: LArLATOMEMapping.h:22
LArLATOMEDecoder::LArLATOMEDecoder
LArLATOMEDecoder(const std::string &type, const std::string &name, const IInterface *parent)
Constructor.
Definition: LArLATOMEDecoder.cxx:24
LArLATOMEDecoder::EventProcess::m_nBC_Averaged
short m_nBC_Averaged
Definition: LArLATOMEDecoder.h:220
LArLATOMEDecoder::EventProcess::m_monHeaderSize
Word m_monHeaderSize
Definition: LArLATOMEDecoder.h:195
LArLATOMEDecoder::EventProcess::m_at1BC
Word m_at1BC
Definition: LArLATOMEDecoder.h:206
LArLATOMEDecoder::m_protectSourceId
BooleanProperty m_protectSourceId
Definition: LArLATOMEDecoder.h:258
LArLATOMEDecoder::LatomeCalibPatterns::patterns
std::vector< unsigned int > patterns
Definition: LArLATOMEDecoder.h:126
LArLATOMEDecoder::EventProcess::m_decoder
const LArLATOMEDecoder * m_decoder
Definition: LArLATOMEDecoder.h:234
MonDataType::AutoCorr
@ AutoCorr
LArLATOMEDecoder::EventProcess::m_nsc4
Word m_nsc4
Definition: LArLATOMEDecoder.h:211
LArLATOMEDecoder::EventProcess::m_isAveraged
bool m_isAveraged
Definition: LArLATOMEDecoder.h:231
LArLATOMEDecoder::EventProcess::m_at0nBC
Word m_at0nBC
Definition: LArLATOMEDecoder.h:203
Mon.h
Tool to store LATOME mon header and footer data.
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:210
ev
int ev
Definition: globals.cxx:25
LArLATOMEDecoder::EventProcess::decodeByte
void decodeByte(unsigned int &byte, unsigned int wordshift, unsigned int byteshift, const uint32_t *p)
Definition: LArLATOMEDecoder.cxx:357
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
LArLATOMEDecoder::LatomeCalibPatterns::delay
unsigned int delay
Definition: LArLATOMEDecoder.h:125
LArLATOMEDecoder::EventProcess::m_at0BC
Word m_at0BC
Definition: LArLATOMEDecoder.h:205
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
eformat::ROBFragment
Definition: L1CaloBsDecoderUtil.h:12
lumiFormat.i
int i
Definition: lumiFormat.py:85
LArLATOMEDecoder::EventProcess::m_caccdigits
LArAccumulatedCalibDigitContainer * m_caccdigits
Definition: LArLATOMEDecoder.h:240
LArLATOMEDecoder::EventProcess::m_nBC_E
short m_nBC_E
Definition: LArLATOMEDecoder.h:218
LArLATOMEDecoder::EventProcess::m_nBC_EID
short m_nBC_EID
Definition: LArLATOMEDecoder.h:219
beamspotman.n
n
Definition: beamspotman.py:731
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::m_nBC_ADC
short m_nBC_ADC
Definition: LArLATOMEDecoder.h:217
python.HLT.CommonSequences.EventBuildingSequences.robs
robs
Definition: EventBuildingSequences.py:401
python.LArMinBiasAlgConfig.int
int
Definition: LArMinBiasAlgConfig.py:59
LArLATOMEDecoder::m_ignoreEndcapChannels
BooleanProperty m_ignoreEndcapChannels
Definition: LArLATOMEDecoder.h:257
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:260
LArLATOMEDecoder::EventProcess::increaseByteShift
void increaseByteShift(unsigned int &wordshift, unsigned int &byteshift)
Definition: LArLATOMEDecoder.cxx:349
LArLATOMEDecoder::interfaceID
static const InterfaceID & interfaceID()
Definition: LArLATOMEDecoder.cxx:29
MonDataType::RawADC
@ RawADC
test_pyathena.parent
parent
Definition: test_pyathena.py:15
AthMessaging
Class to provide easy MsgStream access and capabilities.
Definition: AthMessaging.h:55
find_tgc_unfilled_channelids.ip
ip
Definition: find_tgc_unfilled_channelids.py:3
LArLATOMEDecoder::EventProcess::m_streamNumber
Word m_streamNumber
Definition: LArLATOMEDecoder.h:198
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
LArLATOMEDecoder::EventProcess::m_rawValuesInEvent
std::vector< LatomeRawData > m_rawValuesInEvent
Definition: LArLATOMEDecoder.h:247
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
LArSCDigit
Base class for LArDigits taken by LATOME.
Definition: LArSCDigit.h:19
DataVector::clear
void clear()
Erase all the elements in the collection.
fitman.mux
mux
Definition: fitman.py:547
LArLATOMEDecoder::EventProcess::m_at1typeRec
Word m_at1typeRec
Definition: LArLATOMEDecoder.h:200
LArLATOMEDecoder::EventProcess::m_hasEID
bool m_hasEID
Definition: LArLATOMEDecoder.h:230
MonDataType::Energy
@ Energy
LArCalibParams::DAC
unsigned DAC(const unsigned event, const HWIdentifier calibLineID) const
Definition: LArCalibParams.cxx:131
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
plotBeamSpotMon.b
b
Definition: plotBeamSpotMon.py:77
MonDataType::Averaged
@ Averaged
LArLATOMEDecoder::EventProcess::fillCalib
void fillCalib(const LArLATOMEMapping *map, const LArOnOffIdMapping *onoffmap, const LArCalibLineMapping *clmap)
Definition: LArLATOMEDecoder.cxx:870
LArLATOMEDecoder::EventProcess::fillRaw
void fillRaw(const LArLATOMEMapping *map)
Pass ADC values from an event.
Definition: LArLATOMEDecoder.cxx:1026
LArCalibParams::Delay
unsigned Delay(const unsigned event, const HWIdentifier calibLineID) const
Definition: LArCalibParams.cxx:112
LArLATOMEDecoder::EventProcess::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: LArLATOMEDecoder.cxx:135
DataVector::push_back
value_type push_back(value_type pElem)
Add an element to the end of the collection.
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
xAOD::bcid
setEventNumber setTimeStamp bcid
Definition: EventInfo_v1.cxx:133
LArLATOMEDecoder::EventProcess::m_at1type
Word m_at1type
Definition: LArLATOMEDecoder.h:202
CaloGain::LARHIGHGAIN
@ LARHIGHGAIN
Definition: CaloGain.h:18
LArLATOMEDecoder::EventProcess::m_nPackets
Word m_nPackets
Definition: LArLATOMEDecoder.h:192
LArLATOMEDecoder::EventProcess::m_averagedRawValuesInEvent
std::vector< LatomeAveragedRawData > m_averagedRawValuesInEvent
Definition: LArLATOMEDecoder.h:248
LArLATOMEDecoder::EventProcess::m_accdigits
LArAccumulatedDigitContainer * m_accdigits
Definition: LArLATOMEDecoder.h:239
LArLATOMEDecoder::EventProcess::fillCollection
void fillCollection(const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment *pROB, const LArLATOMEMapping *map, const LArOnOffIdMapping *onoffmap=nullptr, const LArCalibLineMapping *clmap=nullptr)
Execute decoding for an event.
Definition: LArLATOMEDecoder.cxx:429
CaloGain::CaloGain
CaloGain
Definition: CaloGain.h:11
LArLATOMEDecoder::EventProcess::m_latomeCalibPatternsInEvent
std::vector< LatomeCalibPatterns > m_latomeCalibPatternsInEvent
Definition: LArLATOMEDecoder.h:249
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
LArCalibParams.h
LArLATOMEDecoder::EventProcess::m_BC_ADC
short m_BC_ADC
Definition: LArLATOMEDecoder.h:223
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
LArLATOMEDecoder::EventProcess::m_nthLATOME
unsigned int m_nthLATOME
Definition: LArLATOMEDecoder.h:244
LArLATOMEDecoder::Word
unsigned int Word
Definition: LArLATOMEDecoder.h:64
Pythia8_RapidityOrderMPI.val
val
Definition: Pythia8_RapidityOrderMPI.py:14
re
const boost::regex re(r_e)
DEBUG
#define DEBUG
Definition: page_access.h:11
AthCommonMsg::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
LArLATOMEDecoder::EventProcess::m_at0typeRec
Word m_at0typeRec
Definition: LArLATOMEDecoder.h:199
LArLATOMEDecoder::initialize
virtual StatusCode initialize()
Initialize the converter.
Definition: LArLATOMEDecoder.cxx:33
LArCalibParams::initialize
virtual StatusCode initialize()
Definition: LArCalibParams.cxx:16
LArLATOMEDecoder::EventProcess::fillHeader
void fillHeader()
Definition: LArLATOMEDecoder.cxx:1102
convertTimingResiduals.offset
offset
Definition: convertTimingResiduals.py:71
LArLATOMEDecoder::EventProcess::m_headerDecoded
bool m_headerDecoded
Definition: LArLATOMEDecoder.h:214
LArDigitContainer
Container class for LArDigit.
Definition: LArDigitContainer.h:24
LArLATOMEDecoder::EventProcess::m_l1ID
Word m_l1ID
Definition: LArLATOMEDecoder.h:190
Gaudi
=============================================================================
Definition: CaloGPUClusterAndCellDataMonitorOptions.h:273
LArLATOMEDecoder::LatomeCalibPatterns::DAC
unsigned int DAC
Definition: LArLATOMEDecoder.h:124
LArLATOMEDecoder::EventProcess::m_iPacket
Word m_iPacket
Definition: LArLATOMEDecoder.h:193
LArOnline_SuperCellID.h
LArLATOMEDecoder::EventProcess::m_at0type
Word m_at0type
Definition: LArLATOMEDecoder.h:201
LArLATOMEDecoder.h
Byte stream converter of LATOME.
beamspotnt.nt
def nt
Definition: bin/beamspotnt.py:1063
AthAlgTool
Definition: AthAlgTool.h:26
LArLATOMEDecoder::EventProcess::m_nBC_rawADC
short m_nBC_rawADC
Definition: LArLATOMEDecoder.h:216
LArLATOMEDecoder::EventProcess::decodeHeader
unsigned int decodeHeader(const uint32_t *p, unsigned int offset)
Definition: LArLATOMEDecoder.cxx:220
LArLATOMEDecoder::EventProcess::m_hasAdc
bool m_hasAdc
Definition: LArLATOMEDecoder.h:228
LArAccumulatedCalibDigitContainer
Container class for LArAccumulatedCalibDigit.
Definition: LArAccumulatedCalibDigitContainer.h:25
pow
constexpr int pow(int base, int exp) noexcept
Definition: ap_fixedTest.cxx:15
LArLATOMEDecoder::EventProcess::m_nsc2
Word m_nsc2
Definition: LArLATOMEDecoder.h:209
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:254
LAR
@ LAR
Definition: RegSelEnums.h:27
LArLATOMEDecoder::m_keepPulsed
BooleanProperty m_keepPulsed
Definition: LArLATOMEDecoder.h:259
LArLATOMEDecoder::EventProcess::m_isAutoCorr
bool m_isAutoCorr
Definition: LArLATOMEDecoder.h:232
Identifier
Definition: IdentifierFieldParser.cxx:14
Generated on Mon Mar 31 2025 21:13:54 for ATLAS Offline Software by   doxygen 1.8.18