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 <array>
#include <cstddef> // std::ptrdiff_t

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