Cleanup ITSSharedClusterCompatibility and output errors

Author: mpuccio

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

@@ -81,7 +81,6 @@ class CATrackerDPL : public o2::framework::Task
   std::unique_ptr<o2::itsmft::tracking::Tracker> mTracker;
   std::unique_ptr<o2::itsmft::tracking::ClusterDecoder> mClusterDecoder;
   const o2::itsmft::TopologyDictionary* mDictionary = nullptr;
-  o2::itsmft::tracking::ITSSharedClusterCompatibility mCompatibility;
   PublicationAdapter mPublication;
 };
 

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

@@ -20,45 +20,43 @@
 #include <limits>
 #include <optional>
 #include <vector>
+#include <gsl/span>
 
 #include "DetectorsCommonDataFormats/DetID.h"
 #include "GPUCommonMath.h"
-#include "ITSMFTTracking/detail/ITSSharedClusterCompatibility.h"
 #include "ITSMFTTracking/GenericTrack.h"
 #include "ITSMFTTracking/TimeFrame.h"
 #include "ITSMFTTracking/MathUtils.h"
 
 namespace o2::its::ca
 {
 
-// Workflow-owned ITS compatibility for generic tracking results.
+// Workflow-owned shared-cluster flags indexed by the global GenericTrack index.
 class PublicationAdapter
 {
  public:
-  void adoptITSSharedClusterCompatibility(o2::itsmft::tracking::ITSSharedClusterCompatibility* sidecar) noexcept { mSidecar = sidecar; }
-  o2::itsmft::tracking::ITSSharedClusterCompatibility* getITSSharedClusterCompatibility() const noexcept { return mSidecar; }
+  gsl::span<const uint8_t> sharedClusterFlags() const noexcept
+  {
+    return mComplete ? gsl::span<const uint8_t>{mSharedClusterFlags} : gsl::span<const uint8_t>{};
+  }
 
   bool completeAccepted(gsl::span<const uint32_t> trackIndices,
                         const o2::itsmft::IterationParameters& params,
                         const o2::itsmft::tracking::TimeFrame& frame,
                         bool final)
   {
-    if (mSidecar == nullptr) {
-      return true;
-    }
+    mComplete = false;
     if (!stageSharedClusterFlags(trackIndices, params, frame)) {
       return false;
     }
-    return !final || mSidecar->replaceFromAcceptedTrackIndices(mAcceptedTrackIndices, mSharedClusterFlags);
+    mComplete = final;
+    return true;
   }
 
   void reset() noexcept
   {
     mSharedClusterFlags.clear();
-    mAcceptedTrackIndices.clear();
-    if (mSidecar != nullptr) {
-      mSidecar->clear();
-    }
+    mComplete = false;
   }
 
   class Cleanup
@@ -116,16 +114,18 @@ class PublicationAdapter
                                const o2::itsmft::IterationParameters& params,
                                const o2::itsmft::tracking::TimeFrame& frame)
   {
-    mAcceptedTrackIndices.reserve(mAcceptedTrackIndices.size() + trackIndices.size());
+    auto nextIndex = mSharedClusterFlags.size();
     for (const auto index : trackIndices) {
-      if (index >= frame.getGenericTracks().size() ||
-          (!mAcceptedTrackIndices.empty() && mAcceptedTrackIndices.back() >= index)) {
+      if (index >= frame.getGenericTracks().size() || index < nextIndex) {
         return false;
       }
-      mAcceptedTrackIndices.push_back(index);
+      nextIndex = static_cast<std::size_t>(index) + 1;
     }
-    if (!trackIndices.empty() && mSharedClusterFlags.size() <= trackIndices.back()) {
-      mSharedClusterFlags.resize(static_cast<std::size_t>(trackIndices.back()) + 1, 0);
+    // Gaps belong to tracks not accepted by this adapter, and must not be
+    // mistaken for accepted tracks without shared clusters at publication.
+    mSharedClusterFlags.resize(nextIndex, std::numeric_limits<uint8_t>::max());
+    for (const auto index : trackIndices) {
+      mSharedClusterFlags[index] = 0;
     }
     if (!params.AllowSharingFirstCluster) {
       return true;
@@ -163,9 +163,8 @@ class PublicationAdapter
     return true;
   }
 
-  o2::itsmft::tracking::ITSSharedClusterCompatibility* mSidecar = nullptr;
   std::vector<uint8_t> mSharedClusterFlags;
-  std::vector<uint32_t> mAcceptedTrackIndices;
+  bool mComplete = false;
 };
 
 } // namespace o2::its::ca

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

@@ -100,7 +100,6 @@ CATrackerDPL::CATrackerDPL(std::shared_ptr<o2::base::GRPGeomRequest> gr, Workflo
   : mGGCCDBRequest(std::move(gr)), mUseMC(options.useMC), mOptions(std::move(options))
 {
   mClusterDecoder = std::make_unique<o2::itsmft::tracking::ITSGeometryClusterDecoder>();
-  mPublication.adoptITSSharedClusterCompatibility(&mCompatibility);
 }
 
 void CATrackerDPL::addTruthSeedingVertices(const o2::InteractionRecord& origin, gsl::span<const o2::itsmft::ROFRecord> rofs)
@@ -238,7 +237,7 @@ o2::itsmft::tracking::TrackingOutcome CATrackerDPL::processTimeFrame(
         mSession.vertices.update(mSession.frame.getPrimaryVertices().data(), mSession.frame.getPrimaryVertices().size());
       } }, [&](const o2::itsmft::tracking::TrackingResult& result) {
       if (!completePublication(mPublication, mSession.frame, *mTracker, result)) {
-        throw std::runtime_error{"failed to seal ITS tracking compatibility"};
+        throw std::runtime_error{"failed to prepare ITS shared-cluster flags"};
       } });
 }
 
