CbmMcbm2018UnpackerAlgoRich2020.h

Go to the documentation of this file.

/* Copyright (C) 2021 Justus-Liebig-Universitaet Giessen, Giessen
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Semen Lebedev [committer] */
 
#ifndef CbmMcbm2018UnpackerAlgoRich2020_H
#define CbmMcbm2018UnpackerAlgoRich2020_H
 
#include "CbmStar2019Algo.h"  // mother class
 
// STD
#include <array>
#include <map>
#include <vector>
 
// ROOT
#include <TArrayD.h>
#include <TH2D.h>
 
// CbmRoot
#include "CbmMcbm2018UnpackerUtilRich2020.h"
#include "CbmRichDigi.h"
 
class CbmMcbm2018RichPar;
 
#define RISINGEDGEID 1
#define FALLINGEDGEID 0
 
#define TOTMIN -20.
#define TOTMAX 100.
 
enum class TrbNetState
{
  IDLE,
  HEADER,
  EPOCH,
  TDC,
  TRAILER,
  CTS,
  DEBUG
};
 
enum class RichErrorType
{
  mtsError,
  tdcHeader,
  tdcTrailer,
  ctsHeader,
  ctsTrailer,
  subEventError
};
 
class CbmMcbm2018UnpackerAlgoRich2020 : public CbmStar2019Algo<CbmRichDigi> {
public:
  CbmMcbm2018UnpackerAlgoRich2020();
 
  virtual ~CbmMcbm2018UnpackerAlgoRich2020();
 
  virtual Bool_t Init();
 
  virtual void Reset();
 
  virtual void Finish();
 
  virtual Bool_t InitContainers();
 
  virtual Bool_t ReInitContainers();
 
  virtual TList* GetParList();
 
  Bool_t InitParameters();
 
  void AddMsComponentToList(size_t component, UShort_t usDetectorId);
 
  virtual Bool_t ProcessTs(const fles::Timeslice& ts);
 
  virtual Bool_t ProcessTs(const fles::Timeslice& ts, size_t component);
 
  virtual Bool_t ProcessMs(const fles::Timeslice& ts, size_t uMsCompIdx, size_t uMsIdx);
 
  Bool_t DebugMs(const fles::Timeslice& ts, size_t uMsCompIdx, size_t uMsIdx);
 
  void SetMonitorMode(Bool_t bFlagIn = kTRUE) { fbMonitorMode = bFlagIn; }
 
  inline void SetTimeOffsetNs(Double_t dOffsetIn = 0.0) { fdTimeOffsetNs = dOffsetIn; }
 
  inline void DoTotCorr(Bool_t bDoToTCorr = kTRUE) { fbDoToTCorr = bDoToTCorr; }
 
  void SetRawDataMode(Bool_t bDebug = kFALSE) { fRawDataMode = bDebug; }
 
  Int_t Debug(const uint8_t* ptr, const size_t size);
 
private:
  void InitStorage();
 
  void ProcessMicroslice(size_t const size, uint8_t const* const ptr);
 
  Int_t ProcessTRBevent(size_t const size, uint8_t const* const ptr);
 
  Int_t ProcessTRBeventHeader(size_t const size, uint8_t const* const ptr);
 
  Int_t ProcessSKIPsubevent(size_t const size, uint8_t const* const ptr);
 
  Int_t ProcessCTSsubevent(size_t const size, uint8_t const* const ptr);
 
  Int_t ProcessTRBsubevent(size_t const size, uint8_t const* const ptr);
 
  Int_t ProcessTRBsubsubevent(size_t const size, uint8_t const* const ptr, Int_t const hubOffset, size_t const hubSize);
 
  Int_t ProcessTDCword(uint8_t const* const ptr, Int_t const word, size_t const size);
 
  void ProcessTimestampWord(Int_t tdcData);
 
  void WriteOutputDigi(Int_t fpgaID, Int_t channel, Double_t time, Double_t tot, uint64_t MSidx);
 
  void FinalizeTs();
 
  void ErrorMsg(uint16_t errbits, RichErrorType type, uint16_t tdcAddr = 0);
 
  Int_t GetPixelUID(Int_t fpgaID, Int_t ch) const
  {
    // First 16 bits are used for the FPGA ID, then
    // 8 bits unused and then 8 bits are used for the channel
    return ((fpgaID << 16) | (ch & 0x00FF));
  }
 
  void findTDCAlignmentError(uint8_t const* const ptr, size_t const size);
 
private:  // data members
  Bool_t fbMonitorMode;  
 
  Bool_t fbDebugMonitorMode;  
 
