1/*
2 * se_class3_vector_unit_tests.hpp
3 *
4 * Created on: Feb 12, 2017
5 * Author: i-bird
6 */
7
8#ifndef SRC_VECTOR_SE_CLASS3_VECTOR_UNIT_TESTS_HPP_
9#define SRC_VECTOR_SE_CLASS3_VECTOR_UNIT_TESTS_HPP_
10
11#ifdef SE_CLASS3
12
13BOOST_AUTO_TEST_SUITE( vector_dist_class3 )
14
15BOOST_AUTO_TEST_CASE( vector_dist_class3_check )
16{
17 Box<2,float> domain({0.0,0.0},{1.0,1.0});
18
19 // Here we define the boundary conditions of our problem
20 size_t bc[2]={PERIODIC,PERIODIC};
21
22 // extended boundary around the domain, and the processor domain
23 Ghost<2,float> g(0.05);
24
25 vector_dist<2,float,aggregate<float,float[3],openfpm::vector<double>>> vd(4096,domain,bc,g);
26
27 bool error = false;
28
29 {
30 auto it = vd.getDomainIterator();
31 try
32 {
33 while (it.isNext())
34 {
35 auto p = it.get();
36
37 // Read something not initialized ERROR
38 Point<2,float> a = vd.getPosRead(p);
39
40 // Suppress compiler error
41 a.get(0) = 0;
42
43 ++it;
44 }
45 }
46 catch (std::exception & e)
47 {
48 error = true;
49 }
50 }
51
52 BOOST_REQUIRE_EQUAL(error,true);
53 error = false;
54
55 // Initialize
56
57 {
58 auto it = vd.getDomainIterator();
59
60 while (it.isNext())
61 {
62 auto p = it.get();
63
64 // Read something not initialized ERROR
65 vd.getPosWrite(p)[0] = (double)rand()/RAND_MAX;
66 vd.getPosWrite(p)[1] = (double)rand()/RAND_MAX;
67
68 ++it;
69 }
70
71 }
72
73 {
74 auto it = vd.getDomainIterator();
75 try
76 {
77 while (it.isNext())
78 {
79 auto p = it.get();
80
81 // Now has bee initialized so not error should be reported
82 Point<2,float> a = vd.getPosRead(p);
83
84 // Suppress compiler error
85 a.get(0) = 0;
86
87 ++it;
88 }
89 }
90 catch (std::exception & e)
91 {
92 error = true;
93 }
94 }
95
96 BOOST_REQUIRE_EQUAL(error,false);
97 error = false;
98
99 // we redistribute the particle
100
101 vd.map();
102
103 try
104 {
105 // Error we are getting the cell list from ghost out of sync in position
106 vd.getCellList(0.05);
107 }
108 catch (std::exception & e)
109 {
110 error = true;
111 }
112
113 BOOST_REQUIRE_EQUAL(error,true);
114 error = false;
115
116 try
117 {
118 // Error we are getting the cell list from ghost out of sync in position
119 vd.getVerlet(0.1);
120 }
121 catch (std::exception & e)
122 {
123 error = true;
124 }
125
126 BOOST_REQUIRE_EQUAL(error,true);
127 error = false;
128
129 try
130 {
131 // Error we are getting the cell list from ghost out of sync in position
132 vd.getCellListSym(0.05);
133 }
134 catch (std::exception & e)
135 {
136 error = true;
137 }
138
139 BOOST_REQUIRE_EQUAL(error,true);
140 error = false;
141
142 vd.ghost_get<0>();
143
144 try
145 {
146 // OK
147 vd.getCellList(0.05);
148 }
149 catch (std::exception & e)
150 {
151 error = true;
152 }
153
154 BOOST_REQUIRE_EQUAL(error,false);
155 error = false;
156
157 // We make dirty a ghost particle
158 vd.template getPropWrite<0>(vd.size_local()) = 0.5;
159
160 try
161 {
162 // Error we are destroying information
163 vd.ghost_get<0>();
164 }
165 catch (std::exception & e)
166 {
167 error = true;
168 }
169
170 BOOST_REQUIRE_EQUAL(error,true);
171 error = false;
172
173 // We make dirty a ghost particle
174 vd.template getPropWrite<0>(vd.size_local()) = 0.5;
175
176 try
177 {
178 // Also error we are also destroying information
179 vd.ghost_get<1>();
180 }
181 catch (std::exception & e)
182 {
183 error = true;
184 }
185
186 BOOST_REQUIRE_EQUAL(error,true);
187 error = false;
188
189 // We make dirty a ghost particle
190 vd.template getPropWrite<0>(vd.size_local()) = 0.5;
191
192 try
193 {
194 // OK we are not destroying information
195 vd.ghost_get<1>(KEEP_PROPERTIES);
196 }
197 catch (std::exception & e)
198 {
199 error = true;
200 }
201
202 BOOST_REQUIRE_EQUAL(error,false);
203 error = false;
204
205 // We make dirty a ghost particle
206 vd.template getPropWrite<0>(vd.size_local()) = 0.5;
207
208 try
209 {
210 // Error we are destroying information
211 vd.ghost_get<0>(KEEP_PROPERTIES);
212 }
213 catch (std::exception & e)
214 {
215 error = true;
216 }
217
218 BOOST_REQUIRE_EQUAL(error,true);
219 error = false;
220
221 try
222 {
223 // error property 0 has never been initialized
224 vd.ghost_put<add_,0>();
225 }
226 catch (std::exception & e)
227 {
228 error = true;
229 }
230
231 BOOST_REQUIRE_EQUAL(error,true);
232 error = false;
233
234 {
235 auto it = vd.getDomainIterator();
236 try
237 {
238 while (it.isNext())
239 {
240 auto p = it.get();
241
242 vd.getPropWrite<0>(p) = 2.0;
243
244 ++it;
245 }
246
247 // OK Property 0 has been initialized
248 vd.ghost_put<add_,0>();
249 }
250 catch (std::exception & e)
251 {
252 error = true;
253 }
254 }
255
256 BOOST_REQUIRE_EQUAL(error,false);
257 error = false;
258
259 try
260 {
261 // OK we are not destroying information
262 vd.ghost_get<0>();
263 }
264 catch (std::exception & e)
265 {
266 error = true;
267 }
268
269 BOOST_REQUIRE_EQUAL(error,false);
270 error = false;
271
272 try
273 {
274 // Error we are getting the cell list from ghost out of sync in position
275 vd.getCellList(0.05);
276 }
277 catch (std::exception & e)
278 {
279 error = true;
280 }
281
282 BOOST_REQUIRE_EQUAL(error,false);
283 error = false;
284
285 BOOST_REQUIRE_EQUAL(vd.get_se_class3().isGhostSync<1>(),NOTSYNC);
286
287 vd.ghost_put<add_,0>();
288 vd.ghost_get<1>();
289
290 auto NN = vd.getCellList(0.05);
291
292 BOOST_REQUIRE_EQUAL(vd.get_se_class3().isGhostSync<1>(),SYNC);
293
294
295 auto it = vd.getDomainIterator();
296
297 while (it.isNext())
298 {
299 auto p = it.get();
300
301 // we set property 1
302 vd.getPropWrite<1>(p)[0] = 1.0;
303 vd.getPropWrite<1>(p)[1] = 1.0;
304 vd.getPropWrite<1>(p)[2] = 1.0;
305
306 ++it;
307 }
308
309 BOOST_REQUIRE_EQUAL(vd.get_se_class3().isGhostSync<1>(),NOTSYNC);
310
311 {
312 auto it = vd.getDomainIterator();
313 try
314 {
315 while (it.isNext())
316 {
317 auto p = it.get();
318
319 Point<2,float> xp = vd.getPosRead(p);
320
321 auto NNp = NN.template getNNIterator<NO_CHECK>(NN.getCell(xp));
322
323 while (NNp.isNext())
324 {
325 auto q = NNp.get();
326
327 // Error ghost is not initialized
328 Point<3,float> xq = vd.template getPropRead<1>(q);
329
330 xq.get(0) = 0.0;
331
332 ++NNp;
333 }
334
335 ++it;
336 }
337 }
338 catch (std::exception & e)
339 {
340 error = true;
341 }
342 }
343
344 BOOST_REQUIRE_EQUAL(error,true);
345 error = false;
346
347 vd.ghost_get<1>();
348
349 {
350 auto it = vd.getDomainIterator();
351
352 while (it.isNext())
353 {
354 auto p = it.get();
355
356 // we set property 1
357 vd.getPropWrite<1>(p)[0] = 1.0;
358 vd.getPropWrite<1>(p)[1] = 1.0;
359 vd.getPropWrite<1>(p)[2] = 1.0;
360
361 ++it;
362 }
363 }
364
365 BOOST_REQUIRE_EQUAL(vd.get_se_class3().isGhostSync<1>(),NOTSYNC);
366
367 {
368 auto it = vd.getDomainIterator();
369 try
370 {
371 while (it.isNext())
372 {
373 auto p = it.get();
374
375 Point<2,float> xp = vd.getPosRead(p);
376
377 auto NNp = NN.template getNNIterator<NO_CHECK>(NN.getCell(xp));
378
379 while (NNp.isNext())
380 {
381 auto q = NNp.get();
382
383 // Error ghost is not initialized
384 Point<3,float> xq = vd.template getPropRead<1>(q);
385
386 xq.get(0) = 0.0;
387
388 ++NNp;
389 }
390
391 ++it;
392 }
393 }
394 catch (std::exception & e)
395 {
396 error = true;
397 }
398 }
399
400 BOOST_REQUIRE_EQUAL(error,true);
401 error = false;
402
403 vd.ghost_get<1>();
404
405 {
406 auto it = vd.getDomainIterator();
407 try
408 {
409 while (it.isNext())
410 {
411 auto p = it.get();
412
413 Point<2,float> xp = vd.getPosRead(p);
414
415 auto NNp = NN.template getNNIterator<NO_CHECK>(NN.getCell(xp));
416
417 while (NNp.isNext())
418 {
419 auto q = NNp.get();
420
421 // Error we forgot ghost_get
422 Point<3,float> xq = vd.template getPropRead<1>(q);
423
424 xq.get(0) = 0.0;
425
426 ++NNp;
427 }
428
429 ++it;
430 }
431 }
432 catch (std::exception & e)
433 {
434 error = true;
435 }
436 }
437
438 BOOST_REQUIRE_EQUAL(error,false);
439}
440
441
442
443///////////////////////////////////////////// Add and Remove test
444
445
446BOOST_AUTO_TEST_CASE( vector_dist_class3_check_add )
447{
448 Box<2,float> domain({0.0,0.0},{1.0,1.0});
449
450 // Here we define the boundary conditions of our problem
451 size_t bc[2]={PERIODIC,PERIODIC};
452
453 // extended boundary around the domain, and the processor domain
454 Ghost<2,float> g(0.05);
455
456 vector_dist<2,float,aggregate<float,float[3],openfpm::vector<double>>> vd(0,domain,bc,g);
457
458 bool error = false;
459
460 // Initialize
461
462 {
463 for (size_t i = 0 ; i < 1200 ; i++)
464 {
465 vd.add();
466
467 // Read something not initialized ERROR
468 vd.getLastPos()[0] = (double)rand()/RAND_MAX;
469 vd.getLastPos()[1] = (double)rand()/RAND_MAX;
470 }
471 }
472
473 {
474 auto it = vd.getDomainIterator();
475 try
476 {
477 while (it.isNext())
478 {
479 auto p = it.get();
480
481 // Now has bee initialized so not error should be reported
482 Point<2,float> a = vd.getPosRead(p);
483
484 //Suppress warnings
485 a.get(0) = 0.0;
486
487 ++it;
488 }
489 }
490 catch (std::exception & e)
491 {
492 error = true;
493 }
494 }
495
496 BOOST_REQUIRE_EQUAL(error,true);
497 error = false;
498
499 vd.map();
500
501 {
502 auto it = vd.getDomainIterator();
503 try
504 {
505 while (it.isNext())
506 {
507 auto p = it.get();
508
509 // Now has bee initialized so not error should be reported
510 float a = vd.getPropRead<0>(p);
511
512 // Suppress warnings
513 a = 0;
514 a++;
515
516 ++it;
517 }
518 }
519 catch (std::exception & e)
520 {
521 error = true;
522 }
523 }
524
525 BOOST_REQUIRE_EQUAL(error,true);
526}
527
528#if defined(CHECKFOR_POSNAN) && defined(CHECKFOR_PROPNAN) && defined(CHECKFOR_POSINF) && defined(CHECKFOR_PROPINF)
529
530
531BOOST_AUTO_TEST_CASE( vector_dist_class3_check_nan_inf )
532{
533 Box<2,float> domain({0.0,0.0},{1.0,1.0});
534
535 // Here we define the boundary conditions of our problem
536 size_t bc[2]={PERIODIC,PERIODIC};
537
538 // extended boundary around the domain, and the processor domain
539 Ghost<2,float> g(0.05);
540
541 vector_dist<2,float,aggregate<float,float[3],openfpm::vector<double>>> vd(0,domain,bc,g);
542
543 bool error = false;
544
545 // Initialize
546
547 {
548 for (size_t i = 0 ; i < 1200 ; i++)
549 {
550 vd.add();
551
552 // Read something not initialized ERROR
553 vd.getLastPos()[0] = 0.0/0.0;
554 vd.getLastPos()[1] = 0.0/0.0;
555 }
556 }
557
558 {
559 try
560 {
561 vd.getPosRead(0);
562 }
563 catch (std::exception & e)
564 {
565 error = true;
566 }
567 }
568
569 BOOST_REQUIRE_EQUAL(error,true);
570 error = false;
571
572 vector_dist<2,float,aggregate<float,float[3],openfpm::vector<double>>> vd2(0,domain,bc,g);
573
574 {
575 for (size_t i = 0 ; i < 1200 ; i++)
576 {
577 vd2.add();
578
579 // Read something not initialized ERROR
580 vd2.getLastPos()[0] = 5.0/0.0;
581 vd2.getLastPos()[1] = 5.0/0.0;
582 }
583 }
584
585 {
586 try
587 {
588 vd2.getLastPosRead();
589 }
590 catch (std::exception & e)
591 {
592 error = true;
593 }
594 }
595
596 BOOST_REQUIRE_EQUAL(error,true);
597}
598
599#endif
600
601BOOST_AUTO_TEST_SUITE_END()
602
603#endif
604
605#endif /* SRC_VECTOR_SE_CLASS3_VECTOR_UNIT_TESTS_HPP_ */
606