ITS: minor mod to seed (cosmetic)

Author: f3sch

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

@@ -215,13 +215,13 @@ class DBSCAN
   DBSCAN() = default;
   DBSCAN(const DBSCANParams& p);
 
-  DBSCANResult cluster(const LinearizedTrack* tracks, size_t n);
-  const auto& getParams() { return mParams; }
-  const auto& getDistance() { return mDistance; }
+  DBSCANResult cluster(const LinearizedTrack* tracks, size_t n) const;
+  const auto& getParams() const { return mParams; }
+  const auto& getDistance() const { return mDistance; }
 
  private:
-  void findNeighbors(const LinearizedTrack* tracks, size_t n, NeighborList& neighbors);
-  void classify(size_t n, const NeighborList& neighbors, std::vector<int32_t>& labels);
+  void findNeighbors(const LinearizedTrack* tracks, size_t n, NeighborList& neighbors) const;
+  void classify(size_t n, const NeighborList& neighbors, std::vector<int32_t>& labels) const;
   void expandCluster(size_t i, int32_t idx, const NeighborList& neighbors, std::vector<int32_t>& labels) const;
 
   DBSCANParams mParams;
@@ -359,9 +359,9 @@ class Grid
   const LinearizedTrack* mTracks;
   size_t mNPoints;
   std::array<float, NDim> mCellSizes;
-  std::array<float, NDim> mMinBounds;
-  std::array<float, NDim> mMaxBounds;
-  std::array<size_t, NDim> mGridDims;
+  std::array<float, NDim> mMinBounds{};
+  std::array<float, NDim> mMaxBounds{};
+  std::array<size_t, NDim> mGridDims{};
   std::vector<GridCell> mCells;
 };
 

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

@@ -25,10 +25,10 @@ namespace o2::its
 float LinearizedTrack::getChi2(const dataformats::VertexBase& v) const
 {
   // get residuals (Y and Z DCA in track frame) and calculate chi2
-  float dx = v.getX() * cosAlp + v.getY() * sinAlp - x; // VX rotated to track frame - trackX
-  float dy = y + tgP * dx - (-v.getX() * sinAlp + v.getY() * cosAlp);
-  float dz = z + tgL * dx - v.getZ();
-  float chi2 = (dy * dy * sig2YI + dz * dz * sig2ZI) + 2. * dy * dz * sigYZI;
+  float dx = (v.getX() * cosAlp) + (v.getY() * sinAlp) - x; // VX rotated to track frame - trackX
+  float dy = y + (tgP * dx) - (-v.getX() * sinAlp + v.getY() * cosAlp);
+  float dz = z + (tgL * dx) - v.getZ();
+  float chi2 = (dy * dy * sig2YI + dz * dz * sig2ZI) + (2.f * dy * dz * sigYZI);
   return chi2 / 2.f; // not using time
 }
 
