BmnEventHeader.h

Go to the documentation of this file.

#ifndef BMNEVENTHEADER_H
#define BMNEVENTHEADER_H
 
#include <map>
#include <unordered_map>
#include <vector>
// ROOT
#include "TTimeStamp.h"
// FairRoot
#include "FairEventHeader.h"
// BmnRoot
#include "BmnEnums.h"
#include "BmnFunctionSet.h"
#include "BmnTrigInfo.h"
#include "BmnTrigUnion.h"
 
using SysClock = std::chrono::system_clock;
using SysPoint = std::chrono::time_point<SysClock>;
using std::map;
using std::unordered_map;
using std::vector;
 
class BmnEventHeader : public FairEventHeader
{
  private:
    TString fHeaderName;   
 
    UInt_t fEventId;
    UInt_t fPeriodId;
    TTimeStamp fEventTimeTS;
    TTimeStamp fEventVspTS;
    BmnEventType fEventType;
    Bool_t fTripWord;
    Bool_t fSpillStart;
    Double_t fStartSignalTime;    // ns
    Double_t fStartSignalWidth;   // ns
    BmnTrigInfo fTrigInfo;
    //    UInt_t fTrigUnion;
    UInt_t fInputsAR;
    UInt_t fInputsBR;
    vector<uint32_t> fInputsVec;
    TTimeStamp fSpillStartTS;
    Int_t fSpillId;
 
    unordered_map<UInt_t, Long64_t> fTimeShift;
 
  public:
    BmnEventHeader();
 
    BmnEventHeader(UInt_t run_id,
                   UInt_t event_id,
                   TTimeStamp event_time,
                   BmnEventType event_type,
                   Bool_t trip,
                   BmnTrigInfo& trig_info);
 
    BmnEventHeader(UInt_t run_id,
                   UInt_t event_id,
                   TTimeStamp event_time,
                   BmnEventType event_type,
                   Bool_t trip,
                   BmnTrigInfo& trig_info,
                   unordered_map<UInt_t, Long64_t> time_shift);
 
    virtual ~BmnEventHeader();
 
    virtual void Register(Bool_t Persistence = kTRUE)
    {
        //        FairRootManager::Instance()->Register(fHeaderName.Data(), "EvtHeader", this, Persistence);
    }
 
    void Clear();
 
    TString GetHeaderName() { return fHeaderName; }
 
    UInt_t GetEventId() { return fEventId; }
 
    UInt_t GetPeriodId() { return fPeriodId; }
 
    TTimeStamp GetEventTimeTS() { return fEventTimeTS; }
    SysPoint GetEventTimeTP() { return BmnFunctionSet::TimeStamp2TP(fEventTimeTS); }
 
    TTimeStamp GetVspTS() { return fEventVspTS; }
 
    BmnEventType GetEventType() { return fEventType; }
 
    Bool_t GetTripWord() { return fTripWord; }
 
    Bool_t GetSpillStart() { return fSpillStart; }
 
    Double_t GetStartSignalTime() { return fStartSignalTime; }
    Double_t GetStartSignalWidth() { return fStartSignalWidth; }
 
    BmnTrigInfo& GetTrigInfo() { return fTrigInfo; }
 
    //    /** Get the trigger state */
    //    BmnTrigUnion GetTrigState()
    //    {
    //        BmnTrigUnion u;
    //        u.storage = fTrigUnion;
    //        return u;
    //    }
 
    //    UInt_t GetTrigStateWord() { return fTrigUnion; }
 
    UInt_t GetInputSignalsAR() { return fInputsAR; }
 
    UInt_t GetInputSignalsBR() { return fInputsBR; }
 
    vector<uint32_t>& GetInputSignalsVector() { return fInputsVec; }
 
    unordered_map<UInt_t, Long64_t>& GetTimeShift() { return fTimeShift; }
 
    void SetHeaderName(TString header_name) { fHeaderName = header_name; }
 
    void SetEventId(UInt_t event_id) { fEventId = event_id; }
 
    void SetPeriodId(UInt_t period_id) { fPeriodId = period_id; }
 
    void SetEventTimeTS(TTimeStamp event_time) { fEventTimeTS = event_time; }
    void SetEventTimeTP(SysPoint event_time) { fEventTimeTS = BmnFunctionSet::TimePoint2TS(event_time); }
 
    void SetVspTS(TTimeStamp event_time) { fEventVspTS = event_time; }
 
    void SetEventType(BmnEventType event_type) { fEventType = event_type; }
 
    void SetTripWord(Bool_t flag) { fTripWord = flag; }
 
    void SetSpillStart(Bool_t flag) { fSpillStart = flag; }
 
    void SetStartSignalInfo(Double_t time, Double_t width)
    {
        fStartSignalTime = time;
        fStartSignalWidth = width;
    }
 
    void SetTrigInfo(BmnTrigInfo& trig_info) { fTrigInfo.SetFrom(trig_info); }
 
    //    /** Set the trigger state */
    //    void SetTrigState(BmnTrigUnion& v) { fTrigUnion = v.storage; }
 
    void SetInputSignalsAR(UInt_t v) { fInputsAR = v; }
 
    void SetInputSignalsBR(UInt_t v) { fInputsBR = v; }
 
    void SetInputSignalsVector(vector<uint32_t> v) { fInputsVec = v; }
 
    void SetSpillStartTS(TTimeStamp ts) { fSpillStartTS = ts; }
    TTimeStamp GetSpillStartTS() { return fSpillStartTS; }
    Int_t& GetSpillId() { return fSpillId; }
    void SetSpillId(UInt_t sid) { fSpillId = sid; }
 
    void SetTimeShift(unordered_map<UInt_t, Long64_t> time_shift) { fTimeShift = time_shift; }
 
    ClassDef(BmnEventHeader, 5)
};
 
#endif /* BMNEVENTHEADER_H */