Further IOUtils cleanup

Author: mpuccio

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

@@ -35,10 +35,8 @@
 #include "DataFormatsITSMFT/TopologyDictionary.h"
 #include "ITSMFTTracking/GlobalMeasurement.h"
 #include "ITSMFTTracking/Configuration.h"
-#include "ITSMFTTracking/ROFViews.h"
 #include "ITSMFTTracking/SurfaceDescriptor.h"
 #include "ITSMFTTracking/SurfaceMeasurement.h"
-#include "ITSMFTTracking/SurfaceTiming.h"
 #include "MathUtils/Cartesian.h"
 #include "SimulationDataFormat/MCTruthContainer.h"
 
@@ -126,26 +124,26 @@ struct ClusterSourceInput {
   const o2::itsmft::TopologyDictionary* dictionary{nullptr};
   const o2::dataformats::MCTruthContainer<o2::MCCompLabel>* labels{nullptr};
   gsl::span<const LayerId> layerToSurface{};
-  ROFTimingConfig timing{};
-  RuntimeROFViews rofViews{};
 };
 
 /// Reset, decode, and normalize all sources into a configured TimeFrame.
+/// ROF records supply cluster ranges only. The workflow binds runtime ROF views
+/// after loading and owns timing validation independently.
 /// Invalid input throws. On failure, the caller must reset the frame before
 /// reuse; partially loaded data must not be published.
 void loadTimeFrameSources(TimeFrame&, gsl::span<const ClusterSourceInput>,
-                          SurfaceCatalogView, const o2::InteractionRecord&,
+                          SurfaceCatalogView,
                           std::vector<std::vector<uint32_t>>* externalIndicesBySurface = nullptr,
                           std::vector<std::vector<uint32_t>>* clusterSizesBySurface = nullptr);
 
 namespace detail
 {
 void prepareSources(TimeFrame&, const SurfaceCatalogView&, gsl::span<const ClusterSourceInput>,
                     std::vector<std::vector<uint32_t>>*, std::vector<std::vector<uint32_t>>*, bool requireCompleteMapping = false);
-void validateSource(const ClusterSourceInput&, const o2::InteractionRecord&);
+void validateClusterRanges(const ClusterSourceInput&);
 void appendCluster(TimeFrame&, const SurfaceCatalogView&, const ClusterSourceInput&, const DecodedCluster&,
                    uint32_t, uint32_t, std::vector<std::vector<uint32_t>>&, std::vector<std::vector<uint32_t>>&);
-void bindSourceROFNavigation(TimeFrame&, const ClusterSourceInput&, const std::vector<std::vector<int>>&);
+void storeSourceROFClusters(TimeFrame&, const ClusterSourceInput&, const std::vector<std::vector<int>>&);
 
 // Internal loading loop; geometry decoding and synthetic fixtures share the
 // same stream consumption, diagnostics and measurement insertion.
@@ -179,7 +177,7 @@ void loadDecodedSource(TimeFrame& frame, const SurfaceCatalogView& catalog, cons
   if (patterns != src.patterns.end()) {
     throw std::runtime_error(std::format("Trailing cluster pattern data source={} rof={} clusterIndex={}", src.id.value(), static_cast<uint32_t>(src.rofs.size()), static_cast<uint32_t>(src.clusters.size())));
   }
-  bindSourceROFNavigation(frame, src, boundaries);
+  storeSourceROFClusters(frame, src, boundaries);
 }
 } // namespace detail
 

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

