CbmTaskBuildRawEvents.h

Go to the documentation of this file.

/* Copyright (C) 2007-2021 Facility for Antiproton and Ion Research in Europe, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Dominik Smith [committer] */
 
#ifndef CBMTASKBUILDRAWEVENTS_H
#define CBMTASKBUILDRAWEVENTS_H
 
#include "CbmAlgoBuildRawEvents.h"
#include "CbmBmonDigi.h"
#include "CbmDigiEvent.h"
#include "CbmFsdDigi.h"
#include "CbmMuchBeamTimeDigi.h"
#include "CbmMuchDigi.h"
#include "CbmPsdDigi.h"
#include "CbmRichDigi.h"
#include "CbmStsDigi.h"
#include "CbmTofDigi.h"
#include "CbmTrdDigi.h"
 
#include "FairTask.h"
 
 
#include <array>
#include <map>
#include <set>
#include <tuple>
#include <vector>
 
class CbmDigiManager;
class CbmEvent;
class CbmMatch;
class CbmSeedFinderSlidingWindow;
class RawEventBuilderDetector;
class TClonesArray;
class TStopwatch;
 
enum class EOverlapModeRaw;
 
class CbmTaskBuildRawEvents : public FairTask {
 public:
  CbmTaskBuildRawEvents();
 
  CbmTaskBuildRawEvents(const CbmTaskBuildRawEvents&) = delete;
  CbmTaskBuildRawEvents operator=(const CbmTaskBuildRawEvents&) = delete;
 
  //  CbmTaskBuildRawEvents(Int_t verbose);
 
  ~CbmTaskBuildRawEvents();
 
  virtual InitStatus Init();
 
  virtual InitStatus ReInit();
 
  virtual void Exec(Option_t*);
 
  virtual void Finish();
 
  void SetOutFilename(TString sNameIn) { fsOutFileName = sNameIn; }
  void SetWriteHistosToFairSink(Bool_t var) { fbWriteHistosToFairSink = var; }
 
  void SetFillHistos(Bool_t bFlag = kTRUE)
  {
    fbFillHistos = bFlag;
    if (nullptr != fpAlgo) fpAlgo->SetFillHistos(fbFillHistos);
  }
  void SetReferenceDetector(RawEventBuilderDetector refDet, std::vector<bool> select = {})
  {
    if (nullptr != fpAlgo) fpAlgo->SetReferenceDetector(refDet, select);
  }
  void AddDetector(RawEventBuilderDetector selDet)
  {
    if (nullptr != fpAlgo) fpAlgo->AddDetector(selDet);
  }
  void RemoveDetector(RawEventBuilderDetector selDet)
  {
    if (nullptr != fpAlgo) fpAlgo->RemoveDetector(selDet);
  }
  void SetTriggerMinNumber(ECbmModuleId selDet, UInt_t uVal)
  {
    if (nullptr != fpAlgo) fpAlgo->SetTriggerMinNumber(selDet, uVal);
  }
  void SetTriggerMaxNumber(ECbmModuleId selDet, Int_t iVal)
  {
    if (nullptr != fpAlgo) fpAlgo->SetTriggerMaxNumber(selDet, iVal);
  }
  void SetTriggerMinLayersNumber(ECbmModuleId selDet, UInt_t uVal)
  {
    if (nullptr != fpAlgo) fpAlgo->SetTriggerMinLayersNumber(selDet, uVal);
  }
  void SetHistogramMaxDigiNb(ECbmModuleId selDet, UInt_t uVal)
  {
    if (nullptr != fpAlgo) fpAlgo->SetHistogramMaxDigiNb(selDet, uVal);
  }
  void SetTriggerWindow(ECbmModuleId det, Double_t dWinBeg, Double_t dWinEnd)
  {
    if (nullptr != fpAlgo) fpAlgo->SetTriggerWindow(det, dWinBeg, dWinEnd);
  }
  void SetTsParameters(Double_t dTsStartTime, Double_t dTsLength, Double_t dTsOverLength)
  {
    if (nullptr != fpAlgo) fpAlgo->SetTsParameters(dTsStartTime, dTsLength, dTsOverLength);
  }
  void SetEventOverlapMode(EOverlapModeRaw mode)
  {
    if (nullptr != fpAlgo) fpAlgo->SetEventOverlapMode(mode);
  }
  void SetIgnoreTsOverlap(Bool_t bFlagIn)
  {
    if (nullptr != fpAlgo) fpAlgo->SetIgnoreTsOverlap(bFlagIn);
  }
  void ChangeMuchBeamtimeDigiFlag(Bool_t bFlagIn = kFALSE)
  {
    if (nullptr != fpAlgo) fpAlgo->ChangeMuchBeamtimeDigiFlag(bFlagIn);
    fbUseMuchBeamtimeDigi = bFlagIn;
  }
  void SetTimings(Bool_t bFlagIn = kTRUE)
  {
    if (nullptr != fpAlgo) fpAlgo->SetTimings(bFlagIn);
    fbGetTimings = bFlagIn;
  }
 
