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

enum TileRawChannel2Bytes5::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.

                    {
      code_amp5 = 0x20, //  G 0 1 .  . . . .
      code_raws = 0x40, //  G 1 0 .  . . . .
      code_dump = 0x60, //  G 1 1 .  . . . .
      code_ped4 = 0x10, //  0 0 0 1  . . . .
      code_ped5 = 0x90, //  1 0 0 1  . . . .
      code_rawf = 0x08, //  G 0 0 0  1 . . .
      code_amp6 = 0x04, //  G 0 0 0  0 1 . .
      code_full = 0x01, //  G 0 0 0  0 0 0 1
      code_null = 0x00  //  0 0 0 0  0 0 0 0
    };

Constructor & Destructor Documentation

TileRawChannel2Bytes5()

TileRawChannel2Bytes5::TileRawChannel2Bytes5 ( )

inline

Definition at line 71 of file TileRawChannel2Bytes5.h.

    {
      setFormatLookup();
    }

Member Function Documentation

amplitude()

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

Definition at line 623 of file TileRawChannel2Bytes5.cxx.

{
 
  UINT32 calib, calib_coeff;
  INT16 calib_scale;
  int amp, ene, ene0, ene_shift;
  //INT16 amp2;
  const UINT32* ofc;
 
  int FRACBITS_MINUS_11 = _sadd(OF_E_FRACBITS[unit], 11);
 
  int s1 = s[0], s2 = s[1], s3 = s[2], s4 = s[3], s5 = s[4], s6 = s[5], s7 = s[6];
 
  // samples
  UINT32 s1x = _pack2(s1, gain << 15);
  UINT32 s32 = _pack2(s3, s2);
  UINT32 s54 = _pack2(s5, s4);
  UINT32 s76 = _pack2(s7, s6);
 
  ene_shift = 512 + _mpy(gain, 2048 - 512);
 
  ofc = ofw + chan*NOFWORDS_WEIGHTS_7S + gain*NOFWORDS_WEIGHTS_7S_1GAIN;
 
  // amp coeff
  UINT32 a1x = ofc[0];
  UINT32 a32 = ofc[1];
  UINT32 a54 = ofc[2];
  UINT32 a76 = ofc[3];
  //UINT16 a_scale = _extu(a1x, 16, 16);
 
  amp = _mpyh (a1x, s1x)
      + _dotp2(a32, s32)
      + _dotp2(a54, s54)
      + _dotp2(a76, s76);
 
  // calib
  calib = ofc[4];
 
  calib_coeff = _ext(calib, 0, 16);
  calib_scale = _ssub(_extu(calib, 16, 16) , FRACBITS_MINUS_11);
  ene0 = _round(amp, 11);
  ene0 = _round(ene0*calib_coeff, calib_scale);
  ene = ene0 + ene_shift;
 
  return ene;
}

check_raw()

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

Definition at line 756 of file TileRawChannel2Bytes5.cxx.

{
  bool OK = true;
  int chan, i;
  int gain, ene, u[7], s[7];
  const UINT32* data = feb + 3;
  for (chan = 0; chan < 48; ++chan) {
    bool chOK = true;
    //code = Data[chan].code;
    //bad  = Data[chan].bad;
    gain = Data[chan].gain;
    ene  = Data[chan].ene_bin;
    //time = Data[chan].time_bin;
 
    for (i = 0; i < 7; ++i) u[i] = Data[chan].s[i];
        {
      //double s1x32 = _memd8(data + chan*4);
      //double s5476 = _memd8(data + chan*4 + 2);
      UINT32 s1x = data[chan*4 + 0]; //_hi(s1x32);
      UINT32 s32 = data[chan*4 + 1]; //_lo(s1x32);
      UINT32 s54 = data[chan*4 + 2]; //_hi(s5476);
      UINT32 s76 = data[chan*4 + 3]; //_lo(s5476);
      s[1-1] = _extu(s1x,  0, 16);
      s[2-1] = _extu(s32, 16, 16);
      s[3-1] = _extu(s32,  0, 16);
      s[4-1] = _extu(s54, 16, 16);
      s[5-1] = _extu(s54,  0, 16);
      s[6-1] = _extu(s76, 16, 16);
      s[7-1] = _extu(s76,  0, 16);
    }
 
    for (i = 0; i < 7; ++i) {
      if (s[i] != u[i]) chOK = false;
    }
    if (!chOK) { printf("\n %d: Raw Data ERROR", chan); }
 
    ene += (gain == 0 ? 512 : 2048);
 
    if (of_energy[chan] != ene) {
      OK = false;
      printf("\n %d : amp error ene: %d  e_t_amp: %d\n", chan, ene, of_energy[chan]);
    }
 
    if (!chOK) {
      OK = false;
      printf("\n %2d ERROR", chan);
    }
  }
  printf("\nunpack_data");
  if (OK) printf(" OK"); else printf(" ERROR");
  printf("  ");
  return OK;
}

