ATLAS Offline Software
Classes | Public Types | Public Member Functions | Static Public Member Functions | Public Attributes | List of all members
TileRawChannel2Bytes5 Class Reference

Converts the TileRawChannel object into bytes as it. More...

#include <TileRawChannel2Bytes5.h>

Collaboration diagram for TileRawChannel2Bytes5:

Classes

struct  TileChanData
 

Public Types

enum  FormatCode {
  code_amp5 = 0x20, code_raws = 0x40, code_dump = 0x60, code_ped4 = 0x10,
  code_ped5 = 0x90, code_rawf = 0x08, code_amp6 = 0x04, code_full = 0x01,
  code_null = 0x00
}
 

Public Member Functions

 TileRawChannel2Bytes5 ()
 
void unpack_reco (unsigned int w, unsigned int unit, int &fmt, int &gain, double &amp, double &time) const
 Unpack Frag5 reco from 32-bit word w. More...
 
bool unpack_reco_bin (unsigned int w, int &fmt, int &gain, int &amp, int &time) const
 
double getSum (const uint32_t *ptr_frag, int n) const
 Get SumEt, SumEz, SumE value. More...
 
double getSumEt (const uint32_t *ptr_frag) const
 
double getSumEz (const uint32_t *ptr_frag) const
 
double getSumE (const uint32_t *ptr_frag) const
 
void setVerbose (bool)
 Sets verbose mode true or false. More...
 
int get_format (int code) const
 
void setFormatLookup ()
 
int amplitude (const uint32_t *ofw, int unit, int chan, int gain, int s[]) const
 
void unpack (const uint32_t *ofw, const uint32_t *ptr_frag, TileChanData *ChanData) const
 
bool check_raw (const uint32_t *feb, int of_energy[], TileChanData *ChanData) const
 
bool check_reco (const uint32_t *frag, int of_energy[]) const
 

Static Public Member Functions

static bool is_code_amp5 (uint32_t code)
 Compression Format Code inlile functions. More...
 
static bool is_code_raws (uint32_t code)
 
static bool is_code_dump (uint32_t code)
 
static bool is_code_ped4 (uint32_t code)
 
static bool is_code_ped5 (uint32_t code)
 
static bool is_code_rawf (uint32_t code)
 
static bool is_code_amp6 (uint32_t code)
 
static bool is_code_full (uint32_t code)
 
static bool is_code_null (uint32_t code)
 
static bool is_code_ped (uint32_t code)
 
static bool is_code_amp (uint32_t code)
 
static bool is_code_amp_raw_dump (uint32_t code)
 
static int get_code (uint32_t reco)
 
static void print_code (uint32_t code)
 
static int get_size_code (uint32_t code)
 
static int get_quality (int bad, int format)
 

Public Attributes

uint8_t m_FormatLookup [256]
 

Detailed Description

Converts the TileRawChannel object into bytes as it.

Compressed Frag #5 In one 32-bit word

Definition at line 42 of file TileRawChannel2Bytes5.h.

Member Enumeration Documentation

◆ FormatCode

Enumerator
code_amp5 
code_raws 
code_dump 
code_ped4 
code_ped5 
code_rawf 
code_amp6 
code_full 
code_null 

Definition at line 46 of file TileRawChannel2Bytes5.h.

46  {
47  code_amp5 = 0x20, // G 0 1 . . . . .
48  code_raws = 0x40, // G 1 0 . . . . .
49  code_dump = 0x60, // G 1 1 . . . . .
50  code_ped4 = 0x10, // 0 0 0 1 . . . .
51  code_ped5 = 0x90, // 1 0 0 1 . . . .
52  code_rawf = 0x08, // G 0 0 0 1 . . .
53  code_amp6 = 0x04, // G 0 0 0 0 1 . .
54  code_full = 0x01, // G 0 0 0 0 0 0 1
55  code_null = 0x00 // 0 0 0 0 0 0 0 0
56  };

Constructor & Destructor Documentation

◆ TileRawChannel2Bytes5()

TileRawChannel2Bytes5::TileRawChannel2Bytes5 ( )
inline

