CbmMcbm2018MonitorAlgoT0.h

Go to the documentation of this file.

// -----------------------------------------------------------------------------
// -----                                                                   -----
// -----                  CbmMcbm2018MonitorAlgoT0                         -----
// -----               Created 10.02.2019 by P.-A. Loizeau                 -----
// -----                                                                   -----
// -----------------------------------------------------------------------------
 
#ifndef CbmMcbm2018MonitorAlgoT0_H
#define CbmMcbm2018MonitorAlgoT0_H
 
#include "CbmStar2019Algo.h"
 
// Data
#include "CbmTofDigi.h"
#include "gDpbMessv100.h"
 
// CbmRoot
 
// C++11
#include <chrono>
 
// C/C++
#include <map>
#include <vector>
 
class CbmMcbm2018TofPar;
/*
class TCanvas;
class THttpServer;
*/
class TH1;
class TH2;
class TProfile;
 
class CbmMcbm2018MonitorAlgoT0 : public CbmStar2019Algo<CbmTofDigi> {
public:
  CbmMcbm2018MonitorAlgoT0();
  ~CbmMcbm2018MonitorAlgoT0();
 
  virtual Bool_t Init();
  virtual void Reset();
  virtual void Finish();
 
  Bool_t InitContainers();
  Bool_t ReInitContainers();
  TList* GetParList();
 
  Bool_t InitParameters();
 
  Bool_t ProcessTs(const fles::Timeslice& ts);
  Bool_t ProcessTs(const fles::Timeslice& ts, size_t /*component*/) {
    return ProcessTs(ts);
  }
  Bool_t ProcessMs(const fles::Timeslice& ts, size_t uMsCompIdx, size_t uMsIdx);
 
  void AddMsComponentToList(size_t component, UShort_t usDetectorId);
 
  Bool_t CreateHistograms();
  Bool_t FillHistograms();
  Bool_t ResetHistograms(Bool_t bResetTime = kTRUE);
 
  inline void SetMonitorMode(Bool_t bFlagIn = kTRUE) {
    fbMonitorMode = bFlagIn;
  }
  inline void SetHistoryHistoSize(UInt_t inHistorySizeSec = 1800) {
    fuHistoryHistoSize = inHistorySizeSec;
  }
  inline void SetPulserTotLimits(UInt_t uMin, UInt_t uMax) {
    fuMinTotPulser = uMin;
    fuMaxTotPulser = uMax;
  }
  inline void SetSpillThreshold(UInt_t uCntLimit) {
    fuOffSpillCountLimit = uCntLimit;
  }
  inline void SetChannelMap(UInt_t uChan0,
                            UInt_t uChan1,
                            UInt_t uChan2,
                            UInt_t uChan3,
                            UInt_t uChan4,
                            UInt_t uChan5,
                            UInt_t uChan6,
                            UInt_t uChan7) {
    fuDiamChanMap[0] = uChan0;
    fuDiamChanMap[1] = uChan1;
    fuDiamChanMap[2] = uChan2;
    fuDiamChanMap[3] = uChan3;
    fuDiamChanMap[4] = uChan4;
    fuDiamChanMap[5] = uChan5;
    fuDiamChanMap[6] = uChan6;
    fuDiamChanMap[7] = uChan7;
  }
 
private:
  Bool_t fbMonitorMode =
    kFALSE;  
  Bool_t fbDebugMonitorMode =
    kFALSE;  
  std::vector<Bool_t> fvbMaskedComponents = {};
 
  CbmMcbm2018TofPar* fUnpackPar = nullptr;  
  UInt_t fuNrOfGdpbs = 0;  
  std::map<UInt_t, UInt_t> fGdpbIdIndexMap = {};  
  UInt_t fuNrOfFeePerGdpb                  = 0;   
  UInt_t fuNrOfGet4PerFee                  = 0;   
  UInt_t fuNrOfChannelsPerGet4 = 0;  
  UInt_t fuNrOfChannelsPerFee  = 0;  
  UInt_t fuNrOfGet4        = 0;  
  UInt_t fuNrOfGet4PerGdpb = 0;  
  UInt_t fuNrOfChannelsPerGdpb = 0;  
 
