Cleanup indextable configuration

Author: mpuccio

Detectors/ITSMFT/common/tracking/include/ITSMFTTracking/IndexTableConfiguration.h

@@ -12,10 +12,8 @@
 #ifndef ALICEO2_ITSMFT_TRACKING_INDEXTABLECONFIGURATION_H_
 #define ALICEO2_ITSMFT_TRACKING_INDEXTABLECONFIGURATION_H_
 
-#include <cstdint>
-
 // Host-only: DetectorParameters owns std::vector members and is not
-// device-compatible. Keep this boundary separate so existing host-binding
+// device-compatible. Keep this boundary separate so existing host-configuration
 // consumers do not inherit IndexTableUtils.h's extra dependencies.
 #ifndef GPUCA_GPUCODE
 
@@ -30,27 +28,16 @@
 namespace o2::itsmft::tracking
 {
 
-enum class IndexTableConfigError : uint8_t {
-  None,
-  NonPositiveRowBins,
-  NonPositiveColBins,
-  RowColBinCountExceedsIndexRange, // Product exceeds int, the bin-index type.
-  InvalidActiveLayerCount,         // Invalid active surface count.
-  InsufficientChartRanges,         // Fewer descriptor chart ranges than active surfaces.
-  NonFiniteChartRange,             // Chart bound is NaN or +/-Inf.
-  InvalidChartRange,               // Chart maximum does not exceed its minimum.
-  InvalidSurfaceKind,              // Neither Cylinder nor Disk.
-};
-
-/// Validates and binds detector inputs into `staged` for one coordinate kind.
+/// Validates detector inputs and configures `destination` for one coordinate kind.
 /// Resolve `kind` from the validated DetectorConfiguration, never from NLayers or DetId.
-/// On error, `staged` is unchanged. Call once per present kind during detector
+/// Returns true on success; on failure, returns false and leaves `destination` unchanged.
+/// Call once per present kind during detector
 /// initialization, outside iteration and candidate loops.
-IndexTableConfigError bindIndexTableConfiguration(o2::itsmft::IndexTableUtilsCore& staged,
-                                                  const DetectorParameters& params,
-                                                  int activeSurfaceCount,
-                                                  SurfaceKind kind,
-                                                  gsl::span<const SurfaceChartRange> chartRanges) noexcept;
+bool configureIndexTableUtils(o2::itsmft::IndexTableUtilsCore& destination,
+                              const DetectorParameters& params,
+                              int activeSurfaceCount,
+                              SurfaceKind kind,
+                              gsl::span<const SurfaceChartRange> chartRanges) noexcept;
 
 /// True iff all fields stored by setIndexTableParams match between `a` and
 /// `b`. Used to verify that a non-FirstPass iteration matches the

Detectors/ITSMFT/common/tracking/src/IndexTableConfiguration.cxx

@@ -23,52 +23,52 @@ namespace o2::itsmft::tracking
 
 using o2::itsmft::IndexTableCoordType;
 
-IndexTableConfigError bindIndexTableConfiguration(o2::itsmft::IndexTableUtilsCore& staged,
-                                                  const DetectorParameters& params,
-                                                  int activeSurfaceCount,
-                                                  SurfaceKind kind,
-                                                  gsl::span<const SurfaceChartRange> chartRanges) noexcept
+bool configureIndexTableUtils(o2::itsmft::IndexTableUtilsCore& destination,
+                              const DetectorParameters& params,
+                              int activeSurfaceCount,
+                              SurfaceKind kind,
+                              gsl::span<const SurfaceChartRange> chartRanges) noexcept
 {
   if (kind != SurfaceKind::Cylinder && kind != SurfaceKind::Disk) {
-    return IndexTableConfigError::InvalidSurfaceKind;
+    return false;
   }
   if (!(activeSurfaceCount > 0 && activeSurfaceCount <= o2::itsmft::IndexTableUtilsCore::MaxLayers)) {
-    return IndexTableConfigError::InvalidActiveLayerCount;
+    return false;
   }
   if (params.RowBins <= 0) {
-    return IndexTableConfigError::NonPositiveRowBins;
+    return false;
   }
   if (params.ColBins <= 0) {
-    return IndexTableConfigError::NonPositiveColBins;
+    return false;
   }
 
   const std::uint64_t binCount = static_cast<std::uint64_t>(params.RowBins) * static_cast<std::uint64_t>(params.ColBins);
   if (binCount > static_cast<std::uint64_t>(std::numeric_limits<int>::max())) {
-    return IndexTableConfigError::RowColBinCountExceedsIndexRange;
+    return false;
   }
 
   if (chartRanges.size() < static_cast<std::size_t>(activeSurfaceCount)) {
-    return IndexTableConfigError::InsufficientChartRanges;
+    return false;
   }
   std::array<float, o2::itsmft::IndexTableUtilsCore::MaxLayers> colMin{};
   std::array<float, o2::itsmft::IndexTableUtilsCore::MaxLayers> colMax{};
   for (int iLayer = 0; iLayer < activeSurfaceCount; ++iLayer) {
     if (!o2::gpu::GPUCommonMath::Finite(chartRanges[iLayer].min) ||
         !o2::gpu::GPUCommonMath::Finite(chartRanges[iLayer].max)) {
-      return IndexTableConfigError::NonFiniteChartRange;
+      return false;
     }
     if (!(chartRanges[iLayer].max > chartRanges[iLayer].min)) {
-      return IndexTableConfigError::InvalidChartRange;
+      return false;
     }
     colMin[iLayer] = chartRanges[iLayer].min;
     colMax[iLayer] = chartRanges[iLayer].max;
   }
 
-  staged.setIndexTableParams(kind == SurfaceKind::Disk ? IndexTableCoordType::PhiR : IndexTableCoordType::PhiZ,
-                             params.RowBins, params.ColBins, 0.f, o2::constants::math::TwoPI,
-                             gsl::span<const float>{colMin.data(), static_cast<std::size_t>(activeSurfaceCount)},
-                             gsl::span<const float>{colMax.data(), static_cast<std::size_t>(activeSurfaceCount)});
-  return IndexTableConfigError::None;
+  destination.setIndexTableParams(kind == SurfaceKind::Disk ? IndexTableCoordType::PhiR : IndexTableCoordType::PhiZ,
+                                  params.RowBins, params.ColBins, 0.f, o2::constants::math::TwoPI,
+                                  gsl::span<const float>{colMin.data(), static_cast<std::size_t>(activeSurfaceCount)},
+                                  gsl::span<const float>{colMax.data(), static_cast<std::size_t>(activeSurfaceCount)});
+  return true;
 }
 
 } // namespace o2::itsmft::tracking

