PsdGbtDataFormat.h

Go to the documentation of this file.

// -----------------------------------------------------------------------------
// -----                                                                   -----
// -----                       PsdGbtDataFormat                            -----
// -----              Created 14.09.2019 by N.Karpushkin                   -----
// -----                                                                   -----
// -----------------------------------------------------------------------------
 
#ifndef PSD_GBT_DATA_FORMAT_H_
#define PSD_GBT_DATA_FORMAT_H_
 
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <vector>
 
namespace PsdData {
 
  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 PsdData
 
 
#endif /* PSD_GBT_DATA_FORMAT_H_ */