GridContainer.icpp

Go to the documentation of this file.

 
#include "ElementsKernel/Exception.h"
#include "GridConstructionHelper.h"
 
namespace Euclid {
namespace GridContainer {
 
template <typename GridCellManager, typename... AxesTypes>
GridContainer<GridCellManager, AxesTypes...>::GridContainer(GridAxis<AxesTypes>... axes) : m_axes{std::move(axes)...} {
  m_cell_manager =
      GridCellManagerTraits<GridCellManager>::factory(GridConstructionHelper<AxesTypes...>::getAxisIndexFactor(
          m_axes, TemplateLoopCounter<sizeof...(AxesTypes) - 1>{}));
}
 
template <typename GridCellManager, typename... AxesTypes>
GridContainer<GridCellManager, AxesTypes...>::GridContainer(std::tuple<GridAxis<AxesTypes>...> axes_tuple)
    : m_axes{std::move(axes_tuple)} {
  m_cell_manager =
      GridCellManagerTraits<GridCellManager>::factory(GridConstructionHelper<AxesTypes...>::getAxisIndexFactor(
          m_axes, TemplateLoopCounter<sizeof...(AxesTypes) - 1>{}));
}
 
template <typename GridCellManager, typename... AxesTypes>
template <typename... Args>
GridContainer<GridCellManager, AxesTypes...>::GridContainer(std::tuple<GridAxis<AxesTypes>...> axes_tuple,
                                                            Args&&... args)
    : m_axes{std::move(axes_tuple)} {
  m_cell_manager = GridCellManagerTraits<GridCellManager>::factory(
      GridConstructionHelper<AxesTypes...>::getAxisIndexFactor(m_axes, TemplateLoopCounter<sizeof...(AxesTypes) - 1>{}),
      std::forward<Args>(args)...);
}
 
template <typename... AxesTypes>
std::tuple<GridAxis<AxesTypes>...> fixAxis(const std::tuple<GridAxis<AxesTypes>...>& original, size_t axis,
                                           size_t index) {
  std::tuple<GridAxis<AxesTypes>...> result{original};
  GridConstructionHelper<AxesTypes...>::template findAndFixAxis(result, axis, index, TemplateLoopCounter<0>{});
  return result;
}
 
template <typename GridCellManager, typename... AxesTypes>
GridContainer<GridCellManager, AxesTypes...>::GridContainer()
    : m_cell_manager{
          GridCellManagerTraits<GridCellManager>::factory(GridConstructionHelper<AxesTypes...>::getAxisIndexFactor(
              m_axes, TemplateLoopCounter<sizeof...(AxesTypes) - 1>{}))} {}
 
template <typename GridCellManager, typename... AxesTypes>
GridContainer<GridCellManager, AxesTypes...>::GridContainer(const GridContainer<GridCellManager, AxesTypes...>& other,
                                                            size_t axis, size_t index)
    : m_axes{other.m_axes}
    , m_axes_fixed{fixAxis(other.m_axes, axis, index)}
    , m_fixed_indices{other.m_fixed_indices}
    , m_cell_manager{other.m_cell_manager} {
  // Update the fixed indices
  if (m_fixed_indices.find(axis) != m_fixed_indices.end()) {
    throw Elements::Exception() << "Axis " << axis << " is already fixed";
  }
  m_fixed_indices[axis] = index;
}
 
template <typename GridCellManager, typename... AxesTypes>
auto GridContainer<GridCellManager, AxesTypes...>::copy() const -> GridContainer {
  GridContainer clone{m_axes};
  std::copy(begin(), end(), std::begin(clone));
  return clone;
}
 
template <typename GridCellManager, typename... AxesTypes>
template <int I>
auto GridContainer<GridCellManager, AxesTypes...>::getOriginalAxis() const -> const GridAxis<axis_type<I>>& {
  return std::get<I>(m_axes);
}
 
template <typename GridCellManager, typename... AxesTypes>
constexpr size_t GridContainer<GridCellManager, AxesTypes...>::axisNumber() {
  return std::tuple_size<decltype(m_axes_fixed)>::value;
}
 
template <typename GridCellManager, typename... AxesTypes>
template <int I>
auto GridContainer<GridCellManager, AxesTypes...>::getAxis() const -> const GridAxis<axis_type<I>>& {
  return std::get<I>(m_axes_fixed);
}
 
template <typename GridCellManager, typename... AxesTypes>
const std::tuple<GridAxis<AxesTypes>...>& GridContainer<GridCellManager, AxesTypes...>::getAxesTuple() const {
  return m_axes_fixed;
}
 
template <typename GridCellManager, typename... AxesTypes>
auto GridContainer<GridCellManager, AxesTypes...>::begin() -> iterator {
  iterator result{*this, GridCellManagerTraits<GridCellManager>::begin(*m_cell_manager)};
  GridConstructionHelper<AxesTypes...>::fixIteratorAxes(result, m_fixed_indices, TemplateLoopCounter<0>{});
  return result;
}
 
template <typename GridCellManager, typename... AxesTypes>
auto GridContainer<GridCellManager, AxesTypes...>::begin() const -> const_iterator {
  const_iterator result{*this, GridCellManagerTraits<GridCellManager>::begin(*m_cell_manager)};
  GridConstructionHelper<AxesTypes...>::fixIteratorAxes(result, m_fixed_indices, TemplateLoopCounter<0>{});
  return result;
}
 
template <typename GridCellManager, typename... AxesTypes>
auto GridContainer<GridCellManager, AxesTypes...>::cbegin() -> const_iterator {
  const_iterator result{*this, GridCellManagerTraits<GridCellManager>::begin(*m_cell_manager)};
  GridConstructionHelper<AxesTypes...>::fixIteratorAxes(result, m_fixed_indices, TemplateLoopCounter<0>{});
  return result;
}
 
template <typename GridCellManager, typename... AxesTypes>
auto GridContainer<GridCellManager, AxesTypes...>::end() -> iterator {
  return iterator{*this, GridCellManagerTraits<GridCellManager>::end(*m_cell_manager)};
}
 
template <typename GridCellManager, typename... AxesTypes>
auto GridContainer<GridCellManager, AxesTypes...>::end() const -> const_iterator {
  return const_iterator{*this, GridCellManagerTraits<GridCellManager>::end(*m_cell_manager)};
}
 
template <typename GridCellManager, typename... AxesTypes>
auto GridContainer<GridCellManager, AxesTypes...>::cend() -> const_iterator {
  return const_iterator{*this, GridCellManagerTraits<GridCellManager>::end(*m_cell_manager)};
}
 
template <typename GridCellManager, typename... AxesTypes>
size_t GridContainer<GridCellManager, AxesTypes...>::size() const {
  return m_index_helper_fixed.m_axes_index_factors.back();
}
 
template <typename GridCellManager, typename... AxesTypes>
auto GridContainer<GridCellManager, AxesTypes...>::operator()(
    decltype(std::declval<GridAxis<AxesTypes>>().size())... indices) const -> const reference_type {
  size_t total_index = m_index_helper.totalIndex(indices...);
  // If we have fixed axes we need to move the index accordingly
  for (auto& pair : m_fixed_indices) {
    total_index += pair.second * m_index_helper.m_axes_index_factors[pair.first];
  }
  return (*m_cell_manager)[total_index];
}
 
template <typename GridCellManager, typename... AxesTypes>
auto GridContainer<GridCellManager, AxesTypes...>::operator()(
    decltype(std::declval<GridAxis<AxesTypes>>().size())... indices) -> reference_type {
  size_t total_index = m_index_helper.totalIndex(indices...);
  // If we have fixed axes we need to move the index accordingly
  for (auto& pair : m_fixed_indices) {
    total_index += pair.second * m_index_helper.m_axes_index_factors[pair.first];
  }
  return (*m_cell_manager)[total_index];
}
 
template <typename GridCellManager, typename... AxesTypes>
auto GridContainer<GridCellManager, AxesTypes...>::at(
    decltype(std::declval<GridAxis<AxesTypes>>().size())... indices) const -> const reference_type {
  return const_cast<GridContainer*>(this)->at(indices...);
}
 
template <typename GridCellManager, typename... AxesTypes>
auto GridContainer<GridCellManager, AxesTypes...>::at(decltype(std::declval<GridAxis<AxesTypes>>().size())... indices)
    -> reference_type {
  // First make a check that all the fixed axes are zero
  m_index_helper.checkAllFixedAreZero(m_fixed_indices, indices...);
  size_t total_index = m_index_helper.totalIndexChecked(indices...);
  // If we have fixed axes we need to move the index accordingly
  for (auto& pair : m_fixed_indices) {
    total_index += pair.second * m_index_helper.m_axes_index_factors[pair.first];
  }
  return (*m_cell_manager)[total_index];
}
 
template <std::size_t I>
struct InfimumHelper {
  template <typename>
  using Index = std::size_t;
 
