feat: GeoModel plugin changes for ITk building.

Examples/Python/src/GeoModel.cpp

@@ -17,10 +17,12 @@
 #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/GeoModelDetectorSurfaceFactory.hpp"
 #include "Acts/Plugins/GeoModel/GeoModelReader.hpp"
 #include "Acts/Plugins/GeoModel/GeoModelTree.hpp"
 #include "Acts/Plugins/GeoModel/IGeoShapeConverter.hpp"
+#include "Acts/Plugins/GeoModel/SplitModulesByRadius.hpp"
 #include "Acts/Plugins/Python/Utilities.hpp"
 #include "Acts/Surfaces/Surface.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
   {
@@ -179,5 +184,17 @@ void addGeoModel(Context& ctx) {
         .def_readwrite("table",
                        &Acts::GeoModelBlueprintCreater::Options::table);
   }
+
+  py::class_<Acts::ModuleByRadiusSplitter>(gm, "ModuleByRadiusSplitter")
+      .def(py::init<std::map<std::string, std::vector<double>>, double,
+                    Acts::Logging::Level>(),
+           "designs"_a, "tolerance"_a = 1.e-3, "level"_a = Acts::Logging::INFO)
+      .def("split", &Acts::ModuleByRadiusSplitter::split, "surface"_a,
+           "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

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

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

@@ -86,14 +86,28 @@ class GeoModelDetectorElement : public DetectorElementBase {
   /// @return to the Geant4 physical volume
   const GeoFullPhysVol& 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
   const GeoFullPhysVol* m_geoPhysVol{nullptr};
   /// The surface

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

@@ -0,0 +1,56 @@
+// 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"
+
+namespace Acts {
+
+/// 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 {
+  int m_hardware;
+  int m_barrelEndcap;
+  int m_layerWheel;
+  int m_etaModule;
+  int m_phiModule;
+  int m_side;
+
+ public:
+  GeoModelDetectorElementITk(const GeoFullPhysVol& 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, surface, sfTransform, thickness),
+        m_hardware(hardware),
+        m_barrelEndcap(barrelEndcap),
+        m_layerWheel(layerWheel),
+        m_etaModule(etaModule),
+        m_phiModule(phiModule),
+        m_side(side) {}
+
+  int hardware() const { return m_hardware; }
+  int barrelEndcap() const { return m_barrelEndcap; }
+  int layerWheel() const { return m_layerWheel; }
+  int phiModule() const { return m_phiModule; }
+  int etaModule() const { return m_etaModule; }
+  int side() const { return m_side; }
+
+  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);
+};
+
+}  // namespace Acts

Plugins/GeoModel/include/Acts/Plugins/GeoModel/SplitModulesByRadius.hpp

@@ -0,0 +1,43 @@
+// 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 {
+
+class ModuleByRadiusSplitter {
+ public:
+  /// Construct with a map { design-name: list of radii }
+  ModuleByRadiusSplitter(
+      const std::map<std::string, std::vector<double>> &designs,
+      double tolerance = 1.e-3,
+      Acts::Logging::Level level = Acts::Logging::INFO)
+      : m_designs(designs),
+        m_tolerance(tolerance),
+        m_logger(getDefaultLogger("ModuleByRadiusSplitter", level)) {}
+
+  std::optional<std::vector<std::pair<
+      std::shared_ptr<Surface>, std::shared_ptr<GeoModelDetectorElement>>>>
+  split(std::shared_ptr<Surface> surface,
+        std::shared_ptr<GeoModelDetectorElement> detElement,
+        const GeometryContext &gctx) const;
+
+ private:
+  std::map<std::string, std::vector<double>> m_designs;
+  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(
     const GeoFullPhysVol& geoPhysVol, std::shared_ptr<Surface> surface,
     const Transform3& sfTransform, ActsScalar thickness)
@@ -40,3 +42,7 @@ Acts::ActsScalar Acts::GeoModelDetectorElement::thickness() const {
 const GeoFullPhysVol& 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,51 @@
+// 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"
+
+namespace Acts {
+
+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::make_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/GeoModelDetectorSurfaceFactory.cpp

@@ -100,7 +100,10 @@ void Acts::GeoModelDetectorSurfaceFactory::construct(
         if (converted.ok()) {
           // Add the element and surface to the cache
           cache.sensitiveSurfaces.push_back(converted.value());
-          const auto &[el, sf] = converted.value();
+          auto &[el, sf] = converted.value();
+
+          // Set the name to the element
+          el->setDatabaseEntryName(name);
           success = true;
           ACTS_VERBOSE("successfully converted "
                        << name << " (" << vname << " / " << recType(shape)

Plugins/GeoModel/src/SplitModulesByRadius.cpp

@@ -0,0 +1,84 @@
+// 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/SplitModulesByRadius.hpp"
+
+#include "Acts/Surfaces/AnnulusBounds.hpp"
+#include "Acts/Surfaces/DiscSurface.hpp"
+#include "Acts/Utilities/Logger.hpp"
+
+#include <iostream>
+
+namespace Acts {
+
+std::optional<std::vector<std::pair<std::shared_ptr<Surface>,
+                                    std::shared_ptr<GeoModelDetectorElement>>>>
+ModuleByRadiusSplitter::split(
+    std::shared_ptr<Surface> surface,
+    std::shared_ptr<GeoModelDetectorElement> detElement,
+    const Acts::GeometryContext &gctx) const {
+  const auto &logger = *m_logger;
+
+  auto annulusBounds = dynamic_cast<const AnnulusBounds *>(&surface->bounds());
+
+  if (annulusBounds == nullptr) {
+    ACTS_DEBUG("Not annulus bounds");
+    return std::nullopt;
+  }
+
+  std::optional<std::vector<std::pair<
+      std::shared_ptr<Surface>, std::shared_ptr<GeoModelDetectorElement>>>>
+      result;
+
+  for (auto [design, radii] : m_designs) {
+    if ((std::abs(radii.front() - annulusBounds->rMin()) > m_tolerance) ||
+        (std::abs(radii.back() - annulusBounds->rMax()) > m_tolerance)) {
+      ACTS_VERBOSE("Skip design '" << design << "' for element '"
+                                   << detElement->databaseEntryName());
+      continue;
+    }
+
+    radii.front() = annulusBounds->rMin();
+    radii.back() = annulusBounds->rMax();
+
+    ACTS_DEBUG("Accept design '" << design << "' for element '"
+                                 << detElement->databaseEntryName());
+
+    result.emplace();
+    const auto origValues = annulusBounds->values();
+
+    for (auto i = 0ul; i < radii.size() - 1; ++i) {
+      std::array<double, AnnulusBounds::eSize> values;
+      std::copy(origValues.begin(), origValues.end(), values.begin());
+      values[AnnulusBounds::eMinR] = radii[i];
+      values[AnnulusBounds::eMaxR] = radii[i + 1];
+
+      auto bounds = std::make_shared<AnnulusBounds>(values);
+
+      auto newDetElement =
+          GeoModelDetectorElement::createDetectorElement<DiscSurface>(
+              detElement->physicalVolume(), bounds, detElement->transform(gctx),
+              detElement->thickness());
+      auto newSurface = newDetElement->surface().getSharedPtr();
+
+      newDetElement->setDatabaseEntryName(detElement->databaseEntryName());
+
+      result->emplace_back(newSurface, newDetElement);
+    }
+
+    return result;
+  }
+
+  ACTS_WARNING("Could not split '" << detElement->databaseEntryName()
+                                   << "' (rmin: " << annulusBounds->rMin()
+                                   << ", rmax: " << annulusBounds->rMax()
+                                   << ")");
+  return result;
+}
+
+}  // namespace Acts