CbmMcbm2018MonitorSts.h

Go to the documentation of this file.

/* Copyright (C) 2018-2020 Facility for Antiproton and Ion Research in Europe, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Pierre-Alain Loizeau [committer] */
 
// -----------------------------------------------------------------------------
// -----                                                                   -----
// -----                   CbmMcbm2018MonitorSts                        -----
// -----                Created 11/05/18  by P.-A. Loizeau                 -----
// -----                                                                   -----
// -----------------------------------------------------------------------------
 
#ifndef CBMMCBM2018MONITORSTS_H
#define CBMMCBM2018MONITORSTS_H
 
#include "Timeslice.hpp"
 
// Data
#include "StsXyterFinalHit.h"
#include "StsXyterMessage.h"
 
// CbmRoot
#include "CbmHistManager.h"
#include "CbmMcbmUnpack.h"
 
// C++11
#include <chrono>
 
// C/C++
#include <map>
#include <set>
#include <vector>
 
class CbmMcbm2018StsPar;
class CbmCern2017UnpackParSts;
 
class CbmMcbm2018MonitorSts : public CbmMcbmUnpack {
public:
  CbmMcbm2018MonitorSts();
  virtual ~CbmMcbm2018MonitorSts();
 
  virtual Bool_t Init();
 
  virtual Bool_t DoUnpack(const fles::Timeslice& ts, size_t component);
 
  virtual void Reset();
 
  virtual void Finish();
 
  void SetParContainers();
 
  Bool_t InitContainers();
 
  Bool_t ReInitContainers();
 
  virtual void AddMsComponentToList(size_t component, UShort_t usDetectorId);
  virtual void SetNbMsInTs(size_t uCoreMsNb, size_t uOverlapMsNb);
  void SetMsOverlap(size_t uOverlapMsNb = 1) { fuNbOverMsPerTs = uOverlapMsNb; }
  size_t GetMsOverlap() { return fuNbOverMsPerTs; }
  void SetIgnoreOverlapMs(Bool_t bFlagIn = kTRUE) { fbIgnoreOverlapMs = bFlagIn; }
 
  void SetRunStart(Int_t dateIn, Int_t timeIn, Int_t iBinSize = 5);
 
  void ResetAllHistos();
  void SaveAllHistos(TString sFileName = "");
  void SavePulserHistos(TString sFileName = "");
  void SetHistoFileName(TString sFileName = "data/SetupHistos.root") { fsHistoFileFullname = sFileName; }
 
  void SetPrintMessage(Bool_t bPrintMessOn             = kTRUE,
                       stsxyter::MessagePrintMask ctrl = stsxyter::MessagePrintMask::msg_print_Hex
                                                         | stsxyter::MessagePrintMask::msg_print_Human)
  {
    fbPrintMessages = bPrintMessOn;
    fPrintMessCtrl  = ctrl;
  }
  void SetLongDurationLimits(UInt_t uDurationSeconds = 3600, UInt_t uBinSize = 1);
  //   void SetEnableCoincidenceMaps( Bool_t bEnableCoincidenceMapsOn = kTRUE ) { fbEnableCoincidenceMaps = bEnableCoincidenceMapsOn; }
  //   void SetCoincidenceBorder( Double_t dCenterPos, Double_t dBorderVal );
  void SetFebChanCoincidenceLimitNs(Double_t dLimitIn) { fdFebChanCoincidenceLimit = dLimitIn; }
  void SetEnableCheckBugSmx20(Bool_t bEnable = kTRUE) { fbEnableCheckBugSmx20 = bEnable; }
  void UseNoiseLimitsSmx2LogicError(Bool_t bUseNoise = kTRUE) { fbSmx2ErrorUseNoiseLevels = bUseNoise; }
 
  void SetBinningFwFlag(Bool_t bEnable = kTRUE) { fbBinningFw = bEnable; }
 
