BmnSpillHeader.h

Go to the documentation of this file.

#ifndef BMNSPILLHEADER_H
#define BMNSPILLHEADER_H
// STL
#include <chrono>
#include <map>
#include <unordered_map>
//  ROOT
#include <TTimeStamp.h>
// bmnroot
#include "BmnAliases.h"
#include "BmnEnums.h"
#include "BmnFunctionSet.h"
#include "RawTypes.h"
 
using SysClock = std::chrono::system_clock;
using SysPoint = std::chrono::time_point<SysClock>;
using std::array;
using std::string;
using std::vector;
 
typedef std::map<string, vector<std::pair<SysPoint, UInt_t>>> ScalerNameSliceCntMap;
 
class BmnSpillHeader : public TObject
{
  private:
    /** Event Id **/
    UInt_t fEventIdStart;
    /** Event Id **/
    UInt_t fEventIdEnd;
    /** Event count **/
    UInt_t fEventCnt;
    /** Period Id **/
    UInt_t fPeriodId;
    /** Spill Id **/
    UInt_t fSpillId;
    //    SysPoint fStartTS;
    //    SysPoint fStopTS;
    //    SysPoint fFirstEventTS;
    //    SysPoint fLastEventTS;
    TTimeStamp fStartTS;
    TTimeStamp fStopTS;
    TTimeStamp fFirstEventTS;
    TTimeStamp fLastEventTS;
    //    ScalerNameSliceCntMap fScalers;   // name -> count for each time slice
    MapString2Cnt fScalersTotal;     // name -> total spill MSC count
                                     //    vector<uint64_t> fScalersVec;
    MapString2Cnt fEventTrigCount;   // name -> total spill trigger (TRC bit inside events)
 
    //    Name2SerCh fScalersMap;
    array<UInt_t, kT0_BIN_BLOCK_WORDS> fRawT0Cntrs;
 
    UInt_t fBeamTrigger;
    UInt_t fBTnBusy;
    UInt_t fL0;
    UInt_t fTrigProtection;
    UInt_t fBC1;
    UInt_t fBC2;
    UInt_t fBC3;
    UInt_t fAccepted;
    UInt_t fCand;
    UInt_t fBP;
    UInt_t fAP;
    UInt_t fRj;
    UInt_t fAll;
    UInt_t fAvail;
 
  public:
    /** Constructor */
    BmnSpillHeader(UInt_t period_id = 0, UInt_t event_id = 0);
 
    /** Destructor */
    virtual ~BmnSpillHeader();
 
    void Clear();
 
    /** Get the the first event ID for the spill */
    UInt_t GetFirstEventId() { return fEventIdStart; }
    /** Get the the last event ID for the spill */
    UInt_t GetLastEventId() { return fEventIdEnd; }
    /** Get the event count in the spill */
    UInt_t GetNEvents() { return fEventCnt; }
 
    /** Get the period ID */
    UInt_t GetPeriodId() { return fPeriodId; }
 
    /** Get the spill ID */
    UInt_t GetSpillId() { return fSpillId; }
 
    //    ScalerNameSliceCntMap& ScalersVec() { return fScalers; }
 
    //    vector<uint64_t>& ScalersVec() { return fScalersVec; }
 
    MapString2Cnt& Scalers() { return fScalersTotal; }
 
    MapString2Cnt& EventTriggerCnt() { return fEventTrigCount; }
 
    array<UInt_t, kT0_BIN_BLOCK_WORDS>& RawT0Counters() { return fRawT0Cntrs; }
 
    /** Get the start TS */
    const SysPoint GetStartTime() { return BmnFunctionSet::TimeStamp2TP(fStartTS); }
 
    /** Get the stop TS */
    const SysPoint GetStopTime() { return BmnFunctionSet::TimeStamp2TP(fStopTS); }
 
    /** Get the start TS */
    const TTimeStamp& GetStartTS() { return fStartTS; }
    //    const TTimeStamp GetStartTS() { return BmnFunctionSet::TimePoint2TS(fStartTS); }
 
    /** Get the stop TS */
    const TTimeStamp& GetStopTS() { return fStopTS; }
    //    const TTimeStamp GetStopTS() { return BmnFunctionSet::TimePoint2TS(fStopTS); }
 
    /** Get time the first event in the spill */
    const SysPoint GetFirstEventTime() { return BmnFunctionSet::TimeStamp2TP(fFirstEventTS); }
 
    /** Get time the last event in the spill */
    const SysPoint GetLastEventTime() { return BmnFunctionSet::TimeStamp2TP(fLastEventTS); }
 
    /** Get time the first event in the spill */
    const TTimeStamp& GetFirstEventTS() { return fFirstEventTS; }
    //    const TTimeStamp GetFirstEventTS() { return BmnFunctionSet::TimePoint2TS(fFirstEventTS); }
 
