1/*
2 * grid_key_dx_iterator.hpp
3 *
4 * Created on: Dec 15, 2015
5 * Author: i-bird
6 */
7
8#ifndef OPENFPM_DATA_SRC_GRID_ITERATORS_GRID_KEY_DX_ITERATOR_HPP_
9#define OPENFPM_DATA_SRC_GRID_ITERATORS_GRID_KEY_DX_ITERATOR_HPP_
10
11#include "Grid/grid_sm.hpp"
12#include "stencil_type.hpp"
13
14/**
15 *
16 * Grid key class iterator, iterate through the grid element
17 *
18 * \tparam dim dimensionality of the grid
19 * \tparam stencil stencil type iterator
20 *
21 * \note if you have a grid you can get this object from getIterator()
22 *
23 * ### Grid iterator declaration and usage ###
24 * \snippet grid_sm_unit_tests.hpp Grid iterator test usage
25 *
26 */
27template<unsigned int dim, typename stencil=no_stencil, typename linearizer = grid_sm<dim,void>>
28class grid_key_dx_iterator
29{
30#ifdef SE_CLASS1
31 // Actual status of the iterator, when the iterator is not initialized cannot be used
32 // and reinitialize must be called
33 bool initialized = false;
34#endif
35
36 //! information of the grid where this iterator iterate
37 linearizer grid_base;
38
39 /*! \brief return the index i of the gk key
40 *
41 * \param i index to get
42 *
43 * \return index value
44 *
45 */
46
47 inline size_t get_gk(size_t i) const
48 {
49 return gk.get(i);
50 }
51
52protected:
53
54 //! Actual key
55 grid_key_dx<dim> gk;
56
57 //! Additional operation and information in case we do stencil
58 //! operations
59 stencil stl_code;
60
61public:
62
63 /*! \brief Default constructor
64 *
65 * \warning entremly unsafe
66 * Before use the iterator you have call reinitialize
67 *
68 */
69 grid_key_dx_iterator()
70 {
71#ifdef SE_CLASS1
72 initialized = false;
73#endif
74 }
75
76 /*! \brief Constructor from a grid_key_dx_iterator<dim>
77 *
78 * \param g_it grid_key_dx_iterator<dim>
79 */
80 grid_key_dx_iterator(const grid_key_dx_iterator<dim> & g_it)
81 : grid_base(g_it.grid_base)
82 {
83 //! Initialize to 0 the index
84
85 for (size_t i = 0 ; i < dim ; i++)
86 {
87 gk.set_d(i,g_it.get_gk(i));
88 }
89
90 stl_code = g_it.stl_code;
91
92#ifdef SE_CLASS1
93 initialized = true;
94#endif
95 }
96
97 /*! \brief Constructor require a grid_sm<dim,T>
98 *
99 * \param g info of the grid on which iterate
100 * \param stencil_pnt stencil points
101 *
102 */
103 template<typename grid_lin>
104 grid_key_dx_iterator(const grid_lin & g,
105 const grid_key_dx<dim> (& stencil_pnt)[stencil::nsp])
106 :grid_base(g)
107 {
108 reset();
109
110 grid_key_dx<dim> zero;
111 for (size_t i = 0 ; i < dim ; i++) {zero.set_d(i,0);}
112
113 // calculate the offsets for the stencil code
114 stl_code.calc_offsets(g,zero,stencil_pnt);
115
116#ifdef SE_CLASS1
117 initialized = true;
118#endif
119 }
120
121 /*! \brief Constructor
122 *
123 * Using this constructor you must call reinitialize
124 *
125 * \param stencil_pnt stencil points
126 *
127 */
128 grid_key_dx_iterator(const grid_key_dx<dim> (& stencil_pnt)[stencil::nsp])
129 {
130 // calculate the offsets for the stencil code
131 stl_code.set_stencil(stencil_pnt);
132 }
133
134 /*! \brief Constructor require a grid_sm<dim,T>
135 *
136 * \param g info of the grid on which iterate
137 */
138 grid_key_dx_iterator(const linearizer & g)
139 : grid_base(g)
140 {
141 reset();
142
143#ifdef SE_CLASS1
144 initialized = true;
145#endif
146 }
147
148 /*! \brief Constructor from another grid_key_dx_iterator
149 *
150 * \param key_it grid_key_dx_iterator
151 *
152 * \return itself
153 *
154 */
155 inline grid_key_dx_iterator<dim> operator=(const grid_key_dx_iterator<dim> & key_it)
156 {
157 grid_base = key_it.grid_base;
158
159 //! Initialize the index using key_it
160
161 for (size_t i = 0 ; i < dim ; i++)
162 {gk.set_d(i,key_it.get_gk(i));}
163
164 return *this;
165 }
166
167 /*! \brief Get the next element
168 *
169 * \return the next grid_key
170 *
171 */
172
173 inline grid_key_dx_iterator<dim,stencil,linearizer> & operator++()
174 {
175 //! increment the first index
176
177 size_t id = gk.get(0);
178 gk.set_d(0,id+1);
179
180 stl_code.increment();
181
182 //! check the overflow of all the index with exception of the last dimensionality
183
184 size_t i = 0;
185 for ( ; i < dim-1 ; i++)
186 {
187 /* coverity[dead_error_begin] */
188 size_t id = gk.get(i);
189 if (id >= grid_base.size(i))
190 {
191 // ! overflow, increment the next index
192
193 size_t idr = gk.get(i);
194 gk.set_d(i,0);
195 id = gk.get(i+1);
196 gk.set_d(i+1,id+1);
197
198 stl_code.adjust_offset(i,idr,grid_base);
199 }
200 else
201 {
202 break;
203 }
204 }
205
206 return *this;
207 }
208
209 /*! \brief Set the dimension
210 *
211 * Set the dimension
212 *
213 * \param d is the dimension
214 * \param sz set the counter to sz
215 *
216 */
217 inline void set(int d, size_t sz)
218 {
219 // set the counter dim to sz
220
221 gk.set_d(d,sz);
222 }
223
224 /*! \brief Get the actual position
225 *
226 * Get the actual position
227 *
228 * \return the actual key
229 *
230 */
231 template<unsigned int id> inline size_t getStencil() const
232 {
233 return stl_code.template getStencil<id>();
234 }
235
236 /*! \brief Check if there is the next element
237 *
238 * Check if there is the next element
239 *
240 * \return true if there is the next, false otherwise
241 *
242 */
243
244 inline bool isNext()
245 {
246 if (gk.get(dim-1) < (long int)grid_base.size(dim-1))
247 {
248 //! we did not reach the end of the grid
249
250 return true;
251 }
252
253 //! we reach the end of the grid
254 return false;
255 }
256
257 /*! \brief Get the actual key
258 *
259 * Get the actual key
260 *
261 * \return the actual key
262 *
263 */
264 inline const grid_key_dx<dim> & get() const
265 {
266 return gk;
267 }
268
269 /*! \brief Reinitialize the grid_key_dx_iterator
270 *
271 * \param key form
272 *
273 */
274 inline void reinitialize(const grid_key_dx_iterator<dim> & key)
275 {
276 grid_base = key.getGridInfo();
277 reset();
278 }
279
280 /*! \brief Get the information about the grid
281 *
282 * \return the grid info
283 *
284 */
285 inline const linearizer & getGridInfo() const
286 {
287 return grid_base;
288 }
289
290 /*! \brief Reset the iterator (it restart from the beginning)
291 *
292 */
293 inline void reset()
294 {
295 // Initialize to 0 the index
296
297 for (size_t i = 0 ; i < dim ; i++)
298 {gk.set_d(i,0);}
299
300 // here we check if grid have a size equal to zero or negative
301 // in this case the grid has no points
302
303 for (size_t i = 0 ; i < dim ; i++)
304 {
305 // If the size of the grid is zero in any dimension set the iterator
306 // to the end point
307 if (grid_base.size(i) == 0)
308 gk.set_d(dim-1,grid_base.size(dim-1));
309 }
310 }
311
312 /*! \brief Calculate the stencil offset
313 *
314 * \param start_p starting point
315 *
316 */
317 void calc_stencil_offset(const grid_key_dx<dim> & start_p)
318 {
319 // calculate the offsets for the stencil code
320 stl_code.calc_offsets(grid_base,start_p);
321 }
322
323 /*! \brief Return the starting point of the iteration
324 *
325 * it is always the point (0,0) in 2D (0,0,0) in 3D ...
326 *
327 */
328 grid_key_dx<dim> getStart()
329 {
330 grid_key_dx<dim> zero;
331 zero.zero();
332 return zero;
333 }
334
335
336 /*! \brief Return the stop point of the iteration
337 *
338 *
339 */
340 grid_key_dx<dim> getStop()
341 {
342 grid_key_dx<dim> stop;
343
344 for (size_t i = 0 ; i < dim ; i++)
345 {
346 stop.set_d(i,grid_base.size(i) - 1);
347 }
348
349 return stop;
350 }
351
352 /*! \brief Get the volume spanned by this sub-grid iterator
353 *
354 * \return the volume
355 *
356 */
357 inline size_t getVolume()
358 {
359 return Box<dim,long int>::getVolumeKey(getStart().k, getStop().k);
360 }
361
362
363};
364
365
366#endif /* OPENFPM_DATA_SRC_GRID_ITERATORS_GRID_KEY_DX_ITERATOR_HPP_ */
367