Renamed Cbm2021EventBuilder to CbmBuildRawEvents. Solved naming conflicts of...

Renamed Cbm2021EventBuilder to CbmBuildRawEvents. Solved naming conflicts of utility classes (removed dependency on 2019 version).

macro/run/run_reco.C

@@ -222,8 +222,16 @@ void run_reco(TString input        = "",
       /* switch between 2019 and 2021 version here, which have the same interface
       CbmMcbm2019TimeWinEventBuilderTask* evBuildRaw =
         new CbmMcbm2019TimeWinEventBuilderTask();
-*/
-      Cbm2021EventBuilderTask* evBuildRaw = new Cbm2021EventBuilderTask();
+
+      //Choose between NoOverlap, MergeOverlap, AllowOverlap
+      evBuildRaw->SetEventOverlapMode(EOverlapMode::AllowOverlap);  // for 2019 version
+      */
+
+      CbmTaskBuildRawEvents* evBuildRaw = new CbmTaskBuildRawEvents();
+
+      //Choose between NoOverlap, MergeOverlap, AllowOverlap
+      evBuildRaw->SetEventOverlapMode(
+        EOverlapModeRaw::AllowOverlap);  // for raw version
 
       evBuildRaw->SetTsParameters(0.0, 1.e7, 0.0);
 
@@ -243,8 +251,6 @@ void run_reco(TString input        = "",
       // Set STS as reference detector
       evBuildRaw->SetReferenceDetector(kEventBuilderDetSts);
 
-      //Choose between NoOverlap, MergeOverlap, AllowOverlap
-      evBuildRaw->SetEventOverlapMode(EOverlapMode::AllowOverlap);
 
       evBuildRaw->SetTriggerMinNumber(ECbmModuleId::kSts, 10);
       evBuildRaw->SetTriggerMaxNumber(ECbmModuleId::kSts, -1);

reco/eventbuilder/CMakeLists.txt

@@ -67,8 +67,8 @@ link_directories( ${LINK_DIRECTORIES})
 
 set(SRCS
 
-digis/Cbm2021EventBuilderAlgo.cxx
-digis/Cbm2021EventBuilderTask.cxx
+digis/CbmAlgoBuildRawEvents.cxx
+digis/CbmTaskBuildRawEvents.cxx
 digis/CbmBuildEventsIdeal.cxx
 digis/CbmBuildEventsIdealNew.cxx
 digis/CbmBuildEventsQA.cxx

reco/eventbuilder/CbmEventBuilderLinkDef.h

@@ -4,14 +4,14 @@
 #pragma link off all classes;
 #pragma link off all functions;
 
-#pragma link C++ class Cbm2021EventBuilderAlgo + ;
-#pragma link C++ class Cbm2021EventBuilderTask + ;
+#pragma link C++ class CbmAlgoBuildRawEvents + ;
+#pragma link C++ class CbmTaskBuildRawEvents + ;
 #pragma link C++ class CbmBuildEventsFromTracksIdeal + ;
 #pragma link C++ class CbmBuildEventsFromTracksReal + ;
 #pragma link C++ class CbmEventBuilderQA + ;
 #pragma link C++ class CbmBuildEventsIdeal + ;
 #pragma link C++ class CbmBuildEventsIdealNew + ;
-#pragma link C++ class CbmBuildEventsQA+;
+#pragma link C++ class CbmBuildEventsQA + ;
 #pragma link C++ class CbmBuildEventsSimple + ;
 //#pragma link C++ class CbmEvBuildSource+;
 

reco/eventbuilder/digis/Cbm2021EventBuilderAlgo.h → reco/eventbuilder/digis/CbmAlgoBuildRawEvents.h

@@ -5,11 +5,10 @@
  *              GNU Lesser General Public Licence (LGPL) version 3,             *
  *                  copied verbatim in the file "LICENSE"                       *
  ********************************************************************************/
-#ifndef CBM2021EVENTBUILDERALGO_H
-#define CBM2021EVENTBUILDERALGO_H
+#ifndef CBMALGOBUILDRAWEVENTS_H
+#define CBMALGOBUILDRAWEVENTS_H
 
 /// CBM headers
-#include "../../fles/mcbm2018/tasks/CbmMcbm2019TimeWinEventBuilderAlgo.h"  // for EOverlapMode and EventBuilderDetector
 #include "CbmMuchBeamTimeDigi.h"
 #include "CbmMuchDigi.h"
 #include "CbmPsdDigi.h"
@@ -40,27 +39,26 @@ class TH2;
 class TNamed;
 class TCanvas;
 
-/*    get from CbmMcbm2019TimeWinEventBuilderAlgo.h for now
-enum class EOverlapMode { NoOverlap, MergeOverlap, AllowOverlap };
+enum class EOverlapModeRaw { NoOverlap, MergeOverlap, AllowOverlap };
 
-class EventBuilderDetector {
+class RawEventBuilderDetector {
 public:
-  EventBuilderDetector() { ; }
-  EventBuilderDetector(ECbmModuleId detIdIn,
-                       ECbmDataType dataTypeIn,
-                       std::string sNameIn) {
+  RawEventBuilderDetector() { ; }
+  RawEventBuilderDetector(ECbmModuleId detIdIn,
+                          ECbmDataType dataTypeIn,
+                          std::string sNameIn) {
     detId    = detIdIn;
     dataType = dataTypeIn;
     sName    = sNameIn;
   }
-  EventBuilderDetector(ECbmModuleId detIdIn,
-                       ECbmDataType dataTypeIn,
-                       std::string sNameIn,
-                       UInt_t uTriggerMinDigisIn,
-                       Int_t iTriggerMaxDigisIn,
-                       Double_t fdTimeWinBegIn,
-                       Double_t fdTimeWinEndIn)
-    : EventBuilderDetector(detIdIn, dataTypeIn, sNameIn) {
+  RawEventBuilderDetector(ECbmModuleId detIdIn,
+                          ECbmDataType dataTypeIn,
+                          std::string sNameIn,
+                          UInt_t uTriggerMinDigisIn,
+                          Int_t iTriggerMaxDigisIn,
+                          Double_t fdTimeWinBegIn,
+                          Double_t fdTimeWinEndIn)
+    : RawEventBuilderDetector(detIdIn, dataTypeIn, sNameIn) {
     fuTriggerMinDigis = uTriggerMinDigisIn;
     fiTriggerMaxDigis = iTriggerMaxDigisIn;
 
@@ -68,10 +66,10 @@ public:
     fdTimeWinEnd = fdTimeWinEndIn;
   }
 
-  bool operator==(const EventBuilderDetector& other) const {
+  bool operator==(const RawEventBuilderDetector& other) const {
     return (other.detId == this->detId);
   }
-  bool operator!=(const EventBuilderDetector& other) const {
+  bool operator!=(const RawEventBuilderDetector& other) const {
     return (other.detId != this->detId);
   }
 
@@ -95,35 +93,34 @@ public:
 };
 
 /// Pre-defined detector types
-static const EventBuilderDetector kEventBuilderDetSts =
-  EventBuilderDetector(ECbmModuleId::kSts, ECbmDataType::kStsDigi, "Sts");
-static const EventBuilderDetector kEventBuilderDetMuch =
-  EventBuilderDetector(ECbmModuleId::kMuch, ECbmDataType::kMuchDigi, "Much");
-static const EventBuilderDetector kEventBuilderDetTrd =
-  EventBuilderDetector(ECbmModuleId::kTrd, ECbmDataType::kTrdDigi, "Trd");
-static const EventBuilderDetector kEventBuilderDetTof =
-  EventBuilderDetector(ECbmModuleId::kTof, ECbmDataType::kTofDigi, "Tof");
-static const EventBuilderDetector kEventBuilderDetRich =
-  EventBuilderDetector(ECbmModuleId::kRich, ECbmDataType::kRichDigi, "Rich");
-static const EventBuilderDetector kEventBuilderDetPsd =
-  EventBuilderDetector(ECbmModuleId::kPsd, ECbmDataType::kPsdDigi, "Psd");
-static const EventBuilderDetector kEventBuilderDetT0 =
-  EventBuilderDetector(ECbmModuleId::kT0, ECbmDataType::kT0Digi, "T0");
-static const EventBuilderDetector kEventBuilderDetUndef =
-  EventBuilderDetector();
-
-*/
-
-class Cbm2021EventBuilderAlgo {
+static const RawEventBuilderDetector kEventBuilderDetSts =
+  RawEventBuilderDetector(ECbmModuleId::kSts, ECbmDataType::kStsDigi, "Sts");
+static const RawEventBuilderDetector kEventBuilderDetMuch =
+  RawEventBuilderDetector(ECbmModuleId::kMuch, ECbmDataType::kMuchDigi, "Much");
+static const RawEventBuilderDetector kEventBuilderDetTrd =
+  RawEventBuilderDetector(ECbmModuleId::kTrd, ECbmDataType::kTrdDigi, "Trd");
+static const RawEventBuilderDetector kEventBuilderDetTof =
+  RawEventBuilderDetector(ECbmModuleId::kTof, ECbmDataType::kTofDigi, "Tof");
+static const RawEventBuilderDetector kEventBuilderDetRich =
+  RawEventBuilderDetector(ECbmModuleId::kRich, ECbmDataType::kRichDigi, "Rich");
+static const RawEventBuilderDetector kEventBuilderDetPsd =
+  RawEventBuilderDetector(ECbmModuleId::kPsd, ECbmDataType::kPsdDigi, "Psd");
+static const RawEventBuilderDetector kEventBuilderDetT0 =
+  RawEventBuilderDetector(ECbmModuleId::kT0, ECbmDataType::kT0Digi, "T0");
+static const RawEventBuilderDetector kEventBuilderDetUndef =
+  RawEventBuilderDetector();
+
+
+class CbmAlgoBuildRawEvents {
 public:
   /** Default constructor **/
-  Cbm2021EventBuilderAlgo();
+  CbmAlgoBuildRawEvents();
 
-  Cbm2021EventBuilderAlgo(const Cbm2021EventBuilderAlgo&) = delete;
-  Cbm2021EventBuilderAlgo operator=(const Cbm2021EventBuilderAlgo&) = delete;
+  CbmAlgoBuildRawEvents(const CbmAlgoBuildRawEvents&) = delete;
+  CbmAlgoBuildRawEvents operator=(const CbmAlgoBuildRawEvents&) = delete;
 
   /** Destructor **/
-  ~Cbm2021EventBuilderAlgo();
+  ~CbmAlgoBuildRawEvents();
 
   /** Initiliazation at the beginning of a run **/
   Bool_t InitAlgo();
@@ -152,9 +149,9 @@ public:
                    Double_t fdTimeWinBegIn   = -100,
                    Double_t fdTimeWinEndIn   = 100);
 
-  void SetReferenceDetector(EventBuilderDetector refDetIn);
-  void AddDetector(EventBuilderDetector selDet);
-  void RemoveDetector(EventBuilderDetector selDet);
+  void SetReferenceDetector(RawEventBuilderDetector refDetIn);
+  void AddDetector(RawEventBuilderDetector selDet);
+  void RemoveDetector(RawEventBuilderDetector selDet);
 
   void SetTriggerMinNumber(ECbmModuleId selDet, UInt_t uVal);
   void SetTriggerMaxNumber(ECbmModuleId selDet, Int_t iVal);
@@ -171,7 +168,7 @@ public:
   }
 
   /// Control flags
-  void SetEventOverlapMode(EOverlapMode mode) { fOverMode = mode; }
+  void SetEventOverlapMode(EOverlapModeRaw mode) { fOverMode = mode; }
   void SetIgnoreTsOverlap(Bool_t bFlagIn = kTRUE) {
     fbIgnoreTsOverlap = bFlagIn;
   }
@@ -218,7 +215,7 @@ public:
 
 private:
   /// Internal methods
-  Bool_t CheckDataAvailable(EventBuilderDetector& det);
+  Bool_t CheckDataAvailable(RawEventBuilderDetector& det);
   void InitTs();
   void BuildEvents();
 
@@ -229,10 +226,10 @@ private:
   void LoopOnSeeds();
   void CheckSeed(Double_t dSeedTime, UInt_t uSeedDigiIdx);
   template<class DigiCheck>
-  void SearchMatches(Double_t dSeedTime, EventBuilderDetector& detMatch);
-  void AddDigiToEvent(EventBuilderDetector& det, Int_t uIdx);
+  void SearchMatches(Double_t dSeedTime, RawEventBuilderDetector& detMatch);
+  void AddDigiToEvent(RawEventBuilderDetector& det, Int_t uIdx);
   Bool_t HasTrigger(CbmEvent*);
-  Bool_t CheckTriggerConditions(CbmEvent* event, EventBuilderDetector& det);
+  Bool_t CheckTriggerConditions(CbmEvent* event, RawEventBuilderDetector& det);
 
   void UpdateTimeWinBoundariesExtrema();
   void UpdateWidestTimeWinRange();
@@ -247,17 +244,23 @@ private:
   Bool_t fbFillHistos {kTRUE};        //! Switch ON/OFF filling of histograms
   Bool_t fbUseMuchBeamtimeDigi = kTRUE;  //! Switch between MUCH digi classes
     /// Event building mode and detectors selection
-  EOverlapMode fOverMode {EOverlapMode::AllowOverlap};
-
-  EventBuilderDetector fRefDet =
-    EventBuilderDetector(ECbmModuleId::kT0, ECbmDataType::kT0Digi, "T0");
-  std::vector<EventBuilderDetector> fvDets = {
-    EventBuilderDetector(ECbmModuleId::kSts, ECbmDataType::kStsDigi, "kSts"),
-    EventBuilderDetector(ECbmModuleId::kMuch, ECbmDataType::kMuchDigi, "kMuch"),
-    EventBuilderDetector(ECbmModuleId::kTrd, ECbmDataType::kTrdDigi, "kTrd"),
-    EventBuilderDetector(ECbmModuleId::kTof, ECbmDataType::kTofDigi, "kTof"),
-    EventBuilderDetector(ECbmModuleId::kRich, ECbmDataType::kRichDigi, "kRich"),
-    EventBuilderDetector(ECbmModuleId::kPsd, ECbmDataType::kPsdDigi, "kPsd")};
+  EOverlapModeRaw fOverMode {EOverlapModeRaw::AllowOverlap};
+
+  RawEventBuilderDetector fRefDet =
+    RawEventBuilderDetector(ECbmModuleId::kT0, ECbmDataType::kT0Digi, "T0");
+  std::vector<RawEventBuilderDetector> fvDets = {
+    RawEventBuilderDetector(ECbmModuleId::kSts, ECbmDataType::kStsDigi, "kSts"),
+    RawEventBuilderDetector(ECbmModuleId::kMuch,
+                            ECbmDataType::kMuchDigi,
+                            "kMuch"),
+    RawEventBuilderDetector(ECbmModuleId::kTrd, ECbmDataType::kTrdDigi, "kTrd"),
+    RawEventBuilderDetector(ECbmModuleId::kTof, ECbmDataType::kTofDigi, "kTof"),
+    RawEventBuilderDetector(ECbmModuleId::kRich,
+                            ECbmDataType::kRichDigi,
+                            "kRich"),
+    RawEventBuilderDetector(ECbmModuleId::kPsd,
+                            ECbmDataType::kPsdDigi,
+                            "kPsd")};
 
   Double_t fdEarliestTimeWinBeg = kdDefaultTimeWinBeg;
   Double_t fdLatestTimeWinEnd   = kdDefaultTimeWinEnd;
@@ -327,7 +330,7 @@ private:
   Double_t fdPrevEvtEndTime =
     0.;  //! Save previous event last digi time information
 
-  ClassDefNV(Cbm2021EventBuilderAlgo, 1);
+  ClassDefNV(CbmAlgoBuildRawEvents, 1);
 };
 
-#endif  //  CBM2021EVENTBUILDERALGO_H
+#endif  // CBMALGOBUILDRAWEVENTS_H

reco/eventbuilder/digis/Cbm2021EventBuilderTask.cxx → reco/eventbuilder/digis/CbmTaskBuildRawEvents.cxx

@@ -5,8 +5,8 @@
  *              GNU Lesser General Public Licence (LGPL) version 3,             *
  *                  copied verbatim in the file "LICENSE"                       *
  ********************************************************************************/
-#include "Cbm2021EventBuilderTask.h"
-#include "Cbm2021EventBuilderAlgo.h"
+#include "CbmTaskBuildRawEvents.h"
+#include "CbmAlgoBuildRawEvents.h"
 
 #include "CbmDigiManager.h"
 #include "CbmEvent.h"
@@ -22,22 +22,22 @@
 #include <TFile.h>
 
 // ---- Default constructor -------------------------------------------
-Cbm2021EventBuilderTask::Cbm2021EventBuilderTask()
-  : FairTask("Cbm2021EventBuilderTask") {
+CbmTaskBuildRawEvents::CbmTaskBuildRawEvents()
+  : FairTask("CbmTaskBuildRawEvents") {
   /// Create Algo. To be made generic/switchable when more event building algo are available!
-  fpAlgo = new Cbm2021EventBuilderAlgo();
+  fpAlgo = new CbmAlgoBuildRawEvents();
 }
 
 // ---- Destructor ----------------------------------------------------
-Cbm2021EventBuilderTask::~Cbm2021EventBuilderTask() {}
+CbmTaskBuildRawEvents::~CbmTaskBuildRawEvents() {}
 
 // ----  Initialisation  ----------------------------------------------
-void Cbm2021EventBuilderTask::SetParContainers() {
+void CbmTaskBuildRawEvents::SetParContainers() {
   /// Nothing to do
 }
 
 // ---- Init ----------------------------------------------------------
-InitStatus Cbm2021EventBuilderTask::Init() {
+InitStatus CbmTaskBuildRawEvents::Init() {
   /// Get a handle from the IO manager
   FairRootManager* ioman = FairRootManager::Instance();
 
@@ -120,11 +120,11 @@ InitStatus Cbm2021EventBuilderTask::Init() {
 }
 
 // ---- ReInit  -------------------------------------------------------
-InitStatus Cbm2021EventBuilderTask::ReInit() { return kSUCCESS; }
+InitStatus CbmTaskBuildRawEvents::ReInit() { return kSUCCESS; }
 
 // ---- Exec ----------------------------------------------------------
-void Cbm2021EventBuilderTask::Exec(Option_t* /*option*/) {
-  LOG(debug2) << "Cbm2021EventBuilderTask::Exec => Starting sequence";
+void CbmTaskBuildRawEvents::Exec(Option_t* /*option*/) {
+  LOG(debug2) << "CbmTaskBuildRawEvents::Exec => Starting sequence";
 
   //Read STS digis
   if (fDigiMan->IsPresent(ECbmModuleId::kSts)) {
@@ -215,12 +215,12 @@ void Cbm2021EventBuilderTask::Exec(Option_t* /*option*/) {
 
   /// Save the resulting vector of events in TClonesArray
   FillOutput();
-  LOG(debug2) << "Cbm2021EventBuilderTask::Exec => Done";
+  LOG(debug2) << "CbmTaskBuildRawEvents::Exec => Done";
 }
 
 
 // ---- Finish --------------------------------------------------------
-void Cbm2021EventBuilderTask::Finish() {
+void CbmTaskBuildRawEvents::Finish() {
   if (fbFillHistos) { SaveHistos(); }  // if( fbFillHistos )
 
   /// Call Algo finish method
@@ -228,7 +228,7 @@ void Cbm2021EventBuilderTask::Finish() {
 }
 
 //----------------------------------------------------------------------
-void Cbm2021EventBuilderTask::FillOutput() {
+void CbmTaskBuildRawEvents::FillOutput() {
   /// Clear TClonesArray before usage.
   fEvents->Delete();
 
@@ -249,7 +249,7 @@ void Cbm2021EventBuilderTask::FillOutput() {
   fpAlgo->ClearEventVector();
 }
 //----------------------------------------------------------------------
-void Cbm2021EventBuilderTask::SaveHistos() {
+void CbmTaskBuildRawEvents::SaveHistos() {
   /// Obtain vector of pointers on each histo from the algo (+ optionally desired folder)
   std::vector<std::pair<TNamed*, std::string>> vHistos =
     fpAlgo->GetHistoVector();
@@ -281,59 +281,59 @@ void Cbm2021EventBuilderTask::SaveHistos() {
   histoFile->Close();
 }
 //----------------------------------------------------------------------
-void Cbm2021EventBuilderTask::SetFillHistos(Bool_t bFlag) {
+void CbmTaskBuildRawEvents::SetFillHistos(Bool_t bFlag) {
   fbFillHistos = bFlag;
   if (nullptr != fpAlgo) fpAlgo->SetFillHistos(fbFillHistos);
 }
-void Cbm2021EventBuilderTask::SetOutFilename(TString sNameIn) {
+void CbmTaskBuildRawEvents::SetOutFilename(TString sNameIn) {
   fsOutFileName = sNameIn;
 }
 
-void Cbm2021EventBuilderTask::SetReferenceDetector(
-  EventBuilderDetector refDet) {
+void CbmTaskBuildRawEvents::SetReferenceDetector(
+  RawEventBuilderDetector refDet) {
   if (nullptr != fpAlgo) fpAlgo->SetReferenceDetector(refDet);
 }
-void Cbm2021EventBuilderTask::AddDetector(EventBuilderDetector selDet) {
+void CbmTaskBuildRawEvents::AddDetector(RawEventBuilderDetector selDet) {
   if (nullptr != fpAlgo) fpAlgo->AddDetector(selDet);
 }
-void Cbm2021EventBuilderTask::RemoveDetector(EventBuilderDetector selDet) {
+void CbmTaskBuildRawEvents::RemoveDetector(RawEventBuilderDetector selDet) {
   if (nullptr != fpAlgo) fpAlgo->RemoveDetector(selDet);
 }
 
-void Cbm2021EventBuilderTask::SetTriggerMinNumber(ECbmModuleId selDet,
-                                                  UInt_t uVal) {
+void CbmTaskBuildRawEvents::SetTriggerMinNumber(ECbmModuleId selDet,
+                                                UInt_t uVal) {
   if (nullptr != fpAlgo) fpAlgo->SetTriggerMinNumber(selDet, uVal);
 }
-void Cbm2021EventBuilderTask::SetTriggerMaxNumber(ECbmModuleId selDet,
-                                                  Int_t iVal) {
+void CbmTaskBuildRawEvents::SetTriggerMaxNumber(ECbmModuleId selDet,
+                                                Int_t iVal) {
   if (nullptr != fpAlgo) fpAlgo->SetTriggerMaxNumber(selDet, iVal);
 }
 
-void Cbm2021EventBuilderTask::SetTriggerWindow(ECbmModuleId det,
-                                               Double_t dWinBeg,
-                                               Double_t dWinEnd) {
+void CbmTaskBuildRawEvents::SetTriggerWindow(ECbmModuleId det,
+                                             Double_t dWinBeg,
+                                             Double_t dWinEnd) {
   if (nullptr != fpAlgo) fpAlgo->SetTriggerWindow(det, dWinBeg, dWinEnd);
 }
 
 
-void Cbm2021EventBuilderTask::SetTsParameters(Double_t dTsStartTime,
-                                              Double_t dTsLength,
-                                              Double_t dTsOverLength) {
+void CbmTaskBuildRawEvents::SetTsParameters(Double_t dTsStartTime,
+                                            Double_t dTsLength,
+                                            Double_t dTsOverLength) {
   if (nullptr != fpAlgo)
     fpAlgo->SetTsParameters(dTsStartTime, dTsLength, dTsOverLength);
 }
 
-void Cbm2021EventBuilderTask::SetEventOverlapMode(EOverlapMode mode) {
+void CbmTaskBuildRawEvents::SetEventOverlapMode(EOverlapModeRaw mode) {
   if (nullptr != fpAlgo) fpAlgo->SetEventOverlapMode(mode);
 }
-void Cbm2021EventBuilderTask::SetIgnoreTsOverlap(Bool_t bFlagIn) {
+void CbmTaskBuildRawEvents::SetIgnoreTsOverlap(Bool_t bFlagIn) {
   if (nullptr != fpAlgo) fpAlgo->SetIgnoreTsOverlap(bFlagIn);
 }
-void Cbm2021EventBuilderTask::ChangeMuchBeamtimeDigiFlag(Bool_t bFlagIn) {
+void CbmTaskBuildRawEvents::ChangeMuchBeamtimeDigiFlag(Bool_t bFlagIn) {
   if (nullptr != fpAlgo) fpAlgo->ChangeMuchBeamtimeDigiFlag(bFlagIn);
   fbUseMuchBeamtimeDigi = bFlagIn;
 }
 
 //----------------------------------------------------------------------
 
-ClassImp(Cbm2021EventBuilderTask)
+ClassImp(CbmTaskBuildRawEvents)

reco/eventbuilder/digis/Cbm2021EventBuilderTask.h → reco/eventbuilder/digis/CbmTaskBuildRawEvents.h

@@ -5,11 +5,8 @@
  *              GNU Lesser General Public Licence (LGPL) version 3,             *
  *                  copied verbatim in the file "LICENSE"                       *
  ********************************************************************************/
-#ifndef CBMM2021EVENTBUILDERTASK_H
-#define CBMM2021EVENTBUILDERTASK_H
-
-// CBM headers
-#include "../../fles/mcbm2018/tasks/CbmMcbm2019TimeWinEventBuilderAlgo.h"  // for EOverlapMode and EventBuilderDetector
+#ifndef CBMTASKBUILDRAWEVENTS_H
+#define CBMTASKBUILDRAWEVENTS_H
 
 /// FAIRROOT headers
 #include "FairTask.h"
@@ -32,23 +29,26 @@
 #include <vector>
 
 class CbmDigiManager;
-class Cbm2021EventBuilderAlgo;
+class CbmAlgoBuildRawEvents;
+class RawEventBuilderDetector;
 class TClonesArray;
 
-class Cbm2021EventBuilderTask : public FairTask {
+enum class EOverlapModeRaw;
+
+class CbmTaskBuildRawEvents : public FairTask {
 public:
   /** Default constructor **/
-  Cbm2021EventBuilderTask();
+  CbmTaskBuildRawEvents();
 
-  Cbm2021EventBuilderTask(const Cbm2021EventBuilderTask&) = delete;
-  Cbm2021EventBuilderTask operator=(const Cbm2021EventBuilderTask&) = delete;
+  CbmTaskBuildRawEvents(const CbmTaskBuildRawEvents&) = delete;
+  CbmTaskBuildRawEvents operator=(const CbmTaskBuildRawEvents&) = delete;
 
   /** Constructor with parameters (Optional) **/
-  //  Cbm2021EventBuilderTask(Int_t verbose);
+  //  CbmTaskBuildRawEvents(Int_t verbose);
 
 
   /** Destructor **/
-  ~Cbm2021EventBuilderTask();
+  ~CbmTaskBuildRawEvents();
 
 
   /** Initiliazation of task at the beginning of a run **/
@@ -70,9 +70,9 @@ public:
   void SetFillHistos(Bool_t bFlag = kTRUE);
   void SetOutFilename(TString sNameIn);
 
-  void SetReferenceDetector(EventBuilderDetector refDet);
-  void AddDetector(EventBuilderDetector selDet);
-  void RemoveDetector(EventBuilderDetector selDet);
+  void SetReferenceDetector(RawEventBuilderDetector refDet);
+  void AddDetector(RawEventBuilderDetector selDet);
+  void RemoveDetector(RawEventBuilderDetector selDet);
 
   void SetTriggerMinNumber(ECbmModuleId selDet, UInt_t uVal);
   void SetTriggerMaxNumber(ECbmModuleId selDet, Int_t iVal);
@@ -83,7 +83,7 @@ public:
                        Double_t dTsLength,
                        Double_t dTsOverLength);
 
-  void SetEventOverlapMode(EOverlapMode mode);
+  void SetEventOverlapMode(EOverlapModeRaw mode);
   void SetIgnoreTsOverlap(Bool_t bFlagIn);
 
   void ChangeMuchBeamtimeDigiFlag(Bool_t bFlagIn = kFALSE);
@@ -103,7 +103,7 @@ private:
 
   Bool_t fbUseMuchBeamtimeDigi = kTRUE;  //! Switch between MUCH digi classes
 
-  Cbm2021EventBuilderAlgo* fpAlgo = nullptr;
+  CbmAlgoBuildRawEvents* fpAlgo = nullptr;
 
   TClonesArray* fEvents = nullptr;  //! output container of CbmEvents
 
@@ -112,7 +112,7 @@ private:
   /** Name of the histogram output file **/
   TString fsOutFileName {"data/HistosEvtWin.root"};
 
-  ClassDef(Cbm2021EventBuilderTask, 1);
+  ClassDef(CbmTaskBuildRawEvents, 1);
 };
 
-#endif  // CBMM2021EVENTBUILDERTASK_H
+#endif  // CBMTASKBUILDRAWEVENTS_H