RawDataFormat.h

Go to the documentation of this file.

// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
// All rights not expressly granted are reserved.
//
// This software is distributed under the terms of the GNU General Public
// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
//
// In applying this license CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.
 
 
 
 
 
 
#ifndef O2_TOF_RAWDATAFORMAT
#define O2_TOF_RAWDATAFORMAT
 
#ifdef __cplusplus
#include <cstdint>
#else
#include <stdint.h>
#endif
 
#ifdef __cplusplus
namespace o2
{
namespace tof
{
namespace raw
{
#endif
 
#define TOF_MAGIC 0x70F   // 12 bits pattern inserted in some key data to flag TOF data
#define TOF_SOURCE_ID 0x5 // sourceId assigned to TOF (must match value in RDH sourceId field)
 
/* TOF detField description RDH Word3 bit 0-31 
        |31|30|29|28|27|26|25|24|23|22|21|20|19|18|17|16|15|14|13|12|11|10|09|08|07|06|05|04|03|02|01|00|
        -------------------------------------------------------------------------------------------------
        |    Served Triggers    |  Received Triggers    |    0      |             70F                   |
        -------------------------------------------------------------------------------------------------
*/
typedef struct {
  uint32_t TOFmagic : 12;
  uint32_t mbz : 4;
  uint32_t triggerRecvInOrbit : 8;
  uint32_t triggerServInOrbit : 8;
} __attribute__((__packed__)) TOFDetField_t;
#define TOF_DETFIELD_MAGIC(x) (x & FFF)
#define TOF_DETFIELD_RECVTRIGGER(x) ((x >> 16) & 0xFF)
#define TOF_DETFIELD_SERVTRIGGER(x) ((x >> 24) & 0xFF)
 
/* GEO Ad assigned to TOF modules */
#define DRM_GEOAD 1
#define LTM_GEOAD 2
#define TRM_GEOAD_MIN 3
#define TRM_GEOAD_MAX 12
 
/* Symbols and macros valid for all slots */
#define TOF_HEADER 4
#define TOF_TRAILER 5
#define TOF_FILLER 7
#define FILLER_WORD (TOF_FILLER << 28)
#define TOF_GETGEO(x) (x & 0xF)
#define TOF_GETDATAID(x) ((x >> 28) & 0xF)
 
/* TOF Data Header (former CDH)
        |31|30|29|28|27|26|25|24|23|22|21|20|19|18|17|16|15|14|13|12|11|10|09|08|07|06|05|04|03|02|01|00|
        -------------------------------------------------------------------------------------------------
Word 0  |   0100    |    00              |                 Event Length (Bytes)                         |
        -------------------------------------------------------------------------------------------------
Word 1  |                                     LHC Orbit                                                 |
        -------------------------------------------------------------------------------------------------
*/
// TDH - TOF Data Header
typedef struct {
  uint32_t bytePayload : 20;
  uint32_t mbz : 8;
  uint32_t dataId : 4;
} __attribute__((__packed__)) TOFDataHeader_t;
 
typedef struct {
  uint32_t orbit : 32;
} __attribute__((__packed__)) TOFOrbit_t;
 
typedef struct {
  TOFDataHeader_t head;
  TOFOrbit_t orbit;
} __attribute__((__packed__)) TDH_t;
 
#define TDH_SIZE sizeof(TDH_t) // size is in bytes length is in words
#define TDH_LENGTH TDH_SIZE / 4
 
#define TDH_HEADER(d) TOF_GETDATAID(d)
#define TDH_PAYLOAD(d) (d & 0x3FFFF)
#define TDH_WORDS(d) TDH_PAYLOAD(d) / 4
#define TDH_ORBIT(d) (d & 0xFFFFFFFF) //32 bit
 
/* DRM headers & trailer 
 
        |31|30|29|28|27|26|25|24|23|22|21|20|19|18|17|16|15|14|13|12|11|10|09|08|07|06|05|04|03|02|01|00|
        -------------------------------------------------------------------------------------------------
Word 0  |   0100    |DG|   Drm Id           |               Event Length (Words)            |  0001     |
        -------------------------------------------------------------------------------------------------
Word 1  |   0100    |0 | DRMHWords | DRMHVersion  | CLK |0 |  Slot Participating Mask       |  0001     |
        -------------------------------------------------------------------------------------------------
Word 2  |   0100    |TO|  Slot Fault Mask               |0 |  Slot Enable Mask              |  0001     |
        -------------------------------------------------------------------------------------------------
Word 3  |   0100    |   Bunch Crossing (Local)          |    Bunch Crossing (GBTx)          |  0001     |
        -------------------------------------------------------------------------------------------------
Word 4  |   0100    |        00             |  Temp Ad  |   Temp Value                      |  0001     |
        -------------------------------------------------------------------------------------------------
Word 5  |   0100    |        00       |IR|                   Event CRC                      |  0001     |
        -------------------------------------------------------------------------------------------------
Trailer |   0101    |        000                        |    Event Counter (Local)          |  0001     |
        -------------------------------------------------------------------------------------------------
*/
// DRMH - DRM Data Header and Trailer
//----------------------------------- Word 0
typedef struct {
  uint32_t slotId : 4;
  uint32_t eventWords : 16;
  uint32_t drmId : 7;      // 0-71== 0x0-0x47        (Bits 0-7 of A_DRM_ID register)
  uint32_t drmGenData : 1; // DRM generated payload  (Bit 8 of A_DRM_ID)
  uint32_t dataId : 4;
} __attribute__((__packed__)) DRMDataHeader_t;
 
//----------------------------------- Word 1
typedef struct {
  uint32_t slotId : 4;
  uint32_t partSlotMask : 11;
  uint32_t mbza : 1;
  uint32_t clockStatus : 2;
  uint32_t drmhVersion : 5; // > 0x10 is for Run3-4
  uint32_t drmHSize : 4;    // it doesn't count previous word, so currently it is 5
  uint32_t mbzb : 1;
  uint32_t dataId : 4;
} __attribute__((__packed__)) DRMHeadW1_t;
//----------------------------------- Word 2
typedef struct {
  uint32_t slotId : 4;
  uint32_t enaSlotMask : 11;
  uint32_t mbz : 1;
  uint32_t faultSlotMask : 11;
  uint32_t readoutTimeOut : 1;
  uint32_t dataId : 4;
} __attribute__((__packed__)) DRMHeadW2_t;
//----------------------------------- Word 3
typedef struct {
  uint32_t slotId : 4;
  uint32_t gbtBunchCnt : 12;
  uint32_t locBunchCnt : 12;
  uint32_t dataId : 4;
} __attribute__((__packed__)) DRMHeadW3_t;
//----------------------------------- Word 4
typedef struct {
  uint32_t slotId : 4;
  uint32_t tempValue : 10;
  uint32_t mbza : 2;
  uint32_t tempAddress : 4;
  uint32_t mbzb : 8;
  uint32_t dataId : 4;
} __attribute__((__packed__)) DRMHeadW4_t;
//----------------------------------- Word 5
typedef struct {
  uint32_t slotId : 4;
  uint32_t eventCRC : 16;
  uint32_t irq : 1;
  uint32_t mbz : 7;
  uint32_t dataId : 4;
} __attribute__((__packed__)) DRMHeadW5_t;
 
// full DRMH (header + 5 words)
typedef struct {
  DRMDataHeader_t head;
  DRMHeadW1_t w1;
  DRMHeadW2_t w2;
  DRMHeadW3_t w3;
  DRMHeadW4_t w4;
  DRMHeadW5_t w5;
} __attribute__((__packed__)) DRMh_t;
 
typedef struct {
  uint32_t slotId : 4;
  uint32_t locEvCnt : 12;
  uint32_t mbz : 12;
  uint32_t dataId : 4;
} __attribute__((__packed__)) DRMDataTrailer_t;
 
#define DRMH_SIZE sizeof(DRMh_t)
#define DRMH_LENGTH DRMH_SIZE / 4
#define DRM_HEAD_NW DRMH_LENGTH
 
// Word 0
#define DRM_EVWORDS(a) ((a & 0x000FFFF0) >> 4)
#define DRM_DRMID(a) ((a & 0x07F00000) >> 20)
#define DRM_GENDATA(a) ((a & 0x08000000) >> 27)
#define DRM_DRMID_OLD(a) ((a & 0x007E00000) >> 21)
#define DRM_EVWORDS_OLD(a) ((a & 0x0001FFFF0) >> 4)
// Word 1
#define DRM_SLOTID(a) ((a & 0x00007FF0) >> 4)
#define DRM_CLKFLG(a) ((a & 0x00030000) >> 16)
#define DRM_VERSID(a) ((a & 0x007C0000) >> 18)
#define DRM_HSIZE(a) ((a & 0x07800000) >> 23)
#define DRM_VERSID_OLD(a) ((a & 0x003E0000) >> 17)
#define DRM_CLKFLG_OLD(a) ((a & 0x00018000) >> 15)
#define DRM_HSIZE_OLD(a) ((a & 0x03C00000) >> 22)
#define DRM_NEW_VERSION(a) ((a & 0x02000000) >> 25)
// Word 2
#define DRM_ENABLEID(a) ((a & 0x00007FF0) >> 4)
#define DRM_FAULTID(a) ((a & 0x07FF0000) >> 16)
#define DRM_RTMO(a) ((a & 0x08000000) >> 27)
// Word 3
#define DRM_BCGBT(a) ((a & 0x0000FFF0) >> 4)
#define DRM_BCLOC(a) ((a & 0x0FFF0000) >> 16)
// Word 4
#define DRM_TEMP(a) ((a & 0x00003FF0) >> 4)
#define DRM_SENSAD(a) ((a & 0x00070000) >> 16)
// Word 5
#define DRM_EVCRC(a) ((a & 0x000FFFF0) >> 4)
// Trailer
#define DRM_LOCEVCNT(a) ((a & 0x0000FFF0) >> 4)
 
/* TRM headers & trailers */
#define TRM_HEADER TOF_HEADER
#define TRM_TRAILER TOF_TRAILER
#define CHAIN_0_HEADER 0
#define CHAIN_0_TRAILER 1
#define CHAIN_1_HEADER 2
#define CHAIN_1_TRAILER 3
#define HIT_LEADING 0xA
#define HIT_TRAILING 0xC
#define REPORT_ERROR 6
#define DEBERR REPORT_ERROR
 
#define TRM_WORDID(a) TOF_GETDATAID(a) // legacy
 
/* TRM Global Header                 
  |31|30|29|28|27|26|25|24|23|22|21|20|19|18|17|16|15|14|13|12|11|10|09|08|07|06|05|04|03|02|01|00|
  -------------------------------------------------------------------------------------------------
  |   0100    | E|         EVENT NUMBER (10)   |             EVENT WORDS (13)         |  SLOT ID  |
                |
                |__ Empty event
*/
// TRM - TRM Data Global and Chain Header and Trailer
typedef struct {
  uint32_t slotId : 4;
  uint32_t eventWords : 13;
  uint32_t eventCnt : 10;
  uint32_t emptyBit : 1;
  uint32_t dataId : 4;
} __attribute__((__packed__)) TRMDataHeader_t;
#define TRM_EVCNT_GH(a) ((a & 0x07FE0000) >> 17)
#define TRM_EVWORDS(a) ((a & 0x0001FFF0) >> 4)
#define TRM_EMPTYBIT(a) ((a & 0x08000000) >> 27)
 
/* TRM Chain Header
  |31|30|29|28|27|26|25|24|23|22|21|20|19|18|17|16|15|14|13|12|11|10|09|08|07|06|05|04|03|02|01|00|
  -------------------------------------------------------------------------------------------------
  | 0000/0010 |        RESERVED                   |             BUNCH ID              |  SLOT ID  |
*/
typedef struct {
  uint32_t slotId : 4;
  uint32_t bunchCnt : 12;
  uint32_t mbz : 12;
  uint32_t dataId : 4; // bit 29 flag the chain
} __attribute__((__packed__)) TRMChainHeader_t;
#define TRM_BUNCHID(a) ((a & 0x0000FFF0) >> 4)
 
/* TRM Chain Trailer
  |31|30|29|28|27|26|25|24|23|22|21|20|19|18|17|16|15|14|13|12|11|10|09|08|07|06|05|04|03|02|01|00|
  -------------------------------------------------------------------------------------------------
  | 0001/0011 |        EVENT COUNTER              |           CHAIN_EVNT_WORD (12)    |  STATUS   |
*/
typedef struct {
  uint32_t status : 4;
  uint32_t mbz : 12;
  uint32_t eventCnt : 12;
  uint32_t dataId : 4; // bit 29 flag the chain
} __attribute__((__packed__)) TRMChainTrailer_t;
#define TRM_EVCNT_CT(a) ((a & 0x0FFF0000) >> 16)
#define TRM_CHAINSTAT(a) (a & 0xF)
 
/* TRM Global Trailer  
  |31|30|29|28|27|26|25|24|23|22|21|20|19|18|17|16|15|14|13|12|11|10|09|08|07|06|05|04|03|02|01|00|
  -------------------------------------------------------------------------------------------------
  |   0101    | L|TS|CN| SENS AD|        TEMP (8)       |     EVENT CRC (12)                | X| X|
                |  |  |
                |  |  |__ Chain
                |  |__ Temp Status bit (1=OK,0=not valid)
                |__ Lut error
*/
typedef struct {
  uint32_t trailerMark : 2;
  uint32_t eventCRC : 12;
  uint32_t tempValue : 8;
  uint32_t tempAddress : 3;
  uint32_t tempChain : 1;
  uint32_t tempAck : 1;
  uint32_t lutErrorBit : 1;
  uint32_t dataId : 4;
} __attribute__((__packed__)) TRMDataTrailer_t;
 
#define TRM_LUTERRBIT(a) ((a & 0x08000000) >> 27)
#define TRM_PB24TEMP(a) ((a & 0x003FC000) >> 14)
#define TRM_PB24ID(a) ((a & 0x01C00000) >> 22)
#define TRM_PB24CHAIN(a) ((a & 0x02000000) >> 25)
#define TRM_PB24ACK(a) ((a & 0x04000000) >> 26)
#define TRM_EVCRC2(a) ((a & 0x00003FFC) >> 2)
#define TRM_TERM(a) (a & 0x3)
 
//#define TRM_EVCNT2(a)    ((a & 0x07FE0000)>>17)
//#define TRM_EVCRC(a)     ((a & 0x0000FFF0)>>4)
 
// TDC Hit Decoding
/* 
  |31|30|29|28|27|26|25|24|23|22|21|20|19|18|17|16|15|14|13|12|11|10|09|08|07|06|05|04|03|02|01|00|
  -------------------------------------------------------------------------------------------------
  | Data Id   | TDC Id    | Ch Id  | TIME                                                         |       
 
   Note on dataId: all values > 5 here:  
   0110 HPTDC error or HPTDC test word (or global error if TDCId=0xF)
   1010 Hit leading
   1100 Hit trailing
   if bit 28 is on, both copies of LUT corrupted, wrong compensation applied
*/
typedef struct {
  uint32_t time : 21;
  uint32_t chanId : 3;
  uint32_t tdcId : 4;
  uint32_t dataId : 4;
} __attribute__((__packed__)) TRMDataHit_t;
 
#define TRM_TIME(a) (a & 0x1FFFFF)
#define TRM_CHANID(a) ((a >> 21) & 0x7)
#define TRM_TDCID(a) ((a >> 24) & 0xF)
 
// LTM
// LTM - LTM Data Header and Trailer
typedef struct {
  uint32_t slotId : 4;
  uint32_t eventWords : 13;
  uint32_t cycloneErr : 1;
  uint32_t fault : 6;
  uint32_t mbz0 : 4;
  uint32_t dataId : 4;
} __attribute__((__packed__)) LTMDataHeader_t;
#define LTM_HEAD_TAG(x) TOF_GETDATAID(x)
#define LTM_HEAD_FAULTFLAG(x) (((x) >> 18) & 0x1)
#define LTM_HEAD_CYCSTATUS(x) (((x) >> 17) & 0x1)
#define LTM_EVENTSIZE(x) (((x) >> 4) & 0x1FFF) // actual event size
#define LTM_HEAD_EVENTSIZE(x) (((x) >> 4) & 0x1FFF)
#define LTM_HEAD_GEOADDR(x) TOF_GETGEO(x)
#define LTM_HEADER TOF_HEADER
 
typedef struct {
  uint32_t slotId : 4;
  uint32_t eventCRC : 12;
  uint32_t eventCnt : 12;
  uint32_t dataId : 4;
} __attribute__((__packed__)) LTMDataTrailer_t;
#define LTM_TAIL_TAG(x) TOF_GETDATAID(x)
#define LTM_TAIL_EVENTNUM(x) (((x) >> 16) & 0xFFF)
#define LTM_TAIL_EVENTCRC(x) (((x) >> 4) & 0xFFF)
#define LTM_TAIL_GEOADDR(x) TOF_GETGEO(x)
#define LTM_TRAILER TOF_TRAILER
 
typedef struct {
  uint32_t pdl0 : 8;
  uint32_t pdl1 : 8;
  uint32_t pdl2 : 8;
  uint32_t pdl3 : 8;
} __attribute__((__packed__)) LTMPdlWord_t;
 
typedef struct {
  uint32_t adc0 : 10;
  uint32_t adc1 : 10;
  uint32_t adc2 : 10;
  uint32_t mbz : 2;
} __attribute__((__packed__)) LTMAdcWord_t;
 
typedef struct {
  LTMDataHeader_t head;
  LTMPdlWord_t pdlData[12];
  //  48 PDL values        12 words
  LTMAdcWord_t adcData[36];
  //  16 Low Voltages       5 words  + 10 bit
  //  16 Thresholds         5 words  + 10 bit
  //   8 FEAC GND           2 words  + 10 bit
  //   8 FEAC Temp          2 words  + 10 bit
  //  12 LTM  Temp:         4 words
  //  48 OR trigger rates: 16 words
  //                       34 words + 2 words = 36 words
  LTMDataTrailer_t trailer;
} __attribute__((__packed__)) LTMPackedEvent_t;
#define LTM_EVSIZE sizeof(LTMPackedEvent_t) // fixed expected event size
#define LTM_PDL_FIELD(x, n) (((x) >> ((n)*8)) & 0xFF)
#define LTM_V_FIELD(x, n) (((x) >> ((n)*10)) & 0x3FF)
#define LTM_T_FIELD(x, n) (((x) >> ((n)*10)) & 0x3FF)
#define LTM_OR_FIELD(x, n) (((x) >> ((n)*10)) & 0x3FF)
 
typedef struct {
  uint32_t TagHead;
  uint32_t FaultFlag;
  uint32_t CycStatus;
  uint32_t EventSize;
  uint32_t HeadGeo;
  uint32_t PdlDelay[48];
  uint32_t Vlv[16];
  uint32_t Vth[16];
  uint32_t GndFeac[8];
  uint32_t FeacTemp[8];
  uint32_t LocalTemp[12];
  uint32_t OrRate[48];
  uint32_t EventNum;
  uint32_t EventCrc;
  uint32_t TailGeo;
  uint32_t TagTail;
} LTMEvent_t;
 
typedef union {
  uint32_t data;
  TOFDataHeader_t tofDataHeader;
  TOFOrbit_t tofOrbit;
  DRMDataHeader_t drmDataHeader;
  DRMHeadW1_t drmHeadW1;
  DRMHeadW2_t drmHeadW2;
  DRMHeadW3_t drmHeadW3;
  DRMHeadW4_t drmHeadW4;
  DRMHeadW5_t drmHeadW5;
  DRMDataTrailer_t drmDataTrailer;
  TRMDataHeader_t trmDataHeader;
  TRMDataTrailer_t trmDataTrailer;
  TRMChainHeader_t trmChainHeader;
  TRMChainTrailer_t trmChainTrailer;
  TRMDataHit_t trmDataHit;
} Union_t;
 
#ifdef __cplusplus
} // namespace raw
} // namespace tof
} // namespace o2
#endif
 
#endif