  UInt_t fuMinTotPulser       = 90;
  UInt_t fuMaxTotPulser       = 100;
  UInt_t fuOffSpillCountLimit = 200;
 
  static const Int_t kiMaxNbFlibLinks   = 32;
  static const UInt_t kuBytesPerMessage = 8;
  static const UInt_t kuNbChanDiamond   = 8;
 
  ULong64_t fulCurrentTsIdx = 0;
  ULong64_t fulCurrentMsIdx = 0;
  Double_t fdTsStartTime =
    -1.0;  
  Double_t fdTsStopTimeCore =
    -1.0;  
  Double_t fdMsTime =
    -1.0;  
  UInt_t fuMsIndex = 0;  
  std::map<gdpbv100::MessageTypes, UInt_t> fmMsgCounter = {};
  UInt_t fuCurrentEquipmentId =
    0;  
  UInt_t fuCurrDpbId =
    0;  
  UInt_t fuCurrDpbIdx =
    0;  
  Int_t fiRunStartDateTimeSec =
    -1;  
  Int_t fiBinSizeDatePlots =
    -1;  
  UInt_t fuGet4Id =
    0;  
  UInt_t fuGet4Nr =
    0;  
  std::vector<ULong64_t> fvulCurrentEpoch =
    {};  
  std::vector<ULong64_t> fvulCurrentEpochCycle =
    {};  
  std::vector<ULong64_t> fvulCurrentEpochFull = {};  
 
  Double_t fdStartTime =
    -1.0; 
  Double_t fdStartTimeMsSz =
    0.0; 
  std::chrono::steady_clock::time_point ftStartTimeUnix =
    std::chrono::steady_clock::
      now(); 
  std::vector<std::vector<gdpbv100::Message>> fvvmEpSupprBuffer = {};  
  std::vector<gdpbv100::FullMessage> fvmHitsInMs =
    {};  
 
