ITS: properly implemenent low mult vert first

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

Author: f3sch

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

@@ -78,40 +78,33 @@ void Tracker::clustersToTracks(const LogFunc& logger, const LogFunc& error)
 
       total += evaluateTask(&Tracker::initialiseTimeFrame, StateNames[mCurState = TFInit], iteration, logger, iteration);
       for (iROFs = 0; iROFs < nROFsIterations; ++iROFs) {
-        if (mTimeFrame->getPrimaryVertices(iROFs).empty()) {
+        auto nPVs = mTimeFrame->getPrimaryVerticesNum(iROFs, nROFsIterations);
+        if (nPVs == 0) {
           continue;
         }
 
-        std::vector<int> vertOrder(mTimeFrame->getPrimaryVerticesNum(iROFs), -1);
-        if (mTrkParams[0].PerPrimaryVertexProcessing) {
-          // do low mult. cluster first, should steal less, keep relative order though
-          std::iota(vertOrder.begin(), vertOrder.end(), 0);
-          std::stable_sort(vertOrder.begin(), vertOrder.end(), [&](int a, int b) -> bool { return mTimeFrame->getPrimaryVertices(iROFs)[a].getNContributors() < mTimeFrame->getPrimaryVertices(iROFs)[b].getNContributors(); });
-          iVertex = 0;
+        timeTracklets += evaluateTask(&Tracker::computeTracklets, StateNames[mCurState = Trackleting], iteration, evalLog, iteration, iROFs, -1);
+        nTracklets += mTraits->getTFNumberOfTracklets();
+        float trackletsPerCluster = mTraits->getTFNumberOfClusters() > 0 ? float(mTraits->getTFNumberOfTracklets()) / float(mTraits->getTFNumberOfClusters()) : 0.f;
+        if (trackletsPerCluster > mTrkParams[iteration].TrackletsPerClusterLimit) {
+          error(std::format("Too many tracklets per cluster ({}) in iteration {} in ROF span {}-{}:, check the detector status and/or the selections. Current limit is {}",
+                            trackletsPerCluster, iteration, iROFs, iROFs + mTrkParams[iteration].nROFsPerIterations, mTrkParams[iteration].TrackletsPerClusterLimit));
+          break;
         }
 
-        do {
-          // LOGP(info, "iVtx={} -> {} / {}", iVertex, vertOrder[iVertex], vertOrder.size());
-          timeTracklets += evaluateTask(&Tracker::computeTracklets, StateNames[mCurState = Trackleting], iteration, evalLog, iteration, iROFs, vertOrder[iVertex]);
-          nTracklets += mTraits->getTFNumberOfTracklets();
-          float trackletsPerCluster = mTraits->getTFNumberOfClusters() > 0 ? float(mTraits->getTFNumberOfTracklets()) / float(mTraits->getTFNumberOfClusters()) : 0.f;
-          if (trackletsPerCluster > mTrkParams[iteration].TrackletsPerClusterLimit) {
-            error(std::format("Too many tracklets per cluster ({}) in iteration {} in ROF span {}-{}:, check the detector status and/or the selections. Current limit is {}",
-                              trackletsPerCluster, iteration, iROFs, iROFs + mTrkParams[iteration].nROFsPerIterations, mTrkParams[iteration].TrackletsPerClusterLimit));
-            break;
-          }
-          timeCells += evaluateTask(&Tracker::computeCells, StateNames[mCurState = Celling], iteration, evalLog, iteration);
-          nCells += mTraits->getTFNumberOfCells();
-          float cellsPerCluster = mTraits->getTFNumberOfClusters() > 0 ? float(mTraits->getTFNumberOfCells()) / float(mTraits->getTFNumberOfClusters()) : 0.f;
-          if (cellsPerCluster > mTrkParams[iteration].CellsPerClusterLimit) {
-            error(std::format("Too many cells per cluster ({}) in iteration {} in ROF span {}-{}, check the detector status and/or the selections. Current limit is {}",
-                              cellsPerCluster, iteration, iROFs, iROFs + mTrkParams[iteration].nROFsPerIterations, mTrkParams[iteration].CellsPerClusterLimit));
-            break;
-          }
-          timeNeighbours += evaluateTask(&Tracker::findCellsNeighbours, StateNames[mCurState = Neighbouring], iteration, evalLog, iteration);
-          nNeighbours += mTimeFrame->getNumberOfNeighbours();
-          timeRoads += evaluateTask(&Tracker::findRoads, StateNames[mCurState = Roading], iteration, evalLog, iteration);
-        } while (vertOrder[iVertex] >= 0 && ++iVertex < mTimeFrame->getPrimaryVerticesNum(iROFs));
+        timeCells += evaluateTask(&Tracker::computeCells, StateNames[mCurState = Celling], iteration, evalLog, iteration);
+        nCells += mTraits->getTFNumberOfCells();
+        float cellsPerCluster = mTraits->getTFNumberOfClusters() > 0 ? float(mTraits->getTFNumberOfCells()) / float(mTraits->getTFNumberOfClusters()) : 0.f;
+        if (cellsPerCluster > mTrkParams[iteration].CellsPerClusterLimit) {
+          error(std::format("Too many cells per cluster ({}) in iteration {} in ROF span {}-{}, check the detector status and/or the selections. Current limit is {}",
+                            cellsPerCluster, iteration, iROFs, iROFs + mTrkParams[iteration].nROFsPerIterations, mTrkParams[iteration].CellsPerClusterLimit));
+          break;
+        }
+
+        timeNeighbours += evaluateTask(&Tracker::findCellsNeighbours, StateNames[mCurState = Neighbouring], iteration, evalLog, iteration);
+        nNeighbours += mTimeFrame->getNumberOfNeighbours();
+
+        timeRoads += evaluateTask(&Tracker::findRoads, StateNames[mCurState = Roading], iteration, evalLog, iteration);
       }
       logger(std::format(" - Tracklet finding: {} tracklets found in {:.2f} ms", nTracklets, timeTracklets));
       logger(std::format(" - Cell finding: {} cells found in {:.2f} ms", nCells, timeCells));

Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx

@@ -51,7 +51,7 @@ struct PassMode {
 };
 
 template <int nLayers>
-void TrackerTraits<nLayers>::computeLayerTracklets(const int iteration, int iROFslice, int iVertex)
+void TrackerTraits<nLayers>::computeLayerTracklets(const int iteration, int iROFslice, int /*iVertex*/)
 {
 #ifdef OPTIMISATION_OUTPUT
   static int iter{0};
@@ -75,10 +75,13 @@ void TrackerTraits<nLayers>::computeLayerTracklets(const int iteration, int iROF
   mTaskArena->execute([&] {
     for (int rof0{startROF}; rof0 < endROF; ++rof0) {
       gsl::span<const Vertex> primaryVertices = mTrkParams[iteration].UseDiamond ? diamondSpan : mTimeFrame->getPrimaryVertices(rof0);
-      const int startVtx{iVertex >= 0 ? iVertex : 0};
-      const int endVtx{iVertex >= 0 ? o2::gpu::CAMath::Min(iVertex + 1, static_cast<int>(primaryVertices.size())) : static_cast<int>(primaryVertices.size())};
-      if (endVtx - startVtx <= 0) {
-        continue;
+      const int startVtx{0};
+      const int endVtx{static_cast<int>(primaryVertices.size())};
+      std::vector<int> vertOrder(primaryVertices.size());
+      std::iota(vertOrder.begin(), vertOrder.end(), 0);
+      // do low mult. cluster first, should steal less, keep relative order though
+      if (mTrkParams[iteration].PerPrimaryVertexProcessing) {
+        std::stable_sort(vertOrder.begin(), vertOrder.end(), [&](int a, int b) -> bool { return mTimeFrame->getPrimaryVertices(rof0)[a].getNContributors() < mTimeFrame->getPrimaryVertices(rof0)[b].getNContributors(); });
       }
       int minRof = o2::gpu::CAMath::Max(startROF, rof0 - mTrkParams[iteration].DeltaROF);
       int maxRof = o2::gpu::CAMath::Min(endROF - 1, rof0 + mTrkParams[iteration].DeltaROF);
@@ -104,7 +107,7 @@ void TrackerTraits<nLayers>::computeLayerTracklets(const int iteration, int iROF
               const float inverseR0{1.f / currentCluster.radius};
 
               for (int iV{startVtx}; iV < endVtx; ++iV) {
-                const auto& primaryVertex{primaryVertices[iV]};
+                const auto& primaryVertex{primaryVertices[vertOrder[iV]]};
                 if (primaryVertex.isFlagSet(2) && iteration != 3) {
                   continue;
                 }