CbmMcbm2018UnpackerAlgoTof.h

Go to the documentation of this file.

/* Copyright (C) 2019-2020 Facility for Antiproton and Ion Research in Europe, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Pierre-Alain Loizeau [committer] */
 
// -----------------------------------------------------------------------------
// -----                                                                   -----
// -----                  CbmMcbm2018UnpackerAlgoTof                       -----
// -----               Created 10.02.2019 by P.-A. Loizeau                 -----
// -----                                                                   -----
// -----------------------------------------------------------------------------
 
#ifndef CbmMcbm2018UnpackerAlgoTof_H
#define CbmMcbm2018UnpackerAlgoTof_H
 
#include "CbmStar2019Algo.h"
 
// Data
#include "CbmTofDigi.h"
 
#include "gDpbMessv100.h"
 
// CbmRoot
 
// C++11
#include <chrono>
 
// C/C++
#include <map>
#include <vector>
 
class CbmMcbm2018TofPar;
/*
class TCanvas;
class THttpServer;
*/
class TH1;
class TH2;
class TProfile;
 
class CbmMcbm2018UnpackerAlgoTof : public CbmStar2019Algo<CbmTofDigi> {
public:
  CbmMcbm2018UnpackerAlgoTof();
  ~CbmMcbm2018UnpackerAlgoTof();
 
  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; }
  inline void SetDiamondDpbIdx(UInt_t uIdx = 2) { fuDiamondDpbIdx = uIdx; }
 
  inline void SetVectCapInc(Double_t dIncFact) { fdCapacityIncFactor = dIncFact; }
  inline void SetMaxAsicInactive(Int_t ival) { fMaxAsicInactive = ival; }
 
private:
  Bool_t fbMonitorMode;       
  Bool_t fbDebugMonitorMode;  
  std::vector<Bool_t> fvbMaskedComponents;
 
  CbmMcbm2018TofPar* fUnpackPar;             
  UInt_t fuNrOfGdpbs;                        
  std::map<UInt_t, UInt_t> fGdpbIdIndexMap;  
  UInt_t fuNrOfFeePerGdpb;                   
  UInt_t fuNrOfGet4PerFee;                   
  UInt_t fuNrOfChannelsPerGet4;              
  UInt_t fuNrOfChannelsPerFee;               
  UInt_t fuNrOfGet4;                         
  UInt_t fuNrOfGet4PerGdpb;                  
  UInt_t fuNrOfChannelsPerGdpb;              
  UInt_t fuNrOfGbtx;
  UInt_t fuNrOfModules;
  std::vector<Int_t> fviNrOfRpc;
  std::vector<Int_t> fviRpcType;
  std::vector<Int_t> fviRpcSide;
  std::vector<Int_t> fviModuleId;
  std::vector<Int_t> fviRpcChUId;
 
  Double_t fdTimeOffsetNs;
  UInt_t fuDiamondDpbIdx;
 
  static const Int_t kiMaxNbFlibLinks = 32;
  static const UInt_t kuDetMask       = 0x0001FFFF;
 
  ULong64_t fulCurrentTsIdx;    
  ULong64_t fulCurrentMsIdx;    
  size_t fuCurrentMsSysId;      
  Double_t fdTsStartTime;       
  Double_t fdTsStopTimeCore;    
  Double_t fdMsTime;            
  UInt_t fuMsIndex;             
  UInt_t fuCurrentEquipmentId;  
  UInt_t fuCurrDpbId;           
  UInt_t fuCurrDpbIdx;          
  UInt_t fuGet4Id;  
  UInt_t fuGet4Nr;  
  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; 
  std::vector<std::vector<gdpbv100::Message>>
    fvvmEpSupprBuffer;  
  Bool_t fbEpochFoundInThisMs = kFALSE;
 
  std::vector<ULong64_t> fvulGdpbTsMsb;
  std::vector<ULong64_t> fvulGdpbTsLsb;
  std::vector<ULong64_t> fvulStarTsMsb;
  std::vector<ULong64_t> fvulStarTsMid;
  std::vector<ULong64_t> fvulGdpbTsFullLast;
  std::vector<ULong64_t> fvulStarTsFullLast;
  std::vector<UInt_t> fvuStarTokenLast;
  std::vector<UInt_t> fvuStarDaqCmdLast;
  std::vector<UInt_t> fvuStarTrigCmdLast;
 
  Double_t fdRefTime;
  Double_t fdLastDigiTime;
  Double_t fdFirstDigiTimeDif;
  Double_t fdEvTime0;
  TH1* fhRawTDigEvBmon;
  TH1* fhRawTDigRef0;
  TH1* fhRawTDigRef;
  TH1* fhRawTRefDig0;
  TH1* fhRawTRefDig1;
  TH1* fhRawDigiLastDigi;
  std::vector<TH2*> fhRawTotCh;
  std::vector<TH1*> fhChCount;
  std::vector<TH1*> fhChCountRemap;
  std::vector<Bool_t> fvbChanThere;
  std::vector<TH2*> fhChanCoinc;
  Bool_t fbDetChanThere[64];
  TH2* fhDetChanCoinc;
  /*
      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;
  Int_t fMaxAsicInactive       = 0;
 
  void ProcessEpochCycle(const uint64_t& ulCycleData);
  void ProcessEpoch(const gdpbv100::Message& mess, uint32_t uMesgIdx);
  void ProcessEndOfMsEpoch();
  void ProcessStarTrigger(const gdpbv100::Message& mess);
 
  void ProcessEpSupprBuffer();
 
  void ProcessHit(const gdpbv100::FullMessage& mess);
  void ProcessSlCtrl(const gdpbv100::FullMessage& mess);
  void ProcessSysMess(const gdpbv100::FullMessage& mess);
 
  void ProcessError(const gdpbv100::FullMessage& mess);
  void ProcessPattern(const gdpbv100::FullMessage& mess);
 
  inline Int_t GetArrayIndex(Int_t gdpbId, Int_t get4Id) { return gdpbId * fuNrOfGet4PerGdpb + get4Id; }
 
  CbmMcbm2018UnpackerAlgoTof(const CbmMcbm2018UnpackerAlgoTof&);
  CbmMcbm2018UnpackerAlgoTof operator=(const CbmMcbm2018UnpackerAlgoTof&);
 
  ClassDef(CbmMcbm2018UnpackerAlgoTof, 1)
};
 
#endif