CbmStar2019EventBuilderEtofAlgo.h

Go to the documentation of this file.

/* Copyright (C) 2018-2020 Facility for Antiproton and Ion Research in Europe, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Pierre-Alain Loizeau [committer] */
 
// -----------------------------------------------------------------------------
// -----                                                                   -----
// -----                  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 <bitset>
#include <chrono>
#include <map>
#include <vector>
 
#include "gDpbMessv100.h"
 
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