  void UseDaqBuffer(Bool_t) {};
 
private:
  // Parameters
  // Control flags
  std::vector<Bool_t> fvbMaskedComponents;
  // FLES containers
  std::vector<size_t> fvMsComponentsList;  
  size_t fuNbCoreMsPerTs;                  
  size_t fuNbOverMsPerTs;                  
  Bool_t fbIgnoreOverlapMs;                
                                           // Unpacking and mapping
  CbmMcbm2018StsPar* fUnpackParSts;        
  UInt_t fuNbModules;                      
  std::vector<Int_t>
    fviModuleType;  
  std::vector<Int_t> fviModAddress;         
  UInt_t fuNrOfDpbs;                        
  std::map<UInt_t, UInt_t> fDpbIdIndexMap;  
  std::vector<std::vector<Bool_t>>
    fvbCrobActiveFlag;   
  UInt_t fuNbFebs;       
  UInt_t fuNbStsXyters;  
  std::vector<std::vector<std::vector<Int_t>>>
    fviFebModuleIdx;  
  std::vector<std::vector<std::vector<Int_t>>>
    fviFebModuleSide;  
  std::vector<std::vector<std::vector<Int_t>>>
    fviFebType;  
  std::vector<std::vector<std::vector<Double_t>>>
    fvdFebAdcGain;  
  std::vector<std::vector<std::vector<Double_t>>>
    fvdFebAdcOffs;  
 
  // Constants
  static const Int_t kiMaxNbFlibLinks   = 32;
  static const UInt_t kuBytesPerMessage = 4;
 
  TString fsHistoFileFullname;
  Bool_t fbPrintMessages;
  stsxyter::MessagePrintMask fPrintMessCtrl;
  //   Bool_t                fbEnableCoincidenceMaps;
  Bool_t fbEnableCheckBugSmx20;
  Bool_t fbBinningFw = kFALSE;
  ULong64_t fulCurrentTsIdx;
  ULong64_t fulCurrentMsIdx;
  std::map<stsxyter::MessType, UInt_t> fmMsgCounter;
  UInt_t fuCurrentEquipmentId;  
  UInt_t fuCurrDpbId;           
  UInt_t fuCurrDpbIdx;          
  Int_t fiRunStartDateTimeSec;  
  Int_t fiBinSizeDatePlots;     
 
  std::vector<ULong64_t> fvulCurrentTsMsb;                  
  std::vector<UInt_t> fvuCurrentTsMsbCycle;                 
  std::vector<UInt_t> fvuInitialHeaderDone;                 
  std::vector<UInt_t> fvuInitialTsMsbCycleHeader;           
  std::vector<UInt_t> fvuElinkLastTsHit;                    
  std::vector<std::vector<ULong64_t>> fvulChanLastHitTime;  
  std::vector<std::vector<Double_t>> fvdChanLastHitTime;    
  std::vector<Double_t> fvdPrevMsTime;                      
  std::vector<Double_t> fvdMsTime;                          
  std::vector<std::vector<std::vector<UInt_t>>> fvuChanNbHitsInMs;  
  std::vector<std::vector<std::vector<Double_t>>>
    fvdChanLastHitTimeInMs;  
  std::vector<std::vector<std::vector<UShort_t>>>
    fvusChanLastHitAdcInMs;  
  //   std::vector< std::vector< std::multiset< stsxyter::FinalHit > > > fvmChanHitsInTs; //! All hits (time & ADC) in bins in last TS for each Channel
  Double_t fdStartTime;     
  Double_t fdStartTimeMsSz; 
  std::chrono::steady_clock::time_point
    ftStartTimeUnix; 
  std::vector<stsxyter::FinalHit>
    fvmHitsInMs;  
  std::vector<std::vector<stsxyter::FinalHit>>
    fvmAsicHitsInMs;  
  std::vector<std::vector<stsxyter::FinalHit>>
    fvmFebHitsInMs;  
  UInt_t fuMaxNbMicroslices;
  Int_t fiTimeIntervalRateUpdate;
  std::vector<Double_t> fvdFebTimeSecLastRateUpdate;
  std::vector<Int_t> fviFebCountsSinceLastRateUpdate;
  std::vector<std::vector<Double_t>> fvdFebChanCountsSinceLastRateUpdate;
  Bool_t fbLongHistoEnable;
  UInt_t fuLongHistoNbSeconds;
  UInt_t fuLongHistoBinSizeSec;
  UInt_t fuLongHistoBinNb;
 
  Double_t fdCoincCenter;  // ns
  Double_t fdCoincBorder;  // ns, +/-
  Double_t fdCoincMin;     // ns
  Double_t fdCoincMax;     // ns
 
  CbmHistManager* fHM;  
  TH1* fhStsMessType;
  TH1* fhStsSysMessType;
  TH2* fhStsMessTypePerDpb;
  TH2* fhStsSysMessTypePerDpb;
  TH2* fhStsStatusMessType;
  TH2* fhStsMsStatusFieldType;
  TH2* fhStsMessTypePerElink;
  TH2* fhStsHitsElinkPerDpb;
  TH2* fhStsAllFebsHitRateEvo;
  TH2* fhStsAllAsicsHitRateEvo;
  TH2* fhStsFebAsicHitCounts;
 
