ATLAS Offline Software
TileROD_Encoder.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 // Implementation of TileROD_Encoder class
6 
8 
12 #include "TileEvent/TileDigits.h"
13 #include "TileEvent/TileL2.h"
16 
17 #include <iomanip>
18 #include <sstream>
19 #include <algorithm>
20 #include <cassert>
21 #include <cmath>
22 
23 
24 namespace {
25 
26 // Helper to fill a vectorr of uint32_t with packed int16_t values.
27 class ShortVecAdapter
28 {
29 public:
30  ShortVecAdapter (std::vector<uint32_t>& v)
31  : m_v (v) {}
32  void push_back (int16_t x)
33  {
34  if (m_offset) {
35  m_v.back() |= (x << 16);
36  m_offset = false;
37  }
38  else {
39  m_v.push_back (x);
40  m_offset = true;
41  }
42  }
43  void align()
44  {
45  m_offset = false;
46  }
47 
48 private:
49  std::vector<uint32_t>& m_v;
50  bool m_offset = false;
51 };
52 
53 }
54 
55 
57  AthMessaging ("TileROD_Encoder"),
58  m_tileHWID(0),
59  m_verbose(false),
60  m_type(0),
61  m_unitType(0),
62  m_rChUnit(0),
63  m_maxChannels(TileCalibUtils::MAX_CHAN),
64  m_runPeriod(0){
65 }
66 
67 
68 void TileROD_Encoder::setTileHWID(const TileHWID* tileHWID, bool verbose, unsigned int type) {
69  m_tileHWID = tileHWID;
71  m_type = type;
72  m_unitType = (m_type << 16);
73 
74  switch (type) {
75  case 4:
77  break;
78  case 5:
80  break;
81  case 3:
83  break;
84  case 2:
86  break;
87  default:
88  break;
89  }
90 }
91 
92 void TileROD_Encoder::setTileHWID(const TileHWID* tileHWID, int runPeriod) {
93  m_tileHWID = tileHWID;
94  m_runPeriod = runPeriod;
95 }
96 
98 
99  unsigned int OFType = (unsigned int) type;
100  if (OFType > 7) {
101  OFType = 0;
102  ATH_MSG_ERROR( "setTypeAndUnit Incorrect raw data type =" << type
103  << " using type=0 instead " );
104  }
105 
106  unsigned int rChUnit = (unsigned int) unit % (unsigned int) TileRawChannelUnit::OnlineOffset;
107  if (rChUnit > 3) {
108  rChUnit = 0;
109  ATH_MSG_ERROR( "setTypeAndUnit Incorrect raw data unit =" << unit
110  << " assuming ADC counts (0) " );
111  }
112 
113  // make sure that we use frag type 4 for units which are not ADC counts
114  if (rChUnit != 0 && m_type < 4) m_type = 4;
115  if (m_type == 4) { // new fragments have non-zero upper byte
116  // 8 upper bits:
117  // UUPPSTTT
118  // 31,30 - units
119  // 29,28 - pulse type ( = 3 for simulated data)
120  // 27 - 7(=0) or 9(=1) samples (assume 7 samples for now)
121  // 24,25,26 - OF type
122  // next 8 bits - frag type ( 2,3,4, ... )
123  m_unitType = (rChUnit << 30) | (3 << 28) | (0 << 27) | (OFType << 24) | (m_type << 16);
124  m_rChUnit = rChUnit;
125  } else if (m_type == 5) {
126  // 8 upper bits:
127  // UULLLTTT
128  // 31,30 - units
129  // 29,28,27 - length of Level2 part ( = 3 - sumEt, sumEz, sumE )
130  // 24,25,26 - OF type
131  m_unitType = (rChUnit << 30) | (3 << 27) | (OFType << 24) | (m_type << 16);
132  m_rChUnit = rChUnit;
133  }
134 
135 }
136 
137 void TileROD_Encoder::setMaxChannels(int maxChannels) {
138  m_maxChannels = maxChannels;
139 }
140 
141 
145 void TileROD_Encoder::fillROD(std::vector<uint32_t>& v) {
146  switch (m_type) {
147  case 4:
148  fillROD4(v);
149  break;
150  case 5:
151  fillROD5(v);
152  break;
153  case 3:
154  fillROD3(v);
155  break;
156  case 2:
157  fillROD2(v);
158  break;
159  case 1:
160  fillROD1(v);
161  break;
162  case 0x10:
163  fillROD10(v);
164  break;
165  case 0x12:
166  fillROD12(v);
167  break;
168  default:
169  ATH_MSG_ERROR( "fillROD -> Unknown packing type " << m_type );
170  assert(0);
171  break;
172  // return;
173  }
174 }
175 
176 
177 void TileROD_Encoder::fillROD10(std::vector<uint32_t>& v) {
178 
179  int currentFrag(-1);
180  std::vector<uint32_t>::size_type start = 0;
181 
182  int NMuons1 = 0, NMuons2 = 0, frag = 0;
183 
184  for (const TileL2* l2 : m_vTileL2) {
185 
186  int ros = ((l2->identify()) | 0xff) >> 8;
187  int drawer = (l2->identify()) & 0xff;
188 
189  if ((drawer % 2) == 0) frag = 0x00100000 + (ros << 12) + ((drawer + 1) << 6) + drawer;
190 
191  if (frag != currentFrag) { // superdrawer is even
192 
193  currentFrag = frag;
194 
195  // fragment marker
196  v.push_back(0xff1234ff);
197 
198  // fragment size (variable depending on the number of muons found)
199  v.push_back(5);
200 
201  // fragment ID
202  v.push_back(frag);
203 
204  // first word after fragment header
205  start = v.size();
206 
207  // reserve 2 words for Et
208  for (int i = 0; i < 2; ++i)
209  v.push_back(0);
210 
211  // Et superdrawer #1
212  int wet = (int) round(l2->sumEt());
213  v[start] = (unsigned int) (wet + 9000); // shift by 9000 to be compatible with frag 0x10 format
214 
215  // MTag superdrawer #1
216  NMuons1 = l2->NMuons();
217  for (int i = 0; i < 2 * NMuons1; ++i)
218  v.push_back(l2->val(i));
219 
220  } else { // superdrawer is odd
221 
222  // Et superdrawer #2
223  int wet = (int) round(l2->sumEt());
224  v[start + 1] = (unsigned int) (wet + 9000); // shift by 9000 to be compatible with frag 0x10 format
225 
226  // MTag superdrawer #2
227  NMuons2 = l2->NMuons();
228  for (int i = 0; i < 2 * NMuons2; ++i)
229  v.push_back(l2->val(i));
230 
231  // re-write fragment size
232  v[start - 2] = 5 + 2 * NMuons1 + 2 * NMuons2;
233 
234  }
235 
236  }
237 
238  //assert(0);
239 }
240 
241 void TileROD_Encoder::fillROD12(std::vector<uint32_t>& v) {
242 
243  int currentFrag(-1);
244  std::vector<uint32_t>::size_type start = 0;
245 
246  int frag = 0;
247 
248  for (const TileL2* l2 : m_vTileL2) {
249 
250  int ros = (l2->identify()) >> 8;
251  int drawer = (l2->identify()) & 0xff;
252 
253  if ((drawer % 2) == 0)
254  frag = 0x120000 + (ros << 12) + ((drawer + 1) << 6) + drawer;
255  else
256  frag = 0x120000 + (ros << 12) + (drawer << 6) + (drawer - 1);
257 
258  if (frag != currentFrag) { // superdrawer is even
259 
260  currentFrag = frag;
261 
262  // fragment marker
263  v.push_back(0xff1234ff);
264 
265  // fragment size (variable depending on the number of muons found)
266  v.push_back(3);
267 
268  // fragment ID
269  v.push_back(frag);
270 
271  // first word after fragment header
272  start = v.size();
273  }
274 
275  // MTag data
276  int Ndata = l2->Ndata();
277  if (Ndata) {
278  for (int i = 0; i < Ndata; ++i)
279  v.push_back(l2->val(i));
280 
281  // re-write fragment size
282  v[start - 2] += Ndata;
283  }
284  }
285 
286  //assert(0);
287 }
288 
289 void TileROD_Encoder::fillROD2(std::vector<uint32_t>& v) {
290  //std::sort(m_vTileRC.begin(), m_vTileRC.end(), m_order);
291 
292  int currentFrag(-1);
293  std::vector<uint32_t>::size_type start = 0;
294 
295  for (const TileFastRawChannel* rc : m_vTileRC) {
296 
297  int frag = rc->frag() | m_unitType; // FRAG TYPE in upper half of the word
298 
299  if (frag != currentFrag) {
300  currentFrag = frag;
301 
302  // very first word is size of the fragment, which is 50 words
303  v.push_back(50);
304  // next word is frag ID
305  v.push_back(frag);
306 
307  // remember where is the first channel
308  start = v.size();
309  // reserve maximum number of channels in a drawer words
310  // for all channels in the drawer
311  v.resize(start + m_maxChannels, 0);
312 
313  }
314 
315  // FIXME:: protection against both low and high gain amplitude
316  // for the same raw channel,
317  // if this is the case all channels should have both
318  // low and high gain and we should use different fragment type
319 
320  int chan = rc->channel();
321  int gain = rc->adc();
322  if (chan < m_maxChannels) {
323  v[start + chan] = m_rc2bytes2.getWord(rc, gain);
324  }
325 
326  } // end of all TileRawChannel
327 
328  // dumpROD (v) ;
329 
330  return;
331 }
332 
333 void TileROD_Encoder::fillROD3(std::vector<uint32_t>& v) {
334  ShortVecAdapter v16 (v);
335 
336  //std::sort(m_vTileRC.begin(), m_vTileRC.end(), m_order);
337 
338  int currentFrag(-1);
339  bool first = true;
340  std::vector<uint32_t>::size_type head = 0;
341  std::vector<uint32_t>::size_type count = 0;
342 
343  std::vector<short> vshort;
344 
345  for (const TileFastRawChannel* rc : m_vTileRC) {
346 
347 
348  int frag = rc->frag() | m_unitType; // FRAG TYPE in upper half of the word
349  int chan = rc->channel();
350  int gain = rc->adc();
351 
352  if (frag != currentFrag) {
353  currentFrag = frag;
354  // a new frag
355  if (!first) {
356  // close the current frag
357  v16.align();
358  // inclusive word (32bit) for this frag
359  v[count] = v.size();
360  } else
361  first = false;
362 
363  // very first word is size of the fragment
364  // remember where it is
365  count = v.size();
366  v.push_back(0);
367  // add frag ID
368  v.push_back(frag);
369 
370  // remember where map starts
371  head = v.size();
372  // 2 words (64 bits) for channel map
373  v.push_back(0);
374  v.push_back(0);
375  }
376 
377  // FIXME:: protection against both low and high gain amplitude
378  // for the same raw channel,
379  // if this is the case all channels should have both
380  // low and high gain and we should use different fragment type
381 
382  if (checkBit(&(v[head]), chan)) {
383  // the same channel with another gain already exists, ignore second one
384  } else {
385  vshort.clear();
386  m_rc2bytes3.getBytes(rc, gain, vshort);
387  for (short x : vshort)
388  v16.push_back (x);
389  // set bitmap for this channel
390  setBit(&(v[head]), chan);
391  }
392 
393  } // end of all TileRawChannel
394 
395  if (!first) {
396  // close the last Frag
397  v16.align();
398  // inclusive word (32bit) for this frag
399  v[count] = v.size();
400  }
401 
402  // dumpROD (v) ;
403 
404  return;
405 }
406 
407 void TileROD_Encoder::fillROD4(std::vector<uint32_t>& v) {
408  //std::sort(m_vTileRC.begin(), m_vTileRC.end(), m_order);
409 
410  int currentFrag(-1);
411  std::vector<uint32_t>::size_type start = 0;
412 
413  for (const TileFastRawChannel* rc : m_vTileRC) {
414 
415  int frag = rc->frag() | m_unitType; // FRAG TYPE in upper half of the word
416 
417  if (frag != currentFrag) {
418  currentFrag = frag;
419 
420  // very first word is start fragment identifier
421  v.push_back(0xff1234ff);
422  // next word is frag size:
423  // (maximum number of channels in a drawer) + ...
424  // ... + (6 = start frag + frag size + frag ID + 3 sumE words)
425  v.push_back(m_maxChannels + 6);
426  // next word is frag ID
427  v.push_back(frag);
428 
429  // remember where is the first channel
430  start = v.size();
431 
432  // reserve (maximum number of channels in a drawer) words
433  // for all channels in the drawer and 3 sumE words
434  v.resize(start + m_maxChannels + 3, 0);
435 
436  }
437 
438  // FIXME:: protection against both low and high gain amplitude
439  // for the same raw channel,
440  // if this is the case all channels should have both
441  // low and high gain and we should use different fragment type
442 
443  int chan = rc->channel();
444  int gain = rc->adc();
445  if (chan < m_maxChannels) {
447  }
448 
449  } // end of all TileRawChannel
450 
451  // dumpROD (v) ;
452 
453  return;
454 }
455 
456 void TileROD_Encoder::fillRODL2(std::vector<uint32_t>& v) {
457 
458  std::map<int, const TileL2*> l2_map;
459 
460  for (const TileL2* l2 : m_vTileL2) {
461  l2_map[l2->identify()] = l2;
462  //std::cout << "l2 id=0x"<<std::hex<<l2->identify()<<std::dec<<std::endl;
463  }
464 
465  std::vector<uint32_t>::size_type start = 3;
466 
467  while (start <= v.size()) {
468  uint32_t size = v[start - 2];
469  uint32_t fragtype = v[start - 1];
470  int type = (fragtype >> 16) & 0xFF;
471  //std::cout <<std::hex<<"frag 0x"<<fragtype<<std::dec<<" size "<<size<<std::endl;
472  if ((type == 4 && size > 53) || (type == 5 && ((fragtype >> 27) & 7) > 2)) {
473  int frag = fragtype & 0xFFFF;
474  std::map<int, const TileL2*>::const_iterator l2_it = l2_map.find(frag);
475  if (l2_it != l2_map.end()) {
476  int unit = (fragtype >> 30);
477  const TileL2* l2 = l2_it->second;
478  int et = round(l2->sumEt() * AMPLITUDE_FACTOR5_HG[unit]);
479  v[start + 48] = (uint32_t) et;
480  int ez = round(l2->sumEz() * AMPLITUDE_FACTOR5_HG[unit]);
481  v[start + 49] = (uint32_t) ez;
482  int e = round(l2->sumE() * AMPLITUDE_FACTOR5_HG[unit]);
483  v[start + 50] = (uint32_t) e;
484  //std::cout << "Found "<<et<<","<<ez<<","<<e<<std::endl;
485  }
486  }
487  start += size;
488  }
489 
490  if (msgLvl(MSG::VERBOSE)) dumpROD(v);
491 
492  return;
493 }
494 
495 void TileROD_Encoder::fillROD1(std::vector<uint32_t>& v) {
496 
497  std::sort(m_vTileDigi.begin(), m_vTileDigi.end(), m_order);
498 
499  int currentFrag = -1, pos = 0, size = 0;
500  for (const TileDigits* digi : m_vTileDigi) {
501 
502  HWIdentifier adcID = digi->adc_HWID();
503  int frag = m_tileHWID->frag(adcID) | (0x01 << 16); // FRAG TYPE = 1 in upper half of the word
504  if (frag != currentFrag) {
505  if (currentFrag != -1) v[pos] = size;
506  currentFrag = frag;
507  // first word is start of fragment identifier
508  v.push_back(0xFF1234FF);
509  // next word is frag size
510  pos = v.size();
511  v.push_back(0);
512  // next word is frag ID
513  v.push_back(frag);
514  size = 3;
515  }
517  }
518  if (currentFrag != -1) v[pos] = size;
519  return;
520 }
521 
522 void TileROD_Encoder::fillROD5(std::vector<uint32_t>& /* v */) {
523  ATH_MSG_ERROR( "fillROD5 -> store raw channels in frag5 - not yet implemented " );
524 }
525 
526 void TileROD_Encoder::fillROD5D(std::vector<uint32_t>& /* v */) {
527  ATH_MSG_ERROR( "fillROD5D -> store digits in frag5 - not yet implemented " );
528 }
529 
530 // == START of TMDB Encoders: Digits, Raw Channel, Decision
531 
532 // TMDB Digits
533 
534 void TileROD_Encoder::fillRODTileMuRcvDigi(std::vector<uint32_t>& v) {
535 
536  ATH_MSG_DEBUG( "TMDB encoding sub-fragment 0x40: loop over " << m_vTileDigi.size() << " objects" );
537 
538  // sub-fragment marker
539  //
540  v.push_back(0xff1234ff);
541 
542  // sub-fragment size
543  // set the size for the sub-fragment (3 [header] + 8 [# 32bit word/digit/pmt/module] x N [# digit/pmt/module])
544  uint32_t size = m_vTileDigi.size() * 7; // assume 7 samples
545  size = (size+3)>>2; // convert numner of bytes into number of 32bit words
546  v.push_back(3+size);
547  uint savepos=v.size()-1;
548 
549  // type & version: the version is a 16-bit number and is set by fixing the 3th hexadecimal digit (8-12 in bits) to 5 and leaving all other free
550  //
551  uint32_t verfrag = 0x500;
552  uint32_t type_version = (0x40 << 16) + verfrag;
553  v.push_back(type_version);
554 
555  v.resize(v.size()+size); // prepare place for extra words
556 
557  // counters and temporary words
558  //
559  int word8bit_cnt = 0;// number of 8bit words collected 1..4
560  int wc = 0;// number of blocks of 7 32-bit words saved in ROD fragment 1..8
561  int chc = 0;// number of digits inside the tile digits collection
562  int nwc = (m_vTileDigi.size() + 3)>>2; // convert number of channels into number of 4-byte blocks
563  uint nsamp = 7;
564  uint32_t word[7];
565  memset(word, 0, sizeof(word));
566 
567  for (const TileDigits* digi : m_vTileDigi) {
568 
569  if (wc==nwc) {
570  ATH_MSG_WARNING( "Too many channels per fragment for TMDB frag 0x40 - ignoring all the rest" );
571  break;
572  }
573 
574  // Get identifier(s) and digits for later usage
575  //
576  std::vector<float> digits = digi->samples();
577  nsamp = digits.size();
578  if (nsamp>7) {
579  ATH_MSG_WARNING( "Too many samples in digits for TMDB frag 0x40, using first 7 instead of "<<nsamp );
580  nsamp=7;
581  digits.resize(nsamp);
582  }
583 
584  // Digits from TMDB come to fragment in the reverse order i.e. s1->s7 ... s7->s1
585  //
586  std::reverse(digits.begin(),digits.end());
587 
588  // Define two counters: (a) to count for the 8bit sub-fragments (each word has 4 8bit sub-fragments)
589  // (b) to count for the 32bit words (each digit has 7 32bit words)
590  //
591  // | s(i)-m(j)-d6r | s(i)-m(j)-d6l | s(i)-m(j)-d5r | s(i)-m(j)-d5l |
592  //
593  int shift = word8bit_cnt * 8;
594  for ( uint i=0; i<nsamp; ++i ) {
595  word[i] += ((int) digits[i]) << shift;
596  }
597 
598  if (msgLvl(MSG::DEBUG)) {
599  HWIdentifier hwid = digi->adc_HWID();
600  int ros = m_tileHWID->ros(hwid);
601  int drawer = m_tileHWID->drawer(hwid);
602  int channel = m_tileHWID->channel(hwid);
603  const char * strchannel[5] = {" d5L "," d5R "," d6L "," d6R ", " xxx "};
604  int j=std::min(channel,4);
605  if (ros<3) j=4;
606  for ( uint i=0; i<nsamp; ++i ) {
607  msg(MSG::DEBUG) << ros << "/" << drawer << "/" << channel << strchannel[j]
608  <<"\tSample "<<7-i<<" bits |" << std::setfill('0') << std::setw(2)
609  << shift << "-" << std::setw(2) << shift+7 << std::setfill('0')
610  << "| of 32-bit word "<<3 + nwc*i + wc<<" "<<digits[i]
611  <<" "<<MSG::hex<<word[i]<<MSG::dec << endmsg;
612  }
613  }
614 
615  ++word8bit_cnt;
616 
617  // When word8bit_cnt=4 a set of 32bit words word[0..6] are completed and are saved at a position inside the ROD fragment vector:
618  //
619  // 1st 32 bit word holds : | digit0 pmt3 mod0 | digit0 pmt2 mod0 | digit0 pmt1 mod0 | digit0 pmt0 mod0 |
620  // 2nd 32 bit word holds : | digit0 pmt3 mod1 | digit0 pmt2 mod1 | digit0 pmt1 mod1 | digit0 pmt0 mod1 |
621  // ...
622  // 8th 32 bit word holds : | digit0 pmt3 mod7 | digit0 pmt2 mod7 | digit0 pmt1 mod7 | digit0 pmt0 mod7 |
623  // ...
624  //
625  // word8bit_cnt is reset to 0 and a new set of words[0..6] is restarted.
626  //
627  if ( word8bit_cnt == 4 ) {
628  for ( uint i=0; i<nsamp; ++i ) {
629  v.at( 3 + nwc*i + wc ) = word[i];
630  }
631  ++wc;
632  word8bit_cnt=0;
633  memset(word, 0, sizeof(word));
634  }
635  ++chc;
636  }
637 
638  if ( word8bit_cnt != 0 && wc<nwc ) { // some extra channels
639  ATH_MSG_WARNING( "Unexpected number of channels for TMDB frag 0x40" << wc*4 + word8bit_cnt );
640  for ( uint i=0; i<nsamp; ++i ) {
641  v.at( 3 + nwc*i + wc ) = word[i];
642  }
643  ++wc;
644  word8bit_cnt=0;
645  memset(word, 0 ,sizeof(word));
646  }
647 
648  v.at(savepos)=3+size; // not actually needed - size was already set correctly
649 
650  ATH_MSG_DEBUG( "Check version and counters: "<<MSG::hex<< verfrag <<MSG::dec<<" "<< chc <<" "<< wc << " save in position: " << savepos );
651 
652  // dump fragment
653  //
654  if (msgLvl(MSG::VERBOSE)) {
655  msg(MSG::VERBOSE) << "Check content of ROD fragment after including sub-fragment (0x40)... " << v.size() << endmsg;
656  for (size_t i=0; i<v.size(); ++i)
657  msg(MSG::VERBOSE) << i << "\t" << v.at(i) << MSG::hex << " 0x" << v.at(i) << MSG::dec << endmsg;
658  }
659 
660  return;
661 }
662 
663 // TMDB Raw Channel
664 
665 void TileROD_Encoder::fillRODTileMuRcvRawChannel(std::vector<uint32_t>& v) {
666 
667  ATH_MSG_DEBUG( "TMDB encoding sub-fragment 0x41: loop over " << m_vTileRC.size() << " objects" );
668 
669  const float TMDB_AMPLITUDE_FACTOR = 1.0;
670 
671  // sub-fragment marker
672  //
673  v.push_back(0xff1234ff);
674 
675  // sub-fragment size
676  //
677  v.push_back(3);
678  uint savepos=v.size()-1;
679 
680  // type & version: the version is a 16-bit number and is set by fixing the 3th hexadecimal digit (8-12 in bits) to 5 and leaving all other free
681  //
682  uint32_t verfrag = 0x500;
683  // FIXME: for the moment (July 2015) we use 32-bit packing only, so we hide 16-bit version under ifdef
684  // if we decide to use 16-bit version, additional flag for encoder should be passed from top-level algorithm
685 #ifdef ALLOW16BIT
686  if (use_16bit_packing) verfrag += 2;
687  int32_t word16 = 0x0;
688 #endif
689  uint32_t type_version = (0x41 << 16) + verfrag;
690  v.push_back(type_version);
691 
692  // counters and temporary words
693  //
694  int wc = 0;
695  int chc = 0;
696  uint32_t word = 0x0;
697 
698  for (const TileFastRawChannel* rc : m_vTileRC) {
699 
700  // energies of individual pmts 2 words per module | d5r(16) | d5l(17) |
701  // | d6r(37) | d6l(38) |
702  //
703  float f_amp = rc -> amplitude();
704  int32_t i_amp = lround(f_amp*TMDB_AMPLITUDE_FACTOR) ;
705 
706  // FIXME: for the moment (July 2015) we use 32-bit packing only, so we hide 16-bit version under ifdef
707 #ifdef ALLOW16BIT
708  switch (verfrag){
709  case 0x502:
710  // 2's complement (binary conversion for negative numbers)
711  // x in R and bin_x the binary conversion of x ; (if x<0) then bin_x = 0xffff - abs(x) + 1 (else) bin_x = abs(x)
712  //
713  // v0 : - Feb'15: each 32-bit words holds a cell of a module 16-bit for left side PMT 16 bit for right side pmt
714  //
715  // 1st 32 bit word holds : | d5r m0 | d5l m0 |
716  // 2nd 32 bit word holds : | d6r m0 | d6l m0 |
717  // ...
718  // 7th 32 bit word holds : | d5r m3 | d5l m3 |
719  // 8th 32 bit word holds : | d6r m3 | d6l m3 |
720  // ...
721  // - While reading the FPGA it was noticed a longer word coming out larger that 16-bit
722  // - Keep this (for now) just for history but it may be that later we understand better the FPGA output
723  //
724  //limit to the range of 16-bit integer
725  if (i_amp>0x7FFF) word16 = 0x7FFF;
726  else if (i_amp<-0x8000) word16 = -0x8000;
727  else word16 = i_amp;
728 
729  if (chc&1) {
730  word |= word16 << 16;
731  v.push_back(word);
732  ++wc;
733  } else {
734  word = word16 & 0xFFFF;
735  }
736  break;
737 
738  //case 0x500:
739  default:
740 #else
741  {
742 #endif
743  // vMay'15 current version each 32-bit word is a channel
744  word = (uint32_t)i_amp;
745  v.push_back(word);
746  ++wc;
747  }
748 
749  if (msgLvl(MSG::DEBUG)) {
750  int frag_id = rc->frag();
751  int drawer = (frag_id&0xFF);
752  int ros = frag_id>>8;
753  int channel = rc->channel();
754  const char * strchannel[5] = {" d5L "," d5R "," d6L "," d6R ", " xxx "};
755  int j=std::min(channel,4);
756  if (ros<3) j=4;
757  msg(MSG::DEBUG) << ros << "/" << drawer << "/" << channel << strchannel[j]
758  <<"\tAmp " << f_amp << " " << i_amp << " "
759  <<" ch cnt " << chc << " word cnt " << wc
760  << " word 0x" <<MSG::hex<< word <<MSG::dec<<endmsg;
761  }
762 
763  ++chc;
764  }
765 
766  // FIXME: for the moment (July 2015) we use 32-bit packing only, so we hide 16-bit version under ifdef
767 #ifdef ALLOW16BIT
768  if (verfrag==0x502 && wc*2 != chc) { // odd number of channels for 16-bit frags
769  v.push_back(word); // saving last channel
770  ++wc;
771  }
772 #endif
773 
774  v.at(savepos)=3+wc;
775 
776  ATH_MSG_DEBUG("Check version and counters: "<<MSG::hex<< verfrag <<MSG::dec<<" "<< chc <<" "<< wc <<" save in position: "<< savepos );
777 
778  if (msgLvl(MSG::VERBOSE)) {
779  msg(MSG::VERBOSE) << "Check content of ROD fragment after including sub-fragment (0x41)... "<< m_vTileRC.size() <<" "<< v.size() << endmsg;
780  for (size_t i=0; i<v.size(); ++i) {
781  msg(MSG::VERBOSE) << i <<"\t"<< v.at(i) << MSG::hex << " 0x" << v.at(i) << MSG::dec << endmsg;
782  }
783  }
784  return;
785 }
786 
787 // TMDB Decision
788 
789 void TileROD_Encoder::fillRODTileMuRcvObj(std::vector<uint32_t>& v) {
790 
791  // this is the subfragment type 0x42
792 
793  ATH_MSG_INFO( "TMDB encoding sub-fragment 0x42: loop over " << m_vTileMuRcvObj.size() << " objects" );
794 
795  // sub-fragment marker
796  //
797  v.push_back(0xff1234ff);
798 
799  // type & version
800  //
801  v.push_back(5);
802  uint savepos = v.size()-1;
803  uint32_t verfrag = 0x500;
804  uint32_t type_version = (0x42 << 16) + verfrag;
805  v.push_back(type_version);
806 
807  // counters and temporary words
808  //
809  int wc = 0;
810  int chc= 0;
811  uint32_t result1 = 0x0;
812  uint32_t result2 = 0x0;
813  uint32_t result3 = 0x0;
814 
815  switch (m_runPeriod) {
816 
817  case 2:// RUN2
818 
819  msg(MSG::INFO) << "Going trough RUN2 encoding procedure for TMDB data" << endmsg;
820 
821  for (const TileMuonReceiverObj* tmurcv : m_vTileMuRcvObj) {
822 
823  // VERSION RUN2: results are hold in 3 16-bit words. Two 32 bit words.
824  //
825  // 32nd bit -> | results2 || results1 | <- 1st bit
826  // | 0x0 || results3 |
827  //
828  // 32nd bit -> | m-5 | m-4 | m-3 | m-2 || m-2 | m-1 | m-0 | 0x0 | <- 1st bit
829  // | 0x0 || 0x0 | m-7 | m-6 | m-5 |
830  //
831  // each 4 bit word is
832  //
833  // 0 1 2 3 <-- in Obj
834  // | d56h | d56l | d6h | d6l |
835  // bit3 bit2 bit1 bit0
836  //
837 
838  int modid = tmurcv->identify() & 0xff;
839 
840  const std::vector<bool> & slin = tmurcv->GetDecision();
841  int imax = std::min((int)slin.size(),4);
842  uint32_t word4b = 0x0;
843  for (int i=0;i<imax;++i){
844  if (slin[i]) word4b |= 1 << (3-i);
845  }
846 
847  if (msgLvl(MSG::INFO)) {
848  std::stringstream ss;
849  for (const bool val : slin) {
850  ss<<std::setw(2)<<val;
851  }
852  msg(MSG::INFO) << "Result for module: "<<modid<<" in TMDB board "<<modid%8<<MSG::hex<<": 0x"<<word4b<<MSG::dec<<" from "<<ss.str() << endmsg;
853  }
854 
855  switch (modid%8) {
856  case 0: result1 |= word4b << 4 ; break;
857  case 1: result1 |= word4b << 8 ; break;
858  case 2: result1 |= word4b << 12 ; result2 |= word4b; break;
859  case 3: result2 |= word4b << 4 ; break;
860  case 4: result2 |= word4b << 8 ; break;
861  case 5: result2 |= word4b << 12 ; result3 |= word4b; break;
862  case 6: result3 |= word4b << 4 ; break;
863  case 7: result3 |= word4b << 8 ; break;
864  }
865  ++chc;
866  }
867 
868  ATH_MSG_INFO( "Summary : "<<MSG::hex<<" Results 1: 0x"<<result1<<" Results 2: 0x"<<result2<<" Results 3: 0x"<<result3<< MSG::dec );
869 
870  v.push_back( result1 | (result2 << 16) ); ++wc;// | 5 4 3 2 | 2 1 0 - |
871  v.push_back( result3 ); ++wc; // | - - - - | - 7 6 5 | '-' means free/not set/0x0
872  v.at(savepos)=3+wc;
873 
874  break;
875 
876  case 3:// RUN3
877 
878  msg(MSG::INFO) << "Going trough RUN3 encoding procedure for TMDB data" << endmsg;
879 
880  for (const TileMuonReceiverObj* tmurcv : m_vTileMuRcvObj) {
881  // VERSION RUN3: results are hold in two 32-bit word to cover a TMDB board holding 8 TileCal modules.
882  //
883  // 32nd bit -> | results2 [16:31] || results1 [0:15] | <- 1st bit
884  // 32nd bit -> | 0x0 [16:31] || results3 [0:15] | <- 1st bit
885  //
886  // 32nd bit -> | 0x0 [12:15] | m-5 | m-4 | m-3 | m-2 || 0x0 [12:15] | m-3 | m-2 | m-1 | m-0 | <- 1st bit
887  // | 0x0 [16:31] || 0x0 [12:15] | m-7 | m-6 | m-5 | m-4 |
888  //
889  // For each module m-X there is a 3-bit word with the result for a threshold
890  //
891  // | d5+d6 | d6 | d5 |
892  // | bit2 | bit1 | bit0 |
893  //
894 
895  // counters and temporary words
896  //
897 
898 /*
899  *
900  * Comment on implementation...
901  * In Athena the container size is kept to 4. It is fully used for run2 but for run3 the first position is left empty.
902  * The most significative bit is placed in first position [0] of a container so the position reverse while encoding.
903  *
904  * */
905 
906  int modid = tmurcv->identify() & 0xff;
907  const std::vector<bool> & slin = tmurcv->GetDecision();
908  int imax = std::min((int)slin.size(),4);
909  uint32_t word3b = 0x0;
910  for (int i=1;i<imax;++i) {
911  // slin d56 d6 d5
912  // word3b bit2 bit1 bit0
913  // bit 4 is always 0 since iteration starts at 1
914  if (slin[i]) word3b |= 1 << (3-i);
915  }
916 
917  switch (modid%8) {
918  case 0: result1 |= word3b ; break;
919  case 1: result1 |= word3b << 3 ; break;
920  case 2: result1 |= word3b << 6 ; result2 |= word3b ; break;
921  case 3: result1 |= word3b << 9 ; result2 |= word3b << 3 ; break;
922  case 4: result2 |= word3b << 6 ; result3 |= word3b ; break;
923  case 5: result2 |= word3b << 9 ; result3 |= word3b << 3 ; break;
924  case 6: result3 |= word3b << 6 ; break;
925  case 7: result3 |= word3b << 9 ; break;
926  }
927  ++chc;
928  }
929 
930  ATH_MSG_INFO( "Summary : "<<MSG::hex<<" Results 1: 0x"<<result1<<" Results 2: 0x"<<result2<<" Results 3: 0x"<<result3<< MSG::dec );
931 
932  v.push_back( result1 | (result2 << 16) ); ++wc;
933  v.push_back( result3 ); ++wc;
934  v.at(savepos) = 3+wc;
935 
936  break;
937 
938  case 0://not defined
939  ATH_MSG_INFO("Tile Muon Decision Board (TMDB) fragment versions are only available for RUN2 and RUN3");
940  break;
941  }
942  if (msgLvl(MSG::INFO)){
943  msg(MSG::INFO) << "Check version and counters: "<<MSG::hex<<verfrag<<MSG::dec<<" "<<chc<<" "<<wc<<" save in position: "<<savepos<<endmsg;
944  msg(MSG::INFO) << "Check content of ROD fragment after including sub-fragment (0x42)... " << v.size() << endmsg;
945  for (size_t i=0; i<v.size(); ++i) {
946  msg(MSG::INFO) << i << "\t" << v.at(i) << MSG::hex << " 0x" << v.at(i) << MSG::dec << endmsg;
947  }
948  }
949  return;
950 }
951 
952 // == END of TMDB Encoders
953 
954 // set the bit accordingly.
955 // the bits are used when reading TileROD_Decoder::checkBit
957 // chan = (0,47)
958  int a = chan / 32;
959  int r = chan % 32;
960 // a = (0,1), r = ( 0, 31 )
961  *(p + a) |= (1 << r);
962  return;
963 }
964 
965 // check if bit is set
967 // chan = (0,47)
968  int a = chan / 32;
969  int r = chan % 32;
970 // a = (0,1), r = ( 0, 31 )
971  return *(p + a) & (1 << r);
972 
973 }
974 
975 void TileROD_Encoder::dumpROD(const std::vector<uint32_t>& v) {
976  msg(MSG::VERBOSE) << " Dump of Tile ROD block, size = " << v.size() << endmsg;
977 
978  int count = 0, newCount = 3;
979  for (const uint32_t data : v) {
980  if (count == 0) {
981  msg(MSG::VERBOSE) << "Frag delim = 0x" << std::hex << data << std::dec << endmsg;
982  } else if (count == -1) {
983  newCount = data;
984  msg(MSG::VERBOSE) << "Word count = " << newCount << endmsg;
985  } else if (count == -2) {
986  count += newCount;
987  msg(MSG::VERBOSE) << "Frag ID = 0x" << std::hex << data << std::dec << endmsg;
988  } else {
989  msg(MSG::VERBOSE) << " WORD[" << newCount - count << "] = "
990  << data << " = 0x" << std::hex << data
991  << std::dec << endmsg;
992  }
993  --count;
994  }
995 }
TileROD_Encoder::m_order
TileRawDataOrdering m_order
Definition: TileROD_Encoder.h:142
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
beamspotman.r
def r
Definition: beamspotman.py:674
data
char data[hepevt_bytes_allocation_ATLAS]
Definition: HepEvt.cxx:11
et
Extra patterns decribing particle interation process.
TileROD_Encoder::fillROD3
void fillROD3(std::vector< uint32_t > &v)
Definition: TileROD_Encoder.cxx:333
PowhegControl_ttHplus_NLO.ss
ss
Definition: PowhegControl_ttHplus_NLO.py:83
plotting.yearwise_efficiency.channel
channel
Definition: yearwise_efficiency.py:24
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
AthMsgStreamMacros.h
TileROD_Encoder::fillRODTileMuRcvRawChannel
void fillRODTileMuRcvRawChannel(std::vector< uint32_t > &v)
Definition: TileROD_Encoder.cxx:665
TileRawChannel2Bytes::setVerbose
void setVerbose(bool verbose)
Sets verbose mode true or false.
Definition: TileRawChannel2Bytes.h:64
xAOD::uint32_t
setEventNumber uint32_t
Definition: EventInfo_v1.cxx:127
TileROD_Encoder::dumpROD
void dumpROD(const std::vector< uint32_t > &v)
dump contents of the ROD fragment
Definition: TileROD_Encoder.cxx:975
TileROD_Encoder::setTileHWID
void setTileHWID(const TileHWID *tileHWID, bool verbose, unsigned int type=4)
set all necessary parameters for the encoder
Definition: TileROD_Encoder.cxx:68
min
constexpr double min()
Definition: ap_fixedTest.cxx:26
TileCalibUtils
Static class providing several utility functions and constants.
Definition: TileCalibUtils.h:15
mergePhysValFiles.start
start
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:13
TileFragHash::TYPE
TYPE
initialize
Definition: TileFragHash.h:33
CaloCondBlobAlgs_fillNoiseFromASCII.gain
gain
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:109
MuonGM::round
float round(const float toRound, const unsigned int decimals)
Definition: Mdt.cxx:27
TileROD_Encoder::fillROD4
void fillROD4(std::vector< uint32_t > &v)
Definition: TileROD_Encoder.cxx:407
TileROD_Encoder::fillROD1
void fillROD1(std::vector< uint32_t > &v)
convert all TileDigits in the current list to a vector of 32bit words
Definition: TileROD_Encoder.cxx:495
TileRawChannel2Bytes4::setVerbose
void setVerbose(bool)
Sets verbose mode true or false.
Definition: TileRawChannel2Bytes4.h:91
TileROD_Encoder::m_rc2bytes5
TileRawChannel2Bytes5 m_rc2bytes5
Definition: TileROD_Encoder.h:136
TileHWID::frag
int frag(const HWIdentifier &id) const
extract frag field from HW identifier
Definition: TileHWID.h:181
TileCalibUtils.h
TileROD_Encoder::m_runPeriod
int m_runPeriod
Definition: TileROD_Encoder.h:150
TileROD_Encoder::setBit
void setBit(uint32_t *p, int chan)
set the bitmap for a channel
Definition: TileROD_Encoder.cxx:956
HWIdentifier
Definition: HWIdentifier.h:13
x
#define x
xAOD::int16_t
setScaleOne setStatusOne setSaturated int16_t
Definition: gFexGlobalRoI_v1.cxx:55
TileDigits2Bytes::getBytes
int getBytes(const TileDigits *digi, const TileHWID *tileHWID, std::vector< unsigned int > &v)
Definition: TileDigits2Bytes.cxx:12
TileROD_Encoder::checkBit
bool checkBit(const uint32_t *p, int chan)
check the bitmap for a channel
Definition: TileROD_Encoder.cxx:966
Example_ReadSampleNoise.drawer
drawer
Definition: Example_ReadSampleNoise.py:39
python.CaloAddPedShiftConfig.type
type
Definition: CaloAddPedShiftConfig.py:42
TileROD_Encoder::m_verbose
bool m_verbose
Definition: TileROD_Encoder.h:144
XMLtoHeader.count
count
Definition: XMLtoHeader.py:84
TileHWID::channel
int channel(const HWIdentifier &id) const
extract channel field from HW identifier
Definition: TileHWID.h:189
TileROD_Encoder::setTypeAndUnit
void setTypeAndUnit(TileFragHash::TYPE type, TileRawChannelUnit::UNIT unit)
set OF algorigtm type and amplitude units for a drawer
Definition: TileROD_Encoder.cxx:97
DeMoUpdate.reverse
reverse
Definition: DeMoUpdate.py:563
TileHWID::ros
int ros(const HWIdentifier &id) const
extract ros field from HW identifier
Definition: TileHWID.h:167
TileRawChannel2Bytes2::getWord
unsigned int getWord(const TileFastRawChannel *rc, int gain)
Returns a single 32-bit word which encodes the TileRawChannel information (gain,amplitude,...
Definition: TileRawChannel2Bytes2.cxx:18
m_type
TokenType m_type
the type
Definition: TProperty.cxx:44
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
TileHWID
Helper class for TileCal online (hardware) identifiers.
Definition: TileHWID.h:49
uint
unsigned int uint
Definition: LArOFPhaseFill.cxx:20
skel.l2
l2
Definition: skel.GENtoEVGEN.py:410
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:209
TileROD_Encoder::fillROD5
void fillROD5(std::vector< uint32_t > &v)
Definition: TileROD_Encoder.cxx:522
TileHWID.h
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
AthMessaging::msgLvl
bool msgLvl(const MSG::Level lvl) const
Test the output level.
Definition: AthMessaging.h:151
TileROD_Encoder::m_maxChannels
int m_maxChannels
Definition: TileROD_Encoder.h:149
TileROD_Encoder::fillROD10
void fillROD10(std::vector< uint32_t > &v)
convert all TileL2s in the current list to a vector of 32bit words
Definition: TileROD_Encoder.cxx:177
lumiFormat.i
int i
Definition: lumiFormat.py:85
ReadCellNoiseFromCool.chan
chan
Definition: ReadCellNoiseFromCool.py:52
TileROD_Encoder::m_type
unsigned int m_type
Definition: TileROD_Encoder.h:145
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
TileRawChannelUnit::OnlineOffset
@ OnlineOffset
Definition: TileRawChannelUnit.h:25
TileL2.h
AthMessaging
Class to provide easy MsgStream access and capabilities.
Definition: AthMessaging.h:55
TileROD_Encoder::m_tileHWID
const TileHWID * m_tileHWID
Definition: TileROD_Encoder.h:138
TileROD_Encoder::fillRODTileMuRcvObj
void fillRODTileMuRcvObj(std::vector< uint32_t > &v)
Definition: TileROD_Encoder.cxx:789
maskDeadModules.ros
ros
Definition: maskDeadModules.py:35
imax
int imax(int i, int j)
Definition: TileLaserTimingTool.cxx:33
TileRawChannelUnit::UNIT
UNIT
Definition: TileRawChannelUnit.h:16
TileROD_Encoder::m_unitType
unsigned int m_unitType
Definition: TileROD_Encoder.h:146
TileROD_Encoder::m_rc2bytes2
TileRawChannel2Bytes2 m_rc2bytes2
Definition: TileROD_Encoder.h:133
AthMessaging::msg
MsgStream & msg() const
The standard message stream.
Definition: AthMessaging.h:164
TileROD_Encoder::setMaxChannels
void setMaxChannels(int maxChannels)
set maximum number of channels in a drawer
Definition: TileROD_Encoder.cxx:137
TileRawChannel2Bytes::getBytes
int getBytes(const TileFastRawChannel *rc, int gain, std::vector< short > &v)
Pack TileRawChannel information (gain, amplitude, phase and quality) in 3 16-bit words.
Definition: TileRawChannel2Bytes.cxx:10
head
std::string head(std::string s, const std::string &pattern)
head of a string
Definition: computils.cxx:312
TileROD_Encoder::m_vTileRC
std::vector< const TileFastRawChannel * > m_vTileRC
Definition: TileROD_Encoder.h:126
TileROD_Encoder::m_rChUnit
unsigned int m_rChUnit
Definition: TileROD_Encoder.h:147
TileDigits
Definition: TileDigits.h:30
TileROD_Encoder::m_vTileMuRcvObj
std::vector< const TileMuonReceiverObj * > m_vTileMuRcvObj
Definition: TileROD_Encoder.h:130
TileROD_Encoder::fillRODTileMuRcvDigi
void fillRODTileMuRcvDigi(std::vector< uint32_t > &v)
convert the TMDB objects into a vector of 32bit words: 8bit words/digit, 16bit words/RC,...
Definition: TileROD_Encoder.cxx:534
TileROD_Encoder.h
python.LumiBlobConversion.pos
pos
Definition: LumiBlobConversion.py:16
python.PyAthena.v
v
Definition: PyAthena.py:154
TileMuonReceiverObj
Definition: TileMuonReceiverObj.h:28
TileRawChannel2Bytes4::getWord
unsigned int getWord(const TileFastRawChannel &rc, unsigned int unit, int gain) const
Returns a single 32-bit word which encodes the TileRawChannel information (gain,amplitude,...
Definition: TileRawChannel2Bytes4.cxx:21
a
TList * a
Definition: liststreamerinfos.cxx:10
python.CaloAddPedShiftConfig.int
int
Definition: CaloAddPedShiftConfig.py:45
TileHWID::drawer
int drawer(const HWIdentifier &id) const
extract drawer field from HW identifier
Definition: TileHWID.h:171
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
python.Constants.INFO
int INFO
Definition: Control/AthenaCommon/python/Constants.py:15
TileRawChannel2Bytes5::setVerbose
void setVerbose(bool)
Sets verbose mode true or false.
Definition: TileRawChannel2Bytes5.h:103
TileROD_Encoder::TileROD_Encoder
TileROD_Encoder()
constructor
Definition: TileROD_Encoder.cxx:56
TileROD_Encoder::fillROD
void fillROD(std::vector< uint32_t > &v)
convert all TileRawChannels in the current list to a vector of 32bit words
Definition: TileROD_Encoder.cxx:145
Pythia8_RapidityOrderMPI.val
val
Definition: Pythia8_RapidityOrderMPI.py:14
TileROD_Encoder::fillRODL2
void fillRODL2(std::vector< uint32_t > &v)
Definition: TileROD_Encoder.cxx:456
unit
const PlainObject unit() const
This is a plugin that makes Eigen look like CLHEP & defines some convenience methods.
Definition: AmgMatrixBasePlugin.h:21
TileROD_Encoder::m_Digi2bytes
TileDigits2Bytes m_Digi2bytes
Definition: TileROD_Encoder.h:132
python.TriggerHandler.verbose
verbose
Definition: TriggerHandler.py:296
DeMoScan.first
bool first
Definition: DeMoScan.py:534
DEBUG
#define DEBUG
Definition: page_access.h:11
TileROD_Encoder::m_vTileDigi
std::vector< const TileDigits * > m_vTileDigi
Definition: TileROD_Encoder.h:128
AMPLITUDE_FACTOR5_HG
const double AMPLITUDE_FACTOR5_HG[4]
Definition: TileRawChannel2Bytes5.h:33
TileROD_Encoder::fillROD2
void fillROD2(std::vector< uint32_t > &v)
Definition: TileROD_Encoder.cxx:289
TileROD_Encoder::m_rc2bytes3
TileRawChannel2Bytes m_rc2bytes3
Definition: TileROD_Encoder.h:134
TileMuonReceiverObj.h
TileFastRawChannel
Definition: TileFastRawChannel.h:17
python.Constants.VERBOSE
int VERBOSE
Definition: Control/AthenaCommon/python/Constants.py:13
TileROD_Encoder::m_rc2bytes4
TileRawChannel2Bytes4 m_rc2bytes4
Definition: TileROD_Encoder.h:135
TileDigits.h
TileFastRawChannel.h
TileROD_Encoder::m_vTileL2
std::vector< const TileL2 * > m_vTileL2
Definition: TileROD_Encoder.h:127
TileRawChannel2Bytes2::setVerbose
void setVerbose(bool verbose)
Sets verbose mode true or false.
Definition: TileRawChannel2Bytes2.h:82
TileROD_Encoder::fillROD5D
void fillROD5D(std::vector< uint32_t > &v)
Definition: TileROD_Encoder.cxx:526
TileL2
Class to store TileMuId and Et quantities computed at the TileCal ROD DSPs.
Definition: TileL2.h:33
TileROD_Encoder::fillROD12
void fillROD12(std::vector< uint32_t > &v)
Definition: TileROD_Encoder.cxx:241