CbmGeoNodeMap.h

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] */

 
#ifndef CbmGeoNodeMap_h
#define CbmGeoNodeMap_h 1
 
#include "CbmAddress.h"
#include "CbmDefs.h"
#include "CbmRecoSetupUtils.h"
#include "algo/setup/GeoVolume.h"
 
#include <cstdint>
#include <functional>
#include <string>
#include <unordered_map>
 
namespace cbm
{
  class GeoNodeMap {
   public:
    explicit GeoNodeMap(std::unordered_map<uint32_t, std::string>&& nodeMap);

    const std::string& GetNodePath(uint32_t address) const
    {
      auto it = fNodeMap.find(ApplyMask(address));
      if (it != fNodeMap.end()) {
        return it->second;
      }
      return fNodeMap.at(0);
    }

    const auto& GetNodeMap() const { return fNodeMap; }

    algo::GeoVolume ReadGeoVolume(uint32_t address);

    // TODO: extend for a generic root object
    template<class Visitor>
    auto GetVolumeProperties(Visitor&& visitor, ECbmModuleId moduleId) const
    {
      using Property_t = std::invoke_result_t<Visitor, algo::GeoVolume>;
      std::unordered_map<uint32_t, Property_t> res;
      for (const auto& [address, path] : fNodeMap) {
        if (static_cast<ECbmModuleId>(CbmAddress::GetSystemId(address)) == moduleId) {
          res[address] = std::invoke(std::forward<Visitor>(visitor), RecoSetupUtils::ReadVolume(path));
        }
      }
      return res;
    }

    static uint32_t ApplyMask(uint32_t address, ECbmModuleId moduleId)
    {
      switch (moduleId) {
        case ECbmModuleId::kMvd: return address & AlignableMask<ECbmModuleId::kMvd>();
        case ECbmModuleId::kSts: return address & AlignableMask<ECbmModuleId::kSts>();
        case ECbmModuleId::kMuch: return address & AlignableMask<ECbmModuleId::kMuch>();
        case ECbmModuleId::kTrd: return address & AlignableMask<ECbmModuleId::kTrd>();
        case ECbmModuleId::kTof: return address & AlignableMask<ECbmModuleId::kTof>();
        default: return 0;
      }
    }

    static uint32_t ApplyMask(uint32_t address)
    {
      auto moduleId = static_cast<ECbmModuleId>(CbmAddress::GetSystemId(address));
      return ApplyMask(address, moduleId);
    }
 
   private:
    std::unordered_map<uint32_t, std::string> fNodeMap;  

    // TODO: replace with a GetDetectorId method
    template<ECbmModuleId ModuleId>
    static uint32_t AlignableMask()
    {
      if constexpr (ModuleId == ECbmModuleId::kMvd) {
        return 0x00000fff;  // MVD Sensor
      }
      else if constexpr (ModuleId == ECbmModuleId::kSts) {
        return 0xffffffff;  // STS Sensor
      }
      else if constexpr (ModuleId == ECbmModuleId::kMuch) {
        return 0x00007fff;  // MuCh Module ?
      }
      else if constexpr (ModuleId == ECbmModuleId::kTrd) {
        return 0x00007fff;  // TRD Module
      }
      else if constexpr (ModuleId == ECbmModuleId::kTof) {
        return 0x001fffff;  // TOF RPC
      }
    }
  };
 
}  // namespace cbm
 
#endif  // CbmGeoNodeMap_h