feat: GeoModel plugin changes for ITk building.

Examples/Python/src/GeoModel.cpp

@@ -17,7 +17,9 @@
 #include "Acts/Plugins/GeoModel/GeoModelBlueprintCreater.hpp"
 #include "Acts/Plugins/GeoModel/GeoModelConverters.hpp"
 #include "Acts/Plugins/GeoModel/GeoModelDetectorElement.hpp"
+#include "Acts/Plugins/GeoModel/GeoModelDetectorElementITk.hpp"
 #include "Acts/Plugins/GeoModel/GeoModelDetectorObjectFactory.hpp"
+#include "Acts/Plugins/GeoModel/GeoModelModuleSplitter.hpp"
 #include "Acts/Plugins/GeoModel/GeoModelReader.hpp"
 #include "Acts/Plugins/GeoModel/GeoModelTree.hpp"
 #include "Acts/Plugins/GeoModel/IGeoShapeConverter.hpp"
@@ -46,7 +48,10 @@ void addGeoModel(Context& ctx) {
 
   py::class_<Acts::GeoModelDetectorElement,
              std::shared_ptr<Acts::GeoModelDetectorElement>>(
-      gm, "GeoModelDetectorElement");
+      gm, "GeoModelDetectorElement")
+      .def("logVolName", &Acts::GeoModelDetectorElement::logVolName)
+      .def("databaseEntryName",
+           &Acts::GeoModelDetectorElement::databaseEntryName);
 
   // Shape converters
   {
@@ -184,5 +189,17 @@ void addGeoModel(Context& ctx) {
         .def_readwrite("table",
                        &Acts::GeoModelBlueprintCreater::Options::table);
   }
+
+  py::class_<Acts::GeoModelModuleSplitter>(gm, "GeoModelModuleSplitter")
+      .def(py::init<std::map<std::string, std::vector<double>>, double,
+                    Acts::Logging::Level>(),
+           "self"_a, "designs"_a, "tolerance", "level"_a)
+      .def("split", &Acts::GeoModelModuleSplitter::split, "detElement"_a,
+           "gctx"_a);
+
+  py::class_<Acts::GeoModelDetectorElementITk,
+             std::shared_ptr<Acts::GeoModelDetectorElementITk>>(
+      gm, "GeoModelDetectorElementITk");
+  gm.def("convertToItk", &GeoModelDetectorElementITk::convertFromGeomodel);
 }
 }  // namespace Acts::Python

Plugins/GeoModel/CMakeLists.txt

