TileROD_Encoder Class Reference

Provides conversion from TileRawChannel, TileL2 and TMDB (digits,MF raw channel,decision) to ROD format. More...

#include <TileROD_Encoder.h>

Inheritance diagram for TileROD_Encoder:

Public Member Functions
	TileROD_Encoder ()
	constructor
void	setTileHWID (const TileHWID *tileHWID, bool verbose, unsigned int type=4)
	set all necessary parameters for the encoder
void	setTileHWID (const TileHWID *tileHWID, int m_runPeriod)
void	setTypeAndUnit (TileFragHash::TYPE type, TileRawChannelUnit::UNIT unit)
	set OF algorigtm type and amplitude units for a drawer
void	setMaxChannels (int maxChannels)
	set maximum number of channels in a drawer
	~TileROD_Encoder ()
	destructor
void	add (const TileFastRawChannel *rc)
	add TileRawChannels to the current list
void	addL2 (const TileL2 *l2)
	add TileL2s to the current list
void	addTileMuRcvObj (const TileMuonReceiverObj *tileMuRcvObj)
	add TMBDs ROD sub-fragmens TileMuRcvObj (type3) to the current list
void	addDigi (const TileDigits *digi)
	add TileDigits to the current list
void	fillROD (std::vector< uint32_t > &v)
	convert all TileRawChannels in the current list to a vector of 32bit words
void	fillROD2 (std::vector< uint32_t > &v)
void	fillROD3 (std::vector< uint32_t > &v)
void	fillROD4 (std::vector< uint32_t > &v)
void	fillROD5 (std::vector< uint32_t > &v)
void	fillROD10 (std::vector< uint32_t > &v)
	convert all TileL2s in the current list to a vector of 32bit words
void	fillROD12 (std::vector< uint32_t > &v)
void	fillRODL2 (std::vector< uint32_t > &v)
void	fillROD1 (std::vector< uint32_t > &v)
	convert all TileDigits in the current list to a vector of 32bit words
void	fillROD5D (std::vector< uint32_t > &v)
void	fillRODTileMuRcvDigi (std::vector< uint32_t > &v)
	convert the TMDB objects into a vector of 32bit words: 8bit words/digit, 16bit words/RC, 16bit words/decision
void	fillRODTileMuRcvRawChannel (std::vector< uint32_t > &v)
void	fillRODTileMuRcvObj (std::vector< uint32_t > &v)
void	dumpROD (const std::vector< uint32_t > &v)
	dump contents of the ROD fragment
bool	msgLvl (const MSG::Level lvl) const
	Test the output level.
MsgStream &	msg () const
	The standard message stream.
MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream.
void	setLevel (MSG::Level lvl)
	Change the current logging level.

Private Member Functions
void	setBit (uint32_t *p, int chan)
	set the bitmap for a channel
bool	checkBit (const uint32_t *p, int chan)
	check the bitmap for a channel
void	initMessaging () const
	Initialize our message level and MessageSvc.

Private Attributes
std::vector< const TileFastRawChannel * >	m_vTileRC
std::vector< const TileL2 * >	m_vTileL2
std::vector< const TileDigits * >	m_vTileDigi
std::vector< const TileMuonReceiverObj * >	m_vTileMuRcvObj
TileDigits2Bytes	m_Digi2bytes
TileRawChannel2Bytes2	m_rc2bytes2
TileRawChannel2Bytes	m_rc2bytes3
TileRawChannel2Bytes4	m_rc2bytes4
TileRawChannel2Bytes5	m_rc2bytes5
const TileHWID *	m_tileHWID
TileRawDataOrdering	m_order
bool	m_verbose
unsigned int	m_type
unsigned int	m_unitType
unsigned int	m_rChUnit
int	m_maxChannels
int	m_runPeriod
std::string	m_nm
	Message source name.
boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels)
std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer.
std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level.
std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging)

Detailed Description

Provides conversion from TileRawChannel, TileL2 and TMDB (digits,MF raw channel,decision) to ROD format.

Author

A. Solodkov

Version

0-0-1 , Oct 17, 2002

Modified, Jan 20, 2003 Split from TileROD_Decoder.

Definition at line 44 of file TileROD_Encoder.h.

Constructor & Destructor Documentation

TileROD_Encoder()

TileROD_Encoder::TileROD_Encoder

(

)

constructor

Definition at line 56 of file TileROD_Encoder.cxx.

                                : 
  AthMessaging ("TileROD_Encoder"),
  m_tileHWID(0), 
  m_verbose(false), 
  m_type(0), 
  m_unitType(0),
  m_rChUnit(0),
  m_maxChannels(TileCalibUtils::MAX_CHAN),
  m_runPeriod(0){
}

~TileROD_Encoder()

TileROD_Encoder::~TileROD_Encoder ( )

inline

destructor

Definition at line 69 of file TileROD_Encoder.h.

{ }

Member Function Documentation

add()

void TileROD_Encoder::add ( const TileFastRawChannel * rc )

inline

add TileRawChannels to the current list

Definition at line 73 of file TileROD_Encoder.h.

{ m_vTileRC.push_back(rc); }

addDigi()

void TileROD_Encoder::addDigi ( const TileDigits * digi )

inline

add TileDigits to the current list

Definition at line 85 of file TileROD_Encoder.h.

{ m_vTileDigi.push_back(digi); }

addL2()

void TileROD_Encoder::addL2 ( const TileL2 * l2 )

inline

add TileL2s to the current list

Definition at line 77 of file TileROD_Encoder.h.

{ m_vTileL2.push_back(l2); }

addTileMuRcvObj()

void TileROD_Encoder::addTileMuRcvObj ( const TileMuonReceiverObj * tileMuRcvObj )

inline

add TMBDs ROD sub-fragmens TileMuRcvObj (type3) to the current list

Definition at line 81 of file TileROD_Encoder.h.

