StsXyterMessage.h

Go to the documentation of this file.

/************************************************************
 *
 ************************************************************/
 
#ifndef STSXYTERMESSAGE_H
#define STSXYTERMESSAGE_H
 
// C/C++ headers
#include <iostream>
#include <stdint.h>
 
namespace stsxyter {
 
// tools: Use to this allow bitwise operations on C++11 enums
// This needs to be included in the same namespace to work...
#include "bitmask_operators.hpp"
 
  struct MessField {
    uint16_t fusPos;  
    uint16_t fusLen;  
 
    MessField(uint16_t usPos, uint16_t usLen) : fusPos(usPos), fusLen(usLen) {};
  };
  enum class MessType : uint16_t {
    Dummy,
    Hit,
    TsMsb,
    Epoch,
    Status,
    Empty,
    EndOfMs
  };
  enum class MessSubType : uint16_t {
    TsMsb  = 0,
    Epoch  = 1,
    Status = 2,
    Empty  = 3
  };
  enum class MessagePrintMask : uint16_t {
    msg_print_Prefix = (0x1 << 0),
    msg_print_Data   = (0x1 << 1),
    msg_print_Hex    = (0x1 << 2),
    msg_print_Human  = (0x1 << 3)
  };
  ENABLE_BITMASK_OPERATORS(stsxyter::MessagePrintMask)  // Preproc macro!
  enum class MsErrorFlags : uint16_t {
    MsErrOutFifoAlmostFull = (0x1 << 0),
    MsErrOutFifoOverflow   = (0x1 << 1),
    MsErrTimeoutBinReadout = (0x1 << 2),
    MsErrBinOverflow       = (0x1 << 3)
  };
 
  static const uint16_t kusPosNotHitFlag = 31;
  static const uint16_t kusPosLinkIndex  = 22;
  // Hit message
  static const uint16_t kusPosHitChannel = 15;
  static const uint16_t kusPosHitAdc     = 10;
  static const uint16_t kusPosHitTsOver  = 9;
  static const uint16_t kusPosHitTs      = 1;
  static const uint16_t kusPosHitEmFlag  = 0;
  // Non-hit messages
  static const uint16_t kusPosSubtype = 29;
  // TS_MSB message
  static const uint16_t kusPosTsMsbVal = 0;
  // Epoch
  static const uint16_t kusPosEpochVal = 0;
  // Status
  static const uint16_t kusPosStatLinkId = 20;
  static const uint16_t kusPosStatSxTs   = 14;
  static const uint16_t kusPosStatStatus = 10;
  static const uint16_t kusPosStatDpbTs  = 1;
  static const uint16_t kusPosStatCpFlag = 0;
  // Empty/End of MS
  static const uint16_t kusPosEmptyFlag = 28;
  static const uint16_t kusPosMsErrType = 1;
  static const uint16_t kusPosMsErrFlag = 0;
 
  static const uint16_t kusLenNotHitFlag = 1;
  static const uint16_t kusLenLinkIndex  = 9;
  // Hit message
  static const uint16_t kusLenHitChannel = 7;
  static const uint16_t kusLenHitAdc     = 5;
  static const uint16_t kusLenHitTsFull =
    9;  // Includes 1 bit overlap with TS message ?
  static const uint16_t kusLenHitTsOver = 0;  // 0 bit overlap with TS message
  static const uint16_t kusLenHitTs = 9;  // No overlap in this version of FW
  static const uint16_t kusLenHitEmFlag = 1;
  // Other message
  static const uint16_t kusLenSubtype = 2;
  // TS_MSB message
  static const uint16_t kusLenTsMsbVal        = 22;
  static const uint16_t kusLenTsMsbValBinning = 29;
  // Epoch
  static const uint16_t kusLenEpochVal = 29;
  // Status
  static const uint16_t kusLenStatLinkId = 9;
  static const uint16_t kusLenStatSxTs   = 6;
  static const uint16_t kusLenStatStatus = 4;
  static const uint16_t kusLenStatDpbTs  = 9;
  static const uint16_t kusLenStatCpFlag = 1;
  // Empty/End of MS
  static const uint16_t kusLenEmptyFlag = 1;
  static const uint16_t kusLenMsErrType = 4;
  static const uint16_t kusLenMsErrFlag = 1;
 