Detectors/ITSMFT/common/tracking/src/Tracker.cxx

@@ -145,8 +145,8 @@ void prepareDetectorConfiguration(DetectorConfiguration& configuration, const De
   const gsl::span<const SurfaceChartRange> chartRangeView{chartRanges.data(), surfaceCount};
   for (const auto kind : {SurfaceKind::Cylinder, SurfaceKind::Disk}) {
     if (configuration.indexTableConfigs.hasKind(kind) &&
-        bindIndexTableConfiguration(configuration.indexTableConfigs.forKind(kind), parameters,
-                                    static_cast<int>(surfaceCount), kind, chartRangeView) != IndexTableConfigError::None) {
+        !configureIndexTableUtils(configuration.indexTableConfigs.forKind(kind), parameters,
+                                  static_cast<int>(surfaceCount), kind, chartRangeView)) {
       throw std::invalid_argument{"CA traversal: invalid index table configuration"};
     }
   }

Detectors/ITSMFT/common/tracking/test/testMFTCATrackingConfiguration.cxx

@@ -171,7 +171,7 @@ BOOST_AUTO_TEST_CASE(PublicMFTIndexBinsControlRadiusAndPhiLookup)
   std::array<SurfaceChartRange, MFTNLayers> ranges;
   ranges.fill({0.f, 16.f});
   IndexTableUtilsCore index;
-  BOOST_REQUIRE(bindIndexTableConfiguration(index, parameters, MFTNLayers, SurfaceKind::Disk, ranges) == IndexTableConfigError::None);
+  BOOST_REQUIRE(configureIndexTableUtils(index, parameters, MFTNLayers, SurfaceKind::Disk, ranges));
   BOOST_CHECK(index.getCoordType() == IndexTableCoordType::PhiR);
   BOOST_CHECK_EQUAL(index.getRowBinIndex(o2::constants::math::PI), 12);
   BOOST_CHECK_EQUAL(index.getColBinIndex(0, 8.f), 16);