{ m_vTileMuRcvObj.push_back(tileMuRcvObj); } // decision (d6 and d5+d6) calculated @ TMDB

checkBit()

bool TileROD_Encoder::checkBit ( const uint32_t * p, int chan )

private

check the bitmap for a channel

Definition at line 965 of file TileROD_Encoder.cxx.

                                                          {
// chan = (0,47)   
  int a = chan / 32;
  int r = chan % 32;
// a = (0,1), r = ( 0, 31 )
  return *(p + a) & (1 << r);
 
}

dumpROD()

void TileROD_Encoder::dumpROD

(

const std::vector< uint32_t > &

v

)

dump contents of the ROD fragment

Definition at line 974 of file TileROD_Encoder.cxx.

                                                          {
  msg(MSG::VERBOSE) << " Dump of Tile ROD block, size =  " << v.size() << endmsg;
 
  int count = 0, newCount = 3;
  for (const uint32_t data : v) {
    if (count == 0) {
      msg(MSG::VERBOSE) << "Frag delim = 0x" << std::hex << data << std::dec << endmsg;
    } else if (count == -1) {
      newCount = data;
      msg(MSG::VERBOSE) << "Word count = " << newCount << endmsg;
    } else if (count == -2) {
      count += newCount;
      msg(MSG::VERBOSE) << "Frag ID = 0x" << std::hex << data << std::dec << endmsg;
    } else {
      msg(MSG::VERBOSE) << " WORD[" << newCount - count << "] = "
                        << data << " = 0x" << std::hex << data
                        << std::dec << endmsg;
    }
    --count;
  }
}

fillROD()

void TileROD_Encoder::fillROD

(

std::vector< uint32_t > &

v

)

convert all TileRawChannels in the current list to a vector of 32bit words

Definition at line 140 of file TileROD_Encoder.cxx.

                                                    {
  switch (m_type) {
    case 4:
      fillROD4(v);
      break;
    case 5:
      fillROD5(v);
      break;
    case 3:
      fillROD3(v);
      break;
    case 2:
      fillROD2(v);
      break;
    case 1:
      fillROD1(v);
      break;
    case 0x10:
      fillROD10(v);
      break;
    case 0x12:
      fillROD12(v);
      break;
    default:
      ATH_MSG_ERROR( "fillROD -> Unknown packing type " << m_type );
      assert(0);
      break;
      // return;
  }
}

fillROD1()

void TileROD_Encoder::fillROD1

(

std::vector< uint32_t > &

v

)

convert all TileDigits in the current list to a vector of 32bit words

Definition at line 494 of file TileROD_Encoder.cxx.

                                                     {
 
  std::sort(m_vTileDigi.begin(), m_vTileDigi.end(), m_order);
 
  int currentFrag = -1, pos = 0, size = 0;
  for (const TileDigits* digi : m_vTileDigi) {
    
    HWIdentifier adcID = digi->adc_HWID();
    int frag = m_tileHWID->frag(adcID) | (0x01 << 16); // FRAG TYPE = 1 in upper half of the word
    if (frag != currentFrag) {
      if (currentFrag != -1) v[pos] = size;
      currentFrag = frag;
      // first word is start of fragment identifier
      v.push_back(0xFF1234FF);
      // next word is frag size
      pos = v.size();
      v.push_back(0);
      // next word is frag ID
      v.push_back(frag);
      size = 3;
    }
    size += m_Digi2bytes.getBytes(digi, m_tileHWID, v);
  }
  if (currentFrag != -1) v[pos] = size;
  return;
}

fillROD10()

void TileROD_Encoder::fillROD10

(

std::vector< uint32_t > &

v

)

convert all TileL2s in the current list to a vector of 32bit words

Definition at line 172 of file TileROD_Encoder.cxx.

                                                      {
 
  int currentFrag(-1);
  std::vector<uint32_t>::size_type start = 0;
 
  int NMuons1 = 0, NMuons2 = 0, frag = 0;
 
  for (const TileL2* l2 : m_vTileL2) {
 
    int ros = ((l2->identify()) | 0xff) >> 8;
    int drawer = (l2->identify()) & 0xff;
 
    if ((drawer % 2) == 0) frag = 0x00100000 + (ros << 12) + ((drawer + 1) << 6) + drawer;
 
    if (frag != currentFrag) { // superdrawer is even
 
      currentFrag = frag;
 
      // fragment marker
      v.push_back(0xff1234ff);
 
      // fragment size (variable depending on the number of muons found)
      v.push_back(5);
 
      // fragment ID
      v.push_back(frag);
 
      // first word after fragment header
      start = v.size();
 
      // reserve 2 words for Et
      for (int i = 0; i < 2; ++i)
        v.push_back(0);
 
      // Et superdrawer #1
      int wet = (int) round(l2->sumEt());
      v[start] = (unsigned int) (wet + 9000); // shift by 9000 to be compatible with frag 0x10 format
 
      // MTag superdrawer #1
      NMuons1 = l2->NMuons();
      for (int i = 0; i < 2 * NMuons1; ++i)
        v.push_back(l2->val(i));
 
    } else { // superdrawer is odd
 
      // Et superdrawer #2
      int wet = (int) round(l2->sumEt());
      v[start + 1] = (unsigned int) (wet + 9000); // shift by 9000 to be compatible with frag 0x10 format
 
      // MTag superdrawer #2
      NMuons2 = l2->NMuons();
      for (int i = 0; i < 2 * NMuons2; ++i)
        v.push_back(l2->val(i));
 
      // re-write fragment size
      // start should be >= 3 here, but coverity can't prove it.
      //coverity[INTEGER_OVERFLOW]
      v[start - 2] = 5 + 2 * NMuons1 + 2 * NMuons2;
 
    }
 
  }
 
  //assert(0);
}

fillROD12()

void TileROD_Encoder::fillROD12

(

std::vector< uint32_t > &

v

)