  Bool_t fRawDataMode;
 
  Bool_t fError;  
 
  TrbNetState fTrbState;  // State of TrbNet (HEADER,TRAILER,...)
 
  uint32_t fErrorCorr;  // Offset to correct a error in datastream
 
  Bool_t fbDoToTCorr;
 
  Bool_t fSkipMs;
  Double_t fdTimeOffsetNs;
 
  size_t fDataSize = 0;
 
 
  Int_t fRICHcompIdx;
 
  CbmMcbm2018RichPar* fUnpackPar;  
 
  uint64_t fTScounter;
 
  Int_t fCurMSid;  
 
  uint64_t fCurMSidx;  
 
  Int_t fGwordCnt;  
 
  Bool_t fInSubSubEvent;  
 
  UInt_t fCurEpochCounter;  
 
  Int_t fSubSubEvId;  
 
  Bool_t fLastFeeOnHub = false;
 
  std::vector<Int_t> fTDCAlignmentErrorPositions;
 
  Int_t fTdcWordCorrectionCnt = 0;
 
  Int_t fTdcWordCorrectionGlobalCnt = 0;
 
  Int_t fSkipCnt = 0;
 
private:  // Stored timestamps
  Double_t fLastCTSch0_re_time;  
 
  Double_t fLastCTSch2_re_time;  
 
  Double_t fLastCTSch2_fe_time;  
 
  Double_t fPrevLastCTSch0_re_time;  
 
  Double_t fPrevLastCTSch2_re_time;  
 
  Double_t fPrevLastCTSch2_fe_time;  
 
  TArrayD fLastCh0_re_time;  
 
  TArrayD fPrevLastCh0_re_time;  
 
private:  // digi building
  void ProcessRisingEdge(Int_t subSubEvId, Int_t channel, Double_t time);
 
  void ProcessFallingEdge(Int_t subSubEvId, Int_t channel, Double_t time);
 
  std::vector<CbmMcbmRichEdge> fRisingEdgesBuf;  
 
  std::vector<CbmMcbmRichEdge> fFallingEdgesBuf;  
 
public:  // histograms
  Bool_t CreateHistograms();
 
  //    Bool_t FillHistograms();
 
  Bool_t ResetHistograms();
 
  TH1D* GetTotH1(Int_t fpgaID, Int_t channel);
  TH2D* GetTotH2(Int_t fpgaID);
  /*
        TH2D* fhTDCch0re_minusCTSch0re; //!
        TH2D* fhTDCch0re_minusCTSch2re; //!
        TH2D* fhTDCch0re_minusCTSch2fe; //!
        TH2D* fhTDCch0re_minusPrevCTSch0re; //!
        TH2D* fhTDCch0re_minusPrevCTSch2re; //!
        TH2D* fhTDCch0re_minusPrevCTSch2fe; //!
 
        std::vector<TH2D*> fhTDCre_minusTDCch0re; //!
 
        std::vector<TH2D*> fhTDCre_minusPrevTDCch0re; //!
*/
  std::vector<TH2D*> fhTDCre_corrected1;  
 
  std::vector<TH2D*> fhTDCre_corrected2;  
 
  std::vector<TCanvas*> fcTot2d;  
 
  TH1* fhVectorSize     = nullptr;
  TH1* fhVectorCapacity = nullptr;
 
  //TH2* fhDigisInChnl       = nullptr;
  //TH2* fhDigisInDiRICH     = nullptr;
 
  TH2D* fhTdcErrors   = nullptr;
  TH2D* fhEventErrors = nullptr;
 
  TH2D* fhDiRICHWords = nullptr;
  TH2D* fhChnlWords   = nullptr;
 
  TH1* fhEventSize       = nullptr;
  TH2* fhSubEventSize    = nullptr;
  TH2* fhSubSubEventSize = nullptr;
  TH2* fhChnlSize        = nullptr;
 
  std::array<unsigned int, 33> fChnlMsgCnt;
 
  bool fDebugPrint = 0;
  std::map<uint16_t, uint16_t> fMapFEE;
 
  std::map<Int_t, std::map<Int_t, TH1D*>> fhTotMap;
 
  std::map<Int_t, TH2D*> fhTot2dMap;
 
  size_t fuTsMaxVectorSize     = 0;
  Double_t fdCapacityIncFactor = 1.1;
 
  inline void SetVectCapInc(Double_t dIncFact) { fdCapacityIncFactor = dIncFact; }
 
  ClassDef(CbmMcbm2018UnpackerAlgoRich2020, 1);
};
 
#endif  // CbmMcbm2018UnpackerAlgoRich2020_H