trk

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

Author: f3sch

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

@@ -635,30 +635,40 @@ class ROFVertexLookupTable : public LayerTimingBase<NLayers>
 };
 
 // GPU friendly view of the table below
-template <uint32_t NLayers, typename ROFRange>
+template <int32_t NLayers, typename ROFRange>
 struct ROFTimeSliceTableView {
   const ROFRange* mFlatTable{nullptr};
+  const uint8_t* mFlatMask{nullptr};
+  const int32_t* mLayerROFOffsets{nullptr};
   int32_t mSlices{0};
 
+  GPUhdi() const uint8_t* getMask(int32_t layer, int32_t slice) const
+  {
+    assert(layer < NLayers);
+    assert(sliceIdx < mSlices);
+    const auto& range = getSlice(layer, slice);
+    return &mFlatMask[mLayerROFOffsets[layer] + range.getFirstEntry()];
+  }
+
   // Get the BC range for a given layer and slice
-  GPUhdi() const ROFRange& getSlice(uint32_t layer, int32_t sliceIdx) const
+  GPUhdi() const ROFRange& getSlice(int32_t layer, int32_t slice) const
   {
     assert(layer < NLayers);
     assert(sliceIdx < mSlices);
-    return mFlatTable[(layer * mSlices) + sliceIdx];
+    return mFlatTable[(layer * mSlices) + slice];
   }
 
   // Check if a BC falls within a specific slice
-  GPUhdi() bool isInSlice(uint32_t layer, int32_t sliceIdx, int32_t bc) const
+  GPUhdi() bool isInSlice(int32_t layer, int32_t slice, int32_t bc) const
   {
-    const auto& range = getSlice(layer, sliceIdx);
+    const auto& range = getSlice(layer, slice);
     int32_t start = range.getFirstEntry();
     int32_t end = range.getEntriesBound();
     return bc >= start && bc < end;
   }
 
   // Find which slice a BC belongs to (returns -1 if not found)
-  GPUhdi() int32_t findSlice(uint32_t layer, int32_t bc) const
+  GPUhdi() int32_t findSlice(int32_t layer, int32_t bc) const
   {
     assert(layer < NLayers);
     int32_t left = 0;
@@ -694,17 +704,24 @@ struct ROFTimeSliceTableView {
     constexpr int w_start = 12;
     constexpr int w_end = 12;
     constexpr int w_range = 10;
-
+    constexpr int w_active = 12;
     LOGF(info, "Slice table: Layer %d", layer);
-    LOGF(info, "%*s | %*s | %*s | %*s", w_slice, "Slice", w_start, "BC.Start", w_end, "BC.End", w_range, "Range");
-    LOGF(info, "%.*s-+-%.*s-+-%.*s-+-%.*s", w_slice, "----------", w_start, "------------", w_end, "------------", w_range, "----------");
-
+    LOGF(info, "%*s | %*s | %*s | %*s | %*s", w_slice, "Slice", w_start, "BC.Start", w_end, "BC.End", w_range, "Range", w_active, "ActiveROFs");
+    LOGF(info, "%.*s-+-%.*s-+-%.*s-+-%.*s-+-%.*s", w_slice, "----------", w_start, "------------", w_end, "------------", w_range, "----------", w_active, "------------");
     for (int32_t i = 0; i < mSlices; ++i) {
       const auto& range = getSlice(layer, i);
       int32_t start = range.getFirstEntry();
       int32_t rangeLen = range.getEntries();
       int32_t end = range.getEntriesBound();
-      LOGF(info, "%*d | %*d | %*d | %*d", w_slice, i, w_start, start, w_end, end, w_range, rangeLen);
+
+      // Count active ROFs in this slice
+      const uint8_t* mask = getMask(layer, i);
+      int32_t activeCount = 0;
+      for (int32_t j = 0; j < rangeLen; ++j) {
+        activeCount += mask[j];
+      }
+
+      LOGF(info, "%*d | %*d | %*d | %*d | %*d/%d", w_slice, i, w_start, start, w_end, end, w_range, rangeLen, w_active, activeCount, rangeLen);
     }
   }
 };
@@ -723,24 +740,47 @@ class ROFTimeSliceTable : public LayerTimingBase<NLayers>
   {
     mSlices = nSlices;
     std::vector<ROFRange> table[NLayers];
+    int32_t totalROFs = 0;
     for (int32_t layer{0}; layer < NLayers; ++layer) {
       buildSlices(layer, table[layer]);
+      mLayerROFOffsets[layer] = totalROFs;
+      totalROFs += this->getLayer(layer).mNROFsTF;
     }
+    mFlatMask.resize(totalROFs, 1);
     flatten(table);
   }
 
+  GPUh() void selectROFs(int32_t bcStart, int32_t bcEnd)
+  {
+    for (int32_t layer{0}; layer < NLayers; ++layer) {
+      const auto& lay = this->getLayer(layer);
+      int32_t offset = mLayerROFOffsets[layer];
+      for (int32_t rofId{0}; rofId < lay.mNROFsTF; ++rofId) {
+        auto bounds = lay.getROFTimeBounds(rofId);
+        int32_t rofStart = bounds.getFirstEntry();
+        int32_t rofEnd = bounds.getEntriesBound();
+        bool isCompatible = rofStart < bcEnd && rofEnd > bcStart;
+        mFlatMask[offset + rofId] = isCompatible ? 1 : 0;
+      }
+    }
+  }
+
   GPUhd() View getView() const
   {
     View view;
     view.mFlatTable = mFlatTable.data();
+    view.mFlatMask = mFlatMask.data();
+    view.mLayerROFOffsets = mLayerROFOffsets;
     view.mSlices = mSlices;
     return view;
   }
 
-  GPUd() View getDeviceView(const ROFRange* deviceFlatTablePtr) const
+  GPUd() View getDeviceView(const ROFRange* deviceFlatTablePtr, const uint8_t* deviceFlatMaskPtr) const
   {
     View view;
     view.mFlatTable = deviceFlatTablePtr;
+    view.mFlatMask = deviceFlatMaskPtr;
+    view.mLayerROFOffsets = mLayerROFOffsets;
     view.mSlices = mSlices;
     return view;
   }
@@ -768,7 +808,9 @@ class ROFTimeSliceTable : public LayerTimingBase<NLayers>
   }
 
   int32_t mSlices{0};
