DigiRunHeader.h

Go to the documentation of this file.

#ifndef BMNDIGIRUNHEADER_H
#define BMNDIGIRUNHEADER_H
 
#include <map>
#include <unordered_map>
// ROOT
#include "TObject.h"
#include "TTimeStamp.h"
// BmnRoot
#include "BmnAliases.h"
#include "BmnFunctionSet.h"
#include "BmnSpillInfo.h"
#include "BmnTrigConfig.h"
#include "RawTypes.h"
 
using std::map;
using std::unordered_map;
using std::vector;
 
class DigiRunHeader : public TObject
{
  private:
    UInt_t fPeriodId;
    UInt_t fRunId;
    ULong64_t fEventCnt;
    TTimeStamp fRunStartTime;
    TTimeStamp fRunEndTime;
    ULong64_t fBeamTrigger;
    ULong64_t fBTnBusy;
    Double_t fBTAccepted;   
    ULong64_t fAccepted;
    ULong64_t fProtection;
    ULong64_t fL0;
    ULong64_t fBP;
    ULong64_t fAP;
 
    map<SysPoint, BmnSpillInfo> fSpillMap;
    T0ChMap fT0Map;
    NameChMap fTrcBitMap;
    Name2SerCh fScalersMap;
    vector<uint64_t> fScalersVec;
    NameChMap scalers_name2index_map;                     
    vector<string> scalers_index2name_map;                
    map<uint16_t, uint16_t> fTrcIdx2ScalerIdx;            
    unordered_map<UInt_t, vector<uint64_t>> fBoardSums;   
 
    std::array<ULong64_t, kT0_BIN_BLOCK_WORDS> rawt0_cntrs = {};
    MapString2Cnt event_trig_count;   // name -> total spill trigger (TRC bit inside events)
 
    BmnTrigConfig trig_config;
 
  public:
    DigiRunHeader();
 
    DigiRunHeader(UInt_t period_id, UInt_t run_id, TTimeStamp run_start_time, TTimeStamp run_end_time);
 
    virtual ~DigiRunHeader();
 
    ULong64_t GetPeriodId() { return fPeriodId; }
    ULong64_t GetRunId() { return fRunId; }
    ULong64_t GetNEvents() { return fEventCnt; }
    ULong64_t GetBT() { return fBeamTrigger; }
    ULong64_t GetBTnBusy() { return fBTnBusy; }
    Double_t GetBTAccepted() { return fBTAccepted; }
    ULong64_t GetAccepted() { return fAccepted; }
    ULong64_t GetProtection() { return fProtection; }
    ULong64_t GetL0() { return fL0; }
    T0ChMap& T0Map() { return fT0Map; }
    NameChMap& GetTrcBitMap() { return fTrcBitMap; }
    Name2SerCh& GetScalerMap() { return fScalersMap; }
 
    NameChMap& ScalersName2IndexMap() { return scalers_name2index_map; }
 
    vector<string>& ScalersIndex2NameMap() { return scalers_index2name_map; }
 
    map<uint16_t, uint16_t>& TrcIndex2ScalerIndexMap() { return fTrcIdx2ScalerIdx; }
 
    void PrintScalers()
    {
        for (size_t iSc = 0; iSc < scalers_index2name_map.size(); iSc++) {
            string& name = scalers_index2name_map[iSc];
            uint64_t& val = fScalersVec[iSc];
            printf("MSC %-14s  %10lu\n", name.c_str(), val);
        }
    }
 
    vector<uint64_t>& ScalersVec() { return fScalersVec; }
 
    ULong64_t GetScaler(string name);
 
    ULong64_t GetRawT0Counter(string name, UInt_t ch = 0);
    //    ULong64_t GetTrcCounter(string name);
    std::array<ULong64_t, kT0_BIN_BLOCK_WORDS>& RawT0Counters() { return rawt0_cntrs; }
 
    MapString2Cnt& EventTriggerCnt() { return event_trig_count; }
 
    //    vector<vector<> >
    unordered_map<UInt_t, vector<uint64_t>>& GetRawMSC() { return fBoardSums; }
    map<SysPoint, BmnSpillInfo>& GetSpillMap() { return fSpillMap; }
 
    BmnTrigConfig& GetTrigConfig() { return trig_config; }
 
    TTimeStamp GetRunStartTime() { return fRunStartTime; }
    SysPoint GetRunStartTP() { return BmnFunctionSet::TimeStamp2TP(fRunStartTime); }
    TTimeStamp GetRunEndTime() { return fRunEndTime; }
    SysPoint GetRunEndTP() { return BmnFunctionSet::TimeStamp2TP(fRunEndTime); }
 
    void SetPeriodId(UInt_t period_id) { fPeriodId = period_id; }
 
    void SetRunId(UInt_t run_id) { fRunId = run_id; }
    void SetNEvents(ULong64_t events) { fEventCnt = events; }
 
    void SetRunStartTime(TTimeStamp run_start_time) { fRunStartTime = run_start_time; }
    void SetRunStartTP(SysPoint run_start_time) { fRunStartTime = BmnFunctionSet::TimePoint2TS(run_start_time); }
 
    void SetRunEndTime(TTimeStamp run_end_time) { fRunEndTime = run_end_time; }
    void SetRunEndTP(SysPoint run_end_time) { fRunEndTime = BmnFunctionSet::TimePoint2TS(run_end_time); }
 
    void SetBT(ULong64_t cntr) { fBeamTrigger = cntr; }
    void SetBTnBusy(ULong64_t cntr) { fBTnBusy = cntr; }
    void SetBTAccepted(Double_t cntr) { fBTAccepted = cntr; }
    void SetAccepted(ULong64_t cntr) { fAccepted = cntr; }
    void SetProtection(ULong64_t cntr) { fProtection = cntr; }
    void SetL0(ULong64_t cntr) { fL0 = cntr; }
    void SetRawMSC(unordered_map<UInt_t, vector<uint64_t>> v)
    {
        fBoardSums = v;
        //    printf("inner len %lu\n", fBoardSums.size());
    }
    void SetSpillMap(map<SysPoint, BmnSpillInfo> v)
    {
        fSpillMap = v;
        //    printf("inner len %lu\n", fSpillMap.size());
    }
 
    void SetTrigConfig(BmnTrigConfig tc) { trig_config = tc; }
 
    ClassDef(DigiRunHeader, 11)
};
 
#endif /* BMNDIGIRUNHEADER_H */