  static const MessField kFieldLinkIndex(kusPosLinkIndex, kusLenLinkIndex);
  static const MessField kFieldNotHitFlag(kusPosNotHitFlag, kusLenNotHitFlag);
  // Hit message
  static const MessField kFieldHitChannel(kusPosHitChannel, kusLenHitChannel);
  static const MessField kFieldHitAdc(kusPosHitAdc, kusLenHitAdc);
  static const MessField kFieldHitTsFull(kusPosHitTs, kusLenHitTsFull);
  static const MessField kFieldHitTsOver(kusPosHitTsOver, kusLenHitTsOver);
  static const MessField kFieldHitTs(kusPosHitTs, kusLenHitTs);
  static const MessField kFieldHitEmFlag(kusPosHitEmFlag, kusLenHitEmFlag);
  // Non-hit messages
  static const MessField kFieldSubtype(kusPosSubtype, kusLenSubtype);
  // TS_MSB message
  static const MessField kFieldTsMsbVal(kusPosTsMsbVal, kusLenTsMsbVal);
  static const MessField kFieldTsMsbValBinning(kusPosTsMsbVal,
                                               kusLenTsMsbValBinning);
  // Epoch message
  static const MessField kFieldEpochVal(kusPosEpochVal, kusLenEpochVal);
  // Status
  static const MessField kFieldStatLinkId(kusPosStatLinkId, kusLenStatLinkId);
  static const MessField kFieldStatSxTs(kusPosStatSxTs, kusLenStatSxTs);
  static const MessField kFieldStatStatus(kusPosStatStatus, kusLenStatStatus);
  static const MessField kFieldStatDpbTs(kusPosStatDpbTs, kusLenStatDpbTs);
  static const MessField kFieldStatCpFlag(kusPosStatCpFlag, kusLenStatCpFlag);
  // Empty/End of MS
  static const MessField kFieldEmptyFlag(kusPosEmptyFlag, kusLenEmptyFlag);
  static const MessField kFieldMsErrFlag(kusPosMsErrFlag, kusLenMsErrFlag);
  static const MessField kFieldMsErrType(kusPosMsErrType, kusLenMsErrType);
 
  static const uint32_t kuHitNbAdcBins =
    (0 < kusLenHitAdc ? 1 << kusLenHitAdc : 0);
  static const uint32_t kuHitNbTsBins =
    (0 < kusLenHitTs ? 1 << kusLenHitTs : 0);
  static const uint32_t kuHitNbOverBins =
    (0 < kusLenHitTsOver ? 1 << kusLenHitTsOver : 0);
  static const uint32_t kuTsMsbNbTsBins =
    (0 < kusLenTsMsbVal ? 1 << kusLenTsMsbVal : 0);
  static const uint64_t kulTsCycleNbBins =
    static_cast<uint64_t>(kuTsMsbNbTsBins)
    * static_cast<uint64_t>(kuHitNbTsBins);
  static const uint16_t kusMaskTsMsbOver = (1 << kusLenHitTsOver) - 1;
  static const double kdClockCycleNs =
    3.125;  // ns, equivalent to 2*160 MHz clock
  static const uint32_t kuHitNbTsBinsBinning = 1 << 10;
  static const uint64_t kulTsCycleNbBinsBinning =
    static_cast<uint64_t>(1 << kusLenTsMsbValBinning)
    * static_cast<uint64_t>(kuHitNbTsBinsBinning);
 
  class Message {
  private:
  protected:
    uint32_t fuData;  // main and only storage field for the message
 
  public:
    Message() : fuData(0) {}
 
    Message(const Message& src) : fuData(src.fuData) {}
 
    Message(uint32_t uDataIn) : fuData(uDataIn) {}
 
    ~Message() {};
 
    void assign(const Message& src) { fuData = src.fuData; }
 
    Message& operator=(const Message& src) {
      assign(src);
      return *this;
    }
 
    inline void reset() { fuData = 0; }
 
