Alexandria 2.31.0
SDC-CH common library for the Euclid project
Loading...
Searching...
No Matches
GridContainer.icpp
Go to the documentation of this file.
1/**
2 * Copyright (C) 2012-2022 Euclid Science Ground Segment
3 *
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)
7 * any later version.
8 *
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
12 * details.
13 *
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
17 */
18
19/**
20 * @file GridContainer/_impl/GridContainer.icpp
21 * @date May 13, 2014
22 * @author Nikolaos Apostolakos
23 */
24
25#include "ElementsKernel/Exception.h"
26#include "GridConstructionHelper.h"
27
28namespace Euclid {
29namespace GridContainer {
30
31template <typename GridCellManager, typename... AxesTypes>
32GridContainer<GridCellManager, AxesTypes...>::GridContainer(GridAxis<AxesTypes>... axes) : m_axes{std::move(axes)...} {
33 m_cell_manager =
34 GridCellManagerTraits<GridCellManager>::factory(GridConstructionHelper<AxesTypes...>::getAxisIndexFactor(
35 m_axes, TemplateLoopCounter<sizeof...(AxesTypes) - 1>{}));
36}
37
38template <typename GridCellManager, typename... AxesTypes>
39GridContainer<GridCellManager, AxesTypes...>::GridContainer(std::tuple<GridAxis<AxesTypes>...> axes_tuple)
40 : m_axes{std::move(axes_tuple)} {
41 m_cell_manager =
42 GridCellManagerTraits<GridCellManager>::factory(GridConstructionHelper<AxesTypes...>::getAxisIndexFactor(
43 m_axes, TemplateLoopCounter<sizeof...(AxesTypes) - 1>{}));
44}
45
46template <typename GridCellManager, typename... AxesTypes>
47template <typename... Args>
48GridContainer<GridCellManager, AxesTypes...>::GridContainer(std::tuple<GridAxis<AxesTypes>...> axes_tuple,
49 Args&&... args)
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)...);
54}
55
56template <typename... AxesTypes>
57std::tuple<GridAxis<AxesTypes>...> fixAxis(const std::tuple<GridAxis<AxesTypes>...>& original, size_t axis,
58 size_t index) {
59 std::tuple<GridAxis<AxesTypes>...> result{original};
60 GridConstructionHelper<AxesTypes...>::template findAndFixAxis(result, axis, index, TemplateLoopCounter<0>{});
61 return result;
62}
63
64template <typename GridCellManager, typename... AxesTypes>
65GridContainer<GridCellManager, AxesTypes...>::GridContainer()
66 : m_cell_manager{
67 GridCellManagerTraits<GridCellManager>::factory(GridConstructionHelper<AxesTypes...>::getAxisIndexFactor(
68 m_axes, TemplateLoopCounter<sizeof...(AxesTypes) - 1>{}))} {}
69
70template <typename GridCellManager, typename... AxesTypes>
71GridContainer<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";
80 }
81 m_fixed_indices[axis] = index;
82}
83
84template <typename GridCellManager, typename... AxesTypes>
85auto GridContainer<GridCellManager, AxesTypes...>::copy() const -> GridContainer {
86 GridContainer clone{m_axes};
87 std::copy(begin(), end(), std::begin(clone));
88 return clone;
89}
90
91template <typename GridCellManager, typename... AxesTypes>
92template <int I>
93auto GridContainer<GridCellManager, AxesTypes...>::getOriginalAxis() const -> const GridAxis<axis_type<I>>& {
94 return std::get<I>(m_axes);
95}
96
97template <typename GridCellManager, typename... AxesTypes>
98constexpr size_t GridContainer<GridCellManager, AxesTypes...>::axisNumber() {
99 return std::tuple_size<decltype(m_axes_fixed)>::value;
100}
101
102template <typename GridCellManager, typename... AxesTypes>
103template <int I>
104auto GridContainer<GridCellManager, AxesTypes...>::getAxis() const -> const GridAxis<axis_type<I>>& {
105 return std::get<I>(m_axes_fixed);
106}
107
108template <typename GridCellManager, typename... AxesTypes>
109const std::tuple<GridAxis<AxesTypes>...>& GridContainer<GridCellManager, AxesTypes...>::getAxesTuple() const {
110 return m_axes_fixed;
111}
112
113template <typename GridCellManager, typename... AxesTypes>
114auto GridContainer<GridCellManager, AxesTypes...>::begin() -> iterator {
115 iterator result{*this, GridCellManagerTraits<GridCellManager>::begin(*m_cell_manager)};
116 GridConstructionHelper<AxesTypes...>::fixIteratorAxes(result, m_fixed_indices, TemplateLoopCounter<0>{});
117 return result;
118}
119
120template <typename GridCellManager, typename... AxesTypes>
121auto GridContainer<GridCellManager, AxesTypes...>::begin() const -> const_iterator {
122 const_iterator result{*this, GridCellManagerTraits<GridCellManager>::begin(*m_cell_manager)};
123 GridConstructionHelper<AxesTypes...>::fixIteratorAxes(result, m_fixed_indices, TemplateLoopCounter<0>{});
124 return result;
125}
126
127template <typename GridCellManager, typename... AxesTypes>
128auto GridContainer<GridCellManager, AxesTypes...>::cbegin() -> const_iterator {
129 const_iterator result{*this, GridCellManagerTraits<GridCellManager>::begin(*m_cell_manager)};
130 GridConstructionHelper<AxesTypes...>::fixIteratorAxes(result, m_fixed_indices, TemplateLoopCounter<0>{});
131 return result;
132}
133
134template <typename GridCellManager, typename... AxesTypes>
135auto GridContainer<GridCellManager, AxesTypes...>::end() -> iterator {
136 return iterator{*this, GridCellManagerTraits<GridCellManager>::end(*m_cell_manager)};
137}
138
139template <typename GridCellManager, typename... AxesTypes>
140auto GridContainer<GridCellManager, AxesTypes...>::end() const -> const_iterator {
141 return const_iterator{*this, GridCellManagerTraits<GridCellManager>::end(*m_cell_manager)};
142}
143
144template <typename GridCellManager, typename... AxesTypes>
145auto GridContainer<GridCellManager, AxesTypes...>::cend() -> const_iterator {
146 return const_iterator{*this, GridCellManagerTraits<GridCellManager>::end(*m_cell_manager)};
147}
148
149template <typename GridCellManager, typename... AxesTypes>
150size_t GridContainer<GridCellManager, AxesTypes...>::size() const {
151 return m_index_helper_fixed.m_axes_index_factors.back();
152}
153
154template <typename GridCellManager, typename... AxesTypes>
155auto GridContainer<GridCellManager, AxesTypes...>::operator()(
156 decltype(std::declval<GridAxis<AxesTypes>>().size())... indices) const -> const reference_type {
157 size_t total_index = m_index_helper.totalIndex(indices...);
158 // If we have fixed axes we need to move the index accordingly
159 for (auto& pair : m_fixed_indices) {
160 total_index += pair.second * m_index_helper.m_axes_index_factors[pair.first];
161 }
162 return (*m_cell_manager)[total_index];
163}
164
165template <typename GridCellManager, typename... AxesTypes>
166auto GridContainer<GridCellManager, AxesTypes...>::operator()(
167 decltype(std::declval<GridAxis<AxesTypes>>().size())... indices) -> reference_type {
168 size_t total_index = m_index_helper.totalIndex(indices...);
169 // If we have fixed axes we need to move the index accordingly
170 for (auto& pair : m_fixed_indices) {
171 total_index += pair.second * m_index_helper.m_axes_index_factors[pair.first];
172 }
173 return (*m_cell_manager)[total_index];
174}
175
176template <typename GridCellManager, typename... AxesTypes>
177auto GridContainer<GridCellManager, AxesTypes...>::at(
178 decltype(std::declval<GridAxis<AxesTypes>>().size())... indices) const -> const reference_type {
179 return const_cast<GridContainer*>(this)->at(indices...);
180}
181
182template <typename GridCellManager, typename... AxesTypes>
183auto GridContainer<GridCellManager, AxesTypes...>::at(decltype(std::declval<GridAxis<AxesTypes>>().size())... indices)
184 -> reference_type {
185 // First make a check that all the fixed axes are zero
186 m_index_helper.checkAllFixedAreZero(m_fixed_indices, indices...);
187 size_t total_index = m_index_helper.totalIndexChecked(indices...);
188 // If we have fixed axes we need to move the index accordingly
189 for (auto& pair : m_fixed_indices) {
190 total_index += pair.second * m_index_helper.m_axes_index_factors[pair.first];
191 }
192 return (*m_cell_manager)[total_index];
193}
194
195template <std::size_t I>
196struct InfimumHelper {
197 template <typename>
198 using Index = std::size_t;
199
200 template <typename... AxesType>
201 static std::tuple<Index<AxesType>...> getIndex(const std::tuple<AxesType...>& coords,
202 const std::tuple<GridAxis<AxesType>...>& axes) {
203 std::tuple<Index<AxesType>...> index;
204 getIndex(coords, axes, index);
205 return index;
206 }
207
208 template <typename IndexTuple, typename... AxesType>
209 static void getIndex(const std::tuple<AxesType...>& coords, const std::tuple<GridAxis<AxesType>...>& axes,
210 IndexTuple& index) {
211 auto& axn = std::get<I>(axes);
212 std::get<I>(index) = axn.infimum(std::get<I>(coords)) - axn.begin();
213 InfimumHelper<I - 1>::getIndex(coords, axes, index);
214 }
215};
216
217template <>
218struct InfimumHelper<0> {
219 template <typename>
220 using Index = std::size_t;
221
222 template <typename... AxesType>
223 static std::tuple<std::size_t> getIndex(const std::tuple<AxesType...>& coords,
224 const std::tuple<GridAxis<AxesType>...>& axes) {
225 auto i0 = std::get<0>(axes).infimum(std::get<0>(coords));
226 return std::make_tuple(i0);
227 }
228
229 template <typename IndexTuple, typename... AxesType>
230 static void getIndex(const std::tuple<AxesType...>& coords, const std::tuple<GridAxis<AxesType>...>& axes,
231 IndexTuple& index) {
232 auto& ax0 = std::get<0>(axes);
233 std::get<0>(index) = ax0.infimum(std::get<0>(coords)) - ax0.begin();
234 }
235};
236
237template <typename GridCellManager, typename... AxesTypes>
238auto GridContainer<GridCellManager, AxesTypes...>::infimum(const AxesTypes... coordinates) const
239 -> std::tuple<decltype(std::declval<GridAxis<AxesTypes>>().size())...> {
240 return infimum(std::make_tuple(coordinates...));
241}
242
243template <typename GridCellManager, typename... AxesTypes>
244auto GridContainer<GridCellManager, AxesTypes...>::infimum(const std::tuple<AxesTypes...>& coords) const
245 -> std::tuple<decltype(std::declval<GridAxis<AxesTypes>>().size())...> {
246 return InfimumHelper<sizeof...(AxesTypes) - 1>::getIndex(coords, m_axes);
247}
248
249template <typename GridCellManager, typename... AxesTypes>
250template <int I>
251GridContainer<GridCellManager, AxesTypes...>
252GridContainer<GridCellManager, AxesTypes...>::fixAxisByIndex(size_t index) {
253 if (index >= getOriginalAxis<I>().size()) {
254 throw Elements::Exception() << "Index (" << index << ") out of axis " << getOriginalAxis<I>().name() << " size ("
255 << getOriginalAxis<I>().size() << ")";
256 }
257 return GridContainer<GridCellManager, AxesTypes...>(*this, I, index);
258}
259
260template <typename GridCellManager, typename... AxesTypes>
261template <int I>
262const GridContainer<GridCellManager, AxesTypes...>
263GridContainer<GridCellManager, AxesTypes...>::fixAxisByIndex(size_t index) const {
264 return const_cast<GridContainer<GridCellManager, AxesTypes...>*>(this)->fixAxisByIndex<I>(index);
265}
266
267template <typename GridCellManager, typename... AxesTypes>
268template <int I>
269GridContainer<GridCellManager, AxesTypes...>
270GridContainer<GridCellManager, AxesTypes...>::fixAxisByValue(const axis_type<I>& value) {
271 auto& axis = getOriginalAxis<I>();
272 auto found_axis = std::find(axis.begin(), axis.end(), value);
273 if (found_axis == axis.end()) {
274 throw Elements::Exception() << "Failed to fix axis " << getOriginalAxis<I>().name() << " (given value not found)";
275 }
276 return GridContainer<GridCellManager, AxesTypes...>(*this, I, found_axis - axis.begin());
277}
278
279template <typename GridCellManager, typename... AxesTypes>
280template <int I>
281const GridContainer<GridCellManager, AxesTypes...>
282GridContainer<GridCellManager, AxesTypes...>::fixAxisByValue(const axis_type<I>& value) const {
283 return const_cast<GridContainer<GridCellManager, AxesTypes...>*>(this)->fixAxisByValue<I>(value);
284}
285
286} // end of namespace GridContainer
287} // end of namespace Euclid