Definition at line 71 of file TileRawChannel2Bytes5.h.

72  {
74  }

Member Function Documentation

◆ amplitude()

int TileRawChannel2Bytes5::amplitude ( const uint32_t *  ofw,
int  unit,
int  chan,
int  gain,
int  s[] 
) const

Definition at line 624 of file TileRawChannel2Bytes5.cxx.

625 {
626 
627  UINT32 calib, calib_coeff;
628  INT16 calib_scale;
629  int amp, ene, ene0, ene_shift;
630  //INT16 amp2;
631  const UINT32* ofc;
632 
633  int FRACBITS_MINUS_11 = _sadd(OF_E_FRACBITS[unit], 11);
634 
635  int s1 = s[0], s2 = s[1], s3 = s[2], s4 = s[3], s5 = s[4], s6 = s[5], s7 = s[6];
636 
637  // samples
638  UINT32 s1x = _pack2(s1, gain << 15);
639  UINT32 s32 = _pack2(s3, s2);
640  UINT32 s54 = _pack2(s5, s4);
641  UINT32 s76 = _pack2(s7, s6);
642 
643  ene_shift = 512 + _mpy(gain, 2048 - 512);
644 
646 
647  // amp coeff
648  UINT32 a1x = ofc[0];
649  UINT32 a32 = ofc[1];
650  UINT32 a54 = ofc[2];
651  UINT32 a76 = ofc[3];
652  //UINT16 a_scale = _extu(a1x, 16, 16);
653 
654  amp = _mpyh (a1x, s1x)
655  + _dotp2(a32, s32)
656  + _dotp2(a54, s54)
657  + _dotp2(a76, s76);
658 
659  // calib
660  calib = ofc[4];
661 
662  calib_coeff = _ext(calib, 0, 16);
663  calib_scale = _ssub(_extu(calib, 16, 16) , FRACBITS_MINUS_11);
664  ene0 = _round(amp, 11);
665  ene0 = _round(ene0*calib_coeff, calib_scale);
666  ene = ene0 + ene_shift;
667 
668  return ene;
669 }

◆ check_raw()

bool TileRawChannel2Bytes5::check_raw ( const uint32_t *  feb,
int  of_energy[],
TileChanData ChanData 
) const

Definition at line 757 of file TileRawChannel2Bytes5.cxx.

758 {
759  bool OK = true;
760  int chan, i;
761  int gain, ene, u[7], s[7];
762  const UINT32* data = feb + 3;
763  for (chan = 0; chan < 48; ++chan) {
764  bool chOK = true;
765  //code = Data[chan].code;
766  //bad = Data[chan].bad;
767  gain = Data[chan].gain;
768  ene = Data[chan].ene_bin;
769  //time = Data[chan].time_bin;
770 
771  for (i = 0; i < 7; ++i) u[i] = Data[chan].s[i];
772  {
773  //double s1x32 = _memd8(data + chan*4);
774  //double s5476 = _memd8(data + chan*4 + 2);
775  UINT32 s1x = data[chan*4 + 0]; //_hi(s1x32);
776  UINT32 s32 = data[chan*4 + 1]; //_lo(s1x32);
777  UINT32 s54 = data[chan*4 + 2]; //_hi(s5476);
778  UINT32 s76 = data[chan*4 + 3]; //_lo(s5476);
779  s[1-1] = _extu(s1x, 0, 16);
780  s[2-1] = _extu(s32, 16, 16);
781  s[3-1] = _extu(s32, 0, 16);
782  s[4-1] = _extu(s54, 16, 16);
783  s[5-1] = _extu(s54, 0, 16);
784  s[6-1] = _extu(s76, 16, 16);
785  s[7-1] = _extu(s76, 0, 16);
786  }
787 
788  for (i = 0; i < 7; ++i) {
789  if (s[i] != u[i]) chOK = false;
790  }
791  if (!chOK) { printf("\n %d: Raw Data ERROR", chan); }
792 
793  ene += (gain == 0 ? 512 : 2048);
794 
795  if (of_energy[chan] != ene) {
796  OK = false;
797  printf("\n %d : amp error ene: %d e_t_amp: %d\n", chan, ene, of_energy[chan]);
798  }
799 
800  if (!chOK) {
801  OK = false;
802  printf("\n %2d ERROR", chan);
803  }
804  }
805  printf("\nunpack_data");
806  if (OK) printf(" OK"); else printf(" ERROR");
807  printf(" ");
808  return OK;
809 }