check_reco()

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

Definition at line 810 of file TileRawChannel2Bytes5.cxx.

{
  int chan;
  bool OK = true;
  int bad, gain, amp, ene, time;
  const UINT32* reco = (frag + 3); // + Header
  UINT32 w;
 
  for (chan = 0; chan < 48; ++chan) {
    w = reco[chan];
 
    if (!unpack_reco_bin(w, bad, gain, amp, time)) {
      printf("\nTileRawChannel2Bytes5::unpack_reco_bin ERROR\n");
      OK = false;  
    }
 
    ene = amp + AMPLITUDE_OFFSET5[gain];
 
    if (of_energy[chan] != ene) {
      OK = false;
      //printf("\n  "); print_code(code);
      //printf(" amp error ene: %d  e_t_amp: %d", amp, of_energy[chan]);
    }
  } // for
 
  return OK;
}

get_code()

int TileRawChannel2Bytes5::get_code ( uint32_t reco )

inlinestatic

Definition at line 105 of file TileRawChannel2Bytes5.h.

    {
      int code = reco >> 24;
 
      if (is_code_null(code)) code = code_null; else
      if (is_code_ped4(code)) code = code_ped4; else
      if (is_code_ped5(code)) code = code_ped5; else
      if (is_code_amp5(code)) code = code_amp5; else
      if (is_code_amp6(code)) code = code_amp6; else
      if (is_code_raws(code)) code = code_raws; else
      if (is_code_rawf(code)) code = code_rawf; else
      if (is_code_full(code)) code = code_full; else
      if (is_code_dump(code)) code = code_dump; else {
        printf("\nTileRawChannel2Bytes5::get_code ERROR\n");
        code = -1;
      }
      return code;
    }

get_format()

int TileRawChannel2Bytes5::get_format ( int code ) const

inline

Definition at line 154 of file TileRawChannel2Bytes5.h.

{ return m_FormatLookup[code & 0xFF]; }

get_quality()

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

inlinestatic

Definition at line 155 of file TileRawChannel2Bytes5.h.

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

get_size_code()

int TileRawChannel2Bytes5::get_size_code ( uint32_t code )

inlinestatic

Definition at line 138 of file TileRawChannel2Bytes5.h.

    {
      int size = 0;
      if (is_code_null(code)) size = 32; else
      if (is_code_ped4(code)) size = 40; else
      if (is_code_ped5(code)) size = 48; else
      if (is_code_amp5(code)) size = 56; else
      if (is_code_amp6(code)) size = 64; else
      if (is_code_raws(code)) size = 72; else
      if (is_code_rawf(code)) size = 80; else
      if (is_code_full(code)) size = 80; else
      if (is_code_dump(code)) size = 88;
 
      return size/8;
    }

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.

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

getSumE()

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

inline

Definition at line 280 of file TileRawChannel2Bytes5.h.

{ return getSum(ptr_frag, 2); }

getSumEt()

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

inline

Definition at line 278 of file TileRawChannel2Bytes5.h.

{ return getSum(ptr_frag, 0); }

getSumEz()

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

inline

Definition at line 279 of file TileRawChannel2Bytes5.h.

{ return getSum(ptr_frag, 1); }

is_code_amp()

bool TileRawChannel2Bytes5::is_code_amp ( uint32_t code )

inlinestatic

Definition at line 88 of file TileRawChannel2Bytes5.h.

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

is_code_amp5()

bool TileRawChannel2Bytes5::is_code_amp5 ( uint32_t code )

inlinestatic

Compression Format Code inlile functions.

Definition at line 77 of file TileRawChannel2Bytes5.h.

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

is_code_amp6()

bool TileRawChannel2Bytes5::is_code_amp6 ( uint32_t code )

inlinestatic

Definition at line 83 of file TileRawChannel2Bytes5.h.

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

is_code_amp_raw_dump()

bool TileRawChannel2Bytes5::is_code_amp_raw_dump ( uint32_t code )

inlinestatic

Definition at line 89 of file TileRawChannel2Bytes5.h.

{ return (code & 0x6C); }

is_code_dump()

bool TileRawChannel2Bytes5::is_code_dump ( uint32_t code )

inlinestatic

