ITS: template CellSeed

Signed-off-by: Felix Schlepper <[email protected]>

Author: f3sch

Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cell.h

@@ -16,6 +16,8 @@
 #ifndef TRACKINGITSU_INCLUDE_CACELL_H_
 #define TRACKINGITSU_INCLUDE_CACELL_H_
 
+#include <array>
+
 #include "ITStracking/Constants.h"
 #include "GPUCommonDef.h"
 
@@ -43,12 +45,17 @@ class Cell final
   int mLevel{constants::UnusedIndex};
 };
 
+template <int nLayers>
 class CellSeed final : public o2::track::TrackParCovF
 {
  public:
-  GPUhdDefault() CellSeed() = default;
+  GPUhd() CellSeed()
+  {
+    mClusters.fill(constants::UnusedIndex);
+  }
   GPUhd() CellSeed(int innerL, int cl0, int cl1, int cl2, int trkl0, int trkl1, o2::track::TrackParCovF& tpc, float chi2) : o2::track::TrackParCovF(tpc), mChi2(chi2), mLevel(1)
   {
+    mClusters.fill(constants::UnusedIndex);
     setUserField(innerL);
     mClusters[innerL + 0] = cl0;
     mClusters[innerL + 1] = cl1;
@@ -74,18 +81,25 @@ class CellSeed final : public o2::track::TrackParCovF
   GPUhd() int getLevel() const { return mLevel; };
   GPUhd() void setLevel(int level) { mLevel = level; };
   GPUhd() int* getLevelPtr() { return &mLevel; }
-  GPUhd() int* getClusters() { return mClusters; }
+  GPUhd() auto& getClusters() { return mClusters; }
   GPUhd() int getCluster(int i) const { return mClusters[i]; }
   GPUhd() void printCell() const
   {
-    printf("trkl: %d, %d\t lvl: %d\t chi2: %f\tcls: [%d | %d | %d | %d | %d | %d | %d]\n", mTracklets[0], mTracklets[1], mLevel, mChi2, mClusters[0], mClusters[1], mClusters[2], mClusters[3], mClusters[4], mClusters[5], mClusters[6]);
+    printf("cell: %d, %d\t lvl: %d\t chi2: %f\tcls: [", mTracklets[0], mTracklets[1], mLevel, mChi2);
+    for (int i = 0; i < nLayers; ++i) {
+      printf("%d", mClusters[i]);
+      if (i < nLayers - 1) {
+        printf(" | ");
+      }
+    }
+    printf("]\n");
   }
 
  private:
   float mChi2 = -999.f;
   int mLevel = constants::UnusedIndex;
-  int mTracklets[2] = {constants::UnusedIndex, constants::UnusedIndex};
-  int mClusters[7] = {constants::UnusedIndex, constants::UnusedIndex, constants::UnusedIndex, constants::UnusedIndex, constants::UnusedIndex, constants::UnusedIndex, constants::UnusedIndex};
+  std::array<int, 2> mTracklets{constants::UnusedIndex, constants::UnusedIndex};
+  std::array<int, nLayers> mClusters;
 };
 
 } // namespace o2::its

Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h