◆ check_reco()

bool TileRawChannel2Bytes5::check_reco ( const uint32_t *  frag,
int  of_energy[] 
) const

Definition at line 811 of file TileRawChannel2Bytes5.cxx.

812 {
813  int chan;
814  bool OK = true;
815  int bad, gain, amp, ene, time;
816  const UINT32* reco = (frag + 3); // + Header
817  UINT32 w;
818 
819  for (chan = 0; chan < 48; ++chan) {
820  w = reco[chan];
821 
822  if (!unpack_reco_bin(w, bad, gain, amp, time)) {
823  printf("\nTileRawChannel2Bytes5::unpack_reco_bin ERROR\n");
824  OK = false;
825  }
826 
827  ene = amp + AMPLITUDE_OFFSET5[gain];
828 
829  if (of_energy[chan] != ene) {
830  OK = false;
831  //printf("\n "); print_code(code);
832  //printf(" amp error ene: %d e_t_amp: %d", amp, of_energy[chan]);
833  }
834  } // for
835 
836  return OK;
837 }

◆ get_code()

static int TileRawChannel2Bytes5::get_code ( uint32_t  reco)
inlinestatic

Definition at line 105 of file TileRawChannel2Bytes5.h.

106  {
107  int code = reco >> 24;
108 
109  if (is_code_null(code)) code = code_null; else
110  if (is_code_ped4(code)) code = code_ped4; else
111  if (is_code_ped5(code)) code = code_ped5; else
112  if (is_code_amp5(code)) code = code_amp5; else
113  if (is_code_amp6(code)) code = code_amp6; else
114  if (is_code_raws(code)) code = code_raws; else
115  if (is_code_rawf(code)) code = code_rawf; else
116  if (is_code_full(code)) code = code_full; else
117  if (is_code_dump(code)) code = code_dump; else {
118  printf("\nTileRawChannel2Bytes5::get_code ERROR\n");
119  code = -1;
120  }
121  return code;
122  }

◆ get_format()

int TileRawChannel2Bytes5::get_format ( int  code) const
inline

Definition at line 154 of file TileRawChannel2Bytes5.h.

154 { return m_FormatLookup[code & 0xFF]; }

◆ get_quality()

static int TileRawChannel2Bytes5::get_quality ( int  bad,
int  format 
)
inlinestatic

Definition at line 155 of file TileRawChannel2Bytes5.h.

155 { return (bad << 4) + format; }

◆ get_size_code()

static int TileRawChannel2Bytes5::get_size_code ( uint32_t  code)
inlinestatic

Definition at line 138 of file TileRawChannel2Bytes5.h.

139  {
140  int size = 0;
141  if (is_code_null(code)) size = 32; else
142  if (is_code_ped4(code)) size = 40; else
143  if (is_code_ped5(code)) size = 48; else
144  if (is_code_amp5(code)) size = 56; else
145  if (is_code_amp6(code)) size = 64; else
146  if (is_code_raws(code)) size = 72; else
147  if (is_code_rawf(code)) size = 80; else
148  if (is_code_full(code)) size = 80; else
149  if (is_code_dump(code)) size = 88;
150 
151  return size/8;
152  }

◆ getSum()

double TileRawChannel2Bytes5::getSum ( const uint32_t *  ptr_frag,
int  n 
) const
inline

Get SumEt, SumEz, SumE value.

Definition at line 271 of file TileRawChannel2Bytes5.h.

272 {
273  int unit = ptr_frag[2] >> (32 - 2);
274  int amp_bin = (int) (ptr_frag[3 + 48 + n]); // Header + Reco + [SumEt, SumEz, SumE]
275  return Frag5_unpack_bin2sum(unit, amp_bin);
276 }