    /** Get time the last event in the spill */
    const TTimeStamp& GetLastEventTS() { return fLastEventTS; }
    //    const TTimeStamp GetLastEventTS() { return BmnFunctionSet::TimePoint2TS(fLastEventTS); }
 
    void SetCand(UInt_t _v) { fCand = _v; }
 
    UInt_t GetCand() { return fCand; }
 
    void SetAccepted(UInt_t _v) { fAccepted = _v; }
 
    UInt_t GetAccepted() { return fAccepted; }
 
    void SetBefo(UInt_t _v) { fBP = _v; }
 
    UInt_t GetBefo() { return fBP; }
 
    void SetAfter(UInt_t _v) { fAP = _v; }
 
    UInt_t GetAfter() { return fAP; }
 
    void SetRjct(UInt_t _v) { fRj = _v; }
 
    UInt_t GetRjct() { return fRj; }
 
    void SetAll(UInt_t _v) { fAll = _v; }
 
    UInt_t GetAll() { return fAll; }
 
    void SetAvail(UInt_t _v) { fAvail = _v; }
 
    UInt_t GetAvail() { return fAvail; }
 
    void SetBT(UInt_t _v) { fBeamTrigger = _v; }
 
    UInt_t GetBT() { return fBeamTrigger; }
 
    void SetBTnBusy(UInt_t _v) { fBTnBusy = _v; }
 
    UInt_t GetBTnBusy() { return fBTnBusy; }
 
    void SetL0(UInt_t _v) { fL0 = _v; }
 
    UInt_t GetL0() { return fL0; }
 
    void SetProt(UInt_t _v) { fTrigProtection = _v; }
 
    UInt_t GetProt() { return fTrigProtection; }
 
    void SetBC1(UInt_t _v) { fBC1 = _v; }
 
    UInt_t GetBC1() { return fBC1; }
 
    void SetBC2(UInt_t _v) { fBC2 = _v; }
 
    UInt_t GetBC2() { return fBC2; }
 
    void SetBC3(UInt_t _v) { fBC3 = _v; }
 
    UInt_t GetBC3() { return fBC3; }
 
    /** Set the first event ID for the spill
     * @param event_id : unique event id
     */
    void SetFirstEventId(UInt_t event_id) { fEventIdStart = event_id; }
 
    /** Set the last event ID for the spill
     * @param event_id : unique event id
     */
    void SetLastEventId(UInt_t event_id) { fEventIdEnd = event_id; }
 
    /** Set the event count in the spill */
    void SetNEvents(UInt_t events) { fEventCnt = events; }
 
    /** Set the period ID
     * @param period_id : unique period id
     */
    void SetPeriodId(UInt_t period_id) { fPeriodId = period_id; }
 
    /** Set the spill ID
     * @param spill : spill id
     */
    void SetSpillId(UInt_t spill) { fSpillId = spill; }
 
    /** Set the time for spill start */
    void SetStartTime(const SysPoint& time) { fStartTS = BmnFunctionSet::TimePoint2TS(time); }
 
    /** Set the time for spill stop */
    void SetStopTime(const SysPoint& time) { fStopTS = BmnFunctionSet::TimePoint2TS(time); }
 
    /** Set the time for spill start */
    void SetStartTS(const TTimeStamp& ts) { fStartTS = ts; }
    //    void SetStartTS(TTimeStamp ts) { fStartTS = BmnFunctionSet::TimeStamp2TP(ts); }
 
    /** Set the time for spill stop */
    void SetStopTS(const TTimeStamp& ts) { fStopTS = ts; }
    //    void SetStopTS(TTimeStamp ts) { fStopTS = BmnFunctionSet::TimeStamp2TP(ts); }
 
    /** Set the time for the first event in the spill */
    void SetFirstEventTime(const SysPoint& time) { fFirstEventTS = BmnFunctionSet::TimePoint2TS(time); }
 
    /** Set the time for the last event in the spill */
    void SetLastEventTime(const SysPoint& time) { fLastEventTS = BmnFunctionSet::TimePoint2TS(time); }
 
    /** Set the time for the first event in the spill */
    void SetFirstEventTS(const TTimeStamp& ts) { fFirstEventTS = ts; }
    //    void SetFirstEventTS(TTimeStamp ts) { fFirstEventTS = BmnFunctionSet::TimeStamp2TP(ts); }
 
    /** Set the time for the last event in the spill */
    void SetLastEventTS(const TTimeStamp& ts) { fLastEventTS = ts; }
    //    void SetLastEventTS(TTimeStamp ts) { fLastEventTS = BmnFunctionSet::TimeStamp2TP(ts); }
 
    ClassDef(BmnSpillHeader, 12)
};
 
#endif /* BMNSPILLHEADER_H */