CbmTofUnpackMonitor.h

Go to the documentation of this file.

/* Copyright (C) 2022 Facility for Antiproton and Ion Research in Europe, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Pierre-Alain Loizeau [committer]  */
 
#ifndef CbmTofUnpackMonitor_H
#define CbmTofUnpackMonitor_H
 
#include "CbmBmonDigi.h"
#include "CbmMcbm2018TofPar.h"
 
#include <Rtypes.h>
#include <TH1.h>
#include <TH2.h>
#include <TProfile.h>
#include <TProfile2D.h>
 
#include <array>
#include <cstdint>
#include <vector>
 
class TCanvas;
 
class CbmTofUnpackMonitor {
 public:
  CbmTofUnpackMonitor();
 
  virtual ~CbmTofUnpackMonitor();

  virtual Bool_t Init(CbmMcbm2018TofPar* digiParSet);
 
  virtual Bool_t CreateHistograms();
  virtual Bool_t ResetHistograms();
  virtual void DrawCanvases();
 
  Bool_t CreateBmonHistograms();
  Bool_t ResetBmonHistograms(Bool_t bResetTime);
  void DrawBmonCanvases();
 
  Bool_t CreateHistogramsMicroSpills();
  Bool_t ResetHistogramsMicroSpills(Bool_t bResetTime);
  void DrawCanvasesMicroSpills();
 
  Bool_t CreateHistogramsQFactors(Bool_t bBmon = kTRUE);
  Bool_t ResetHistogramsQFactors(Bool_t bResetTime);
  void DrawCanvasesQFactors(Bool_t bBmon = kTRUE);
 
  Bool_t CreateMsComponentSizeHistos(UInt_t component);
  Bool_t ResetMsComponentSizeHistos(UInt_t component);

  void Finish();
 
  void SetHistoFileName(TString nameIn) { fHistoFileName = nameIn; }
 
  inline void SetPulserTotLimits(UInt_t uMin, UInt_t uMax)
  {
    fuMinTotPulser = uMin;
    fuMaxTotPulser = uMax;
  }
  inline void SetSpillThreshold(UInt_t uCntLimit) { fuOffSpillCountLimit = uCntLimit; }
  inline void SetSpillThresholdNonPulser(UInt_t uCntLimit) { fuOffSpillCountLimitNonPulser = uCntLimit; }
  inline void SetSpillCheckInterval(Double_t dIntervalSec) { fdSpillCheckInterval = dIntervalSec; }
  void SetBmonChannelMap(std::vector<uint32_t> vChanMapIn);
 
  void SetLongDurationLimits(UInt_t uDurationSeconds, UInt_t uBinSize)
  {
    //fbLongHistoEnable     = kTRUE;
    fuLongHistoNbSeconds  = uDurationSeconds;
    fuLongHistoBinSizeSec = uBinSize;
  }
 
  void AddHistoToVector(TNamed* pointer, std::string sFolder = "")
  {
    fvpAllHistoPointers.push_back(std::pair<TNamed*, std::string>(pointer, sFolder));
  }
  std::vector<std::pair<TNamed*, std::string>> GetHistoVector() { return fvpAllHistoPointers; }
 
  void AddCanvasToVector(TCanvas* pointer, std::string sFolder = "")
  {
    fvpAllCanvasPointers.push_back(std::pair<TCanvas*, std::string>(pointer, sFolder));
  }
  std::vector<std::pair<TCanvas*, std::string>> GetCanvasVector() { return fvpAllCanvasPointers; }
 
  UInt_t GetMaxNbFlibLinks() { return kuMaxNbFlibLinks; }

  void FillMsSize(UInt_t uMsComp, UInt_t uSize) { fvhMsSize[uMsComp]->Fill(uSize); }
  void FillMsSizeTime(UInt_t uMsComp, Double_t dTime, UInt_t uSize) { fvhMsSizeTime[uMsComp]->Fill(dTime, uSize); }
 

  //  void FillMsCntEvo(ULong64_t MsIdx) { fhMsCntEvo->Fill(MsIdx * 1e-9); }
  virtual void FillHitMonitoringHistos(const double_t& dMsTime, const uint32_t& uCurrCompIdx, const uint32_t& uGet4Id,
                                       const uint32_t& uRawCh, const uint32_t& uRemapCh, const uint32_t& uTot,
                                       const double_t& dHitTime, const uint32_t& uFts, bool bDiamond = false);
  virtual void FillEpochMonitoringHistos(const uint32_t& uCurrCompIdx, const uint32_t& uGet4Id, const bool& bSyncFlag,
                                         const bool& bDataLoss, const bool& bEpochLoss, const bool& bMissmMatch);
  virtual void FillScmMonitoringHistos(const uint32_t& uCurrCompIdx, const uint32_t& uGet4Id, const uint32_t& uCh,
                                       const uint32_t& uEdge, const uint32_t& uType);
  virtual void FillSysMonitoringHistos(const uint32_t& uCurrCompIdx, const uint32_t& uGet4Id, const uint32_t& uType);
  virtual void FillErrMonitoringHistos(const uint32_t& uCurrCompIdx, const uint32_t& uGet4Id, const uint32_t& uCh,
                                       const uint32_t& uType);
  virtual void FinalizeMsHistos() {}
  virtual void FinalizeTsHistos(double_t /*dTsStartTime*/) {}