    // --------------------------- Accessors ---------------------------------
    inline uint32_t GetData() const { return fuData; }
    inline void SetData(uint32_t uValue) { fuData = uValue; }
 
    inline uint32_t GetField(uint32_t uShift, uint32_t uLen) const {
      return (fuData >> uShift) & (((static_cast<uint32_t>(1)) << uLen) - 1);
    }
 
    inline uint8_t GetBit(uint32_t uShift) const {
      return (fuData >> uShift) & 1;
    }
 
    inline uint32_t GetFieldBE(uint32_t uShift, uint32_t uLen) const {
      return (DataBE() >> uShift) & (((static_cast<uint32_t>(1)) << uLen) - 1);
    }
    inline uint8_t GetBitBE(uint32_t uShift) const {
      return (DataBE() >> uShift) & 1;
    }
    inline uint32_t DataBE() const {
      return ((fuData & 0x000000FF) << 24) + ((fuData & 0x0000FF00) << 8)
             + ((fuData >> 8) & 0x0000FF00) + ((fuData >> 24) & 0x000000FF);
    }
 
    // --------------------------- Setters ---------------------------------------
    inline void SetField(uint32_t uShift, uint32_t uLen, uint32_t uValue) {
      fuData =
        (fuData & ~((((static_cast<uint32_t>(1)) << uLen) - 1) << uShift))
        | ((static_cast<uint64_t>(uValue)) << uShift);
    }
 
    inline void SetBit(uint32_t uShift, uint8_t uValue) {
      fuData = uValue ? (fuData | ((static_cast<uint32_t>(1)) << uShift))
                      : (fuData & ~((static_cast<uint32_t>(1)) << uShift));
    }
 
    // --------------------------- Simplified Acc_or/Setters ---------------------
    inline uint32_t GetField(MessField field) const {
      return GetField(field.fusPos, field.fusLen);
    }
    inline uint8_t GetBit(MessField field) const {
      return GetBit(field.fusPos);
    }
    inline bool GetFlag(MessField field) const {
      return (1 == GetBit(field.fusPos));
    }
    inline uint32_t GetFieldBE(MessField field) const {
      return GetFieldBE(field.fusPos, field.fusLen);
    }
    inline uint8_t GetBitBE(MessField field) const {
      return GetBitBE(field.fusPos);
    }
 
    inline void SetField(MessField field, uint32_t uValue) {
      SetField(field.fusPos, field.fusLen, uValue);
    }
    inline void SetBit(MessField field, uint8_t ucValue) {
      SetBit(field.fusPos, ucValue);
    }
 
    // --------------------------- common fields ---------------------------------
    inline uint16_t GetLinkIndex() const { return GetField(kFieldLinkIndex); }
    inline bool IsHit() const { return !GetFlag(kFieldNotHitFlag); }
    inline bool IsDummy() const { return IsHit() && (0 == GetHitAdc()); }
    inline bool IsTsMsb() const {
      return (!IsHit() && MessSubType::TsMsb == GetSubType());
    }
    inline MessType GetMessType() const {
      return !GetFlag(kFieldNotHitFlag)
               ? (0 == GetHitAdc() ? MessType::Dummy : MessType::Hit)
               : (MessSubType::TsMsb == GetSubType()
                    ? MessType::TsMsb
                    : (MessSubType::Epoch == GetSubType()
                         ? MessType::Epoch
                         : (MessSubType::Status == GetSubType()
                              ? MessType::Status
                              : (IsEmptyMsg() ? MessType::Empty
                                              : MessType::EndOfMs))));
    }
 
    // ------------------------ Hit message fields -------------------------------
    inline uint16_t GetHitChannel() const { return GetField(kFieldHitChannel); }
 
    inline uint16_t GetHitAdc() const { return GetField(kFieldHitAdc); }
 
    inline uint16_t GetHitTimeFull() const { return GetField(kFieldHitTsFull); }
 
    inline uint16_t GetHitTimeOver() const { return GetField(kFieldHitTsOver); }
 
    inline uint16_t GetHitTime() const { return GetField(kFieldHitTs); }
 