@@ -123,8 +123,8 @@ struct TimeFrame {
   const auto& getIndexTableUtils(int layer) const { return mIndexTableUtils[layer]; }
 
   void setROFViews(RuntimeROFViews views) noexcept;
-  void setROFNavigation(std::size_t position, gsl::span<const int> boundaries,
-                        RuntimeROFViews views, uint16_t localLayer);
+  void setROFViews(std::size_t position, RuntimeROFViews views, uint16_t localLayer);
+  void setROFClusters(std::size_t position, gsl::span<const int> boundaries);
   const RuntimeROFViews& getROFViews() const noexcept { return mROFViews; }
   const RuntimeROFViews& getROFViews(int layer) const noexcept { return mROFViewsBySurface.empty() ? mROFViews : mROFViewsBySurface[layer]; }
   int getROFLocalLayer(int layer) const noexcept { return mROFLocalLayerBySurface.empty() ? layer : mROFLocalLayerBySurface[layer]; }

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

@@ -23,6 +23,7 @@
 #include "ITSMFTTracking/TrackPublicationHelpers.h"
 #include "ITSMFTTracking/IOUtils.h"
 #include "ITSMFTTracking/ROFLookupTables.h"
+#include "ITSMFTTracking/SurfaceTiming.h"
 #include "ITSMFTTracking/Tracker.h"
 
 namespace o2::itsmft::tracking
@@ -40,6 +41,19 @@ inline CATrackerPublicationAction decideCATrackerPublicationAction(bool active,
   return success ? CATrackerPublicationAction::PublishActiveResult : CATrackerPublicationAction::SkipDroppedTimeFrame;
 }
 
+// Timing belongs to the workflow; cluster loading only consumes ROF ranges.
+inline void validateSourceROFTiming(const ClusterSourceInput& source, const o2::InteractionRecord& origin,
+                                    const ROFTimingConfig& timing)
+{
+  for (uint32_t rof = 0; rof < source.rofs.size(); ++rof) {
+    const auto built = computeROFIntervalBC(source.rofs[rof].getBCData(), origin, timing, rof);
+    if (!built.ok()) {
+      throw std::runtime_error(std::format("Invalid ROF timing: source={} rof={} timingError={}",
+                                           source.id.value(), rof, static_cast<int>(built.error)));
+    }
+  }
+}
+
 // The common columns are copied into framework-owned output storage before the
 // session is reset. Detector-specific columns (MFT seed patterns, MC) stay explicit.
 template <typename Allocator, typename Output, typename Staged>
@@ -216,10 +230,13 @@ class WorkflowSession
             throw std::runtime_error{std::string(mDetectorName) + " CA tracker received no adapter-owned runtime ROF timing view"};
           }
           const auto& clock = views.overlap.getLayer(0);
-          source.timing = {clock.mROFLength, clock.mROFDelay, clock.mROFBias, clock.mROFAddTimeErr};
-          source.rofViews = views;
+          validateSourceROFTiming(source, origin, {clock.mROFLength, clock.mROFDelay, clock.mROFBias, clock.mROFAddTimeErr});
           loadTimeFrameSources(frame, gsl::span<const ClusterSourceInput>{&source, 1},
-                               frame.getDetectorConfiguration().getSurfaceCatalog(), origin, &externalIndices, &clusterSizes);
+                               frame.getDetectorConfiguration().getSurfaceCatalog(), &externalIndices, &clusterSizes);
+          frame.setROFViews(views);
+          for (uint16_t layer = 0; layer < source.layerToSurface.size(); ++layer) {
+            frame.setROFViews(source.layerToSurface[layer].value(), views, layer);
+          }
           afterLoad(origin);
         })) {
       return false;

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

@@ -32,7 +32,6 @@ o2::itsmft::tracking::DecodedCluster decodeCluster(
   gsl::span<const unsigned char>::iterator& patterns,
   const o2::itsmft::TopologyDictionary* dict)
 {
-  o2::itsmft::tracking::DecodedCluster result;
   if (dict == nullptr) {
     throw std::runtime_error("Cluster dictionary is not available");
   }
@@ -57,19 +56,18 @@ o2::itsmft::tracking::DecodedCluster decodeCluster(
   if constexpr (DetId == o2::detectors::DetID::ITS) {
     const auto trkXYZ = geom->getMatrixT2L(sensorID) ^ clusterData.coordinates;
     const auto gloXYZ = geom->getMatrixL2G(sensorID) * clusterData.coordinates;
-    result = {{gloXYZ.x(), gloXYZ.y(), gloXYZ.z()},
-              {trkXYZ.x(), trkXYZ.y(), trkXYZ.z(), geom->getSensorRefAlpha(sensorID)},
-              {sigma2Row, 0.f, sigma2Col},
-              clusterData.nPixels,
-              layer};
+    return {{gloXYZ.x(), gloXYZ.y(), gloXYZ.z()},
+            {trkXYZ.x(), trkXYZ.y(), trkXYZ.z(), geom->getSensorRefAlpha(sensorID)},
+            {sigma2Row, 0.f, sigma2Col},
+            clusterData.nPixels,
+            layer};
   } else {
     if (!geom->getCacheL2G().isFilled() || geom->getCacheL2G().getSize() <= sensorID) {
       throw std::runtime_error("Cluster geometry is not available");
     }
     const auto gloXYZ = geom->getMatrixL2G(sensorID) * clusterData.coordinates;
-    result = {{gloXYZ.x(), gloXYZ.y(), gloXYZ.z()}, {}, {sigma2Row, 0.f, sigma2Col}, clusterData.nPixels, layer};
+    return {{gloXYZ.x(), gloXYZ.y(), gloXYZ.z()}, {}, {sigma2Row, 0.f, sigma2Col}, clusterData.nPixels, layer};
   }
-  return result;
 }
 
 template <o2::detectors::DetID::ID DetId, typename Consume>
@@ -108,8 +106,8 @@ GlobalMeasurement makeCylinderGlobalMeasurement(const DecodedCluster& decoded, u
      cosine * cosine * covariance.uu,
      cosine * covariance.uv,
      covariance.vv},
-    std::hypot(decoded.global.x, decoded.global.y),
-    std::atan2(decoded.global.y, decoded.global.x),
+    0.f, // Radius and phi are computed after subtracting the beam position.
+    0.f,
     clusterId};
 }
 