  //   UInt_t   kuNbAsicPerFeb = 8;
  Double_t fdFebChanCoincidenceLimit;  // ns
  std::vector<TH1*> fhStsFebChanCntRaw;
  std::vector<TH1*> fhStsFebChanCntRawGood;
  std::vector<TH2*> fhStsFebChanAdcRaw;
  std::vector<TProfile*> fhStsFebChanAdcRawProf;
  //   std::vector<TH2 *>     fhStsFebChanAdcCal;
  //   std::vector<TProfile*> fhStsFebChanAdcCalProf;
  std::vector<TH2*> fhStsFebChanRawTs;
  std::vector<TH2*> fhStsFebChanMissEvt;
  std::vector<TH2*> fhStsFebChanMissEvtEvo;
  std::vector<TH2*> fhStsFebAsicMissEvtEvo;
  std::vector<TH1*> fhStsFebMissEvtEvo;
  std::vector<TH2*> fhStsFebChanHitRateEvo;
  std::vector<TProfile*> fhStsFebChanHitRateProf;
  std::vector<TH2*> fhStsFebAsicHitRateEvo;
  std::vector<TH1*> fhStsFebHitRateEvo;
  std::vector<TH2*> fhStsFebChanHitRateEvoLong;
  std::vector<TH2*> fhStsFebAsicHitRateEvoLong;
  std::vector<TH1*> fhStsFebHitRateEvoLong;
  std::vector<std::vector<Double_t>> fdStsFebChanLastTimeForDist;
  std::vector<TH2*> fhStsFebChanDistT;
  std::vector<TH2*> fhStsFebChanCloseHitsCounts;
  std::vector<TProfile*> fhStsFebChanCloseHitsRatio;
  /*
   std::vector< std::vector<TH1*> > fhStsFebChanDtCoinc;
   std::vector< std::vector<TH2*> > fhStsFebChanCoinc;
 
   std::vector< TH1* > fhStsModulePNCoincDt;
   std::vector< TH2* > fhStsModulePNCoincDtAsicP;
   std::vector< TH2* > fhStsModulePNCoincDtAsicN;
   std::vector< TH2* > fhStsModulePNCoincChan;
   std::vector< TH2* > fhStsModulePNCoincAdc;
   std::vector< TH2* > fhStsModuleCoincAdcChanP;
   std::vector< TH2* > fhStsModuleCoincAdcChanN;
   std::vector< TH2* > fhStsModuleCoincMap;
*/
  Bool_t fbSmx2ErrorUseNoiseLevels;
  static const UInt_t kuSmxErrCoincWinNbHits          = 11;
  constexpr static const Double_t kdSmxErrCoincWinBeg = 0;  //ns, true for time sorted hits!
  constexpr static const Double_t kdSmxErrCoincWinMainM07 = 320;  //ns
  constexpr static const Double_t kdSmxErrCoincWinMainM08 = 380;  //ns
  constexpr static const Double_t kdSmxErrCoincWinMainM09 = 450;  //ns
  constexpr static const Double_t kdSmxErrCoincWinMainM10 = 510;  //ns
  constexpr static const Double_t kdSmxErrCoincWinMainM11 = 570;  //ns
  constexpr static const Double_t kdSmxErrCoincWinNoiseM07 = 390;  //ns
  constexpr static const Double_t kdSmxErrCoincWinNoiseM08 = 460;  //ns
  constexpr static const Double_t kdSmxErrCoincWinNoiseM09 = 540;  //ns
  constexpr static const Double_t kdSmxErrCoincWinNoiseM10 = 600;  //ns
  constexpr static const Double_t kdSmxErrCoincWinNoiseM11 = 660;  //ns
  Double_t fdSmxErrCoincWinM07;
  Double_t fdSmxErrCoincWinM08;
  Double_t fdSmxErrCoincWinM09;
  Double_t fdSmxErrCoincWinM10;
  Double_t fdSmxErrCoincWinM11;
  std::vector<std::vector<std::vector<Double_t>>>
    fvdSmxErrTimeLastHits;                                   
  std::vector<std::vector<UInt_t>> fvuSmxErrIdxFirstHitM07;  
  std::vector<std::vector<UInt_t>> fvuSmxErrIdxFirstHitM08;  
  std::vector<std::vector<UInt_t>> fvuSmxErrIdxFirstHitM09;  
  std::vector<std::vector<UInt_t>> fvuSmxErrIdxFirstHitM10;  
  std::vector<std::vector<UInt_t>> fvuSmxErrIdxFirstHitM11;  
  std::vector<std::vector<UInt_t>> fvuSmxErrIdxLastHit;
  void SmxErrInitializeVariables();
  Bool_t SmxErrCheckCoinc(UInt_t uFebIdx, UInt_t uAsicIdx, Double_t dNewHitTime);
  std::vector<TProfile*> fhStsFebSmxErrRatioEvo;
  std::vector<TProfile2D*> fhStsFebSmxErrRatioEvoAsic;
  std::vector<TProfile*> fhStsFebSmxErrRatioCopyEvo;
  std::vector<TProfile2D*> fhStsFebSmxErrRatioCopyEvoAsic;
  std::vector<TProfile*> fhStsFebSmxErrRatioCopySameAdcEvo;
  std::vector<TProfile2D*> fhStsFebSmxErrRatioCopySameAdcEvoAsic;
 
