2 * Copyright (C) 2012-2022 Euclid Science Ground Segment
4 * This library is free software; you can redistribute it and/or modify it under
5 * the terms of the GNU Lesser General Public License as published by the Free
6 * Software Foundation; either version 3.0 of the License, or (at your option)
9 * This library is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
14 * You should have received a copy of the GNU Lesser General Public License
15 * along with this library; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 * @file GridContainer/_impl/GridContainer.icpp
22 * @author Nikolaos Apostolakos
25 #include "ElementsKernel/Exception.h"
26 #include "GridConstructionHelper.h"
29 namespace GridContainer {
31 template <typename GridCellManager, typename... AxesTypes>
32 GridContainer<GridCellManager, AxesTypes...>::GridContainer(GridAxis<AxesTypes>... axes) : m_axes{std::move(axes)...} {
34 GridCellManagerTraits<GridCellManager>::factory(GridConstructionHelper<AxesTypes...>::getAxisIndexFactor(
35 m_axes, TemplateLoopCounter<sizeof...(AxesTypes) - 1>{}));
38 template <typename GridCellManager, typename... AxesTypes>
39 GridContainer<GridCellManager, AxesTypes...>::GridContainer(std::tuple<GridAxis<AxesTypes>...> axes_tuple)
40 : m_axes{std::move(axes_tuple)} {
42 GridCellManagerTraits<GridCellManager>::factory(GridConstructionHelper<AxesTypes...>::getAxisIndexFactor(
43 m_axes, TemplateLoopCounter<sizeof...(AxesTypes) - 1>{}));
46 template <typename GridCellManager, typename... AxesTypes>
47 template <typename... Args>
48 GridContainer<GridCellManager, AxesTypes...>::GridContainer(std::tuple<GridAxis<AxesTypes>...> axes_tuple,
50 : m_axes{std::move(axes_tuple)} {
51 m_cell_manager = GridCellManagerTraits<GridCellManager>::factory(
52 GridConstructionHelper<AxesTypes...>::getAxisIndexFactor(m_axes, TemplateLoopCounter<sizeof...(AxesTypes) - 1>{}),
53 std::forward<Args>(args)...);
56 template <typename... AxesTypes>
57 std::tuple<GridAxis<AxesTypes>...> fixAxis(const std::tuple<GridAxis<AxesTypes>...>& original, size_t axis,
59 std::tuple<GridAxis<AxesTypes>...> result{original};
60 GridConstructionHelper<AxesTypes...>::template findAndFixAxis(result, axis, index, TemplateLoopCounter<0>{});
64 template <typename GridCellManager, typename... AxesTypes>
65 GridContainer<GridCellManager, AxesTypes...>::GridContainer()
67 GridCellManagerTraits<GridCellManager>::factory(GridConstructionHelper<AxesTypes...>::getAxisIndexFactor(
68 m_axes, TemplateLoopCounter<sizeof...(AxesTypes) - 1>{}))} {}
70 template <typename GridCellManager, typename... AxesTypes>
71 GridContainer<GridCellManager, AxesTypes...>::GridContainer(const GridContainer<GridCellManager, AxesTypes...>& other,
72 size_t axis, size_t index)
73 : m_axes{other.m_axes}
74 , m_axes_fixed{fixAxis(other.m_axes, axis, index)}
75 , m_fixed_indices{other.m_fixed_indices}
76 , m_cell_manager{other.m_cell_manager} {
77 // Update the fixed indices
78 if (m_fixed_indices.find(axis) != m_fixed_indices.end()) {
79 throw Elements::Exception() << "Axis " << axis << " is already fixed";
81 m_fixed_indices[axis] = index;
84 template <typename GridCellManager, typename... AxesTypes>
86 auto GridContainer<GridCellManager, AxesTypes...>::getOriginalAxis() const -> const GridAxis<axis_type<I>>& {
87 return std::get<I>(m_axes);
90 template <typename GridCellManager, typename... AxesTypes>
91 constexpr size_t GridContainer<GridCellManager, AxesTypes...>::axisNumber() {
92 return std::tuple_size<decltype(m_axes_fixed)>::value;
95 template <typename GridCellManager, typename... AxesTypes>
97 auto GridContainer<GridCellManager, AxesTypes...>::getAxis() const -> const GridAxis<axis_type<I>>& {
98 return std::get<I>(m_axes_fixed);
101 template <typename GridCellManager, typename... AxesTypes>
102 const std::tuple<GridAxis<AxesTypes>...>& GridContainer<GridCellManager, AxesTypes...>::getAxesTuple() const {
106 template <typename GridCellManager, typename... AxesTypes>
107 auto GridContainer<GridCellManager, AxesTypes...>::begin() -> iterator {
108 iterator result{*this, GridCellManagerTraits<GridCellManager>::begin(*m_cell_manager)};
109 GridConstructionHelper<AxesTypes...>::fixIteratorAxes(result, m_fixed_indices, TemplateLoopCounter<0>{});
113 template <typename GridCellManager, typename... AxesTypes>
114 auto GridContainer<GridCellManager, AxesTypes...>::begin() const -> const_iterator {
115 const_iterator result{*this, GridCellManagerTraits<GridCellManager>::begin(*m_cell_manager)};
116 GridConstructionHelper<AxesTypes...>::fixIteratorAxes(result, m_fixed_indices, TemplateLoopCounter<0>{});
120 template <typename GridCellManager, typename... AxesTypes>
121 auto GridContainer<GridCellManager, AxesTypes...>::cbegin() -> const_iterator {
122 const_iterator result{*this, GridCellManagerTraits<GridCellManager>::begin(*m_cell_manager)};
123 GridConstructionHelper<AxesTypes...>::fixIteratorAxes(result, m_fixed_indices, TemplateLoopCounter<0>{});
127 template <typename GridCellManager, typename... AxesTypes>
128 auto GridContainer<GridCellManager, AxesTypes...>::end() -> iterator {
129 return iterator{*this, GridCellManagerTraits<GridCellManager>::end(*m_cell_manager)};
132 template <typename GridCellManager, typename... AxesTypes>
133 auto GridContainer<GridCellManager, AxesTypes...>::end() const -> const_iterator {
134 return const_iterator{*this, GridCellManagerTraits<GridCellManager>::end(*m_cell_manager)};
137 template <typename GridCellManager, typename... AxesTypes>
138 auto GridContainer<GridCellManager, AxesTypes...>::cend() -> const_iterator {
139 return const_iterator{*this, GridCellManagerTraits<GridCellManager>::end(*m_cell_manager)};
142 template <typename GridCellManager, typename... AxesTypes>
143 size_t GridContainer<GridCellManager, AxesTypes...>::size() const {
144 return m_index_helper_fixed.m_axes_index_factors.back();
147 template <typename GridCellManager, typename... AxesTypes>
148 auto GridContainer<GridCellManager, AxesTypes...>::operator()(
149 decltype(std::declval<GridAxis<AxesTypes>>().size())... indices) const -> const reference_type {
150 size_t total_index = m_index_helper.totalIndex(indices...);
151 // If we have fixed axes we need to move the index accordingly
152 for (auto& pair : m_fixed_indices) {
153 total_index += pair.second * m_index_helper.m_axes_index_factors[pair.first];
155 return (*m_cell_manager)[total_index];
158 template <typename GridCellManager, typename... AxesTypes>
159 auto GridContainer<GridCellManager, AxesTypes...>::operator()(
160 decltype(std::declval<GridAxis<AxesTypes>>().size())... indices) -> reference_type {
161 size_t total_index = m_index_helper.totalIndex(indices...);
162 // If we have fixed axes we need to move the index accordingly
163 for (auto& pair : m_fixed_indices) {
164 total_index += pair.second * m_index_helper.m_axes_index_factors[pair.first];
166 return (*m_cell_manager)[total_index];
169 template <typename GridCellManager, typename... AxesTypes>
170 auto GridContainer<GridCellManager, AxesTypes...>::at(
171 decltype(std::declval<GridAxis<AxesTypes>>().size())... indices) const -> const reference_type {
172 return const_cast<GridContainer*>(this)->at(indices...);
175 template <typename GridCellManager, typename... AxesTypes>
176 auto GridContainer<GridCellManager, AxesTypes...>::at(decltype(std::declval<GridAxis<AxesTypes>>().size())... indices)
178 // First make a check that all the fixed axes are zero
179 m_index_helper.checkAllFixedAreZero(m_fixed_indices, indices...);
180 size_t total_index = m_index_helper.totalIndexChecked(indices...);
181 // If we have fixed axes we need to move the index accordingly
182 for (auto& pair : m_fixed_indices) {
183 total_index += pair.second * m_index_helper.m_axes_index_factors[pair.first];
185 return (*m_cell_manager)[total_index];
188 template <std::size_t I>
189 struct InfimumHelper {
191 using Index = std::size_t;
193 template <typename... AxesType>
194 static std::tuple<Index<AxesType>...> getIndex(const std::tuple<AxesType...>& coords,
195 const std::tuple<GridAxis<AxesType>...>& axes) {
196 std::tuple<Index<AxesType>...> index;
197 getIndex(coords, axes, index);
201 template <typename IndexTuple, typename... AxesType>
202 static void getIndex(const std::tuple<AxesType...>& coords, const std::tuple<GridAxis<AxesType>...>& axes,
204 auto& axn = std::get<I>(axes);
205 std::get<I>(index) = axn.infimum(std::get<I>(coords)) - axn.begin();
206 InfimumHelper<I - 1>::getIndex(coords, axes, index);
211 struct InfimumHelper<0> {
213 using Index = std::size_t;
215 template <typename... AxesType>
216 static std::tuple<std::size_t> getIndex(const std::tuple<AxesType...>& coords,
217 const std::tuple<GridAxis<AxesType>...>& axes) {
218 auto i0 = std::get<0>(axes).infimum(std::get<0>(coords));
219 return std::make_tuple(i0);
222 template <typename IndexTuple, typename... AxesType>
223 static void getIndex(const std::tuple<AxesType...>& coords, const std::tuple<GridAxis<AxesType>...>& axes,
225 auto& ax0 = std::get<0>(axes);
226 std::get<0>(index) = ax0.infimum(std::get<0>(coords)) - ax0.begin();
230 template <typename GridCellManager, typename... AxesTypes>
231 auto GridContainer<GridCellManager, AxesTypes...>::infimum(const AxesTypes... coordinates) const
232 -> std::tuple<decltype(std::declval<GridAxis<AxesTypes>>().size())...> {
233 return infimum(std::make_tuple(coordinates...));
236 template <typename GridCellManager, typename... AxesTypes>
237 auto GridContainer<GridCellManager, AxesTypes...>::infimum(const std::tuple<AxesTypes...>& coords) const
238 -> std::tuple<decltype(std::declval<GridAxis<AxesTypes>>().size())...> {
239 return InfimumHelper<sizeof...(AxesTypes) - 1>::getIndex(coords, m_axes);
242 template <typename GridCellManager, typename... AxesTypes>
244 GridContainer<GridCellManager, AxesTypes...>
245 GridContainer<GridCellManager, AxesTypes...>::fixAxisByIndex(size_t index) {
246 if (index >= getOriginalAxis<I>().size()) {
247 throw Elements::Exception() << "Index (" << index << ") out of axis " << getOriginalAxis<I>().name() << " size ("
248 << getOriginalAxis<I>().size() << ")";
250 return GridContainer<GridCellManager, AxesTypes...>(*this, I, index);
253 template <typename GridCellManager, typename... AxesTypes>
255 const GridContainer<GridCellManager, AxesTypes...>
256 GridContainer<GridCellManager, AxesTypes...>::fixAxisByIndex(size_t index) const {
257 return const_cast<GridContainer<GridCellManager, AxesTypes...>*>(this)->fixAxisByIndex<I>(index);
260 template <typename GridCellManager, typename... AxesTypes>
262 GridContainer<GridCellManager, AxesTypes...>
263 GridContainer<GridCellManager, AxesTypes...>::fixAxisByValue(const axis_type<I>& value) {
264 auto& axis = getOriginalAxis<I>();
265 auto found_axis = std::find(axis.begin(), axis.end(), value);
266 if (found_axis == axis.end()) {
267 throw Elements::Exception() << "Failed to fix axis " << getOriginalAxis<I>().name() << " (given value not found)";
269 return GridContainer<GridCellManager, AxesTypes...>(*this, I, found_axis - axis.begin());
272 template <typename GridCellManager, typename... AxesTypes>
274 const GridContainer<GridCellManager, AxesTypes...>
275 GridContainer<GridCellManager, AxesTypes...>::fixAxisByValue(const axis_type<I>& value) const {
276 return const_cast<GridContainer<GridCellManager, AxesTypes...>*>(this)->fixAxisByValue<I>(value);
279 } // end of namespace GridContainer
280 } // end of namespace Euclid