  void CheckBmonSpillLimits(const double_t& dMsTime);
  void FillHitBmonMonitoringHistos(const double_t& dMsTime, const uint32_t& uCurrCompIdx, const uint32_t& uGet4Id,
                                   const uint32_t& uTot);
 
  void FillErrBmonMonitoringHistos(const double_t& dMsTime, const uint32_t& uCurrCompIdx, const uint32_t& uGet4Id,
                                   const bool& bErrEvtLost);

  void SetBmonMode(bool value) { fBmonMode = value; }

  bool GetBmonMode() { return fBmonMode; }

  void FillHitBmonMicroSpillHistos(const double_t& dMsTime, const double_t& dTime);
  void FinalizeTsBmonMicroSpillHistos();

  void FillHitBmonQfactorHistos(const double_t& dMsTime, const double_t& dTime);
  void FinalizeTsBmonQfactorHistos(uint64_t uTsTimeNs, std::vector<CbmBmonDigi>* vDigis);

  void SetBmonMicroSpillMode(bool value) { fBmonMicroSpillMode = value; }

  bool GetBmonMicroSpillMode() { return fBmonMicroSpillMode; }

  void SetBmonScvdMode(bool value) { fBmonScvdMode = value; }

  bool GetBmonScvdMode() { return fBmonScvdMode; }

  void SetBmonQFactorMode(bool value)
  {
    fBmonQfactorsMode = value;
    if (fBmonQfactorsMode) {
      fBmonMicroSpillMode = false;
      fBmonScvdMode       = false;
    }
  }

  bool GetBmonQFactorMode() { return fBmonQfactorsMode; }

  void SetTofQFactorMode(bool value) { fTofQfactorsMode = value; }

  bool GetTofQFactorMode() { return fTofQfactorsMode; }

  void SetInternalHttpMode(bool value) { fbInternalHttp = value; }

  bool GetInternalHttpMode() { return fbInternalHttp; }

  void SetHistosStartTime(double_t value) { fdStartTime = value; }

  double_t GetHistosStartTime() { return fdStartTime; }
 
 protected:
  TString fHistoFileName = "data/mon.tof.root";

  CbmMcbm2018TofPar* fUnpackPar = nullptr;
  UInt_t fuNbOfComps           = 0;  
  UInt_t fuNbOfGet4PerComp     = 0;  
  UInt_t fuNbOfChannelsPerGet4 = 0;  
  UInt_t fuNbOfChannelsPerComp = 0;  
  UInt_t fuNbOfGet4InSyst      = 0;  

  Double_t fdStartTime = -1.0; 
  UInt_t fuHistoryHistoSize  = 3600; 
  double_t dFirstTsStartTime = 0;
  //Bool_t fbLongHistoEnable;
  UInt_t fuLongHistoNbSeconds  = 3600;
  UInt_t fuLongHistoBinSizeSec = 10;
  UInt_t fuLongHistoBinNb      = 1;

  bool fBmonMode           = false;
  bool fBmonScvdMode       = false;
  bool fBmonMicroSpillMode = false;
  bool fBmonQfactorsMode   = false;
  bool fTofQfactorsMode    = false;
  bool fbInternalHttp      = true;

  static const UInt_t kuMaxNbFlibLinks  = 32;
  static const UInt_t kuBytesPerMessage = 8;
  static const UInt_t kuNbChanBmon      = 16;
  static const UInt_t kuNbChanBmonScvd  = 20;
  static const UInt_t kuNbSpillPlots    = 5;

  UInt_t fuMinTotPulser                = 185;
  UInt_t fuMaxTotPulser                = 189;
  UInt_t fuOffSpillCountLimit          = 200;
  UInt_t fuOffSpillCountLimitNonPulser = 80;
  Double_t fdSpillCheckInterval        = 1.0;
  static constexpr UInt_t kuBmonChanMap[kuNbChanBmon] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
  static constexpr UInt_t kuBmonChanMapScvd[kuNbChanBmonScvd] = {0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
                                                                 10, 11, 12, 13, 14, 15, 16, 17, 18, 19};