  TH2* fhMsErrorsEvo = nullptr;
 
  std::vector<TCanvas*> fvcStsSumm;
  std::vector<TCanvas*> fvcStsSmxErr;
 
  TCanvas* fcMsSizeAll;
  TH1* fhMsSz[kiMaxNbFlibLinks];
  TProfile* fhMsSzTime[kiMaxNbFlibLinks];
  /*
   Double_t                          fdStartTs; //! Last hits in each ASIC
   std::vector< stsxyter::FinalHit > fvmLastHitAsic; //! Last hits in each ASIC
   std::vector<TH2 *>                fhStsTimeDiffPerAsic;
   std::vector< std::vector<TH1 *> > fhStsTimeDiffPerAsicPair;
   std::vector< std::vector<TH1 *> > fhStsTimeDiffClkPerAsicPair;
   std::vector< std::vector<TH2 *> > fhStsTimeDiffEvoPerAsicPair;
   std::vector< std::vector<TProfile *> > fhStsTimeDiffEvoPerAsicPairProf;
   std::vector< std::vector<TProfile *> > fhStsRawTimeDiffEvoPerAsicPairProf;
   std::vector< std::vector<TH2 *> > fhStsTsLsbMatchPerAsicPair;
   std::vector< std::vector<TH2 *> > fhStsTsMsbMatchPerAsicPair;
   std::vector<TH1 *>                fhStsIntervalAsic;
   std::vector<TH1 *>                fhStsIntervalLongAsic;
 
   static const UInt_t kuNbValuesForTimeDiffMean = 100;
   constexpr static const double kdPulserPeriod = 154000; /// ns
   constexpr static const double kdTimeDiffToMeanMargin = 50;
   std::vector< std::vector< std::vector< Double_t > > > fvdLastTimeDiffValuesAsicPair;
   std::vector< std::vector< UInt_t > >  fvuLastTimeDiffSlotAsicPair;
   std::vector< std::vector< Double_t > > fvdMeanTimeDiffAsicPair;
 
   void UpdatePairMeanValue( UInt_t uAsicA, UInt_t uAsicB, Double_t dNewValue );
*/
 
  // Methods later going into Algo
  Bool_t InitStsParameters();
  void CreateHistograms();
  Bool_t ProcessStsMs(const fles::Timeslice& ts, size_t uMsComp, UInt_t uMsIdx);
 
  void FillHitInfo(stsxyter::Message mess, const UShort_t& usElinkIdx, const UInt_t& uAsicIdx, const UInt_t& uMsIdx);
  void FillTsMsbInfo(stsxyter::Message mess, UInt_t uMessIdx = 0, UInt_t uMsIdx = 0);
  void FillEpochInfo(stsxyter::Message mess);
 
  void ResetStsHistos();
  void SaveStsHistos(TString sFileName = "");
  Bool_t ScanForNoisyChannels(Double_t dNoiseThreshold = 1e3);
 
  CbmMcbm2018MonitorSts(const CbmMcbm2018MonitorSts&);
  CbmMcbm2018MonitorSts operator=(const CbmMcbm2018MonitorSts&);
 
  ClassDef(CbmMcbm2018MonitorSts, 1)
};
 
#endif  // CBMMCBM2018MONITORSTS_H