  template <typename... AxesType>
  static std::tuple<Index<AxesType>...> getIndex(const std::tuple<AxesType...>&           coords,
                                                 const std::tuple<GridAxis<AxesType>...>& axes) {
    std::tuple<Index<AxesType>...> index;
    getIndex(coords, axes, index);
    return index;
  }
 
  template <typename IndexTuple, typename... AxesType>
  static void getIndex(const std::tuple<AxesType...>& coords, const std::tuple<GridAxis<AxesType>...>& axes,
                       IndexTuple& index) {
    auto& axn          = std::get<I>(axes);
    std::get<I>(index) = axn.infimum(std::get<I>(coords)) - axn.begin();
    InfimumHelper<I - 1>::getIndex(coords, axes, index);
  }
};
 
template <>
struct InfimumHelper<0> {
  template <typename>
  using Index = std::size_t;
 
  template <typename... AxesType>
  static std::tuple<std::size_t> getIndex(const std::tuple<AxesType...>&           coords,
                                          const std::tuple<GridAxis<AxesType>...>& axes) {
    auto i0 = std::get<0>(axes).infimum(std::get<0>(coords));
    return std::make_tuple(i0);
  }
 
  template <typename IndexTuple, typename... AxesType>
  static void getIndex(const std::tuple<AxesType...>& coords, const std::tuple<GridAxis<AxesType>...>& axes,
                       IndexTuple& index) {
    auto& ax0          = std::get<0>(axes);
    std::get<0>(index) = ax0.infimum(std::get<0>(coords)) - ax0.begin();
  }
};
 
template <typename GridCellManager, typename... AxesTypes>
auto GridContainer<GridCellManager, AxesTypes...>::infimum(const AxesTypes... coordinates) const
    -> std::tuple<decltype(std::declval<GridAxis<AxesTypes>>().size())...> {
  return infimum(std::make_tuple(coordinates...));
}
 
template <typename GridCellManager, typename... AxesTypes>
auto GridContainer<GridCellManager, AxesTypes...>::infimum(const std::tuple<AxesTypes...>& coords) const
    -> std::tuple<decltype(std::declval<GridAxis<AxesTypes>>().size())...> {
  return InfimumHelper<sizeof...(AxesTypes) - 1>::getIndex(coords, m_axes);
}
 
template <typename GridCellManager, typename... AxesTypes>
template <int I>
GridContainer<GridCellManager, AxesTypes...>
GridContainer<GridCellManager, AxesTypes...>::fixAxisByIndex(size_t index) {
  if (index >= getOriginalAxis<I>().size()) {
    throw Elements::Exception() << "Index (" << index << ") out of axis " << getOriginalAxis<I>().name() << " size ("
                                << getOriginalAxis<I>().size() << ")";
  }
  return GridContainer<GridCellManager, AxesTypes...>(*this, I, index);
}
 
template <typename GridCellManager, typename... AxesTypes>
template <int I>
const GridContainer<GridCellManager, AxesTypes...>
GridContainer<GridCellManager, AxesTypes...>::fixAxisByIndex(size_t index) const {
  return const_cast<GridContainer<GridCellManager, AxesTypes...>*>(this)->fixAxisByIndex<I>(index);
}
 
template <typename GridCellManager, typename... AxesTypes>
template <int I>
GridContainer<GridCellManager, AxesTypes...>
GridContainer<GridCellManager, AxesTypes...>::fixAxisByValue(const axis_type<I>& value) {
  auto& axis       = getOriginalAxis<I>();
  auto  found_axis = std::find(axis.begin(), axis.end(), value);
  if (found_axis == axis.end()) {
    throw Elements::Exception() << "Failed to fix axis " << getOriginalAxis<I>().name() << " (given value not found)";
  }
  return GridContainer<GridCellManager, AxesTypes...>(*this, I, found_axis - axis.begin());
}
 
template <typename GridCellManager, typename... AxesTypes>
template <int I>
const GridContainer<GridCellManager, AxesTypes...>
GridContainer<GridCellManager, AxesTypes...>::fixAxisByValue(const axis_type<I>& value) const {
  return const_cast<GridContainer<GridCellManager, AxesTypes...>*>(this)->fixAxisByValue<I>(value);
}
 
}  // end of namespace GridContainer
}  // end of namespace Euclid