@@ -18,6 +18,8 @@ add_library(
     src/detail/GeoModelBinningHelper.cpp
     src/detail/GeoModelExtentHelper.cpp
     src/detail/GeoUnionDoubleTrdConverter.cpp
+    src/GeoModelModuleSplitter.cpp
+    src/GeoModelDetectorElementITk.cpp
 )
 target_include_directories(
     ActsPluginGeoModel

Plugins/GeoModel/include/Acts/Plugins/GeoModel/GeoModelDetectorElement.hpp

@@ -87,14 +87,28 @@ class GeoModelDetectorElement : public DetectorElementBase {
   /// @return to the Geant4 physical volume
   PVConstLink physicalVolume() const;
 
- private:
+  /// Get the name of the logical volume
+  const std::string& logVolName() const;
+
+  /// Get the string identifier of the corresponding database entry
+  /// Note: This is not by defnitition a unique identifier, there can be
+  /// several detector elements created from a single database entry.
+  const std::string& databaseEntryName() const { return m_entryName; };
+
+  /// Set the corresponding database entry string
+  void setDatabaseEntryName(const std::string& n) { m_entryName = n; };
+
+ protected:
   /// Attach a surface
   ///
   /// @param surface The surface to attach
   void attachSurface(std::shared_ptr<Surface> surface) {
     m_surface = std::move(surface);
   }
 
+ private:
+  std::string m_entryName;
+
   /// The GeoModel full physical volume
   PVConstLink m_geoPhysVol{nullptr};
   /// The surface

Plugins/GeoModel/include/Acts/Plugins/GeoModel/GeoModelDetectorElementITk.hpp

@@ -0,0 +1,77 @@
+// This file is part of the Acts project.
+//
+// Copyright (C) 2024 CERN for the benefit of the Acts project
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#pragma once
+
+#include "Acts/Plugins/GeoModel/GeoModelDetectorElement.hpp"
+#include "Acts/Utilities/MultiIndex.hpp"
+
+namespace Acts {
+
+class ITkIdentifier {
+  Acts::MultiIndex<std::size_t, 1, 2, 20, 20, 20, 1> m_identifier{};
+
+ public:
+  ITkIdentifier(int hardware, int barrelEndcap, int layerWheel, int etaModule,
+                int phiModule, int side);
+
+  /// Access the hardware specifier (pixel=0, strip=1)
+  int hardware() const;
+
+  /// Access the barrel-endcap specifier (-2,0,2)
+  int barrelEndcap() const;
+
+  /// Access the layer specifier
+  int layerWheel() const;
+
+  /// Access the phi module specifier
+  int phiModule() const;
+
+  /// Access the eta module specifier
+  int etaModule() const;
+
+  /// Access the side (for double sided strip modules)
+  int side() const;
+
+  /// A unique identifier that represents the combination of specifiers
+  std::size_t value() const;
+};
+
+/// Specialization of the GeoModelDetectorElement for the ITk. This allows
+/// mapping of Acts::GeometryIdentifiers to ITk modules in a straight-forward
+/// way.
+class GeoModelDetectorElementITk : public GeoModelDetectorElement {
+ public:
+  GeoModelDetectorElementITk(const PVConstLink& geoPhysVol,
+                             std::shared_ptr<Surface> surface,
+                             const Transform3& sfTransform,
+                             ActsScalar thickness, int hardware,
+                             int barrelEndcap, int layerWheel, int etaModule,
+                             int phiModule, int side)
+      : GeoModelDetectorElement(geoPhysVol, std::move(surface), sfTransform,
+                                thickness),
+        m_identifier(hardware, barrelEndcap, layerWheel, etaModule, phiModule,
+                     side) {}
+
+  ITkIdentifier identifier() const { return m_identifier; }
+
+  /// Convert a GeoModelDetectorElement to a GeoModelDetectorElementITk
+  /// A new surface is constructed.
+  /// @todo Remove redundancy in signature once plugin is refactored
+  static std::tuple<std::shared_ptr<GeoModelDetectorElementITk>,
+                    std::shared_ptr<Surface>>
+  convertFromGeomodel(std::shared_ptr<GeoModelDetectorElement> detEl,
+                      std::shared_ptr<Surface> srf, const GeometryContext& gctx,
+                      int hardware, int barrelEndcap, int layerWheel,
+                      int etaModule, int phiModule, int side);
+
+ private:
+  ITkIdentifier m_identifier;
+};
+
+}  // namespace Acts

Plugins/GeoModel/include/Acts/Plugins/GeoModel/GeoModelModuleSplitter.hpp

@@ -0,0 +1,58 @@
+// This file is part of the Acts project.
+//
+// Copyright (C) 2024 CERN for the benefit of the Acts project
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#pragma once
+
+#include "Acts/Plugins/GeoModel/GeoModelDetectorElement.hpp"
+#include "Acts/Utilities/Logger.hpp"
+
+#include <map>
+#include <string>
+#include <vector>
+
+namespace Acts {
+
+/// This class allows to split modules with annulus shape along into several
+/// parts with the help of a list of radii. This is used for building
+/// an ITk geometry.
+/// The splitting works based on a provided list of radii [r0, r1, ..., rN]:
+/// An annulus bound with radial constraint (rA, rB) is split in N-1 bounds
+/// with radii (r0,r1), (r1,r2), ...
+/// A pattern is only accepted, if rA ~ r0 and rB ~ r1 up to a configurable
+/// tolerance.
+class GeoModelModuleSplitter {
+ public:
+  /// Construct the module splitter
+  /// @param splitPatterns A map of named split patterns
+  /// @param tolerance The tolerance applied when matching the split
+  /// patterns to the modules
+  /// @param level The level of the internal logger
+  /// @throws std::runtime_error if the surface does not has annulus
+  /// bounds or no pattern matches
+  GeoModelModuleSplitter(
+      const std::map<std::string, std::vector<double>> &splitPatterns,
+      double tolerance = 1.e-3,
+      Acts::Logging::Level level = Acts::Logging::INFO)
+      : m_splitPatterns(splitPatterns),
+        m_tolerance(tolerance),
+        m_logger(getDefaultLogger("GeoModelModuleSplitter", level)) {}
+
+  /// Perform the split for a detector element
+  /// @param detElement The detector element to split
+  /// @param gctx The geometry context
+  std::vector<std::shared_ptr<GeoModelDetectorElement>> split(
+      std::shared_ptr<GeoModelDetectorElement> detElement,
+      const GeometryContext &gctx) const;
+
+ private:
+  std::map<std::string, std::vector<double>> m_splitPatterns;
+  double m_tolerance;
+  std::unique_ptr<const Acts::Logger> m_logger;
+};
+
+}  // namespace Acts

Plugins/GeoModel/src/GeoModelDetectorElement.cpp

@@ -12,6 +12,8 @@
 
 #include <utility>
 
+#include <GeoModelKernel/GeoFullPhysVol.h>
+
 Acts::GeoModelDetectorElement::GeoModelDetectorElement(
     PVConstLink geoPhysVol, std::shared_ptr<Surface> surface,
     const Transform3& sfTransform, ActsScalar thickness)
@@ -40,3 +42,7 @@ Acts::ActsScalar Acts::GeoModelDetectorElement::thickness() const {
 PVConstLink Acts::GeoModelDetectorElement::physicalVolume() const {
   return m_geoPhysVol;
 }
+
+const std::string& Acts::GeoModelDetectorElement::logVolName() const {
+  return m_geoPhysVol->getLogVol()->getName();
+}

Plugins/GeoModel/src/GeoModelDetectorElementITk.cpp

@@ -0,0 +1,108 @@
+// This file is part of the Acts project.
+//
+// Copyright (C) 2024 CERN for the benefit of the Acts project
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#include "Acts/Plugins/GeoModel/GeoModelDetectorElementITk.hpp"
+
+#include "Acts/Surfaces/AnnulusBounds.hpp"
+#include "Acts/Surfaces/DiscSurface.hpp"
+#include "Acts/Surfaces/PlaneSurface.hpp"
+#include "Acts/Surfaces/RectangleBounds.hpp"
+
+#include <ranges>
+
+namespace Acts {
+
+// Mapping between the barrel-endcap identifier and its unsigned representation
+constexpr static std::array<std::pair<unsigned, int>, 3> s_barrelEndcapMap{
+    {{0, 0}, {1, 2}, {2, -2}}};
+
+Acts::ITkIdentifier::ITkIdentifier(int hardware, int barrelEndcap,
+                                   int layerWheel, int etaModule, int phiModule,
+                                   int side) {
+  m_identifier.set(0, hardware);
+
+  auto found = std::ranges::find(s_barrelEndcapMap, barrelEndcap,
+                                 &std::pair<unsigned, int>::second);
+  if (found == s_barrelEndcapMap.end()) {
+    throw std::invalid_argument("Invalid barrel-endcap specifier");
+  }
+  m_identifier.set(1, found->first);
+  m_identifier.set(2, layerWheel);
+  m_identifier.set(3, etaModule);
+  m_identifier.set(4, phiModule);
+  m_identifier.set(5, side);
+}
+
+int Acts::ITkIdentifier::hardware() const {
+  return m_identifier.level(0);
+}
+
+int Acts::ITkIdentifier::barrelEndcap() const {
+  auto found = std::ranges::find(s_barrelEndcapMap, m_identifier.level(1),
+                                 &std::pair<unsigned, int>::first);
+  if (found == s_barrelEndcapMap.end()) {
+    throw std::invalid_argument("Invalid barrel-endcap specifier");
+  }
+  return found->second;
+}
+
+int Acts::ITkIdentifier::layerWheel() const {
+  return m_identifier.level(2);
+}
+
+int Acts::ITkIdentifier::phiModule() const {
+  return m_identifier.level(3);
+}
+
+int Acts::ITkIdentifier::etaModule() const {
+  return m_identifier.level(4);
+}
+
+int Acts::ITkIdentifier::side() const {
+  return m_identifier.level(5);
+}
+
+std::size_t Acts::ITkIdentifier::value() const {
+  return m_identifier.value();
+}
+
+std::tuple<std::shared_ptr<Acts::GeoModelDetectorElementITk>,
+           std::shared_ptr<Acts::Surface>>
+Acts::GeoModelDetectorElementITk::convertFromGeomodel(
+    std::shared_ptr<GeoModelDetectorElement> detEl,
+    std::shared_ptr<Surface> srf, const GeometryContext& gctx, int hardware,
+    int barrelEndcap, int layerWheel, int etaModule, int phiModule, int side) {
+  auto helper = [&]<typename surface_t, typename bounds_t>() {
+    auto bounds = std::make_shared<bounds_t>(
+        dynamic_cast<const bounds_t&>(srf->bounds()));
+
+    auto itkEl = std::make_shared<GeoModelDetectorElementITk>(
+        detEl->physicalVolume(), nullptr, detEl->transform(gctx),
+        detEl->thickness(), hardware, barrelEndcap, layerWheel, etaModule,
+        phiModule, side);
+    auto surface = Surface::makeShared<surface_t>(bounds, *itkEl.get());
+
+    itkEl->attachSurface(surface);
+    itkEl->setDatabaseEntryName(detEl->databaseEntryName());
+    return std::pair{itkEl, surface};
+  };
+
+  if (srf->type() == Acts::Surface::Plane &&
+      srf->bounds().type() == Acts::SurfaceBounds::eRectangle) {
+    return helper.operator()<Acts::PlaneSurface, Acts::RectangleBounds>();
+  }
+  if (srf->type() == Acts::Surface::Disc &&
+      srf->bounds().type() == Acts::SurfaceBounds::eAnnulus) {
+    return helper.operator()<Acts::DiscSurface, Acts::AnnulusBounds>();
+  }
+
+  throw std::runtime_error(
+      "Only Plane+Rectangle and Disc+Annulus are converted for the ITk");
+}
+
+}  // namespace Acts

Plugins/GeoModel/src/GeoModelDetectorObjectFactory.cpp

@@ -164,6 +164,9 @@ void Acts::GeoModelDetectorObjectFactory::convertFpv(
           fpv->getAbsoluteTransform() * surface.transform;
       convertSensitive(surface.volume, transform, sensitives);
     }
+    for (auto &[detEl, _] : sensitives) {
+      detEl->setDatabaseEntryName(name);
+    }
     cache.sensitiveSurfaces.insert(cache.sensitiveSurfaces.end(),
                                    sensitives.begin(), sensitives.end());
     if (convertBox(name)) {
@@ -179,9 +182,16 @@ void Acts::GeoModelDetectorObjectFactory::convertFpv(
       cache.boundingBoxes.push_back(box);
     }
   } else {
+    const auto prevSize = cache.sensitiveSurfaces.size();
+
     // convert fpvs to surfaces
     const Transform3 &transform = fpv->getAbsoluteTransform();
     convertSensitive(fpv, transform, cache.sensitiveSurfaces);
+
+    for (auto i = prevSize; i < cache.sensitiveSurfaces.size(); ++i) {
+      auto &[detEl, _] = cache.sensitiveSurfaces[i];
+      detEl->setDatabaseEntryName(name);
+    }
   }
 }
 // lambda to determine if object fits query