  void SetSeedFinderQa(Bool_t bFlagIn = kTRUE);
  void PrintTimings();
  void AddSeedTimeFillerToList(RawEventBuilderDetector seedDet);
  void SetSlidingWindowSeedFinder(int32_t minDigis, double dWindDur, double dDeadT, double dOffset = 0.0);
  void SetIdealSeedFinder(const int32_t fileId = -1);
 
  void DumpSeedTimesFromDetList();
  void SetSeedTimeWindow(Double_t beg, Double_t end) { fpAlgo->SetSeedTimeWindow(beg, end); }
 
  void SetDigiEventOutput(Bool_t bFlagIn = kTRUE) { fbDigiEvtOut = bFlagIn; }
  void SetDigiEventExclusiveTrdExtraction(Bool_t bFlagIn = kTRUE) { fbExclusiveTrdExtraction = bFlagIn; }
 
 private:
  void BuildEvents();
 
  void FillOutput();
  void SaveHistos();
 
  Bool_t fbUseMuchBeamtimeDigi = kTRUE;  
 
  CbmSeedFinderSlidingWindow* fSeedFinderSlidingWindow = nullptr;
 
  CbmDigiManager* fDigiMan                             = nullptr;
  std::vector<CbmMuchDigi>* fMuchDigis                 = nullptr;
  std::vector<CbmMuchBeamTimeDigi>* fMuchBeamTimeDigis = nullptr;
  std::vector<CbmStsDigi>* fStsDigis                   = nullptr;
  std::vector<CbmTrdDigi>* fTrdDigis                   = nullptr;
  std::vector<CbmTofDigi>* fTofDigis                   = nullptr;
  std::vector<CbmRichDigi>* fRichDigis                 = nullptr;
  std::vector<CbmPsdDigi>* fPsdDigis                   = nullptr;
  std::vector<CbmFsdDigi>* fFsdDigis                   = nullptr;
  std::vector<CbmBmonDigi>* fBmonDigis                 = nullptr;
  std::vector<Double_t>* fSeedTimes                    = nullptr;
 
  template<class TDigi>
  void InitDigis(ECbmModuleId detId, std::vector<TDigi>** vDigi);
 
  std::vector<Double_t>* fTempDigiTimes =
    nullptr;  //used when multiple seed detectors are combined with sliding window seed finder
 
  std::vector<RawEventBuilderDetector> fSeedTimeDetList;  //for multiple seed detectors
 
  template<class TDigi>
  void ReadDigis(ECbmModuleId detId, std::vector<TDigi>* vDigis);
 
  // Store digi matches for QA tasks
  std::vector<CbmMatch>* fvDigiMatchQa = nullptr;
 
  Double_t GetDigiTime(ECbmModuleId _system, UInt_t _entry);
  UInt_t GetNofDigis(ECbmModuleId _system);
 
  void FillSeedTimesFromDetList(std::vector<Double_t>* vdSeedTimes, std::vector<CbmMatch>* vDigiMatch = nullptr);
  void FillSeedTimesFromSlidingWindow();
  void FillSeedTimesFromSlidingWindow(const RawEventBuilderDetector* seedDet);
 
  TStopwatch* fTimer     = nullptr;  
  TStopwatch* fCopyTimer = nullptr;  
 
  CbmAlgoBuildRawEvents* fpAlgo = nullptr;
 
  Bool_t fbDigiEvtOut                    = kFALSE;
  Bool_t fbExclusiveTrdExtraction        = kFALSE;   
  TClonesArray* fEvents                  = nullptr;  
  std::vector<CbmDigiEvent>* fDigiEvents = nullptr;  
 
  void ExtractSelectedData(std::vector<CbmEvent*> vEvents);
 
  Bool_t fbFillHistos{kTRUE};             
  Bool_t fbWriteHistosToFairSink{kTRUE};  
  Bool_t fbGetTimings = kFALSE;           
 
  TString fsOutFileName{"data/HistosEvtWin.root"};
 
  Int_t fNofTs        = 0;
  Long64_t fNofEvents = 0;
  Double_t fTime      = 0.;
 
  uint64_t fTotalSeedCount = 0;
 
  ClassDef(CbmTaskBuildRawEvents, 1);
};
 
#endif  // CBMTASKBUILDRAWEVENTS_H