CbmTofStarData2019.h

Go to the documentation of this file.

// -----------------------------------------------------------------------------
// -----                                                                   -----
// -----                        CbmTofStarData2019                         -----
// -----               Created 13.01.2017 by P.-A. Loizeau                 -----
// -----                                                                   -----
// -----------------------------------------------------------------------------
 
#ifndef CbmTofStarData2019_H
#define CbmTofStarData2019_H
 
#include "gDpbMessv100.h"
 
#include "Rtypes.h"
 
#include <vector>
 
class CbmTofStarTrigger2019 {
public:
  // Constructors
  CbmTofStarTrigger2019(ULong64_t ulGdpbTsFullIn,
                        ULong64_t ulStarTsFullIn,
                        UInt_t uStarTokenIn,
                        UInt_t uStarDaqCmdIn,
                        UInt_t uStarTrigCmdIn,
                        UShort_t usGdpbId = 0);
 
  // Destructor
  ~CbmTofStarTrigger2019() {};
 
  // Setters
  inline void SetFullGdpbTs(ULong64_t ulGdpbTsFullIn) {
    fulGdpbTsFull = ulGdpbTsFullIn;
  }
  inline void SetFullStarTs(ULong64_t ulStarTsFullIn) {
    fulStarTsFull = ulStarTsFullIn;
  }
  inline void SetStarToken(UInt_t uStarTokenIn) { fuStarToken = uStarTokenIn; }
  inline void SetStarDaqCmd(UInt_t uStarDaqCmdIn) {
    fusStarDaqCmd = uStarDaqCmdIn;
  }
  inline void SetStarTRigCmd(UInt_t uStarTrigCmdIn) {
    fusStarTrigCmd = uStarTrigCmdIn;
  }
 
  // Accessors
  inline ULong64_t GetFullGdpbTs() const { return fulGdpbTsFull; }
  inline ULong64_t GetFullStarTs() const { return fulStarTsFull; }
  inline UInt_t GetStarToken() const { return fuStarToken; }
  inline UShort_t GetStarDaqCmd() const { return fusStarDaqCmd; }
  inline UShort_t GetStarTrigCmd() const { return fusStarTrigCmd; }
  UInt_t GetStarTrigerWord() const;
  UInt_t GetFullGdpbEpoch() const;
  std::vector<gdpbv100::FullMessage> GetGdpbMessages() const;
 
  // Operators
  bool operator<(const CbmTofStarTrigger2019& other) const;
 
private:
  UShort_t fusGdpbId;
  ULong64_t fulGdpbTsFull;
  ULong64_t fulStarTsFull;
  UInt_t fuStarToken;
  UShort_t fusStarDaqCmd;
  UShort_t fusStarTrigCmd;
 
  //      CbmTofStarTrigger2019(const CbmTofStarTrigger2019&);
  //      CbmTofStarTrigger2019 operator=(const CbmTofStarTrigger2019&);
 
  //   ClassDef(CbmTofStarTrigger2019, 1)
};
 
class CbmTofStarSubevent2019 {
  // Methods implementation can be found at the end of CbmTsMonitorTofStar.cxx!
public:
  // Constructors
  CbmTofStarSubevent2019();
  CbmTofStarSubevent2019(CbmTofStarTrigger2019 triggerIn, UShort_t sourceIdIn);
  CbmTofStarSubevent2019(const CbmTofStarSubevent2019&);
  CbmTofStarSubevent2019 operator=(const CbmTofStarSubevent2019&);
 
  // Destructor
  ~CbmTofStarSubevent2019();
 
