CbmMcbm2018MonitorAlgoPsd.h

Go to the documentation of this file.

// -----------------------------------------------------------------------------
// -----                                                                   -----
// -----                  CbmMcbm2018MonitorAlgoPsd                        -----
// -----              Created 26.09.2019 by N.Karpushkin                   -----
// -----      based on CbmMcbm2018MonitorAlgoT0 by P.-A. Loizeau           -----
// -----                                                                   -----
// -----------------------------------------------------------------------------
 
#ifndef CbmMcbm2018MonitorAlgoPsd_H
#define CbmMcbm2018MonitorAlgoPsd_H
 
#include "CbmStar2019Algo.h"
 
// Data
#include "CbmPsdDigi.h"
#include "PronyFitter.h"
#include "PsdGbtReader.h"
 
// CbmRoot
 
// C++11
#include <chrono>
 
// C/C++
#include <map>
#include <vector>
 
class CbmMcbm2018PsdPar;
class TH1;
class TH2;
class TProfile;
class TGraph;
 
class CbmMcbm2018MonitorAlgoPsd : public CbmStar2019Algo<CbmPsdDigi> {
public:
  CbmMcbm2018MonitorAlgoPsd();
  ~CbmMcbm2018MonitorAlgoPsd();
 
  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();
 
  inline void SetMonitorMode(Bool_t bFlagIn = kTRUE) {
    fbMonitorMode = bFlagIn;
  }
  inline void SetHistoryHistoSize(UInt_t inHistorySizeSec = 1800) {
    fuHistoryHistoSize = inHistorySizeSec;
  }
  inline void SetChargeHistoArgs(std::vector<Int_t> inVec) {
    fviHistoChargeArgs = inVec;
  }
  inline void SetAmplHistoArgs(std::vector<Int_t> inVec) {
    fviHistoAmplArgs = inVec;
  }
  inline void SetZLHistoArgs(std::vector<Int_t> inVec) {
    fviHistoZLArgs = inVec;
  }
 
 
private:
  Bool_t
    fbMonitorMode;  
  Bool_t
    fbDebugMonitorMode;  
  std::vector<Bool_t> fvbMaskedComponents;
  Bool_t fbFirstPackageError;
 
  CbmMcbm2018PsdPar* fUnpackPar;  
  UInt_t fuNrOfGdpbs;             
  std::map<UInt_t, UInt_t> fGdpbIdIndexMap;  
  UInt_t fuNrOfFeePerGdpb;                   
  UInt_t fuNrOfChannelsPerFee;               
  UInt_t fuNrOfChannelsPerGdpb;              
 
  static const Int_t kiMaxNbFlibLinks   = 32;
  static const UInt_t kuBytesPerMessage = 8;
  static const UInt_t kuNbChanPsd       = 10;
 
  static constexpr UInt_t GetNbChanPsd() { return kuNbChanPsd; }
  ULong64_t fulCurrentTsIdx;
  ULong64_t fulCurrentMsIdx;
  Double_t
    fdTsStartTime;  
  Double_t
    fdTsStopTimeCore;  
  Double_t
    fdMsTime;  
  Double_t
    fdPrevMsTime;  
  UInt_t fuMsIndex;  
 
  UInt_t
    fuCurrentEquipmentId;  
  UInt_t
    fuCurrDpbId;  
  UInt_t
    fuCurrDpbIdx;  
  Int_t
    fiRunStartDateTimeSec;  
  Int_t fiBinSizeDatePlots;  
 
  std::vector<ULong64_t> fvulCurrentEpoch;  
  std::vector<ULong64_t>
    fvulCurrentEpochCycle;  
  std::vector<ULong64_t> fvulCurrentEpochFull;  
 
