PsdGbtDataFormat-v1.00.h

Go to the documentation of this file.

/* Copyright (C) 2019-2021 Institute for Nuclear Research, Moscow
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Nikolay Karpushkin [committer]*/
 
#ifndef PSD_GBT_DATA_FORMAT_V100_H_
#define PSD_GBT_DATA_FORMAT_V100_H_
 
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <vector>
 
namespace PsdDataV100
{
 
  struct PsdMsHeader {
    enum bitFieldSizes
    {
      MWs = 8,  
      E0s = 8,  
      MSs = 64  
    };
 
    uint8_t uMagicWord : MWs;     
    uint8_t uEmpty0 : E0s;        
    uint64_t ulMicroSlice : MSs;  
 
    void printout()
    {
      printf("MS magic word: %x; microslice: %llu\n", uMagicWord, static_cast<long long unsigned int>(ulMicroSlice));
    }
 
    void clear()
    {
      uMagicWord   = 0;
      uEmpty0      = 0;
      ulMicroSlice = 0;
    }
 
    PsdMsHeader() { clear(); }
 
  };  //PsdMsHeader;
 
 
  struct PsdPackHeader {
    enum bitFieldSizes
    {
      MWs = 4,   
      LIs = 4,   
      E0s = 24,  
      HNs = 8,   
      TWs = 8,   
      TMs = 32   
    };
 
    uint8_t uMagicWord : MWs;   
    uint8_t uLinkIndex : LIs;   
    uint32_t uEmpty0 : E0s;     
    uint8_t uHitsNumber : HNs;  
    uint8_t uTotalWords : TWs;  
    uint32_t uAdcTime : TMs;    
 
    void printout()
    {
      printf("Pack magic word: %x; link: %u; total hits: %u; total gbt words: %u; ADC time in microslice: %u\n",
             uMagicWord, uLinkIndex, uHitsNumber, uTotalWords, uAdcTime);
    }
 
    void clear()
    {
      uMagicWord  = 0;
      uLinkIndex  = 0;
      uEmpty0     = 0;
      uHitsNumber = 0;
      uTotalWords = 0;
      uAdcTime    = 0;
    }
 
    PsdPackHeader() { clear(); }
 
  };  //PsdPackHeader;
 
 
  struct PsdHitHeader {
    enum bitFieldSizes
    {
      HCs = 8,   
      WWs = 8,   
      FAs = 16,  
      E0s = 12,  
      SCs = 20,  
      ZLs = 16   
    };
 
    uint8_t uHitChannel : HCs;     
    uint8_t uWfmWords : WWs;       
    uint32_t uFeeAccum : FAs;      
    uint32_t uEmpty0 : E0s;        
    uint32_t uSignalCharge : SCs;  
    uint16_t uZeroLevel : ZLs;     
 
    void printout()
    {
      printf("hit channel: %u; waveform words: %u; fee accumulator: %u; signal charge: %u; zero level: %u\n",
             uHitChannel, uWfmWords, uFeeAccum, uSignalCharge, uZeroLevel);
    }
 
    void clear()
    {
      uHitChannel   = 0;
      uWfmWords     = 0;
      uFeeAccum     = 0;
      uEmpty0       = 0;
      uSignalCharge = 0;
      uZeroLevel    = 0;
    }
 
    PsdHitHeader() { clear(); }
 
  };  //PsdHitHeader;
 
 
  struct PsdHitData {
    enum bitFieldSizes
    {
      E0s = 16,  
      WPs = 16   
    };
 
    uint16_t uEmpty0 : E0s;      
    std::vector<uint16_t> uWfm;  
 
    void printout()
    {
      printf("waveform: ");
      for (uint8_t iter = 0; iter < uWfm.size(); iter++)
        printf("%u ", uWfm.at(iter));
      printf("\n");
    }
 
    void clear()
    {
      uEmpty0 = 0;
      uWfm.clear();
    }
 
    PsdHitData() { clear(); }
 
  };  //PsdHitData;
 
 
  struct PsdMsTrailer {
    enum bitFieldSizes
    {
      E0s = 64,  
    };
 
    uint64_t uEmpty0 : E0s;  
 
    void printout() { printf("trailer: %llu\n", static_cast<long long unsigned int>(uEmpty0)); }
 
    void clear() { uEmpty0 = 0; }
 
    PsdMsTrailer() { clear(); }
 
  };  //PsdMsTrailer;
 
 
}  // namespace PsdDataV100
 
 
#endif /* PSD_GBT_DATA_FORMAT_V100_H_ */