CbmGeoNodeMapBuilder.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 "CbmGeoNodeMapBuilder.h"
 
#include "CbmGeoHelper.h"
#include "CbmMvdAddress.h"
#include "CbmMvdDetector.h"
#include "CbmMvdSensor.h"
#include "CbmStsSetup.h"
#include "CbmTofAddress.h"
#include "CbmTrdAddress.h"
 
#include <FairRuntimeDb.h>
 
#include <TGeoManager.h>
#include <TGeoPhysicalNode.h>
 
using cbm::GeoNodeMap;
using cbm::GeoNodeMapBuilder;
 
// A tag for convenient ECbmModuleId dispatching in lambdas
template<ECbmModuleId ModuleId>
using Tag = std::integral_constant<ECbmModuleId, ModuleId>;
 
// ---------------------------------------------------------------------------------------------------------------------
//
template<>
std::unordered_map<uint32_t, std::string> GeoNodeMapBuilder::Add<ECbmModuleId::kMvd>()
{
  std::unordered_map<uint32_t, std::string> res;
  const auto& mvdSensorMap = CbmMvdDetector::Instance()->GetSensorMap();
  for (auto [address, pSensor] : mvdSensorMap) {
    res[address] = pSensor->GetNodeName().Data();
  }
  return res;
}
 
// ---------------------------------------------------------------------------------------------------------------------
//
template<>
std::unordered_map<uint32_t, std::string> GeoNodeMapBuilder::Add<ECbmModuleId::kSts>()
{
  std::unordered_map<uint32_t, std::string> res;
  const auto* pSetup = CbmStsSetup::Instance();
  for (int iSensor = 0; iSensor < pSetup->GetNofSensors(); ++iSensor) {
    const auto* pSensor = pSetup->GetSensor(iSensor);
    assert(pSensor);
    const auto* pNode = pSensor->GetNode();
    assert(pNode);
    std::string path = pNode->GetName();
    if (path.compare(0, 4, "cave") == 0) {  // The path is global but does not start with '/'
      path = "/" + path;
    }
    uint32_t address = pSensor->GetAddress();
    res[address]     = path;
  }
  return res;
}
 
// ---------------------------------------------------------------------------------------------------------------------
//
template<>
std::unordered_map<uint32_t, std::string> GeoNodeMapBuilder::Add<ECbmModuleId::kTof>()
{
  std::unordered_map<uint32_t, std::string> res;
 
  assert(gGeoManager);
  auto vRpcPaths{GeoHelper::CollectNodes("tof", std::regex{"counter"}, "", gGeoManager->GetTopNode())};
  std::regex rpcPattern{"module_(\\d+)_(\\d+)/gas_box_(\\d+)/counter_(\\d+)"};
 
  for (const auto& rpcPath : vRpcPaths) {
    std::smatch match;
    std::string line{rpcPath.Data()};
    if (std::regex_search(line, match, rpcPattern)) {
      int smTypeId{std::stoi(match[1])};
      int smId{std::stoi(match[2])};
      int rpcId{std::stoi(match[4])};
      uint32_t address{CbmTofAddress::GetUniqueAddress(smId, rpcId, 0, 0, smTypeId, 0)};
      res[address] = std::string(rpcPath.Data());
    }
  }
 
  return res;
}
 
// ---------------------------------------------------------------------------------------------------------------------
//
template<>
std::unordered_map<uint32_t, std::string> GeoNodeMapBuilder::Add<ECbmModuleId::kTrd>()
{
  std::unordered_map<uint32_t, std::string> res;
 
  assert(gGeoManager);
  auto vRpcPaths{GeoHelper::CollectNodes("tof", std::regex{"counter"}, "", gGeoManager->GetTopNode())};
  std::regex rpcPattern{"layer(\\d+)_(\\d+)/module(\\d+)_(\\d+)"};
 
  for (const auto& rpcPath : vRpcPaths) {
    std::smatch match;
    std::string line{rpcPath.Data()};
    if (std::regex_search(line, match, rpcPattern)) {
      int layerId{std::stoi(match[1])};
      int moduleId{std::stoi(match[3])};
      uint32_t address{CbmTrdAddress::GetAddress(layerId, moduleId, 0, 0, 0)};
      res[address] = std::string(rpcPath.Data());
    }
  }
 
  return res;
}
 
// ---------------------------------------------------------------------------------------------------------------------
//
GeoNodeMap GeoNodeMapBuilder::Build() const
try {
  std::unordered_map<uint32_t, std::string> collectedNodes;
 
  // Using tag dispatching before C++20
  auto AddNodes = [&](auto aTag) -> void {
    constexpr ECbmModuleId ModuleId = decltype(aTag)::value;
    if (fDetToBuildNodes.find(ModuleId) != fDetToBuildNodes.end()) {
      LOG(info) << "GeoNodeMapBuilder: building node map for " << ModuleId;
      collectedNodes.merge(Add<ModuleId>());
    }
  };
 
  AddNodes(Tag<ECbmModuleId::kMvd>{});
  AddNodes(Tag<ECbmModuleId::kSts>{});
  AddNodes(Tag<ECbmModuleId::kMuch>{});
  AddNodes(Tag<ECbmModuleId::kTrd>{});
  AddNodes(Tag<ECbmModuleId::kTof>{});
 
  return GeoNodeMap{std::move(collectedNodes)};
}
catch (const std::exception& err) {
  LOG(fatal) << "cbm::GeoNodeMapBuilder: failed building the map. Reason: " << err.what();
  __builtin_unreachable();  // No return is reachable
}