Definition at line 238 of file TileROD_Encoder.cxx.

                                                      {
 
  int currentFrag(-1);
  std::vector<uint32_t>::size_type start = 0;
 
  int frag = 0;
 
  for (const TileL2* l2 : m_vTileL2) {
 
    int ros = (l2->identify()) >> 8;
    int drawer = (l2->identify()) & 0xff;
 
    if ((drawer % 2) == 0)
      frag = 0x120000 + (ros << 12) + ((drawer + 1) << 6) + drawer;
    else
      frag = 0x120000 + (ros << 12) + (drawer << 6) + (drawer - 1);
 
    if (frag != currentFrag) { // superdrawer is even
 
      currentFrag = frag;
 
      // fragment marker
      v.push_back(0xff1234ff);
 
      // fragment size (variable depending on the number of muons found)
      v.push_back(3);
 
      // fragment ID
      v.push_back(frag);
 
      // first word after fragment header
      start = v.size();
    }
 
    // MTag data
    int Ndata = l2->Ndata();
    if (Ndata) {
      for (int i = 0; i < Ndata; ++i)
        v.push_back(l2->val(i));
 
      // re-write fragment size
      // start should be >= 3 here, but coverity can't prove it.
      //coverity[INTEGER_OVERFLOW]
      v[start - 2] += Ndata;
    }
  }
 
  //assert(0);
}

fillROD2()

void TileROD_Encoder::fillROD2

(

std::vector< uint32_t > &

v

)

Definition at line 288 of file TileROD_Encoder.cxx.

                                                     {
  //std::sort(m_vTileRC.begin(), m_vTileRC.end(), m_order);
 
  int currentFrag(-1);
  std::vector<uint32_t>::size_type start = 0;
 
  for (const TileFastRawChannel* rc : m_vTileRC) {
 
    int frag = rc->frag() | m_unitType; // FRAG TYPE in upper half of the word
 
    if (frag != currentFrag) {
      currentFrag = frag;
 
      // very first word is size of the fragment, which is 50 words
      v.push_back(50);
      // next word is frag ID
      v.push_back(frag);
 
      // remember where is the first channel
      start = v.size();
      // reserve maximum number of channels in a drawer words 
      // for all channels in the drawer
      v.resize(start + m_maxChannels, 0);
 
    }
 
    // FIXME:: protection against both low and high gain amplitude
    // for the same raw channel,
    // if this is the case all channels should have both
    // low and high gain and we should use different fragment type
 
    int chan = rc->channel();
    int gain = rc->adc();
    if (chan < m_maxChannels) {
      v[start + chan] = m_rc2bytes2.getWord(rc, gain);
    }
 
  } // end of all TileRawChannel
 
  // dumpROD (v) ;
 
  return;
}

fillROD3()

void TileROD_Encoder::fillROD3

(

std::vector< uint32_t > &

v

)

Definition at line 332 of file TileROD_Encoder.cxx.

                                                     {
  ShortVecAdapter v16 (v);
 
  //std::sort(m_vTileRC.begin(), m_vTileRC.end(), m_order); 
 
  int currentFrag(-1);
  bool first = true;
  std::vector<uint32_t>::size_type head = 0;
  std::vector<uint32_t>::size_type count = 0;
 
  std::vector<short> vshort;
 
  for (const TileFastRawChannel* rc : m_vTileRC) {
 
 
    int frag = rc->frag() | m_unitType; // FRAG TYPE in upper half of the word
    int chan = rc->channel();
    int gain = rc->adc();
 
    if (frag != currentFrag) {
      currentFrag = frag;
      // a new frag
      if (!first) {
        // close the current frag
        v16.align();
        // inclusive word (32bit) for this frag
        v[count] = v.size();
      } else
        first = false;
 
      // very first word is size of the fragment
      // remember where it is
      count = v.size();
      v.push_back(0);
      //  add frag ID
      v.push_back(frag);
 
      // remember where map starts
      head = v.size();
      // 2 words (64 bits) for channel map
      v.push_back(0);
      v.push_back(0);
    }
 
    // FIXME:: protection against both low and high gain amplitude
    // for the same raw channel,
    // if this is the case all channels should have both
    // low and high gain and we should use different fragment type
 
    if (checkBit(&(v[head]), chan)) {
      // the same channel with another gain already exists, ignore second one
    } else {
      vshort.clear();
      m_rc2bytes3.getBytes(rc, gain, vshort);
      for (short x : vshort)
        v16.push_back (x);
      // set bitmap for this channel
      setBit(&(v[head]), chan);
    }
 
  } // end of all TileRawChannel
 
  if (!first) {
    // close the last Frag
    v16.align();
    // inclusive word (32bit) for this frag
    v[count] = v.size();
  }
 
  // dumpROD (v) ;
 
  return;
}

fillROD4()

void TileROD_Encoder::fillROD4

(

std::vector< uint32_t > &

v

)

Definition at line 406 of file TileROD_Encoder.cxx.

                                                     {
  //std::sort(m_vTileRC.begin(), m_vTileRC.end(), m_order);
 
  int currentFrag(-1);
  std::vector<uint32_t>::size_type start = 0;
 
  for (const TileFastRawChannel* rc : m_vTileRC) {
 
    int frag = rc->frag() | m_unitType; // FRAG TYPE in upper half of the word
 
    if (frag != currentFrag) {
      currentFrag = frag;
 
      // very first word is start fragment identifier
      v.push_back(0xff1234ff);
      // next word is frag size: 
      // (maximum number of channels in a drawer) + ...
      // ... + (6 = start frag + frag size + frag ID + 3 sumE words)
      v.push_back(m_maxChannels + 6);
      // next word is frag ID
      v.push_back(frag);
 
      // remember where is the first channel
      start = v.size();
 
      // reserve (maximum number of channels in a drawer) words 
      // for all channels in the drawer and 3 sumE words
      v.resize(start + m_maxChannels + 3, 0);
 
    }
 
    // FIXME:: protection against both low and high gain amplitude
    // for the same raw channel,
    // if this is the case all channels should have both
    // low and high gain and we should use different fragment type
 
    int chan = rc->channel();
    int gain = rc->adc();
    if (chan < m_maxChannels) {
      v[start + chan] = m_rc2bytes4.getWord(*rc, m_rChUnit, gain);
    }
 
  } // end of all TileRawChannel
 
  // dumpROD (v) ;
 
  return;
}

