CaGrid.h

Go to the documentation of this file.

/* Copyright (C) 2010-2023 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Igor Kulakov [committer], Sergey Gorbunov */
 
 
#pragma once  // include this header only once per compilation unit
 
#include "CaGridEntry.h"
#include "CaHit.h"
#include "CaSimd.h"
#include "CaVector.h"
 
namespace cbm::algo::ca
{
 
 
  class Grid {
   public:
    Grid() = default;
 
    ~Grid() = default;
 
    void BuildBins(fscal xMin, fscal xMax, fscal yMin, fscal yMax, fscal binWidthX, fscal binWidthY);
 
    // TODO: write the method with a template input
 
    void StoreHits(const ca::Vector<ca::Hit>& hits, ca::HitIndex_t hitStartIndex, ca::HitIndex_t nHits,
                   const ca::Vector<unsigned char>& hitKeyFlags);
 
    void RemoveUsedHits(const ca::Vector<ca::Hit>& hits, const ca::Vector<unsigned char>& hitKeyFlags);
 
    int GetBin(fscal X, fscal Y) const;
 
    int GetBinX(fscal X) const;
 
    int GetBinY(fscal Y) const;
 
    std::tuple<fscal, fscal> GetBinBoundsX(int iBin) const;
 
    std::tuple<fscal, fscal> GetBinBoundsY(int iBin) const;
 
    int GetNofBins() const { return fN; }
 
    int GetNofBinsX() const { return fNx; }
 
    int GetNofBinsY() const { return fNy; }
 
    ca::HitIndex_t GetFirstBinEntryIndex(int bin) const { return fFirstBinEntryIndex[(bin < fN) ? bin : fN]; }
 
    //ca::HitIndex_t GetNofBinEntries(int bin) const { return fNofBinEntries[bin < fN ? bin : fN]; }
 
    const ca::Vector<ca::GridEntry>& GetEntries() const { return fEntries; }
 
    fscal GetMinX() const { return fMinX; }
 
    fscal GetMinY() const { return fMinY; }
 
    fscal GetBinWidthX() const { return fBinWidthX; }
 
    fscal GetBinWidthY() const { return fBinWidthY; }
 
    fscal GetMaxRangeX() const { return fMaxRangeX; }
 
    fscal GetMaxRangeY() const { return fMaxRangeY; }
 
    fscal GetMaxRangeT() const { return fMaxRangeT; }
 
   private:
 
    int fN{0};   
    int fNx{0};  
    int fNy{0};  
 
    fscal fMinX{0.};          
    fscal fMinY{0.};          
    fscal fBinWidthX{0.};     
    fscal fBinWidthY{0.};     
    fscal fBinWidthXinv{0.};  
    fscal fBinWidthYinv{0.};  
 
    fscal fMaxRangeX{0.};  
    fscal fMaxRangeY{0.};  
    fscal fMaxRangeT{0.};  
 
    ca::Vector<ca::HitIndex_t> fFirstBinEntryIndex{"Grid::fFirstBinEntryIndex", 1,
                                                   0};  
 
    ca::Vector<ca::HitIndex_t> fNofBinEntries{"Grid::fNofBinEntries", 1, 0};  
 
    ca::Vector<ca::GridEntry> fEntries{
      "Ca::Grid::fEntries"};  
  };
 
 
  inline int Grid::GetBin(fscal X, fscal Y) const
  {
    //
    return GetBinY(Y) * fNx + GetBinX(X);
  }
 
  inline int Grid::GetBinX(fscal X) const
  {
    int binX = static_cast<int>((X - fMinX) * fBinWidthXinv);
    return std::max(0, std::min(fNx - 1, binX));
  }
 
  inline int Grid::GetBinY(fscal Y) const
  {
    int binY = static_cast<int>((Y - fMinY) * fBinWidthYinv);
    return std::max(0, std::min(fNy - 1, binY));
  }
 
  inline std::tuple<fscal, fscal> Grid::GetBinBoundsX(int iBin) const
  {
    fscal Xmin = fMinX + (iBin % fNx) * fBinWidthX;
    return std::make_tuple(Xmin, Xmin + fBinWidthX);
  }
 
  inline std::tuple<fscal, fscal> Grid::GetBinBoundsY(int iBin) const
  {
    fscal Ymin = fMinY + (iBin / fNx) * fBinWidthY;
    return std::make_tuple(Ymin, Ymin + fBinWidthY);
  }
 
}  // namespace cbm::algo::ca