CbmStar2019EventBuilderEtofAlgo.h

Go to the documentation of this file.

// -----------------------------------------------------------------------------
// -----                                                                   -----
// -----                  CbmStar2019EventBuilderEtofAlgo                  -----
// -----               Created 03.11.2018 by P.-A. Loizeau                 -----
// -----                                                                   -----
// -----------------------------------------------------------------------------
 
#ifndef CbmStar2019EventBuilderEtofAlgo_H
#define CbmStar2019EventBuilderEtofAlgo_H
 
#include "CbmStar2019Algo.h"
 
#include "CbmTofDigi.h"
#include "CbmTofStarData2019.h"
#include "gDpbMessv100.h"
 
#include <bitset>
#include <chrono>
#include <map>
#include <vector>
 
class CbmStar2019TofPar;
/*
class TCanvas;
class THttpServer;
*/
class TH1;
class TH2;
class TProfile;
 
class CbmStar2019EventBuilderEtofAlgo : public CbmStar2019Algo<CbmTofDigi> {
public:
  CbmStar2019EventBuilderEtofAlgo();
  ~CbmStar2019EventBuilderEtofAlgo();
 
  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 BuildEvents();
  std::vector<CbmTofStarSubevent2019>& GetEventBuffer() {
    return fvEventsBuffer;
  }
 
  Bool_t CreateHistograms();
  Bool_t FillHistograms();
  Bool_t ResetHistograms();
 
  inline void SetMonitorMode(Bool_t bFlagIn = kTRUE) {
    fbMonitorMode = bFlagIn;
  }
  inline void SetDebugMonitorMode(Bool_t bFlagIn = kTRUE) {
    fbDebugMonitorMode = bFlagIn;
  }
  inline void SetStoreLostEventMsg(Bool_t bFlagIn = kTRUE) {
    fbStoreLostEventMsg = bFlagIn;
  }
  inline void SetAddStatusToEvent(Bool_t bFlagIn = kTRUE) {
    fbAddStatusToEvent = bFlagIn;
  }
  inline void SetPulserTotLimits(UInt_t uMin, UInt_t uMax) {
    fuMinTotPulser = uMin;
    fuMaxTotPulser = uMax;
  }
 
private:
  Bool_t
    fbMonitorMode;  
  Bool_t
    fbDebugMonitorMode;  
  Bool_t
    fbStoreLostEventMsg;  
  Bool_t
    fbAddStatusToEvent;  
 
  static const UInt_t kuMaxNbErrorsPerGdpbPerEvent =
    500;  
 
  CbmStar2019TofPar* fUnpackPar;  
  UInt_t fuNrOfGdpbs;             // Total number of GDPBs in the system
  std::map<UInt_t, UInt_t> fGdpbIdIndexMap;  // gDPB ID to index map
  UInt_t fuNrOfFeePerGdpb;                   // Number of FEBs per GDPB
  UInt_t fuNrOfGet4PerFee;                   // Number of GET4s per FEE
  UInt_t fuNrOfChannelsPerGet4;              // Number of channels in each GET4
 
  UInt_t fuNrOfChannelsPerFee;   // Number of channels in each FEE
  UInt_t fuNrOfGet4;             // Total number of Get4 chips in the system
  UInt_t fuNrOfGet4PerGdpb;      // Number of GET4s per GDPB
  UInt_t fuNrOfChannelsPerGdpb;  // Number of channels per GDPB
  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;
  Double_t fdAllowedTriggersSpread;
  std::vector<Double_t> fdStarTriggerDeadtime;  
  std::vector<Double_t> fdStarTriggerDelay;     
  std::vector<Double_t> fdStarTriggerWinSize;   
 
  UInt_t fuMinTotPulser;
  UInt_t fuMaxTotPulser;
 
  ULong64_t fulCurrentTsIndex;  // Idx of the current TS
  Double_t
    fdTsStartTime;  // Time in ns of current TS from the index of the first MS first component
  Double_t
    fdTsStopTimeCore;  // End Time in ns of current TS Core from the index of the first MS first component
  size_t fuCurrentMs;  // Idx of the current MS in TS (0 to fuTotalMsNb)
  Double_t fdMsTime;  // Time in ns of current MS from its index field in header
  UInt_t fuMsIndex;   // Index of current MS within the TS
  UInt_t fuGdpbId;    // Id (hex number) of the GDPB for current message
  UInt_t
    fuGdpbNr;  // running number (0 to fuNrOfGdpbs) of the GDPB for current message
  UInt_t
    fuGet4Id;  // running number (0 to fuNrOfGet4PerGdpb) of the Get4 chip of a unique GDPB for current message
  UInt_t
    fuGet4Nr;  // running number (0 to fuNrOfGet4) of the Get4 chip in the system for current message
  Int_t fiEquipmentId;
 
  std::vector<ULong64_t> fvulCurrentEpoch;  
  std::vector<ULong64_t>
    fvulCurrentEpochCycle;  
  std::vector<ULong64_t> fvulCurrentEpochFull;  
 
