1/*
2 * ProcKeys.hpp
3 *
4 * Created on: Mar 14, 2017
5 * Author: i-bird
6 */
7
8#ifndef OPENFPM_DATA_SRC_NN_CELLLIST_PROCKEYS_HPP_
9#define OPENFPM_DATA_SRC_NN_CELLLIST_PROCKEYS_HPP_
10
11extern "C"
12{
13#include "hilbertKey.h"
14}
15
16/* !Brief Class for a linear (1D-like) order processing of cell keys for CellList_gen implementation
17 *
18 * \tparam dim Dimansionality of the space
19 */
20template<unsigned int dim, typename CellList>
21class Process_keys_lin
22{
23 //! stub object
24 openfpm::vector<size_t> keys;
25
26public:
27
28 //! Particle Iterator produced by this key generator
29 typedef ParticleIt_CellP<CellList> Pit;
30
31 /*! \brief Return cellkeys vector
32 *
33 * \return vector of cell keys
34 *
35 */
36 inline const openfpm::vector<size_t> & getKeys() const
37 {
38 return keys;
39 }
40
41 /*! \brief Get a linear (1D-like) key from the coordinates and add to the getKeys vector
42 *
43 * \tparam S Cell list type
44 *
45 * \param obj Cell list object
46 * \param gk grid key
47 * \param m order of a curve
48 */
49 template<typename S> void get_hkey(S & obj, grid_key_dx<dim> gk, size_t m)
50 {
51 size_t point[dim];
52
53 for (size_t i = 0; i < dim; i++)
54 {
55 point[i] = gk.get(i) + obj.getPadding(i);
56 }
57
58 keys.add(obj.getGrid().LinIdPtr(static_cast<size_t *>(point)));
59 }
60
61 template<typename S> void linearize_hkeys(S & obj, size_t m)
62 {
63 return;
64 }
65};
66
67/*! \brief Class for an hilbert order processing of cell keys for CellList_gen implementation
68 *
69 * \tparam dim Dimansionality of the space
70 */
71template<unsigned int dim, typename CellList>
72class Process_keys_hilb
73{
74 //! vector for storing the cell keys
75 openfpm::vector<size_t> keys;
76
77 //! vector for storing the particle keys
78 openfpm::vector<size_t> p_keys;
79
80 //! Order of an hilbert curve
81 size_t m = 0;
82
83public:
84
85 //! Particle Iterator produced by this key generator
86 typedef ParticleIt_CellP<CellList> Pit;
87
88 /*! \brief Return cellkeys vector
89 *
90 * \return vector of cell keys
91 *
92 */
93 inline const openfpm::vector<size_t> & getKeys() const
94 {
95 return keys;
96 }
97
98 /*! \brief Get an hilbert key from the coordinates and add to the getKeys vector
99 *
100 * \tparam S Cell list type
101 *
102 * \param obj Cell list object
103 * \param gk grid key
104 * \param m order of a curve
105 */
106 template<typename S> inline void get_hkey(S & obj, grid_key_dx<dim> gk, size_t m)
107 {
108 //An integer to handle errors
109 int err;
110
111 uint64_t point[dim];
112
113 for (size_t i = 0; i < dim; i++)
114 {
115 point[i] = gk.get(i);
116 }
117
118 size_t hkey = getHKeyFromIntCoord(m, dim, point, &err);
119
120 keys.add(hkey);
121 }
122
123 /*! \brief Get get the coordinates from hilbert key, linearize and add to the getKeys vector
124 *
125 * \tparam S Cell list type
126 *
127 * \param obj Cell list object
128 * \param m order of a curve
129 */
130 template<typename S> inline void linearize_hkeys(S & obj, size_t m)
131 {
132 //An integer to handle errors
133 int err;
134
135 //Array to handle output
136 uint64_t coord[dim];
137 size_t coord2[dim];
138
139 keys.sort();
140
141 openfpm::vector<size_t> keys_new;
142
143 for(size_t i = 0; i < obj.getKeys().size(); i++)
144 {
145 getIntCoordFromHKey(coord, m, dim, obj.getKeys().get(i), &err);
146
147 for (size_t j = 0 ; j < dim ; j++) {coord2[j] = coord[j] + obj.getPadding(j);}
148
149 keys_new.add(obj.getGrid().LinIdPtr(static_cast<size_t *>(coord2)));
150 }
151
152 keys.swap(keys_new);
153 }
154};
155
156/*! \brief Class for an hilbert order processing of cell keys for CellList_gen implementation
157 *
158 * \tparam dim Dimansionality of the space
159 */
160template<unsigned int dim, typename CellList>
161class Process_keys_grid
162{
163 //! vector for storing the cell keys
164 openfpm::vector<size_t> keys;
165
166 //! vector for storing the particle keys
167 openfpm::vector<size_t> p_keys;
168
169 //! Order of an hilbert curve
170 size_t m = 0;
171
172public:
173
174 //! Particle Iterator produced by this key generator
175 typedef ParticleIt_CellP<CellList> Pit;
176
177 /*! \brief Return cellkeys vector
178 *
179 * \return vector of cell keys
180 *
181 */
182 inline const openfpm::vector<size_t> & getKeys() const
183 {
184 return keys;
185 }
186
187 /*! \brief Get an hilbert key from the coordinates and add to the getKeys vector
188 *
189 * \tparam S Cell list type
190 *
191 * \param obj Cell list object
192 * \param gk grid key
193 * \param m order of a curve
194 */
195 template<typename S> inline void get_hkey(S & obj, grid_key_dx<dim> gk, size_t m)
196 {
197 uint64_t point[dim];
198
199 for (size_t i = 0; i < dim; i++)
200 {
201 point[i] = gk.get(i);
202 }
203
204 size_t hkey = obj.getGrid().LinId(gk);
205
206 keys.add(hkey);
207 }
208
209 /*! \brief Get get the coordinates from hilbert key, linearize and add to the getKeys vector
210 *
211 * \tparam S Cell list type
212 *
213 * \param obj Cell list object
214 * \param m order of a curve
215 */
216 template<typename S> inline void linearize_hkeys(S & obj, size_t m)
217 {
218 }
219};
220
221#endif /* OPENFPM_DATA_SRC_NN_CELLLIST_PROCKEYS_HPP_ */
222