  UInt_t fuNbChanBmon               = 0;
  std::vector<UInt_t> fuBmonChanMap = {};

  TH1* fvhMsSize[kuMaxNbFlibLinks];
  TProfile* fvhMsSizeTime[kuMaxNbFlibLinks];

  TH2* fhGet4MessType    = nullptr;
  TH2* fhGet4EpochFlags  = nullptr;
  TH2* fhGet4ScmType     = nullptr;
  TH2* fhGet4SysMessType = nullptr;
  TH2* fhGet4ErrorsType  = nullptr;
  std::vector<TH2*> fvhCompGet4MessType = {};
  std::vector<TH2*> fvhCompGet4ChScm    = {};
  std::vector<TH2*> fvhCompGet4ChErrors = {};
  std::vector<TH1*> fvhCompRawChCount = {};
  std::vector<TH2*> fvhCompRawChRate  = {};
  std::vector<TH2*> fvhCompRawChTot   = {};
  std::vector<TH1*> fvhCompRemapChCount = {};
  std::vector<TH2*> fvhCompRemapChRate  = {};
  std::vector<TH2*> fvhCompRemapChTot   = {};
  TH1* fhPulserChCounts = nullptr;
  TH2* fhPulserChEvo    = nullptr;

  std::vector<UInt_t> fvuBmonHitCntChanMs           = {};
  std::vector<UInt_t> fvuBmonErrorCntChanMs         = {};
  std::vector<UInt_t> fvuBmonEvtLostCntChanMs       = {};
  std::vector<TH1*> fvhBmonMsgCntEvoChan            = {};
  std::vector<TH2*> fvhBmonMsgCntPerMsEvoChan       = {};
  std::vector<TH1*> fvhBmonHitCntEvoChan            = {};
  std::vector<TH2*> fvhBmonHitCntPerMsEvoChan       = {};
  std::vector<TH1*> fvhBmonErrorCntEvoChan          = {};
  std::vector<TH2*> fvhBmonErrorCntPerMsEvoChan     = {};
  std::vector<TH1*> fvhBmonEvtLostCntEvoChan        = {};
  std::vector<TH2*> fvhBmonEvtLostCntPerMsEvoChan   = {};
  std::vector<TProfile*> fvhBmonErrorFractEvoChan   = {};
  std::vector<TH2*> fvhBmonErrorFractPerMsEvoChan   = {};
  std::vector<TProfile*> fvhBmonEvtLostFractEvoChan = {};
  std::vector<TH2*> fvhBmonEvtLostFractPerMsEvoChan = {};
  TH1* fhBmonCompMapAll       = nullptr;
  TH2* fhBmonCompGet4         = nullptr;
  TH1* fhBmonGet4Map          = nullptr;
  TH2* fhBmonGet4MapEvo       = nullptr;
  TH1* fhBmonChannelMapAll    = nullptr;
  TH2* fhBmonChannelTotAll    = nullptr;
  TH2* fhBmonHitMapEvoAll     = nullptr;
  TH2* fhBmonHitTotEvoAll     = nullptr;
  TH1* fhBmonChanHitMapAll    = nullptr;
  TH2* fhBmonChanHitMapEvoAll = nullptr;
  TH1* fhBmonCompMap       = nullptr;
  TH1* fhBmonChannelMap    = nullptr;
  TH2* fhBmonHitMapEvo     = nullptr;
  TH2* fhBmonHitTotEvo     = nullptr;
  TH1* fhBmonChanHitMap    = nullptr;
  TH2* fhBmonChanHitMapEvo = nullptr;
  std::vector<TH1*> fvhBmonCompMapSpill    = {};
  std::vector<TH1*> fvhBmonChannelMapSpill = {};
  TH1* fhBmonHitsPerSpill                  = nullptr;
  TH1* fhBmonMsgCntEvo            = nullptr;
  TH1* fhBmonHitCntEvo            = nullptr;
  TH1* fhBmonErrorCntEvo          = nullptr;
  TH1* fhBmonLostEvtCntEvo        = nullptr;
  TProfile* fhBmonErrorFractEvo   = nullptr;
  TProfile* fhBmonLostEvtFractEvo = nullptr;
  TH2* fhBmonMsgCntPerMsEvo       = nullptr;
  TH2* fhBmonHitCntPerMsEvo       = nullptr;
  TH2* fhBmonErrorCntPerMsEvo     = nullptr;
  TH2* fhBmonLostEvtCntPerMsEvo   = nullptr;
  TH2* fhBmonErrorFractPerMsEvo   = nullptr;
  TH2* fhBmonLostEvtFractPerMsEvo = nullptr;
  TH1* fhBmonChannelMapPulser = nullptr;
  TH2* fhBmonHitMapEvoPulser  = nullptr;