◆ getSumE()

double TileRawChannel2Bytes5::getSumE ( const uint32_t *  ptr_frag) const
inline

Definition at line 280 of file TileRawChannel2Bytes5.h.

280 { return getSum(ptr_frag, 2); }

◆ getSumEt()

double TileRawChannel2Bytes5::getSumEt ( const uint32_t *  ptr_frag) const
inline

Definition at line 278 of file TileRawChannel2Bytes5.h.

278 { return getSum(ptr_frag, 0); }

◆ getSumEz()

double TileRawChannel2Bytes5::getSumEz ( const uint32_t *  ptr_frag) const
inline

Definition at line 279 of file TileRawChannel2Bytes5.h.

279 { return getSum(ptr_frag, 1); }

◆ is_code_amp()

static bool TileRawChannel2Bytes5::is_code_amp ( uint32_t  code)
inlinestatic

Definition at line 88 of file TileRawChannel2Bytes5.h.

88 { return (is_code_amp5(code) || is_code_amp6(code)); }

◆ is_code_amp5()

static bool TileRawChannel2Bytes5::is_code_amp5 ( uint32_t  code)
inlinestatic

Compression Format Code inlile functions.

Definition at line 77 of file TileRawChannel2Bytes5.h.

77 { return ((code & 0x60) == code_amp5); }

◆ is_code_amp6()

static bool TileRawChannel2Bytes5::is_code_amp6 ( uint32_t  code)
inlinestatic

Definition at line 83 of file TileRawChannel2Bytes5.h.

83 { return ((code & 0x7C) == code_amp6); }

◆ is_code_amp_raw_dump()

static bool TileRawChannel2Bytes5::is_code_amp_raw_dump ( uint32_t  code)
inlinestatic

Definition at line 89 of file TileRawChannel2Bytes5.h.

89 { return (code & 0x6C); }

◆ is_code_dump()

static bool TileRawChannel2Bytes5::is_code_dump ( uint32_t  code)
inlinestatic

Definition at line 79 of file TileRawChannel2Bytes5.h.

79 { return ((code & 0x60) == code_dump); }

◆ is_code_full()

static bool TileRawChannel2Bytes5::is_code_full ( uint32_t  code)
inlinestatic

Definition at line 84 of file TileRawChannel2Bytes5.h.

84 { return ((code & 0x3F) == code_full); }

◆ is_code_null()

static bool TileRawChannel2Bytes5::is_code_null ( uint32_t  code)
inlinestatic

Definition at line 85 of file TileRawChannel2Bytes5.h.

85 { return ((code & 0xFF) == code_null); }

◆ is_code_ped()

static bool TileRawChannel2Bytes5::is_code_ped ( uint32_t  code)
inlinestatic

Definition at line 87 of file TileRawChannel2Bytes5.h.

87 { return ((code & 0x70) == code_ped4); }

◆ is_code_ped4()

static bool TileRawChannel2Bytes5::is_code_ped4 ( uint32_t  code)
inlinestatic

Definition at line 80 of file TileRawChannel2Bytes5.h.

80 { return ((code & 0xF0) == code_ped4); }

◆ is_code_ped5()

static bool TileRawChannel2Bytes5::is_code_ped5 ( uint32_t  code)
inlinestatic

Definition at line 81 of file TileRawChannel2Bytes5.h.

81 { return ((code & 0xF0) == code_ped5); }

◆ is_code_rawf()

static bool TileRawChannel2Bytes5::is_code_rawf ( uint32_t  code)
inlinestatic

Definition at line 82 of file TileRawChannel2Bytes5.h.

82 { return ((code & 0x78) == code_rawf); }

◆ is_code_raws()

static bool TileRawChannel2Bytes5::is_code_raws ( uint32_t  code)
inlinestatic

Definition at line 78 of file TileRawChannel2Bytes5.h.

78 { return ((code & 0x60) == code_raws); }

◆ print_code()

static void TileRawChannel2Bytes5::print_code ( uint32_t  code)
inlinestatic

Definition at line 124 of file TileRawChannel2Bytes5.h.

