chore: Remove AlignedTelescopeDetector and default-align TelescopeDetector (acts-project#5369)

Remove AlignedTelescopeDetector, align TelescopeDetector

Author: goblirsc

Examples/Detectors/TelescopeDetector/CMakeLists.txt

@@ -3,7 +3,6 @@ acts_add_library(
     src/TelescopeDetector.cpp
     src/TelescopeDetectorElement.cpp
     src/BuildTelescopeDetector.cpp
-    src/AlignedTelescopeDetector.cpp
 )
 
 target_include_directories(

Examples/Detectors/TelescopeDetector/include/ActsExamples/TelescopeDetector/AlignedTelescopeDetector.hpp

@@ -10,7 +10,6 @@
 
 #include "Acts/Geometry/TrackingGeometry.hpp"
 #include "Acts/Utilities/AxisDefinitions.hpp"
-#include "ActsExamples/TelescopeDetector/TelescopeDetectorElement.hpp"
 
 #include <array>
 #include <memory>
@@ -43,7 +42,6 @@ enum class TelescopeSurfaceType {
 /// parallel to
 std::unique_ptr<const Acts::TrackingGeometry> buildTelescopeDetector(
     const Acts::GeometryContext& gctx,
-    const TelescopeDetectorElement::DetectorElementFactory& factory,
     std::vector<std::shared_ptr<const Acts::SurfacePlacementBase>>&
         detectorStore,
     const std::vector<double>& positions,

Examples/Detectors/TelescopeDetector/include/ActsExamples/TelescopeDetector/BuildTelescopeDetector.hpp

@@ -9,7 +9,6 @@
 #pragma once
 
 #include "Acts/Definitions/Units.hpp"
-#include "Acts/Utilities/AxisDefinitions.hpp"
 #include "Acts/Utilities/Logger.hpp"
 #include "ActsExamples/DetectorCommons/Detector.hpp"
 

Examples/Detectors/TelescopeDetector/include/ActsExamples/TelescopeDetector/TelescopeDetector.hpp

@@ -12,10 +12,9 @@
 #include "Acts/Geometry/GeometryContext.hpp"
 #include "Acts/Surfaces/Surface.hpp"
 #include "Acts/Surfaces/SurfacePlacementBase.hpp"
+#include "ActsExamples/DetectorCommons/AlignmentContext.hpp"
 
 #include <memory>
-#include <utility>
-#include <vector>
 
 namespace Acts {
 class Surface;
@@ -42,14 +41,6 @@ class TelescopeDetectorElement : public Acts::SurfacePlacementBase {
   using identifier_diff = long long;
   using Identifier = identifier_type;
 
-  using DetectorElementFactory =
-      std::function<std::shared_ptr<TelescopeDetectorElement>(
-          const Acts::Transform3&,
-          std::variant<std::shared_ptr<const Acts::PlanarBounds>,
-                       std::shared_ptr<const Acts::DiscBounds>>,
-          double, std::shared_ptr<const Acts::ISurfaceMaterial>,
-          std::vector<std::shared_ptr<const Acts::SurfacePlacementBase>>&)>;
-
   /// Constructor for single sided detector element
   /// - bound to a Plane Surface
   ///
@@ -105,18 +96,6 @@ class TelescopeDetectorElement : public Acts::SurfacePlacementBase {
     return nominalTransform();
   }
 
-  /// Return local to global transform associated with this identifier
-  ///
-  /// @param alignedTransform is a new transform
-  /// @param iov is the batch for which it is meant
-  void addAlignedTransform(std::unique_ptr<Acts::Transform3> alignedTransform,
-                           unsigned int iov);
-
-  /// Return the set of alignment transforms in flight
-  const std::vector<std::unique_ptr<Acts::Transform3>>& alignedTransforms()
-      const {
-    return m_alignedTransforms;
-  };
   /// Is the detector element a sensitive element
   bool isSensitive() const final { return true; }
 
@@ -128,8 +107,6 @@ class TelescopeDetectorElement : public Acts::SurfacePlacementBase {
   Identifier m_elementIdentifier;
   /// the transform for positioning in 3D space
   std::shared_ptr<const Acts::Transform3> m_elementTransform = nullptr;
-  // the aligned transforms
-  std::vector<std::unique_ptr<Acts::Transform3>> m_alignedTransforms = {};
   /// the surface represented by it
   std::shared_ptr<Acts::Surface> m_elementSurface = nullptr;
   /// the element thickness
@@ -155,28 +132,24 @@ inline double TelescopeDetectorElement::thickness() const {
 inline const Acts::Transform3& TelescopeDetectorElement::localToGlobalTransform(
     const Acts::GeometryContext& gctx) const {
   // Check if a different transform than the nominal exists
-  if (!m_alignedTransforms.empty()) {
-    // cast into the right context object
-    auto alignContext = gctx.get<ContextType>();
-    return (*m_alignedTransforms[alignContext.iov].get());
+  if (gctx.hasValue()) {
+    const auto* alignmentContext = gctx.maybeGet<AlignmentContext>();
+    if (alignmentContext != nullptr && alignmentContext->store != nullptr) {
+      const auto* transform =
+          alignmentContext->store->contextualTransform(this->surface());
+      // The store may only have a subset of surfaces registered
+      if (transform != nullptr) {
+        return *transform;
+      }
+    }
   }
-  // Return the standard transform if not found
-  return nominalTransform(gctx);
+  // If no alignment context is available, return the nominal transform
+  return nominalTransform();
 }
 
 inline const Acts::Transform3& TelescopeDetectorElement::nominalTransform()
     const {
   return *m_elementTransform;
 }
 
-inline void TelescopeDetectorElement::addAlignedTransform(
-    std::unique_ptr<Acts::Transform3> alignedTransform, unsigned int iov) {
-  // most standard case, it's just a new one:
-  auto cios = m_alignedTransforms.size();
-  for (unsigned int ic = cios; ic <= iov; ++ic) {
-    m_alignedTransforms.push_back(nullptr);
-  }
-  m_alignedTransforms[iov] = std::move(alignedTransform);
-}
-
 }  // namespace ActsExamples

Examples/Detectors/TelescopeDetector/include/ActsExamples/TelescopeDetector/TelescopeDetectorElement.hpp

@@ -29,6 +29,7 @@
 #include "Acts/Surfaces/SurfaceArray.hpp"
 #include "Acts/Surfaces/SurfacePlacementBase.hpp"
 #include "Acts/Utilities/Logger.hpp"
+#include "ActsExamples/TelescopeDetector/TelescopeDetectorElement.hpp"
 
 #include <algorithm>
 #include <cstddef>
@@ -37,7 +38,6 @@
 std::unique_ptr<const Acts::TrackingGeometry>
 ActsExamples::buildTelescopeDetector(
     const Acts::GeometryContext& gctx,
-    const TelescopeDetectorElement::DetectorElementFactory& factory,
     std::vector<std::shared_ptr<const Acts::SurfacePlacementBase>>&
         detectorStore,
     const std::vector<double>& positions,
@@ -91,13 +91,21 @@ ActsExamples::buildTelescopeDetector(
 
     // Create the detector element
     std::shared_ptr<TelescopeDetectorElement> detElement = nullptr;
+
+    const auto id =
+        static_cast<TelescopeDetectorElement::Identifier>(detectorStore.size());
+
     if (surfaceType == TelescopeSurfaceType::Plane) {
-      detElement =
-          factory(trafo, pBounds, 1._um, surfaceMaterial, detectorStore);
+      detElement = std::make_shared<TelescopeDetectorElement>(
+          id, std::make_shared<Acts::Transform3>(trafo), pBounds, 1._um,
+          surfaceMaterial);
     } else {
-      detElement =
-          factory(trafo, rBounds, 1._um, surfaceMaterial, detectorStore);
+      detElement = std::make_shared<TelescopeDetectorElement>(
+          id, std::make_shared<Acts::Transform3>(trafo), rBounds, 1._um,
+          surfaceMaterial);
     }
+    detectorStore.push_back(detElement);
+
     // Get the surface
     auto surface = detElement->surface().getSharedPtr();
     // Add the detector element to the detector store

Examples/Detectors/TelescopeDetector/src/AlignedTelescopeDetector.cpp

@@ -10,7 +10,6 @@
 
 #include "Acts/Geometry/GeometryContext.hpp"
 #include "ActsExamples/TelescopeDetector/BuildTelescopeDetector.hpp"
-#include "ActsExamples/TelescopeDetector/TelescopeDetectorElement.hpp"
 
 #include <stdexcept>
 
@@ -41,37 +40,10 @@ TelescopeDetector::TelescopeDetector(const Config& cfg)
 
   m_nominalGeometryContext =
       Acts::GeometryContext::dangerouslyDefaultConstruct();
-  auto detectorElementFactory =
-      [](const Acts::Transform3& transform,
-         std::variant<std::shared_ptr<const Acts::PlanarBounds>,
-                      std::shared_ptr<const Acts::DiscBounds>>
-             bounds,
-         double thickness,
-         std::shared_ptr<const Acts::ISurfaceMaterial> material,
-         std::vector<std::shared_ptr<const Acts::SurfacePlacementBase>>&
-             detStore) {
-        auto ID =
-            static_cast<TelescopeDetectorElement::Identifier>(detStore.size());
-
-        std::shared_ptr<TelescopeDetectorElement> detElem;
-        if (bounds.index() == 0) {
-          detElem = std::make_shared<TelescopeDetectorElement>(
-              ID, std::make_shared<Acts::Transform3>(transform),
-              std::get<std::shared_ptr<const Acts::PlanarBounds>>(bounds),
-              thickness, std::move(material));
-        } else {
-          detElem = std::make_shared<TelescopeDetectorElement>(
-              ID, std::make_shared<Acts::Transform3>(transform),
-              std::get<std::shared_ptr<const Acts::DiscBounds>>(bounds),
-              thickness, std::move(material));
-        }
-        detStore.push_back(detElem);
-        return detElem;
-      };
   m_trackingGeometry = buildTelescopeDetector(
-      m_nominalGeometryContext, detectorElementFactory, m_detectorStore,
-      m_cfg.positions, m_cfg.stereos, m_cfg.offsets, m_cfg.bounds,
-      m_cfg.thickness, static_cast<TelescopeSurfaceType>(m_cfg.surfaceType),
+      m_nominalGeometryContext, m_detectorStore, m_cfg.positions, m_cfg.stereos,
+      m_cfg.offsets, m_cfg.bounds, m_cfg.thickness,
+      static_cast<TelescopeSurfaceType>(m_cfg.surfaceType),
       static_cast<Acts::AxisDirection>(m_cfg.binValue));
 }
 

Examples/Detectors/TelescopeDetector/src/BuildTelescopeDetector.cpp

@@ -10,7 +10,6 @@
 
 from acts.examples import (
     TelescopeDetector,
-    AlignedTelescopeDetector,
     Sequencer,
     StructureSelector,
     RandomNumbers,
@@ -70,18 +69,13 @@
 #
 # In the alignment, at least 4 layers are expected (layer ID 8 will
 # be fixed as the alignment reference).
-def getTelescopeDetector(misaligned: bool = False):
+def getTelescopeDetector():
     bounds = [200, 200]
     positions = [30, 60, 90, 120, 150, 180, 210, 240, 270]
     stereos = [0] * len(positions)
-    if not misaligned:
-        detector = TelescopeDetector(
-            bounds=bounds, positions=positions, stereos=stereos, binValue=1
-        )
-    else:
-        detector = AlignedTelescopeDetector(
-            bounds=bounds, positions=positions, stereos=stereos, binValue=1
-        )
+    detector = TelescopeDetector(
+        bounds=bounds, positions=positions, stereos=stereos, binValue=1
+    )
 
     return detector
 
@@ -158,7 +152,7 @@ def addSolverFromMille(
 os.makedirs(outputDir, exist_ok=True)
 
 # Instantiate the telescope detector - with alignment enabled
-detector = getTelescopeDetector(misaligned=True)
+detector = getTelescopeDetector()
 trackingGeometry = detector.trackingGeometry()
 decorators = detector.contextDecorators()
 

Examples/Detectors/TelescopeDetector/src/TelescopeDetector.cpp

@@ -16,7 +16,6 @@
 #include "ActsExamples/Framework/IContextDecorator.hpp"
 #include "ActsExamples/GenericDetector/AlignedGenericDetector.hpp"
 #include "ActsExamples/GenericDetector/GenericDetector.hpp"
-#include "ActsExamples/TelescopeDetector/AlignedTelescopeDetector.hpp"
 #include "ActsExamples/TelescopeDetector/TelescopeDetector.hpp"
 #include "ActsExamples/Utilities/Options.hpp"
 #include "ActsPython/Utilities/Helpers.hpp"
@@ -92,12 +91,6 @@ void addDetector(py::module& mex) {
     ACTS_PYTHON_STRUCT(c, positions, stereos, offsets, bounds, thickness,
                        surfaceType, binValue, materialDecorator, logLevel);
   }
-  {
-    auto ad = py::class_<AlignedTelescopeDetector, TelescopeDetector,
-                         std::shared_ptr<AlignedTelescopeDetector>>(
-                  mex, "AlignedTelescopeDetector")
-                  .def(py::init<const TelescopeDetector::Config&>());
-  }
 }
 
 }  // namespace ActsPython