@@ -293,8 +292,7 @@ void CATrackerDPL::run(ProcessingContext& pc)
       gsl::span<const o2::itsmft::ROFRecord>{rofsinput.data(), rofsinput.size()}, *mSession.publicationClock,
       kLayerToLayout,
       &mSession.externalIndices, &mSession.clusterSizes};
-    o2::itsmft::tracking::GenericTrackOutputAdapterError error = o2::itsmft::tracking::GenericTrackOutputAdapterError::None;
-    const auto staged = o2::itsmft::tracking::stageITSGenericTrackOutput(mSession.frame, context, mCompatibility, mUseMC, error);
+    const auto staged = o2::itsmft::tracking::stageITSGenericTrackOutput(mSession.frame, context, mPublication.sharedClusterFlags(), mUseMC);
     if (!staged) {
       throw std::runtime_error{"ITS GenericTrack output staging failed"};
     }

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

@@ -21,6 +21,8 @@
 #include <boost/test/unit_test.hpp>
 
 #include <algorithm>
+#include <array>
+#include <limits>
 #include <string>
 
 #include "Framework/DataProcessorSpec.h"
@@ -94,28 +96,58 @@ BOOST_AUTO_TEST_CASE(DeviceNameIsStable)
   BOOST_CHECK_EQUAL(spec.name, "its-ca-tracker");
 }
 