fillROD5()

void TileROD_Encoder::fillROD5

(

std::vector< uint32_t > &

v

)

Definition at line 521 of file TileROD_Encoder.cxx.

                                                     {
  ATH_MSG_ERROR( "fillROD5 -> store raw channels in frag5 - not yet implemented " );
}

fillROD5D()

void TileROD_Encoder::fillROD5D

(

std::vector< uint32_t > &

v

)

Definition at line 525 of file TileROD_Encoder.cxx.

                                                      {
  ATH_MSG_ERROR( "fillROD5D -> store digits in frag5 - not yet implemented " );
}

fillRODL2()

void TileROD_Encoder::fillRODL2

(

std::vector< uint32_t > &

v

)

Definition at line 455 of file TileROD_Encoder.cxx.

                                                      {
 
  std::map<int, const TileL2*> l2_map;
 
  for (const TileL2* l2 : m_vTileL2) {
    l2_map[l2->identify()] = l2;
    //std::cout << "l2 id=0x"<<std::hex<<l2->identify()<<std::dec<<std::endl;
  }
 
  std::vector<uint32_t>::size_type start = 3;
 
  while (start <= v.size()) {
    uint32_t size = v[start - 2];
    uint32_t fragtype = v[start - 1];
    int type = (fragtype >> 16) & 0xFF;
    //std::cout <<std::hex<<"frag 0x"<<fragtype<<std::dec<<" size "<<size<<std::endl;
    if ((type == 4 && size > 53) || (type == 5 && ((fragtype >> 27) & 7) > 2)) {
      int frag = fragtype & 0xFFFF;
      std::map<int, const TileL2*>::const_iterator l2_it = l2_map.find(frag);
      if (l2_it != l2_map.end()) {
        int unit = (fragtype >> 30);
        const TileL2* l2 = l2_it->second;
        int et = round(l2->sumEt() * AMPLITUDE_FACTOR5_HG[unit]);
        v[start + 48] = (uint32_t) et;
        int ez = round(l2->sumEz() * AMPLITUDE_FACTOR5_HG[unit]);
        v[start + 49] = (uint32_t) ez;
        int e = round(l2->sumE() * AMPLITUDE_FACTOR5_HG[unit]);
        v[start + 50] = (uint32_t) e;
        //std::cout << "Found "<<et<<","<<ez<<","<<e<<std::endl;
      }
    }
    start += size;
  }
 
  if (msgLvl(MSG::VERBOSE)) dumpROD(v);
 
  return;
}

fillRODTileMuRcvDigi()

void TileROD_Encoder::fillRODTileMuRcvDigi

(

std::vector< uint32_t > &

v

)

convert the TMDB objects into a vector of 32bit words: 8bit words/digit, 16bit words/RC, 16bit words/decision

