GeometryIDmapper.h

Go to the documentation of this file.

#ifndef LARCOREALG_GEOMETRY_GEOMETRYIDMAPPER_H
#define LARCOREALG_GEOMETRY_GEOMETRYIDMAPPER_H

// LArSoft libraries
#include "larcoreobj/SimpleTypesAndConstants/geo_types.h"

// C/C++ standard libraries
#include <algorithm> // std::copy()
#include <array>
#include <cassert>
#include <cstdlib> // std::size_t
#include <initializer_list>
#include <type_traits> // std::index_sequence

namespace geo {

  template <typename IDType, typename Index = std::size_t>
  class GeoIDmapper;

  template <typename Index = std::size_t>
  class TPCIDmapper;

  template <typename Index = std::size_t>
  class PlaneIDmapper;

  // ---------------------------------------------------------------------------
  namespace details {

    template <std::size_t N, typename T>
    auto initializerListToArray(std::initializer_list<T> values);

  } // namespace details
  // ---------------------------------------------------------------------------

} // namespace geo

// --- BEGIN Geometry ID mappers -----------------------------------------------

template <typename IDType, typename Index /* = std::size_t */>
class geo::GeoIDmapper {

public:
  using ID_t = IDType;      
  using index_type = Index; 

  GeoIDmapper();

  GeoIDmapper(std::initializer_list<unsigned int> dims);

  // --- BEGIN Indexer status query --------------------------------------------

  index_type size() const;

  bool empty() const;

  template <std::size_t Level>
  unsigned int dimSize() const;

  static constexpr unsigned int dimensions();

  template <typename GeoID = ID_t>
  bool hasElement(GeoID const& id) const;

  template <typename GeoID = ID_t>
  GeoID firstID() const;

  template <typename GeoID = ID_t>
  GeoID lastID() const;

  // --- END Indexer status query ----------------------------------------------

  // --- BEGIN Mapping transformations -----------------------------------------

  index_type index(ID_t const& id) const;

  ID_t ID(index_type const index) const;

  index_type operator()(ID_t const& id) const;

  ID_t operator()(index_type const index) const;

  // --- END Mapping transformations -------------------------------------------

  // --- BEGIN Mapping modification --------------------------------------------

  void resize(std::initializer_list<unsigned int> dims);

  template <typename OIDType, typename OIndex>
  void resizeAs(GeoIDmapper<OIDType, OIndex> const& other);

  void clear();

  // --- END Mapping modification ----------------------------------------------

private:
  using Dimensions_t = std::array<unsigned int, dimensions()>;

  Dimensions_t fN = zeroDimensions();

  template <std::size_t Level, typename GeoID>
  index_type indexLevel(GeoID const& id) const;

  template <std::size_t Level, std::size_t N>
  void fillID(std::array<unsigned int, N>& id, index_type index) const;

  template <std::size_t Level, typename GeoID>
  bool hasElementLevel(GeoID const& id) const;

  index_type computeSize() const;

  template <typename OIDType, typename OIndex, std::size_t... Indices>
  void resizeAsImpl(GeoIDmapper<OIDType, OIndex> const& other, std::index_sequence<Indices...>);

  template <std::size_t Level, typename Dims>
  static index_type sizeLevel(Dims const& dimSizes);

  static Dimensions_t zeroDimensions()
  {
    Dimensions_t dims;
    dims.fill(0);
    return dims;
  }

  template <typename Value, typename Upper>
  static bool bounded(Value v, Upper upper)
  {
    return (v >= 0) && (static_cast<index_type>(v) < upper);
  }

}; // class geo::GeoIDmapper<>

template <typename Index /* = std::size_t */>
class geo::TPCIDmapper : public geo::GeoIDmapper<geo::TPCID, Index> {

  using BaseMapper_t = GeoIDmapper<TPCID, Index>;

public:
  // import types
  using ID_t = typename BaseMapper_t::ID_t;
  using index_type = typename BaseMapper_t::index_type;

  // import all constructors from `geo::GeoIDmapper`
  using BaseMapper_t::BaseMapper_t;

  TPCIDmapper(unsigned int nCryo, unsigned int nTPCs) : BaseMapper_t({nCryo, nTPCs}) {}

  // --- BEGIN Mapping modification --------------------------------------------

  using BaseMapper_t::resize;

  void resize(unsigned int nCryo, unsigned int nTPCs) { BaseMapper_t::resize({nCryo, nTPCs}); }

  // --- END Mapping modification ----------------------------------------------

  // --- BEGIN Mapping status query --------------------------------------------