-BOOST_AUTO_TEST_CASE(PublicationCompatibilityIsClearedOnEveryWorkflowExit)
+BOOST_AUTO_TEST_CASE(PublicationFlagsAreClearedOnEveryWorkflowExit)
 {
   o2::its::ca::PublicationAdapter publication;
-  o2::itsmft::tracking::ITSSharedClusterCompatibility compatibility;
-  publication.adoptITSSharedClusterCompatibility(&compatibility);
   o2::itsmft::tracking::TimeFrame frame;
+  frame.getGenericTracks().resize(1);
   o2::itsmft::IterationParameters parameters;
+  parameters.AllowSharingFirstCluster = false;
+  const std::array<uint32_t, 1> indices{0};
   for (bool fail : {false, true}) {
-    BOOST_REQUIRE(publication.completeAccepted({}, parameters, frame, true));
-    BOOST_REQUIRE(compatibility.isSealed());
+    BOOST_REQUIRE(publication.completeAccepted(indices, parameters, frame, true));
+    BOOST_REQUIRE_EQUAL(publication.sharedClusterFlags().size(), 1u);
     try {
       auto cleanup = publication.cleanupOnExit();
-      BOOST_CHECK(!compatibility.isSealed());
-      BOOST_REQUIRE(publication.completeAccepted({}, parameters, frame, true));
-      BOOST_CHECK(compatibility.isSealed());
+      BOOST_CHECK(publication.sharedClusterFlags().empty());
+      BOOST_REQUIRE(publication.completeAccepted(indices, parameters, frame, true));
+      BOOST_REQUIRE_EQUAL(publication.sharedClusterFlags().size(), 1u);
+      BOOST_CHECK_EQUAL(publication.sharedClusterFlags()[0], 0);
       if (fail) {
         throw std::runtime_error{"publication failure"};
       }
     } catch (const std::runtime_error&) {
       BOOST_CHECK(fail);
     }
-    BOOST_CHECK(!compatibility.isSealed());
-    BOOST_CHECK(compatibility.entries().empty());
+    BOOST_CHECK(publication.sharedClusterFlags().empty());
   }
 }
+
+BOOST_AUTO_TEST_CASE(PublicationFlagsRequireFinalCompletionAndAcceptedIndices)
+{
+  o2::its::ca::PublicationAdapter publication;
+  o2::itsmft::tracking::TimeFrame frame;
+  frame.getGenericTracks().resize(3);
+  o2::itsmft::IterationParameters parameters;
+  parameters.AllowSharingFirstCluster = false;
+  const std::array<uint32_t, 1> first{0}, last{2}, outOfRange{3};
+  BOOST_REQUIRE(publication.completeAccepted(first, parameters, frame, false));
+  BOOST_CHECK(publication.sharedClusterFlags().empty());
+  BOOST_REQUIRE(publication.completeAccepted(last, parameters, frame, true));
+  const auto flags = publication.sharedClusterFlags();
+  BOOST_REQUIRE_EQUAL(flags.size(), 3u);
+  BOOST_CHECK_EQUAL(flags[0], 0);
+  BOOST_CHECK_EQUAL(flags[1], std::numeric_limits<uint8_t>::max());
+  BOOST_CHECK_EQUAL(flags[2], 0);
+  BOOST_CHECK(!publication.completeAccepted(last, parameters, frame, true));
+  BOOST_CHECK(publication.sharedClusterFlags().empty());
+  publication.reset();
+  BOOST_CHECK(!publication.completeAccepted(outOfRange, parameters, frame, true));
+  const std::array<uint32_t, 2> reversed{2, 0}, repeated{0, 0};
+  BOOST_CHECK(!publication.completeAccepted(reversed, parameters, frame, true));
+  BOOST_CHECK(!publication.completeAccepted(repeated, parameters, frame, true));
+  BOOST_REQUIRE(publication.completeAccepted(first, parameters, frame, false));
+  BOOST_REQUIRE(publication.completeAccepted({}, parameters, frame, true));
+  BOOST_REQUIRE_EQUAL(publication.sharedClusterFlags().size(), 1u);
+  BOOST_CHECK_EQUAL(publication.sharedClusterFlags()[0], 0);
+}

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

@@ -224,8 +224,7 @@ void CATrackerDPL::run(ProcessingContext& pc)
       gsl::span<const o2::itsmft::ROFRecord>{rofsinput.data(), rofsinput.size()}, *mSession.publicationClock,
       kLayerToLayout,
       &mSession.externalIndices, &mSession.clusterSizes};
-    o2::itsmft::tracking::GenericTrackOutputAdapterError error = o2::itsmft::tracking::GenericTrackOutputAdapterError::None;
-    const auto staged = o2::itsmft::tracking::stageMFTGenericTrackOutput(mSession.frame, context, mUseMC, error);
+    const auto staged = o2::itsmft::tracking::stageMFTGenericTrackOutput(mSession.frame, context, mUseMC);
     if (!staged) {
       throw std::runtime_error{"MFT GenericTrack output staging failed"};
     }