GridContainerIndices.h

Go to the documentation of this file.

#ifndef LARDATA_UTILITIES_GRIDCONTAINERINDICES_H
#define LARDATA_UTILITIES_GRIDCONTAINERINDICES_H


// LArSoft libraries
#include "lardata/Utilities/TensorIndices.h"

// C/C++ standard libraries
#include <cstddef> // std::ptrdiff_t
#include <array>


namespace util {
  
  namespace details {
    
    template <unsigned int DIMS>
    class GridContainerIndicesBase {
      using IndexManager_t = util::TensorIndices<DIMS>;
        public:
      
      static constexpr unsigned int dims() { return DIMS; }
      
      using CellIndex_t = typename IndexManager_t::LinIndex_t;
      
      using CellIndexOffset_t = std::ptrdiff_t;
      
      using CellDimIndex_t = CellIndexOffset_t;
      
      using CellID_t = std::array<CellDimIndex_t, dims()>;
      
      GridContainerIndicesBase(std::array<size_t, dims()> const& new_dims)
        : indices(new_dims.begin())
        {}
      
      
      bool has(CellIndexOffset_t index) const
        { return indices.hasLinIndex(index); }
      
      size_t size() const { return indices.size(); }
      
      
      
      CellIndex_t operator[] (CellID_t id) const { return index(id); }
      
      CellIndexOffset_t offset
        (CellID_t const& origin, CellID_t const& cellID) const
        { return index(cellID) - index(origin); }
      
      
        protected:
      IndexManager_t indices; 
      
      CellIndex_t index(CellID_t id) const
        { return indices(id.begin()); }
      
    }; // GridContainerIndicesBase
    
  } // namespace details
  
  
  
  template <unsigned int DIMS = 1U>
  class GridContainerIndicesBase1D:
    public details::GridContainerIndicesBase<DIMS>
  {
    static_assert(DIMS >= 1U,
      "Dimensions for GridContainerIndicesBase1D must be at least 1");
    using Base_t = details::GridContainerIndicesBase<DIMS>;
    
      public:
    
    using Base_t::GridContainerIndicesBase;
    
    
    bool hasX(typename Base_t::CellDimIndex_t index) const
      { return Base_t::indices.template hasIndex<0>(index); }
    
    size_t sizeX() const { return Base_t::indices.template dim<0>(); }
    
    
  }; // GridContainerIndicesBase1D
  
  
  template <unsigned int DIMS = 2U>
  class GridContainerIndicesBase2D: public GridContainerIndicesBase1D<DIMS> {
    static_assert(DIMS >= 2U,
      "Dimensions for GridContainerIndicesBase2D must be at least 2");
    
    using Base_t = GridContainerIndicesBase1D<DIMS>;
    
      public:
    
    using Base_t::GridContainerIndicesBase1D;
    
    
    bool hasY(typename Base_t::CellDimIndex_t index) const
      { return Base_t::indices.template hasIndex<1>(index); }
    
    size_t sizeY() const { return Base_t::indices.template dim<1>(); }
    
    
  }; // GridContainerIndicesBase2D
  
  
  template <unsigned int DIMS = 3U>
  class GridContainerIndicesBase3D: public GridContainerIndicesBase2D<DIMS> {
    static_assert(DIMS >= 3U,
      "Dimensions for GridContainerIndicesBase3D must be at least 3");
    using Base_t = GridContainerIndicesBase2D<DIMS>;
    
      public:
    
    using Base_t::GridContainerIndicesBase2D;
    
    
    bool hasZ(typename Base_t::CellDimIndex_t index) const
      { return Base_t::indices.template hasIndex<2>(index); }
    
    size_t sizeZ() const { return Base_t::indices.template dim<2>(); }
    
    
  }; // GridContainerIndicesBase3D
    
  
  
  using GridContainer2DIndices = GridContainerIndicesBase2D<>;
    
  using GridContainer3DIndices = GridContainerIndicesBase3D<>;
  
  
} // namespace util



#endif // LARDATA_UTILITIES_GRIDCONTAINERINDICES_H