CbmDeviceDigiEventSink.h

Go to the documentation of this file.

/* Copyright (C) 2020-2021 Facility for Antiproton and Ion Research in Europe, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Pierre-Alain Loizeau [committer] */
 
#ifndef CBMDEVICEDIGIEVTSINK_H_
#define CBMDEVICEDIGIEVTSINK_H_
 
#include "CbmBmonDigi.h"
#include "CbmDigiEvent.h"
#include "CbmEvent.h"
#include "CbmMqTMessage.h"
#include "CbmMuchDigi.h"
#include "CbmPsdDigi.h"
#include "CbmRichDigi.h"
#include "CbmStsDigi.h"
#include "CbmTofDigi.h"
#include "CbmTrdDigi.h"
#include "CbmTsEventHeader.h"
 
#include "TimesliceMetaData.h"
 
#include "FairMQDevice.h"
 
#include "Rtypes.h"
#include "TClonesArray.h"
#include "TObjArray.h"
 
#include <chrono>
#include <map>
#include <vector>
 
class TCanvas;
class TFile;
class TH1;
class TProfile;
class TList;
class TClonesArray;
//class TimesliceMetaData;
class FairRunOnline;
class FairRootManager;
 
class CbmEventTimeslice {
public:
  CbmEventTimeslice(FairMQParts& parts, bool bDigiEvtInput = false);
  ~CbmEventTimeslice();
 
  void ExtractSelectedData(bool bExclusiveTrdExtract = true);
  std::vector<CbmDigiEvent>& GetSelectedData(bool bExclusiveTrdExtract = true)
  {
    if (!fbDigiEvtInput) ExtractSelectedData(bExclusiveTrdExtract);
    return fvDigiEvents;
  }
 
  bool fbDigiEvtInput = false;
  CbmTsEventHeader fCbmTsEventHeader;
  std::vector<CbmBmonDigi> fvDigiBmon;
  std::vector<CbmStsDigi> fvDigiSts;
  std::vector<CbmMuchDigi> fvDigiMuch;
  std::vector<CbmTrdDigi> fvDigiTrd;
  std::vector<CbmTofDigi> fvDigiTof;
  std::vector<CbmRichDigi> fvDigiRich;
  std::vector<CbmPsdDigi> fvDigiPsd;
  TimesliceMetaData fTsMetaData;
  std::vector<CbmEvent> fvEvents;
  std::vector<CbmDigiEvent> fvDigiEvents;
};
 
class CbmDeviceDigiEventSink : public FairMQDevice {
public:
  CbmDeviceDigiEventSink();
  virtual ~CbmDeviceDigiEventSink();
 
protected:
  virtual void InitTask();
  bool HandleMissTsData(FairMQMessagePtr&, int);
  bool HandleData(FairMQParts&, int);
  bool HandleCommand(FairMQMessagePtr&, int);
  virtual void PostRun();
 
private:
 
  bool fbStoreFullTs         = false;  
  bool fbBypassConsecutiveTs = false;  
  bool fbWriteMissingTs      = false;  
  bool fbDisableCompression  = false;  
  bool fbDigiEventInput      = false;  
  bool fbExclusiveTrdExtract = true;   
  bool fbFillHistos          = false;  
  bool fbInitDone            = false;  
  bool fbFinishDone          = false;  
 
  std::string fsOutputFileName = "mcbm_digis_events.root";
  std::string fsChannelNameMissedTs    = "missedts";
  std::string fsChannelNameDataInput   = "events";
  std::string fsChannelNameCommands    = "commands";
  std::string fsChannelNameHistosInput = "histogram-in";
  int64_t fiTreeFileMaxSize = 10000000000LL;  
  uint32_t fuPublishFreqTs   = 100;
  double_t fdMinPublishTime  = 0.5;
  double_t fdMaxPublishTime  = 5.0;
  std::string fsHistosSuffix = "";
 
  std::vector<std::string> fsAllowedChannels = {fsChannelNameDataInput};
 
  //      TList* fParCList = nullptr;
  //      Bool_t InitParameters( TList* fParCList );
 
  uint64_t fuPrevTsIndex                                 = 0;
  uint64_t fulNumMessages                                = 0;
  uint64_t fulTsCounter                                  = 0;
  uint64_t fulMissedTsCounter                            = 0;
  uint64_t fulProcessedEvents                            = 0;
  uint64_t fulLastFullTsCounter                          = 0;
  uint64_t fulLastMissTsCounter                          = 0;
  uint64_t fulLastProcessedEvents                        = 0;
  std::chrono::system_clock::time_point fLastPublishTime = std::chrono::system_clock::now();
  std::chrono::system_clock::time_point fLastFillTime    = std::chrono::system_clock::now();
  std::chrono::system_clock::time_point fStartTime       = std::chrono::system_clock::now();
 
  bool fbReceivedEof      = false;
  uint64_t fuLastTsIndex  = 0;
  uint64_t fuTotalTsCount = 0;
 
  CbmTsEventHeader* fEvtHeader = nullptr;
  TClonesArray* fTimeSliceMetaDataArray = nullptr;  
                                                    //  TimesliceMetaData* fTsMetaData        = nullptr;
  std::vector<CbmDigiEvent>* fEventsSel = nullptr;  
  std::vector<CbmBmonDigi>* fvDigiBmon = nullptr;
  std::vector<CbmStsDigi>* fvDigiSts   = nullptr;
  std::vector<CbmMuchDigi>* fvDigiMuch = nullptr;
  std::vector<CbmTrdDigi>* fvDigiTrd   = nullptr;
  std::vector<CbmTofDigi>* fvDigiTof   = nullptr;
  std::vector<CbmRichDigi>* fvDigiRich = nullptr;
  std::vector<CbmPsdDigi>* fvDigiPsd   = nullptr;
 
  std::vector<uint64_t> fvulMissedTsIndices = {};
  std::map<uint64_t, CbmEventTimeslice> fmFullTsStorage = {};
 
  FairRunOnline* fpRun           = nullptr;
  FairRootManager* fpFairRootMgr = nullptr;
 
  TObjArray fArrayHisto = {};
  std::vector<std::pair<std::string, std::string>> fvpsHistosFolder = {};
  std::vector<std::pair<std::string, std::string>> fvpsCanvasConfig = {};
  bool fbConfigSent = false;
 
  TProfile* fhFullTsBuffSizeEvo;
  TProfile* fhMissTsBuffSizeEvo;
  TH1* fhFullTsProcEvo;
  TH1* fhMissTsProcEvo;
  TH1* fhTotalTsProcEvo;
  TH1* fhTotalEventsEvo;
  TCanvas* fcEventSinkAllHist;
 
  bool IsChannelNameAllowed(std::string channelName);
  bool InitHistograms();
  bool ResetHistograms(bool bResetStartTime = false);
  void CheckTsQueues();
  void PrepareTreeEntry(CbmEventTimeslice unpTs);
  void DumpTreeEntry();
  bool SendHistoConfAndData();
  bool SendHistograms();
  void Finish();
};
 
#endif /* CBMDEVICEDIGIEVTSINK_H_ */