Definition at line 533 of file TileROD_Encoder.cxx.

                                                                  {
 
  ATH_MSG_DEBUG( "TMDB encoding sub-fragment 0x40: loop over " << m_vTileDigi.size() << " objects" );
 
  // sub-fragment marker
  // 
  v.push_back(0xff1234ff);
 
  // sub-fragment size
  // set the size for the sub-fragment (3 [header] + 8 [# 32bit word/digit/pmt/module] x N [# digit/pmt/module])
  uint32_t size = m_vTileDigi.size()  * 7; // assume 7 samples
  size = (size+3)>>2; // convert numner of bytes into number of 32bit words
  v.push_back(3+size);
  uint savepos=v.size()-1;
 
  // 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
  //
  uint32_t verfrag      = 0x500;
  uint32_t type_version = (0x40 << 16) + verfrag;   
  v.push_back(type_version);
 
  v.resize(v.size()+size); // prepare place for extra words
 
  // counters and temporary words
  //
  int  word8bit_cnt = 0;// number of 8bit words collected 1..4
  int  wc           = 0;// number of blocks of 7 32-bit words saved in ROD fragment 1..8
  int  chc          = 0;// number of digits inside the tile digits collection
  int  nwc = (m_vTileDigi.size() + 3)>>2; // convert number of channels into number of 4-byte blocks
  uint nsamp = 7;
  uint32_t word[7];
  memset(word, 0, sizeof(word));
 
  for (const TileDigits* digi : m_vTileDigi) {
 
    if (wc==nwc) {
      ATH_MSG_WARNING( "Too many channels per fragment for TMDB frag 0x40 - ignoring all the rest" );
      break;
    }
  
    // Get identifier(s) and digits for later usage
    //
    std::vector<float> digits = digi->samples();
    nsamp = digits.size();
    if (nsamp>7) {
      ATH_MSG_WARNING( "Too many samples in digits for TMDB frag 0x40, using first 7 instead of "<<nsamp );
      nsamp=7;
      digits.resize(nsamp);
    }
 
    // Digits from TMDB come to fragment in the reverse order i.e. s1->s7 ... s7->s1
    //
    std::reverse(digits.begin(),digits.end());
    
    // Define two counters: (a) to count for the 8bit sub-fragments (each word has 4 8bit sub-fragments) 
    //                      (b) to count for the 32bit words (each digit has 7 32bit words)
    //
    //                      |  s(i)-m(j)-d6r  |  s(i)-m(j)-d6l  |  s(i)-m(j)-d5r  |  s(i)-m(j)-d5l  |
    //
    int shift = word8bit_cnt * 8;
    for ( uint i=0; i<nsamp; ++i ) {
      word[i]  += ((int) digits[i]) << shift; 
    }
 
    if (msgLvl(MSG::DEBUG)) {
      HWIdentifier hwid = digi->adc_HWID();
      int ros     = m_tileHWID->ros(hwid);
      int drawer  = m_tileHWID->drawer(hwid);
      int channel = m_tileHWID->channel(hwid);
      const char * strchannel[5] = {" d5L "," d5R "," d6L "," d6R ", " xxx "};
      int j=std::min(channel,4);
      if (ros<3) j=4;
      for ( uint i=0; i<nsamp; ++i ) {
        msg(MSG::DEBUG) << ros << "/" << drawer << "/" << channel << strchannel[j]
                        <<"\tSample "<<7-i<<" bits |" << std::setfill('0') << std::setw(2) 
                        << shift << "-" << std::setw(2) << shift+7 << std::setfill('0') 
                        << "| of 32-bit word "<<3 + nwc*i + wc<<" "<<digits[i]
                        <<" "<<MSG::hex<<word[i]<<MSG::dec << endmsg;
      }
    }
 
    ++word8bit_cnt;
 
    // 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:
    //
    //   1st 32 bit word holds : | digit0 pmt3 mod0 | digit0 pmt2 mod0 | digit0 pmt1 mod0 | digit0 pmt0 mod0 |
    //   2nd 32 bit word holds : | digit0 pmt3 mod1 | digit0 pmt2 mod1 | digit0 pmt1 mod1 | digit0 pmt0 mod1 |
    //   ...
    //   8th 32 bit word holds : | digit0 pmt3 mod7 | digit0 pmt2 mod7 | digit0 pmt1 mod7 | digit0 pmt0 mod7 |
    //   ...
    //
    // word8bit_cnt is reset to 0 and a new set of words[0..6] is restarted.
    //
    if ( word8bit_cnt == 4 ) {
      for ( uint i=0; i<nsamp; ++i ) {
        v.at( 3 + nwc*i + wc ) = word[i];
      }
      ++wc;
      word8bit_cnt=0;
      memset(word, 0, sizeof(word));
    }
    ++chc;
  }
 
  if ( word8bit_cnt != 0  && wc<nwc ) { // some extra channels 
    ATH_MSG_WARNING( "Unexpected number of channels for TMDB frag 0x40" << wc*4 + word8bit_cnt );
    for ( uint i=0; i<nsamp; ++i ) {
      v.at( 3 + nwc*i + wc ) = word[i];
    }
    ++wc;
    word8bit_cnt=0;
    memset(word, 0 ,sizeof(word));
  }
 
  v.at(savepos)=3+size;  // not actually needed - size was already set correctly
 
  ATH_MSG_DEBUG( "Check version and counters: "<<MSG::hex<< verfrag <<MSG::dec<<" "<< chc <<" "<< wc << " save in position: " << savepos );
 
  // dump fragment
  //    
  if (msgLvl(MSG::VERBOSE)) {
    msg(MSG::VERBOSE) << "Check content of ROD fragment after including sub-fragment (0x40)... " << v.size() << endmsg;
    for (size_t i=0; i<v.size(); ++i)
      msg(MSG::VERBOSE) << i << "\t" << v.at(i) << MSG::hex << " 0x" << v.at(i) << MSG::dec << endmsg;
  }
 
  return;
}

fillRODTileMuRcvObj()

void TileROD_Encoder::fillRODTileMuRcvObj

(

std::vector< uint32_t > &

v

)