125  {
126  if (code == code_ped4) printf("ped4"); else
127  if (code == code_ped5) printf("ped5"); else
128  if (code == code_amp5) printf("amp5"); else
129  if (code == code_amp6) printf("amp6"); else
130  if (code == code_raws) printf("raws"); else
131  if (code == code_rawf) printf("rawf"); else
132  if (code == code_full) printf("full"); else
133  if (code == code_dump) printf("dump"); else
134  if (code == code_null) printf("null"); else
135  printf("ERR ");
136  }

◆ setFormatLookup()

void TileRawChannel2Bytes5::setFormatLookup ( )
inline

Definition at line 157 of file TileRawChannel2Bytes5.h.

158  {
159  uint8_t fmt;
160  for (int code = 0; code < 0xFF; code++) {
161  if (is_code_null(code)) fmt = 0; else
162  if (is_code_ped4(code)) fmt = 1; else
163  if (is_code_ped5(code)) fmt = 2; else
164  if (is_code_amp5(code)) fmt = 3; else
165  if (is_code_amp6(code)) fmt = 4; else
166  if (is_code_raws(code)) fmt = 5; else
167  if (is_code_rawf(code)) fmt = 6; else
168  if (is_code_full(code)) fmt = 7; else
169  if (is_code_dump(code)) fmt = 8; else
170  fmt = 0xFF;
172  }
173  }

◆ setVerbose()

void TileRawChannel2Bytes5::setVerbose ( bool  )
inline

Sets verbose mode true or false.

Definition at line 103 of file TileRawChannel2Bytes5.h.

103 { }

◆ unpack()

void TileRawChannel2Bytes5::unpack ( const uint32_t *  ofw,
const uint32_t *  ptr_frag,
TileChanData ChanData 
) const

Definition at line 672 of file TileRawChannel2Bytes5.cxx.

