Use legacy timing classes

Author: mpuccio

Detectors/ITSMFT/ITS/workflow-ca/include/ITSCAWorkflow/TruthSeeding.h

@@ -15,26 +15,46 @@
 #include <algorithm>
 #include <limits>
 #include <optional>
+#include <gsl/span>
 
 #include "CommonDataFormat/InteractionRecord.h"
 #include "DataFormatsITS/TimeEstBC.h"
-#include "ITSMFTTracking/SurfaceTiming.h"
+#include "DataFormatsITSMFT/ROFRecord.h"
+#include "ITSMFTTracking/ROFLookupTables.h"
 
 namespace o2::its::ca
 {
+// Keep the readout window anchored to the actual input ROF records, including
+// sparse/triggered input, while using the legacy interval and timing types.
+inline std::optional<o2::its::TimeEstBC> truthSeedingWindow(
+  gsl::span<const o2::itsmft::ROFRecord> rofs, const o2::InteractionRecord& origin,
+  const o2::its::LayerTiming& timing) noexcept
+{
+  if (rofs.empty() || timing.mROFLength == 0) {
+    return std::nullopt;
+  }
+  const int64_t offset = static_cast<int64_t>(timing.mROFDelay) + timing.mROFBias;
+  const int64_t begin = std::max(int64_t{0}, rofs.front().getBCData().differenceInBC(origin) + offset - timing.mROFAddTimeErr);
+  const int64_t end = rofs.back().getBCData().differenceInBC(origin) + offset + timing.mROFLength + timing.mROFAddTimeErr;
+  if (begin >= end || end > std::numeric_limits<o2::its::TimeStampType>::max()) {
+    return std::nullopt;
+  }
+  return o2::its::TimeEstBC{static_cast<uint32_t>(begin), static_cast<uint32_t>(end - begin)};
+}
+
 // Use the same origin as cluster loading. ROF delay/bias belong to the
 // readout window, not to the collision timestamp. Preserve the existing
 // forward uncertainty interval and select only collisions overlapping this TF.
 inline std::optional<o2::its::TimeEstBC> truthSeedingTime(
   const o2::InteractionRecord& collision, const o2::InteractionRecord& origin,
-  const o2::itsmft::tracking::ROFIntervalBC& window, uint32_t duration) noexcept
+  const o2::its::TimeEstBC& window, uint32_t duration) noexcept
 {
-  if (collision.isDummy() || !window.isValid() || duration == 0) {
+  if (collision.isDummy() || window.lower() >= window.upper() || duration == 0) {
     return std::nullopt;
   }
   const auto begin = collision.differenceInBC(origin);
   const auto end = begin + duration;
-  if (end <= window.begin || begin >= window.end || end <= 0) {
+  if (end <= window.lower() || begin >= window.upper() || end <= 0) {
     return std::nullopt;
   }
   // TimeEstBC has unsigned bounds; clip only the part preceding this origin.

Detectors/ITSMFT/ITS/workflow-ca/src/CATrackerSpec.cxx

@@ -38,7 +38,6 @@
 #include "ITSMFTTracking/Tracker.h"
 #include "ITSMFTTracking/TrackPublicationHelpers.h"
 #include "ITSMFTTracking/IOUtils.h"
-#include "ITSMFTTracking/SurfaceTiming.h"
 #include "ITSMFTTracking/ITSMFTDetectorDefinitions.h"
 #include "ITSMFTTracking/TrackingConfigParam.h"
 #include "ITSMFTTracking/BoundedAllocator.h"
@@ -241,15 +240,10 @@ void CATrackerDPL::addTruthSeedingVertices(const o2::InteractionRecord& origin,
   }
   LOGP(info, "ITS CA using truth seeds as vertices");
   const auto& clock = mSession.frame.getROFViews().overlap.getLayer(0);
-  const o2::itsmft::tracking::ROFTimingConfig timing{clock.mROFLength, clock.mROFDelay, clock.mROFBias, clock.mROFAddTimeErr};
-  const auto first = o2::itsmft::tracking::computeROFIntervalBC(rofs.front().getBCData(), origin, timing, 0);
-  const auto last = o2::itsmft::tracking::computeROFIntervalBC(rofs.back().getBCData(), origin, timing, rofs.size() - 1);
-  const auto firstWindow = o2::itsmft::tracking::widen(first.interval, timing.rofAddTimeErr);
-  const auto lastWindow = o2::itsmft::tracking::widen(last.interval, timing.rofAddTimeErr);
-  if (!first.ok() || !last.ok() || !firstWindow.ok() || !lastWindow.ok()) {
+  const auto window = truthSeedingWindow(rofs, origin, clock);
+  if (!window) {
     throw std::runtime_error("ITS CA truth seeding received invalid ROF timing");
   }
-  const o2::itsmft::tracking::ROFIntervalBC window{std::max(int64_t{0}, firstWindow.interval.begin), lastWindow.interval.end, 0, 0};
   const std::unique_ptr<o2::steer::DigitizationContext> dc{o2::steer::DigitizationContext::loadFromFile(mOptions.truthContext.c_str())};
   if (!dc) {
     throw std::runtime_error("ITS CA truth seeding could not load " + mOptions.truthContext);
@@ -264,7 +258,7 @@ void CATrackerDPL::addTruthSeedingVertices(const o2::InteractionRecord& origin,
     if (collision == eveId2colId.end()) {
       continue;
     }
-    const auto timestamp = truthSeedingTime(irs.at(collision->second), origin, window, clock.mROFLength / 2);
+    const auto timestamp = truthSeedingTime(irs.at(collision->second), origin, *window, clock.mROFLength / 2);
     if (timestamp) {
       selected.emplace_back(*timestamp, iEve);
     }

Detectors/ITSMFT/ITS/workflow-ca/test/testITSCATruthSeeding.cxx

@@ -28,17 +28,18 @@ BOOST_AUTO_TEST_CASE(ConsecutiveFramesSelectTheirOwnCollisionsAndLookupROFs)
   const std::array<o2::InteractionRecord, 2> collisions{firstOrigin + 50, firstOrigin + 250};
   const std::array<float, 2> z{1.f, 7.f};
   // Two ROFs with nonzero delay and bias, matching the cluster loader.
-  const ROFTimingConfig timing{100, 10, 20, 0};
+  const o2::its::LayerTiming timing{.mNROFsTF = 2, .mROFLength = 100, .mROFDelay = 10, .mROFBias = 20};
   for (int frame = 0; frame < 2; ++frame) {
     const auto origin = firstOrigin + 200 * frame;
-    const auto first = computeROFIntervalBC(origin, origin, timing, 0);
-    const auto last = computeROFIntervalBC(origin + 100, origin, timing, 1);
-    BOOST_REQUIRE(first.ok() && last.ok());
-    const ROFIntervalBC window{first.interval.begin, last.interval.end, 0, 0};
+    const std::array<o2::itsmft::ROFRecord, 2> rofs{{{origin, 0, 0, 0}, {origin + 100, 1, 0, 0}}};
+    const auto window = truthSeedingWindow(rofs, origin, timing);
+    BOOST_REQUIRE(window);
+    BOOST_CHECK_EQUAL(window->lower(), 30u);
+    BOOST_CHECK_EQUAL(window->upper(), 230u);
     std::vector<o2::its::Vertex> vertices;
     std::vector<int> eventIds;
     for (int event = 0; event < 2; ++event) {
-      if (const auto time = truthSeedingTime(collisions[event], origin, window, 50)) {
+      if (const auto time = truthSeedingTime(collisions[event], origin, *window, 50)) {
         o2::its::Vertex vertex;
         vertex.setXYZ(0.f, 0.f, z[event]);
         vertex.getTimeStamp() = *time;
@@ -62,7 +63,7 @@ BOOST_AUTO_TEST_CASE(ConsecutiveFramesSelectTheirOwnCollisionsAndLookupROFs)
 BOOST_AUTO_TEST_CASE(TruthTimingPreservesOverlapAndRejectsOutOfFrameEvents)
 {
   const o2::InteractionRecord origin{0, 40};
-  const ROFIntervalBC window{0, 200, 0, 0};
+  const o2::its::TimeEstBC window{0, 200};
   const auto overlap = truthSeedingTime(origin - 10, origin, window, 50);
   BOOST_REQUIRE(overlap);
   BOOST_CHECK_EQUAL(overlap->lower(), 0);
@@ -73,3 +74,19 @@ BOOST_AUTO_TEST_CASE(TruthTimingPreservesOverlapAndRejectsOutOfFrameEvents)
   BOOST_CHECK(!truthSeedingTime(origin, origin, window, 0));
   BOOST_CHECK(!truthSeedingTime(origin, origin, {}, 50));
 }
+
+BOOST_AUTO_TEST_CASE(TruthWindowUsesActualROFRecordsAndLegacyTimingFields)
+{
+  const o2::InteractionRecord origin{0, 40};
+  const std::array<o2::itsmft::ROFRecord, 2> rofs{{{origin, 0, 0, 0}, {origin + 1000, 1, 0, 0}}};
+  o2::its::LayerTiming timing{.mNROFsTF = 2, .mROFLength = 100, .mROFDelay = 10, .mROFBias = 20, .mROFAddTimeErr = 50};
+  const auto window = truthSeedingWindow(rofs, origin, timing);
+  BOOST_REQUIRE(window);
+  BOOST_CHECK_EQUAL(window->lower(), 0u);
+  BOOST_CHECK_EQUAL(window->upper(), 1180u);
+  BOOST_CHECK(!truthSeedingWindow({}, origin, timing));
+  timing.mROFLength = 0;
+  BOOST_CHECK(!truthSeedingWindow(rofs, origin, timing));
+  timing.mROFLength = std::numeric_limits<uint32_t>::max();
+  BOOST_CHECK(!truthSeedingWindow(rofs, origin, timing));
+}

Detectors/ITSMFT/MFT/workflow/src/CATrackerSpec.cxx

@@ -36,7 +36,6 @@
 #include "ITSMFTTracking/Tracker.h"
 #include "ITSMFTTracking/TrackPublicationHelpers.h"
 #include "ITSMFTTracking/IOUtils.h"
-#include "ITSMFTTracking/SurfaceTiming.h"
 #include "ITSMFTTracking/ITSMFTDetectorDefinitions.h"
 #include "ITSMFTTracking/TrackingConfigParam.h"
 #include "DetectorsBase/Propagator.h"

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

@@ -24,7 +24,7 @@
 #include "ITSMFTTracking/IdTypes.h"
 #include "ITSMFTTracking/SurfaceTrackState.h"
 #include "ITSMFTTracking/LayerMask.h"
-#include "ITSMFTTracking/SurfaceTiming.h"
+#include "DataFormatsITS/TimeEstBC.h"
 
 namespace o2::itsmft::tracking
 {
@@ -46,7 +46,7 @@ struct GenericTrack {
   SurfaceTrackState innerState{};
   SurfaceTrackState outerState{};
   float chi2{0.f};
-  GenericTrackTimestamp timestamp{};
+  o2::its::TimeStamp timestamp{};
   LayerMask hitLayers{};
   uint32_t firstClusterRef{0};
   uint32_t clusterRefEnd{0};