CbmMcbm2018MonitorAlgoTof.h

Go to the documentation of this file.

/* Copyright (C) 2019-2020 Facility for Antiproton and Ion Research in Europe, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Pierre-Alain Loizeau [committer] */
 
// -----------------------------------------------------------------------------
// -----                                                                   -----
// -----                  CbmMcbm2018MonitorAlgoTof                         -----
// -----               Created 27.11.2019 by P.-A. Loizeau                 -----
// -----                                                                   -----
// -----------------------------------------------------------------------------
 
#ifndef CbmMcbm2018MonitorAlgoTof_H
#define CbmMcbm2018MonitorAlgoTof_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 TH1;
class TH2;
class TProfile;
class TProfile2D;
 
class CbmMcbm2018MonitorAlgoTof : public CbmStar2019Algo<CbmTofDigi> {
public:
  CbmMcbm2018MonitorAlgoTof();
  ~CbmMcbm2018MonitorAlgoTof();
 
  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);
  void ResetEvolutionHistograms();
 
  inline void SetDebugMonitorMode(Bool_t bFlagIn = kTRUE) { fbDebugMonitorMode = bFlagIn; }
  inline void SetIgnoreCriticalErrors(Bool_t bFlagIn = kTRUE) { fbIgnoreCriticalErrors = 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 SetGdpbIndex(Int_t iGdpb = -1) { fiGdpbIndex = iGdpb; }
 
  inline void UseAbsoluteTime(Bool_t bFlagIn = kTRUE) { fbUseAbsoluteTime = bFlagIn; }
 
private:
  Bool_t fbDebugMonitorMode;      
  Bool_t fbIgnoreCriticalErrors;  
  std::vector<Bool_t> fvbMaskedComponents;
  Int_t fiGdpbIndex;
  Bool_t fbUseAbsoluteTime = kFALSE;  
 
  CbmMcbm2018TofPar* fUnpackPar;             
  UInt_t fuNrOfGdpbs;                        
  std::map<UInt_t, UInt_t> fGdpbIdIndexMap;  
  UInt_t fuNrOfFeePerGdpb;                   
  UInt_t fuNrOfGet4PerFee;                   
  UInt_t fuNrOfChannelsPerGet4;              
  UInt_t fuNrOfChannelsPerFee;               
  UInt_t fuNrOfGet4;                         
  UInt_t fuNrOfGet4PerGdpb;                  
  UInt_t fuNrOfChannelsPerGdpb;              
 
  UInt_t fuMinTotPulser;
  UInt_t fuMaxTotPulser;
 
  static const Int_t kiMaxNbFlibLinks   = 32;
  static const UInt_t kuBytesPerMessage = 8;
  static const UInt_t kuNbChanDiamond   = 8;
 
  ULong64_t fulCurrentTsIdx;
  ULong64_t fulCurrentMsIdx;
  uint32_t fuCurrentMsSysId;  
  Double_t fdTsStartTime;     
  Double_t fdTsStopTimeCore;  
  Double_t fdMsTime;          
  UInt_t fuMsIndex;           
  std::map<gdpbv100::MessageTypes, UInt_t> fmMsgCounter;
  UInt_t fuCurrentEquipmentId;  
  UInt_t fuCurrDpbId;           
  UInt_t fuCurrDpbIdx;          
  Int_t fiRunStartDateTimeSec;  
  Int_t fiBinSizeDatePlots;     
  UInt_t fuGet4Id;  
  UInt_t fuGet4Nr;  
  std::vector<ULong64_t> fvulCurrentEpoch;       
  std::vector<ULong64_t> fvulCurrentEpochCycle;  
  std::vector<ULong64_t> fvulCurrentEpochFull;   
 
  std::vector<gdpbv100::Message> fvmEpSupprBuffer;
 
  Double_t fdStartTime;     
  Double_t fdStartTimeMsSz; 
  std::chrono::steady_clock::time_point
    ftStartTimeUnix; 
  std::vector<ULong64_t> fvulGdpbTsMsb;
  std::vector<ULong64_t> fvulGdpbTsLsb;
  std::vector<ULong64_t> fvulStarTsMsb;
  std::vector<ULong64_t> fvulStarTsMid;
  std::vector<ULong64_t> fvulGdpbTsFullLast;
  std::vector<ULong64_t> fvulStarTsFullLast;
  std::vector<UInt_t> fvuStarTokenLast;
  std::vector<UInt_t> fvuStarDaqCmdLast;
  std::vector<UInt_t> fvuStarTrigCmdLast;
 
  Bool_t fbEpochSinceLastHit;
  UInt_t fuDuplicatesCount;
  gdpbv100::Message fmLastHit;
 
  UInt_t fuHistoryHistoSize;  
 
  TH1* fhMessType;                                   
  TH1* fhSysMessType;                                
  TH2* fhGet4MessType;                               
  TH2* fhGet4ChanScm;                                
  TH2* fhGet4ChanErrors;                             
  TH2* fhGet4EpochFlags;                             
  TH2* fhGdpbAsicSpiCounts;                          
  TH2* fhGdpbMessType;                               
  TH2* fhGdpbSysMessType;                            
  TH2* fhGdpbSysMessPattType;                        
  TH2* fhGdpbEpochFlags;                             
  TH2* fhGdpbEpochSyncEvo;                           
  TH2* fhGdpbEpochMissEvo;                           
  TH1* fhGdpbEndMsBufferNotEmpty;                    
  TH2* fhGdpbEndMsDataLost;                          
  TH2* fhGdpbHitRate;                                
  std::vector<TH2*> fvhGdpbGet4MessType;             
  std::vector<TH2*> fvhGdpbGet4ChanScm;              
  std::vector<TH2*> fvhGdpbGet4ChanErrors;           
  TH1* fhMsgCntEvo;                                  
  TH1* fhHitCntEvo;                                  
  TH1* fhErrorCntEvo;                                
  TH1* fhLostEvtCntEvo;                              
  TProfile* fhErrorFractEvo;                         
  TProfile* fhLostEvtFractEvo;                       
  TH2* fhMsgCntPerMsEvo;                             
  TH2* fhHitCntPerMsEvo;                             
  TH2* fhErrorCntPerMsEvo;                           
  TH2* fhLostEvtCntPerMsEvo;                         
  TH2* fhErrorFractPerMsEvo;                         
  TH2* fhLostEvtFractPerMsEvo;                       
  std::vector<TH2*> fvhRawFt_gDPB;                   
  std::vector<TH2*> fvhRawCt_gDPB;                   
  std::vector<TH2*> fvhRemapTot_gDPB;                
  std::vector<TH1*> fvhRemapChCount_gDPB;            
  std::vector<TH2*> fvhRemapChRate_gDPB;             
  std::vector<TProfile2D*> fvhRemapChErrFract_gDPB;  
  std::vector<UInt_t> fuNbMissmatchPattern;
  TH2* fhNbMissPatternPerMs;                                    
  TH2* fhPatternMissmatch;                                      
  TH2* fhPatternEnable;                                         
  TH2* fhPatternResync;                                         
  std::vector<TH2*> fvhGdpbPatternMissmatchEvo;                 
  std::vector<TH2*> fvhGdpbPatternEnableEvo;                    
  std::vector<TH2*> fvhGdpbPatternResyncEvo;                    
  std::vector<std::vector<bool>> fvvbGdpbLastMissmatchPattern;  
  std::vector<std::vector<bool>> fvvbGdpbLastEnablePattern;     
  std::vector<std::vector<bool>> fvvbGdpbLastResyncPattern;     
  std::vector<TH2*> fvhGdpbMissmatchEvoPerTs;                   
  std::vector<TH2*> fvhGdpbMissmatchEnaEvoPerTs;                
  std::vector<TH2*> fvhGdpbEnableEvoPerTs;                      
  std::vector<TH2*> fvhGdpbResyncEvoPerTs;                      
  std::vector<TH2*> fvhGdpbResyncEnaEvoPerTs;                   
  std::vector<TH2*> fvhGdpbStateEvoPerTs;                       
  std::vector<TH1*> fvhTokenMsgType;                            
  std::vector<TH1*> fvhTriggerRate;                             
  std::vector<TH2*> fvhCmdDaqVsTrig;                            
  std::vector<TH2*> fvhStarTokenEvo;                            
  std::vector<TProfile*> fvhStarTrigGdpbTsEvo;                  
  std::vector<TProfile*> fvhStarTrigStarTsEvo;                  
 
  TCanvas* fcSummary;                    
  TCanvas* fcSummaryGdpb;                
  std::vector<TCanvas*> fvcSumGdpbGet4;  
  TCanvas* fcStarTrigTokenType;          
  TCanvas* fcStarTriggerRate;            
  TCanvas* fcStarTrigCmdDaqVsTrig;       
  TCanvas* fcStarTrigStarTokenEvo;       
  TCanvas* fcStarTrigGdpbTsEvo;          
  TCanvas* fcStarTrigStarTsEvo;          
 
  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);
  void ProcessPattern(gdpbv100::Message mess);
 
  void ProcessSlowCtrl(gdpbv100::Message mess);
 
  void ProcessStarTrig(gdpbv100::Message mess);
 
  CbmMcbm2018MonitorAlgoTof(const CbmMcbm2018MonitorAlgoTof&);
  CbmMcbm2018MonitorAlgoTof operator=(const CbmMcbm2018MonitorAlgoTof&);
 
  ClassDef(CbmMcbm2018MonitorAlgoTof, 1)
};
 
#endif  // CbmMcbm2018MonitorAlgoTof_H