Belle II Software  release-05-01-25
minMaxCollector.cc
1 /**************************************************************************
2  * BASF2 (Belle Analysis Framework 2) *
3  * Copyright(C) 2014 - Belle II Collaboration *
4  * *
5  * Author: The Belle II Collaboration *
6  * Contributors: Jakob Lettenbichler (jakob.lettenbichler@oeaw.ac.at) *
7  * *
8  * This software is provided "as is" without any warranty. *
9  **************************************************************************/
10 
11 #include <gtest/gtest.h>
12 
13 #include <tracking/trackFindingVXD/sectorMapTools/MinMaxCollector.h>
14 
15 #include <TRandom.h>
16 // #include <tracking/spacePointCreation/SpacePoint.h>
17 // #include <tracking/trackFindingVXD/filterMap/fourHitVariables/DeltaPt.h>
18 // #include <tracking/trackFindingVXD/filterMap/fourHitVariables/DeltaDistCircleCenter.h>
19 // #include <tracking/trackFindingVXD/filterTools/SelectionVariableHelper.h>
20 //
21 // #include <tracking/trackFindingVXD/filterMap/filterFramework/Shortcuts.h>
22 //
23 // #include <vxd/geometry/SensorInfoBase.h>
24 //
25 // #include <math.h>
26 
27 
28 using namespace std;
29 using namespace Belle2;
30 
31 namespace VXDTFMinMaxCollectorTest {
32 
34  class MinMaxCollectorTest : public ::testing::Test {
35  protected:
36  };
37 
38 
40  TEST_F(MinMaxCollectorTest, CheckUserHandling)
41  {
42  // only requests for quantiles 0-0.5 are allowed, for quantile cut q, MinMaxCollector collects quantile-ranges 0 - q & (1-q) - 1.
43  EXPECT_ANY_THROW(MinMaxCollector<double>(0.55));
44  EXPECT_ANY_THROW(MinMaxCollector<double>(-0.1));
45  EXPECT_ANY_THROW(MinMaxCollector<double>(42.));
46 
47  double quantileCut = 0.025;
48  auto newCollector = MinMaxCollector<double>(0.025);
49 
50  // request for quantiles in empty container:
51  EXPECT_ANY_THROW(newCollector.getMinMax(0., 1.));
52 
53  for (unsigned i = 1 ; i < 501 ; i++) { // fill up to 500
54  newCollector.append(gRandom->Uniform(1.));
55  }
56 
57  EXPECT_ANY_THROW(newCollector.getMinMax(quantileCut + 0.1, 1.)); // first breaks, second is okay
58  EXPECT_ANY_THROW(newCollector.getMinMax(0.1, 1. + quantileCut)); // first is okay, second is not
59 
60  }
61 
62 
63 
65  TEST_F(MinMaxCollectorTest, SomeBasicFillingAndTesting)
66  {
67  auto newCollector = MinMaxCollector<double>();
68 
69 
70  EXPECT_EQ(0, newCollector.size());
71  EXPECT_EQ(0, newCollector.totalSize());
72  EXPECT_EQ(0, newCollector.sampleSize());
73  EXPECT_TRUE(newCollector.empty());
74 
75  B2INFO("add first entry");
76  newCollector.append(42.);
77  newCollector.print();
78 
79  EXPECT_EQ(1, newCollector.size());
80  EXPECT_EQ(2, newCollector.totalSize());
81  EXPECT_EQ(1, newCollector.sampleSize());
82  EXPECT_FALSE(newCollector.empty());
83 
84  EXPECT_EQ(42., newCollector.getMinMax(0.01, 0.99).first);
85  EXPECT_EQ(42., newCollector.getMinMax(0.01, 0.99).second);
86 
87  B2INFO("add 2nd entry");
88  newCollector.append(23.);
89  newCollector.print();
90 
91  EXPECT_EQ(2, newCollector.size());
92  EXPECT_EQ(4, newCollector.totalSize()); // did not grow, old value replaced...
93  EXPECT_EQ(2, newCollector.sampleSize());
94  EXPECT_EQ(23., newCollector.getMinMax(0.01, 0.99).first);
95  EXPECT_EQ(42., newCollector.getMinMax(0.01, 0.99).second);
96 
97  B2INFO("add 3rd entry");
98  newCollector.append(5.);
99  newCollector.print();
100 
101  EXPECT_EQ(3, newCollector.size());
102  EXPECT_EQ(6, newCollector.totalSize()); // did not grow, old value replaced...
103  EXPECT_EQ(3, newCollector.sampleSize());
104  EXPECT_EQ(5., newCollector.getMinMax(0.01, 0.99).first);
105  EXPECT_EQ(42., newCollector.getMinMax(0.01, 0.99).second);
106 
107  B2INFO("add 47 more entries (sorted add, now 50)");
108  for (int i = 1; i < 48; i++) {
109  newCollector.append(5. + 0.25 * double(i));
110  }
111  newCollector.print();
112 
113  EXPECT_EQ(9, newCollector.size());
114  EXPECT_EQ(18, newCollector.totalSize()); // did not grow, old value replaced...
115  EXPECT_EQ(50, newCollector.sampleSize());
116  EXPECT_EQ(5., newCollector.getMinMax(0.009, 0.991).first);
117  EXPECT_EQ(42., newCollector.getMinMax(0.009, 0.991).second);
118  EXPECT_EQ(5.25, newCollector.getMinMax(0.02, 0.98).first);
119  EXPECT_EQ(23., newCollector.getMinMax(0.02, 0.98).second);
120  EXPECT_NE(16.75, newCollector.getMinMax(0.02, 0.98).second);
121 
122  B2INFO("add 50 more entries (sorted add, now 100)");
123  for (int i = 1; i < 51; i++) {
124  newCollector.append(23. + 0.25 * double(i));
125  }
126  B2INFO("add 150 more entries (sorted add, now 250)");
127  for (int i = 1; i < 151; i++) {
128  newCollector.append(3. + 0.3 * double(i));
129  }
130  newCollector.print(true);
131  newCollector.print();
132 
133  EXPECT_EQ(10, newCollector.size());
134  EXPECT_EQ(unsigned(newCollector.size() * 2), newCollector.totalSize());
135  EXPECT_EQ(250, newCollector.sampleSize());
136  EXPECT_EQ(3.3, newCollector.getMinMax(0., 1.).first);
137  // worst case: through sorted adding, some of the lower quantiles are lost
138  EXPECT_EQ(3.9, newCollector.getMinMax(0.009, 0.99).first);
139  EXPECT_NE(3.9, newCollector.getMinMax(0.01, 0.99).first);
140  EXPECT_NE(4.5, newCollector.getMinMax(0.02, 0.98).first);
141  EXPECT_EQ(48., newCollector.getMinMax(0., 1.).second);
142  EXPECT_EQ(47.4, newCollector.getMinMax(0.01, 0.991).second);
143  EXPECT_EQ(46.5, newCollector.getMinMax(0.02, 0.98).second);
144  }
145 
146 
147 
149  TEST_F(MinMaxCollectorTest, ComparisonWithClassicApproach)
150  {
151  auto newCollector = MinMaxCollector<double>(0.03);
152 
153  auto vectorCollector = std::vector<double>();
154  unsigned vecSize = vectorCollector.size();
155 
157  auto getIndex = [&](double quantile) -> unsigned int { return (double(vecSize - 1) * quantile + 0.5); };
158 
159 
160  EXPECT_EQ(0, newCollector.size());
161  EXPECT_EQ(0, newCollector.totalSize());
162  EXPECT_EQ(0, newCollector.sampleSize());
163  EXPECT_TRUE(newCollector.empty());
164 
165 
166  for (unsigned i = 1 ; i < 51 ; i++) { // fill up to 50
167  double val = gRandom->Uniform(1.);
168  newCollector.append(val);
169  vectorCollector.push_back(val);
170  }
171 
172  newCollector.print();
173 
174  std::sort(vectorCollector.begin(), vectorCollector.end());
175  vecSize = vectorCollector.size();
176 
177  EXPECT_EQ(vectorCollector.size(), newCollector.sampleSize());
178  EXPECT_EQ(vectorCollector.front(), newCollector.getMinMax(0., 1.).first);
179  EXPECT_EQ(vectorCollector.back(), newCollector.getMinMax(0., 1.).second);
180  EXPECT_EQ(vectorCollector.at(1), newCollector.getMinMax(0.011, 0.989).first);
181  EXPECT_EQ(vectorCollector.at(vecSize - 2), newCollector.getMinMax(0.011, 0.989).second);
182 
183 
184 
185  for (unsigned i = 1 ; i < 151 ; i++) { // fill up to 200
186  double val = gRandom->Uniform(1.);
187  newCollector.append(val);
188  vectorCollector.push_back(val);
189  }
190 
191  newCollector.print();
192 
193  std::sort(vectorCollector.begin(), vectorCollector.end());
194  vecSize = vectorCollector.size();
195 
196  EXPECT_EQ(vectorCollector.size(), newCollector.sampleSize());
197  EXPECT_EQ(vectorCollector.front(), newCollector.getMinMax(0., 1.).first);
198  EXPECT_EQ(vectorCollector.back(), newCollector.getMinMax(0., 1.).second);
199  EXPECT_EQ(vectorCollector.at(2), newCollector.getMinMax(0.011, 0.989).first);
200  EXPECT_EQ(vectorCollector.at(vecSize - 3), newCollector.getMinMax(0.011, 0.989).second);
201  EXPECT_EQ(vectorCollector.at(4), newCollector.getMinMax(0.022, 0.978).first);
202  EXPECT_EQ(vectorCollector.at(vecSize - 5), newCollector.getMinMax(0.022, 0.978).second);
203 
204 
205 
206  for (unsigned i = 1 ; i < 801 ; i++) { // fill up to 1000
207  double val = gRandom->Uniform(1.);
208  newCollector.append(val);
209  vectorCollector.push_back(val);
210  }
211 
212  newCollector.print(true);
213  newCollector.print();
214 
215  std::sort(vectorCollector.begin(), vectorCollector.end());
216  vecSize = vectorCollector.size();
217 
218  EXPECT_EQ(vectorCollector.size(), newCollector.sampleSize());
219  EXPECT_EQ(vectorCollector.front(), newCollector.getMinMax(0., 1.).first);
220  EXPECT_EQ(vectorCollector.back(), newCollector.getMinMax(0., 1.).second);
221  EXPECT_EQ(vectorCollector.at(getIndex(0.01)), newCollector.getMinMax(0.01, 0.99).first);
222  EXPECT_EQ(vectorCollector.at(getIndex(0.99)), newCollector.getMinMax(0.01, 0.99).second);
223  EXPECT_NEAR(vectorCollector.at(getIndex(0.022)), newCollector.getMinMax(0.022, 0.978).first,
224  0.001); // requested quantile is near the threshold, therefore no exact results quaranteed
225  EXPECT_EQ(vectorCollector.at(getIndex(0.978)), newCollector.getMinMax(0.022, 0.978).second);
226 
227 
228 
229  for (unsigned i = 1 ; i < 9001 ; i++) { // fill up to 10000
230  double val = gRandom->Uniform(1.);
231  newCollector.append(val);
232  vectorCollector.push_back(val);
233  }
234 
235  newCollector.print();
236 
237  std::sort(vectorCollector.begin(), vectorCollector.end());
238  vecSize = vectorCollector.size();
239 
240  EXPECT_EQ(vectorCollector.size(), newCollector.sampleSize());
241  EXPECT_EQ(vectorCollector.front(), newCollector.getMinMax(0., 1.).first);
242  EXPECT_EQ(vectorCollector.back(), newCollector.getMinMax(0., 1.).second);
243  EXPECT_EQ(vectorCollector.at(getIndex(0.01)), newCollector.getMinMax(0.01, 0.99).first);
244  EXPECT_EQ(vectorCollector.at(getIndex(0.99)), newCollector.getMinMax(0.01, 0.99).second);
245  EXPECT_NEAR(vectorCollector.at(getIndex(0.022)), newCollector.getMinMax(0.022, 0.978).first, 0.001);
246  EXPECT_EQ(vectorCollector.at(getIndex(0.978)), newCollector.getMinMax(0.022, 0.978).second);
247 
248 
249 
250  // starting now a second collector to be merged afterwards:
251  auto secondCollector = MinMaxCollector<double>();
252  for (unsigned i = 1 ; i < 10001 ; i++) { // fill up to 10000
253  double val = gRandom->Uniform(1.);
254  secondCollector.append(val);
255  vectorCollector.push_back(val);
256  }
257  newCollector.merge(secondCollector);
258 
259  std::sort(vectorCollector.begin(), vectorCollector.end());
260  vecSize = vectorCollector.size();
261 
262  EXPECT_EQ(vectorCollector.size(), newCollector.sampleSize());
263  EXPECT_EQ(vectorCollector.front(), newCollector.getMinMax(0., 1.).first);
264  EXPECT_EQ(vectorCollector.back(), newCollector.getMinMax(0., 1.).second);
265  EXPECT_EQ(vectorCollector.at(getIndex(0.01)), newCollector.getMinMax(0.01, 0.99).first);
266  EXPECT_EQ(vectorCollector.at(getIndex(0.99)), newCollector.getMinMax(0.01, 0.99).second);
267  EXPECT_EQ(vectorCollector.at(getIndex(0.022)), newCollector.getMinMax(0.022, 0.978).first);
268  EXPECT_NEAR(vectorCollector.at(getIndex(0.978)), newCollector.getMinMax(0.022, 0.978).second, 0.0005);
269 
270 
271 
272  for (unsigned i = 1 ; i < 30001 ; i++) { // fill up to 50,000
273  double val = gRandom->Uniform(1.);
274  newCollector.append(val);
275  vectorCollector.push_back(val);
276  }
277 
278  newCollector.print();
279 
280  std::sort(vectorCollector.begin(), vectorCollector.end());
281  vecSize = vectorCollector.size();
282 
283  EXPECT_EQ(vectorCollector.size(), newCollector.sampleSize());
284  EXPECT_EQ(vectorCollector.front(), newCollector.getMinMax(0., 1.).first);
285  EXPECT_EQ(vectorCollector.back(), newCollector.getMinMax(0., 1.).second);
286  EXPECT_EQ(vectorCollector.at(getIndex(0.01)), newCollector.getMinMax(0.01, 0.99).first);
287  EXPECT_EQ(vectorCollector.at(getIndex(0.99)), newCollector.getMinMax(0.01, 0.99).second);
288  EXPECT_EQ(vectorCollector.at(getIndex(0.022)), newCollector.getMinMax(0.022, 0.978).first);
289  EXPECT_NEAR(vectorCollector.at(getIndex(0.978)), newCollector.getMinMax(0.022, 0.978).second, 0.0001);
290  }
291 }
292 
Belle2::MinMaxCollector< double >
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:19
Belle2::TEST_F
TEST_F(GlobalLabelTest, LargeNumberOfTimeDependentParameters)
Test large number of time-dep params for registration and retrieval.
Definition: globalLabel.cc:65
VXDTFMinMaxCollectorTest::MinMaxCollectorTest
Test class for these new and shiny two-hit-filters.
Definition: minMaxCollector.cc:34