CbmSourceRecoTimeslice.cxx

Go to the documentation of this file.

/* Copyright (C) 2025 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Sergei Zharko [committer] */

 
#include "CbmSourceRecoTimeslice.h"
 
#include "CbmTimeSlice.h"
#include "CbmTsEventHeader.h"
 
#include <FairRootManager.h>
#include <FairRun.h>
 
// ---------------------------------------------------------------------------------------------------------------------
//
CbmSourceRecoTimeslice::CbmSourceRecoTimeslice(const char* fileName) : fInputFileName(fileName) {}
 
 
// ---------------------------------------------------------------------------------------------------------------------
//
void CbmSourceRecoTimeslice::Close()
{
  LOG(info) << "Source: closing after " << fNumTs << " timeslices";
  ClearOutputVectors();
}
 
 
// ---------------------------------------------------------------------------------------------------------------------
//
Bool_t CbmSourceRecoTimeslice::Init()
{
  using namespace cbm::algo;
 
  // Create input archive
  fArchive = std::make_unique<cbm::algo::RecoResultsInputArchive>(fInputFileName);
  LOG(info) << "Source: Reading from input archive " << fInputFileName;
  auto desc = fArchive->descriptor();
  LOG(info) << "      - Time created: " << desc.time_created();
  LOG(info) << "      - Host name   : " << desc.hostname();
  LOG(info) << "      - User name   : " << desc.username();
 
  auto* ioman = FairRootManager::Instance();
  if (!ioman) {
    LOG(fatal) << "CbmSourceRecoTimeslice::Init(): FairRootManager is not defined";
    return kFALSE;
  }
 
  if (!(fTsEventHeader = dynamic_cast<CbmTsEventHeader*>(FairRun::Instance()->GetEventHeader()))) {
    LOG(fatal) << "CbmSourceRecoTimeslice::Init() no CbmTsEventHeader was added to the run. Without it, we can not "
                  "store the UTC of the "
                  "Timeslices correctly. Hence, this causes a fatal. Please add it in the steering macro to the Run.";
    return kFALSE;
  }
 
  // TimeSlice. branch initialization
  if (ioman->GetObject("TimeSlice.")) {
    LOG(fatal) << "Source: Branch TimeSlice. already exists!";
    return kFALSE;
  }
  else {
    // NOTE: the max time of timeslice is 1.28e8, taken from CbmRecoUnpack.cxx
    fTimeslice = new CbmTimeSlice(0., 1.28e8 + 1.28e6);
    ioman->Register("TimeSlice.", "DAQ", fTimeslice, kTRUE);
  }
 
  auto RegisterVector = [&](auto*& vec, const char* name) -> bool {
    if (ioman->GetObject(name)) {
      LOG(fatal) << "Source: branch " << name << " already exists!";
      return false;
    }
    ioman->RegisterAny(name, vec, kTRUE);
    LOG(info) << "Source: registered branch " << name << " at " << vec;
 
    return true;
  };
 
  // TODO: replace individual vectors with reco-timeslice objects
  fBmonHits = new cbm::PartitionedVector<bmon::Hit>();
  if (!RegisterVector(fBmonHits, "OnlineBmonHit")) {
    return kFALSE;
  }
 
  fStsHits = new cbm::PartitionedVector<sts::Hit>();
  if (!RegisterVector(fStsHits, "OnlineStsHit")) {
    return kFALSE;
  }
 
  fTrdHits = new cbm::PartitionedVector<trd::Hit>();
  if (!RegisterVector(fTrdHits, "OnlineTrdHit")) {
    return kFALSE;
  }
 
  fTofHits = new cbm::PartitionedVector<tof::Hit>();
  if (!RegisterVector(fTofHits, "OnlineTofHit")) {
    return kFALSE;
  }
 
  fTracks = new ca::Vector<ca::Track>();
  if (!RegisterVector(fTracks, "OnlineTrack")) {
    return kFALSE;
  }
 
  fTrackStsHitIndices = new StorableRecoResults::TrackHitIndexContainer_t();
  if (!RegisterVector(fTrackStsHitIndices, "OnlineTrackStsHitIndex")) {
    return kFALSE;
  }
 
  fTrackTrdHitIndices = new StorableRecoResults::TrackHitIndexContainer_t();
  if (!RegisterVector(fTrackTrdHitIndices, "OnlineTrackTrdHitIndex")) {
    return kFALSE;
  }
 
  fTrackTofHitIndices = new StorableRecoResults::TrackHitIndexContainer_t();
  if (!RegisterVector(fTrackTofHitIndices, "OnlineTrackTofHitIndex")) {
    return kFALSE;
  }
 
  return kTRUE;
}
 
 
// ---------------------------------------------------------------------------------------------------------------------
//
Int_t CbmSourceRecoTimeslice::ReadEvent(UInt_t)
{
  // Get next timeslice data from archive. Stop run if end of archive is reached.
  auto results = fArchive->get();
  if (fArchive->eos()) {
    LOG(info) << "Source: End of input archive; terminating run";
    return 1;
  }
 
  // Move event data from input archive to ROOT tree
  if (!results) {
    LOG(error) << "Source: Failed to read RecoResults from archive";
    return 1;
  }
 
  LOG(info) << "Source: reading TS " << fNumTs << ", index " << results->TsIndex() << ", start "                //
            << results->TsStartTime() << ", contains\n"                                                         //
            << " Hits: BMON=" << results->BmonHits().NElements() << ", STS=" << results->StsHits().NElements()  //
            << ", TRD=" << results->TrdHits().NElements() << ", TOF=" << results->TofHits().NElements()         //
            << "\n Tracks: " << results->Tracks().size();
 
  fTsEventHeader->SetTsIndex(results->TsIndex());
  fTsEventHeader->SetTsStartTime(results->TsStartTime());
  fTimeslice->SetStartTime(results->TsStartTime());
 
  *fBmonHits           = std::move(results->BmonHits());
  *fStsHits            = std::move(results->StsHits());
  *fTrdHits            = std::move(results->TrdHits());
  *fTofHits            = std::move(results->TofHits());
  *fTracks             = std::move(results->Tracks());
  *fTrackStsHitIndices = std::move(results->TrackStsHitIndices());
  *fTrackTrdHitIndices = std::move(results->TrackTrdHitIndices());
  *fTrackTofHitIndices = std::move(results->TrackTofHitIndices());
 
  ++fNumTs;
 
  return 0;
}
 
 
// ---------------------------------------------------------------------------------------------------------------------
//
void CbmSourceRecoTimeslice::ClearOutputVectors()
{
  fBmonHits->Clear();
  fStsHits->Clear();
  fTrdHits->Clear();
  fTofHits->Clear();
  fTracks->clear();
  fTrackStsHitIndices->clear();
  fTrackTrdHitIndices->clear();
  fTrackTofHitIndices->clear();
}
 
 
ClassImp(CbmSourceRecoTimeslice);