refactor: Explicit default construction for GeometryContext (acts-project#4957)

This pull request refactors the way default `GeometryContext` objects are constructed and used throughout the codebase. The main change is to deprecate the use of the default `GeometryContext` constructor and replace it with an explicit factory method, `GeometryContext::dangerouslyDefaultConstruct()`. This makes the creation of empty or default geometry contexts more intentional and clear, especially for testing and simple use cases.

Author: paulgessinger

Core/include/Acts/EventData/detail/MultiTrajectoryTestsCommon.hpp

@@ -466,7 +466,7 @@ class MultiTrajectoryTestsCommon {
 
     // use temporary measurement to reset calibrated data
     TestTrackState ttsb(rng, 2u);
-    Acts::GeometryContext gctx;
+    const auto gctx = Acts::GeometryContext::dangerouslyDefaultConstruct();
     Acts::CalibrationContext cctx;
     BOOST_CHECK_EQUAL(
         ts.getUncalibratedSourceLink().template get<TestSourceLink>().sourceId,

Core/include/Acts/EventData/detail/TestTrackState.hpp

@@ -126,9 +126,9 @@ void fillTrackState(const TestTrackState& pc, TrackStatePropMask mask,
   // source link defines the uncalibrated measurement
   // create calibrated measurements from source link
   if (ACTS_CHECK_BIT(mask, TrackStatePropMask::Calibrated)) {
-    testSourceLinkCalibrator<trajectory_t>(Acts::GeometryContext{},
-                                           Acts::CalibrationContext{},
-                                           SourceLink{pc.sourceLink}, ts);
+    testSourceLinkCalibrator<trajectory_t>(
+        Acts::GeometryContext::dangerouslyDefaultConstruct(),
+        Acts::CalibrationContext{}, SourceLink{pc.sourceLink}, ts);
     assert(ts.hasUncalibratedSourceLink());
   }
 }

Core/include/Acts/Geometry/GeometryContext.hpp

@@ -9,6 +9,7 @@
 #pragma once
 
 // Set the Geometry Context PLUGIN
+#include "Acts/Utilities/Diagnostics.hpp"
 #ifdef ACTS_CORE_GEOMETRYCONTEXT_PLUGIN
 #include ACTS_CORE_GEOMETRYCONTEXT_PLUGIN
 #else
@@ -25,11 +26,57 @@ namespace Acts {
 /// @ingroup context
 ///
 /// It is propagated through the code to allow for event/thread
-/// dependent geometry changes
+/// dependent geometry changes.
+///
+/// ## Construction
+///
+/// For typical use cases with alignment or conditions data:
+/// @code
+/// MyAlignmentData alignment = ...;
+/// GeometryContext gctx{alignment};
+/// @endcode
+///
+/// For testing or simple applications without alignment:
+/// @code
+/// auto gctx = GeometryContext::dangerouslyDefaultConstruct();
+/// @endcode
+///
+/// @note The default constructor is deprecated. Use the factory method
+///       dangerouslyDefaultConstruct() to make empty context creation explicit.
 class GeometryContext : public ContextType {
  public:
-  /// Inherit all constructors
-  using ContextType::ContextType;
+  /// Static factory method for default construction
+  /// @note Use this when you need a default context for testing or
+  ///       simple applications without alignment/conditions data
+  static GeometryContext dangerouslyDefaultConstruct() {
+    ACTS_PUSH_IGNORE_DEPRECATED()
+    return GeometryContext();
+    ACTS_POP_IGNORE_DEPRECATED()
+  }
+
+  /// Default constructor
+  /// @deprecated Use GeometryContext::dangerouslyDefaultConstruct() instead
+  ///             to make empty context construction explicit
+  [[deprecated("Use GeometryContext::dangerouslyDefaultConstruct() instead")]]
+  GeometryContext() = default;
+
+  /// Move construct from arbitrary type (inherited from ContextType)
+  /// @tparam T The type of the value to construct from
+  /// @param value The value to construct from
+  template <typename T>
+    requires(!std::is_same_v<std::decay_t<T>, GeometryContext> &&
+             !std::is_base_of_v<ContextType, std::decay_t<T> >)
+  explicit GeometryContext(T&& value) : ContextType(std::forward<T>(value)) {}
+
+  /// Copy construct from arbitrary type (inherited from ContextType)
+  /// @tparam T The type of the value to construct from
+  /// @param value The value to construct from
+  template <typename T>
+    requires(!std::is_same_v<std::decay_t<T>, GeometryContext> &&
+             !std::is_base_of_v<ContextType, std::decay_t<T> >)
+  explicit GeometryContext(const T& value) : ContextType(value) {}
+
+  /// Inherit assignment operators
   using ContextType::operator=;
 };
 

Core/include/Acts/Material/BinnedSurfaceMaterialAccumulater.hpp

@@ -26,7 +26,7 @@ class BinnedSurfaceMaterialAccumulater final
   /// @brief Nested config struct
   struct Config {
     /// Geometry context for coordinate transformations
-    GeometryContext geoContext;
+    GeometryContext geoContext = GeometryContext::dangerouslyDefaultConstruct();
 
     /// Correct for empty bins (recommended)
     bool emptyBinCorrection = true;

Core/include/Acts/Surfaces/SurfaceArray.hpp

@@ -203,7 +203,7 @@ class SurfaceArray {
     /// @param bin the global bin index
     /// @return The bin center
     Vector3 getBinCenter(std::size_t bin) const override {
-      GeometryContext gctx;
+      auto gctx = GeometryContext::dangerouslyDefaultConstruct();
       return getBinCenterImpl(gctx, bin);
     }
 
@@ -355,7 +355,7 @@ class SurfaceArray {
 
     std::size_t findGlobalBin(const Vector3& position, const Vector3& direction,
                               double tolerance) const {
-      GeometryContext gctx;
+      auto gctx = GeometryContext::dangerouslyDefaultConstruct();
 
       const Intersection3D intersection =
           m_representative

Core/include/Acts/TrackFinding/TrackParamsLookupAccumulator.hpp

@@ -78,7 +78,7 @@ class TrackParamsLookupAccumulator {
   LookupGrid finalizeLookup() {
     auto meanTrack = [&](const TrackParameters& track, std::size_t count) {
       if constexpr (detail::isGenericBoundTrackParams<TrackParameters>) {
-        Acts::GeometryContext gctx;
+        const auto gctx = Acts::GeometryContext::dangerouslyDefaultConstruct();
 
         auto res = TrackParameters::create(
             gctx, track.referenceSurface().getSharedPtr(),
@@ -146,7 +146,7 @@ class TrackParamsLookupAccumulator {
 
     // Assume track parameters being i.i.d.
     if constexpr (detail::isGenericBoundTrackParams<TrackParameters>) {
-      Acts::GeometryContext gctx;
+      const auto gctx = Acts::GeometryContext::dangerouslyDefaultConstruct();
 
       Acts::Vector4 fourPosition = a.fourPosition(gctx) + b.fourPosition(gctx);
 

Core/include/Acts/TrackFitting/GaussianSumFitter.hpp

@@ -245,8 +245,9 @@ struct GaussianSumFitter {
     // Check if the start parameters are on the start surface
     IntersectionStatus intersectionStatusStartSurface =
         sParameters.referenceSurface()
-            .intersect(GeometryContext{},
-                       sParameters.position(GeometryContext{}),
+            .intersect(GeometryContext::dangerouslyDefaultConstruct(),
+                       sParameters.position(
+                           GeometryContext::dangerouslyDefaultConstruct()),
                        sParameters.direction(), BoundaryTolerance::None())
             .closest()
             .status();

Core/include/Acts/Utilities/BinAdjustment.hpp

@@ -256,7 +256,7 @@ static inline BinUtility adjustBinUtility(const BinUtility& bu,
   }
 
   std::stringstream ss;
-  ss << surface.toStream({});
+  ss << surface.toStream(GeometryContext::dangerouslyDefaultConstruct());
   throw std::invalid_argument(
       "Bin adjustment not implemented for this surface yet:\n" + ss.str());
 }

Core/include/Acts/Utilities/Diagnostics.hpp

@@ -32,3 +32,9 @@
 #define ACTS_DIAGNOSTIC_POP() _ACTS_DO_PRAGMA(GCC diagnostic pop)
 
 #endif
+
+#define ACTS_PUSH_IGNORE_DEPRECATED() \
+  ACTS_DIAGNOSTIC_PUSH()              \
+  ACTS_DIAGNOSTIC_IGNORE("-Wdeprecated-declarations")
+
+#define ACTS_POP_IGNORE_DEPRECATED() ACTS_DIAGNOSTIC_POP()

Core/include/Acts/Utilities/detail/ContextType.hpp

@@ -30,13 +30,15 @@ class ContextType {
   /// @tparam T The type of the value to construct from
   /// @param value The value to construct from
   template <typename T>
+    requires(!std::is_base_of_v<ContextType, std::decay_t<T>>)
   explicit ContextType(T&& value) : m_data{std::forward<T>(value)} {}
 
   /// Copy construct a new Context Type object from anything. Must be explicit.
   ///
   /// @tparam T The type of the value to construct from
   /// @param value The value to construct from
   template <typename T>
+    requires(!std::is_base_of_v<ContextType, std::decay_t<T>>)
   explicit ContextType(const T& value) : m_data{value} {}
 
   /// Move assignment of anything to this object is allowed.
@@ -45,6 +47,7 @@ class ContextType {
   /// @param value The value to assign
   /// @return ContextType&
   template <typename T>
+    requires(!std::is_base_of_v<ContextType, std::decay_t<T>>)
   ContextType& operator=(T&& value) {
     m_data = std::forward<T>(value);
     return *this;
@@ -56,6 +59,7 @@ class ContextType {
   /// @param value The value to assign
   /// @return ContextType&
   template <typename T>
+    requires(!std::is_base_of_v<ContextType, std::decay_t<T>>)
   ContextType& operator=(const T& value) {
     m_data = value;
     return *this;