  bool hasCryostat(CryostatID const& cryoid) const { return BaseMapper_t::hasElement(cryoid); }

  bool hasTPC(TPCID const& tpcid) const { return BaseMapper_t::hasElement(tpcid); }

  // --- END Mapping status query ----------------------------------------------

}; // geo::TPCIDmapper<>

template <typename Index /* = std::size_t */>
class geo::PlaneIDmapper : public geo::GeoIDmapper<geo::PlaneID, Index> {

  using BaseMapper_t = GeoIDmapper<PlaneID, Index>;

public:
  // import types
  using ID_t = typename BaseMapper_t::ID_t;
  using index_type = typename BaseMapper_t::index_type;

  // import all constructors from `geo::GeoIDmapper`
  using BaseMapper_t::BaseMapper_t;

  PlaneIDmapper(unsigned int nCryo, unsigned int nTPCs, unsigned int nPlanes)
    : BaseMapper_t({nCryo, nTPCs, nPlanes})
  {}

  // --- BEGIN Mapping modification --------------------------------------------

  using BaseMapper_t::resize;

  void resize(unsigned int nCryo, unsigned int nTPCs, unsigned int nPlanes)
  {
    BaseMapper_t::resize({nCryo, nTPCs, nPlanes});
  }

  // --- END Mapping modification ----------------------------------------------

  // --- BEGIN Mapping status query --------------------------------------------

  bool hasCryostat(CryostatID const& cryoid) const { return BaseMapper_t::hasElement(cryoid); }

  bool hasTPC(TPCID const& tpcid) const { return BaseMapper_t::hasElement(tpcid); }

  bool hasPlane(PlaneID const& planeid) const { return BaseMapper_t::hasElement(planeid); }

  // --- END Mapping status query ----------------------------------------------

}; // geo::PlaneIDmapper<>

// --- END Geometry ID mappers -------------------------------------------------
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
//--- Template implementation
//------------------------------------------------------------------------------
template <std::size_t N, typename T>
auto geo::details::initializerListToArray(std::initializer_list<T> values)
{
  std::array<T, N> data{}; // <- initializing to quiet the compiler
  std::copy(values.begin(), values.end(), data.begin());
  return data;
}

//------------------------------------------------------------------------------
//--- geo::GeoIDmapper
//------------------------------------------------------------------------------
template <typename IDType, typename Index>
geo::GeoIDmapper<IDType, Index>::GeoIDmapper()
{
  fN.fill(0U);
}

//------------------------------------------------------------------------------
template <typename IDType, typename Index>
geo::GeoIDmapper<IDType, Index>::GeoIDmapper(std::initializer_list<unsigned int> dims)
  : fN(details::initializerListToArray<dimensions()>(dims))
{
  assert(dims.size() == dimensions()); // can't be static
}

//------------------------------------------------------------------------------
template <typename IDType, typename Index>
auto geo::GeoIDmapper<IDType, Index>::size() const -> index_type
{
  return computeSize();
}

//------------------------------------------------------------------------------
template <typename IDType, typename Index>
bool geo::GeoIDmapper<IDType, Index>::empty() const
{
  return size() == index_type{0};
}

//------------------------------------------------------------------------------
template <typename IDType, typename Index>
template <std::size_t Level>
unsigned int geo::GeoIDmapper<IDType, Index>::dimSize() const
{
  if constexpr (Level >= dimensions())
    return 0U; // technically it would be 1...
  else
    return fN[Level];
}

//------------------------------------------------------------------------------
template <typename IDType, typename Index>
constexpr unsigned int geo::GeoIDmapper<IDType, Index>::dimensions()
{
  return IDType::Level + 1;
}

//------------------------------------------------------------------------------
template <typename IDType, typename Index>
template <typename GeoID>
bool geo::GeoIDmapper<IDType, Index>::hasElement(GeoID const& id) const
{
  return hasElementLevel<GeoID::Level>(id);
}

//------------------------------------------------------------------------------
template <typename IDType, typename Index>
template <typename GeoID /* = ID_t */>
GeoID geo::GeoIDmapper<IDType, Index>::firstID() const
{
  if constexpr (GeoID::Level == 0)
    return GeoID(0U);
  else
    return GeoID(firstID<typename GeoID::ParentID_t>(), 0U);
}

//------------------------------------------------------------------------------
template <typename IDType, typename Index>
template <typename GeoID /* = ID_t */>
GeoID geo::GeoIDmapper<IDType, Index>::lastID() const
{
  if constexpr (GeoID::Level == 0)
    return GeoID(fN[GeoID::Level] - 1U);
  else
    return GeoID(lastID<typename GeoID::ParentID_t>(), fN[GeoID::Level] - 1U);
}