673 {
674  int unit = _extu(ptr_frag[2], 0, 32 - 2); // frag_info = xx......
675  int size_L2 = _extu(ptr_frag[2], 2, 32 - 3); // frag_info = ..xxx...
676  int i, chan, code, size;
677  int gain(0), bad, ene(0), time(0), u[7];
678  const UINT32* ptr_reco = (const UINT32*) (ptr_frag + 3); // + Header
679  const unsigned char* ptr_buff = (const unsigned char*) (ptr_frag + 3 + 48 + size_L2); // + Header + Reco + Size_L2
680  const UINT32* ptr = ptr_reco;
681  UINT16 bad_bits[3];
682  UINT16 bad16 = 0;
683 
684  const unsigned char* ptr_ped4;
685  const unsigned char* ptr_ped5;
686  const unsigned char* ptr_amp5;
687  const unsigned char* ptr_amp6;
688  const unsigned char* ptr_raws;
689  const unsigned char* ptr_rawf;
690  const unsigned char* ptr_full;
691  const unsigned char* ptr_dump;
692 
693  int cnt_ped4, cnt_ped5, cnt_amp5, cnt_amp6,
694  cnt_raws, cnt_rawf, cnt_full, cnt_null, cnt_dump;
695  cnt_ped4 = cnt_ped5 = cnt_amp5 = cnt_amp6 =
696  cnt_raws = cnt_rawf = cnt_full = cnt_null = cnt_dump = 0;
697 
698  bad_bits[0] = pop_buf(&ptr_buff, 16);
699  bad_bits[1] = pop_buf(&ptr_buff, 16);
700  bad_bits[2] = pop_buf(&ptr_buff, 16);
701 
702  for (chan = 0; chan < 48; ++chan) {
703  for (i = 0; i < 7; ++i) u[i] = 0;
704  code = get_code(ptr_reco[chan]);
705  if (code == code_ped4) cnt_ped4++; else
706  if (code == code_ped5) cnt_ped5++; else
707  if (code == code_amp5) cnt_amp5++; else
708  if (code == code_amp6) cnt_amp6++; else
709  if (code == code_raws) cnt_raws++; else
710  if (code == code_rawf) cnt_rawf++; else
711  if (code == code_full) cnt_full++; else
712  if (code == code_dump) cnt_dump++; else
713  if (code == code_null) cnt_null++;
714  }
715 
716  ptr_ped4 = ptr_buff;
717  ptr_ped5 = ptr_ped4 + cnt_ped4*1; // 40 - ped4
718  ptr_amp5 = ptr_ped5 + cnt_ped5*2; // 48 - ped5
719  ptr_amp6 = ptr_amp5 + cnt_amp5*3; // 56 - amp5
720  ptr_raws = ptr_amp6 + cnt_amp6*4; // 64 - amp6
721  ptr_rawf = ptr_raws + cnt_raws*5; // 72 - raws
722  ptr_full = ptr_rawf + cnt_rawf*6; // 80 - rawf
723  ptr_dump = ptr_full + cnt_full*6; // 80 - full
724 
725  for (chan = 0; chan < 48; ++chan) {
726  if (chan % 16 == 0) bad16 = ~bad_bits[chan/16]; // note inversion here
727  bad = (bad16 & 0x1); bad16 >>= 1;
728  code = get_code(ptr_reco[chan]);
729 
730  size = 0;
731  if (code == code_ped4) size = unpack_ped (ofw, unit, chan, &ptr, &ptr_ped4, &gain, &ene, &time, u); else
732  if (code == code_ped5) size = unpack_ped (ofw, unit, chan, &ptr, &ptr_ped5, &gain, &ene, &time, u); else
733  if (code == code_amp5) size = unpack_amp (ofw, unit, chan, &ptr, &ptr_amp5, &gain, &ene, &time, u); else
734  if (code == code_amp6) size = unpack_amp (ofw, unit, chan, &ptr, &ptr_amp6, &gain, &ene, &time, u); else
735  if (code == code_raws) size = unpack_raw (ofw, unit, chan, &ptr, &ptr_raws, &gain, &ene, &time, u); else
736  if (code == code_rawf) size = unpack_raw (ofw, unit, chan, &ptr, &ptr_rawf, &gain, &ene, &time, u); else
737  if (code == code_full) size = unpack_full(ofw, chan, &ptr, &ptr_full, &gain, &ene, &time, u); else
738  if (code == code_dump) size = unpack_dump(ofw, chan, &ptr, &ptr_dump, &gain, &ene, &time, u); else
739  if (code == code_null) size = unpack_null(ofw, chan, &ptr, &gain, &ene, &time, u);
740  if (size == 0) printf("\nTileRawChannel2Bytes5::unpack ERROR size = 0\n");
741 
742  // Fill ChanData
743  ChanData[chan].code = code;
744  ChanData[chan].gain = gain;
745  ChanData[chan].bad = bad;
746  ChanData[chan].ene_bin = ene;
747  ChanData[chan].time_bin = time;
748 
749  ChanData[chan].ene = (gain) ? ene/AMPLITUDE_FACTOR5_HG[unit]
750  : ene/AMPLITUDE_FACTOR5_LG[unit];
751  ChanData[chan].time = time/2.0;
752 
753  for (i = 0; i < 7; ++i) ChanData[chan].s[i] = u[i];
754  }
755 }

◆ unpack_reco()

void TileRawChannel2Bytes5::unpack_reco ( unsigned int  w,
unsigned int  unit,
int &  fmt,
int &  gain,
double &  amp,
double &  time 
) const
inline

Unpack Frag5 reco from 32-bit word w.

Definition at line 260 of file TileRawChannel2Bytes5.h.

262 {
263  int amp_bin, time_bin;
264  if (unpack_reco_bin(w, fmt, gain, amp_bin, time_bin)) {
265  Frag5_unpack_bin2reco(unit, gain, amp_bin, amp, time_bin, time);
266  } else {
267  amp = 0.0; time = 0.0;
268  }
269 }

◆ unpack_reco_bin()

bool TileRawChannel2Bytes5::unpack_reco_bin ( unsigned int  w,
int &  fmt,
int &  gain,
int &  amp,
int &  time 
) const
inline

Definition at line 246 of file TileRawChannel2Bytes5.h.

