10 #ifndef SRC_VECTOR_VECTOR_DIST_CELL_LIST_TESTS_HPP_
11 #define SRC_VECTOR_VECTOR_DIST_CELL_LIST_TESTS_HPP_
16 BOOST_AUTO_TEST_CASE( vector_dist_reorder_2d_test )
26 std::default_random_engine eg;
27 std::uniform_real_distribution<float> ud(0.0f, 1.0f);
29 #ifdef TEST_COVERAGE_MODE
35 long int big_step = k / 4;
36 big_step = (big_step == 0)?1:big_step;
38 print_test_v(
"Testing 2D vector with hilbert curve reordering k<=",k);
41 for ( ; k >= 2 ; k-= decrement(k,big_step) )
43 BOOST_TEST_CHECKPOINT(
"Testing 2D vector with hilbert curve reordering k=" << k );
48 size_t bc[2]={NON_PERIODIC,NON_PERIODIC};
52 auto it = vd.getIterator();
58 vd.getPos(
key)[0] = ud(eg);
59 vd.getPos(
key)[1] = ud(eg);
70 auto NN1 = vd.getCellList(0.01,
true);
79 auto NN2 = vd.getCellList(0.01,
true);
82 for (
size_t i = 0 ; i < NN1.getGrid().size() ; i++)
84 size_t n1 = NN1.getNelements(i);
85 size_t n2 = NN2.getNelements(i);
87 BOOST_REQUIRE_EQUAL(n1,n2);
92 BOOST_AUTO_TEST_CASE( vector_dist_cl_random_vs_hilb_forces_test )
102 const size_t dim = 3;
106 size_t cl_k_start = 10000;
108 size_t cl_k_min = 1000;
110 double ghost_part = 0.05;
115 for (
size_t r = 0; r < cl_r_cutoff.size(); r++ )
118 float r_cut = cl_r_cutoff.get(r);
123 std::string str(
"Testing " + std::to_string(dim) +
"D vector's forces (random vs hilb celllist) k<=");
125 vector_dist_test::print_test_v(str,k);
128 for (
size_t k_int = k ; k_int >= cl_k_min ; k_int/=2 )
130 BOOST_TEST_CHECKPOINT(
"Testing " << dim <<
"D vector's forces (random vs hilb celllist) k<=" << k_int );
134 for (
size_t i = 0; i < dim; i++)
143 for (
size_t i = 0; i < dim; i++)
151 vd_initialize_double<dim>(vd, vd2, v_cl, k_int);
158 auto NN = vd.getCellList(r_cut);
162 calc_forces<dim>(NN,vd,r_cut);
166 auto NN_hilb = vd2.getCellList_hilb(r_cut);
169 calc_forces_hilb<dim>(NN_hilb,vd2,r_cut);
174 for (
size_t i = 0 ; i < dim ; i++) {avg.
get(i) = 0.0;}
176 auto it_v2 = vd.getIterator();
177 while (it_v2.isNext())
182 for (
size_t i = 0; i < dim; i++)
183 avg.
get(i) += fabs(vd.getProp<0>(key)[i]);
189 for (
size_t i = 0 ; i < dim ; i++) {avg.
get(i) /= count;}
191 auto it_v = vd.getIterator();
192 while (it_v.isNext())
197 for (
size_t i = 0; i < dim; i++)
199 auto a1 = vd.getProp<0>(key)[i];
200 auto a2 = vd2.getProp<0>(key)[i];
205 per = fabs(0.1*avg.
get(i)/a1);
207 BOOST_REQUIRE_CLOSE((
float)a1,(
float)a2,per);
216 BOOST_AUTO_TEST_CASE( vector_dist_cl_random_vs_reorder_forces_test )
218 Vcluster & v_cl = create_vcluster();
226 const size_t dim = 3;
230 size_t cl_k_start = 10000;
232 size_t cl_k_min = 1000;
234 double ghost_part = 0.01;
239 for (
size_t r = 0; r < cl_r_cutoff.size(); r++ )
242 float r_cut = cl_r_cutoff.get(r);
247 std::string str(
"Testing " + std::to_string(dim) +
"D vector's forces (random vs reorder) k<=");
249 vector_dist_test::print_test_v(str,k);
252 for (
size_t k_int = k ; k_int >= cl_k_min ; k_int/=2 )
254 BOOST_TEST_CHECKPOINT(
"Testing " << dim <<
"D vector's forces (random vs reorder) k<=" << k_int );
258 for (
size_t i = 0; i < dim; i++)
267 for (
size_t i = 0; i < dim; i++)
273 vd_initialize<dim,decltype(vd)>(vd, v_cl, k_int);
279 auto NN1 = vd.getCellList(r_cut);
283 calc_forces<dim>(NN1,vd,r_cut);
291 auto NN2 = vd.getCellList(r_cut);
294 calc_forces<dim,1>(NN2,vd,r_cut);
299 for (
size_t i = 0 ; i < dim ; i++) {avg.
get(i) = 0.0;}
301 auto it_v2 = vd.getIterator();
302 while (it_v2.isNext())
307 for (
size_t i = 0; i < dim; i++)
308 avg.
get(i) += fabs(vd.getProp<0>(key)[i]);
314 for (
size_t i = 0 ; i < dim ; i++) {avg.
get(i) /= count;}
317 auto it_v = vd.getDomainIterator();
319 while (it_v.isNext())
324 for (
size_t i = 0; i < dim; i++)
326 float a1 = vd.getProp<0>(key)[i];
327 float a2 = vd.getProp<1>(key)[i];
332 per = fabs(0.1*avg.
get(i)/a1);
334 BOOST_REQUIRE_CLOSE(a1,a2,per);
343 BOOST_AUTO_TEST_CASE( vector_dist_symmetric_cell_list )
345 Vcluster & v_cl = create_vcluster();
355 std::default_random_engine eg;
356 std::uniform_real_distribution<float> ud(-L,L);
360 long int big_step = k / 4;
361 big_step = (big_step == 0)?1:big_step;
363 print_test(
"Testing 3D periodic vector symmetric cell-list k=",k);
364 BOOST_TEST_CHECKPOINT(
"Testing 3D periodic vector symmetric cell-list k=" << k );
369 size_t bc[3]={PERIODIC,PERIODIC,PERIODIC};
382 bool operator<(
const struct point_and_gid & pag)
const
384 return (
id < pag.id);
392 size_t start = vd.init_size_accum(k);
394 auto it = vd.getIterator();
400 vd.getPosWrite(key)[0] = ud(eg);
401 vd.getPosWrite(key)[1] = ud(eg);
402 vd.getPosWrite(key)[2] = ud(eg);
406 vd.getPropWrite<0>(key) = 0;
407 vd.getPropWrite<1>(key) = 0;
408 vd.getPropWrite<2>(key) = key.
getKey() + start;
418 auto NN = vd.getCellList(r_cut);
419 auto p_it = vd.getDomainIterator();
421 while (p_it.isNext())
427 auto Np = NN.getNNIterator(NN.getCell(xp));
444 float distance = f.
norm();
448 if (distance < r_cut )
450 vd.getPropWrite<0>(p)++;
451 vd.getPropWrite<3>(p).add();
452 vd.getPropWrite<3>(p).last().xq = xq;
453 vd.getPropWrite<3>(p).last().id = vd.getPropWrite<2>(q);
464 auto NN2 = vd.getCellListSym(r_cut);
466 auto p_it2 = vd.getDomainIterator();
468 while (p_it2.isNext())
470 auto p = p_it2.
get();
474 auto Np = NN2.getNNIteratorSym<NO_CHECK>(NN2.getCell(xp),p.getKey(),vd.getPosVector());
491 float distance = f.
norm();
495 if (distance < r_cut )
497 vd.getPropWrite<1>(p)++;
498 vd.getPropWrite<1>(q)++;
500 vd.getPropWrite<4>(p).add();
501 vd.getPropWrite<4>(q).add();
503 vd.getPropWrite<4>(p).last().xq = xq;
504 vd.getPropWrite<4>(q).last().xq = xp;
505 vd.getPropWrite<4>(p).last().id = vd.getProp<2>(q);
506 vd.getPropWrite<4>(q).last().id = vd.getProp<2>(p);
515 vd.ghost_put<
add_,1>();
518 auto p_it3 = vd.getDomainIterator();
521 while (p_it3.isNext())
523 auto p = p_it3.get();
525 ret &= vd.getPropRead<1>(p) == vd.getPropRead<0>(p);
527 vd.getPropRead<3>(p).sort();
528 vd.getPropRead<4>(p).sort();
530 ret &= vd.getPropRead<3>(p).size() == vd.getPropRead<4>(p).size();
532 for (
size_t i = 0 ; i < vd.getPropRead<3>(p).size() ; i++)
533 ret &= vd.getPropRead<3>(p).get(i).id == vd.getPropRead<4>(p).
get(i).id;
537 std::cout << vd.getPropRead<3>(p).size() <<
" " << vd.getPropRead<4>(p).size() << std::endl;
539 for (
size_t i = 0 ; i < vd.getPropRead<3>(p).size() ; i++)
540 std::cout << vd.getPropRead<3>(p).get(i).id <<
" " << vd.getPropRead<4>(p).
get(i).id << std::endl;
542 std::cout << vd.getPropRead<1>(p) <<
" A " << vd.getPropRead<0>(p) << std::endl;
550 BOOST_REQUIRE_EQUAL(ret,
true);
553 BOOST_AUTO_TEST_CASE( vector_dist_symmetric_crs_cell_list )
555 Vcluster & v_cl = create_vcluster();
565 std::uniform_real_distribution<float> ud(-L,L);
569 long int big_step = k / 4;
570 big_step = (big_step == 0)?1:big_step;
572 print_test(
"Testing 3D periodic vector symmetric crs cell-list k=",k);
573 BOOST_TEST_CHECKPOINT(
"Testing 3D periodic vector symmetric crs cell-list k=" << k );
578 size_t bc[3]={PERIODIC,PERIODIC,PERIODIC};
585 ghost2.setLow(0,0.0);
586 ghost2.setLow(1,0.0);
587 ghost2.setLow(2,0.0);
595 bool operator<(
const struct point_and_gid & pag)
const
597 return (
id < pag.id);
606 size_t start = vd.init_size_accum(k);
608 auto it = vd.getIterator();
614 vd.getPosWrite(key)[0] = ud(eg);
615 vd.getPosWrite(key)[1] = ud(eg);
616 vd.getPosWrite(key)[2] = ud(eg);
618 vd2.getPosWrite(key)[0] = vd.getPosRead(key)[0];
619 vd2.getPosWrite(key)[1] = vd.getPosRead(key)[1];
620 vd2.getPosWrite(key)[2] = vd.getPosRead(key)[2];
624 vd.getPropWrite<0>(key) = 0;
625 vd.getPropWrite<1>(key) = 0;
626 vd.getPropWrite<2>(key) = key.
getKey() + start;
628 vd2.getPropWrite<0>(key) = 0;
629 vd2.getPropWrite<1>(key) = 0;
630 vd2.getPropWrite<2>(key) = key.
getKey() + start;
640 vd2.ghost_get<0,2>();
642 vd2.write(
"CRS_output");
643 vd2.getDecomposition().write(
"CRS_output_dec");
645 auto NN = vd.getCellList(r_cut);
646 auto p_it = vd.getDomainIterator();
648 while (p_it.isNext())
654 auto Np = NN.getNNIterator(NN.getCell(xp));
671 float distance = f.
norm();
675 if (distance < r_cut )
677 vd.getPropWrite<0>(p)++;
678 vd.getPropWrite<3>(p).add();
679 vd.getPropWrite<3>(p).last().xq = xq;
680 vd.getPropWrite<3>(p).last().id = vd.getPropRead<2>(q);
691 auto NN2 = vd2.getCellListSym(r_cut);
695 auto p_it2 = vd2.getParticleIteratorCRS_Cell(NN2);
698 while (p_it2.isNext())
700 auto p = p_it2.
get();
704 auto Np = p_it2.getNNIteratorCSR(vd2.getPosVector());
721 float distance = f.
norm();
725 if (distance < r_cut )
727 vd2.getPropWrite<1>(p)++;
728 vd2.getPropWrite<1>(q)++;
730 vd2.getPropWrite<4>(p).add();
731 vd2.getPropWrite<4>(q).add();
733 vd2.getPropWrite<4>(p).last().xq = xq;
734 vd2.getPropWrite<4>(q).last().xq = xp;
735 vd2.getPropWrite<4>(p).last().id = vd2.getPropRead<2>(q);
736 vd2.getPropWrite<4>(q).last().id = vd2.getPropRead<2>(p);
745 vd2.ghost_put<
add_,1>(NO_CHANGE_ELEMENTS);
746 vd2.ghost_put<
merge_,4>();
749 vd2.getDomainIterator();
752 auto p_it3 = vd.getDomainIterator();
755 while (p_it3.isNext())
757 auto p = p_it3.get();
759 ret &= vd2.getPropRead<1>(p) == vd.getPropRead<0>(p);
762 vd.getPropWrite<3>(p).sort();
763 vd2.getPropWrite<4>(p).sort();
765 ret &= vd.getPropRead<3>(p).size() == vd2.getPropRead<4>(p).size();
767 for (
size_t i = 0 ; i < vd.getPropRead<3>(p).size() ; i++)
768 ret &= vd.getPropRead<3>(p).get(i).id == vd2.getPropRead<4>(p).
get(i).id;
776 BOOST_REQUIRE_EQUAL(ret,
true);
779 BOOST_AUTO_TEST_CASE( vector_dist_symmetric_verlet_list )
781 Vcluster & v_cl = create_vcluster();
791 std::default_random_engine eg;
792 std::uniform_real_distribution<float> ud(-L,L);
796 long int big_step = k / 4;
797 big_step = (big_step == 0)?1:big_step;
799 print_test(
"Testing 3D periodic vector symmetric cell-list k=",k);
800 BOOST_TEST_CHECKPOINT(
"Testing 3D periodic vector symmetric verlet-list k=" << k );
805 size_t bc[3]={PERIODIC,PERIODIC,PERIODIC};
818 bool operator<(
const struct point_and_gid & pag)
const
820 return (
id < pag.id);
828 size_t start = vd.init_size_accum(k);
830 auto it = vd.getIterator();
836 vd.getPosWrite(key)[0] = ud(eg);
837 vd.getPosWrite(key)[1] = ud(eg);
838 vd.getPosWrite(key)[2] = ud(eg);
842 vd.getPropWrite<0>(key) = 0;
843 vd.getPropWrite<1>(key) = 0;
844 vd.getPropWrite<2>(key) = key.
getKey() + start;
854 auto NN = vd.getVerlet(r_cut);
855 auto p_it = vd.getDomainIterator();
857 while (p_it.isNext())
863 auto Np = NN.getNNIterator(p.getKey());
880 float distance = f.
norm();
884 if (distance < r_cut )
886 vd.getPropWrite<0>(p)++;
887 vd.getPropWrite<3>(p).add();
888 vd.getPropWrite<3>(p).last().xq = xq;
889 vd.getPropWrite<3>(p).last().id = vd.getPropRead<2>(q);
900 auto NN2 = vd.getVerletSym(r_cut);
902 auto p_it2 = vd.getDomainIterator();
904 while (p_it2.isNext())
906 auto p = p_it2.
get();
910 auto Np = NN2.getNNIterator<NO_CHECK>(p.getKey());
927 float distance = f.
norm();
931 if (distance < r_cut )
933 vd.getPropWrite<1>(p)++;
934 vd.getPropWrite<1>(q)++;
936 vd.getPropWrite<4>(p).add();
937 vd.getPropWrite<4>(q).add();
939 vd.getPropWrite<4>(p).last().xq = xq;
940 vd.getPropWrite<4>(q).last().xq = xp;
941 vd.getPropWrite<4>(p).last().id = vd.getPropRead<2>(q);
942 vd.getPropWrite<4>(q).last().id = vd.getPropRead<2>(p);
951 vd.ghost_put<
add_,1>();
954 auto p_it3 = vd.getDomainIterator();
957 while (p_it3.isNext())
959 auto p = p_it3.get();
961 ret &= vd.getPropRead<1>(p) == vd.getPropRead<0>(p);
963 vd.getPropWrite<3>(p).sort();
964 vd.getPropWrite<4>(p).sort();
966 ret &= vd.getPropRead<3>(p).size() == vd.getPropRead<4>(p).size();
968 for (
size_t i = 0 ; i < vd.getPropRead<3>(p).size() ; i++)
969 ret &= vd.getPropRead<3>(p).get(i).id == vd.getPropRead<4>(p).
get(i).id;
977 BOOST_REQUIRE_EQUAL(ret,
true);
980 BOOST_AUTO_TEST_CASE( vector_dist_symmetric_verlet_list_no_bottom )
982 Vcluster & v_cl = create_vcluster();
992 std::default_random_engine eg;
993 std::uniform_real_distribution<float> ud(-L,L);
997 long int big_step = k / 4;
998 big_step = (big_step == 0)?1:big_step;
1000 print_test(
"Testing 3D periodic vector symmetric cell-list no bottom k=",k);
1001 BOOST_TEST_CHECKPOINT(
"Testing 3D periodic vector symmetric cell-list no bottom k=" << k );
1006 size_t bc[3]={PERIODIC,PERIODIC,PERIODIC};
1008 float r_cut = 100.0;
1013 ghost2.setLow(2,0.0);
1016 struct point_and_gid
1021 bool operator<(
const struct point_and_gid & pag)
const
1023 return (
id < pag.id);
1030 for (
size_t s = 0 ; s < 8 ; s++)
1036 size_t start = vd.init_size_accum(k);
1038 auto it = vd.getIterator();
1042 auto key = it.get();
1044 vd.getPosWrite(key)[0] = ud(eg);
1045 vd.getPosWrite(key)[1] = ud(eg);
1046 vd.getPosWrite(key)[2] = ud(eg);
1048 vd2.getPosWrite(key)[0] = vd.getPosRead(key)[0];
1049 vd2.getPosWrite(key)[1] = vd.getPosRead(key)[1];
1050 vd2.getPosWrite(key)[2] = vd.getPosRead(key)[2];
1054 vd.getPropWrite<0>(key) = 0;
1055 vd.getPropWrite<1>(key) = 0;
1056 vd.getPropWrite<2>(key) = key.
getKey() + start;
1058 vd2.getPropWrite<0>(key) = 0;
1059 vd2.getPropWrite<1>(key) = 0;
1060 vd2.getPropWrite<2>(key) = key.
getKey() + start;
1069 vd.ghost_get<0,2>();
1070 vd2.ghost_get<0,2>();
1072 auto NN = vd.getVerlet(r_cut);
1073 auto p_it = vd.getDomainIterator();
1075 while (p_it.isNext())
1077 auto p = p_it.get();
1081 auto Np = NN.getNNIterator(p.getKey());
1087 if (p.getKey() == q)
1098 float distance = f.
norm();
1102 if (distance < r_cut )
1104 vd.getPropWrite<0>(p)++;
1105 vd.getPropWrite<3>(p).add();
1106 vd.getPropWrite<3>(p).last().xq = xq;
1107 vd.getPropWrite<3>(p).last().id = vd.getPropRead<2>(q);
1118 auto NN2 = vd2.getVerletSym(r_cut);
1120 auto p_it2 = vd2.getDomainIterator();
1122 while (p_it2.isNext())
1124 auto p = p_it2.
get();
1128 auto Np = NN2.getNNIterator<NO_CHECK>(p.getKey());
1134 if (p.getKey() == q)
1145 float distance = f.
norm();
1149 if (distance < r_cut )
1151 vd2.getPropWrite<1>(p)++;
1152 vd2.getPropWrite<1>(q)++;
1154 vd2.getPropWrite<4>(p).add();
1155 vd2.getPropWrite<4>(q).add();
1157 vd2.getPropWrite<4>(p).last().xq = xq;
1158 vd2.getPropWrite<4>(q).last().xq = xp;
1159 vd2.getPropWrite<4>(p).last().id = vd2.getPropRead<2>(q);
1160 vd2.getPropWrite<4>(q).last().id = vd2.getPropRead<2>(p);
1170 vd2.ghost_put<
add_,1>();
1171 vd2.ghost_put<
merge_,4>();
1174 vd2.getDomainIterator();
1177 auto p_it3 = vd.getDomainIterator();
1180 while (p_it3.isNext())
1182 auto p = p_it3.get();
1184 ret &= vd2.getPropRead<1>(p) == vd.getPropRead<0>(p);
1187 vd.getPropWrite<3>(p).sort();
1188 vd2.getPropWrite<4>(p).sort();
1190 ret &= vd.getPropRead<3>(p).size() == vd2.getPropRead<4>(p).size();
1192 for (
size_t i = 0 ; i < vd.getPropRead<3>(p).size() ; i++)
1193 ret &= vd.getPropRead<3>(p).get(i).id == vd2.getPropRead<4>(p).
get(i).id;
1201 BOOST_REQUIRE_EQUAL(ret,
true);
1207 std::default_random_engine & eg,
1208 std::uniform_real_distribution<float> & ud,
1216 auto key = it.get();
1228 vd.template getPropWrite<0>(key) = 0;
1229 vd.template getPropWrite<1>(key) = 0;
1230 vd.template getPropWrite<2>(key) = key.
getKey() + start;
1232 vd2.template getPropWrite<0>(key) = 0;
1233 vd2.template getPropWrite<1>(key) = 0;
1234 vd2.template getPropWrite<2>(key) = key.
getKey() + start;
1243 vd.template ghost_get<0,2>();
1244 vd2.template ghost_get<0,2>();
1249 while (p_it.isNext())
1251 auto p = p_it.
get();
1255 auto Np = NN.getNNIterator(p.getKey());
1261 if (p.getKey() == q)
1272 float distance = f.
norm();
1276 if (distance < r_cut )
1278 vd.template getPropWrite<0>(p)++;
1279 vd.template getPropWrite<3>(p).add();
1280 vd.template getPropWrite<3>(p).last().xq = xq;
1281 vd.template getPropWrite<3>(p).last().id = vd.template getPropRead<2>(q);
1297 while (p_it2.isNext())
1299 auto p = p_it2.get();
1303 auto Np = NN2.template getNNIterator<NO_CHECK>(p);
1320 float distance = f.
norm();
1322 if (distance < r_cut )
1324 vd2.template getPropWrite<1>(p)++;
1325 vd2.template getPropWrite<1>(q)++;
1327 vd2.template getPropWrite<4>(p).add();
1328 vd2.template getPropWrite<4>(q).add();
1330 vd2.template getPropWrite<4>(p).last().xq = xq;
1331 vd2.template getPropWrite<4>(q).last().xq = xp;
1332 vd2.template getPropWrite<4>(p).last().id = vd2.template getPropRead<2>(q);
1333 vd2.template getPropWrite<4>(q).last().id = vd2.template getPropRead<2>(p);
1342 vd2.template ghost_put<add_,1>();
1343 vd2.template ghost_put<merge_,4>();
1352 while (p_it3.isNext())
1354 auto p = p_it3.get();
1356 ret &= vd2.template getPropRead<1>(p) == vd.template getPropRead<0>(p);
1361 std::cout <<
"ERROR " << vd2.template getPropWrite<1>(p) <<
" " << vd.template getPropWrite<0>(p) <<
" " << xp.
toString() << std::endl;
1364 vd.template getPropWrite<3>(p).sort();
1365 vd2.template getPropWrite<4>(p).sort();
1367 ret &= vd.template getPropRead<3>(p).size() == vd2.template getPropRead<4>(p).size();
1369 for (
size_t i = 0 ; i < vd.template getPropRead<3>(p).size() ; i++)
1370 ret &= vd.template getPropRead<3>(p).get(i).id == vd2.template getPropRead<4>(p).
get(i).id;
1378 BOOST_REQUIRE_EQUAL(ret,
true);
1382 void test_csr_verlet_list()
1384 Vcluster & v_cl = create_vcluster();
1394 std::default_random_engine eg;
1395 std::uniform_real_distribution<float> ud(-L,L);
1399 long int big_step = k / 4;
1400 big_step = (big_step == 0)?1:big_step;
1402 print_test(
"Testing 3D periodic vector symmetric cell-list k=",k);
1403 BOOST_TEST_CHECKPOINT(
"Testing 3D periodic vector symmetric cell-list k=" << k );
1408 size_t bc[3]={PERIODIC,PERIODIC,PERIODIC};
1410 float r_cut = 100.0;
1415 ghost2.setLow(0,0.0);
1416 ghost2.setLow(1,0.0);
1417 ghost2.setLow(2,0.0);
1420 struct point_and_gid
1425 bool operator<(
const struct point_and_gid & pag)
const
1427 return (
id < pag.id);
1438 test_crs_full(vd,vd2,eg,ud,start,r_cut);
1441 void test_csr_verlet_list_override()
1443 Vcluster & v_cl = create_vcluster();
1453 std::default_random_engine eg;
1454 std::uniform_real_distribution<float> ud(-L,L);
1458 long int big_step = k / 4;
1459 big_step = (big_step == 0)?1:big_step;
1461 print_test(
"Testing 3D periodic vector symmetric cell-list k=",k);
1462 BOOST_TEST_CHECKPOINT(
"Testing 3D periodic vector symmetric cell-list k=" << k );
1467 size_t bc[3]={PERIODIC,PERIODIC,PERIODIC};
1469 float r_cut = 100.0;
1474 ghost2.setLow(0,0.0);
1475 ghost2.setLow(1,0.0);
1476 ghost2.setLow(2,0.0);
1479 struct point_and_gid
1484 bool operator<(
const struct point_and_gid & pag)
const
1486 return (
id < pag.id);
1511 test_crs_full(vd,vd2,eg,ud,start,r_cut);
1514 BOOST_AUTO_TEST_CASE( vector_dist_symmetric_crs_verlet_list )
1516 test_csr_verlet_list();
1519 BOOST_AUTO_TEST_CASE( vector_dist_symmetric_crs_verlet_list_dec_override )
1521 test_csr_verlet_list_override();
1524 BOOST_AUTO_TEST_CASE( vector_dist_symmetric_crs_verlet_list_partit )
1526 Vcluster & v_cl = create_vcluster();
1538 std::default_random_engine eg;
1539 std::uniform_real_distribution<float> ud(-L,L);
1543 long int big_step = k / 4;
1544 big_step = (big_step == 0)?1:big_step;
1546 print_test(
"Testing 3D periodic vector symmetric cell-list k=",k);
1547 BOOST_TEST_CHECKPOINT(
"Testing 3D periodic vector symmetric cell-list k=" << k );
1552 size_t bc[3]={PERIODIC,PERIODIC,PERIODIC};
1554 float r_cut = 100.0;
1559 ghost2.setLow(0,0.0);
1560 ghost2.setLow(1,0.0);
1561 ghost2.setLow(2,0.0);
1573 auto key = it.get();
1575 vd.
getPos(key)[0] = ud(eg);
1576 vd.
getPos(key)[1] = ud(eg);
1577 vd.
getPos(key)[2] = ud(eg);
1599 while (p_it2.isNext())
1601 auto p = p_it2.get();
1602 auto p2 = p_it3.get();
1613 BOOST_REQUIRE_EQUAL(ret,
true);
1616 BOOST_AUTO_TEST_CASE( vector_dist_checking_unloaded_processors )
1618 Vcluster & v_cl = create_vcluster();
1628 std::default_random_engine eg;
1629 std::uniform_real_distribution<float> ud(0,L);
1633 long int big_step = k / 4;
1634 big_step = (big_step == 0)?1:big_step;
1636 print_test(
"Testing 3D periodic vector symmetric cell-list (unload processors) k=",k);
1637 BOOST_TEST_CHECKPOINT(
"Testing 3D periodic vector symmetric cell-list (unload processors) k=" << k );
1642 size_t bc[3]={PERIODIC,PERIODIC,PERIODIC};
1644 float r_cut = 100.0;
1649 ghost2.setLow(0,0.0);
1650 ghost2.setLow(1,0.0);
1651 ghost2.setLow(2,0.0);
1663 auto key = it.get();
1665 vd.
getPos(key)[0] = ud(eg);
1666 vd.
getPos(key)[1] = ud(eg);
1667 vd.
getPos(key)[2] = ud(eg);
1686 BOOST_REQUIRE_EQUAL(min,0ul);
1701 BOOST_REQUIRE_EQUAL(min,0ul);
1705 BOOST_AUTO_TEST_CASE( vector_dist_cell_list_multi_type )
1707 Vcluster & v_cl = create_vcluster();
1717 std::default_random_engine eg;
1718 std::uniform_real_distribution<float> ud(-L,L);
1722 long int big_step = k / 4;
1723 big_step = (big_step == 0)?1:big_step;
1725 print_test(
"Testing 3D periodic vector symmetric cell-list k=",k);
1726 BOOST_TEST_CHECKPOINT(
"Testing 3D periodic vector symmetric cell-list k=" << k );
1731 size_t bc[3]={PERIODIC,PERIODIC,PERIODIC};
1733 float r_cut = 100.0;
1747 auto key = it.get();
1749 vd.
getPos(key)[0] = ud(eg);
1750 vd.
getPos(key)[1] = ud(eg);
1751 vd.
getPos(key)[2] = ud(eg);
1765 auto NN = vd.
getCellList<CELL_MEMFAST(3,
float)>(r_cut);
1766 auto NN2 = vd.
getCellList<CELL_MEMBAL(3,
float)>(r_cut);
1767 auto NN3 = vd.
getCellList<CELL_MEMMW(3,
float)>(r_cut);
1771 while (p_it.isNext())
1773 auto p = p_it.
get();
1777 auto Np = NN.getNNIterator(NN.getCell(xp));
1778 auto Np2 = NN2.getNNIterator(NN2.getCell(xp));
1779 auto Np3 = NN3.getNNIterator(NN3.getCell(xp));
1785 ret &= (Np.isNext() == Np2.isNext()) && (Np3.isNext() == Np.isNext());
1791 auto q2 = Np2.get();
1792 auto q3 = Np3.get();
1794 ret &= (q == q2) && (q == q3);
1804 ret &= (Np.isNext() == Np2.isNext()) && (Np.isNext() == Np3.isNext());
1812 BOOST_REQUIRE_EQUAL(ret,
true);
auto getPosWrite(vect_dist_key_dx vec_key) -> decltype(v_pos.template get< 0 >(vec_key.getKey()))
Get the position of an element.
size_t getProcessUnitID()
Get the process unit id.
auto getPos(vect_dist_key_dx vec_key) -> decltype(v_pos.template get< 0 >(vec_key.getKey()))
Get the position of an element.
void execute()
Execute all the requests.
std::string toString() const
Return the string with the point coordinate.
This structure define the operation add to use with copy general.
openfpm::vector_key_iterator_seq< typename vrl::local_index_t > getParticleIteratorCRS(vrl &NN)
Get a special particle iterator able to iterate across particles using symmetric crossing scheme...
void setHigh(int i, T val)
set the high interval of the box
VerletList< dim, St, FAST, shift< dim, St > > getVerletCrs(St r_cut)
for each particle get the symmetric verlet list
This structure define the operation add to use with copy general.
This class implement the point shape in an N-dimensional space.
Grid key for a distributed grid.
vector_dist_iterator getIterator()
Get an iterator that traverse domain and ghost particles.
CellL getCellList(St r_cut, bool no_se3=false)
Construct a cell list starting from the stored particles.
size_t size_local_with_ghost() const
return the local size of the vector
Implementation of VCluster class.
vector_dist_iterator getDomainIterator() const
Get an iterator that traverse the particles in the domain.
auto getProp(vect_dist_key_dx vec_key) -> decltype(v_prp.template get< id >(vec_key.getKey()))
Get the property of an element.
This class decompose a space into sub-sub-domains and distribute them across processors.
ParticleItCRS_Cells< dim, cli > getParticleIteratorCRS_Cell(cli &NN)
Get a special particle iterator able to iterate across particles using symmetric crossing scheme...
VerletList< dim, St, FAST, shift< dim, St > > getVerlet(St r_cut)
for each particle get the verlet list
const T & get(int i) const
Get coordinate.
void setLow(int i, T val)
set the low interval of the box
void map()
It move all the particles that does not belong to the local processor to the respective processor...
size_t getKey() const
Get the key.
This class represent an N-dimensional box.
T norm()
norm of the vector
This class is a trick to indicate the compiler a specific specialization pattern. ...
size_t size_local() const
return the local size of the vector
auto getPosRead(vect_dist_key_dx vec_key) const -> decltype(v_pos.template get< 0 >(vec_key.getKey()))
Get the position of an element.
void min(T &num)
Get the minimum number across all processors (or reduction with insinity norm)
size_t init_size_accum(size_t np)
It return the number of particles contained by the previous processors.
vect_dist_key_dx get()
Get the actual key.
aggregate of properties, from a list of object if create a struct that follow the OPENFPM native stru...
Implementation of 1-D std::vector like structure.
size_t getProcessingUnits()
Get the total number of processors.
void ghost_get(size_t opt=WITH_POSITION)
It synchronize the properties and position of the ghost particles.