TgcByteStreamData.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef MUONTGC_CNVTOOLS_TGCBYTESTREAMDATA_H
#define MUONTGC_CNVTOOLS_TGCBYTESTREAMDATA_H
 
#include "AthenaKernel/errorcheck.h"
 
#include <cstring> // This file is needed to use memset. 
 
const uint32_t TGC_BYTESTREAM_HEADER = 0xee1234ee;
const uint32_t TGC_BYTESTREAM_HEADERSIZE = 0x9;
const uint32_t TGC_BYTESTREAM_HEADERVERSION = 0x03000300;
const uint32_t TGC_BYTESTREAM_STATUSSIZE = 0x5;

struct TGC_BYTESTREAM_SOURCEID
{
  unsigned rodid: 8;
  unsigned fill1: 8;
  unsigned side:  8;
  unsigned fill2: 8;
 
  TGC_BYTESTREAM_SOURCEID() { memset(this, 0, sizeof(*this)); }
};

struct TGC_BYTESTREAM_ERRORS
{
  unsigned badBcID:  1;
  unsigned badL1Id:  1;
  unsigned timedout: 1;
  unsigned badData:  1;
  unsigned overflow: 1;
  unsigned fill1:   11;
 
  TGC_BYTESTREAM_ERRORS() { memset(this, 0, sizeof(*this)); }
};

struct TGC_BYTESTREAM_LOCALSTATUS
{
  unsigned mergedHitBCs:      1;
  unsigned mergedTrackletBCs: 1;
  unsigned sortedHits:        1;
  unsigned sortedTracklets:   1;
  unsigned fill1:            10;
  unsigned hasRoI:            1;
  unsigned fakeSsw:           1;
 
  unsigned fill2:             1;
  unsigned raw:               1;
  unsigned hitsRO:            1;
  unsigned trkRO:             1;
  unsigned hitsCH:            1;
  unsigned trkCH:             1;
  unsigned fill3:             2;
  unsigned hipt:              1;
  unsigned sl:                1;
  unsigned fill4:             6;
 
  TGC_BYTESTREAM_LOCALSTATUS() { memset(this, 0, sizeof(*this)); }
};

struct TGC_BYTESTREAM_FRAGMENTCOUNT
{
  unsigned count: 24;
  unsigned id:     8;
};

struct TGC_BYTESTREAM_READOUTHIT
{
  unsigned channel:  8;
  unsigned sbId:     5;
  unsigned sbType:   3;
  unsigned adj:      1;
  unsigned ldbId:    4;
  unsigned bcBitmap: 3;
  unsigned tracklet: 6;
  unsigned fill1:    1;
  unsigned ok:       1;
 
  TGC_BYTESTREAM_READOUTHIT() { memset(this, 0, sizeof(*this)); }
};

struct TGC_BYTESTREAM_READOUTTRACKLET
{
  unsigned rphi:     5;
  unsigned subm:     2;
  unsigned seg:      1;
  signed   delta:    4;
  unsigned sbId:     5;
  unsigned ldbId:    4;
  unsigned bcBitmap: 3;
  unsigned trkType:  3;
  unsigned fill1:    1;
  unsigned slbType:  3;
  unsigned ok:       1;
 
  TGC_BYTESTREAM_READOUTTRACKLET() { memset(this, 0, sizeof(*this)); }
};

struct TGC_BYTESTREAM_READOUTTRIPLETSTRIP
{
  unsigned phi:      4;
  unsigned subc:     2;
  unsigned fill1:    1;
  unsigned seg:      1;
  unsigned fill2:    4;
  unsigned sbId:     5;
  unsigned ldbId:    4;
  unsigned bcBitmap: 3;
  unsigned trkType:  3;
  unsigned fill3:    1;
  unsigned slbType:  3;
  unsigned ok:       1;
 
  TGC_BYTESTREAM_READOUTTRIPLETSTRIP() { memset(this, 0, sizeof(*this)); }
};