//------------------------------------------------------------------------------
template <typename IDType, typename Index>
auto geo::GeoIDmapper<IDType, Index>::index(ID_t const& id) const -> index_type
{
  return indexLevel<ID_t::Level>(id);
}

//------------------------------------------------------------------------------
template <typename IDType, typename Index>
auto geo::GeoIDmapper<IDType, Index>::ID(index_type const index) const -> ID_t
{
  std::array<unsigned int, ID_t::Level + 1u> numbers;
  fillID<ID_t::Level>(numbers, index);
  auto id = std::make_from_tuple<ID_t>(numbers);
  id.setValidity(id.Cryostat < fN[0u]);
  return id;
}

//------------------------------------------------------------------------------
template <typename IDType, typename Index>
auto geo::GeoIDmapper<IDType, Index>::operator()(ID_t const& id) const -> index_type
{
  return index(id);
}

//------------------------------------------------------------------------------
template <typename IDType, typename Index>
auto geo::GeoIDmapper<IDType, Index>::operator()(index_type const index) const -> ID_t
{
  return ID(index);
}

//------------------------------------------------------------------------------
template <typename IDType, typename Index>
void geo::GeoIDmapper<IDType, Index>::resize(std::initializer_list<unsigned int> dims)
{
  fN = details::initializerListToArray<dimensions()>(dims);
}

//------------------------------------------------------------------------------
template <typename IDType, typename Index>
template <typename OIDType, typename OIndex>
void geo::GeoIDmapper<IDType, Index>::resizeAs(GeoIDmapper<OIDType, OIndex> const& other)
{
  resizeAsImpl(other, std::make_index_sequence<dimensions()>{});
}

//------------------------------------------------------------------------------
template <typename IDType, typename Index>
void geo::GeoIDmapper<IDType, Index>::clear()
{
  fN.fill(0U);
}

//------------------------------------------------------------------------------
template <typename IDType, typename Index>
template <std::size_t Level, typename GeoID>
auto geo::GeoIDmapper<IDType, Index>::indexLevel(GeoID const& id) const -> index_type
{
  if constexpr (Level == 0)
    return id.template getIndex<0U>();
  else {
    return indexLevel<(Level - 1U)>(id) * fN[Level] + id.template getIndex<Level>();
  }
}

//------------------------------------------------------------------------------
template <typename IDType, typename Index>
template <std::size_t Level, std::size_t N>
void geo::GeoIDmapper<IDType, Index>::fillID(std::array<unsigned int, N>& numbers,
                                             index_type index) const
{
  if constexpr (Level == 0) { numbers[0] = index; }
  else {
    numbers[Level] = index % fN[Level];
    fillID<Level - 1U>(numbers, index / fN[Level]);
  }
}

//------------------------------------------------------------------------------
template <typename IDType, typename Index>
template <std::size_t Level, typename GeoID>
bool geo::GeoIDmapper<IDType, Index>::hasElementLevel(GeoID const& id) const
{
  if (!bounded(id.template getIndex<Level>(), fN[Level])) return false;
  if constexpr (Level == 0U)
    return true;
  else
    return hasElementLevel<(Level - 1U)>(id);
}

//------------------------------------------------------------------------------
template <typename IDType, typename Index>
auto geo::GeoIDmapper<IDType, Index>::computeSize() const -> index_type
{
  return sizeLevel<0U>(fN);
}

//------------------------------------------------------------------------------
template <typename IDType, typename Index>
template <typename OIDType, typename OIndex, std::size_t... Indices>
void geo::GeoIDmapper<IDType, Index>::resizeAsImpl(GeoIDmapper<OIDType, OIndex> const& other,
                                                   std::index_sequence<Indices...>)
{
  // Clang 5.0.1 does not understand `other.dimensions()` is constexpr
  static_assert(GeoIDmapper<OIDType, OIndex>::dimensions() >= dimensions(),
                "Can't resize a deeper mapping to a shallower one.");
  resize({other.template dimSize<Indices>()...});
}

//------------------------------------------------------------------------------
template <typename IDType, typename Index>
template <std::size_t Level, typename Dims>
auto geo::GeoIDmapper<IDType, Index>::sizeLevel(Dims const& dimSizes) -> index_type
{
  if constexpr (Level >= dimensions())
    return 1U;
  else
    return sizeLevel<(Level + 1U)>(dimSizes) * dimSizes[Level];
}

//------------------------------------------------------------------------------

#endif // LARCOREALG_GEOMETRY_GEOMETRYIDMAPPER_H