    inline uint16_t GetHitTimeBinning() const {
      return ((static_cast<uint16_t>(GetBit(30)) << 9) + GetField(kFieldHitTs));
    }
 
    inline uint16_t GetLinkIndexHitBinning() const {
      return GetField(kFieldLinkIndex) & 0x3F;
    }
 
    inline bool IsHitMissedEvts() const { return GetFlag(kFieldHitEmFlag); }
 
    inline void SetHitChannel(uint16_t usVal) {
      SetField(kFieldHitChannel, usVal);
    }
 
    inline void SetHitAdc(uint16_t usVal) { SetField(kFieldHitAdc, usVal); }
 
    inline void SetHitTimeFull(uint16_t usVal) {
      SetField(kFieldHitTsFull, usVal);
    }
 
    inline void SetHitTimeOver(uint16_t usVal) {
      SetField(kFieldHitTsOver, usVal);
    }
 
    inline void SetHitTime(uint16_t usVal) { SetField(kFieldHitTs, usVal); }
 
    inline void SetHitMissEvtsFlag(bool bVal) { SetBit(kFieldHitEmFlag, bVal); }
 
    // ----------------------- Non-Hit message fields ----------------------------
    //         inline MessSubType GetSubType() const { return static_cast< uint16_t >( GetField( kFieldSubtype ) ); }
    MessSubType GetSubType() const;
 
    // ------------------------ TS_MSB message fields ----------------------------
    inline uint32_t GetTsMsbVal() const { return GetField(kFieldTsMsbVal); }
 
    inline uint32_t GetTsMsbValBinning() const {
      return GetField(kFieldTsMsbValBinning);
    }
 
    inline void SetTsMsbVal(uint32_t uVal) { SetField(kFieldTsMsbVal, uVal); }
 
    // ------------------------ Epoch message fields -----------------------------
    inline uint32_t GetEpochVal() const { return GetField(kFieldEpochVal); }
 
    inline void SetEpochVal(uint32_t uVal) { SetField(kFieldEpochVal, uVal); }
 
    // ------------------------ Status message fields ----------------------------
    inline uint16_t GetStatusLink() const { return GetField(kFieldStatLinkId); }
 
    inline uint16_t GetStatusSxTs() const { return GetField(kFieldStatSxTs); }
 
    inline uint16_t GetStatusStatus() const {
      return GetField(kFieldStatStatus);
    }
 
    inline uint16_t GetStatusDpbTs() const { return GetField(kFieldStatDpbTs); }
 
    inline bool IsCpFlagOn() const { return GetField(kFieldStatCpFlag); }
 
    inline void SetStatusLink(uint16_t usVal) {
      SetField(kFieldStatLinkId, usVal);
    }
 
    inline void SetStatusSxTs(uint16_t usVal) {
      SetField(kFieldStatSxTs, usVal);
    }
 
    inline void SetStatusStatus(uint16_t usVal) {
      SetField(kFieldStatStatus, usVal);
    }
 
    inline void SetStatusDpbTs(uint16_t usVal) {
      SetField(kFieldStatDpbTs, usVal);
    }
 
    inline void SetCpFlag(bool bVal) { SetField(kFieldStatCpFlag, bVal); }
 
    // -------------------- Empty/End of MS message fields -----------------------
    inline bool IsEmptyMsg() const { return GetField(kFieldEmptyFlag); }
 
    inline bool IsMsErrorFlagOn() const { return GetField(kFieldMsErrFlag); }
 
    inline uint16_t GetMsErrorType() const { return GetField(kFieldMsErrType); }
 
    inline void SetEmptyMsgFlag(bool bVal) { SetField(kFieldEmptyFlag, bVal); }
 
    inline void SetMsErrorFlag(bool bVal) { SetField(kFieldMsErrFlag, bVal); }
 
    inline void SetMsErrorType(uint16_t usVal) {
      SetField(kFieldMsErrType, usVal);
    }
 
    // ------------------------ General OP ---------------------------------------
    bool
    PrintMess(std::ostream& os,
              MessagePrintMask ctrl = MessagePrintMask::msg_print_Human) const;
  };
}  // namespace stsxyter
#endif  // STSXYTERMESSAGE_H