247 {
248  uint32_t code = w >> 24;
250 
252  else {
253  gain = 0; amp = 0; time = 0;
254  printf("\nTileRawChannel2Bytes5::unpack_reco_bin.ERROR reco = %08X\n", w);
255  return false;
256  }
257  return true;
258 }

Member Data Documentation

◆ m_FormatLookup

uint8_t TileRawChannel2Bytes5::m_FormatLookup[256]

Definition at line 69 of file TileRawChannel2Bytes5.h.


The documentation for this class was generated from the following files:
bad
@ bad
Definition: SUSYToolsTester.cxx:100
TileRawChannel2Bytes5::is_code_dump
static bool is_code_dump(uint32_t code)
Definition: TileRawChannel2Bytes5.h:79
data
char data[hepevt_bytes_allocation_ATLAS]
Definition: HepEvt.cxx:11
Frag5_unpack_bin2reco
#define Frag5_unpack_bin2reco(unit, gain, amp_bin, amp, time_bin, time)
unpack_bin2reco
Definition: TileRawChannel2Bytes5.h:232
ReadCellNoiseFromCoolCompare.s1
s1
Definition: ReadCellNoiseFromCoolCompare.py:378
python.SystemOfUnits.s
int s
Definition: SystemOfUnits.py:131
vtune_athena.format
format
Definition: vtune_athena.py:14
xAOD::uint8_t
uint8_t
Definition: Muon_v1.cxx:557
TileRawChannel2Bytes5::code_raws
@ code_raws
Definition: TileRawChannel2Bytes5.h:48
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
TileRawChannel2Bytes5::code_ped4
@ code_ped4
Definition: TileRawChannel2Bytes5.h:50
TileRawChannel2Bytes5::is_code_amp6
static bool is_code_amp6(uint32_t code)
Definition: TileRawChannel2Bytes5.h:83
xAOD::uint32_t
setEventNumber uint32_t
Definition: EventInfo_v1.cxx:127
TileRawChannel2Bytes5::is_code_null
static bool is_code_null(uint32_t code)
Definition: TileRawChannel2Bytes5.h:85
Frag5_unpack_bin2sum
#define Frag5_unpack_bin2sum(unit, amp_bin)
unpack_bin2sum
Definition: TileRawChannel2Bytes5.h:240
Data
@ Data
Definition: BaseObject.h:11
CaloCondBlobAlgs_fillNoiseFromASCII.gain
gain
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:110
AMPLITUDE_FACTOR5_LG
const double AMPLITUDE_FACTOR5_LG[4]
Definition: TileRawChannel2Bytes5.h:32
NOFWORDS_WEIGHTS_7S
const int NOFWORDS_WEIGHTS_7S
Definition: TileRawChannel2Bytes5.h:36
fmt
const char *const fmt
Definition: TripleGaussCollFit.cxx:84
TileRawChannel2Bytes5::is_code_full
static bool is_code_full(uint32_t code)
Definition: TileRawChannel2Bytes5.h:84
TileRawChannel2Bytes5::code_dump
@ code_dump
Definition: TileRawChannel2Bytes5.h:49
ReadCellNoiseFromCoolCompare.s4
s4
Definition: ReadCellNoiseFromCoolCompare.py:381
dbg::ptr
void * ptr(T *p)
Definition: SGImplSvc.cxx:74
TileRawChannel2Bytes5::is_code_amp5
static bool is_code_amp5(uint32_t code)
Compression Format Code inlile functions.
Definition: TileRawChannel2Bytes5.h:77
Trk::u
@ u
Enums for curvilinear frames.
Definition: ParamDefs.h:77
TileRawChannel2Bytes5::is_code_ped5
static bool is_code_ped5(uint32_t code)
Definition: TileRawChannel2Bytes5.h:81
INT16
#define INT16
Definition: TileRawChannel2Bytes5.cxx:13
TileRawChannel2Bytes5::get_code
static int get_code(uint32_t reco)
Definition: TileRawChannel2Bytes5.h:105
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
TileRawChannel2Bytes5::is_code_rawf
static bool is_code_rawf(uint32_t code)
Definition: TileRawChannel2Bytes5.h:82
UINT32
#define UINT32
Definition: TileRawChannel2Bytes5.cxx:10
histSizes.code
code
Definition: histSizes.py:129
TileRawChannel2Bytes5::code_full
@ code_full
Definition: TileRawChannel2Bytes5.h:54
TileRawChannel2Bytes5::code_amp5
@ code_amp5
Definition: TileRawChannel2Bytes5.h:47
lumiFormat.i
int i
Definition: lumiFormat.py:85
TileRawChannel2Bytes5::m_FormatLookup
uint8_t m_FormatLookup[256]
Definition: TileRawChannel2Bytes5.h:69
ReadCellNoiseFromCool.chan
chan
Definition: ReadCellNoiseFromCool.py:52
beamspotman.n
n
Definition: beamspotman.py:731
if_Frag5_unpack_reco_bin
#define if_Frag5_unpack_reco_bin(w, code, gain, amp, time)
if_unpack_reco_bin
Definition: TileRawChannel2Bytes5.h:221
AMPLITUDE_OFFSET5
const int AMPLITUDE_OFFSET5[2]
Definition: TileRawChannel2Bytes5.h:31
TileRawChannel2Bytes5::is_code_ped4
static bool is_code_ped4(uint32_t code)
Definition: TileRawChannel2Bytes5.h:80
NOFWORDS_WEIGHTS_7S_1GAIN
const int NOFWORDS_WEIGHTS_7S_1GAIN
Definition: TileRawChannel2Bytes5.h:35
TileRawChannel2Bytes5::code_ped5
@ code_ped5
Definition: TileRawChannel2Bytes5.h:51
ReadCellNoiseFromCoolCompare.s3
s3
Definition: ReadCellNoiseFromCoolCompare.py:380
TileRawChannel2Bytes5::is_code_raws
static bool is_code_raws(uint32_t code)
Definition: TileRawChannel2Bytes5.h:78
PlotSFuncertainty.calib
calib
Definition: PlotSFuncertainty.py:110
TileRawChannel2Bytes5::setFormatLookup
void setFormatLookup()
Definition: TileRawChannel2Bytes5.h:157
TileRawChannel2Bytes5::getSum
double getSum(const uint32_t *ptr_frag, int n) const
Get SumEt, SumEz, SumE value.
Definition: TileRawChannel2Bytes5.h:271
fmt
CaloSwCorrections.time
def time(flags, cells_name, *args, **kw)
Definition: CaloSwCorrections.py:242
TileRawChannel2Bytes5::unpack_reco_bin
bool unpack_reco_bin(unsigned int w, int &fmt, int &gain, int &amp, int &time) const
Definition: TileRawChannel2Bytes5.h:246
_round
#define _round(u, k)
Definition: TileRawChannel2Bytes5.cxx:205
unit
const PlainObject unit() const
This is a plugin that makes Eigen look like CLHEP & defines some convenience methods.
Definition: AmgMatrixBasePlugin.h:21
ReadCellNoiseFromCoolCompare.s2
s2
Definition: ReadCellNoiseFromCoolCompare.py:379
AMPLITUDE_FACTOR5_HG
const double AMPLITUDE_FACTOR5_HG[4]
Definition: TileRawChannel2Bytes5.h:33
TileRawChannel2Bytes5::code_rawf
@ code_rawf
Definition: TileRawChannel2Bytes5.h:52
python.IoTestsLib.w
def w
Definition: IoTestsLib.py:200
TileRawChannel2Bytes5::code_null
@ code_null
Definition: TileRawChannel2Bytes5.h:55
UINT16
#define UINT16
Definition: TileRawChannel2Bytes5.cxx:11
ReadOfcFromCool.ofc
ofc
Definition: ReadOfcFromCool.py:110
TileRawChannel2Bytes5::code_amp6
@ code_amp6
Definition: TileRawChannel2Bytes5.h:53
MuonSegmentReaderConfig.reco
reco
Definition: MuonSegmentReaderConfig.py:133