  // Setters
  inline void SetTrigger(CbmTofStarTrigger2019 triggerIn) {
    fTrigger     = triggerIn;
    fbTriggerSet = kTRUE;
  }
  inline void SetSource(UShort_t sourceIdIn) {
    fusSourceId = sourceIdIn;
    fulEventStatusFlags =
      (fulEventStatusFlags & !(kulSourceIdMask << kulSourceIdOffset))
      | ((sourceIdIn & kulSourceIdMask) << kulSourceIdOffset);
  }
  inline void SetBadEventFlag(Bool_t bFlagState = kTRUE) {
    bFlagState ? (fulEventStatusFlags |= kulFlagBadEvt)
               : (fulEventStatusFlags &= ~(kulFlagBadEvt));
  }
  inline void SetOverlapEventFlag(Bool_t bFlagState = kTRUE) {
    bFlagState ? (fulEventStatusFlags |= kulFlagOverlapEvt)
               : (fulEventStatusFlags &= ~(kulFlagOverlapEvt));
  }
  inline void SetEmptyEventFlag(Bool_t bFlagState = kTRUE) {
    bFlagState ? (fulEventStatusFlags |= kulFlagEmptyEvt)
               : (fulEventStatusFlags &= ~(kulFlagEmptyEvt));
  }
  inline void SetStartBorderEventFlag(Bool_t bFlagState = kTRUE) {
    bFlagState ? (fulEventStatusFlags |= kulFlagStartBorderEvt)
               : (fulEventStatusFlags &= ~(kulFlagStartBorderEvt));
  }
  inline void SetEndBorderEventFlag(Bool_t bFlagState = kTRUE) {
    bFlagState ? (fulEventStatusFlags |= kulFlagEndBorderEvt)
               : (fulEventStatusFlags &= ~(kulFlagEndBorderEvt));
  }
  inline void SetIncompleteEventFlag(Bool_t bFlagState = kTRUE) {
    bFlagState ? (fulEventStatusFlags |= kulFlagIncompleteEvt)
               : (fulEventStatusFlags &= ~(kulFlagIncompleteEvt));
  }
  inline void AddMsg(const gdpbv100::FullMessage& msgIn) {
    fvMsgBuffer.push_back(msgIn);
    fuEventSizeBytes += 2 * sizeof(ULong64_t);
  }
 
  // Accessors
  inline CbmTofStarTrigger2019 GetTrigger() const { return fTrigger; }
  inline UShort_t GetSource() const { return fusSourceId; }
  inline Bool_t GetBadEventFlag() const {
    return 0 < (fulEventStatusFlags & kulFlagBadEvt);
  }
  inline Bool_t GetOverlapEventFlag() const {
    return 0 < (fulEventStatusFlags & kulFlagOverlapEvt);
  }
  inline Bool_t GetEmptyEventFlag() const {
    return 0 < (fulEventStatusFlags & kulFlagEmptyEvt);
  }
  inline Bool_t GetStartBorderEventFlag() const {
    return 0 < (fulEventStatusFlags & kulFlagStartBorderEvt);
  }
  inline Bool_t GetEndBorderEventFlag() const {
    return 0 < (fulEventStatusFlags & kulFlagEndBorderEvt);
  }
  inline Bool_t GetIncompleteEventFlag() const {
    return 0 < (fulEventStatusFlags & kulFlagIncompleteEvt);
  }
  inline Int_t GetEventSize() const { return fuEventSizeBytes; }
  inline gdpbv100::Message GetMsg(UInt_t uMsgIdx) const;
  inline UInt_t GetMsgBuffSize() const { return fvMsgBuffer.size(); }
  inline static uint32_t GetMaxOutputSize() { return kuMaxOutputSize; }
  inline Double_t GetEventTimeSec() const {
    return (1e-9) * gdpbv100::kdClockCycleSizeNs * fTrigger.GetFullGdpbTs();
  }
 
  // Content clearing
  void ClearSubEvent();
 
  // Sort content of output buffer
  void SortMessages();
 
  // Sub-event output
  void* BuildOutput(Int_t& iOutputSizeBytes);
 
  // Sub-event input
  Bool_t LoadInput(void* pBuff, Int_t iInputSizeBytes);
 
  // Print the heade and the messages in the buffer
  void PrintSubEvent();
 
private:
  static const uint32_t kuMaxOutputSize = 131072;  // 2^17
  static const uint32_t kuMaxNbMsgs =
    8190;  // 4 * 64b in header => floor( (2^17 / 8 ) - 4) / 2
  static const uint64_t kulFlagBadEvt = 0x1
                                        << 0;  
  static const uint64_t kulFlagOverlapEvt =
    0x1 << 1;  
  static const uint64_t kulFlagEmptyEvt = 0x1 << 2;  
  static const uint64_t kulFlagStartBorderEvt =
    0x1 << 3;  
  static const uint64_t kulFlagEndBorderEvt =
    0x1 << 4;  
  static const uint64_t kulFlagIncompleteEvt =
    0x1 << 5;  
  static const uint64_t kulSourceIdOffset  = 16;
  static const uint64_t kulSourceIdMask    = 0xFFFF;
  static const uint64_t kulEventSizeOffset = 32;
  static const uint64_t kulEventSizeMask   = 0xFFFFFFFF;
 
  Bool_t fbTriggerSet;
  CbmTofStarTrigger2019 fTrigger;
  UShort_t fusSourceId;
  ULong64_t fulEventStatusFlags;
  UInt_t fuEventSizeBytes;
  std::vector<gdpbv100::FullMessage> fvMsgBuffer;
  ULong64_t fpulBuff[kuMaxOutputSize];
 
 
  //   ClassDef(CbmTofStarSubevent2019, 1)
};
 
#endif