Definition at line 79 of file TileRawChannel2Bytes5.h.

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

is_code_full()

bool TileRawChannel2Bytes5::is_code_full ( uint32_t code )

inlinestatic

Definition at line 84 of file TileRawChannel2Bytes5.h.

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

is_code_null()

bool TileRawChannel2Bytes5::is_code_null ( uint32_t code )

inlinestatic

Definition at line 85 of file TileRawChannel2Bytes5.h.

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

is_code_ped()

bool TileRawChannel2Bytes5::is_code_ped ( uint32_t code )

inlinestatic

Definition at line 87 of file TileRawChannel2Bytes5.h.

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

is_code_ped4()

bool TileRawChannel2Bytes5::is_code_ped4 ( uint32_t code )

inlinestatic

Definition at line 80 of file TileRawChannel2Bytes5.h.

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

is_code_ped5()

bool TileRawChannel2Bytes5::is_code_ped5 ( uint32_t code )

inlinestatic

Definition at line 81 of file TileRawChannel2Bytes5.h.

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

is_code_rawf()

bool TileRawChannel2Bytes5::is_code_rawf ( uint32_t code )

inlinestatic

Definition at line 82 of file TileRawChannel2Bytes5.h.

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

is_code_raws()

bool TileRawChannel2Bytes5::is_code_raws ( uint32_t code )

inlinestatic

Definition at line 78 of file TileRawChannel2Bytes5.h.

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

print_code()

void TileRawChannel2Bytes5::print_code ( uint32_t code )

inlinestatic

Definition at line 124 of file TileRawChannel2Bytes5.h.

    {
      if (code == code_ped4) printf("ped4"); else
      if (code == code_ped5) printf("ped5"); else
      if (code == code_amp5) printf("amp5"); else
      if (code == code_amp6) printf("amp6"); else
      if (code == code_raws) printf("raws"); else
      if (code == code_rawf) printf("rawf"); else
      if (code == code_full) printf("full"); else
      if (code == code_dump) printf("dump"); else
      if (code == code_null) printf("null"); else
        printf("ERR ");
    }

setFormatLookup()

void TileRawChannel2Bytes5::setFormatLookup ( )

inline

Definition at line 157 of file TileRawChannel2Bytes5.h.

    {
      uint8_t fmt;
      for (int code = 0; code < 0xFF; code++) {
        if (is_code_null(code)) fmt = 0; else
        if (is_code_ped4(code)) fmt = 1; else
        if (is_code_ped5(code)) fmt = 2; else
        if (is_code_amp5(code)) fmt = 3; else
        if (is_code_amp6(code)) fmt = 4; else
        if (is_code_raws(code)) fmt = 5; else
        if (is_code_rawf(code)) fmt = 6; else
        if (is_code_full(code)) fmt = 7; else
        if (is_code_dump(code)) fmt = 8; else
          fmt = 0xFF;
        m_FormatLookup[code] = fmt;
      }
    }

setVerbose()

void TileRawChannel2Bytes5::setVerbose ( bool )

inline

Sets verbose mode true or false.

Definition at line 103 of file TileRawChannel2Bytes5.h.

{  }  

unpack()

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

Definition at line 671 of file TileRawChannel2Bytes5.cxx.

