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:
    /** Period Id **/
    uint32_t fPeriodId;
    /** Run Id **/
    uint32_t fRunId;
    /** Event count **/
    uint64_t fEventCnt;
    TTimeStamp fRunStartTime;
    TTimeStamp fRunEndTime;
    uint64_t fBeamTrigger;
    uint64_t fBTnBusy;
    Double_t fBTAccepted;   ///< BT&notBusy normalized according to Acc/(Acc + BP + AP) | for SRC => sum [BT * (DAQ_Busy
                            ///< -peds)/ (DAQ_TRigger - peds)]
    uint64_t fAccepted;
    uint64_t fProtection;
    uint64_t fL0;
    uint64_t fBP;
    uint64_t fAP;
 
    map<SysPoint, BmnSpillInfo> fSpillMap;
    T0ChMap fT0Map;
    NameChMap fTrcBitMap;
    Name2SerCh fScalersMap;
    vector<uint64_t> fScalersVec;
    NameChMap scalers_name2index_map;                       ///< name -> index in fScalersVec (scaler index)
    vector<string> scalers_index2name_map;                  ///< index -> name
    map<uint16_t, uint16_t> fTrcIdx2ScalerIdx;              ///<  TRC index -> scaler index
    unordered_map<uint32_t, vector<uint64_t>> fBoardSums;   ///<  (MSC serial, raw sums of the counters)
 
    std::array<uint64_t, kT0_BIN_BLOCK_WORDS> rawt0_cntrs = {};
    MapString2Cnt event_trig_count;   // name -> total spill trigger (TRC bit inside events)
 
    BmnTrigConfig trig_config;
 
  public:
    //    /** Default constructor */
    //    DigiRunHeader();
 
    /** Constructor
     * \param[in] period_id : unique period id
     * \param[in] run_id : unique run id
     * \param[in] run_start_time : run start time
     * \param[in] run_end_time : run end time
     */
    DigiRunHeader(uint32_t period_id = 9,
                  uint32_t run_id = 0,
                  TTimeStamp run_start_time = TTimeStamp(0, 0),
                  TTimeStamp run_end_time = TTimeStamp(0, 0));
 
    /** Destructor */
    virtual ~DigiRunHeader();
 
    /** Get the period ID for this run */
    uint64_t GetPeriodId() { return fPeriodId; }
    /** Get the run ID */
    uint64_t GetRunId() { return fRunId; }
    /** Get the event count */
    uint64_t GetNEvents() { return fEventCnt; }
    /** Get the BeamTrigger counter */
    uint64_t GetBT() { return fBeamTrigger; }
    /** Get the BT and not Busy  */
    uint64_t GetBTnBusy() { return fBTnBusy; }
    /** Get the (BT and not Busy) by live time  */
    Double_t GetBTAccepted() { return fBTAccepted; }
    /** Get the Accepted by live time  */
    uint64_t GetAccepted() { return fAccepted; }
    /** Get the Trigger Protection  */
    uint64_t GetProtection() { return fProtection; }
    /** Get the L0  */
    uint64_t GetL0() { return fL0; }
    /** Ref to the T0 map  */
    T0ChMap& T0Map() { return fT0Map; }
    /** TRC bit map */
    NameChMap& GetTrcBitMap() { return fTrcBitMap; }
    /** MSC bit map */
    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; }
 
    uint64_t GetScaler(string name);
 
    uint64_t GetRawT0Counter(string name, uint32_t ch = 0);
    //    uint64_t GetTrcCounter(string name);
    /** Raw T0 counters (sum over all spills)*/
    std::array<uint64_t, kT0_BIN_BLOCK_WORDS>& RawT0Counters() { return rawt0_cntrs; }
 
    MapString2Cnt& EventTriggerCnt() { return event_trig_count; }
 
    //    vector<vector<> >
    /** Get the raw MSC counters  */
    unordered_map<uint32_t, vector<uint64_t>>& GetRawMSC() { return fBoardSums; }
    map<SysPoint, BmnSpillInfo>& GetSpillMap() { return fSpillMap; }
 
    /** Get DAQ trigger config */
    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); }
 
    /** Set the period ID for this run
     * \param[in] period_id : unique period id
     */
    void SetPeriodId(uint32_t period_id) { fPeriodId = period_id; }
 
    /** Set the period ID for this run
     * \param[in] run_id : unique run id
     */
    void SetRunId(uint32_t run_id) { fRunId = run_id; }
    /** Set the event count */
    void SetNEvents(uint64_t events) { fEventCnt = events; }
 
    /** Set the period ID for this run
     * \param[in] run_start_time : run start time
     */
    void SetRunStartTime(TTimeStamp run_start_time) { fRunStartTime = run_start_time; }
    void SetRunStartTP(SysPoint run_start_time) { fRunStartTime = BmnFunctionSet::TimePoint2TS(run_start_time); }
 
    /** Set the period ID for this run
     * \param[in] run_end_time : run end time
     */
    void SetRunEndTime(TTimeStamp run_end_time) { fRunEndTime = run_end_time; }
    void SetRunEndTP(SysPoint run_end_time) { fRunEndTime = BmnFunctionSet::TimePoint2TS(run_end_time); }
 
    /** Set the Beam Trigger counter
     * \param[in] cntr : Beam Trigger counter
     */
    void SetBT(uint64_t cntr) { fBeamTrigger = cntr; }
    /** Set the BT and Busy counter
     * \param[in] cntr : BT and Busy
     */
    void SetBTnBusy(uint64_t cntr) { fBTnBusy = cntr; }
    /** Set the (BT and not Busy) by live time
     * \param[in] cntr : BT Accepted
     */
    void SetBTAccepted(Double_t cntr) { fBTAccepted = cntr; }
    /** Set the Accepted counter
     * \param[in] cntr : Accepted counter
     */
    void SetAccepted(uint64_t cntr) { fAccepted = cntr; }
    /** Set the Trigger Protection counter
     * \param[in] cntr : Trigger Protection counter
     */
    void SetProtection(uint64_t cntr) { fProtection = cntr; }
    /** Set the L0 counter
     * \param[in] cntr : L0 counter
     */
    void SetL0(uint64_t cntr) { fL0 = cntr; }
    /** Set the raw MSC counters
     * \param[in] v : map < MSC serial, counters vector>
     */
    void SetRawMSC(unordered_map<uint32_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, 12)
};
 
#endif /* BMNDIGIRUNHEADER_H */