feat: Gen3 DD4hep construction

Core/include/Acts/Utilities/FunctionComposition.hpp

@@ -0,0 +1,61 @@
+// This file is part of the ACTS project.
+//
+// Copyright (C) 2016 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 https://mozilla.org/MPL/2.0/.
+
+#pragma once
+
+#include <functional>
+#include <utility>
+
+namespace Acts {
+
+namespace detail {
+
+/// @brief Base case: apply a single function to a value.
+/// @param x The input value
+/// @param f The function to apply
+/// @return The result of invoking @p f with @p x
+template <typename T, typename F>
+decltype(auto) applyRight(T&& x, const F& f) {
+  return std::invoke(f, std::forward<T>(x));
+}
+
+/// @brief Recursive case: apply the last function first, then fold right.
+/// @param x The input value
+/// @param f The outermost function to apply last
+/// @param rest The remaining functions, applied right-to-left
+/// @return The result of the right-to-left function chain
+template <typename T, typename F, typename... Rest>
+decltype(auto) applyRight(T&& x, const F& f, const Rest&... rest) {
+  return std::invoke(f, applyRight(std::forward<T>(x), rest...));
+}
+
+}  // namespace detail
+
+/// @brief Compose multiple callables into a single callable, applied
+///        right-to-left (mathematical convention).
+///
+/// Given `compose(f, g, h)`, the returned callable computes `f(g(h(x)))`.
+/// All callables are stored exactly once in a tuple, avoiding the nested-copy
+/// overhead of a recursive lambda approach.
+///
+/// @tparam Fs The callable types
+/// @param fs The callables to compose
+/// @return A callable that applies @p fs right-to-left
+template <typename... Fs>
+auto compose(Fs&&... fs) {
+  return [tup = std::make_tuple(std::forward<Fs>(fs)...)]<typename T>(
+             T&& x) -> decltype(auto) {
+    return std::apply(
+        [&](const auto&... fns) -> decltype(auto) {
+          return detail::applyRight(std::forward<T>(x), fns...);
+        },
+        tup);
+  };
+}
+
+}  // namespace Acts

Examples/Detectors/DD4hepDetector/include/ActsExamples/DD4hepDetector/OpenDataDetector.hpp

@@ -8,17 +8,55 @@
 
 #pragma once
 
+#include "Acts/Geometry/Extent.hpp"
+#include "Acts/Utilities/AxisDefinitions.hpp"
 #include "ActsExamples/DD4hepDetector/DD4hepDetector.hpp"
 
 namespace Acts {
 class GeometryContext;
 }
 