@@ -65,9 +65,12 @@ class TimeFrameGPU;
 
 template <int nLayers = 7>
 struct TimeFrame {
+  using CellSeedN = CellSeed<nLayers>;
   friend class gpu::TimeFrameGPU<nLayers>;
+
   TimeFrame();
   virtual ~TimeFrame();
+
   const Vertex& getPrimaryVertex(const int ivtx) const { return mPrimaryVertices[ivtx]; }
   gsl::span<const Vertex> getPrimaryVertices(int rofId) const;
   gsl::span<const Vertex> getPrimaryVertices(int romin, int romax) const;
@@ -298,7 +301,7 @@ struct TimeFrame {
 
   std::array<bounded_vector<Cluster>, nLayers> mUnsortedClusters;
   std::vector<bounded_vector<Tracklet>> mTracklets;
-  std::vector<bounded_vector<CellSeed>> mCells;
+  std::vector<bounded_vector<CellSeedN>> mCells;
   bounded_vector<Road<nLayers - 2>> mRoads;
   std::vector<bounded_vector<TrackITSExt>> mTracks;
   std::vector<bounded_vector<int>> mCellsNeighbours;

Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h

@@ -22,6 +22,7 @@
 #include "ITStracking/Configuration.h"
 #include "ITStracking/MathUtils.h"
 #include "ITStracking/TimeFrame.h"
+#include "ITStracking/Cell.h"
 #include "ITStracking/BoundedAllocator.h"
 
 // #define OPTIMISATION_OUTPUT
@@ -39,6 +40,8 @@ class TrackITSExt;
 template <int nLayers = 7>
 class TrackerTraits
 {
+  using CellSeedN = CellSeed<nLayers>;
+
  public:
   virtual ~TrackerTraits() = default;
   virtual void adoptTimeFrame(TimeFrame<nLayers>* tf) { mTimeFrame = tf; }
@@ -55,7 +58,7 @@ class TrackerTraits
   virtual void findShortPrimaries();
 
   virtual bool trackFollowing(TrackITSExt* track, int rof, bool outward, const int iteration);
-  virtual void processNeighbours(int iLayer, int iLevel, const bounded_vector<CellSeed>& currentCellSeed, const bounded_vector<int>& currentCellId, bounded_vector<CellSeed>& updatedCellSeed, bounded_vector<int>& updatedCellId);
+  virtual void processNeighbours(int iLayer, int iLevel, const bounded_vector<CellSeedN>& currentCellSeed, const bounded_vector<int>& currentCellId, bounded_vector<CellSeedN>& updatedCellSeed, bounded_vector<int>& updatedCellId);
 
   void updateTrackingParameters(const std::vector<TrackingParameters>& trkPars) { mTrkParams = trkPars; }
   TimeFrame<nLayers>* getTimeFrame() { return mTimeFrame; }

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

@@ -382,7 +382,7 @@ unsigned long TimeFrame<nLayers>::getArtefactsMemory() const
     size += sizeof(Tracklet) * trkl.size();
   }
   for (const auto& cells : mCells) {
-    size += sizeof(CellSeed) * cells.size();
+    size += sizeof(CellSeedN) * cells.size();
   }
   for (const auto& cellsN : mCellsNeighbours) {
     size += sizeof(int) * cellsN.size();

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

@@ -190,7 +190,7 @@ void Tracker<nLayers>::computeRoadsMClabels()
         }
       }
 
-      const CellSeed& currentCell{mTimeFrame->getCells()[iCell][currentCellIndex]};
+      const auto& currentCell{mTimeFrame->getCells()[iCell][currentCellIndex]};
 
       if (isFirstRoadCell) {
 

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

@@ -319,7 +319,7 @@ void TrackerTraits<nLayers>::computeLayerCells(const int iteration)
   }
 
   mTaskArena->execute([&] {
-    auto forTrackletCells = [&](auto Tag, int iLayer, bounded_vector<CellSeed>& layerCells, int iTracklet, int offset = 0) -> int {
+    auto forTrackletCells = [&](auto Tag, int iLayer, bounded_vector<CellSeedN>& layerCells, int iTracklet, int offset = 0) -> int {
       const Tracklet& currentTracklet{mTimeFrame->getTracklets()[iLayer][iTracklet]};
       const int nextLayerClusterIndex{currentTracklet.secondClusterIndex};
       const int nextLayerFirstTrackletIndex{mTimeFrame->getTrackletsLookupTable()[iLayer][nextLayerClusterIndex]};
@@ -392,7 +392,7 @@ void TrackerTraits<nLayers>::computeLayerCells(const int iteration)
             } else if constexpr (decltype(Tag)::value == PassMode::TwoPassCount::value) {
               ++foundCells;
             } else if constexpr (decltype(Tag)::value == PassMode::TwoPassInsert::value) {
-              layerCells[offset++] = CellSeed(iLayer, clusId[0], clusId[1], clusId[2], iTracklet, iNextTracklet, track, chi2);
+              layerCells[offset++] = CellSeedN(iLayer, clusId[0], clusId[1], clusId[2], iTracklet, iNextTracklet, track, chi2);
             } else {
               static_assert(false, "Unknown mode!");
             }
@@ -615,7 +615,7 @@ void TrackerTraits<nLayers>::findCellsNeighbours(const int iteration)
 }
 
 template <int nLayers>
-void TrackerTraits<nLayers>::processNeighbours(int iLayer, int iLevel, const bounded_vector<CellSeed>& currentCellSeed, const bounded_vector<int>& currentCellId, bounded_vector<CellSeed>& updatedCellSeeds, bounded_vector<int>& updatedCellsIds)
+void TrackerTraits<nLayers>::processNeighbours(int iLayer, int iLevel, const bounded_vector<CellSeedN>& currentCellSeed, const bounded_vector<int>& currentCellId, bounded_vector<CellSeedN>& updatedCellSeeds, bounded_vector<int>& updatedCellsIds)
 {
   CA_DEBUGGER(std::cout << "Processing neighbours layer " << iLayer << " level " << iLevel << ", size of the cell seeds: " << currentCellSeed.size() << std::endl);
   auto propagator = o2::base::Propagator::Instance();
@@ -626,7 +626,7 @@ void TrackerTraits<nLayers>::processNeighbours(int iLayer, int iLevel, const bou
 
   mTaskArena->execute([&] {
     auto forCellNeighbours = [&](auto Tag, int iCell, int offset = 0) -> int {
-      const CellSeed& currentCell{currentCellSeed[iCell]};
+      const auto& currentCell{currentCellSeed[iCell]};
 
       if constexpr (decltype(Tag)::value != PassMode::TwoPassInsert::value) {
         if (currentCell.getLevel() != iLevel) {
@@ -646,7 +646,7 @@ void TrackerTraits<nLayers>::processNeighbours(int iLayer, int iLevel, const bou
       for (int iNeighbourCell{startNeighbourId}; iNeighbourCell < endNeighbourId; ++iNeighbourCell) {
         CA_DEBUGGER(attempts++);
         const int neighbourCellId = mTimeFrame->getCellsNeighbours()[iLayer - 1][iNeighbourCell];
-        const CellSeed& neighbourCell = mTimeFrame->getCells()[iLayer - 1][neighbourCellId];
+        const auto& neighbourCell = mTimeFrame->getCells()[iLayer - 1][neighbourCellId];
         if (neighbourCell.getSecondTrackletIndex() != currentCell.getFirstTrackletIndex()) {
           CA_DEBUGGER(failedByMismatch++);
           continue;
@@ -660,7 +660,7 @@ void TrackerTraits<nLayers>::processNeighbours(int iLayer, int iLevel, const bou
         }
 
         /// Let's start the fitting procedure
-        CellSeed seed{currentCell};
+        CellSeedN seed{currentCell};
         const auto& trHit = mTimeFrame->getTrackingFrameInfoOnLayer(iLayer - 1)[neighbourCell.getFirstClusterIndex()];
 
         if (!seed.rotate(trHit.alphaTrackingFrame)) {
@@ -767,17 +767,17 @@ void TrackerTraits<nLayers>::findRoads(const int iteration)
 
   for (int startLevel{mTrkParams[iteration].CellsPerRoad()}; startLevel >= mTrkParams[iteration].CellMinimumLevel(); --startLevel) {
     CA_DEBUGGER(std::cout << "\t > Processing level " << startLevel << std::endl);
-    auto seedFilter = [&](const CellSeed& seed) {
+    auto seedFilter = [&](const auto& seed) {
       return seed.getQ2Pt() <= 1.e3 && seed.getChi2() <= mTrkParams[0].MaxChi2NDF * ((startLevel + 2) * 2 - 5);
     };
-    bounded_vector<CellSeed> trackSeeds(mMemoryPool.get());
+    bounded_vector<CellSeedN> trackSeeds(mMemoryPool.get());
     for (int startLayer{mTrkParams[iteration].CellsPerRoad() - 1}; startLayer >= startLevel - 1; --startLayer) {
       if ((mTrkParams[iteration].StartLayerMask & (1 << (startLayer + 2))) == 0) {
         continue;
       }
       CA_DEBUGGER(std::cout << "\t\t > Starting processing layer " << startLayer << std::endl);
       bounded_vector<int> lastCellId(mMemoryPool.get()), updatedCellId(mMemoryPool.get());
-      bounded_vector<CellSeed> lastCellSeed(mMemoryPool.get()), updatedCellSeed(mMemoryPool.get());
+      bounded_vector<CellSeedN> lastCellSeed(mMemoryPool.get()), updatedCellSeed(mMemoryPool.get());
 
       processNeighbours(startLayer, startLevel, mTimeFrame->getCells()[startLayer], lastCellId, updatedCellSeed, updatedCellId);
 
@@ -805,7 +805,7 @@ void TrackerTraits<nLayers>::findRoads(const int iteration)
     bounded_vector<TrackITSExt> tracks(mMemoryPool.get());
     mTaskArena->execute([&] {
       auto forSeed = [&](auto Tag, int iSeed, int offset = 0) {
-        const CellSeed& seed{trackSeeds[iSeed]};
+        const auto& seed{trackSeeds[iSeed]};
         TrackITSExt temporaryTrack{seed};
         temporaryTrack.resetCovariance();
         temporaryTrack.setChi2(0);