@@ -124,8 +122,8 @@ GlobalMeasurement makeDiskGlobalMeasurement(const DecodedCluster& decoded, uint3
     decoded.global.z,
     {decoded.rowColumnCovariance.uu, decoded.rowColumnCovariance.uv, 0.f,
      decoded.rowColumnCovariance.vv, 0.f, 0.f},
-    std::hypot(decoded.global.x, decoded.global.y),
-    std::atan2(decoded.global.y, decoded.global.x),
+    0.f, // Radius and phi are computed after subtracting the beam position.
+    0.f,
     clusterId};
 }
 
@@ -181,7 +179,7 @@ bool globalCovarianceIsPositiveSemidefinite(const GlobalCovariance3F& covariance
 bool decodedMeasurementIsValid(const GlobalMeasurement& global,
                                const SurfaceMeasurement& local) noexcept
 {
-  return globalCovarianceIsPositiveSemidefinite(global.covariance) &
+  return globalCovarianceIsPositiveSemidefinite(global.covariance) &&
          covariance2DIsPositiveSemidefinite(local.covariance.uu, local.covariance.uv, local.covariance.vv);
 }
 
@@ -264,11 +262,8 @@ void prepareSources(TimeFrame& frame, const SurfaceCatalogView& catalog,
       throw std::runtime_error(std::format("Invalid source-to-surface layer mapping source={}", owner.value()));
     }
   }
-  if (!sources.empty()) {
-    frame.setROFViews(sources.front().rofViews);
-  }
 }
