1 /*
2  * Distributed under the OSI-approved Apache License, Version 2.0.  See
3  * accompanying file Copyright.txt for details.
4  */
5 #include <cmath>
6 #include <cstdint>
7 #include <cstring>
8 
9 #include <iostream>
10 #include <limits>
11 #include <stdexcept>
12 
13 #include <adios2.h>
14 #include <adios2/common/ADIOSTypes.h>
15 #include <adios2/helper/adiosMath.h>
16 
17 #include <gtest/gtest.h>
18 
19 template <typename T>
printVector(const std::vector<T> & v)20 void printVector(const std::vector<T> &v)
21 {
22     const size_t ndim = v.size();
23     std::cout << "{";
24     for (int d = 0; d < ndim; ++d)
25     {
26         std::cout << v[d];
27         if (d < ndim - 1)
28         {
29             std::cout << ", ";
30         }
31         if (d > 0 && !(d % 20))
32         {
33             std::cout << "\n        ";
34         }
35     }
36     std::cout << "}";
37 }
38 
printTestInfo(const adios2::Dims & count,const size_t blockSize,const size_t sourceLine)39 void printTestInfo(const adios2::Dims &count, const size_t blockSize,
40                    const size_t sourceLine)
41 {
42     const size_t ndim = count.size();
43     std::cout << "\nTest " << ndim << "-D array ";
44     printVector(count);
45     std::cout << " divide by blockSize " << blockSize << " at line "
46               << sourceLine << std::endl;
47 }
48 
printBlockDivisionInfo(const adios2::helper::BlockDivisionInfo & info)49 void printBlockDivisionInfo(const adios2::helper::BlockDivisionInfo &info)
50 {
51     std::cout << "    nblocks = " << info.NBlocks;        // << std::endl;
52     std::cout << " subblockSize = " << info.SubBlockSize; // << std::endl;
53     std::cout << " div = ";
54     printVector(info.Div);
55     // std::cout << std::endl;
56     std::cout << " rem = ";
57     printVector(info.Rem);
58     // std::cout << std::endl;
59     std::cout << " reverseDivProduct = ";
60     printVector(info.ReverseDivProduct);
61     std::cout << std::endl;
62 }
63 
printBlock(const adios2::Box<adios2::Dims> & block,const int blockID)64 void printBlock(const adios2::Box<adios2::Dims> &block, const int blockID)
65 {
66     std::cout << "        block " << blockID << " start = ";
67     printVector(block.first);
68     std::cout << "  count = ";
69     printVector(block.second);
70     std::cout << std::endl;
71 }
72 
73 template <typename T>
printMinMax(const std::vector<T> & expected_minmax,const T & expected_bmin,const T & expected_bmax)74 void printMinMax(const std::vector<T> &expected_minmax, const T &expected_bmin,
75                  const T &expected_bmax)
76 {
77     std::cout << "    expected  bmin = " << expected_bmin
78               << "  bmax = " << expected_bmax;
79     std::cout << "  min-max = \n       ";
80     printVector(expected_minmax);
81     std::cout << std::endl;
82 }
83 
printBlock(const adios2::Box<adios2::Dims> & block,const int blockID,const std::vector<uint16_t> & expected_start,const std::vector<uint16_t> & expected_count)84 void printBlock(const adios2::Box<adios2::Dims> &block, const int blockID,
85                 const std::vector<uint16_t> &expected_start,
86                 const std::vector<uint16_t> &expected_count)
87 {
88     std::cout << "        block " << blockID << " start = ";
89     printVector(block.first);
90     std::cout << "  count = ";
91     printVector(block.second);
92     std::cout << "  expected start = ";
93     printVector(expected_start);
94     std::cout << "  count = ";
95     printVector(expected_count);
96     std::cout << std::endl;
97 }
98 
assert_block(const adios2::Box<adios2::Dims> & block,const int blockID,const std::vector<uint16_t> & expected_start,const std::vector<uint16_t> & expected_count)99 void assert_block(const adios2::Box<adios2::Dims> &block, const int blockID,
100                   const std::vector<uint16_t> &expected_start,
101                   const std::vector<uint16_t> &expected_count)
102 {
103     printBlock(block, blockID, expected_start, expected_count);
104     const adios2::Dims &block_start = block.first;
105     const adios2::Dims &block_count = block.second;
106     ASSERT_EQ(block_start.size(), expected_start.size());
107     const size_t nstart = expected_start.size();
108     for (int d = 0; d < nstart; ++d)
109     {
110         ASSERT_EQ(block_start[d], expected_start[d]);
111     }
112     ASSERT_EQ(block_count.size(), expected_count.size());
113     const size_t ncount = expected_count.size();
114     for (int d = 0; d < nstart; ++d)
115     {
116         ASSERT_EQ(block_count[d], expected_count[d]);
117     }
118 }
119 
120 template <typename T>
assert_minmax(const size_t nBlocks,const T & bmin,const T & bmax,const std::vector<T> & minmax,const T & expected_bmin,const T & expected_bmax,const std::vector<T> & expected_minmax)121 void assert_minmax(const size_t nBlocks, const T &bmin, const T &bmax,
122                    const std::vector<T> &minmax, const T &expected_bmin,
123                    const T &expected_bmax,
124                    const std::vector<T> &expected_minmax)
125 {
126     printMinMax(expected_minmax, expected_bmin, expected_bmax);
127     ASSERT_EQ(bmin, expected_bmin);
128     ASSERT_EQ(bmax, expected_bmax);
129 
130     const size_t nMinMax = expected_minmax.size();
131     ASSERT_EQ(nMinMax, 2 * nBlocks);
132     for (int i = 0; i < nMinMax; ++i)
133     {
134         ASSERT_EQ(minmax[i], expected_minmax[i]);
135     }
136 }
137 
TEST(ADIOS2MinMaxs,ADIOS2MinMaxs_1D_100)138 TEST(ADIOS2MinMaxs, ADIOS2MinMaxs_1D_100)
139 {
140     std::vector<int> data(100);
141     for (int i = 0; i < data.size(); ++i)
142     {
143         data[i] = i;
144     }
145     size_t blockSize;
146     adios2::Dims count(1, data.size());
147     adios2::Box<adios2::Dims> block;
148     // int blockID;
149     std::vector<int> MinMaxs;
150     int Min, Max;
151 
152     {
153         blockSize = 100;
154         printTestInfo(count, blockSize, __LINE__);
155 
156         struct adios2::helper::BlockDivisionInfo subBlockInfo =
157             adios2::helper::DivideBlock(
158                 count, blockSize,
159                 adios2::helper::BlockDivisionMethod::Contiguous);
160         printBlockDivisionInfo(subBlockInfo);
161 
162         /*blockID = 0;
163         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
164         assert_block(block, blockID, {0}, {100});*/
165 
166         adios2::helper::GetMinMaxSubblocks(data.data(), count, subBlockInfo,
167                                            MinMaxs, Min, Max, 1);
168         assert_minmax(subBlockInfo.NBlocks, Min, Max, MinMaxs, 0, 99, {0, 99});
169     }
170 
171     {
172         blockSize = 50;
173         printTestInfo(count, blockSize, __LINE__);
174 
175         struct adios2::helper::BlockDivisionInfo subBlockInfo =
176             adios2::helper::DivideBlock(
177                 count, blockSize,
178                 adios2::helper::BlockDivisionMethod::Contiguous);
179         printBlockDivisionInfo(subBlockInfo);
180 
181         /*blockID = 0;
182         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
183         assert_block(block, blockID, {0}, {50});
184 
185         blockID = 1;
186         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
187         assert_block(block, blockID, {50}, {50});*/
188 
189         adios2::helper::GetMinMaxSubblocks(data.data(), count, subBlockInfo,
190                                            MinMaxs, Min, Max, 1);
191         assert_minmax(subBlockInfo.NBlocks, Min, Max, MinMaxs, 0, 99,
192                       {0, 49, 50, 99});
193     }
194 
195     {
196         blockSize = 17;
197         printTestInfo(count, blockSize, __LINE__);
198 
199         struct adios2::helper::BlockDivisionInfo subBlockInfo =
200             adios2::helper::DivideBlock(
201                 count, blockSize,
202                 adios2::helper::BlockDivisionMethod::Contiguous);
203         printBlockDivisionInfo(subBlockInfo);
204 
205         /*blockID = 0;
206         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
207         assert_block(block, blockID, {0}, {17});
208 
209         blockID = 1;
210         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
211         assert_block(block, blockID, {17}, {17});
212 
213         blockID = 2;
214         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
215         assert_block(block, blockID, {34}, {17});
216 
217         blockID = 3;
218         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
219         assert_block(block, blockID, {51}, {17});
220 
221         blockID = 4;
222         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
223         assert_block(block, blockID, {68}, {16});
224 
225         blockID = 5;
226         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
227         assert_block(block, blockID, {84}, {16});*/
228 
229         adios2::helper::GetMinMaxSubblocks(data.data(), count, subBlockInfo,
230                                            MinMaxs, Min, Max, 1);
231         assert_minmax(subBlockInfo.NBlocks, Min, Max, MinMaxs, 0, 99,
232                       {0, 16, 17, 33, 34, 50, 51, 67, 68, 83, 84, 99});
233     }
234 
235     {
236         blockSize = 170;
237         printTestInfo(count, blockSize, __LINE__);
238 
239         struct adios2::helper::BlockDivisionInfo subBlockInfo =
240             adios2::helper::DivideBlock(
241                 count, blockSize,
242                 adios2::helper::BlockDivisionMethod::Contiguous);
243         printBlockDivisionInfo(subBlockInfo);
244 
245         /*blockID = 0;
246         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
247         assert_block(block, blockID, {0}, {100});*/
248 
249         adios2::helper::GetMinMaxSubblocks(data.data(), count, subBlockInfo,
250                                            MinMaxs, Min, Max, 1);
251         assert_minmax(subBlockInfo.NBlocks, Min, Max, MinMaxs, 0, 99, {0, 99});
252     }
253 
254     {
255         blockSize = 1;
256         printTestInfo(count, blockSize, __LINE__);
257 
258         struct adios2::helper::BlockDivisionInfo subBlockInfo =
259             adios2::helper::DivideBlock(
260                 count, blockSize,
261                 adios2::helper::BlockDivisionMethod::Contiguous);
262         printBlockDivisionInfo(subBlockInfo);
263         ASSERT_EQ(subBlockInfo.NBlocks, 100);
264         ASSERT_EQ(subBlockInfo.SubBlockSize, blockSize);
265         ASSERT_EQ(subBlockInfo.Div.size(), 1);
266         ASSERT_EQ(subBlockInfo.Div[0], 100);
267         ASSERT_EQ(subBlockInfo.Rem.size(), 1);
268         ASSERT_EQ(subBlockInfo.Rem[0], 0);
269         ASSERT_EQ(subBlockInfo.ReverseDivProduct.size(), 1);
270         ASSERT_EQ(subBlockInfo.ReverseDivProduct[0], 1);
271 
272         /*blockID = 0;
273         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
274         assert_block(block, blockID, {0}, {1});
275 
276         blockID = 1;
277         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
278         assert_block(block, blockID, {1}, {1});
279 
280         blockID = 77;
281         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
282         assert_block(block, blockID, {77}, {1});
283 
284         blockID = 99;
285         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
286         assert_block(block, blockID, {99}, {1});*/
287 
288         adios2::helper::GetMinMaxSubblocks(data.data(), count, subBlockInfo,
289                                            MinMaxs, Min, Max, 1);
290         std::vector<int> mm(200);
291         for (int j = 0; j < 100; j++)
292         {
293             mm[2 * j] = j;
294             mm[2 * j + 1] = j;
295         }
296         assert_minmax(subBlockInfo.NBlocks, Min, Max, MinMaxs, 0, 99, mm);
297     }
298 }
299 
TEST(ADIOS2MinMaxs,ADIOS2MinMaxs_2D_10x10)300 TEST(ADIOS2MinMaxs, ADIOS2MinMaxs_2D_10x10)
301 {
302     std::vector<int> data(100);
303     for (int i = 0; i < data.size(); ++i)
304     {
305         data[i] = i;
306     }
307     size_t blockSize;
308     adios2::Dims count(2, 10);
309 
310     adios2::Box<adios2::Dims> block;
311     // int blockID;
312     std::vector<int> MinMaxs;
313     int Min, Max;
314 
315     {
316         blockSize = 100;
317         printTestInfo(count, blockSize, __LINE__);
318 
319         struct adios2::helper::BlockDivisionInfo subBlockInfo =
320             adios2::helper::DivideBlock(
321                 count, blockSize,
322                 adios2::helper::BlockDivisionMethod::Contiguous);
323         printBlockDivisionInfo(subBlockInfo);
324 
325         /*blockID = 0;
326         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
327         assert_block(block, blockID, {0, 0}, {10, 10});*/
328 
329         adios2::helper::GetMinMaxSubblocks(data.data(), count, subBlockInfo,
330                                            MinMaxs, Min, Max, 1);
331         assert_minmax(subBlockInfo.NBlocks, Min, Max, MinMaxs, 0, 99, {0, 99});
332     }
333 
334     {
335         blockSize = 50;
336         printTestInfo(count, blockSize, __LINE__);
337 
338         struct adios2::helper::BlockDivisionInfo subBlockInfo =
339             adios2::helper::DivideBlock(
340                 count, blockSize,
341                 adios2::helper::BlockDivisionMethod::Contiguous);
342         printBlockDivisionInfo(subBlockInfo);
343 
344         /*blockID = 0;
345         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
346         assert_block(block, blockID, {0, 0}, {5, 10});
347 
348         blockID = 1;
349         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
350         assert_block(block, blockID, {5, 0}, {5, 10});*/
351 
352         adios2::helper::GetMinMaxSubblocks(data.data(), count, subBlockInfo,
353                                            MinMaxs, Min, Max, 1);
354         assert_minmax(subBlockInfo.NBlocks, Min, Max, MinMaxs, 0, 99,
355                       {0, 49, 50, 99});
356     }
357 
358     {
359         blockSize = 5;
360         printTestInfo(count, blockSize, __LINE__);
361 
362         struct adios2::helper::BlockDivisionInfo subBlockInfo =
363             adios2::helper::DivideBlock(
364                 count, blockSize,
365                 adios2::helper::BlockDivisionMethod::Contiguous);
366         printBlockDivisionInfo(subBlockInfo);
367         ASSERT_EQ(subBlockInfo.NBlocks, 20);
368         ASSERT_EQ(subBlockInfo.SubBlockSize, blockSize);
369         ASSERT_EQ(subBlockInfo.Div.size(), 2);
370         ASSERT_EQ(subBlockInfo.Div[0], 10);
371         ASSERT_EQ(subBlockInfo.Div[1], 2);
372         ASSERT_EQ(subBlockInfo.Rem.size(), 2);
373         ASSERT_EQ(subBlockInfo.Rem[0], 0);
374         ASSERT_EQ(subBlockInfo.Rem[1], 0);
375         ASSERT_EQ(subBlockInfo.ReverseDivProduct.size(), 2);
376         ASSERT_EQ(subBlockInfo.ReverseDivProduct[0], 2);
377         ASSERT_EQ(subBlockInfo.ReverseDivProduct[1], 1);
378 
379         /*blockID = 0;
380         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
381         assert_block(block, blockID, {0, 0}, {1, 5});
382 
383         blockID = 1;
384         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
385         assert_block(block, blockID, {0, 5}, {1, 5});
386 
387         blockID = 2;
388         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
389         assert_block(block, blockID, {1, 0}, {1, 5});
390 
391         blockID = 3;
392         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
393         assert_block(block, blockID, {1, 5}, {1, 5});
394 
395         blockID = 18;
396         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
397         assert_block(block, blockID, {9, 0}, {1, 5});
398 
399         blockID = 19;
400         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
401         assert_block(block, blockID, {9, 5}, {1, 5});*/
402 
403         adios2::helper::GetMinMaxSubblocks(data.data(), count, subBlockInfo,
404                                            MinMaxs, Min, Max, 1);
405         assert_minmax(subBlockInfo.NBlocks, Min, Max, MinMaxs, 0, 99,
406                       {0,  4,  5,  9,  10, 14, 15, 19, 20, 24, 25, 29, 30, 34,
407                        35, 39, 40, 44, 45, 49, 50, 54, 55, 59, 60, 64, 65, 69,
408                        70, 74, 75, 79, 80, 84, 85, 89, 90, 94, 95, 99});
409     }
410 
411     {
412         blockSize = 17;
413         printTestInfo(count, blockSize, __LINE__);
414 
415         struct adios2::helper::BlockDivisionInfo subBlockInfo =
416             adios2::helper::DivideBlock(
417                 count, blockSize,
418                 adios2::helper::BlockDivisionMethod::Contiguous);
419         printBlockDivisionInfo(subBlockInfo);
420         ASSERT_EQ(subBlockInfo.NBlocks, 6);
421         ASSERT_EQ(subBlockInfo.SubBlockSize, blockSize);
422         ASSERT_EQ(subBlockInfo.Div.size(), 2);
423         ASSERT_EQ(subBlockInfo.Div[0], 6);
424         ASSERT_EQ(subBlockInfo.Div[1], 1);
425         ASSERT_EQ(subBlockInfo.Rem.size(), 2);
426         ASSERT_EQ(subBlockInfo.Rem[0], 4);
427         ASSERT_EQ(subBlockInfo.Rem[1], 0);
428         ASSERT_EQ(subBlockInfo.ReverseDivProduct.size(), 2);
429         ASSERT_EQ(subBlockInfo.ReverseDivProduct[0], 1);
430         ASSERT_EQ(subBlockInfo.ReverseDivProduct[1], 1);
431 
432         /*blockID = 0;
433         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
434         assert_block(block, blockID, {0, 0}, {2, 10});
435 
436         blockID = 1;
437         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
438         assert_block(block, blockID, {2, 0}, {2, 10});
439 
440         blockID = 2;
441         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
442         assert_block(block, blockID, {4, 0}, {2, 10});
443 
444         blockID = 3;
445         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
446         assert_block(block, blockID, {6, 0}, {2, 10});
447 
448         blockID = 4;
449         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
450         assert_block(block, blockID, {8, 0}, {1, 10});
451 
452         blockID = 5;
453         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
454         assert_block(block, blockID, {9, 0}, {1, 10});*/
455 
456         adios2::helper::GetMinMaxSubblocks(data.data(), count, subBlockInfo,
457                                            MinMaxs, Min, Max, 1);
458         assert_minmax(subBlockInfo.NBlocks, Min, Max, MinMaxs, 0, 99,
459                       {0, 19, 20, 39, 40, 59, 60, 79, 80, 89, 90, 99});
460     }
461 
462     {
463         blockSize = 170;
464         printTestInfo(count, blockSize, __LINE__);
465 
466         struct adios2::helper::BlockDivisionInfo subBlockInfo =
467             adios2::helper::DivideBlock(
468                 count, blockSize,
469                 adios2::helper::BlockDivisionMethod::Contiguous);
470         printBlockDivisionInfo(subBlockInfo);
471         ASSERT_EQ(subBlockInfo.NBlocks, 1);
472         ASSERT_EQ(subBlockInfo.SubBlockSize, blockSize);
473         ASSERT_EQ(subBlockInfo.Div.size(), 2);
474         ASSERT_EQ(subBlockInfo.Div[0], 1);
475         ASSERT_EQ(subBlockInfo.Div[1], 1);
476         ASSERT_EQ(subBlockInfo.Rem.size(), 2);
477         ASSERT_EQ(subBlockInfo.Rem[0], 0);
478         ASSERT_EQ(subBlockInfo.Rem[1], 0);
479         ASSERT_EQ(subBlockInfo.ReverseDivProduct.size(), 2);
480         ASSERT_EQ(subBlockInfo.ReverseDivProduct[0], 1);
481         ASSERT_EQ(subBlockInfo.ReverseDivProduct[1], 1);
482 
483         /*blockID = 0;
484         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
485         assert_block(block, blockID, {0, 0}, {10, 10});*/
486 
487         adios2::helper::GetMinMaxSubblocks(data.data(), count, subBlockInfo,
488                                            MinMaxs, Min, Max, 1);
489         assert_minmax(subBlockInfo.NBlocks, Min, Max, MinMaxs, 0, 99, {0, 99});
490     }
491 
492     {
493         blockSize = 1;
494         printTestInfo(count, blockSize, __LINE__);
495 
496         struct adios2::helper::BlockDivisionInfo subBlockInfo =
497             adios2::helper::DivideBlock(
498                 count, blockSize,
499                 adios2::helper::BlockDivisionMethod::Contiguous);
500         printBlockDivisionInfo(subBlockInfo);
501         ASSERT_EQ(subBlockInfo.NBlocks, 100);
502         ASSERT_EQ(subBlockInfo.SubBlockSize, blockSize);
503         ASSERT_EQ(subBlockInfo.Div.size(), 2);
504         ASSERT_EQ(subBlockInfo.Div[0], 10);
505         ASSERT_EQ(subBlockInfo.Div[1], 10);
506         ASSERT_EQ(subBlockInfo.Rem.size(), 2);
507         ASSERT_EQ(subBlockInfo.Rem[0], 0);
508         ASSERT_EQ(subBlockInfo.Rem[1], 0);
509         ASSERT_EQ(subBlockInfo.ReverseDivProduct.size(), 2);
510         ASSERT_EQ(subBlockInfo.ReverseDivProduct[0], 10);
511         ASSERT_EQ(subBlockInfo.ReverseDivProduct[1], 1);
512 
513         /*blockID = 0;
514         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
515         assert_block(block, blockID, {0, 0}, {1, 1});
516 
517         blockID = 1;
518         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
519         assert_block(block, blockID, {0, 1}, {1, 1});
520 
521         blockID = 9;
522         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
523         assert_block(block, blockID, {0, 9}, {1, 1});
524 
525         blockID = 10;
526         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
527         assert_block(block, blockID, {1, 0}, {1, 1});
528 
529         blockID = 77;
530         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
531         assert_block(block, blockID, {7, 7}, {1, 1});
532 
533         blockID = 99;
534         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
535         assert_block(block, blockID, {9, 9}, {1, 1});*/
536 
537         adios2::helper::GetMinMaxSubblocks(data.data(), count, subBlockInfo,
538                                            MinMaxs, Min, Max, 1);
539         std::vector<int> mm(200);
540         for (int j = 0; j < 100; j++)
541         {
542             mm[2 * j] = j;
543             mm[2 * j + 1] = j;
544         }
545         assert_minmax(subBlockInfo.NBlocks, Min, Max, MinMaxs, 0, 99, mm);
546     }
547 
548     {
549         blockSize = 3;
550         printTestInfo(count, blockSize, __LINE__);
551 
552         struct adios2::helper::BlockDivisionInfo subBlockInfo =
553             adios2::helper::DivideBlock(
554                 count, blockSize,
555                 adios2::helper::BlockDivisionMethod::Contiguous);
556         printBlockDivisionInfo(subBlockInfo);
557         ASSERT_EQ(subBlockInfo.NBlocks, 30);
558         ASSERT_EQ(subBlockInfo.SubBlockSize, blockSize);
559         ASSERT_EQ(subBlockInfo.Div.size(), 2);
560         ASSERT_EQ(subBlockInfo.Div[0], 10);
561         ASSERT_EQ(subBlockInfo.Div[1], 3);
562         ASSERT_EQ(subBlockInfo.Rem.size(), 2);
563         ASSERT_EQ(subBlockInfo.Rem[0], 0);
564         ASSERT_EQ(subBlockInfo.Rem[1], 1);
565         ASSERT_EQ(subBlockInfo.ReverseDivProduct.size(), 2);
566         ASSERT_EQ(subBlockInfo.ReverseDivProduct[0], 3);
567 
568         /*blockID = 0;
569         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
570         assert_block(block, blockID, {0, 0}, {1, 4});
571 
572         blockID = 1;
573         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
574         assert_block(block, blockID, {0, 4}, {1, 3});
575 
576         blockID = 2;
577         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
578         assert_block(block, blockID, {0, 7}, {1, 3});
579 
580         blockID = 3;
581         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
582         assert_block(block, blockID, {1, 0}, {1, 4});
583 
584         blockID = 4;
585         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
586         assert_block(block, blockID, {1, 4}, {1, 3});
587 
588         blockID = 5;
589         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
590         assert_block(block, blockID, {1, 7}, {1, 3});
591 
592         blockID = 27;
593         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
594         assert_block(block, blockID, {9, 0}, {1, 4});
595 
596         blockID = 28;
597         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
598         assert_block(block, blockID, {9, 4}, {1, 3});
599 
600         blockID = 29;
601         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
602         assert_block(block, blockID, {9, 7}, {1, 3}); */
603 
604         adios2::helper::GetMinMaxSubblocks(data.data(), count, subBlockInfo,
605                                            MinMaxs, Min, Max, 1);
606         assert_minmax(subBlockInfo.NBlocks, Min, Max, MinMaxs, 0, 99,
607                       {0,  3,  4,  6,  7,  9,  10, 13, 14, 16, 17, 19,
608                        20, 23, 24, 26, 27, 29, 30, 33, 34, 36, 37, 39,
609                        40, 43, 44, 46, 47, 49, 50, 53, 54, 56, 57, 59,
610                        60, 63, 64, 66, 67, 69, 70, 73, 74, 76, 77, 79,
611                        80, 83, 84, 86, 87, 89, 90, 93, 94, 96, 97, 99});
612     }
613 }
614 
TEST(ADIOS2MinMaxs,ADIOS2MinMaxs_3D_10x10x10)615 TEST(ADIOS2MinMaxs, ADIOS2MinMaxs_3D_10x10x10)
616 {
617     std::vector<int> data(1000);
618     for (int i = 0; i < data.size(); ++i)
619     {
620         data[i] = i;
621     }
622     size_t blockSize;
623     adios2::Dims count(3, 10);
624 
625     adios2::Box<adios2::Dims> block;
626     // int blockID;
627     std::vector<int> MinMaxs;
628     int Min, Max;
629 
630     {
631         blockSize = 100;
632         printTestInfo(count, blockSize, __LINE__);
633 
634         struct adios2::helper::BlockDivisionInfo subBlockInfo =
635             adios2::helper::DivideBlock(
636                 count, blockSize,
637                 adios2::helper::BlockDivisionMethod::Contiguous);
638         printBlockDivisionInfo(subBlockInfo);
639         ASSERT_EQ(subBlockInfo.NBlocks, 10);
640         ASSERT_EQ(subBlockInfo.SubBlockSize, blockSize);
641         ASSERT_EQ(subBlockInfo.Div.size(), 3);
642         ASSERT_EQ(subBlockInfo.Div[0], 10);
643         ASSERT_EQ(subBlockInfo.Div[1], 1);
644         ASSERT_EQ(subBlockInfo.Div[2], 1);
645         ASSERT_EQ(subBlockInfo.Rem.size(), 3);
646         ASSERT_EQ(subBlockInfo.Rem[0], 0);
647         ASSERT_EQ(subBlockInfo.Rem[1], 0);
648         ASSERT_EQ(subBlockInfo.Rem[2], 0);
649         ASSERT_EQ(subBlockInfo.ReverseDivProduct.size(), 3);
650         ASSERT_EQ(subBlockInfo.ReverseDivProduct[0], 1);
651         ASSERT_EQ(subBlockInfo.ReverseDivProduct[1], 1);
652         ASSERT_EQ(subBlockInfo.ReverseDivProduct[2], 1);
653 
654         /*blockID = 0;
655         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
656         assert_block(block, blockID, {0, 0, 0}, {1, 10, 10});
657 
658         blockID = 1;
659         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
660         assert_block(block, blockID, {1, 0, 0}, {1, 10, 10});
661 
662         blockID = 9;
663         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
664         assert_block(block, blockID, {9, 0, 0}, {1, 10, 10});*/
665 
666         adios2::helper::GetMinMaxSubblocks(data.data(), count, subBlockInfo,
667                                            MinMaxs, Min, Max, 1);
668         assert_minmax(subBlockInfo.NBlocks, Min, Max, MinMaxs, 0, 999,
669                       {0,   99,  100, 199, 200, 299, 300, 399, 400, 499,
670                        500, 599, 600, 699, 700, 799, 800, 899, 900, 999});
671     }
672 
673     {
674         blockSize = 500;
675         printTestInfo(count, blockSize, __LINE__);
676 
677         struct adios2::helper::BlockDivisionInfo subBlockInfo =
678             adios2::helper::DivideBlock(
679                 count, blockSize,
680                 adios2::helper::BlockDivisionMethod::Contiguous);
681         printBlockDivisionInfo(subBlockInfo);
682         ASSERT_EQ(subBlockInfo.NBlocks, 2);
683         ASSERT_EQ(subBlockInfo.SubBlockSize, blockSize);
684         ASSERT_EQ(subBlockInfo.Div.size(), 3);
685         ASSERT_EQ(subBlockInfo.Div[0], 2);
686         ASSERT_EQ(subBlockInfo.Div[1], 1);
687         ASSERT_EQ(subBlockInfo.Div[2], 1);
688         ASSERT_EQ(subBlockInfo.Rem.size(), 3);
689         ASSERT_EQ(subBlockInfo.Rem[0], 0);
690         ASSERT_EQ(subBlockInfo.Rem[1], 0);
691         ASSERT_EQ(subBlockInfo.Rem[2], 0);
692         ASSERT_EQ(subBlockInfo.ReverseDivProduct.size(), 3);
693         ASSERT_EQ(subBlockInfo.ReverseDivProduct[0], 1);
694         ASSERT_EQ(subBlockInfo.ReverseDivProduct[1], 1);
695         ASSERT_EQ(subBlockInfo.ReverseDivProduct[2], 1);
696 
697         /*blockID = 0;
698         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
699         assert_block(block, blockID, {0, 0, 0}, {5, 10, 10});
700 
701         blockID = 1;
702         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
703         assert_block(block, blockID, {5, 0, 0}, {5, 10, 10});*/
704         adios2::helper::GetMinMaxSubblocks(data.data(), count, subBlockInfo,
705                                            MinMaxs, Min, Max, 1);
706         assert_minmax(subBlockInfo.NBlocks, Min, Max, MinMaxs, 0, 999,
707                       {0, 499, 500, 999});
708     }
709 
710     {
711         blockSize = 50;
712         printTestInfo(count, blockSize, __LINE__);
713 
714         struct adios2::helper::BlockDivisionInfo subBlockInfo =
715             adios2::helper::DivideBlock(
716                 count, blockSize,
717                 adios2::helper::BlockDivisionMethod::Contiguous);
718         printBlockDivisionInfo(subBlockInfo);
719         ASSERT_EQ(subBlockInfo.NBlocks, 20);
720         ASSERT_EQ(subBlockInfo.SubBlockSize, blockSize);
721         ASSERT_EQ(subBlockInfo.Div.size(), 3);
722         ASSERT_EQ(subBlockInfo.Div[0], 10);
723         ASSERT_EQ(subBlockInfo.Div[1], 2);
724         ASSERT_EQ(subBlockInfo.Div[2], 1);
725         ASSERT_EQ(subBlockInfo.Rem.size(), 3);
726         ASSERT_EQ(subBlockInfo.Rem[0], 0);
727         ASSERT_EQ(subBlockInfo.Rem[1], 0);
728         ASSERT_EQ(subBlockInfo.Rem[2], 0);
729         ASSERT_EQ(subBlockInfo.ReverseDivProduct.size(), 3);
730         ASSERT_EQ(subBlockInfo.ReverseDivProduct[0], 2);
731         ASSERT_EQ(subBlockInfo.ReverseDivProduct[1], 1);
732         ASSERT_EQ(subBlockInfo.ReverseDivProduct[2], 1);
733 
734         /*blockID = 0;
735         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
736         assert_block(block, blockID, {0, 0, 0}, {1, 5, 10});
737 
738         blockID = 1;
739         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
740         assert_block(block, blockID, {0, 5, 0}, {1, 5, 10});
741 
742         blockID = 2;
743         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
744         assert_block(block, blockID, {1, 0, 0}, {1, 5, 10});
745 
746         blockID = 3;
747         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
748         assert_block(block, blockID, {1, 5, 0}, {1, 5, 10});
749 
750         blockID = 18;
751         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
752         assert_block(block, blockID, {9, 0, 0}, {1, 5, 10});
753 
754         blockID = 19;
755         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
756         assert_block(block, blockID, {9, 5, 0}, {1, 5, 10});*/
757 
758         adios2::helper::GetMinMaxSubblocks(data.data(), count, subBlockInfo,
759                                            MinMaxs, Min, Max, 1);
760         assert_minmax(subBlockInfo.NBlocks, Min, Max, MinMaxs, 0, 999,
761                       {0,   49,  50,  99,  100, 149, 150, 199, 200, 249,
762                        250, 299, 300, 349, 350, 399, 400, 449, 450, 499,
763                        500, 549, 550, 599, 600, 649, 650, 699, 700, 749,
764                        750, 799, 800, 849, 850, 899, 900, 949, 950, 999});
765     }
766 
767     {
768         blockSize = 17;
769         printTestInfo(count, blockSize, __LINE__);
770 
771         struct adios2::helper::BlockDivisionInfo subBlockInfo =
772             adios2::helper::DivideBlock(
773                 count, blockSize,
774                 adios2::helper::BlockDivisionMethod::Contiguous);
775         printBlockDivisionInfo(subBlockInfo);
776         ASSERT_EQ(subBlockInfo.NBlocks, 50);
777         ASSERT_EQ(subBlockInfo.SubBlockSize, blockSize);
778         ASSERT_EQ(subBlockInfo.Div.size(), 3);
779         ASSERT_EQ(subBlockInfo.Div[0], 10);
780         ASSERT_EQ(subBlockInfo.Div[1], 5);
781         ASSERT_EQ(subBlockInfo.Div[2], 1);
782         ASSERT_EQ(subBlockInfo.Rem.size(), 3);
783         ASSERT_EQ(subBlockInfo.Rem[0], 0);
784         ASSERT_EQ(subBlockInfo.Rem[1], 0);
785         ASSERT_EQ(subBlockInfo.Rem[2], 0);
786         ASSERT_EQ(subBlockInfo.ReverseDivProduct.size(), 3);
787         ASSERT_EQ(subBlockInfo.ReverseDivProduct[0], 5);
788         ASSERT_EQ(subBlockInfo.ReverseDivProduct[1], 1);
789         ASSERT_EQ(subBlockInfo.ReverseDivProduct[2], 1);
790 
791         /*blockID = 0;
792         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
793         assert_block(block, blockID, {0, 0, 0}, {1, 2, 10});
794 
795         blockID = 1;
796         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
797         assert_block(block, blockID, {0, 2, 0}, {1, 2, 10});
798 
799         blockID = 2;
800         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
801         assert_block(block, blockID, {0, 4, 0}, {1, 2, 10});
802 
803         blockID = 4;
804         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
805         assert_block(block, blockID, {0, 8, 0}, {1, 2, 10});
806 
807         blockID = 5;
808         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
809         assert_block(block, blockID, {1, 0, 0}, {1, 2, 10});
810 
811         blockID = 48;
812         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
813         assert_block(block, blockID, {9, 6, 0}, {1, 2, 10});
814 
815         blockID = 49;
816         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
817         assert_block(block, blockID, {9, 8, 0}, {1, 2, 10});*/
818 
819         adios2::helper::GetMinMaxSubblocks(data.data(), count, subBlockInfo,
820                                            MinMaxs, Min, Max, 1);
821         std::vector<int> mm(100);
822         for (int j = 0; j < 50; j++)
823         {
824             mm[2 * j] = 20 * j;
825             mm[2 * j + 1] = 20 * j + 19;
826         }
827         assert_minmax(subBlockInfo.NBlocks, Min, Max, MinMaxs, 0, 999, mm);
828     }
829 
830     {
831         blockSize = 170;
832         printTestInfo(count, blockSize, __LINE__);
833 
834         struct adios2::helper::BlockDivisionInfo subBlockInfo =
835             adios2::helper::DivideBlock(
836                 count, blockSize,
837                 adios2::helper::BlockDivisionMethod::Contiguous);
838         printBlockDivisionInfo(subBlockInfo);
839         ASSERT_EQ(subBlockInfo.NBlocks, 6);
840         ASSERT_EQ(subBlockInfo.SubBlockSize, blockSize);
841         ASSERT_EQ(subBlockInfo.Div.size(), 3);
842         ASSERT_EQ(subBlockInfo.Div[0], 6);
843         ASSERT_EQ(subBlockInfo.Div[1], 1);
844         ASSERT_EQ(subBlockInfo.Div[2], 1);
845         ASSERT_EQ(subBlockInfo.Rem.size(), 3);
846         ASSERT_EQ(subBlockInfo.Rem[0], 4);
847         ASSERT_EQ(subBlockInfo.Rem[1], 0);
848         ASSERT_EQ(subBlockInfo.Rem[2], 0);
849         ASSERT_EQ(subBlockInfo.ReverseDivProduct.size(), 3);
850         ASSERT_EQ(subBlockInfo.ReverseDivProduct[0], 1);
851         ASSERT_EQ(subBlockInfo.ReverseDivProduct[1], 1);
852         ASSERT_EQ(subBlockInfo.ReverseDivProduct[2], 1);
853 
854         /*blockID = 0;
855         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
856         assert_block(block, blockID, {0, 0, 0}, {2, 10, 10});
857 
858         blockID = 1;
859         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
860         assert_block(block, blockID, {2, 0, 0}, {2, 10, 10});
861 
862         blockID = 2;
863         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
864         assert_block(block, blockID, {4, 0, 0}, {2, 10, 10});
865 
866         blockID = 3;
867         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
868         assert_block(block, blockID, {6, 0, 0}, {2, 10, 10});
869 
870         blockID = 4;
871         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
872         assert_block(block, blockID, {8, 0, 0}, {1, 10, 10});
873 
874         blockID = 5;
875         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
876         assert_block(block, blockID, {9, 0, 0}, {1, 10, 10}); */
877 
878         adios2::helper::GetMinMaxSubblocks(data.data(), count, subBlockInfo,
879                                            MinMaxs, Min, Max, 1);
880         assert_minmax(
881             subBlockInfo.NBlocks, Min, Max, MinMaxs, 0, 999,
882             {0, 199, 200, 399, 400, 599, 600, 799, 800, 899, 900, 999});
883     }
884 
885     {
886         blockSize = 1;
887         printTestInfo(count, blockSize, __LINE__);
888 
889         struct adios2::helper::BlockDivisionInfo subBlockInfo =
890             adios2::helper::DivideBlock(
891                 count, blockSize,
892                 adios2::helper::BlockDivisionMethod::Contiguous);
893         printBlockDivisionInfo(subBlockInfo);
894         ASSERT_EQ(subBlockInfo.NBlocks, 1000);
895         ASSERT_EQ(subBlockInfo.SubBlockSize, blockSize);
896         ASSERT_EQ(subBlockInfo.Div.size(), 3);
897         ASSERT_EQ(subBlockInfo.Div[0], 10);
898         ASSERT_EQ(subBlockInfo.Div[1], 10);
899         ASSERT_EQ(subBlockInfo.Div[2], 10);
900         ASSERT_EQ(subBlockInfo.Rem.size(), 3);
901         ASSERT_EQ(subBlockInfo.Rem[0], 0);
902         ASSERT_EQ(subBlockInfo.Rem[1], 0);
903         ASSERT_EQ(subBlockInfo.Rem[2], 0);
904         ASSERT_EQ(subBlockInfo.ReverseDivProduct.size(), 3);
905         ASSERT_EQ(subBlockInfo.ReverseDivProduct[0], 100);
906         ASSERT_EQ(subBlockInfo.ReverseDivProduct[1], 10);
907         ASSERT_EQ(subBlockInfo.ReverseDivProduct[2], 1);
908 
909         /*blockID = 0;
910         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
911         assert_block(block, blockID, {0, 0, 0}, {1, 1, 1});
912 
913         blockID = 1;
914         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
915         assert_block(block, blockID, {0, 0, 1}, {1, 1, 1});
916 
917         blockID = 10;
918         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
919         assert_block(block, blockID, {0, 1, 0}, {1, 1, 1});
920 
921         blockID = 17;
922         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
923         assert_block(block, blockID, {0, 1, 7}, {1, 1, 1});
924 
925         blockID = 536;
926         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
927         assert_block(block, blockID, {5, 3, 6}, {1, 1, 1});
928 
929         blockID = 999;
930         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
931         assert_block(block, blockID, {9, 9, 9}, {1, 1, 1});*/
932 
933         adios2::helper::GetMinMaxSubblocks(data.data(), count, subBlockInfo,
934                                            MinMaxs, Min, Max, 1);
935         std::vector<int> mm(2000);
936         for (int j = 0; j < 1000; j++)
937         {
938             mm[2 * j] = j;
939             mm[2 * j + 1] = j;
940         }
941         assert_minmax(subBlockInfo.NBlocks, Min, Max, MinMaxs, 0, 999, mm);
942     }
943 
944     {
945         blockSize = 3;
946         printTestInfo(count, blockSize, __LINE__);
947 
948         struct adios2::helper::BlockDivisionInfo subBlockInfo =
949             adios2::helper::DivideBlock(
950                 count, blockSize,
951                 adios2::helper::BlockDivisionMethod::Contiguous);
952         printBlockDivisionInfo(subBlockInfo);
953         ASSERT_EQ(subBlockInfo.NBlocks, 300);
954         ASSERT_EQ(subBlockInfo.SubBlockSize, blockSize);
955         ASSERT_EQ(subBlockInfo.Div.size(), 3);
956         ASSERT_EQ(subBlockInfo.Div[0], 10);
957         ASSERT_EQ(subBlockInfo.Div[1], 10);
958         ASSERT_EQ(subBlockInfo.Div[2], 3);
959         ASSERT_EQ(subBlockInfo.Rem.size(), 3);
960         ASSERT_EQ(subBlockInfo.Rem[0], 0);
961         ASSERT_EQ(subBlockInfo.Rem[1], 0);
962         ASSERT_EQ(subBlockInfo.Rem[2], 1);
963         ASSERT_EQ(subBlockInfo.ReverseDivProduct.size(), 3);
964         ASSERT_EQ(subBlockInfo.ReverseDivProduct[0], 30);
965         ASSERT_EQ(subBlockInfo.ReverseDivProduct[1], 3);
966         ASSERT_EQ(subBlockInfo.ReverseDivProduct[2], 1);
967 
968         /*blockID = 0;
969         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
970         assert_block(block, blockID, {0, 0, 0}, {1, 1, 4});
971 
972         blockID = 1;
973         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
974         assert_block(block, blockID, {0, 0, 4}, {1, 1, 3});
975 
976         blockID = 2;
977         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
978         assert_block(block, blockID, {0, 0, 7}, {1, 1, 3});
979 
980         blockID = 3;
981         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
982         assert_block(block, blockID, {0, 1, 0}, {1, 1, 4});
983 
984         blockID = 29;
985         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
986         assert_block(block, blockID, {0, 9, 7}, {1, 1, 3});
987 
988         blockID = 30;
989         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
990         assert_block(block, blockID, {1, 0, 0}, {1, 1, 4});
991 
992         blockID = 60;
993         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
994         assert_block(block, blockID, {2, 0, 0}, {1, 1, 4});
995 
996         blockID = 180;
997         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
998         assert_block(block, blockID, {6, 0, 0}, {1, 1, 4});
999 
1000         blockID = 217;
1001         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
1002         assert_block(block, blockID, {7, 2, 4}, {1, 1, 3});
1003 
1004         blockID = 299;
1005         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
1006         assert_block(block, blockID, {9, 9, 7}, {1, 1, 3});*/
1007 
1008         adios2::helper::GetMinMaxSubblocks(data.data(), count, subBlockInfo,
1009                                            MinMaxs, Min, Max, 1);
1010         std::vector<int> mm(600);
1011         for (int i = 0; i < 10; i++)
1012         {
1013             for (int j = 0; j < 10; j++)
1014             {
1015                 int idx = i * 10 + j;
1016                 int minstart = 100 * i + 10 * j;
1017                 int k = 6 * idx;
1018                 mm[k++] = minstart;
1019                 mm[k++] = minstart + 3;
1020                 mm[k++] = minstart + 4;
1021                 mm[k++] = minstart + 6;
1022                 mm[k++] = minstart + 7;
1023                 mm[k++] = minstart + 9;
1024             }
1025         }
1026         assert_minmax(subBlockInfo.NBlocks, Min, Max, MinMaxs, 0, 999, mm);
1027     }
1028 }
1029 
TEST(ADIOS2MinMaxs,ADIOS2MinMaxs_3D_24x24x48)1030 TEST(ADIOS2MinMaxs, ADIOS2MinMaxs_3D_24x24x48)
1031 {
1032     std::vector<int> data(27648);
1033     for (int i = 0; i < data.size(); ++i)
1034     {
1035         data[i] = i;
1036     }
1037     size_t blockSize;
1038     adios2::Dims count({24, 24, 48});
1039 
1040     adios2::Box<adios2::Dims> block;
1041     // int blockID;
1042 
1043     std::vector<int> MinMaxs;
1044     int Min, Max;
1045 
1046     {
1047         blockSize = 5000;
1048         printTestInfo(count, blockSize, __LINE__);
1049 
1050         struct adios2::helper::BlockDivisionInfo subBlockInfo =
1051             adios2::helper::DivideBlock(
1052                 count, blockSize,
1053                 adios2::helper::BlockDivisionMethod::Contiguous);
1054         printBlockDivisionInfo(subBlockInfo);
1055         ASSERT_EQ(subBlockInfo.NBlocks, 6);
1056         ASSERT_EQ(subBlockInfo.SubBlockSize, blockSize);
1057         ASSERT_EQ(subBlockInfo.Div.size(), 3);
1058         ASSERT_EQ(subBlockInfo.Div[0], 6);
1059         ASSERT_EQ(subBlockInfo.Div[1], 1);
1060         ASSERT_EQ(subBlockInfo.Div[2], 1);
1061         ASSERT_EQ(subBlockInfo.Rem.size(), 3);
1062         ASSERT_EQ(subBlockInfo.Rem[0], 0);
1063         ASSERT_EQ(subBlockInfo.Rem[1], 0);
1064         ASSERT_EQ(subBlockInfo.Rem[2], 0);
1065         ASSERT_EQ(subBlockInfo.ReverseDivProduct.size(), 3);
1066         ASSERT_EQ(subBlockInfo.ReverseDivProduct[0], 1);
1067         ASSERT_EQ(subBlockInfo.ReverseDivProduct[1], 1);
1068         ASSERT_EQ(subBlockInfo.ReverseDivProduct[2], 1);
1069 
1070         /*blockID = 0;
1071         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
1072         assert_block(block, blockID, {0, 0, 0}, {4, 24, 48});
1073 
1074         blockID = 1;
1075         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
1076         assert_block(block, blockID, {4, 0, 0}, {4, 24, 48});
1077 
1078         blockID = 5;
1079         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
1080         assert_block(block, blockID, {20, 0, 0}, {4, 24, 48});*/
1081 
1082         adios2::helper::GetMinMaxSubblocks(data.data(), count, subBlockInfo,
1083                                            MinMaxs, Min, Max, 1);
1084         assert_minmax(subBlockInfo.NBlocks, Min, Max, MinMaxs, 0, 27647,
1085                       {0, 4607, 4608, 9215, 9216, 13823, 13824, 18431, 18432,
1086                        23039, 23040, 27647});
1087     }
1088 }
1089 
TEST(ADIOS2MinMaxs,ADIOS2MinMaxs_4D_3x2x5x4)1090 TEST(ADIOS2MinMaxs, ADIOS2MinMaxs_4D_3x2x5x4)
1091 {
1092     std::vector<int> data(120);
1093     for (int i = 0; i < data.size(); ++i)
1094     {
1095         data[i] = i;
1096     }
1097     size_t blockSize;
1098     adios2::Dims count({3, 2, 5, 4});
1099 
1100     adios2::Box<adios2::Dims> block;
1101     // int blockID;
1102 
1103     std::vector<int> MinMaxs;
1104     int Min, Max;
1105 
1106     {
1107         blockSize = 6;
1108         printTestInfo(count, blockSize, __LINE__);
1109 
1110         struct adios2::helper::BlockDivisionInfo subBlockInfo =
1111             adios2::helper::DivideBlock(
1112                 count, blockSize,
1113                 adios2::helper::BlockDivisionMethod::Contiguous);
1114         printBlockDivisionInfo(subBlockInfo);
1115         ASSERT_EQ(subBlockInfo.NBlocks, 18);
1116         ASSERT_EQ(subBlockInfo.SubBlockSize, blockSize);
1117         ASSERT_EQ(subBlockInfo.Div.size(), 4);
1118         ASSERT_EQ(subBlockInfo.Div[0], 3);
1119         ASSERT_EQ(subBlockInfo.Div[1], 2);
1120         ASSERT_EQ(subBlockInfo.Div[2], 3);
1121         ASSERT_EQ(subBlockInfo.Div[3], 1);
1122         ASSERT_EQ(subBlockInfo.Rem.size(), 4);
1123         ASSERT_EQ(subBlockInfo.Rem[0], 0);
1124         ASSERT_EQ(subBlockInfo.Rem[1], 0);
1125         ASSERT_EQ(subBlockInfo.Rem[2], 2);
1126         ASSERT_EQ(subBlockInfo.Rem[3], 0);
1127         ASSERT_EQ(subBlockInfo.ReverseDivProduct.size(), 4);
1128         ASSERT_EQ(subBlockInfo.ReverseDivProduct[0], 6);
1129         ASSERT_EQ(subBlockInfo.ReverseDivProduct[1], 3);
1130         ASSERT_EQ(subBlockInfo.ReverseDivProduct[2], 1);
1131         ASSERT_EQ(subBlockInfo.ReverseDivProduct[3], 1);
1132 
1133         /*blockID = 0;
1134         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
1135         assert_block(block, blockID, {0, 0, 0, 0}, {1, 1, 2, 4});
1136 
1137         blockID = 1;
1138         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
1139         assert_block(block, blockID, {0, 0, 2, 0}, {1, 1, 2, 4});
1140 
1141         blockID = 2;
1142         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
1143         assert_block(block, blockID, {0, 0, 4, 0}, {1, 1, 1, 4});
1144 
1145         blockID = 3;
1146         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
1147         assert_block(block, blockID, {0, 1, 0, 0}, {1, 1, 2, 4});
1148 
1149         blockID = 4;
1150         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
1151         assert_block(block, blockID, {0, 1, 2, 0}, {1, 1, 2, 4});
1152 
1153         blockID = 5;
1154         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
1155         assert_block(block, blockID, {0, 1, 4, 0}, {1, 1, 1, 4});
1156 
1157         blockID = 6;
1158         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
1159         assert_block(block, blockID, {1, 0, 0, 0}, {1, 1, 2, 4});
1160 
1161         blockID = 17;
1162         block = adios2::helper::GetSubBlock(count, subBlockInfo, blockID);
1163         assert_block(block, blockID, {2, 1, 4, 0}, {1, 1, 1, 4});*/
1164 
1165         adios2::helper::GetMinMaxSubblocks(data.data(), count, subBlockInfo,
1166                                            MinMaxs, Min, Max, 1);
1167         assert_minmax(subBlockInfo.NBlocks, Min, Max, MinMaxs, 0, 119,
1168                       {0,  7,  8,  15, 16, 19, 20,  27,  28,  35,  36,  39,
1169                        40, 47, 48, 55, 56, 59, 60,  67,  68,  75,  76,  79,
1170                        80, 87, 88, 95, 96, 99, 100, 107, 108, 115, 116, 119});
1171     }
1172 }
1173 
main(int argc,char ** argv)1174 int main(int argc, char **argv)
1175 {
1176 
1177     int result;
1178     ::testing::InitGoogleTest(&argc, argv);
1179     result = RUN_ALL_TESTS();
1180 
1181     return result;
1182 }
1183