struct TGC_BYTESTREAM_HIPT
{
  signed   delta:    5;
  unsigned sub:      1;
  unsigned hitId:    3;
  unsigned hipt:     1;
  unsigned cand:     1;
  unsigned chip:     2;
  unsigned sector:   3;
  unsigned fwd:      1;
  unsigned strip:    1;
  unsigned bcBitmap: 3;
  unsigned fill1:   11;
 
  TGC_BYTESTREAM_HIPT() { memset(this, 0, sizeof(*this)); }
};

struct TGC_BYTESTREAM_HIPT_INNER
{
  unsigned inner:    8;
  unsigned fill1:    1;
  unsigned hipt:     1;
  unsigned cand:     1;
  unsigned chip:     2;
  unsigned sector:   3;
  unsigned fwd:      1;
  unsigned strip:    1;
  unsigned bcBitmap: 3;
  unsigned fill2:   11;
 
  TGC_BYTESTREAM_HIPT_INNER() { memset(this, 0, sizeof(*this)); }
};

struct TGC_BYTESTREAM_SL
{
  unsigned roi:       8;
  unsigned overlap:   1;
  unsigned threshold: 3;
  unsigned fill1:     1;
  unsigned bcId:      3;
  unsigned sign:      1;
  unsigned cand:      1;
  unsigned sector:    3;
  unsigned fwd:       1;
  unsigned bcBitmap:  3;
  unsigned cand2plus: 1;
  unsigned veto:      1;
  unsigned fill2:     5;
 
  TGC_BYTESTREAM_SL() { memset(this, 0, sizeof(*this)); }
};
 
/**********************/
/**********************/
 
struct TGC_BYTESTREAM_NSL_ROI
{
  unsigned roi:       8;
  unsigned pt:        4;
  unsigned charge:    1;
  unsigned coinflag:  3;
  unsigned innerflag: 4;
  unsigned fill1:     2;
  unsigned bcBitmap:  2;
  unsigned sector:    4;
  unsigned fwd:       1;
  unsigned type:      3;
 
  TGC_BYTESTREAM_NSL_ROI() { memset(this, 0, sizeof(*this)); }
};
 
struct TGC_BYTESTREAM_NSW_POS
{
  unsigned eta:       8;
  unsigned phi:       6;
  unsigned fill1:     3;
  unsigned input:     3;
  unsigned cand:      2;
  unsigned bcBitmap:  2;
  unsigned sector:    4;
  unsigned fwd:       1;
  unsigned type:      3;
 
  TGC_BYTESTREAM_NSW_POS() { memset(this, 0, sizeof(*this)); }
};
 
struct TGC_BYTESTREAM_NSW_ANG
{
  unsigned angle:     5;
  unsigned phires:    1;
  unsigned lowres:    1;
  unsigned fill1:     2;
  unsigned nswid:     4;
  unsigned bcid:      4;
  unsigned input:     3;
  unsigned cand:      2;
  unsigned bcBitmap:  2;
  unsigned sector:    4;
  unsigned fwd:       1;
  unsigned type:      3;
 
  TGC_BYTESTREAM_NSW_ANG() { memset(this, 0, sizeof(*this)); }
};
 
struct TGC_BYTESTREAM_RPCBIS78_POS
{
  unsigned eta:       6;
  unsigned phi:       6;
  unsigned fill1:     8;
  unsigned cand:      2;
  unsigned bcBitmap:  2;
  unsigned sector:    4;
  unsigned fwd:       1;
  unsigned type:      3;
 
  TGC_BYTESTREAM_RPCBIS78_POS() { memset(this, 0, sizeof(*this)); }
};
struct TGC_BYTESTREAM_RPCBIS78_COIN
{
  unsigned fill1:     4;
  unsigned deta:      3;
  unsigned dphi:      3;
  unsigned flag:      2;
  unsigned fill2:     1;
  unsigned bcid:      4;
  unsigned fill3:     3;
  unsigned cand:      2;
  unsigned bcBitmap:  2;
  unsigned sector:    4;
  unsigned fwd:       1;
  unsigned type:      3;
 