+namespace ActsPlugins {
+class DD4hepDetectorElement;
+}
+
 namespace ActsExamples {
 
 class OpenDataDetector final : public DD4hepDetectorBase {
  public:
-  struct Config : public DD4hepDetectorBase::Config {};
+  struct Config : public DD4hepDetectorBase::Config {
+    enum class ConstructionMethod {
+      BarrelEndcap,
+      DirectLayer,
+      DirectLayerGrouped
+    };
+
+    using ElementFactory =
+        std::function<std::shared_ptr<ActsPlugins::DD4hepDetectorElement>(
+            const dd4hep::DetElement& element, ActsPlugins::TGeoAxes axes,
+            double scale)>;
+
+    ElementFactory detectorElementFactory = defaultDetectorElementFactory;
+
+    /// Select the conversion style used to construct the Gen3 ODD geometry.
+    ConstructionMethod constructionMethod = ConstructionMethod::BarrelEndcap;
+
+    /// Envelope for the blueprint root (world volume). Values in mm.
+    Acts::ExtentEnvelope blueprintEnvelope =
+        Acts::ExtentEnvelope::Zero()
+            .set(Acts::AxisDirection::AxisZ, {20., 20.})
+            .set(Acts::AxisDirection::AxisR, {0., 20.});
+
+    /// Envelope for layer volumes. Values in mm.
+    Acts::ExtentEnvelope layerEnvelope =
+        Acts::ExtentEnvelope::Zero()
+            .set(Acts::AxisDirection::AxisZ, {2., 2.})
+            .set(Acts::AxisDirection::AxisR, {2., 2.});
+  };
+
+  static std::shared_ptr<ActsPlugins::DD4hepDetectorElement>
+  defaultDetectorElementFactory(const dd4hep::DetElement& element,
+                                ActsPlugins::TGeoAxes axes, double scale);
 
   explicit OpenDataDetector(const Config& cfg,
                             const Acts::GeometryContext& gctx);
@@ -28,6 +66,18 @@ class OpenDataDetector final : public DD4hepDetectorBase {
  private:
   void construct(const Acts::GeometryContext& gctx);
 
+  /// Construction path using BarrelEndcapAssembler (wraps
+  /// ElementLayerAssembler).
+  void constructBarrelEndcap(const Acts::GeometryContext& gctx);
+
+  /// Construction path using ElementLayerAssembler directly. For illustration.
+  void constructDirectLayer(const Acts::GeometryContext& gctx);
+
+  /// Construction path using SensorLayerAssembler with groupBy. For
+  /// illustration: sensors are collected directly and grouped by walking the
+  /// parent chain to find the enclosing layer element.
+  void constructDirectLayerGrouped(const Acts::GeometryContext& gctx);
+
   Config m_cfg;
 };
 

Examples/Detectors/DD4hepDetector/src/OpenDataDetector.cpp

@@ -8,42 +8,47 @@
 
 #include "ActsExamples/DD4hepDetector/OpenDataDetector.hpp"
 
-#include "Acts/Geometry/Blueprint.hpp"
-#include "Acts/Geometry/BlueprintOptions.hpp"
-#include "Acts/Geometry/CylinderVolumeBounds.hpp"
+#include "ActsPlugins/DD4hep/DD4hepDetectorElement.hpp"
+#include "ActsPlugins/DD4hep/OpenDataDetectorBuilder.hpp"
+#include "ActsPlugins/Root/TGeoAxes.hpp"
+
+#include <memory>
 
 namespace ActsExamples {
 
 OpenDataDetector::OpenDataDetector(const Config& cfg,
                                    const Acts::GeometryContext& gctx)
     : DD4hepDetectorBase{cfg}, m_cfg{cfg} {
   ACTS_INFO("OpenDataDetector construct");
-  construct(gctx);
+  switch (m_cfg.constructionMethod) {
+    case Config::ConstructionMethod::BarrelEndcap:
+      m_trackingGeometry =
+          ActsPlugins::DD4hep::buildOpenDataDetectorBarrelEndcap(
+              dd4hepDetector(), gctx, logger());
+      break;
+    case Config::ConstructionMethod::DirectLayer:
+      m_trackingGeometry =
+          ActsPlugins::DD4hep::buildOpenDataDetectorDirectLayer(
+              dd4hepDetector(), gctx, logger());
+      break;
+    case Config::ConstructionMethod::DirectLayerGrouped:
+      m_trackingGeometry =
+          ActsPlugins::DD4hep::buildOpenDataDetectorDirectLayerGrouped(
+              dd4hepDetector(), gctx, logger());
+      break;
+  }
 }
 
 auto OpenDataDetector::config() const -> const Config& {
   return m_cfg;
 }
 
-void OpenDataDetector::construct(const Acts::GeometryContext& gctx) {
-  using namespace Acts::Experimental;
-  using namespace Acts;
-  using namespace Acts::UnitLiterals;
-
-  Blueprint::Config cfg;
-  cfg.envelope[AxisDirection::AxisZ] = {20_mm, 20_mm};
-  cfg.envelope[AxisDirection::AxisR] = {0_mm, 20_mm};
-  Blueprint root{cfg};
-
-  auto volBounds = std::make_shared<CylinderVolumeBounds>(0_mm, 100_mm, 1_m);
-  auto vol =
-      std::make_unique<TrackingVolume>(Transform3::Identity(), volBounds);
-
-  root.addStaticVolume(std::move(vol));
-
-  BlueprintOptions options;
-
-  m_trackingGeometry = root.construct(options, gctx, logger());
+std::shared_ptr<ActsPlugins::DD4hepDetectorElement>
+OpenDataDetector::defaultDetectorElementFactory(
+    const dd4hep::DetElement& element, ActsPlugins::TGeoAxes axes,
+    double scale) {
+  return std::make_shared<ActsPlugins::DD4hepDetectorElement>(element, axes,
+                                                              scale);
 }
 
 }  // namespace ActsExamples

Examples/Scripts/Python/geometry.py

@@ -56,10 +56,15 @@ def runGeometry(
             writer.write(context)
 
         if outputObj:
-            writer = ObjTrackingGeometryWriter(
-                level=acts.logging.INFO, outputDir=outputDir / "obj"
+            vis = acts.ObjVisualization3D()
+            trackingGeometry.visualize(
+                vis,
+                context.geoContext,
+                portalViewConfig=acts.ViewConfig(visible=False),
+                sensitiveViewConfig=acts.ViewConfig(visible=True),
+                viewConfig=acts.ViewConfig(visible=False),
             )
-            writer.write(context, trackingGeometry)
+            vis.write(outputDir / "obj" / "geometry.obj")
 
         if outputJson:
             # if not os.path.isdir(outputDir / "json"):

Plugins/DD4hep/CMakeLists.txt

@@ -10,6 +10,8 @@ acts_add_library(
     src/DD4hepLayerBuilder.cpp
     src/DD4hepVolumeBuilder.cpp
     src/DD4hepFieldAdapter.cpp
+    src/BlueprintBuilder.cpp
+    src/OpenDataDetectorBuilder.cpp
     ACTS_INCLUDE_FOLDER include/ActsPlugins
 )