  Double_t
    fdStartTime; 
  Double_t
    fdStartTimeMsSz; 
  std::chrono::steady_clock::time_point
    ftStartTimeUnix; 
  UInt_t fuHistoryHistoSize; 
  std::vector<Int_t>
    fviHistoChargeArgs; 
  std::vector<Int_t>
    fviHistoAmplArgs; 
  std::vector<Int_t>
    fviHistoZLArgs; 
  UInt_t fuReadEvtCnt;
  UInt_t fuMsgsCntInMs;
  UInt_t fuReadMsgsCntInMs;
  UInt_t fuLostMsgsCntInMs;
  UInt_t fuReadEvtCntInMs;
 
  std::vector<UInt_t> fvuHitCntChanMs;
  std::vector<UInt_t> fvuErrorCntChanMs;
  std::vector<UInt_t> fvuEvtLostCntChanMs;
  std::vector<TH1*> fvhHitCntEvoChan;
  std::vector<TH2*> fvhHitCntPerMsEvoChan;
  std::vector<TH1*> fvhHitChargeChan;
  std::vector<TH1*> fvhHitZeroLevelChan;
  std::vector<TH1*> fvhHitAmplChan;
  std::vector<TH1*> fvhHitChargeByWfmChan;
  std::vector<TH2*> fvhHitChargeEvoChan;
  std::vector<TH1*> fvhHitWfmChan;
  std::vector<TH1*> fvhHitFitWfmChan;
 
  static const UInt_t kuNbWfmRanges   = 8;
  static const UInt_t kuNbWfmExamples = 8;
  std::vector<UInt_t> kvuWfmRanges;
  std::vector<UInt_t> kvuWfmInRangeToChangeChan;
  std::vector<TH1*> fv3hHitWfmFlattenedChan;
 
  Bool_t fbSpillOn;
  UInt_t fuCurrentSpillIdx;
  UInt_t fuCurrentSpillPlot;
  Double_t fdStartTimeSpill;
  Double_t fdLastSecondTime;
  UInt_t fuCountsLastSecond;
  static const UInt_t kuNbSpillPlots       = 5;
  static const UInt_t kuOffSpillCountLimit = 200;
 
  const UInt_t kuPsdChanMap[kuNbChanPsd] = {
    0};  // = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; //! Map from electronics channel to PSD physical channel
  TH1* fhChannelMap;
  TH1* fhHitChargeMap;
  TH1* fhHitMapEvo;
  TH2* fhChanHitMapEvo;
  std::vector<TH1*> fvhChannelMapSpill;
  TH1* fhHitsPerSpill;
 
  TH1* fhMsgsCntEvo;
  TH1* fhReadMsgsCntEvo;
  TH1* fhLostMsgsCntEvo;
  TH1* fhReadEvtsCntEvo;
 
  TH2* fhAdcTimeEvo;
  TH2* fhMsLengthEvo;
 
  TH2* fhMsgsCntPerMsEvo;
  TH2* fhReadMsgsCntPerMsEvo;
  TH2* fhLostMsgsCntPerMsEvo;
  TH2* fhReadEvtsCntPerMsEvo;
 
  std::vector<TH2*> fvhFitHarmonic1Chan;
  std::vector<TH2*> fvhFitHarmonic2Chan;
  std::vector<TH2*> fvhFitQaChan;
 
  TCanvas* fcSummary;
  TCanvas* fcHitMaps;
  TCanvas* fcChargesFPGA;
  TCanvas* fcChargesWfm;
  TCanvas* fcAmplitudes;
  TCanvas* fcGenCntsPerMs;
  TCanvas* fcSpillCounts;
  TCanvas* fcSpillCountsHori;
  TCanvas* fcWfmsAllChannels;
  std::vector<TCanvas*> fvcWfmsChan;
  TCanvas* fcPronyFit;
 
  CbmMcbm2018MonitorAlgoPsd(const CbmMcbm2018MonitorAlgoPsd&);
  CbmMcbm2018MonitorAlgoPsd operator=(const CbmMcbm2018MonitorAlgoPsd&);
 
  ClassDef(CbmMcbm2018MonitorAlgoPsd, 1)
};
 
#endif