Definition at line 788 of file TileROD_Encoder.cxx.

                                                                {
 
  // this is the subfragment type 0x42  
 
  ATH_MSG_INFO( "TMDB encoding sub-fragment 0x42: loop over " << m_vTileMuRcvObj.size() << " objects" );
 
  // sub-fragment marker
  //
  v.push_back(0xff1234ff);
 
  // type & version
  //
  v.push_back(5);
  uint savepos = v.size()-1;
  uint32_t verfrag      = 0x500;
  uint32_t type_version = (0x42 << 16) + verfrag;
  v.push_back(type_version);
 
  // counters and temporary words
  //
  int wc = 0;
  int chc= 0;
  uint32_t result1      = 0x0;
  uint32_t result2      = 0x0;
  uint32_t result3      = 0x0;
 
  switch (m_runPeriod) {
 
      case 2:// RUN2
  
         msg(MSG::INFO) << "Going trough RUN2 encoding procedure for TMDB data" << endmsg;
 
             for (const TileMuonReceiverObj* tmurcv : m_vTileMuRcvObj) {
 
                // VERSION RUN2: results are hold in 3 16-bit words. Two 32 bit words.
                //
                //     32nd bit -> |        results2       ||       results1        | <- 1st bit
                //                 |          0x0          ||       results3        |
                //
        //     32nd bit -> | m-5 | m-4 | m-3 | m-2 || m-2 | m-1 | m-0 | 0x0 | <- 1st bit
        //                 |          0x0          || 0x0 | m-7 | m-6 | m-5 |
        //
                // each 4 bit word is
        //
        //                 0      1      2     3    <-- in Obj
        //              | d56h | d56l | d6h | d6l |
        //                bit3   bit2  bit1  bit0
        //
 
                int modid = tmurcv->identify() & 0xff;
 
                const std::vector<bool> & slin = tmurcv->GetDecision();
                int imax = std::min((int)slin.size(),4);
                uint32_t word4b = 0x0;
                for (int i=0;i<imax;++i){
                   if (slin[i]) word4b |= 1 << (3-i);
                }
    
                if (msgLvl(MSG::INFO)) {
                   std::stringstream ss;
                   for (const bool val : slin) {
                      ss<<std::setw(2)<<val;
                   }
                   msg(MSG::INFO) << "Result for module: "<<modid<<" in TMDB board "<<modid%8<<MSG::hex<<": 0x"<<word4b<<MSG::dec<<" from "<<ss.str() << endmsg; 
                }
    
        switch (modid%8) {
                    case 0: result1 |= word4b << 4  ; break;
                    case 1: result1 |= word4b << 8  ; break;
                    case 2: result1 |= word4b << 12 ; result2 |= word4b; break;
                    case 3: result2 |= word4b << 4  ; break;
                    case 4: result2 |= word4b << 8  ; break;
                    case 5: result2 |= word4b << 12 ; result3 |= word4b; break;
                    case 6: result3 |= word4b << 4  ; break;
                    case 7: result3 |= word4b << 8  ; break;
                }
                ++chc;
             }
 
             ATH_MSG_INFO( "Summary : "<<MSG::hex<<" Results 1: 0x"<<result1<<" Results 2: 0x"<<result2<<" Results 3: 0x"<<result3<< MSG::dec );
 
             v.push_back( result1 | (result2 << 16) ); ++wc;// | 5 4 3 2 | 2 1 0 - |
             v.push_back( result3 ); ++wc;                  // | - - - - | - 7 6 5 | '-' means free/not set/0x0
             v.at(savepos)=3+wc;
 
         break;
 
          case 3:// RUN3
 
             msg(MSG::INFO) << "Going trough RUN3 encoding procedure for TMDB data" << endmsg;
 
             for (const TileMuonReceiverObj* tmurcv : m_vTileMuRcvObj) {
                // VERSION RUN3: results are hold in two 32-bit word to cover a TMDB board holding 8 TileCal modules.
                //
        //               32nd bit -> |         results2 [16:31]            ||           results1 [0:15]           | <- 1st bit
                //               32nd bit -> |            0x0 [16:31]              ||           results3 [0:15]           | <- 1st bit
                //
        //               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
        //                           |          0x0 [16:31]                || 0x0 [12:15] | m-7 | m-6 | m-5 | m-4 |
        //
        //               For each module m-X there is a 3-bit word with the result for a threshold
        //
        //                    |  d5+d6  |  d6   |  d5  |
        //                    |   bit2  |  bit1 | bit0 |
        //
 
                // counters and temporary words
                //
 
/*
 *
 * Comment on implementation...
 * In Athena the  container size is kept to 4. It is fully used for run2 but for run3 the first position is left empty.
 * The most significative bit is placed in first position [0] of a container so the position reverse while encoding.
 *
 * */
 
        int modid = tmurcv->identify() & 0xff;
        const std::vector<bool> & slin = tmurcv->GetDecision();
        int imax  = std::min((int)slin.size(),4);
                uint32_t word3b = 0x0;
                for (int i=1;i<imax;++i) {
                   // slin    d56  d6   d5
                   // word3b bit2 bit1 bit0
                   // bit 4 is always 0 since iteration starts at 1
                   if (slin[i]) word3b |= 1 << (3-i);
                }
 
        switch (modid%8) {
            case 0: result1 |= word3b   ; break;
                    case 1: result1 |= word3b << 3  ; break;
                    case 2: result1 |= word3b << 6  ; result2 |= word3b      ; break;
                    case 3: result1 |= word3b << 9  ; result2 |= word3b << 3 ; break;
                    case 4: result2 |= word3b << 6  ; result3 |= word3b      ; break;
                    case 5: result2 |= word3b << 9  ; result3 |= word3b << 3 ; break;
                    case 6: result3 |= word3b << 6  ; break;
                    case 7: result3 |= word3b << 9  ; break;
                }
                ++chc;
             }
 
             ATH_MSG_INFO( "Summary : "<<MSG::hex<<" Results 1: 0x"<<result1<<" Results 2: 0x"<<result2<<" Results 3: 0x"<<result3<< MSG::dec );
 
             v.push_back( result1 | (result2 << 16) ); ++wc;
             v.push_back( result3 ); ++wc;
             v.at(savepos) = 3+wc;
 
         break;
 
      case 0://not defined
         ATH_MSG_INFO("Tile Muon Decision Board (TMDB) fragment versions are only available for RUN2 and RUN3");
         break;
          }
          if (msgLvl(MSG::INFO)){
             msg(MSG::INFO) << "Check version and counters: "<<MSG::hex<<verfrag<<MSG::dec<<" "<<chc<<" "<<wc<<" save in position: "<<savepos<<endmsg;
         msg(MSG::INFO) << "Check content of ROD fragment after including sub-fragment (0x42)... " << v.size() << endmsg;
         for (size_t i=0; i<v.size(); ++i) {
             msg(MSG::INFO) << i << "\t" << v.at(i) << MSG::hex << " 0x" << v.at(i) << MSG::dec << endmsg;
         }
      }
  return;
}

fillRODTileMuRcvRawChannel()

void TileROD_Encoder::fillRODTileMuRcvRawChannel

(

std::vector< uint32_t > &

v

)

