CbmMuchRecoSetupUnitFactory.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 "CbmMuchRecoSetupUnitFactory.h"
 
#include "CbmGeoHelper.h"
#include "CbmMuchAddress.h"
#include "CbmMuchGeoScheme.h"
#include "CbmMuchModuleGem.h"
#include "CbmMuchPad.h"
#include "CbmMuchStation.h"
#include "CbmRecoSetupUtils.h"
#include "CbmSetup.h"
 
#include <Logger.h>
 
#include <TGeoManager.h>
#include <TString.h>
#include <TSystem.h>
 
#include <sstream>
#include <utility>
 
using cbm::algo::GeoVolume;
using cbm::algo::much::RecoSetupUnit;
using cbm::much::RecoSetupUnitFactory;
 
// ---------------------------------------------------------------------------------------------------------------------
//
RecoSetupUnitFactory::RecoSetupUnitFactory()
try {
  if (!CbmSetup::Instance()->IsActive(ECbmModuleId::kMuch)) {
    throw std::runtime_error("MuCh is not in the setup, but the much::RecoSetupUnitFactory was called (this should "
                             "never happen!");
  }
 
  if (!CbmMuchGeoScheme::Instance()->IsInitialized()) {
    TString geoTag;
    CbmSetup::Instance()->GetGeoTag(ECbmModuleId::kMuch, geoTag);
    TString parFile = gSystem->Getenv("VMCWORKDIR");
    if (parFile.IsNull()) {
      throw std::runtime_error("The VMCWORKDIR env. variable is required but not defined. Please, configure CbmRoot");
    }
    parFile += "/parameters/much/much_" + geoTag(0, 4) + "_digi_sector.root";
    CbmMuchGeoScheme::Instance()->Init(parFile, static_cast<int>(geoTag.Contains("mcbm")));
  }
}
catch (const std::exception& err) {
  LOG(fatal)
    << "much::RecoSetupUnitFactory cannot be constructed, because " << err.what() << ". Please ensure, if the "
    << "required parameters are defined before the point of the much::RecoSetupUnitFactory object construction";
}
 
// ---------------------------------------------------------------------------------------------------------------------
//
RecoSetupUnit RecoSetupUnitFactory::Create() const
{
  RecoSetupUnit res{CreateStationVolumes(), CreateStationIdOffsets()};
  if (!res.IsValid()) {
    LOG(error) << res.TableOfTrackingStations();
    LOG(fatal) << "much::RecoSetupUnitFactory: creation of a valid MuCh reco-setup unit failed";
  }
  return res;
}
 
// ---------------------------------------------------------------------------------------------------------------------
//
RecoSetupUnitFactory::OffsetContainer_t RecoSetupUnitFactory::CreateStationIdOffsets() const
{
  OffsetContainer_t res;
  const auto* pGeoScheme = CbmMuchGeoScheme::Instance();
  res.reserve(pGeoScheme->GetNStations() + 1);
  res.push_back(0);
  for (int iMuchSt = 0; iMuchSt < pGeoScheme->GetNStations(); ++iMuchSt) {
    res.push_back(res.back() + pGeoScheme->GetStation(iMuchSt)->GetNLayers());
  }
  return res;
}
 
// ---------------------------------------------------------------------------------------------------------------------
//
std::pair<std::vector<GeoVolume>, std::vector<GeoVolume>> RecoSetupUnitFactory::CreateStationVolumes() const
{
  const auto* pGeoScheme = CbmMuchGeoScheme::Instance();
 
  int nStations{0};
  for (int iMuchSt = 0; iMuchSt < pGeoScheme->GetNStations(); ++iMuchSt) {
    nStations += pGeoScheme->GetStation(iMuchSt)->GetNLayers();
  }
 
  std::vector<GeoVolume> fullVolumes(nStations);
  std::vector<GeoVolume> activeVolumes(nStations);
  std::regex rgxLayerPattern{"muchstation(\\d+)layer(\\d+)_(\\d+)"};
  auto vLayerPaths{GeoHelper::CollectNodes("much", rgxLayerPattern, "", gGeoManager->GetTopNode())};
 
  assert(static_cast<int>(vLayerPaths.size()) == nStations);
  for (int iTrkSt = 0; iTrkSt < nStations; ++iTrkSt) {
    const auto& layerPath = vLayerPaths[iTrkSt];
    fullVolumes[iTrkSt]   = RecoSetupUtils::ReadVolume(layerPath);
    gGeoManager->cd(layerPath);
    auto vActPaths{GeoHelper::CollectNodes("much", std::regex{"active"}, layerPath(0, layerPath.Last('/')),
                                           gGeoManager->GetCurrentNode())};
    if (vActPaths.empty()) {
      throw std::runtime_error("Could not find nodes containing \"active\" in their paths");
    }
    for (const auto& activePath : vActPaths) {
      activeVolumes[iTrkSt] += RecoSetupUtils::ReadVolume(activePath);
    }
  }
 
  return {std::move(fullVolumes), std::move(activeVolumes)};
}