  UInt_t fuHistoryHistoSize =
    3600; 
  std::vector<UInt_t> fvuHitCntChanMs = std::vector<UInt_t>(kuNbChanDiamond, 0);
  std::vector<UInt_t> fvuErrorCntChanMs =
    std::vector<UInt_t>(kuNbChanDiamond, 0);
  std::vector<UInt_t> fvuEvtLostCntChanMs =
    std::vector<UInt_t>(kuNbChanDiamond, 0);
  std::vector<TH1*> fvhMsgCntEvoChan =
    std::vector<TH1*>(kuNbChanDiamond, nullptr);
  std::vector<TH2*> fvhMsgCntPerMsEvoChan =
    std::vector<TH2*>(kuNbChanDiamond, nullptr);
  std::vector<TH1*> fvhHitCntEvoChan =
    std::vector<TH1*>(kuNbChanDiamond, nullptr);
  std::vector<TH2*> fvhHitCntPerMsEvoChan =
    std::vector<TH2*>(kuNbChanDiamond, nullptr);
  std::vector<TH1*> fvhErrorCntEvoChan =
    std::vector<TH1*>(kuNbChanDiamond, nullptr);
  std::vector<TH2*> fvhErrorCntPerMsEvoChan =
    std::vector<TH2*>(kuNbChanDiamond, nullptr);
  std::vector<TH1*> fvhEvtLostCntEvoChan =
    std::vector<TH1*>(kuNbChanDiamond, nullptr);
  std::vector<TH2*> fvhEvtLostCntPerMsEvoChan =
    std::vector<TH2*>(kuNbChanDiamond, nullptr);
  std::vector<TProfile*> fvhErrorFractEvoChan =
    std::vector<TProfile*>(kuNbChanDiamond, nullptr);
  std::vector<TH2*> fvhErrorFractPerMsEvoChan =
    std::vector<TH2*>(kuNbChanDiamond, nullptr);
  std::vector<TProfile*> fvhEvtLostFractEvoChan =
    std::vector<TProfile*>(kuNbChanDiamond, nullptr);
  std::vector<TH2*> fvhEvtLostFractPerMsEvoChan =
    std::vector<TH2*>(kuNbChanDiamond, nullptr);
  Bool_t fbSpillOn                   = kTRUE;
  UInt_t fuCurrentSpillIdx           = 0;
  UInt_t fuCurrentSpillPlot          = 0;
  Double_t fdStartTimeSpill          = -1.0;
  Double_t fdLastSecondTime          = -1.0;
  UInt_t fuCountsLastSecond          = 0;
  static const UInt_t kuNbSpillPlots = 5;
  //      UInt_t  kuDiamChanMap[ kuNbChanDiamond ] = { 2, 3, 4, 5, 0, 1, 6, 7 }; //! Map from electronics channel to Diamond strip
  UInt_t fuDiamChanMap[kuNbChanDiamond] =
    {0, 1, 2, 3, 4, 5, 6, 7};  
  TH1* fhDpbMap                        = nullptr;
  TH1* fhChannelMap                    = nullptr;
  TH2* fhHitMapEvo                     = nullptr;
  TH2* fhHitTotEvo                     = nullptr;
  TH2* fhChanHitMapEvo                 = nullptr;
  std::vector<TH1*> fvhDpbMapSpill     = {};
  std::vector<TH1*> fvhChannelMapSpill = {};
  TH1* fhHitsPerSpill                  = nullptr;
  TH1* fhMsgCntEvo            = nullptr;
  TH1* fhHitCntEvo            = nullptr;
  TH1* fhErrorCntEvo          = nullptr;
  TH1* fhLostEvtCntEvo        = nullptr;
  TProfile* fhErrorFractEvo   = nullptr;
  TProfile* fhLostEvtFractEvo = nullptr;
 
  TH2* fhMsgCntPerMsEvo       = nullptr;
  TH2* fhHitCntPerMsEvo       = nullptr;
  TH2* fhErrorCntPerMsEvo     = nullptr;
  TH2* fhLostEvtCntPerMsEvo   = nullptr;
  TH2* fhErrorFractPerMsEvo   = nullptr;
  TH2* fhLostEvtFractPerMsEvo = nullptr;
 
  TH1* fhChannelMapPulser = nullptr;
  TH2* fhHitMapEvoPulser  = nullptr;
 
  TCanvas* fcSummary            = nullptr;
  TCanvas* fcHitMaps            = nullptr;
  TCanvas* fcGenCntsPerMs       = nullptr;
  TCanvas* fcSpillCounts        = nullptr;
  TCanvas* fcSpillCountsHori    = nullptr;
  TCanvas* fcSpillDpbCountsHori = nullptr;
 
  /*
      void ProcessEpochCycle( uint64_t ulCycleData );
      void ProcessEpoch(       gdpbv100::Message mess );
 
      void ProcessEpSupprBuffer();
 
      void ProcessHit(     gdpbv100::FullMessage mess );
      void ProcessSysMess( gdpbv100::FullMessage mess );
 
      void ProcessError(   gdpbv100::FullMessage mess );
 
      inline Int_t GetArrayIndex(Int_t gdpbId, Int_t get4Id)
      {
         return gdpbId * fuNrOfGet4PerGdpb + get4Id;
      }
*/
  CbmMcbm2018MonitorAlgoT0(const CbmMcbm2018MonitorAlgoT0&);
  CbmMcbm2018MonitorAlgoT0 operator=(const CbmMcbm2018MonitorAlgoT0&);
 
  ClassDef(CbmMcbm2018MonitorAlgoT0, 1)
};
 
#endif