CbmRecoSetupManager.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 "CbmRecoSetupManager.h"
 
#include "CbmDigiManager.h"
#include "CbmGeoNodeMapBuilder.h"
#include "CbmMuchRecoSetupUnitFactory.h"
#include "CbmMvdRecoSetupUnitFactory.h"
#include "CbmSetup.h"
#include "CbmStsRecoSetupUnitFactory.h"
#include "CbmTofRecoSetupUnitFactory.h"
#include "CbmTrdRecoSetupUnitFactory.h"
 
#include <FairRun.h>
#include <FairRuntimeDb.h>
#include <Logger.h>
 
#include <type_traits>
#include <utility>
 
using cbm::RecoSetupManager;
 
 
// ---------------------------------------------------------------------------------------------------------------------
//
RecoSetupManager::RecoSetupManager() : FairTask("cbm::RecoSetupManager", 0) {}
 
// ---------------------------------------------------------------------------------------------------------------------
//
bool RecoSetupManager::HasGeoNodeMaps() const
{
  if (fGeoNodeMap == nullptr) {
    LOG(warn) << "cbm::RecoSetupManager: the geo node map was not built. Please, request the geo node map building "
                 "with the cbm::RecoSetupManager::Instance()->BuildGeoNodeMaps() method at a point of registering "
                 "the task in FairRunAna";
    return false;
  }
 
  return true;
}
 
// ---------------------------------------------------------------------------------------------------------------------
//
InitStatus RecoSetupManager::Init()
try {
  //CbmDigiManager::Instance()->Init();
 
  auto CreateSetupUnit = [&](auto&& factory) {
    using RecoSetupUnit_t = typename std::remove_reference_t<decltype(factory)>::RecoSetupUnit_t;
    LOG(info) << "Creating reconstruction setup unit for " << RecoSetupUnit_t::GetDetectorName();
    return factory.Create();
  };
 
  GeoNodeMapBuilder nodeMapBuilder;
 
  if (CbmSetup::Instance()->IsActive(ECbmModuleId::kMuch)) {
    fSetup.SetMuch(std::move(CreateSetupUnit(much::RecoSetupUnitFactory{})));
    nodeMapBuilder.Request(ECbmModuleId::kMuch);
  }
  if (CbmSetup::Instance()->IsActive(ECbmModuleId::kMvd)) {
    fSetup.SetMvd(std::move(CreateSetupUnit(mvd::RecoSetupUnitFactory{})));
    nodeMapBuilder.Request(ECbmModuleId::kMvd);
  }
  if (CbmSetup::Instance()->IsActive(ECbmModuleId::kSts)) {
    fSetup.SetSts(std::move(CreateSetupUnit(sts::RecoSetupUnitFactory{})));
    nodeMapBuilder.Request(ECbmModuleId::kSts);
  }
  if (CbmSetup::Instance()->IsActive(ECbmModuleId::kTof)) {
    fSetup.SetTof(std::move(CreateSetupUnit(tof::RecoSetupUnitFactory{})));
    nodeMapBuilder.Request(ECbmModuleId::kTof);
  }
  if (CbmSetup::Instance()->IsActive(ECbmModuleId::kTrd)) {
    fSetup.SetTrd(std::move(CreateSetupUnit(trd::RecoSetupUnitFactory{})));
    nodeMapBuilder.Request(ECbmModuleId::kTrd);
  }
 
  if (fbBuildGeoNodeMaps) {
    LOG(info) << "RecoSetupManager: building geo-node map ...";
    fGeoNodeMap = std::make_shared<const GeoNodeMap>(std::move(nodeMapBuilder.Build()));
    LOG(info) << "RecoSetupManager: building geo-node map ... done";
  }
 
  LOG(info) << fSetup.ToString();
 
  fbInitialized = true;
 
  if (!fSetupOutFilename.empty()) {
    LOG(info) << "RecoSetupManger: storing setup to file " << fSetupOutFilename;
    if (!fbInitialized) {
      throw std::logic_error("cbm::RecoSetupManager: attempt to store a setup from uninitialized manager instance");
    }
 
    algo::RecoSetup::Store(fSetup, fSetupOutFilename);
    LOG(info) << "RecoSetupManger: storing setup to file: done";
  }
 
  return kSUCCESS;
}
catch (const std::exception& err) {
  LOG(error) << "RecoSetupManager: Initialization failed, because " << err.what();
  return kFATAL;
}
 
// ---------------------------------------------------------------------------------------------------------------------
//
RecoSetupManager* RecoSetupManager::Instance()
{
  static RecoSetupManager instance;
  return &instance;
}
 
// ---------------------------------------------------------------------------------------------------------------------
//
bool RecoSetupManager::IsInitialized() const
{
  if (!fbInitialized) {
    LOG(error) << "The cbm::RecoSetupManager is not initialized. Please, register the cbm::RecoSetupManager instance "
                  "as a FairTask in your FairRunAna: \n  run->AddTask(cbm::RecoSetupManager::Instance())";
  }
  return fbInitialized;
}
 
// ---------------------------------------------------------------------------------------------------------------------
//
void RecoSetupManager::LoadSetup(const std::string& filename)
{
  LOG(info) << "RecoSetupManger: loading setup from file " << filename;
  fSetup = std::move(algo::RecoSetup::Load(filename));
  LOG(info) << "RecoSetupManger: loading setup from file: done";
}
 
// ---------------------------------------------------------------------------------------------------------------------
//
void RecoSetupManager::SetParContainers()
{
  // Touch the containers to force their creation and initialization
  auto* db = FairRun::Instance()->GetRuntimeDb();
  // STS
  db->getContainer("CbmStsParSetModule");
  db->getContainer("CbmStsParSetSensor");
  db->getContainer("CbmStsParSetSensorCond");
  // TRD
  db->getContainer("CbmTrdParSetAsic");
  db->getContainer("CbmTrdParSetGas");
  db->getContainer("CbmTrdParSetDigi");
  db->getContainer("CbmTrdParSetGain");
  db->getContainer("CbmTrdParSetGeo");
  // TOF
  db->getContainer("CbmTofDigiPar");
  db->getContainer("CbmTofDigiBdfPar");
}