  double_t fdBmonMicrospillsTsLengthSec = 0.128;  // 128 ms
  uint32_t fuBmonMicrospillsNbBinsTs    = 0;
  uint32_t fuNbTsMicrospills            = 0;
  std::unique_ptr<double[]> fArrHitCounts;
  std::unique_ptr<double[]> fArrErrCounts;
  TH1* fhBmonMicrospillsDistHits       = nullptr;  // Only internal, not for users
  TH1* fhBmonMicrospillsDistErrs       = nullptr;  // Only internal, not for users
  TH2* fhBmonMicrospillsTsBinCntHits   = nullptr;
  TH2* fhBmonMicrospillsTsBinCntErrs   = nullptr;
  TH1* fhBmonMicrospillsTsMeanHits     = nullptr;
  TH1* fhBmonMicrospillsTsMeanErrs     = nullptr;
  TH1* fhBmonMicrospillsTsMedianHits   = nullptr;
  TH1* fhBmonMicrospillsTsMedianErrs   = nullptr;
  TH2* fhBmonMicrospillsTsBinRatioHits = nullptr;
  TH2* fhBmonMicrospillsTsBinRatioErrs = nullptr;
  TH2* fhBmonMicrospillsTsBinFractHits = nullptr;
  TH2* fhBmonMicrospillsTsBinFractErrs = nullptr;

  double_t fdTsSizeNs                        = fdBmonMicrospillsTsLengthSec * 1e9;
  uint32_t fuQFactorMaxNbTs                  = 400;
  std::vector<double_t> fvdQfactorBinSizesNs = {20, 200, 1.28e3, 10.24e3, 25.6e3, 102.4e3, 204.8e3};  // 7 values
  std::vector<double_t> fvdQfactorIntegrationNs     = {2.56e6};  // 1 value
  std::vector<uint32_t> fvuNbHistoCyclesPerTS       = {};
  std::vector<uint32_t> fvuQfactorIdxHistoCycleinTS = {};
  std::vector<double_t> fvdQfactorHistMax = {2000., 400., 40., 20., 20., 20., 20.};
  uint16_t fuQfactorNbPlots               = 0;
  std::vector<std::vector<uint32_t>> fvuQfactorNbBinsHisto;
  std::vector<uint32_t> fvuQfactorNbHistoCyclesPerTS;
  std::vector<std::vector<TH1*>> fvhBmonQfactHisto;
  std::vector<std::vector<TH1*>> fvhBmonQfactQval;
  std::vector<std::vector<TH1*>> fvhBmonQfactMean;
  std::vector<TH1*> fvhBmonQfactBinCountDistribution;
  std::vector<TH2*> fvhBmonQfactBinCountDistributionEvo;
  double_t ExtractQFactor(TH1* pHistoIn);
  double_t ExtractMean(TH1* pHistoIn);
 

  TCanvas* fcSummaryGet4s          = nullptr;
  std::vector<TCanvas*> fvcSumComp = {};
  TCanvas* fcBmonSummary             = nullptr;
  TCanvas* fcBmonSummaryMap          = nullptr;
  TCanvas* fcBmonHitMaps             = nullptr;
  TCanvas* fcBmonGenCntsPerMs        = nullptr;
  TCanvas* fcBmonSpillCounts         = nullptr;
  TCanvas* fcBmonSpillCountsHori     = nullptr;
  TCanvas* fcBmonSpillCompCountsHori = nullptr;
  TCanvas* fcBmonMicrospillsBinCnts  = nullptr;
  TCanvas* fcBmonMicrospillsRatios   = nullptr;
  TCanvas* fcBmonMicrospillsFraction = nullptr;
  TCanvas* fcBmonQFactorVal        = nullptr;
  TCanvas* fcBmonQFactorMean       = nullptr;
  TCanvas* fcBmonQFactorBinCntDist = nullptr;

  Bool_t fbSpillOn                      = kTRUE;
  UInt_t fuCurrentSpillIdx              = 0;
  UInt_t fuCurrentSpillPlot             = 0;
  Double_t fdStartTimeSpill             = -1.0;
  Double_t fdBmonLastInterTime          = -1.0;
  UInt_t fuBmonCountsLastInter          = 0;
  UInt_t fuBmonNonPulserCountsLastInter = 0;

  std::vector<std::pair<TNamed*, std::string>>
    fvpAllHistoPointers;  
  std::vector<std::pair<TCanvas*, std::string>>
    fvpAllCanvasPointers;  
 
 private:
  CbmTofUnpackMonitor(const CbmTofUnpackMonitor&);
  CbmTofUnpackMonitor operator=(const CbmTofUnpackMonitor&);
 
  ClassDef(CbmTofUnpackMonitor, 1)
};
 
#endif