@@ -38,37 +38,38 @@ void VertexSeed::updateTukeyScale(const LinearizedTrack* ltracks, const int* lab
   if (status == kIterateFirst) {
     scaleSig2ITuk2I = 1.f / (tukeyC * tukeyC);
     return;
-  } else if (status == kIterateRelaxScale) {
+  }
+  if (status == kIterateRelaxScale) {
     // relax by 1/3
     scaleSig2ITuk2I *= 2.f / 3.f;
     return;
-  } else {
-    std::vector<float> chi2s;
-    chi2s.reserve(getNContributors());
+  }
 
-    for (uint32_t entry{ref.getFirstEntry()}; entry < ref.getEntriesBound(); ++entry) {
-      const auto& lt = ltracks[entry];
-      if (lt.isDead() || labels[entry] != idx) {
-        continue;
-      }
-      chi2s.push_back(lt.getChi2((const dataformats::VertexBase&)*this));
-    }
-    if (chi2s.empty()) {
-      return;
-    }
-    // get MAD scale
-    std::sort(chi2s.begin(), chi2s.end());
-    float median = chi2s[chi2s.size() / 2];
-    std::vector<float> dev;
-    dev.reserve(chi2s.size());
-    for (float c : chi2s) {
-      dev.push_back(o2::gpu::CAMath::Abs(c - median));
+  std::vector<float> chi2s;
+  chi2s.reserve(getNContributors());
+
+  for (uint32_t entry{ref.getFirstEntry()}; entry < ref.getEntriesBound(); ++entry) {
+    const auto& lt = ltracks[entry];
+    if (lt.isDead() || labels[entry] != idx) {
+      continue;
     }
-    std::sort(dev.begin(), dev.end());
-    float mad = dev[dev.size() / 2];
-    float scale = sigma2Gaus * mad;
-    scaleSig2ITuk2I = 1.f / (scale * tukeyC * tukeyC);
+    chi2s.push_back(lt.getChi2((const dataformats::VertexBase&)*this));
+  }
+  if (chi2s.empty()) {
+    return;
+  }
+  // get MAD scale
+  std::sort(chi2s.begin(), chi2s.end());
+  float median = chi2s[chi2s.size() / 2];
+  std::vector<float> dev;
+  dev.reserve(chi2s.size());
+  for (float c : chi2s) {
+    dev.push_back(o2::gpu::CAMath::Abs(c - median));
   }
+  std::sort(dev.begin(), dev.end());
+  float mad = dev[dev.size() / 2];
+  float scale = sigma2Gaus * mad;
+  scaleSig2ITuk2I = 1.f / (scale * tukeyC * tukeyC);
 }
 
 void VertexSeed::resetForNewIteration()
@@ -81,14 +82,14 @@ void VertexSeed::resetForNewIteration()
 bool VertexSeed::acceptTrack(const LinearizedTrack& lt)
 {
   float chi2Red = lt.getChi2((const dataformats::VertexBase&)*this);
-  float wghT = (1.f - chi2Red * scaleSig2ITuk2I); // weighted distance to vertex
+  float wghT = (1.f - (chi2Red * scaleSig2ITuk2I)); // weighted distance to vertex
   return wghT >= wghMin;
 }
 
 void VertexSeed::accountTrack(const LinearizedTrack& lt)
 {
   float chi2Red = lt.getChi2((const dataformats::VertexBase&)*this);
-  float wghT = (1.f - chi2Red * scaleSig2ITuk2I); // weighted distance to vertex
+  float wghT = (1.f - (chi2Red * scaleSig2ITuk2I)); // weighted distance to vertex
   if (wghT < wghMin) {
     return;
   }
@@ -103,7 +104,7 @@ void VertexSeed::accountTrack(const LinearizedTrack& lt)
   float tmpSP = lt.sinAlp * lt.tgP, tmpCP = lt.cosAlp * lt.tgP,
         tmpSC = lt.sinAlp + tmpCP, tmpCS = -lt.cosAlp + tmpSP,
         tmpCL = lt.cosAlp * lt.tgL, tmpSL = lt.sinAlp * lt.tgL,
-        tmpYXP = lt.y - lt.tgP * lt.x, tmpZXL = lt.z - lt.tgL * lt.x,
+        tmpYXP = lt.y - (lt.tgP * lt.x), tmpZXL = lt.z - (lt.tgL * lt.x),
         tmpCLzz = tmpCL * szzI, tmpSLzz = tmpSL * szzI, tmpSCyz = tmpSC * syzI,
         tmpCSyz = tmpCS * syzI, tmpCSyy = tmpCS * syyI, tmpSCyy = tmpSC * syyI,
         tmpSLyz = tmpSL * syzI, tmpCLyz = tmpCL * syzI;
@@ -133,15 +134,14 @@ void VertexSeed::solveVertex()
   setXYZ(sol(0), sol(1), sol(2));
   setCov(C(0, 0), C(1, 0), C(1, 1), C(2, 0), C(2, 1), C(2, 2));
   setChi2(wghChi2 / o2::gpu::CAMath::Max(1.f, wghSum - 3.f));
-  return;
 }
 
 namespace dbscan
 {
 
 DBSCAN::DBSCAN(const DBSCANParams& p) : mParams(p), mDistance(mParams.eps) {}
 
-DBSCANResult DBSCAN::cluster(const LinearizedTrack* tracks, size_t n)
+DBSCANResult DBSCAN::cluster(const LinearizedTrack* tracks, size_t n) const
 {
   DBSCANResult result;
   result.labels.resize(n, DB_UNVISITED);
@@ -185,7 +185,7 @@ DBSCANResult DBSCAN::cluster(const LinearizedTrack* tracks, size_t n)
   return result;
 }
 
-void DBSCAN::findNeighbors(const LinearizedTrack* tracks, size_t n, NeighborList& neighbors)
+void DBSCAN::findNeighbors(const LinearizedTrack* tracks, size_t n, NeighborList& neighbors) const
 {
   Grid grid(tracks, n, mParams.eps);
 
@@ -215,7 +215,7 @@ void DBSCAN::findNeighbors(const LinearizedTrack* tracks, size_t n, NeighborList
     });
 }
 
-void DBSCAN::classify(size_t n, const NeighborList& neighbors, std::vector<int32_t>& labels)
+void DBSCAN::classify(size_t n, const NeighborList& neighbors, std::vector<int32_t>& labels) const
 {
   SCOPED_TIMER("classify");
   std::vector<bool> isCore(n, false);