-void validateSource(const ClusterSourceInput& src, const o2::InteractionRecord& origin)
+void validateClusterRanges(const ClusterSourceInput& src)
 {
   int64_t expectedNext = 0;
   for (uint32_t r = 0; r < src.rofs.size(); ++r) {
@@ -286,13 +281,6 @@ void validateSource(const ClusterSourceInput& src, const o2::InteractionRecord&
   if (expectedNext != static_cast<int64_t>(src.clusters.size())) {
     throw std::runtime_error(std::format("Invalid ROF cluster range source={} rof={}", src.id.value(), static_cast<uint32_t>(src.rofs.size())));
   }
-
-  for (uint32_t r = 0; r < src.rofs.size(); ++r) {
-    const auto built = computeROFIntervalBC(src.rofs[r].getBCData(), origin, src.timing, r);
-    if (!built.ok()) {
-      throw std::runtime_error(std::format("Invalid ROF timing: source={} rof={} timingError={}", src.id.value(), r, static_cast<int>(built.error)));
-    }
-  }
 }
 void appendCluster(TimeFrame& frame, const SurfaceCatalogView& catalog,
                    const ClusterSourceInput& src, const DecodedCluster& decoded,
@@ -337,17 +325,17 @@ void appendCluster(TimeFrame& frame, const SurfaceCatalogView& catalog,
   clusterSizes[expectedSurface.value()].push_back(decoded.nPixels);
   externalIndices[expectedSurface.value()].push_back(externalIndex);
 }
-void bindSourceROFNavigation(TimeFrame& frame, const ClusterSourceInput& source,
-                             const std::vector<std::vector<int>>& boundaries)
+void storeSourceROFClusters(TimeFrame& frame, const ClusterSourceInput& source,
+                            const std::vector<std::vector<int>>& boundaries)
 {
   for (uint16_t layer = 0; layer < source.layerToSurface.size(); ++layer) {
-    frame.setROFNavigation(source.layerToSurface[layer].value(), boundaries[layer], source.rofViews, layer);
+    frame.setROFClusters(source.layerToSurface[layer].value(), boundaries[layer]);
   }
 }
 } // namespace detail
 
 void loadTimeFrameSources(TimeFrame& frame, gsl::span<const ClusterSourceInput> sources,
-                          SurfaceCatalogView catalog, const o2::InteractionRecord& origin,
+                          SurfaceCatalogView catalog,
                           std::vector<std::vector<uint32_t>>* externalIndicesBySurface,
                           std::vector<std::vector<uint32_t>>* clusterSizesBySurface)
 {
@@ -356,7 +344,7 @@ void loadTimeFrameSources(TimeFrame& frame, gsl::span<const ClusterSourceInput>
   std::vector<std::vector<uint32_t>> clusterSizes(catalog.nSurfaces);
   bool hasMCInformation = false;
   for (const auto& source : sources) {
-    detail::validateSource(source, origin);
+    detail::validateClusterRanges(source);
     const auto load = [&](const auto& decode) {
       detail::loadDecodedSource(frame, catalog, source, decode, externalIndices, clusterSizes);
     };

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

@@ -205,7 +205,7 @@ bool covarianceDiagonalsNonNegative(const SurfaceTrackState& state) noexcept
 // the retained TrackParametrizationWithError<float>::checkCovariance()
 // range-clamp values, and the same five constants
 // PropagatorBarrelOperations.cxx's post-propagate/rotate/update
-// sanitization (ADR 0008) enforces.
+// sanitization enforces.
 constexpr float kBarrelMaxDiagonal[5] = {o2::track::kCY2max, o2::track::kCZ2max, o2::track::kCSnp2max,
                                          o2::track::kCTgl2max, o2::track::kC1Pt2max};
 

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

@@ -90,7 +90,7 @@ void transportCovariance(SurfaceTrackState& state, const DenseMatrix5& jacobian)
 }
 
 // Shared commit point for non-linRef rotate() and propagate(). It validates
-// and sanitizes the covariance (ADR 0008) on every exit, including dx == 0.
+// and sanitizes the covariance on every exit, including dx == 0.
 bool commit(SurfaceTrackState& destination, SurfaceTrackState& scratch) noexcept
 {
   sanitizeCovariance(scratch, kBarrelMaxDiagonal);

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

@@ -203,13 +203,19 @@ void TimeFrame::setROFViews(RuntimeROFViews views) noexcept
   mUseUPC = false;
 }
 
-void TimeFrame::setROFNavigation(std::size_t position, gsl::span<const int> boundaries,
-                                 RuntimeROFViews views, uint16_t localLayer)
+void TimeFrame::setROFClusters(std::size_t position, gsl::span<const int> boundaries)
 {
   if (!mConfigurationValid || position >= mROFramesClusters.size()) {
-    throw std::logic_error{"TimeFrame::setROFNavigation(): invalid or unconfigured surface position"};
+    throw std::logic_error{"TimeFrame::setROFClusters(): invalid or unconfigured surface position"};
   }
   mROFramesClusters[position].assign(boundaries.begin(), boundaries.end());
+}
+
+void TimeFrame::setROFViews(std::size_t position, RuntimeROFViews views, uint16_t localLayer)
+{
+  if (!mConfigurationValid || position >= mROFViewsBySurface.size()) {
+    throw std::logic_error{"TimeFrame::setROFViews(): invalid or unconfigured surface position"};
+  }
   mROFViewsBySurface[position] = views;
   mROFLocalLayerBySurface[position] = localLayer;
   mUseUPC = false;

Detectors/ITSMFT/common/tracking/test/CombinedTrackingTestSupport.h

@@ -178,7 +178,7 @@ class CombinedTrackingPlan
   }
 
   SurfaceCatalogView catalogView() const noexcept { return combinedCatalogView(); }
-  void configureRofTables(const ClusterSourceInput& itsSource, const ClusterSourceInput& mftSource)
+  void configureRofTables(const TestClusterSourceInput& itsSource, const TestClusterSourceInput& mftSource)
   {
     auto configure = [](auto& overlap, auto& vertex, auto& mask, const auto& timing, uint32_t nROFs, int layers) {
       o2::its::LayerTiming layerTiming{};

Detectors/ITSMFT/common/tracking/test/TrackingParameterTestSupport.h

@@ -14,6 +14,7 @@
 #include "ITSMFTTracking/Configuration.h"
 #include "ITSMFTTracking/IOUtils.h"
 #include "ITSMFTTracking/TimeFrame.h"
+#include "ITSMFTTracking/SurfaceTiming.h"
 #include <functional>
 #include "ITSMFTTracking/ITSMFTDetectorDefinitions.h"
 
@@ -92,6 +93,9 @@ inline std::vector<TrackingParameters> referenceTrackingParameters(o2::detectors
 // Synthetic decoding is confined to tests. Exercise the same normalization
 // and ROF bookkeeping as production without constructing detector geometry.
 struct TestClusterSourceInput : ClusterSourceInput {
+  // Fixture-owned timing is bound separately after cluster loading.
+  ROFTimingConfig timing{};
+  RuntimeROFViews rofViews{};
   std::function<DecodedCluster(const itsmft::CompClusterExt&, gsl::span<const unsigned char>::iterator&,
                                const itsmft::TopologyDictionary*, uint32_t)>
     decode;
@@ -106,7 +110,7 @@ struct TestClusterSourceInput : ClusterSourceInput {
 };
 
 inline void loadSources(TimeFrame& frame, const SurfaceCatalogView& catalog,
-                        gsl::span<const TestClusterSourceInput> sources, const o2::InteractionRecord& origin,
+                        gsl::span<const TestClusterSourceInput> sources, const o2::InteractionRecord&,
                         std::vector<std::vector<uint32_t>>* indices = nullptr,
                         std::vector<std::vector<uint32_t>>* sizes = nullptr, bool requireCompleteMapping = false)
 {
@@ -116,13 +120,21 @@ inline void loadSources(TimeFrame& frame, const SurfaceCatalogView& catalog,
   std::vector<std::vector<uint32_t>> clusterSizes(catalog.nSurfaces);
   bool hasMCInformation = false;
   for (const auto& source : sources) {
-    detail::validateSource(source, origin);
+    detail::validateClusterRanges(source);
     detail::loadDecodedSource(frame, catalog, source, [&](const auto& cluster, auto& patterns) {
       const auto index = static_cast<uint32_t>(&cluster - source.clusters.data());
       return source.decode(cluster, patterns, source.dictionary, index); }, externalIndices, clusterSizes);
     hasMCInformation |= source.labels != nullptr;
   }
   frame.setHasMCInformation(hasMCInformation);
+  if (!sources.empty()) {
+    frame.setROFViews(sources.front().rofViews);
+    for (const auto& source : sources) {
+      for (uint16_t layer = 0; layer < source.layerToSurface.size(); ++layer) {
+        frame.setROFViews(source.layerToSurface[layer].value(), source.rofViews, layer);
+      }
+    }
+  }
   if (indices != nullptr) {
     *indices = std::move(externalIndices);
   }