  std::vector<std::vector<gdpbv100::Message>> fvvmEpSupprBuffer;  
  std::vector<std::vector<gdpbv100::FullMessage>>
    fvvBufferMajorAsicErrors;  
  std::vector<std::vector<gdpbv100::FullMessage>>
    fvvBufferMessages;  
  std::vector<std::vector<CbmTofStarTrigger2019>>
    fvvBufferTriggers;                                 
  std::vector<CbmTofStarSubevent2019> fvEventsBuffer;  
 
  Bool_t fbTriggerFoundA;
  Bool_t fbTriggerFoundB;
  Bool_t fbTriggerFoundC;
  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;         
  std::vector<ULong64_t> fvulGdpbTsFullLastCore;  
  std::vector<ULong64_t> fvulStarTsFullLastCore;  
  std::vector<UInt_t> fvuStarTokenLastCore;       
  std::vector<UInt_t> fvuStarDaqCmdLastCore;      
  std::vector<UInt_t> fvuStarTrigCmdLastCore;     
 
  std::vector<Double_t> fvdMessCandidateTimeStart;  
  std::vector<Double_t> fvdMessCandidateTimeStop;   
  std::vector<Double_t> fvdTrigCandidateTimeStart;  
  std::vector<Double_t> fvdTrigCandidateTimeStop;   
  Bool_t fbEpochAfterCandWinFound;
  Bool_t fbTriggerAfterCandWinFound;
 
  static const uint32_t kuNbMsgPerPattern = 8;
  static const uint32_t kuNbAsicPerGdpb   = 240;
  std::vector<std::bitset<kuNbAsicPerGdpb>>
    fvbGdpbLastMissmatchPattern;  
  std::vector<std::bitset<kuNbAsicPerGdpb>>
    fvbGdpbLastEnablePattern;  
  std::vector<std::bitset<kuNbAsicPerGdpb>>
    fvbGdpbLastResyncPattern;  
  std::vector<std::vector<std::pair<uint64_t,
                                    std::bitset<kuNbAsicPerGdpb>>>>
    fvSectorStatusPattern;  
 
 
  std::vector<TH1*> fvhHitsTimeToTriggerRaw;  
  std::vector<TH2*>
    fvhHitsTimeToTriggerRawPulser;  
  std::vector<TH1*> fvhHitsTimeToTriggerSel;  
  std::vector<TH2*>
    fvhHitsTimeToTriggerSelVsDaq;  
  std::vector<TH2*>
    fvhHitsTimeToTriggerSelVsTrig;  
  std::vector<TH1*> fvhTriggerDt;   
  std::vector<TH1*>
    fvhTriggerDistributionInTs;  
  std::vector<TH1*>
    fvhTriggerDistributionInMs;  
  std::vector<TH1*>
    fvhMessDistributionInMs;              
  TH1* fhEventNbPerTs;                    
  TH1* fhEventSizeDistribution;           
  TProfile* fhEventSizeEvolution;         
  TH1* fhEventNbEvolution;                
  TH1* fhEventNbDistributionInTs;         
  TProfile* fhEventSizeDistributionInTs;  
  TH2* fhRawTriggersStats;                
  TH2* fhRawTriggersStatsCore;            
  TH2* fhRawTriggersStatsOver;            
  TH2* fhRawTriggersStatsSel;             
  TH2* fhMissingTriggersEvolution;        
  TCanvas* fcTimeToTrigRaw;               
  TCanvas* fcTimeToTrigSel;               
  TCanvas* fcTrigDistMs;       
  TCanvas* fcMessDistMs;       
  TCanvas* fcEventBuildStats;  
  TCanvas* fcTriggerStats;     
 
  void ProcessEpochCycle(uint64_t ulCycleData);
  void ProcessEpoch(gdpbv100::Message mess);
  void ProcessStarTrigger(gdpbv100::Message mess);
 
  void ProcessEpSupprBuffer(uint32_t uGdpbNr);
  void StoreMessageInBuffer(gdpbv100::FullMessage fullMess, uint32_t uGdpbNr);
 
  void ProcessHit(gdpbv100::Message mess, uint64_t ulCurEpochGdpbGet4);
  void ProcessSlCtrl(gdpbv100::Message mess, uint64_t ulCurEpochGdpbGet4);
  void ProcessSysMess(gdpbv100::Message mess, uint64_t ulCurEpochGdpbGet4);
  void ProcessPattern(gdpbv100::Message mess, uint64_t ulCurEpochGdpbGet4);
 
  void UpdateStatusPatternCurrGdpb();
  gdpbv100::FullMessage CreateStatusMessage(
    uint16_t uGdpbId,
    uint32_t uIndex,
    std::pair<uint64_t, std::bitset<kuNbAsicPerGdpb>> statusIn);
 
  CbmStar2019EventBuilderEtofAlgo(const CbmStar2019EventBuilderEtofAlgo&);
  CbmStar2019EventBuilderEtofAlgo
  operator=(const CbmStar2019EventBuilderEtofAlgo&);
 
  ClassDef(CbmStar2019EventBuilderEtofAlgo, 1)
};
 
#endif