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, fscal zRef);

    // 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 GetZref() const { return fZref; }

    fscal GetMaxRangeX() const { return fMaxRangeX; }

    fscal GetMaxRangeY() const { return fMaxRangeY; }

    fscal GetMaxRangeT() const { return fMaxRangeT; }

    fscal GetMinZ() const { return fMinZ; }

    fscal GetMaxZ() const { return fMaxZ; }
 
   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 fZref{0.};          
 
    fscal fMaxRangeX{0.};  
    fscal fMaxRangeY{0.};  
    fscal fMaxRangeT{0.};  
    fscal fMinZ{0.};       
    fscal fMaxZ{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