  TGC_BYTESTREAM_RPCBIS78_COIN() { memset(this, 0, sizeof(*this)); }
};
 
struct TGC_BYTESTREAM_NSL_EIFI
{
  unsigned ei:        8;
  unsigned fi:        8;
  unsigned chamberid: 3;
  unsigned fill1:     3;
  unsigned bcBitmap:  2;
  unsigned sector:    4;
  unsigned fwd:       1;
  unsigned type:      3;
 
  TGC_BYTESTREAM_NSL_EIFI() { memset(this, 0, sizeof(*this)); }
};
 
struct TGC_BYTESTREAM_NSL_HIPT
{
  signed   delta:     5;
  unsigned sub:       1;
  unsigned hitId:     3;
  unsigned hipt:      1;
  unsigned cand:      1;
  unsigned chip:      2;
  unsigned strip:     1;
  unsigned fill1:     8;
  unsigned bcBitmap:  2;
  unsigned sector:    4;
  unsigned fwd:       1;
  unsigned type:      3;
 
  TGC_BYTESTREAM_NSL_HIPT() { memset(this, 0, sizeof(*this)); }
};
 
struct TGC_BYTESTREAM_NSL_TMDB
{
  unsigned module:   12;
  unsigned bcid:      4;
  unsigned fill1:     6;
  unsigned bcBitmap:  2;
  unsigned sector:    4;
  unsigned fwd:       1;
  unsigned type:      3;
 
  TGC_BYTESTREAM_NSL_TMDB() { memset(this, 0, sizeof(*this)); }
};
 
/*****************************/
/*****************************/
 
 
template <typename DEST, typename SRC> DEST* my_pointer_cast(SRC* src) {
  void* ptr = src;  
  return reinterpret_cast<DEST*>(ptr); 
}
template <class T> inline uint32_t toBS32(T& data) { return *(my_pointer_cast<uint32_t>(&data)); }
template <class T> inline uint16_t toBS16(T& data) { return *(my_pointer_cast<uint16_t>(&data)); }
template <class T> inline void fromBS32(uint32_t data, T& s) { s = *(my_pointer_cast<T>(&data)); }
template <class T> inline void fromBS16(uint16_t data, T& s) { s = *(my_pointer_cast<T>(&data)); }
inline uint8_t  low8(uint32_t data)   { return (uint8_t)(data & 0x000000ff); }
inline uint16_t low16(uint32_t data)  { return (uint16_t)(data & 0x0000ffff); }
inline uint16_t high16(uint32_t data) { return (uint16_t)(data >> 16); }
inline uint16_t bcId(uint32_t data) { return data & 0xfff; }
 
inline int fragmentCount(uint32_t data, int id)
{
  TGC_BYTESTREAM_FRAGMENTCOUNT counter;
  fromBS32(data, counter);
  if(counter.id != (unsigned int)id)
    {
      REPORT_MESSAGE_WITH_CONTEXT(MSG::ERROR, "TgcByteStreamData")
        << "Requested count of frament " << id << ", data is for fragment " << counter.id << endmsg;
      return 0;
    }
  return counter.count;
}
 
inline uint32_t from16(uint16_t high16, uint16_t low16)
{
  return (uint32_t)((high16 << 16) | low16);
}
 
inline uint32_t from8(uint8_t high8, uint8_t highmid8, uint8_t lowmid8, uint8_t low8)
{
  return (uint32_t)((high8 << 24) | (highmid8 << 16) | (lowmid8 << 8) | low8);
}
 
inline unsigned bcBitmap(uint16_t bcTag)
{
  return (bcTag == 1 ? 4 :
      ((bcTag == 0 || bcTag == 2) ? 2 :
       (bcTag == 3 ? 1 :
        0)));
}
 
inline unsigned bcTag(unsigned bcBitMap)
{
  return (bcBitMap == 4 ? 1 :
      (bcBitMap == 2 ? 2 :
       (bcBitMap == 1 ? 3 :
        0)));
}
 
#endif // MUONTGC_CNVTOOLS_TGCBYTESTREAMDATA_H