CbmMcbm2018UnpackerAlgoMuch.h

Go to the documentation of this file.

// -----------------------------------------------------------------------------
// -----                                                                   -----
// -----                  CbmMcbm2018UnpackerAlgoMuch                      -----
// -----               Created 02.02.2019 by P.-A. Loizeau                 -----
// -----                                                                   -----
// -----------------------------------------------------------------------------
 
#ifndef CbmMcbm2018UnpackerAlgoMuch_H
#define CbmMcbm2018UnpackerAlgoMuch_H
 
#include "CbmStar2019Algo.h"
 
// Data
#include "CbmMuchBeamTimeDigi.h"
#include "StsXyterFinalHit.h"
#include "StsXyterMessage.h"
 
// CbmRoot
 
// C++11
#include <chrono>
 
// C/C++
#include <map>
#include <vector>
 
class CbmMcbm2018MuchPar;
/*
class TCanvas;
class THttpServer;
*/
class TH1;
class TH2;
class TProfile;
 
class CbmMcbm2018UnpackerAlgoMuch :
  public CbmStar2019Algo<CbmMuchBeamTimeDigi> {
public:
  CbmMcbm2018UnpackerAlgoMuch();
  ~CbmMcbm2018UnpackerAlgoMuch();
 
  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 SetTimeOffsetNs(Double_t dOffsetIn = 0.0) {
    fdTimeOffsetNs = dOffsetIn;
  }
  void SetTimeOffsetNsAsic(UInt_t uAsicIdx, Double_t dOffsetIn = 0.0);
  void MaskNoisyChannel(UInt_t uFeb, UInt_t uChan, Bool_t bMasked = kTRUE);
  void EnableAsicType(Int_t flag = 0) { fiFlag = flag; }
 
  void SetBinningFwFlag(Bool_t bEnable = kTRUE) { fbBinningFw = bEnable; }
 
  inline void SetVectCapInc(Double_t dIncFact) {
    fdCapacityIncFactor = dIncFact;
  }
 
  void SetAdcCut(UInt_t uAdc) { fdAdcCut = uAdc; }
 
 
  CbmMuchBeamTimeDigi* CreateMuchDigi(stsxyter::FinalHit*);
 
 
private:
  Bool_t
    fbMonitorMode;  
  Bool_t
    fbDebugMonitorMode;  
  std::vector<Bool_t> fvbMaskedComponents;
  Bool_t fbBinningFw = kFALSE;
 
  Int_t
    fiFlag;  
 
  CbmMcbm2018MuchPar* fUnpackPar;  
  UInt_t fuNrOfDpbs;               
  std::map<UInt_t, UInt_t>
    fDpbIdIndexMap;  
  std::vector<std::vector<Bool_t>>
    fvbCrobActiveFlag;  
  UInt_t fuNbFebs;       
  UInt_t fuNbStsXyters;  
 
  Double_t fdTimeOffsetNs;
  std::vector<Double_t> fvdTimeOffsetNsAsics;
  //std::vector< Int_t >     fviFebAddress;  //! Much address for each FEB, [ NbDpb * NbCrobPerDpb * NbFebsPerCrob ]
 
  Bool_t fbUseChannelMask;
  std::vector<std::vector<bool>>
    fvvbMaskedChannels;  
  UInt_t fdAdcCut;
  static const Int_t kiMaxNbFlibLinks = 32;
 
  ULong64_t fulCurrentTsIdx;
  ULong64_t fulCurrentMsIdx;
  Double_t
    fdTsStartTime;  
  Double_t
    fdTsStopTimeCore;  
  Double_t
    fdMsTime;  
  UInt_t fuMsIndex;  
  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;  
  Double_t
    fdStartTime; 
  Double_t
    fdStartTimeMsSz; 
  std::chrono::steady_clock::time_point
    ftStartTimeUnix; 
  std::vector<stsxyter::FinalHit>
    fvmHitsInMs;  
 
  static const UInt_t kuMaxTsMsbDiffDuplicates =
    32;  
  std::vector<std::vector<UShort_t>>
    fvvusLastTsChan;  
  std::vector<std::vector<UShort_t>>
    fvvusLastAdcChan;  
  std::vector<std::vector<UShort_t>>
    fvvusLastTsMsbChan;  
  std::vector<std::vector<UShort_t>>
    fvvusLastTsMsbCycleChan;  
 
  TH1* fhDigisTimeInRun;  
                          /*
      std::vector< TH1* > fvhHitsTimeToTriggerRaw;       //! [sector]
      std::vector< TH1* > fvhMessDistributionInMs;       //! [sector], extra monitor for debug
      TH1 *               fhEventNbPerTs;                //!
      TCanvas *           fcTimeToTrigRaw;               //! All sectors
*/
  TH1* fhVectorSize            = nullptr;
  TH1* fhVectorCapacity        = nullptr;
  size_t fuTsMaxVectorSize     = 0;
  Double_t fdCapacityIncFactor = 1.1;
 
  void ProcessHitInfo(const stsxyter::Message& mess,
                      const UShort_t& usElinkIdx,
                      const UInt_t& uAsicIdx,
                      const UInt_t& uMsIdx);
  void ProcessTsMsbInfo(const stsxyter::Message& mess,
                        UInt_t uMessIdx = 0,
                        UInt_t uMsIdx   = 0);
  void ProcessEpochInfo(const stsxyter::Message& mess);
  void ProcessStatusInfo(const stsxyter::Message& mess, const UInt_t& uAsicIdx);
 
  CbmMcbm2018UnpackerAlgoMuch(const CbmMcbm2018UnpackerAlgoMuch&);
  CbmMcbm2018UnpackerAlgoMuch operator=(const CbmMcbm2018UnpackerAlgoMuch&);
 
  ClassDef(CbmMcbm2018UnpackerAlgoMuch, 1)
};
 
#endif