+  int32_t mLayerROFOffsets[NLayers];
   std::vector<ROFRange> mFlatTable;
+  std::vector<uint8_t> mFlatMask;
 };
 
 } // namespace o2::its

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

@@ -38,18 +38,18 @@ namespace its
 {
 class TrackITSExt;
 
-template <int nLayers = 7>
+template <int NLayers = 7>
 class TrackerTraits
 {
  public:
-  using IndexTableUtilsN = IndexTableUtils<nLayers>;
-  using CellSeedN = CellSeed<nLayers>;
+  using IndexTableUtilsN = IndexTableUtils<NLayers>;
+  using CellSeedN = CellSeed<NLayers>;
 
   virtual ~TrackerTraits() = default;
-  virtual void adoptTimeFrame(TimeFrame<nLayers>* tf) { mTimeFrame = tf; }
+  virtual void adoptTimeFrame(TimeFrame<NLayers>* tf) { mTimeFrame = tf; }
   virtual void initialiseTimeFrame(const int iteration) { mTimeFrame->initialise(iteration, mTrkParams[iteration], mTrkParams[iteration].NLayers); }
 
-  virtual void computeLayerTracklets(const int iteration, int iSlice, int iVertex);
+  virtual void computeLayerTracklets(const int iteration, const int iSlice, const int iVertex);
   virtual void computeLayerCells(const int iteration);
   virtual void findCellsNeighbours(const int iteration);
   virtual void findRoads(const int iteration);
@@ -63,7 +63,7 @@ class TrackerTraits
   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; }
+  TimeFrame<NLayers>* getTimeFrame() { return mTimeFrame; }
 
   virtual void setBz(float bz);
   float getBz() const { return mBz; }
@@ -101,15 +101,15 @@ class TrackerTraits
 
  protected:
   o2::gpu::GPUChainITS* mChain = nullptr;
-  TimeFrame<nLayers>* mTimeFrame;
+  TimeFrame<NLayers>* mTimeFrame;
   std::vector<TrackingParameters> mTrkParams;
 
   float mBz{-999.f};
   bool mIsZeroField{false};
 };
 
-template <int nLayers>
-inline const int4 TrackerTraits<nLayers>::getBinsRect(const int layerIndex, float phi, float maxdeltaphi, float z1, float z2, float maxdeltaz) const noexcept
+template <int NLayers>
+inline const int4 TrackerTraits<NLayers>::getBinsRect(const int layerIndex, float phi, float maxdeltaphi, float z1, float z2, float maxdeltaz) const noexcept
 {
   const float zRangeMin = o2::gpu::GPUCommonMath::Min(z1, z2) - maxdeltaz;
   const float phiRangeMin = (maxdeltaphi > o2::constants::math::PI) ? 0.f : phi - maxdeltaphi;