AccDataSis18.h

Go to the documentation of this file.

/* Copyright (C) 2022-2025 Facility for Antiproton and Ion Research in Europe, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Pierre-Alain Loizeau [committer] */
 
#ifndef ACCDATASIS18_H
#define ACCDATASIS18_H 1
 
#include <Rtypes.h>  // for THashConsistencyHolder, ClassDef
 
#include <cstdint>
#include <string>
#include <vector>
 
class AccTimingEvent {
public:
  AccTimingEvent() = default;
 
  AccTimingEvent(uint64_t ulPlannedUTCIn, uint64_t ulPlannedTAIIn, uint64_t ulRawEventIn, uint64_t ulRawParamsIn,
                 uint32_t uRawTimingFlagsIn, uint64_t ulExecutedUTCIn, uint64_t ulExecutedTAIIn);
 
  AccTimingEvent(std::string sLine, bool bVerbose = false);
 
  virtual ~AccTimingEvent() = default;
 
  void Print() const;
 
  uint32_t GetGroupId() const { return ((fulRawEvent >> kOffsetGroupId) & ((1ULL << kNbBitsGroupId) - 1)); }
  uint32_t GetEventId() const { return ((fulRawEvent >> kOffsetEventId) & ((1ULL << kNbBitsEventId) - 1)); }
 
  uint64_t GetTime() const { return fulPlannedUTC; }
 
  inline bool IsCycleStart() const { return (kEventIdStartCycle == GetEventId()); }
  inline bool IsCycleEnd() const { return (kEventIdEndCycle == GetEventId()); }
  inline bool IsExtractionStart() const { return (kEventIdExtrStartSlow == GetEventId()); }
  inline bool IsExtractionEnd() const { return (kEventIdExtrEnd == GetEventId()); }
  inline bool IsKickerStart() const { return (kEventIdExtrKickerStart == GetEventId()); }
  inline bool IsExtractionStopSlow() const { return (kEventIdExtrStopSlow == GetEventId()); }
 
  inline bool operator<(const AccTimingEvent& rhs) const { return fulPlannedUTC < rhs.fulPlannedUTC; }
  inline bool operator<(const uint64_t& rhs) const { return fulPlannedUTC < rhs; }

  friend bool operator<(const uint64_t& lhs, const AccTimingEvent& rhs) { return lhs < rhs.fulPlannedUTC; }
 
private:
  static const uint32_t kNbBitsFormatId   = 4;  // Content of field should always be 1!!
  static const uint32_t kNbBitsGroupId    = 12;
  static const uint32_t kNbBitsEventId    = 12;
  static const uint32_t kNbBitsFlags      = 4;
  static const uint32_t kNbBitsSequenceId = 12;
  static const uint32_t kNbBitsBeamProcId = 14;
  static const uint32_t kNbBitsReserved   = 6;
  static const uint32_t kOffsetReserved   = 0;
  static const uint32_t kOffsetBeamProcId = kOffsetReserved + kNbBitsReserved;
  static const uint32_t kOffsetSequenceId = kOffsetBeamProcId + kNbBitsBeamProcId;
  static const uint32_t kOffsetFlags      = kOffsetSequenceId + kNbBitsSequenceId;
  static const uint32_t kOffsetEventId    = kOffsetFlags + kNbBitsFlags;
  static const uint32_t kOffsetGroupId    = kOffsetEventId + kNbBitsEventId;
  static const uint32_t kOffsetFormatId   = kOffsetGroupId + kNbBitsGroupId;
  static const uint32_t kEventIdStartCycle      = 32;
  static const uint32_t kEventIdExtrStartSlow   = 46;
  static const uint32_t kEventIdExtrKickerStart = 49;
  static const uint32_t kEventIdExtrEnd         = 51;
  static const uint32_t kEventIdEndCycle        = 55;
  static const uint32_t kEventIdExtrStopSlow    = 78;