{
  int unit    = _extu(ptr_frag[2], 0, 32 - 2); // frag_info = xx......
  int size_L2 = _extu(ptr_frag[2], 2, 32 - 3); // frag_info = ..xxx...
  int i, chan, code, size;
  int gain(0), bad, ene(0), time(0), u[7];
  const UINT32* ptr_reco = ptr_frag + 3; // + Header
  const unsigned char* ptr_buff = reinterpret_cast<const unsigned char*> (ptr_frag + 3 + 48 + size_L2); // + Header + Reco + Size_L2
  const UINT32* ptr = ptr_reco;
  UINT16 bad_bits[3];
  UINT16 bad16 = 0;
 
  const unsigned char* ptr_ped4;
  const unsigned char* ptr_ped5;
  const unsigned char* ptr_amp5;
  const unsigned char* ptr_amp6;
  const unsigned char* ptr_raws;
  const unsigned char* ptr_rawf;
  const unsigned char* ptr_full;
  const unsigned char* ptr_dump;
 
  int cnt_ped4, cnt_ped5, cnt_amp5, cnt_amp6, 
      cnt_raws, cnt_rawf, cnt_full, cnt_null, cnt_dump;
  cnt_ped4 = cnt_ped5 = cnt_amp5 = cnt_amp6 = 
  cnt_raws = cnt_rawf = cnt_full = cnt_null = cnt_dump = 0;
  
  bad_bits[0] = pop_buf(&ptr_buff, 16);
  bad_bits[1] = pop_buf(&ptr_buff, 16);
  bad_bits[2] = pop_buf(&ptr_buff, 16);
 
  for (chan = 0; chan < 48; ++chan) {
    for (i = 0; i < 7; ++i) u[i] = 0;
    code = get_code(ptr_reco[chan]);
    if (code == code_ped4) cnt_ped4++; else
    if (code == code_ped5) cnt_ped5++; else
    if (code == code_amp5) cnt_amp5++; else
    if (code == code_amp6) cnt_amp6++; else
    if (code == code_raws) cnt_raws++; else
    if (code == code_rawf) cnt_rawf++; else
    if (code == code_full) cnt_full++; else
    if (code == code_dump) cnt_dump++; else
    if (code == code_null) cnt_null++;
  }
 
  ptr_ped4 = ptr_buff;
  ptr_ped5 = ptr_ped4 + cnt_ped4*1; // 40 - ped4
  ptr_amp5 = ptr_ped5 + cnt_ped5*2; // 48 - ped5
  ptr_amp6 = ptr_amp5 + cnt_amp5*3; // 56 - amp5
  ptr_raws = ptr_amp6 + cnt_amp6*4; // 64 - amp6
  ptr_rawf = ptr_raws + cnt_raws*5; // 72 - raws
  ptr_full = ptr_rawf + cnt_rawf*6; // 80 - rawf
  ptr_dump = ptr_full + cnt_full*6; // 80 - full
 
  for (chan = 0; chan < 48; ++chan) {
    if (chan % 16 == 0) bad16 = ~bad_bits[chan/16]; // note inversion here
    bad = (bad16 & 0x1); bad16 >>= 1;
    code = get_code(ptr_reco[chan]);
 
    size = 0;
    if (code == code_ped4) size = unpack_ped (ofw, unit, chan, &ptr, &ptr_ped4, &gain, &ene, &time, u); else
    if (code == code_ped5) size = unpack_ped (ofw, unit, chan, &ptr, &ptr_ped5, &gain, &ene, &time, u); else
    if (code == code_amp5) size = unpack_amp (ofw, unit, chan, &ptr, &ptr_amp5, &gain, &ene, &time, u); else
    if (code == code_amp6) size = unpack_amp (ofw, unit, chan, &ptr, &ptr_amp6, &gain, &ene, &time, u); else
    if (code == code_raws) size = unpack_raw (ofw, unit, chan, &ptr, &ptr_raws, &gain, &ene, &time, u); else
    if (code == code_rawf) size = unpack_raw (ofw, unit, chan, &ptr, &ptr_rawf, &gain, &ene, &time, u); else
    if (code == code_full) size = unpack_full(ofw,       chan, &ptr, &ptr_full, &gain, &ene, &time, u); else
    if (code == code_dump) size = unpack_dump(ofw,       chan, &ptr, &ptr_dump, &gain, &ene, &time, u); else
    if (code == code_null) size = unpack_null(ofw,       chan, &ptr,            &gain, &ene, &time, u);
    if (size == 0) printf("\nTileRawChannel2Bytes5::unpack ERROR size = 0\n");
 
    // Fill ChanData
    ChanData[chan].code    = code;
    ChanData[chan].gain    = gain;
    ChanData[chan].bad     = bad;
    ChanData[chan].ene_bin = ene;
    ChanData[chan].time_bin = time;
 
    ChanData[chan].ene = (gain) ? ene/AMPLITUDE_FACTOR5_HG[unit]
                                : ene/AMPLITUDE_FACTOR5_LG[unit];
    ChanData[chan].time = time/2.0;
 
    for (i = 0; i < 7; ++i) ChanData[chan].s[i] = u[i];
  }
}

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.

{
  int amp_bin, time_bin;
  if (unpack_reco_bin(w, fmt, gain, amp_bin, time_bin)) {
    Frag5_unpack_bin2reco(unit, gain, amp_bin, amp, time_bin, time);
  } else {
    amp = 0.0; time = 0.0;
  }
}

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.

{
  uint32_t code = w >> 24;
  fmt = m_FormatLookup[code];
 
  if_Frag5_unpack_reco_bin(w, code, gain, amp, time)
  else {
    gain = 0; amp = 0; time = 0;
    printf("\nTileRawChannel2Bytes5::unpack_reco_bin.ERROR reco = %08X\n", w);
    return false;
  }
  return true;
}

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:

• TileRawChannel2Bytes5.h
• TileRawChannel2Bytes5.cxx