Definition at line 664 of file TileROD_Encoder.cxx.

                                                                        {
 
  ATH_MSG_DEBUG( "TMDB encoding sub-fragment 0x41: loop over " << m_vTileRC.size() << " objects" );
 
  const float TMDB_AMPLITUDE_FACTOR = 1.0;
 
  // sub-fragment marker
  //
  v.push_back(0xff1234ff);
 
  // sub-fragment size
  //
  v.push_back(3);
  uint savepos=v.size()-1;
 
  // 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
  //
  uint32_t verfrag      = 0x500;
  // FIXME: for the moment (July 2015) we use 32-bit packing only, so we hide 16-bit version under ifdef
  // if we decide to use 16-bit version, additional flag for encoder should be passed from top-level algorithm
#ifdef ALLOW16BIT
  if (use_16bit_packing) verfrag += 2;
  int32_t word16 = 0x0;
#endif
  uint32_t type_version = (0x41 << 16) + verfrag;
  v.push_back(type_version);
 
  // counters and temporary words
  //
  int wc       = 0;
  int chc      = 0;
  uint32_t word  = 0x0;
 
  for (const TileFastRawChannel* rc : m_vTileRC) {
 
    // energies of individual pmts 2 words per module  |  d5r(16)  |  d5l(17)  |
    //                                                 |  d6r(37)  |  d6l(38)  | 
    //
    float    f_amp = rc -> amplitude();
    int32_t  i_amp = lround(f_amp*TMDB_AMPLITUDE_FACTOR) ;
 
  // FIXME: for the moment (July 2015) we use 32-bit packing only, so we hide 16-bit version under ifdef
#ifdef ALLOW16BIT
    switch (verfrag){
    case 0x502:
      // 2's complement (binary conversion for negative numbers) 
      //    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)
      //
      // 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
      //
      //   1st 32 bit word holds : |    d5r m0    |    d5l m0    |
      //   2nd 32 bit word holds : |    d6r m0    |    d6l m0    |
      //   ...
      //   7th 32 bit word holds : |    d5r m3    |    d5l m3    |
      //   8th 32 bit word holds : |    d6r m3    |    d6l m3    | 
      //   ...
      //      - While reading the FPGA it was noticed a longer word coming out larger that 16-bit
      //      - Keep this (for now) just for history but it may be that later we understand better the FPGA output
      //
      //limit to the range of 16-bit integer
      if (i_amp>0x7FFF) word16 = 0x7FFF;
      else if (i_amp<-0x8000) word16 = -0x8000;
      else word16 = i_amp;
 
      if (chc&1) {
        word |= word16 << 16;
        v.push_back(word);
        ++wc;
      } else {
        word = word16 & 0xFFFF;
      }
      break;
 
    //case 0x500:
    default:
#else
    {
#endif
      // vMay'15 current version each 32-bit word is a channel
      word = (uint32_t)i_amp;
      v.push_back(word);
      ++wc;
    }
 
    if (msgLvl(MSG::DEBUG)) {
        int frag_id = rc->frag();
        int drawer  = (frag_id&0xFF);
        int ros     = frag_id>>8;
        int channel = rc->channel();
        const char * strchannel[5] = {" d5L "," d5R "," d6L "," d6R ", " xxx "};
        int j=std::min(channel,4);
        if (ros<3) j=4;
        msg(MSG::DEBUG) << ros << "/" << drawer << "/" << channel << strchannel[j] 
                        <<"\tAmp " << f_amp << " " << i_amp << " " 
                        <<" ch cnt " << chc << " word cnt " << wc 
                        << " word 0x" <<MSG::hex<< word <<MSG::dec<<endmsg;
    }
    
    ++chc;
  }
 
  // FIXME: for the moment (July 2015) we use 32-bit packing only, so we hide 16-bit version under ifdef
#ifdef ALLOW16BIT
  if (verfrag==0x502 && wc*2 != chc) { // odd number of channels for 16-bit frags
    v.push_back(word); // saving last channel
    ++wc;
  }
#endif
 
  v.at(savepos)=3+wc; 
 
  ATH_MSG_DEBUG("Check version and counters: "<<MSG::hex<< verfrag <<MSG::dec<<" "<< chc <<" "<< wc <<" save in position: "<< savepos );
 
  if (msgLvl(MSG::VERBOSE)) {
    msg(MSG::VERBOSE) << "Check content of ROD fragment after including sub-fragment (0x41)... "<< m_vTileRC.size() <<" "<< v.size() << endmsg;
    for (size_t i=0; i<v.size(); ++i) {
      msg(MSG::VERBOSE) << i <<"\t"<< v.at(i) << MSG::hex << " 0x" << v.at(i) << MSG::dec << endmsg;
    }
  }
  return;
}

initMessaging()

void AthMessaging::initMessaging ( ) const

privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

{
  m_imsg = Athena::getMessageSvc();
  // If user did not set an explicit level, set a default
  if (m_lvl == MSG::NIL) {
    m_lvl = m_imsg ?
      static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
      MSG::INFO;
  }
}

msg() [1/2]

MsgStream & AthMessaging::msg ( ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 163 of file AthMessaging.h.

{
  MsgStream* ms = m_msg_tls.get();
  if (!ms) {
    if (!m_initialized.test_and_set()) initMessaging();
    ms = new MsgStream(m_imsg,m_nm);
    m_msg_tls.reset( ms );
  }
 
  ms->setLevel (m_lvl);
  return *ms;
}

msg() [2/2]

MsgStream & AthMessaging::msg ( const MSG::Level lvl ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 178 of file AthMessaging.h.

{ return msg() << lvl; }

msgLvl()

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

inlineinherited

Test the output level.

Parameters

lvl	The message level to test against

Returns

boolean Indicating if messages at given level will be printed

Return values

true	Messages at level "lvl" will be printed

Definition at line 151 of file AthMessaging.h.

{
  if (m_lvl <= lvl) {
    msg() << lvl;
    return true;
  } else {
    return false;
  }
}

setBit()

void TileROD_Encoder::setBit ( uint32_t * p, int chan )

private

set the bitmap for a channel

Definition at line 955 of file TileROD_Encoder.cxx.

                                                  {
// chan = (0,47)   
  int a = chan / 32;
  int r = chan % 32;
// a = (0,1), r = ( 0, 31 )
  *(p + a) |= (1 << r);
  return;
}

setLevel()

void AthMessaging::setLevel ( MSG::Level lvl )

inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

{
  m_lvl = lvl;
}

setMaxChannels()

void TileROD_Encoder::setMaxChannels

(

int

maxChannels

)

set maximum number of channels in a drawer

Definition at line 132 of file TileROD_Encoder.cxx.

                                                    {
  m_maxChannels = maxChannels;
}

setTileHWID() [1/2]

void TileROD_Encoder::setTileHWID	(	const TileHWID *	tileHWID,
		bool	verbose,
		unsigned int	type = 4 )

set all necessary parameters for the encoder

Definition at line 68 of file TileROD_Encoder.cxx.

                                                                                           {
  m_tileHWID = tileHWID;
  m_verbose = verbose;
  m_type = type;
  m_unitType = (m_type << 16);
 
  switch (type) {
    case 4:
      m_rc2bytes4.setVerbose(verbose);
      break;
    case 5:
      m_rc2bytes5.setVerbose(verbose);
      break;
    case 3:
      m_rc2bytes3.setVerbose(verbose);
      break;
    case 2:
      m_rc2bytes2.setVerbose(verbose);
      break;
    default:
      break;
  }
}

setTileHWID() [2/2]

void TileROD_Encoder::setTileHWID	(	const TileHWID *	tileHWID,
		int	m_runPeriod )

Definition at line 92 of file TileROD_Encoder.cxx.

                                                                         {
   m_tileHWID = tileHWID;
   m_runPeriod = runPeriod;
}

setTypeAndUnit()

void TileROD_Encoder::setTypeAndUnit	(	TileFragHash::TYPE	type,
		TileRawChannelUnit::UNIT	unit )

set OF algorigtm type and amplitude units for a drawer

Definition at line 97 of file TileROD_Encoder.cxx.

                                                                                       {
 
  unsigned int OFType = (unsigned int) type;
  if (OFType > 7) {
    OFType = 0;
    ATH_MSG_ERROR( "setTypeAndUnit Incorrect raw data type =" << type
                  << " using type=0 instead " );
  }
 
  unsigned int rChUnit = (unsigned int) unit % (unsigned int) TileRawChannelUnit::OnlineOffset;
 
  // make sure that we use frag type 4 for units which are not ADC counts
  if (rChUnit != 0 && m_type < 4) m_type = 4;
  if (m_type == 4) { // new fragments have non-zero upper byte
    // 8 upper bits:
    // UUPPSTTT
    // 31,30 - units
    // 29,28 - pulse type ( = 3 for simulated data)
    // 27    - 7(=0) or 9(=1) samples (assume 7 samples for now)
    // 24,25,26 - OF type
    // next 8 bits - frag type ( 2,3,4, ... )
    m_unitType = (rChUnit << 30) | (3 << 28) | (0 << 27) | (OFType << 24) | (m_type << 16);
    m_rChUnit = rChUnit;
  } else if (m_type == 5) {
    // 8 upper bits:
    // UULLLTTT
    // 31,30 - units
    // 29,28,27 - length of Level2 part ( = 3 - sumEt, sumEz, sumE )
    // 24,25,26 - OF type
    m_unitType = (rChUnit << 30) | (3 << 27) | (OFType << 24) | (m_type << 16);
    m_rChUnit = rChUnit;
  }
 
}

Member Data Documentation

ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT

mutableprivateinherited

Messaging initialized (initMessaging)

Definition at line 141 of file AthMessaging.h.

m_Digi2bytes

TileDigits2Bytes TileROD_Encoder::m_Digi2bytes

private

Definition at line 132 of file TileROD_Encoder.h.

m_imsg

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

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

{ nullptr };

m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

{ MSG::NIL };

m_maxChannels

int TileROD_Encoder::m_maxChannels

private

Definition at line 149 of file TileROD_Encoder.h.

m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls

mutableprivateinherited

MsgStream instance (a std::cout like with print-out levels)

Definition at line 132 of file AthMessaging.h.

m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

m_order

TileRawDataOrdering TileROD_Encoder::m_order

private

Definition at line 142 of file TileROD_Encoder.h.

m_rc2bytes2

TileRawChannel2Bytes2 TileROD_Encoder::m_rc2bytes2

private

Definition at line 133 of file TileROD_Encoder.h.

m_rc2bytes3

TileRawChannel2Bytes TileROD_Encoder::m_rc2bytes3

private

Definition at line 134 of file TileROD_Encoder.h.

m_rc2bytes4

TileRawChannel2Bytes4 TileROD_Encoder::m_rc2bytes4

private

Definition at line 135 of file TileROD_Encoder.h.

m_rc2bytes5

TileRawChannel2Bytes5 TileROD_Encoder::m_rc2bytes5

private

Definition at line 136 of file TileROD_Encoder.h.

m_rChUnit

unsigned int TileROD_Encoder::m_rChUnit

private

Definition at line 147 of file TileROD_Encoder.h.

m_runPeriod

int TileROD_Encoder::m_runPeriod

private

Definition at line 150 of file TileROD_Encoder.h.

m_tileHWID

const TileHWID* TileROD_Encoder::m_tileHWID

private

Definition at line 138 of file TileROD_Encoder.h.

m_type

unsigned int TileROD_Encoder::m_type

private

Definition at line 145 of file TileROD_Encoder.h.

m_unitType

unsigned int TileROD_Encoder::m_unitType

private

Definition at line 146 of file TileROD_Encoder.h.

m_verbose

bool TileROD_Encoder::m_verbose

private

Definition at line 144 of file TileROD_Encoder.h.

m_vTileDigi

std::vector<const TileDigits*> TileROD_Encoder::m_vTileDigi

private

Definition at line 128 of file TileROD_Encoder.h.

m_vTileL2

std::vector<const TileL2*> TileROD_Encoder::m_vTileL2

private

Definition at line 127 of file TileROD_Encoder.h.

m_vTileMuRcvObj

std::vector<const TileMuonReceiverObj*> TileROD_Encoder::m_vTileMuRcvObj

private

Definition at line 130 of file TileROD_Encoder.h.

m_vTileRC

std::vector<const TileFastRawChannel*> TileROD_Encoder::m_vTileRC

private

Definition at line 126 of file TileROD_Encoder.h.

---

The documentation for this class was generated from the following files:

• TileROD_Encoder.h
• TileROD_Encoder.cxx