  uint64_t fulPlannedUTC    = 0;
  uint64_t fulPlannedTAI    = 0;
  uint64_t fulRawEvent      = 0;
  uint64_t fulRawParams     = 0;
  uint32_t fuRawTimingFlags = 0;
  uint64_t fulExecutedUTC   = 0;
  uint64_t fulExecutedTAI   = 0;
 
  ClassDef(AccTimingEvent, 1);
};
 
//--------------------------------------------------------------------------------------------------------------------//
 
class AccPatternEvent {
 public:
  AccPatternEvent() = default;
 
  AccPatternEvent(uint64_t ulPlannedUTCIn, uint64_t ulPlannedTAIIn, bool bHtdPatternOnIn, uint64_t ulExecutedUTCIn,
                  uint64_t ulExecutedTAIIn);
 
  AccPatternEvent(std::string sLine, bool bVerbose = false);
 
  virtual ~AccPatternEvent() = default;
 
  void Print() const;
 
  uint64_t GetTime() const { return fulPlannedUTC; }
 
  inline bool IsHtdOn() const { return fbHtdPatternOn; }
  inline bool IsMcbmOn() const { return IsHtdOn(); }  // More obvious alias for non-expert users
 
  inline bool operator<(const AccPatternEvent& rhs) const { return fulPlannedUTC < rhs.fulPlannedUTC; }
  inline bool operator<(const uint64_t& rhs) const { return fulPlannedUTC < rhs; }

  friend bool operator<(const uint64_t& lhs, const AccPatternEvent& rhs) { return lhs < rhs.fulPlannedUTC; }
 
 private:

  uint64_t fulPlannedUTC  = 0;
  uint64_t fulPlannedTAI  = 0;
  bool fbHtdPatternOn     = false;
  uint64_t fulExecutedUTC = 0;
  uint64_t fulExecutedTAI = 0;
 
  ClassDef(AccPatternEvent, 1);
};
 
//--------------------------------------------------------------------------------------------------------------------//
 
class AccStatusTs {
public:
  AccStatusTs() = default;
 
  AccStatusTs(uint32_t uSpillIdx, AccTimingEvent lastEvtBefTs)
    : fuSpillIndexAtStart(uSpillIdx)
    , fLastEvtBeforeTs(lastEvtBefTs)
  {
  }
 
  virtual ~AccStatusTs() = default;
 
  void SetLastEvtBefTs(AccTimingEvent lastEvtBefTs) { fLastEvtBeforeTs = lastEvtBefTs; }
  void SetLastPatternBefTs(AccPatternEvent lastPatternBefTs) { fLastPatternBeforeTs = lastPatternBefTs; }

  inline bool IsCycleOnAtStart() const { return !(fLastEvtBeforeTs.IsCycleEnd()); }
  inline bool IsSpillOnAtStart() const { return fLastEvtBeforeTs.IsExtractionStart(); }
  inline bool IsPatternOnAtStart() const { return fLastPatternBeforeTs.IsHtdOn(); }
 
  bool IsSpillOnAtTime(uint64_t uTimeUtc) const;
  uint32_t GetSpillIdxAtTime(uint64_t uTimeUtc) const;
 
  bool IsPatternOnAtTime(uint64_t uTimeUtc) const;
  bool IsMcbmSpillOnAtTime(uint64_t uTimeUtc) const
  {
    return (IsPatternOnAtTime(uTimeUtc) && IsSpillOnAtTime(uTimeUtc));
  }

  uint32_t fuSpillIndexAtStart                    = 0;
  AccTimingEvent fLastEvtBeforeTs                 = {};
  AccPatternEvent fLastPatternBeforeTs            = {};
  std::vector<AccTimingEvent> fvEventsDuringTS    = {};
  std::vector<AccPatternEvent> fvPatternsDuringTS = {};
 
  ClassDef(AccStatusTs, 1);
};
//--------------------------------------------------------------------------------------------------------------------//
 
#endif /* ACCDATASIS18_H */