CbmTaskMakeRecoEvents.cxx

Go to the documentation of this file.

/* Copyright (C) 2021 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Volker Friese [committer] */
 
 
#include "CbmTaskMakeRecoEvents.h"
 
#include "CbmDefs.h"
#include "CbmEvent.h"
 
#include <FairRootManager.h>
#include <Logger.h>
 
#include <TClonesArray.h>
#include <TStopwatch.h>
 
#include <algorithm>
#include <cassert>
#include <iomanip>
#include <vector>
 
 
using namespace std;
 
 
// -----   Constructor   -----------------------------------------------------
CbmTaskMakeRecoEvents::CbmTaskMakeRecoEvents() : FairTask("MakeRecoEvents") {}
// ---------------------------------------------------------------------------
 
 
// -----   Destructor   ------------------------------------------------------
CbmTaskMakeRecoEvents::~CbmTaskMakeRecoEvents() {}
// ---------------------------------------------------------------------------
 
 
// -----   Execution   -------------------------------------------------------
void CbmTaskMakeRecoEvents::Exec(Option_t*)
{
 
  // --- Timer and counters
  TStopwatch timer;
  timer.Start();
 
  // --- No action if no DigiEvent branch is present
  if (!fDigiEvents) return;
 
  // --- Clear output arrays
  fBmonDigis->clear();
  fMvdDigis->clear();
  fStsDigis->clear();
  fRichDigis->clear();
  fMuchDigis->clear();
  fTrdDigis->clear();
  fTofDigis->clear();
  fFsdDigis->clear();
 
  //fRecoEvents->Clear(); //causes memory leak
  fRecoEvents->Delete();
 
  // --- Event loop
  Int_t eventNr = 0;
  for (auto& digiEvent : *fDigiEvents) {
 
    // --- Create CbmEvent object
    CbmEvent* recoEvent = new ((*fRecoEvents)[eventNr]) CbmEvent(eventNr);
 
    // --- Copy BMON digis
    FillTree<CbmBmonDigi>(digiEvent.fData.fBmon.fDigis, fBmonDigis, recoEvent, ECbmDataType::kBmonDigi);
 
    // --- Copy MVD digis
    FillTreeMvd(digiEvent.fData.fMvd.fDigis, fMvdDigis, recoEvent);
 
    // --- Copy STS digis
    FillTree<CbmStsDigi>(digiEvent.fData.fSts.fDigis, fStsDigis, recoEvent, ECbmDataType::kStsDigi);
 
    // --- Copy RICH digis
    FillTree<CbmRichDigi>(digiEvent.fData.fRich.fDigis, fRichDigis, recoEvent, ECbmDataType::kRichDigi);
 
    // --- Copy MUCH digis
    FillTree<CbmMuchDigi>(digiEvent.fData.fMuch.fDigis, fMuchDigis, recoEvent, ECbmDataType::kMuchDigi);
 
    // --- Copy TRD digis
    FillTree<CbmTrdDigi>(digiEvent.fData.fTrd.fDigis, fTrdDigis, recoEvent, ECbmDataType::kTrdDigi);
 
    // --- Copy TOF digis
    FillTree<CbmTofDigi>(digiEvent.fData.fTof.fDigis, fTofDigis, recoEvent, ECbmDataType::kTofDigi);
 
    // --- Copy FSD digis
    FillTree<CbmFsdDigi>(digiEvent.fData.fFsd.fDigis, fFsdDigis, recoEvent, ECbmDataType::kFsdDigi);
 
    eventNr++;
  }  //# events
 
  // --- Timeslice log
  timer.Stop();
  stringstream logOut;
  logOut << setw(20) << left << GetName() << " [";
  logOut << fixed << setw(8) << setprecision(1) << right << timer.RealTime() * 1000. << " ms] ";
  logOut << "TS " << fNumTs << ", events " << fDigiEvents->size() << ", Digis: BMON " << fBmonDigis->size() << " MVD "
         << fMvdDigis->size() << " STS " << fStsDigis->size() << " RICH " << fRichDigis->size() << " MUCH "
         << fMuchDigis->size() << " TRD " << fTrdDigis->size() << " TOF " << fTofDigis->size() << " FSD "
         << fFsdDigis->size();
  LOG(info) << logOut.str();
 
  // --- Run statistics
  fNumTs++;
  fTimeTot += timer.RealTime();
  assert(fDigiEvents->size() == static_cast<size_t>(fRecoEvents->GetEntriesFast()));
  fNumEvents += fDigiEvents->size();
}
// ----------------------------------------------------------------------------
 
 
// -----   End-of-timeslice action   ------------------------------------------
void CbmTaskMakeRecoEvents::Finish()
{
  LOG(info) << "=====================================";
  LOG(info) << GetName() << ": Run summary";
  LOG(info) << "Timeslices         : " << fNumTs;
  LOG(info) << "Events             : " << fNumEvents;
  LOG(info) << "Time  / TS         : " << fixed << setprecision(2) << 1000. * fTimeTot / double(fNumTs) << " ms";
  LOG(info) << "=====================================";
}
// ----------------------------------------------------------------------------
 
 
// -----   Initialisation   ---------------------------------------------------
InitStatus CbmTaskMakeRecoEvents::Init()
{
 
  LOG(info) << "==================================================";
  LOG(info) << GetName() << ": Initialising ";
 
  // --- Get FairRootManager instance
  FairRootManager* frm = FairRootManager::Instance();
  assert(frm);
 
  // --- Try to get input vector (CbmDigiEvent)
  fDigiEvents = frm->InitObjectAs<const std::vector<CbmDigiEvent>*>("DigiEvent");
 
  // --- If DigiEvents are present, create Digi and CbmEvent branches
  if (fDigiEvents) {
    LOG(info) << GetName() << ": Found branch DigiEvent";
 
    // --- Event
    if (frm->GetObject("CbmEvent")) {
      LOG(error) << GetName() << ": Found branch CbmEvent! Aborting...";
      return kFATAL;
    }
    fRecoEvents = new TClonesArray("CbmEvent", 1);
    frm->Register("CbmEvent", "Reco events", fRecoEvents, IsOutputBranchPersistent("CbmEvent"));
    if (frm->GetObject("StsDigi")) {
      LOG(error) << GetName() << ": Found branch StsDigi! Aborting...";
      return kFATAL;
    }
 
    // --- BMON digis
    fBmonDigis = new std::vector<CbmBmonDigi>;
    frm->RegisterAny("BmonDigi", fBmonDigis, kFALSE);
 
    // --- MVD digis
    fMvdDigis = new std::vector<CbmMvdDigi>;
    frm->RegisterAny("MvdDigi", fMvdDigis, kFALSE);
 
    // --- STS digis
    fStsDigis = new std::vector<CbmStsDigi>;
    frm->RegisterAny("StsDigi", fStsDigis, kFALSE);
 
    // --- RICH digis
    fRichDigis = new std::vector<CbmRichDigi>;
    frm->RegisterAny("RichDigi", fRichDigis, kFALSE);
 
    // --- MUCH digis
    fMuchDigis = new std::vector<CbmMuchDigi>;
    frm->RegisterAny("MuchDigi", fMuchDigis, kFALSE);
 
    // --- TRD digis
    fTrdDigis = new std::vector<CbmTrdDigi>;
    frm->RegisterAny("TrdDigi", fTrdDigis, kFALSE);
 
    // --- TOF digis
    fTofDigis = new std::vector<CbmTofDigi>;
    frm->RegisterAny("TofDigi", fTofDigis, kFALSE);
 
    // --- FSD digis
    fFsdDigis = new std::vector<CbmFsdDigi>;
    frm->RegisterAny("FsdDigi", fFsdDigis, kFALSE);
  }
 
  // --- If no DigiEvent branch is present, there must be a CbmEvent branch
  else {
    fRecoEvents = dynamic_cast<TClonesArray*>(frm->GetObject("CbmEvent"));
    if (fRecoEvents == nullptr) {
      LOG(error) << GetName() << ": Neither DigiEvent nor CbmEvent branch found! Aborting...";
      return kFATAL;
    }
  }
 
  LOG(info) << "==================================================";
 
  return kSUCCESS;
}
// ----------------------------------------------------------------------------
 
ClassImp(CbmTaskMakeRecoEvents)