PsdGbtDataFormat-v0.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_H_
#define PSD_GBT_DATA_FORMAT_H_
 
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <vector>
 
namespace PsdDataV000
{
 
  struct PsdEventHeaderAB {
    enum bitFieldSizes
    {
      MWs = 8,  
      HNs = 8,  
      MSs = 64  
    };
 
    uint8_t uMagicWordAB : MWs;   
    uint8_t uHitsNumber : HNs;    
    uint64_t ulMicroSlice : MSs;  
 
    void printout()
    {
      printf("magic word AB: %u; hits number: %u; microslice: %llu\n", uMagicWordAB, uHitsNumber,
             static_cast<long long unsigned int>(ulMicroSlice));
    }
 
    void clear()
    {
      uMagicWordAB = 0;
      uHitsNumber  = 0;
      ulMicroSlice = 0;
    }
 
    PsdEventHeaderAB() { clear(); }
  };
 
 
  struct PsdEventHeaderAC {
    enum bitFieldSizes
    {
      MWs = 8,   
      PVs = 8,   
      E0s = 32,  
      TMs = 32   
    };
 
    uint8_t uMagicWordAC : MWs;    
    uint8_t uPacketVersion : PVs;  
    uint32_t uEmpty0 : E0s;        
    uint32_t uAdcTime : TMs;       
 
    void printout()
    {
      printf("magic word AC: %u; packet version: %u; ADC time in microslice: %u\n", uMagicWordAC, uPacketVersion,
             uAdcTime);
    }
 
    void clear()
    {
      uMagicWordAC   = 0;
      uPacketVersion = 0;
      uEmpty0        = 0;
      uAdcTime       = 0;
    }
 
    PsdEventHeaderAC() { clear(); }
  };
 
 
  struct PsdHitHeader {
    enum bitFieldSizes
    {
      WPSs = 8,   
      HCs  = 8,   
      E0s  = 32,  
      SCs  = 16,  
      ZLs  = 16   
    };
 
    uint8_t uWfmPoints : WPSs;     
    uint8_t uHitChannel : HCs;     
    uint32_t uEmpty0 : E0s;        
    uint16_t uSignalCharge : SCs;  
    uint16_t uZeroLevel : ZLs;     
 
    void printout()
    {
      printf("waveform points: %u; hit channel: %u; signal charge: %u; zero "
             "level: %u\n",
             uWfmPoints, uHitChannel, uSignalCharge, uZeroLevel);
    }
 
    void clear()
    {
      uWfmPoints    = 0;
      uHitChannel   = 0;
      uEmpty0       = 0;
      uSignalCharge = 0;
      uZeroLevel    = 0;
    }
 
    PsdHitHeader() { clear(); }
  };
 
 
  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(); }
  };
 
}  // namespace PsdDataV000
 
 
#endif /* PSD_GBT_DATA_FORMAT_H_ */