Ca: rewrite and restructure of the hit data stored in 2D grids, move grid data to /algo

• rewrite and restructure of the hit data stored in 2D grids
• move the grid structures to /algo library

algo/ca/core/data/CaGrid.cxx

+/* Copyright (C) 2017-2021 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
+   SPDX-License-Identifier: GPL-3.0-only
+   Authors: Maksym Zyzak [committer], Valentina Akishina */
+
+/// \file L1Grid.cxx
+/// \brief Class for storing 2d objects in a grid
+
+
+#include "CaGrid.h"
+
+#include <algorithm>
+
+#include <string.h>
+
+#include "CaHit.h"
+
+
+using namespace cbm::algo::ca;
+using namespace cbm::algo;
+
+
+void Grid::BuildBins(fscal xMin, fscal xMax, fscal yMin, fscal yMax, fscal binWidthX, fscal binWidthY)
+{
+  fMinX = std::min(xMin, xMax);
+  fMinY = std::min(yMin, yMax);
+
+  xMax = std::max(xMin, xMax);
+  yMax = std::max(yMin, yMax);
+
+  fBinWidthX = binWidthX;
+  fBinWidthY = binWidthY;
+
+  // some sanity checks
+  if (fBinWidthX < 0.001) { fBinWidthX = 0.001; }
+  if (fBinWidthY < 0.001) { fBinWidthY = 0.001; }
+
+  fBinWidthXinv = 1. / fBinWidthX;
+  fBinWidthYinv = 1. / fBinWidthY;
+
+  fNx = static_cast<int>(std::ceil((xMax - fMinX) / fBinWidthX));
+  fNy = static_cast<int>(std::ceil((yMax - fMinY) / fBinWidthY));
+
+  // some sanity checks
+  if (fNx < 1) fNx = 1;
+  if (fNy < 1) fNy = 1;
+
+  fN = fNx * fNy;
+
+  fEntries.clear();
+  fFirstBinEntryIndex.reset(fN + 1, 0);
+  fNofBinEntries.reset(fN + 1, 0);
+}
+
+
+void Grid::StoreHits(const Vector<ca::Hit>& hits, ca::HitIndex_t hitStartIndex, ca::HitIndex_t nHits,
+                     const Vector<unsigned char>& hitKeyFlags)
+{
+  fFirstBinEntryIndex.reset(fN + 1, 0);
+  fNofBinEntries.reset(fN + 1, 0);
+
+  int nEntries = 0;
+  for (ca::HitIndex_t ih = 0; ih < nHits; ih++) {
+    const ca::Hit& hit = hits[hitStartIndex + ih];
+    if (!(hitKeyFlags[hit.f] || hitKeyFlags[hit.b])) {
+      fNofBinEntries[GetBin(hit.x, hit.y)]++;
+      nEntries++;
+    }
+  }
+
+  fEntries.reset(nEntries);
+
+  for (int bin = 0; bin < fN; bin++) {
+    fFirstBinEntryIndex[bin + 1] = fFirstBinEntryIndex[bin] + fNofBinEntries[bin];
+    fNofBinEntries[bin]          = 0;
+  }
+  fNofBinEntries[fN] = 0;
+
+  fMaxRangeX = 0.;
+  fMaxRangeY = 0.;
+  fMaxRangeT = 0.;
+
+  for (ca::HitIndex_t ih = 0; ih < nHits; ih++) {
+    const ca::Hit& hit = hits[hitStartIndex + ih];
+    if (!(hitKeyFlags[hit.f] || hitKeyFlags[hit.b])) {
+      int bin = GetBin(hit.x, hit.y);
+      fEntries[fFirstBinEntryIndex[bin] + fNofBinEntries[bin]].Set(hit, hitStartIndex + ih);
+      fNofBinEntries[bin]++;
+      fMaxRangeX = std::max(fMaxRangeX, hit.rangeX);
+      fMaxRangeY = std::max(fMaxRangeY, hit.rangeY);
+      fMaxRangeT = std::max(fMaxRangeT, hit.rangeT);
+    }
+  }
+}
+
+void Grid::RemoveUsedHits(const Vector<ca::Hit>& hits, const Vector<unsigned char>& hitKeyFlags)
+{
+  int nEntries = 0;
+  fMaxRangeX   = 0.;
+  fMaxRangeY   = 0.;
+  fMaxRangeT   = 0.;
+
+  for (int bin = 0; bin < fN; bin++) {
+    ca::HitIndex_t firstEntryOld = fFirstBinEntryIndex[bin];
+    fFirstBinEntryIndex[bin]     = nEntries;
+    fNofBinEntries[bin]          = 0;
+    for (ca::HitIndex_t i = firstEntryOld; i < fFirstBinEntryIndex[bin + 1]; i++) {
+      const ca::Hit& hit = hits[fEntries[i].GetObjectId()];
+      if (!(hitKeyFlags[hit.f] || hitKeyFlags[hit.b])) {
+        fEntries[nEntries] = fEntries[i];
+        nEntries++;
+        fNofBinEntries[bin]++;
+        fMaxRangeX = std::max(fMaxRangeX, hit.rangeX);
+        fMaxRangeY = std::max(fMaxRangeY, hit.rangeY);
+        fMaxRangeT = std::max(fMaxRangeT, hit.rangeT);
+      }
+    }
+  }
+  fFirstBinEntryIndex[fN] = nEntries;
+  fNofBinEntries[fN]      = 0;
+  fEntries.reduce(nEntries);
+}