100 auto evtsWriter = builderE.
cursor<aod::Events>();
101 for (
auto i = 0;
i < 20; ++
i) {
102 evtsWriter(0,
i, 0.5f *
i, 2.f *
i, 3.f *
i);
104 auto evtTable = builderE.
finalize();
107 auto trksWriter = builderT.
cursor<aod::TrksX>();
108 for (
auto i = 0;
i < 20; ++
i) {
109 for (
auto j = 0.f;
j < 5;
j += 0.5f) {
110 trksWriter(0,
i, 0.5f *
j);
113 auto trkTable = builderT.
finalize();
114 aod::Events e{evtTable};
115 aod::TrksX t{trkTable};
116 REQUIRE(e.size() == 20);
117 REQUIRE(t.size() == 10 * 20);
119 auto tt = std::make_tuple(t);
121 auto s = slices.updateCacheEntry(0, trkTable);
125 for (
auto& slice :
g) {
126 auto as = slice.associatedTables();
127 auto gg = slice.groupingElement();
128 REQUIRE(gg.globalIndex() ==
count);
129 auto trks = std::get<aod::TrksX>(as);
130 REQUIRE(trks.size() == 10);
131 for (
auto& trk : trks) {
132 REQUIRE(trk.eventId() ==
count);
141 auto evtsWriter = builderE.
cursor<aod::Events>();
142 for (
auto i = 0;
i < 20; ++
i) {
143 evtsWriter(0,
i, 0.5f *
i, 2.f *
i, 3.f *
i);
145 auto evtTable = builderE.
finalize();
148 auto trksWriterX = builderTX.
cursor<aod::TrksX>();
150 auto trksWriterY = builderTY.
cursor<aod::TrksY>();
152 auto trksWriterZ = builderTZ.
cursor<aod::TrksZ>();
155 auto trksWriterXYZ = builderTXYZ.
cursor<aod::TrksU>();
157 for (
auto i = 0;
i < 20; ++
i) {
158 for (
auto j = 0.f;
j < 5;
j += 0.5f) {
159 trksWriterX(0,
i, 0.5f *
j);
161 for (
auto j = 0.f;
j < 10;
j += 0.5f) {
162 trksWriterY(0,
i, 0.5f *
j);
164 for (
auto j = 0.f;
j < 15;
j += 0.5f) {
165 trksWriterZ(0,
i, 0.5f *
j);
168 for (
auto j = 0.f;
j < 5;
j += 0.5f) {
169 trksWriterXYZ(0, 0.5f *
j, 2.f *
j, 2.5f *
j);
172 auto trkTableX = builderTX.
finalize();
173 auto trkTableY = builderTY.finalize();
174 auto trkTableZ = builderTZ.finalize();
176 auto trkTableXYZ = builderTXYZ.finalize();
178 aod::Events e{evtTable};
179 aod::TrksX tx{trkTableX};
180 aod::TrksY ty{trkTableY};
181 aod::TrksZ tz{trkTableZ};
183 aod::TrksU tu{trkTableXYZ};
185 REQUIRE(e.size() == 20);
186 REQUIRE(tx.size() == 10 * 20);
187 REQUIRE(ty.size() == 20 * 20);
188 REQUIRE(tz.size() == 30 * 20);
190 REQUIRE(tu.size() == 10 * 20);
192 auto tt = std::make_tuple(tx, ty, tz, tu);
195 {soa::getLabelFromType<aod::TrksY>(),
key},
196 {soa::getLabelFromType<aod::TrksZ>(),
key}});
197 auto s = slices.updateCacheEntry(0, {trkTableX});
198 s = slices.updateCacheEntry(1, {trkTableY});
199 s = slices.updateCacheEntry(2, {trkTableZ});
203 for (
auto& slice :
g) {
204 auto as = slice.associatedTables();
205 auto gg = slice.groupingElement();
206 REQUIRE(gg.globalIndex() ==
count);
207 auto trksx = std::get<aod::TrksX>(as);
208 auto trksy = std::get<aod::TrksY>(as);
209 auto trksz = std::get<aod::TrksZ>(as);
211 auto trksu = std::get<aod::TrksU>(as);
213 REQUIRE(trksx.size() == 10);
214 REQUIRE(trksy.size() == 20);
215 REQUIRE(trksz.size() == 30);
217 REQUIRE(trksu.size() == 10 * 20);
219 for (
auto& trk : trksx) {
220 REQUIRE(trk.eventId() ==
count);
222 for (
auto& trk : trksy) {
223 REQUIRE(trk.eventId() ==
count);
225 for (
auto& trk : trksz) {
226 REQUIRE(trk.eventId() ==
count);
236 auto evtsWriter = builderE.
cursor<aod::Events>();
237 for (
auto i = 0;
i < 20; ++
i) {
238 evtsWriter(0,
i, 0.5f *
i, 2.f *
i, 3.f *
i);
240 auto evtTable = builderE.
finalize();
243 auto trksWriter = builderT.
cursor<aod::TrksX>();
244 for (
auto i = 0;
i < 20; ++
i) {
245 if (
i == 3 ||
i == 10 ||
i == 12 ||
i == 16 ||
i == 19) {
248 for (
auto j = 0;
j < 10; ++
j) {
249 trksWriter(0,
i, 0.5f * (
j / 2.));
252 auto trkTable = builderT.
finalize();
253 aod::Events e{evtTable};
254 aod::TrksX t{trkTable};
255 REQUIRE(e.size() == 20);
256 REQUIRE(t.size() == 10 * (20 - 5));
258 auto tt = std::make_tuple(t);
260 auto s = slices.updateCacheEntry(0, trkTable);
263 for (
auto& slice :
g) {
264 auto as = slice.associatedTables();
265 auto gg = slice.groupingElement();
266 REQUIRE(gg.globalIndex() == (int64_t)slice.position);
267 auto trks = std::get<aod::TrksX>(as);
268 if (slice.position == 3 || slice.position == 10 || slice.position == 12 || slice.position == 16 || slice.position == 19) {
269 REQUIRE(trks.size() == 0);
271 REQUIRE(trks.size() == 10);
273 for (
auto& trk : trks) {
274 REQUIRE(trk.eventId() == (int64_t)slice.position);
282 auto evtsWriter = builderE.
cursor<aod::Events>();
283 for (
auto i = 0;
i < 20; ++
i) {
284 evtsWriter(0,
i, 0.5f *
i, 2.f *
i, 3.f *
i);
286 auto evtTable = builderE.
finalize();
291 auto trksWriter = builderT.
cursor<aod::TrksX>();
292 for (
auto i = 0;
i < 20; ++
i) {
293 if (
i == 3 ||
i == 10 ||
i == 12 ||
i == 16 ||
i == 19) {
294 for (
auto iz = 0; iz < 5; ++iz) {
295 trksWriter(0, -1 - skip, 0.123f * iz + 1.654f);
300 for (
auto j = 0;
j < 10; ++
j) {
301 trksWriter(0,
i, 0.5f * (
j / 2.));
304 for (
auto i = 0;
i < 5; ++
i) {
305 trksWriter(0, -6, 0.123f *
i + 1.654f);
307 auto trkTable = builderT.
finalize();
309 aod::Events e{evtTable};
310 aod::TrksX t{trkTable};
311 REQUIRE(e.size() == 20);
312 REQUIRE(t.size() == (30 + 10 * (20 - 5)));
314 auto tt = std::make_tuple(t);
316 auto s = slices.updateCacheEntry(0, trkTable);
320 for (
auto& slice :
g) {
321 auto as = slice.associatedTables();
322 auto gg = slice.groupingElement();
323 REQUIRE(gg.globalIndex() ==
count);
324 auto trks = std::get<aod::TrksX>(as);
326 REQUIRE(trks.size() == 0);
328 REQUIRE(trks.size() == 10);
330 for (
auto& trk : trks) {
331 REQUIRE(trk.eventId() ==
count);
340 auto evtsWriter = builderE.
cursor<aod::Events>();
341 for (
auto i = 0;
i < 20; ++
i) {
342 evtsWriter(0,
i, 0.5f *
i, 2.f *
i, 3.f *
i);
344 auto evtTable = builderE.
finalize();
347 auto trksWriter = builderT.
cursor<aod::TrksX>();
348 for (
auto i = 0;
i < 20; ++
i) {
349 if (
i == 3 ||
i == 10 ||
i == 12 ||
i == 16) {
352 for (
auto j = 0.f;
j < 5;
j += 0.5f) {
353 trksWriter(0,
i, 0.5f *
j);
356 auto trkTable = builderT.
finalize();
359 FilteredEvents e{{evtTable}, {2, 4, 10, 9, 15}};
360 aod::TrksX t{trkTable};
361 REQUIRE(e.size() == 5);
362 REQUIRE(t.size() == 10 * (20 - 4));
364 auto tt = std::make_tuple(t);
366 auto s = slices.updateCacheEntry(0, trkTable);
371 for (
auto& slice :
g) {
372 auto as = slice.associatedTables();
373 auto gg = slice.groupingElement();
374 REQUIRE(gg.globalIndex() ==
rows[
count]);
375 auto trks = std::get<aod::TrksX>(as);
377 REQUIRE(trks.size() == 0);
379 REQUIRE(trks.size() == 10);
381 for (
auto& trk : trks) {
391 auto evtsWriter = builderE.
cursor<aod::Events>();
392 for (
auto i = 0;
i < 20; ++
i) {
393 evtsWriter(0,
i, 0.5f *
i, 2.f *
i, 3.f *
i);
395 auto evtTable = builderE.
finalize();
398 auto trksWriter = builderT.
cursor<aod::TrksXU>();
399 std::vector<int> randomized{10, 2, 1, 0, 15, 3, 6, 4, 14, 5, 7, 9, 8, 19, 11, 13, 17, 12, 18, 19};
400 std::vector<int64_t> sel;
401 sel.resize(10 * (20 - 4));
402 std::iota(sel.begin(), sel.end(), 0);
403 for (
auto i : randomized) {
404 if (
i == 3 ||
i == 10 ||
i == 12 ||
i == 16) {
407 for (
auto j = 0.f;
j < 5;
j += 0.5f) {
408 trksWriter(0,
i, 0.5f *
j);
411 auto trkTable = builderT.
finalize();
414 auto trksWriterE = builderTE.
cursor<aod::TrksXU>();
415 auto trkTableE = builderTE.
finalize();
419 FilteredEvents e{{evtTable}, {2, 4, 10, 9, 15}};
422 REQUIRE(e.size() == 5);
423 REQUIRE(t.size() == 10 * (20 - 4));
425 auto tt = std::make_tuple(t);
427 auto s = slices.updateCacheEntryUnsorted(0, trkTable);
430 unsigned int count = 0;
432 for (
auto& slice :
g) {
433 auto as = slice.associatedTables();
434 auto gg = slice.groupingElement();
435 REQUIRE(gg.globalIndex() ==
rows[
count]);
436 auto trks = std::get<soa::SmallGroups<aod::TrksXU>>(as);
438 REQUIRE(trks.size() == 0);
440 REQUIRE(trks.size() == 10);
442 for (
auto& trk : trks) {
448 std::vector<int64_t> sele;
450 auto tte = std::make_tuple(te);
454 for (
auto& slice : ge) {
455 auto as = slice.associatedTables();
456 auto gg = slice.groupingElement();
457 REQUIRE(gg.globalIndex() ==
rows[
count]);
458 auto trks = std::get<soa::SmallGroups<aod::TrksXU>>(as);
459 REQUIRE(trks.size() == 0);
464 auto ttu = std::make_tuple(tu);
468 for (
auto& slice : gu) {
469 auto as = slice.associatedTables();
470 auto gg = slice.groupingElement();
471 REQUIRE(gg.globalIndex() ==
rows[
count]);
472 auto trks = std::get<soa::SmallGroupsUnfiltered<aod::TrksXU>>(as);
474 REQUIRE(trks.size() == 0);
476 REQUIRE(trks.size() == 10);
507TEST_CASE(
"GroupSlicerMismatchedUnsortedFilteredGroupsWithSelfIndex")
510 auto evtsWriter = builderE.
cursor<aod::Events>();
511 for (
auto i = 0;
i < 10; ++
i) {
512 evtsWriter(0,
i, 0.5f *
i, 2.f *
i, 3.f *
i);
514 auto evtTable = builderE.
finalize();
517 auto partsWriter = builderP.
cursor<aod::Parts>();
519 std::random_device
rd;
520 std::mt19937
gen(
rd());
521 std::uniform_int_distribution<> distrib(0, 99);
523 for (
auto i = 0;
i < 100; ++
i) {
524 filler[0] = distrib(
gen);
525 filler[1] = distrib(
gen);
526 if (filler[0] > filler[1]) {
527 std::swap(filler[0], filler[1]);
529 partsWriter(0, std::floor(
i / 10.),
i, filler);
531 auto partsTable = builderP.
finalize();
534 auto thingsWriter = builderT.
cursor<aod::Things>();
535 for (
auto i = 0;
i < 10; ++
i) {
536 thingsWriter(0,
i, distrib(
gen));
538 auto thingsTable = builderT.
finalize();
540 aod::Events e{evtTable};
541 aod::Things t{thingsTable};
545 for (
auto i = 0;
i <
size; ++
i) {
548 FilteredParts fp{{partsTable},
rows};
549 auto associatedTuple = std::make_tuple(fp, t);
551 {soa::getLabelFromType<aod::Things>(),
"fIndex" +
o2::framework::cutString(soa::getLabelFromType<aod::Events>())}});
553 auto s1 = slices.updateCacheEntry(1, thingsTable);
556 overwriteInternalIndices(associatedTuple, associatedTuple);
559 for (
auto& slice :
g) {
560 auto as = slice.associatedTables();
561 auto gg = slice.groupingElement();
562 overwriteInternalIndices(as, associatedTuple);
563 auto& ts = std::get<1>(as);
564 ts.bindExternalIndices(&e, &std::get<0>(associatedTuple));
565 for (
auto& thing : ts) {
566 if (thing.has_part()) {
567 auto part = thing.part_as<FilteredParts>();
568 REQUIRE(std::same_as<std::decay_t<
decltype(part)>::parent_t, FilteredParts>);
569 auto rs = part.relatives_as<std::decay_t<
decltype(part)::parent_t>>();
570 REQUIRE(std::same_as<std::decay_t<
decltype(rs)>, FilteredParts>);
572 REQUIRE(std::same_as<std::decay_t<
decltype(
r)>::parent_t, FilteredParts>);
573 auto rss =
r.relatives_as<std::decay_t<
decltype(
r)>::parent_t>();
574 REQUIRE(std::same_as<std::decay_t<
decltype(rss)>, FilteredParts>);
575 for (
auto&
rr : rss) {
576 REQUIRE(std::same_as<std::decay_t<
decltype(
rr)>::parent_t, FilteredParts>);
577 auto rsss =
rr.relatives_as<std::decay_t<
decltype(
rr)>::parent_t>();
578 REQUIRE(std::same_as<std::decay_t<
decltype(rsss)>, FilteredParts>);
579 for (
auto& rrr : rsss) {
580 REQUIRE(std::same_as<std::decay_t<
decltype(rrr)>::parent_t, FilteredParts>);
581 auto rssss = rrr.relatives_as<std::decay_t<
decltype(rrr)>::parent_t>();
582 REQUIRE(std::same_as<std::decay_t<
decltype(rssss)>, FilteredParts>);
594 auto evtsWriter = builderE.
cursor<aod::Events>();
595 for (
auto i = 0;
i < 20; ++
i) {
596 evtsWriter(0,
i, 0.5f *
i, 2.f *
i, 3.f *
i);
598 auto evtTable = builderE.
finalize();
601 auto trksWriter = builderT.
cursor<aod::TrksX>();
602 auto trkTable = builderT.
finalize();
604 aod::Events e{evtTable};
605 aod::TrksX t{trkTable};
606 REQUIRE(e.size() == 20);
607 REQUIRE(t.size() == 0);
609 auto tt = std::make_tuple(t);
611 auto s = slices.updateCacheEntry(0, trkTable);
614 unsigned int count = 0;
615 for (
auto& slice :
g) {
616 auto as = slice.associatedTables();
617 auto gg = slice.groupingElement();
618 auto trks = std::get<aod::TrksX>(as);
619 REQUIRE(gg.globalIndex() ==
count);
620 REQUIRE(trks.size() == 0);
627 int counts[] = {5, 5, 5, 4, 1};
628 int offsets[] = {0, 5, 10, 15, 19, 20};
629 int ids[] = {0, 1, 2, 3, 4};
630 int sizes[] = {4, 1, 12, 5, 2};
635 auto evtsWriter = builderE.
cursor<aod::Events>();
637 for (
auto i = 0;
i < 20; ++
i) {
641 evtsWriter(0,
ids[step], 0.5f *
i, 2.f *
i, 3.f *
i);
643 auto evtTable = builderE.
finalize();
646 auto evtsEWriter = builderEE.
cursor<aod::EventExtra>();
649 for (
auto i = 0;
i < 20; ++
i) {
653 float arr[3] = {0.1f *
i, 0.2f *
i, 0.3f *
i};
654 std::vector<double> d;
655 for (
auto z = 0;
z <
sizes[step]; ++
z) {
656 d.push_back((
double)
z * 0.5);
658 evtsEWriter(0, arr,
i % 2 == 0, d);
660 auto evtETable = builderEE.
finalize();
662 aod::Events e{evtTable};
663 aod::EventExtra ee{evtETable};
664 BigE b_e{{evtTable, evtETable}};
666 std::vector<std::shared_ptr<arrow::ChunkedArray>> slices_array;
667 std::vector<std::shared_ptr<arrow::ChunkedArray>> slices_bool;
668 std::vector<std::shared_ptr<arrow::ChunkedArray>> slices_vec;
670 for (
auto i = 0u;
i < 5; ++
i) {
671 slices_array.emplace_back(evtETable->column(0)->Slice(
offset, counts[
i]));
672 slices_bool.emplace_back(evtETable->column(1)->Slice(
offset, counts[
i]));
673 slices_vec.emplace_back(evtETable->column(2)->Slice(
offset, counts[
i]));
675 REQUIRE(slices_array[
i]->
length() == counts[
i]);
676 REQUIRE(slices_bool[
i]->
length() == counts[
i]);
677 REQUIRE(slices_vec[
i]->
length() == counts[
i]);
680 std::vector<arrow::Datum> slices;
681 std::vector<uint64_t> offsts;
682 auto bk =
Entry(soa::getLabelFromType<aod::Events>(),
"fID");
684 auto s = cache.updateCacheEntry(0, {evtTable});
685 auto lcache = cache.getCacheFor(bk);
686 for (
auto i = 0u;
i < 5; ++
i) {
688 auto tbl = b_e.asArrowTable()->Slice(
offset,
count);
689 auto ca = tbl->GetColumnByName(
"fArr");
690 auto cb = tbl->GetColumnByName(
"fBoo");
691 auto cv = tbl->GetColumnByName(
"fLst");
692 REQUIRE(ca->length() == counts[
i]);
693 REQUIRE(cb->length() == counts[
i]);
694 REQUIRE(cv->length() == counts[
i]);
695 REQUIRE(ca->Equals(slices_array[
i]));
696 REQUIRE(cb->Equals(slices_bool[
i]));
697 REQUIRE(cv->Equals(slices_vec[
i]));
701 for (
auto i = 0u;
i < 5; ++
i) {
703 auto tbl = BigE{{b_e.asArrowTable()->Slice(
offset,
count)},
static_cast<uint64_t
>(
offset)};
704 REQUIRE(tbl.size() == counts[
i]);
705 for (
auto&
row : tbl) {
707 REQUIRE(
row.boo() == (
j % 2 == 0));
708 auto rid =
row.globalIndex();
709 auto arr =
row.arr();
710 REQUIRE(arr[0] == 0.1f * (
float)rid);
711 REQUIRE(arr[1] == 0.2f * (
float)rid);
712 REQUIRE(arr[2] == 0.3f * (
float)rid);
715 REQUIRE(d.size() == (
size_t)
sizes[
i]);
716 for (
auto z = 0u;
z < d.size(); ++
z) {
717 REQUIRE(d[
z] == 0.5 * (
double)
z);