CbmMcbm2018MonitorMuchLite.h

Go to the documentation of this file.

/* Copyright (C) 2019-2020 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: David Emschermann [committer] */
 
// -----------------------------------------------------------------------------
// -----                                                                   -----
// -----                   CbmMcbm2018MonitorMuchLite                        -----
// -----                Created 11/05/18  by P.-A. Loizeau                 -----
// -----                Modified 07/12/18  by Ajit Kumar                 -----
// -----                Modified 05/03/19  by Vikas Singhal               -----
// -----                                                                   -----
// -----------------------------------------------------------------------------
 
#ifndef CBMMCBM2018MonitorMuchLite_H
#define CBMMCBM2018MonitorMuchLite_H
 
#ifndef __CINT__
#include "Timeslice.hpp"
#endif
 
// 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 CbmMcbm2018MuchPar;
//class CbmCern2017UnpackParSts;
 
class CbmMcbm2018MonitorMuchLite : public CbmMcbmUnpack {
public:
  CbmMcbm2018MonitorMuchLite();
  virtual ~CbmMcbm2018MonitorMuchLite();
 
  virtual Bool_t Init();
#ifndef __CINT__
  virtual Bool_t DoUnpack(const fles::Timeslice& ts, size_t component);
#endif
  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 SetRunStart(Int_t dateIn, Int_t timeIn, Int_t iBinSize = 5);
 
