1/*
2 * CellListIterator_test.hpp
3 *
4 * Created on: May 7, 2016
5 * Author: Yaroslav Zaluzhnyi
6 */
7
8#ifndef OPENFPM_DATA_SRC_NN_CELLLIST_CELLLISTITERATOR_TEST_HPP_
9#define OPENFPM_DATA_SRC_NN_CELLLIST_CELLLISTITERATOR_TEST_HPP_
10
11#include "NN/CellList/CellListIterator.hpp"
12#include "NN/CellList/ParticleIt_Cells.hpp"
13#include "NN/CellList/ParticleItCRS_Cells.hpp"
14
15/*! \brief Fill the cell-list with particles in the box 0.0,1.0
16 *
17 * \param k Number of particles
18 * \param NN Cell-list
19 *
20 */
21template<unsigned int dim, typename CellList> void FillCellList(size_t k, CellList & NN)
22{
23 float pos[dim];
24
25 //Fill with particles
26 for (size_t i = 0; i < k; i++)
27 {
28 for (size_t j = 0; j < dim; j++)
29 {
30 pos[j] = rand()/double(RAND_MAX);
31 }
32 NN.add(pos,i);
33 }
34}
35
36#include "CellListFast_gen.hpp"
37
38BOOST_AUTO_TEST_SUITE( celllist_gen_and_iterator_tests )
39
40BOOST_AUTO_TEST_CASE( celllist_lin_and_iterator_test )
41{
42 ///////// INPUT DATA //////////
43
44 const size_t dim = 3;
45
46 size_t div[dim] = {4,5,6};
47
48 //Number of particles
49 size_t k = 300;
50
51 ///////////////////////////////
52
53 Box<dim,float> box;
54
55 for (size_t i = 0; i < dim; i++)
56 {
57 box.setLow(i,0.0);
58 box.setHigh(i,1.0);
59 }
60
61 // Initialize a cell list
62 CellList_gen<dim,float,Process_keys_lin> NN;
63
64 NN.Initialize(box,div,1);
65 NN.set_gm(k*0.9);
66
67 float pos[dim];
68
69 //Fill with particles
70 for (size_t i = 0; i < k*0.9; i++)
71 {
72 for (size_t j = 0; j < dim; j++)
73 {
74 pos[j] = rand()/double(RAND_MAX);
75 }
76 NN.add(pos,i);
77 }
78
79 //Test the iterator
80 auto it_cl = NN.getIterator();
81
82 size_t count = 0;
83
84 while (it_cl.isNext())
85 {
86 auto p_key = it_cl.get();
87
88 BOOST_REQUIRE(p_key < NN.get_gm());
89
90 count++;
91 ++it_cl;
92 }
93
94 BOOST_REQUIRE_EQUAL(count,NN.get_gm());
95}
96
97BOOST_AUTO_TEST_CASE( celllist_hilb_and_iterator_test )
98{
99 ///////// INPUT DATA //////////
100
101 const size_t dim = 3;
102
103 size_t div[dim] = {4,5,6};
104
105 //Number of particles
106 size_t k = 300;
107
108 ///////////////////////////////
109
110 Box<dim,float> box;
111
112 for (size_t i = 0; i < dim; i++)
113 {
114 box.setLow(i,0.0);
115 box.setHigh(i,1.0);
116 }
117
118 // Initialize a cell list
119 CellList_gen<dim,float,Process_keys_hilb> NN;
120
121 NN.Initialize(box,div,1);
122 NN.set_gm(k*0.9);
123
124 FillCellList<dim>((size_t)k*0.9,NN);
125
126
127 //Test the iterator
128 auto it_cl = NN.getIterator();
129
130 size_t count = 0;
131
132 while (it_cl.isNext())
133 {
134 auto p_key = it_cl.get();
135
136 BOOST_REQUIRE(p_key < NN.get_gm());
137
138 count++;
139 ++it_cl;
140 }
141
142 BOOST_REQUIRE_EQUAL(count,NN.get_gm());
143
144 // Load previous results and check equality
145
146 openfpm::vector<size_t> keys_old;
147
148 keys_old.load("test_data/NN_hilb_keys");
149
150 for (size_t i = 0; i < keys_old.size(); i++)
151 {
152 size_t a1 = keys_old.get(i);
153 size_t a2 = NN.getCellSFC().getKeys().get(i);
154
155 BOOST_REQUIRE_EQUAL(a1,a2);
156 }
157
158 size_t s1 = keys_old.size();
159 size_t s2 = NN.getCellSFC().getKeys().size();
160
161 BOOST_REQUIRE_EQUAL(s1,s2);
162}
163
164BOOST_AUTO_TEST_CASE( ParticleItCRS_Cells_iterator )
165{
166 ///////// INPUT DATA //////////
167
168 const size_t dim = 3;
169
170 size_t div[dim] = {4,5,6};
171 size_t div_p[dim] = {6,7,8};
172
173 grid_sm<3,void> gs(div_p);
174
175 //Number of particles
176 size_t k = 300;
177
178 ///////////////////////////////
179
180 Box<dim,float> box;
181
182 for (size_t i = 0; i < dim; i++)
183 {
184 box.setLow(i,0.0);
185 box.setHigh(i,1.0);
186 }
187
188 // Initialize a cell list
189 CellList<dim,float,Mem_fast<>,shift<dim,float>> NN;
190
191 NN.Initialize(box,div,1);
192
193 FillCellList<dim>(k,NN);
194
195 float pos[dim];
196
197 grid_key_dx<3> start(0,0,0);
198 grid_key_dx<3> stop(div[2]-1+2*NN.getPadding(2),div[1]-1+2*NN.getPadding(1),div[0]-1+2*NN.getPadding(0));
199
200 openfpm::vector<size_t> dom;
201 openfpm::vector<subsub_lin<dim>> anom;
202
203 // No anomalous cells + all domain cells
204 grid_key_dx_iterator_sub<dim> it(gs,start,stop);
205
206 while (it.isNext())
207 {
208 auto key = it.get();
209
210 dom.add(gs.LinId(key));
211
212 ++it;
213 }
214
215 typedef openfpm::vector<Point<3,float>> vector_type;
216
217 //Test the iterator
218 ParticleItCRS_Cells<dim,CellList<dim,float,Mem_fast<>,shift<dim,float>,vector_type>,vector_type> it_cl(NN,dom,anom,NN.getNNc_sym());
219
220 size_t count = 0;
221
222 while (it_cl.isNext())
223 {
224 count++;
225 ++it_cl;
226 }
227
228 BOOST_REQUIRE_EQUAL(count,k);
229
230 //////////////////////////////// KEY ///////////////////////////////
231
232 NN.clear();
233
234 grid_key_dx<3> start2(1,1,1);
235 grid_key_dx<3> stop2(div[2]-2+2*NN.getPadding(2),div[1]-2+2*NN.getPadding(1),div[0]-2+2*NN.getPadding(0));
236
237 //Fill with particles
238 for (size_t i = 0; i < k; i++)
239 {
240 pos[0] = 0.999*rand()/double(RAND_MAX) + 0.0001;
241 pos[1] = 0.999*rand()/double(RAND_MAX) + 0.0001;
242 pos[2] = 0.999*rand()/double(RAND_MAX) + 0.0001;
243
244 NN.add(pos,i);
245 }
246
247 dom.clear();
248
249 bool alternate = false;
250
251 // No anomalous cells + all domain cells
252 grid_key_dx_iterator_sub<dim> it2(gs,start,stop);
253
254 while (it2.isNext())
255 {
256 auto key = it2.get();
257
258 if (alternate == false)
259 {
260 dom.add(gs.LinId(key));
261 alternate = true;
262 }
263 else
264 {
265 anom.add();
266 anom.last().subsub = gs.LinId(key);
267 alternate = false;
268 }
269
270 ++it2;
271 }
272
273 typedef openfpm::vector<Point<dim,float>> vector_type;
274
275 ParticleItCRS_Cells<dim,CellList<dim,float,Mem_fast<>,shift<dim,float>,vector_type>,vector_type> it_cl2(NN,dom,anom,NN.getNNc_sym());
276
277 count = 0;
278
279 while (it_cl2.isNext())
280 {
281 count++;
282 ++it_cl2;
283 }
284
285 BOOST_REQUIRE_EQUAL(count,k);
286}
287
288BOOST_AUTO_TEST_CASE( ParticleIt_Cells_NN_iterator )
289{
290 ///////// INPUT DATA //////////
291
292 const size_t dim = 3;
293
294 size_t div[dim] = {4,5,6};
295 size_t div_p[dim] = {6,7,8};
296
297 grid_sm<3,void> gs2(div);
298 grid_sm<3,void> gs(div_p);
299
300 ///////////////////////////////
301
302 Box<dim,float> box;
303
304 for (size_t i = 0; i < dim; i++)
305 {
306 box.setLow(i,0.0);
307 box.setHigh(i,1.0);
308 }
309
310 // Initialize a cell list
311 CellList<dim,float,Mem_fast<>,shift<dim,float>> NN;
312
313 NN.Initialize(box,div,1);
314
315 grid_key_dx_iterator<3> it(gs2);
316
317 float spacing[dim];
318 float middle[dim];
319 for (size_t i = 0 ; i < dim ; i++)
320 {
321 spacing[i] = box.getHigh(i) / div[i];
322 middle[i] = spacing[i]/2;
323 }
324
325 size_t cnt = 0;
326
327 //Fill with particles
328 openfpm::vector<Point<dim,float>> vp;
329 while (it.isNext())
330 {
331 auto key = it.get();
332
333 Point<3,float> p;
334
335 p.get(0) = key.get(0)*spacing[0] + middle[0];
336 p.get(1) = key.get(1)*spacing[1] + middle[1];
337 p.get(2) = key.get(2)*spacing[2] + middle[2];
338
339 vp.add(p);
340
341 NN.add(p,cnt);
342 cnt++;
343
344 ++it;
345 }
346
347 grid_key_dx<3> start2(2,2,2);
348 grid_key_dx<3> stop2(div[2]-3+2*NN.getPadding(2),div[1]-3+2*NN.getPadding(1),div[0]-3+2*NN.getPadding(0));
349
350 openfpm::vector<size_t> dom;
351 openfpm::vector<subsub_lin<dim>> anom;
352
353 // No anomalous cells + all domain cells
354 grid_key_dx_iterator_sub<dim> it2(gs,start2,stop2);
355
356 bool alternate = false;
357 while (it2.isNext())
358 {
359 auto key = it2.get();
360
361 if (alternate == false)
362 {
363 dom.add(gs.LinId(key));
364 alternate = true;
365 }
366 else
367 {
368 anom.add();
369 anom.last().subsub = gs.LinId(key);
370
371 for(size_t j = 0 ; j < openfpm::math::pow(3,dim)/2+1 ; j++)
372 {anom.last().NN_subsub.add(NN.getNNc_sym()[j]);}
373
374 alternate = false;
375 }
376
377 ++it2;
378 }
379
380 typedef openfpm::vector<Point<dim,float>> vector_type;
381
382 //Test the iterator
383 ParticleItCRS_Cells<dim,CellList<dim,float,Mem_fast<>,shift<dim,float>,vector_type>,vector_type> it_cl(NN,dom,anom,NN.getNNc_sym());
384
385 size_t count = 0;
386
387 while (it_cl.isNext())
388 {
389 auto NN_it = it_cl.getNNIteratorCSR(vp);
390
391 size_t size_NN = 0;
392
393 while (NN_it.isNext())
394 {
395 size_NN++;
396
397 ++NN_it;
398 }
399
400 BOOST_REQUIRE_EQUAL(size_NN,14ul);
401
402 count++;
403 ++it_cl;
404 }
405
406 BOOST_REQUIRE_EQUAL(count,(div[0]-2)*(div[1]-2)*(div[2]-2));
407}
408
409BOOST_AUTO_TEST_CASE( ParticleIt_Cells_iterator )
410{
411 ///////// INPUT DATA //////////
412
413 const size_t dim = 3;
414
415 size_t div[dim] = {4,5,6};
416 size_t div_p[dim] = {6,7,8};
417
418 grid_sm<3,void> gs(div_p);
419
420 //Number of particles
421 size_t k = 300;
422
423 ///////////////////////////////
424
425 Box<dim,float> box;
426
427 for (size_t i = 0; i < dim; i++)
428 {
429 box.setLow(i,0.0);
430 box.setHigh(i,1.0);
431 }
432
433 // Initialize a cell list
434 CellList<dim,float,Mem_fast<>,shift<dim,float>> NN;
435
436 NN.Initialize(box,div,1);
437
438 FillCellList<dim>(k,NN);
439
440 grid_key_dx<3> start(0,0,0);
441 grid_key_dx<3> stop(div[2]-1+2*NN.getPadding(2),div[1]-1+2*NN.getPadding(1),div[0]-1+2*NN.getPadding(0));
442
443
444 // No anomalous cells + all domain cells
445 grid_key_dx_iterator_sub<dim> it(gs,start,stop);
446
447 openfpm::vector<size_t> dom;
448
449 while (it.isNext())
450 {
451 auto key = it.get();
452
453 dom.add(gs.LinId(key));
454
455 ++it;
456 }
457
458 //Test the iterator
459 ParticleIt_Cells<dim,CellList<dim,float,Mem_fast<>,shift<dim,float>>> it_cl(NN,dom,290);
460
461 size_t count = 0;
462
463 while (it_cl.isNext())
464 {
465 auto i = it_cl.get();
466
467 count++;
468 ++it_cl;
469 }
470
471 BOOST_REQUIRE_EQUAL(count,290ul);
472}
473
474BOOST_AUTO_TEST_SUITE_END()
475
476#endif /* OPENFPM_DATA_SRC_NN_CELLLIST_CELLLISTITERATOR_TEST_HPP_ */
477