fix: Return nullptr if outside tracking geometry in TrackingGeometry::lowestTrackingVolume

Core/include/Acts/Geometry/TrackingVolume.hpp

@@ -452,7 +452,7 @@ class TrackingVolume : public Volume {
   /// static layers
   std::unique_ptr<const LayerArray> m_confinedLayers = nullptr;
 
-  /// Array of Volumes inside the Volume when actin as container
+  /// Array of Volumes inside the Volume when acting as container
   std::shared_ptr<const TrackingVolumeArray> m_confinedVolumes = nullptr;
 
   /// confined dense

Core/include/Acts/Propagator/Navigator.hpp

@@ -319,6 +319,11 @@ class Navigator {
               : nullptr;
       if (state.navigation.startVolume != nullptr) {
         ACTS_VERBOSE(volInfo(state) << "Start volume resolved.");
+      } else {
+        ACTS_VERBOSE(volInfo(state)
+                     << "No start volume resolved. Nothing left to do.");
+        // set the navigation break
+        state.navigation.navigationBreak = true;
       }
     }
 

Core/include/Acts/TrackFitting/GlobalChiSquareFitter.hpp

@@ -423,6 +423,25 @@ class Gx2Fitter {
                     const Logger& /*logger*/) const {
       assert(result.fittedStates && "No MultiTrajectory set");
 
+      // Sanity check in the pre propagation phase
+      if (state.stage == PropagatorStage::prePropagation) {
+        // Check if we are in the expected volume
+        if (startVolume != nullptr &&
+            startVolume != state.navigation.startVolume) {
+          ACTS_INFO("The update pushed us to a new volume from '"
+                    << startVolume->volumeName() << "' to '"
+                    << ((state.navigation.startVolume != nullptr)
+                            ? state.navigation.startVolume->volumeName()
+                            : "nullptr")
+                    << "'. Starting to abort.");
+          result.result =
+              Result<void>(Experimental::GlobalChiSquareFitterError::
+                               UpdatePushedToNewVolume);
+          return;
+        }
+        result.startVolume = state.navigation.startVolume;
+      }
+
       // Check if we can stop to propagate
       if (result.measurementStates == inputMeasurements->size()) {
         ACTS_INFO("Actor: finish: All measurements have been found.");
@@ -442,19 +461,6 @@ class Gx2Fitter {
         return;
       }
 
-      if (startVolume != nullptr &&
-          startVolume != state.navigation.startVolume) {
-        ACTS_INFO("The update pushed us to a new volume from '"
-                  << startVolume->volumeName() << "' to '"
-                  << state.navigation.startVolume->volumeName()
-                  << "'. Starting to abort.");
-        result.result = Result<void>(
-            Experimental::GlobalChiSquareFitterError::UpdatePushedToNewVolume);
-
-        return;
-      }
-      result.startVolume = state.navigation.startVolume;
-
       // Update:
       // - Waiting for a current surface
       auto surface = navigator.currentSurface(state.navigation);

Core/src/Geometry/TrackingGeometry.cpp

@@ -42,13 +42,7 @@ Acts::TrackingGeometry::~TrackingGeometry() = default;
 
 const Acts::TrackingVolume* Acts::TrackingGeometry::lowestTrackingVolume(
     const GeometryContext& gctx, const Acts::Vector3& gp) const {
-  const TrackingVolume* searchVolume = m_world.get();
-  const TrackingVolume* currentVolume = nullptr;
-  while (currentVolume != searchVolume && (searchVolume != nullptr)) {
-    currentVolume = searchVolume;
-    searchVolume = searchVolume->lowestTrackingVolume(gctx, gp);
-  }
-  return currentVolume;
+  return m_world->lowestTrackingVolume(gctx, gp);
 }
 
 const Acts::TrackingVolume* Acts::TrackingGeometry::highestTrackingVolume()
@@ -63,7 +57,10 @@ Acts::TrackingGeometry::highestTrackingVolumeShared() const {
 
 const Acts::Layer* Acts::TrackingGeometry::associatedLayer(
     const GeometryContext& gctx, const Acts::Vector3& gp) const {
-  const TrackingVolume* lowestVol = (lowestTrackingVolume(gctx, gp));
+  const TrackingVolume* lowestVol = lowestTrackingVolume(gctx, gp);
+  if (lowestVol == nullptr) {
+    return nullptr;
+  }
   return lowestVol->associatedLayer(gctx, gp);
 }
 

Core/src/Geometry/TrackingVolume.cpp

@@ -64,11 +64,18 @@ TrackingVolume::TrackingVolume(const Transform3& transform,
 TrackingVolume::~TrackingVolume() = default;
 
 const TrackingVolume* TrackingVolume::lowestTrackingVolume(
-    const GeometryContext& /*gctx*/, const Vector3& position,
+    const GeometryContext& gctx, const Vector3& position,
     const double tol) const {
+  if (!inside(position, tol)) {
+    return nullptr;
+  }
+
   // confined static volumes - highest hierarchy
   if (m_confinedVolumes) {
-    return (m_confinedVolumes->object(position).get());
+    const TrackingVolume* volume = m_confinedVolumes->object(position).get();
+    if (volume != nullptr) {
+      return volume->lowestTrackingVolume(gctx, position, tol);
+    }
   }
 
   // search for dense volumes

Examples/Algorithms/Geant4/include/ActsExamples/Geant4/SensitiveSurfaceMapper.hpp

@@ -41,17 +41,19 @@ struct SensitiveCandidates {
   /// @return a vector of sensitive surfaces
   std::vector<const Acts::Surface*> operator()(
       const Acts::GeometryContext& gctx, const Acts::Vector3& position) const {
-    std::vector<const Acts::Surface*> surfaces;
+    if (trackingGeometry == nullptr) {
+      return {};
+    }
 
-    if (trackingGeometry != nullptr) {
-      auto layer = trackingGeometry->associatedLayer(gctx, position);
+    auto layer = trackingGeometry->associatedLayer(gctx, position);
+    if (layer == nullptr || layer->surfaceArray() == nullptr) {
+      return {};
+    }
 
-      if (layer->surfaceArray() != nullptr) {
-        for (const auto& surface : layer->surfaceArray()->surfaces()) {
-          if (surface->associatedDetectorElement() != nullptr) {
-            surfaces.push_back(surface);
-          }
-        }
+    std::vector<const Acts::Surface*> surfaces;
+    for (const auto& surface : layer->surfaceArray()->surfaces()) {
+      if (surface->associatedDetectorElement() != nullptr) {
+        surfaces.push_back(surface);
       }
     }
     return surfaces;

Tests/UnitTests/Core/Geometry/CuboidVolumeBuilderTests.cpp

@@ -226,13 +226,16 @@ BOOST_AUTO_TEST_CASE(CuboidVolumeBuilderTest) {
   std::unique_ptr<const TrackingGeometry> detector =
       tgb.trackingGeometry(tgContext);
   BOOST_CHECK_EQUAL(
-      detector->lowestTrackingVolume(tgContext, Vector3(1., 0., 0.))
+      detector->lowestTrackingVolume(tgContext, Vector3(1_mm, 0_mm, 0_mm))
           ->volumeName(),
       volumeConfig.name);
   BOOST_CHECK_EQUAL(
-      detector->lowestTrackingVolume(tgContext, Vector3(-1., 0., 0.))
+      detector->lowestTrackingVolume(tgContext, Vector3(-1_mm, 0_mm, 0_mm))
           ->volumeName(),
       volumeConfig2.name);
+  BOOST_CHECK_EQUAL(
+      detector->lowestTrackingVolume(tgContext, Vector3(1000_m, 0_m, 0_m)),
+      nullptr);
 }
 
 }  // namespace Acts::Test

Tests/UnitTests/Core/TrackFitting/Gx2fTests.cpp

@@ -291,16 +291,14 @@ std::shared_ptr<const TrackingGeometry> makeToyDetectorYdirection(
   //    volumeConfig2.length = volumeConfig.length;
   volumeConfig2.length = {2 * halfSizeSurface, (nSurfaces + 1) * 1_m,
                           2 * halfSizeSurface};
-  ;
   volumeConfig2.position = {volumeConfig2.length.x(),
                             volumeConfig2.length.y() / 2, 0.};
   volumeConfig2.name = "AdditionalVolume";
   volumeConfig2.binningDimension = Acts::BinningValue::binY;
 
   // Outer volume - Build TrackingGeometry configuration and fill
   CuboidVolumeBuilder::Config config;
-  config.length = {4 * halfSizeSurface, (nSurfaces + 1) * 1_m,
-                   2 * halfSizeSurface};
+  config.length = {10_m, 10_m, 10_m};
   config.position = {volumeConfig.length.x() / 2, volumeConfig.length.y() / 2,
                      0.};
   config.volumeCfg = {volumeConfig, volumeConfig2};