  void ResetAllHistos();
  void SaveAllHistos(TString sFileName = "");
  void SaveHistos(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 UseNoiseLimitsSmx2LogicError( Bool_t bUseNoise = kTRUE ) { fbSmx2ErrorUseNoiseLevels = bUseNoise; }
 
  void SetMuchMode(Bool_t bMuchMode = kTRUE) { fbMuchMode = bMuchMode; }
 
  //   void SetTimeBin( size_t uTimeBin );
  void UseDaqBuffer(Bool_t) {};  //Virtual function in Mother Class, Need to update accordingly. VS
 
  void SetBinningFwFlag(Bool_t bEnable = kTRUE) { fbBinningFw = bEnable; }
 
private:
  // Parameters
  // Control flags
  Bool_t fbMuchMode;
  std::vector<Bool_t> fvbMaskedComponents;
  Bool_t fbBinningFw = kFALSE;
 
  // FLES containers
  std::vector<size_t> fvMsComponentsList;   
  size_t fuNbCoreMsPerTs;                   
  size_t fuNbOverMsPerTs;                   
  Bool_t fbIgnoreOverlapMs;                 
                                            // Unpacking and mapping
  CbmMcbm2018MuchPar* fUnpackParMuch;       
  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< Double_t > > > fvdFebAdcGain;  //! ADC gain in e-/b, [ NbDpb ][ NbCrobPerDpb ][ NbFebsPerCrob ]
  //std::vector< std::vector< std::vector< Double_t > > > fvdFebAdcOffs;  //! ADC offset in e-, [ NbDpb ][ NbCrobPerDpb ][ NbFebsPerCrob ]
 
  // Constants
  static const Int_t kiMaxNbFlibLinks   = 32;
  static const UInt_t kuBytesPerMessage = 4;
 
  TString fsHistoFileFullname;
  Bool_t fbPrintMessages;
  stsxyter::MessagePrintMask fPrintMessCtrl;
  // Bool_t                fbEnableCoincidenceMaps;
  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< ULong64_t  > > fvdChanLastHitTime;    //! Last hit time in ns   for each Channel
  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
  //Long64_t              fdStartTime;           /** Time of first valid hit (TS_MSB available), used as reference for evolution plots**/
  Long64_t prevtime_new;    
  Long64_t prevTime;        
  UInt_t prevAsic;          
  UInt_t prevChan;          
  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<Int_t> fviFebTimeSecLastRateUpdate;
  std::vector<Int_t> fviFebCountsSinceLastRateUpdate;
  std::vector<std::vector<Double_t>> fvdFebChanCountsSinceLastRateUpdate;
  //Bool_t fbLongHistoEnable;
  //UInt_t fuLongHistoNbSeconds;
  //UInt_t fuLongHistoBinSizeSec;
  //UInt_t fuLongHistoBinNb;
  UInt_t Counter;
  UInt_t Counter1;
  //Double_t fdCoincCenter;  // ns
  //Double_t fdCoincBorder;  // ns, +/-
  //Double_t fdCoincMin;     // ns
  //Double_t fdCoincMax;     // ns
 
  CbmHistManager* fHM;  
  TH1* fhMuchMessType;
  TH1* fhMuchSysMessType;
  TH1* fhMuchFebChanAdcRaw_combined;
  TH2* fhMuchMessTypePerDpb;
  TH2* fhMuchSysMessTypePerDpb;
  TH2* fhStatusMessType;
  TH2* fhMsStatusFieldType;
  TH2* fhMuchHitsElinkPerDpb;
 
  TH1* fhRate;
  TH1* fhRateAdcCut;
  TH1* fhFEBcount = nullptr;
  // std::vector<TH1 *>     fhMuchFebChanRateEvo;
 
  //UInt_t   kuNbAsicPerFeb = 1;
 
  std::vector<TH2*> fHistPadDistr;
  std::vector<TH2*> fRealHistPadDistr;
 
  //Double_t fdFebChanCoincidenceLimit; // ns
  std::vector<TH1*> fhMuchFebChanCntRaw;
  std::vector<TH1*> fhMuchFebSpill = {};
  std::vector<TH2*> fhMuchFebADC   = {};
  //std::vector<TH1 *>     fhMuchFebChanCntRawGood;
  std::vector<TH2*> fhMuchFebChanAdcRaw;
  std::vector<TProfile*> fhMuchFebChanAdcRawProf;
  //std::vector<TH2 *>     fhMuchFebChanAdcCal;
  //std::vector<TProfile*> fhMuchFebChanAdcCalProf;
  std::vector<TH2*> fhMuchFebChanRawTs;
  std::vector<TH2*> fhMuchChannelTime = {};
  //std::vector<TH2*>      fhMuchFebChanMissEvt;
  //std::vector<TH2*>      fhMuchFebChanMissEvtEvo;
  //std::vector<TH2*>      fhMuchFebAsicMissEvtEvo;
  //std::vector<TH1*>      fhMuchFebMissEvtEvo;
  std::vector<TH2*> fhMuchFebChanHitRateEvo;
  std::vector<TProfile*> fhMuchFebChanHitRateProf;
  //std::vector<TH2*>      fhMuchFebAsicHitRateEvo;
  std::vector<TH1*> fhMuchFebHitRateEvo;
  std::vector<TH1*> fhMuchFebHitRateEvo_mskch;
  std::vector<TH1*> fhMuchFebHitRateEvo_mskch_adccut;
  std::vector<TH1*> fhMuchFebHitRateEvo_WithoutDupli;
  //std::vector<TH2*>      fhMuchFebChanHitRateEvoLong;
  //std::vector<TH2*>      fhMuchFebAsicHitRateEvoLong;
  //std::vector<TH1*>      fhMuchFebHitRateEvoLong;
  std::vector<std::vector<Double_t>> fdMuchFebChanLastTimeForDist;
  std::vector<TH2*> fhMuchFebChanDistT;
  //std::vector< std::vector<TH1*> > fhMuchFebChanDtCoinc;
  //std::vector< std::vector<TH2*> > fhMuchFebChanCoinc;
  std::vector<TProfile*> fhMuchFebDuplicateHitProf;
 
  TH2* fhDpbMsErrors = nullptr;
 
  TCanvas* fcMsSizeAll;
  TH1* fhMsSz[kiMaxNbFlibLinks];
  TProfile* fhMsSzTime[kiMaxNbFlibLinks];
 
  // Methods later going into Algo
  Bool_t InitMuchParameters();
  void CreateHistograms();
  Bool_t ProcessMuchMs(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 ResetMuchHistos();
  void SaveMuchHistos(TString sFileName = "");
  Bool_t ScanForNoisyChannels(Double_t dNoiseThreshold = 1e3);
 
  CbmMcbm2018MonitorMuchLite(const CbmMcbm2018MonitorMuchLite&);
  CbmMcbm2018MonitorMuchLite operator=(const CbmMcbm2018MonitorMuchLite&);
 
  ClassDef(CbmMcbm2018MonitorMuchLite, 1)
};
 
#endif  // CBMMCBM2018MonitorMuchLite_H