Belle II Software development
spacePointTrackCand.cc
1/**************************************************************************
2 * basf2 (Belle II Analysis Software Framework) *
3 * Author: The Belle II Collaboration *
4 * *
5 * See git log for contributors and copyright holders. *
6 * This file is licensed under LGPL-3.0, see LICENSE.md. *
7 **************************************************************************/
8
9#include <framework/gearbox/Const.h>
10
11// google test framework
12#include <gtest/gtest.h>
13
14// class to be tested
15#include <tracking/spacePointCreation/SpacePointTrackCand.h>
16
17// stuff needed for setting up the tests
18
19using namespace std;
20
21namespace Belle2 {
30 class SpacePointTrackCandTest : public ::testing::Test {
31 public:
33 VXD::SensorInfoBase createSensorInfo(VxdID aVxdID, double width = 1., double length = 1., double width2 = -1.)
34 {
35 // (SensorType type, VxdID id, double width, double length, double thickness, int uCells, int vCells, double width2=-1, double splitLength=-1, int vCells2=0)
36 VXD::SensorInfoBase sensorInfoBase(VXD::SensorInfoBase::PXD, aVxdID, width, length, 0.3, 2, 4, width2);
37
38 TGeoRotation r1;
39 r1.SetAngles(45, 20, 30); // rotation defined by Euler angles
40 TGeoTranslation t1(-10, 10, 1);
41 TGeoCombiTrans c1(t1, r1);
42 TGeoHMatrix transform = c1;
43 sensorInfoBase.setTransformation(transform);
44
45 return sensorInfoBase;
46 }
47 protected:
48 };
49
53 TEST_F(SpacePointTrackCandTest, testConstructorFromVector)
54 {
55 // set up some SpacePoints and group them to a vector
56 VxdID aVxdID = VxdID(1, 1, 1);
57 VXD::SensorInfoBase aSensorInfoBase = createSensorInfo(aVxdID, 2.3, 4.2);
58 PXDCluster aCluster = PXDCluster(aVxdID, 0., 0., 0.1, 0.1, 0, 0, 1, 1, 1, 1, 1, 1);
59 const SpacePoint aPXDSpacePoint = SpacePoint(&aCluster, &aSensorInfoBase);
60
61 VxdID anotherVxdID = VxdID(3, 3, 3);
62 VXD::SensorInfoBase anotherSensorInfoBase = createSensorInfo(anotherVxdID, 2.3, 4.2);
63 SVDCluster aUCluster = SVDCluster(anotherVxdID, true, -0.23, 0.1, 0.01, 0.001, 1, 1, 1, 1.0);
64 SVDCluster aVCluster = SVDCluster(anotherVxdID, false, 0.42, 0.1, 0.01, 0.001, 1, 1, 1, 1.0);
65 std::vector<const SVDCluster*> a2HitCluster = { &aUCluster, &aVCluster };
66 const SpacePoint aSVDSpacePoint = SpacePoint(a2HitCluster, &anotherSensorInfoBase);
67
68 SVDCluster anotherUCluster = SVDCluster(anotherVxdID, true, 0.23, 0.1, 0.01, 0.001, 1, 1, 1, 1.0);
69 std::vector<const SVDCluster*> a1HitCluster = { &anotherUCluster };
70 const SpacePoint anotherSVDSpacePoint = SpacePoint(a1HitCluster, &anotherSensorInfoBase);
71
72 const std::vector<const Belle2::SpacePoint*> aSpacePointVec = { &aPXDSpacePoint, &aSVDSpacePoint, &anotherSVDSpacePoint };
73
74
75 // construct SpacePointTrackCand with (more or less arbitrary) values for pdg code, charge and MC-TrackID
76 SpacePointTrackCand aSpacePointTC = SpacePointTrackCand(aSpacePointVec, 11, -1, 23);
77
78 // do some checks
79 // check if all SpacePoints are actually in the TrackCand
80 EXPECT_EQ(aSpacePointTC.getNHits(), aSpacePointVec.size());
81 // check pdg, charge, etc...
82 EXPECT_EQ(aSpacePointTC.getPdgCode(), Const::electron.getPDGCode());
83 EXPECT_DOUBLE_EQ(aSpacePointTC.getChargeSeed(), -1);
84 EXPECT_EQ(aSpacePointTC.getMcTrackID(), 23);
85
86 // get SpacePoints and compare them with the original vector
87 const std::vector<const SpacePoint*> returnSPVector = aSpacePointTC.getHits();
88 for (unsigned int i = 0; i < aSpacePointTC.getNHits(); i++) {
89 EXPECT_TRUE(returnSPVector[i] == aSpacePointVec[i]);
90 }
91 }
92
96 TEST_F(SpacePointTrackCandTest, testEqualityOperator)
97 {
98 // set up some set up some space points and add them to SpacePointTrackCands
99 // many parts copied from spacePoint.cc (tracking/tests/)
100
101 VxdID aVxdID = VxdID(1, 1, 1);
102 VXD::SensorInfoBase sensorInfoBase = createSensorInfo(aVxdID, 2.3, 4.2);
103 PXDCluster aCluster = PXDCluster(aVxdID, 0., 0., 0.1, 0.1, 0, 0, 1, 1, 1, 1, 1, 1);
104 const SpacePoint aPXDSpacePoint = SpacePoint(&aCluster, &sensorInfoBase);
105
106 VxdID anotherVxdID = VxdID(3, 3, 3);
107 VXD::SensorInfoBase anotherSensorInfoBase = createSensorInfo(anotherVxdID, 2.3, 4.2);
108 SVDCluster aUCluster = SVDCluster(anotherVxdID, true, -0.23, 0.1, 0.01, 0.001, 1, 1, 1, 1.0);
109 SVDCluster aVCluster = SVDCluster(anotherVxdID, false, 0.42, 0.1, 0.01, 0.001, 1, 1, 1, 1.0);
110 std::vector<const SVDCluster*> a2HitCluster = { &aUCluster, &aVCluster };
111 const SpacePoint aSVDSpacePoint = SpacePoint(a2HitCluster, &anotherSensorInfoBase);
112
113 SVDCluster anotherUCluster = SVDCluster(anotherVxdID, true, 0.23, 0.1, 0.01, 0.001, 1, 1, 1, 1.0);
114 std::vector<const SVDCluster*> a1HitCluster = { &anotherUCluster };
115 const SpacePoint anotherSVDSpacePoint = SpacePoint(a1HitCluster, &anotherSensorInfoBase);
116
117 const std::vector<const Belle2::SpacePoint*> aSpacePointVec = { &aPXDSpacePoint, &aSVDSpacePoint };
118 const std::vector<const Belle2::SpacePoint*> sameSpacePointVec = { &aPXDSpacePoint, &aSVDSpacePoint };
119 const std::vector<const Belle2::SpacePoint*> anotherSpacePointVec = { &aPXDSpacePoint, &anotherSVDSpacePoint };
120
121 // set up two SpacePointTrackCands from the SpacePoint* vectors above
122 Belle2::SpacePointTrackCand aSpacePointTC = SpacePointTrackCand(aSpacePointVec, 1);
123 Belle2::SpacePointTrackCand anotherSpacePointTC = SpacePointTrackCand(sameSpacePointVec);
124
125 // getting undefined reference here!
126 EXPECT_TRUE(aSpacePointTC == anotherSpacePointTC);
127
128 // change pdg code and compare again (should not have any influence)
129 anotherSpacePointTC.setPdgCode(-Const::electron.getPDGCode());
130 EXPECT_TRUE(aSpacePointTC == anotherSpacePointTC);
131
132 // add a space point with arbitrary sorting parameter and compare again, should now give false
133 anotherSpacePointTC.addSpacePoint(&anotherSVDSpacePoint, 1.0);
134
135 EXPECT_FALSE(aSpacePointTC == anotherSpacePointTC);
136
137 // create another TC with different SVD SpacePoint and compare again with the previously created TCs.
138 Belle2::SpacePointTrackCand changedSVDSpacePointTC = SpacePointTrackCand(anotherSpacePointVec, 2, 3, 4);
139
140 EXPECT_FALSE(aSpacePointTC == changedSVDSpacePointTC);
141 EXPECT_FALSE(changedSVDSpacePointTC == anotherSpacePointTC);
142
143 // create an empty TC and add SpacePoints by hand and compare again with the other TCs
144 Belle2::SpacePointTrackCand newSpacePointTC;
145 newSpacePointTC.addSpacePoint(&aPXDSpacePoint, 1.0);
146 newSpacePointTC.addSpacePoint(&aSVDSpacePoint, 1.1);
147
148 EXPECT_TRUE(newSpacePointTC == aSpacePointTC);
149
150 newSpacePointTC.addSpacePoint(&anotherSVDSpacePoint, 1.2);
151
152 EXPECT_TRUE(newSpacePointTC == anotherSpacePointTC);
153
154 }
155
159 TEST_F(SpacePointTrackCandTest, testSetPdgCode)
160 {
161 SpacePointTrackCand aSpacePointTC;
162
163 // electron
164 aSpacePointTC.setPdgCode(Const::electron.getPDGCode());
165 EXPECT_DOUBLE_EQ(aSpacePointTC.getChargeSeed(), -1);
166 // positron
167 aSpacePointTC.setPdgCode(-Const::electron.getPDGCode());
168 EXPECT_DOUBLE_EQ(aSpacePointTC.getChargeSeed(), 1);
169
170 // B+ Meson
171 aSpacePointTC.setPdgCode(521);
172 EXPECT_DOUBLE_EQ(aSpacePointTC.getChargeSeed(), 1);
173 }
174
178 TEST_F(SpacePointTrackCandTest, testGetHitsInRange)
179 {
180 SpacePointTrackCand fullTrackCand;
181
182 // set up some SpacePoints and add them to a SpacePointTrackCand
183 VxdID aVxdID1 = VxdID(1, 1, 1);
184 VXD::SensorInfoBase sensorInfoBase1 = createSensorInfo(aVxdID1, 2.3, 4.2);
185 PXDCluster aCluster = PXDCluster(aVxdID1, 0., 0., 0.1, 0.1, 0, 0, 1, 1, 1, 1, 1, 1);
186 const SpacePoint aPXDSpacePoint = SpacePoint(&aCluster, &sensorInfoBase1);
187 fullTrackCand.addSpacePoint(&aPXDSpacePoint, 1.23); // add a SpacePoint with an arbitrary sorting parameter
188
189 VxdID aVxdID2 = VxdID(2, 2, 2);
190 VXD::SensorInfoBase sensorInfoBase2 = createSensorInfo(aVxdID2, 2.3, 4.2);
191 SVDCluster aUCluster = SVDCluster(aVxdID2, true, -0.23, 0.1, 0.01, 0.001, 1, 1, 1, 1.0);
192 SVDCluster aVCluster = SVDCluster(aVxdID2, false, 0.42, 0.1, 0.01, 0.001, 1, 1, 1, 1.0);
193 std::vector<const SVDCluster*> UVClusterVec1 = { &aUCluster, &aVCluster };
194 std::vector<const SVDCluster*> VClusterVec = { &aVCluster };
195 std::vector<const SVDCluster*> UClusterVec = { &aUCluster };
196 const SpacePoint SVDSpacePoint1 = SpacePoint(UVClusterVec1, &sensorInfoBase2);
197 const SpacePoint SVDSpacePoint2 = SpacePoint(VClusterVec, &sensorInfoBase2);
198 const SpacePoint SVDSpacePoint3 = SpacePoint(UClusterVec, &sensorInfoBase2);
199 fullTrackCand.addSpacePoint(&SVDSpacePoint1, 2.34);
200 fullTrackCand.addSpacePoint(&SVDSpacePoint2, 3.45);
201 fullTrackCand.addSpacePoint(&SVDSpacePoint3, 4.56);
202
203 VxdID aVxdId3 = VxdID(3, 3, 3);
204 VXD::SensorInfoBase sensorInfoBase3 = createSensorInfo(aVxdId3, 2.3, 4.2);
205 SVDCluster aUCluster2 = SVDCluster(aVxdId3, true, -0.23, 0.1, 0.01, 0.001, 1, 1, 1, 1.0);
206 SVDCluster aVCluster2 = SVDCluster(aVxdId3, false, 0.42, 0.1, 0.01, 0.001, 1, 1, 1, 1.0);
207 std::vector<const SVDCluster*> UVClusterVec2 = { &aUCluster2, &aVCluster2 };
208 std::vector<const SVDCluster*> VClusterVec2 = { &aVCluster2 };
209 std::vector<const SVDCluster*> UClusterVec2 = { &aUCluster2 };
210 const SpacePoint SVDSpacePoint4 = SpacePoint(UVClusterVec2, &sensorInfoBase3);
211 const SpacePoint SVDSpacePoint5 = SpacePoint(VClusterVec2, &sensorInfoBase3);
212 const SpacePoint SVDSpacePoint6 = SpacePoint(UClusterVec2, &sensorInfoBase3);
213 fullTrackCand.addSpacePoint(&SVDSpacePoint4, 5.67);
214 fullTrackCand.addSpacePoint(&SVDSpacePoint5, 6.78);
215 fullTrackCand.addSpacePoint(&SVDSpacePoint6, 7.89);
216
217 // set up some 'shorter' SpacePointTrackCands
218 SpacePointTrackCand shortTC1;
219 shortTC1.addSpacePoint(&aPXDSpacePoint, 1.23);
220 shortTC1.addSpacePoint(&SVDSpacePoint1, 2.34);
221 shortTC1.addSpacePoint(&SVDSpacePoint2, 3.45);
222
223 SpacePointTrackCand shortTC2;
224 shortTC2.addSpacePoint(&SVDSpacePoint2, 3.45);
225 shortTC2.addSpacePoint(&SVDSpacePoint3, 4.56);
226 shortTC2.addSpacePoint(&SVDSpacePoint4, 5.67);
227 shortTC2.addSpacePoint(&SVDSpacePoint5, 6.78);
228
229 SpacePointTrackCand subTrackCand1 = SpacePointTrackCand(fullTrackCand.getHitsInRange(0, 3));
230 EXPECT_TRUE(subTrackCand1 == shortTC1);
231 std::vector<double> sortParams1 = { 1.23, 2.34, 3.45 };
232 std::vector<double> sortParamsTC1 = fullTrackCand.getSortingParametersInRange(0, 3);
233 EXPECT_EQ(sortParams1.size(), sortParamsTC1.size());
234 for (unsigned int i = 0; i < sortParamsTC1.size(); ++i) { EXPECT_DOUBLE_EQ(sortParams1.at(i), sortParamsTC1.at(i)); }
235
236 SpacePointTrackCand subTrackCand2 = SpacePointTrackCand(fullTrackCand.getHitsInRange(2, 6));
237 EXPECT_TRUE(subTrackCand2 == shortTC2);
238 std::vector<double> sortParams2 = { 3.45, 4.56, 5.67, 6.78 };
239 std::vector<double> sortParamsTC2 = fullTrackCand.getSortingParametersInRange(2, 6);
240 EXPECT_EQ(sortParams2.size(), sortParamsTC2.size());
241 for (unsigned int i = 0; i < sortParamsTC2.size(); ++i) { EXPECT_DOUBLE_EQ(sortParams2.at(i), sortParamsTC2.at(i)); }
242
243 // test throwing of exceptions
244 unsigned int nHits = fullTrackCand.getNHits();
245 ASSERT_THROW(fullTrackCand.getHitsInRange(0, nHits + 1),
246 SpacePointTrackCand::SPTCIndexOutOfBounds); // throw due to too high final index
247 ASSERT_NO_THROW(fullTrackCand.getHitsInRange(nHits - 2, nHits));
248 ASSERT_THROW(fullTrackCand.getHitsInRange(-1, 3),
249 SpacePointTrackCand::SPTCIndexOutOfBounds); // throw due to negative starting index
250 ASSERT_THROW(fullTrackCand.getHitsInRange(0, 10), SpacePointTrackCand::SPTCIndexOutOfBounds); // throw due to too high final index
251 ASSERT_THROW(fullTrackCand.getHitsInRange(10, 0),
252 SpacePointTrackCand::SPTCIndexOutOfBounds); // throw due to too high starting index
253 ASSERT_THROW(fullTrackCand.getHitsInRange(2, -1), SpacePointTrackCand::SPTCIndexOutOfBounds); // throw due to too low final index
254 ASSERT_THROW(fullTrackCand.getSortingParametersInRange(-1, 2),
255 SpacePointTrackCand::SPTCIndexOutOfBounds); // throw due to negative starting index
256 ASSERT_THROW(fullTrackCand.getSortingParametersInRange(0, nHits + 1),
257 SpacePointTrackCand::SPTCIndexOutOfBounds); // throw due to too high final index
258 ASSERT_THROW(fullTrackCand.getSortingParametersInRange(12, 3),
259 SpacePointTrackCand::SPTCIndexOutOfBounds); // throw due to too high starting index
260 ASSERT_THROW(fullTrackCand.getSortingParametersInRange(2, -2),
261 SpacePointTrackCand::SPTCIndexOutOfBounds); // throw due to too low final index
262 ASSERT_NO_THROW(fullTrackCand.getSortingParametersInRange(0, nHits));
263 }
264
268 TEST_F(SpacePointTrackCandTest, testRefereeStatus)
269 {
270 SpacePointTrackCand trackCand; // default constructor -> should initialize the referee status to c_initialState
271
272 // currently c_isActive is the initialState:
273 EXPECT_EQ(trackCand.getRefereeStatus(), SpacePointTrackCand::c_isActive);
274 EXPECT_EQ(SpacePointTrackCand::c_initialState, SpacePointTrackCand::c_isActive);
275
276 unsigned short int initialStatus = trackCand.getRefereeStatus();
277 EXPECT_EQ(initialStatus, SpacePointTrackCand::c_initialState);
278
279 // design an arbitrary status and set it, then test if the returned status is the set status
280 unsigned short int newStatus = 0;
281 newStatus += SpacePointTrackCand::c_checkedByReferee;
282 newStatus += SpacePointTrackCand::c_checkedTrueHits;
283 trackCand.setRefereeStatus(newStatus);
284 EXPECT_EQ(trackCand.getRefereeStatus(), newStatus);
285
286 // clear the status and test if its 0
287 trackCand.clearRefereeStatus();
288 EXPECT_EQ(trackCand.getRefereeStatus(), 0);
289
290 // reset the status and test if it's the initial state
291 trackCand.resetRefereeStatus();
292 EXPECT_EQ(trackCand.getRefereeStatus(), SpacePointTrackCand::c_initialState);
293
294
295 trackCand.clearRefereeStatus(); // enforce empty refereeStatus
296 // add several statusses one by one and test if the overall status is as expected (once with 'overall status' and once with status one by one)
297 trackCand.addRefereeStatus(SpacePointTrackCand::c_checkedClean);
298 EXPECT_TRUE(trackCand.hasRefereeStatus(SpacePointTrackCand::c_checkedClean));
299 trackCand.addRefereeStatus(SpacePointTrackCand::c_hitsOnSameSensor);
300 EXPECT_TRUE(trackCand.hasRefereeStatus(SpacePointTrackCand::c_hitsOnSameSensor));
301 EXPECT_FALSE(trackCand.hasRefereeStatus(SpacePointTrackCand::c_hitsLowDistance));
302
303 trackCand.addRefereeStatus(SpacePointTrackCand::c_checkedByReferee);
304 unsigned short int expectedStatus = SpacePointTrackCand::c_checkedClean + SpacePointTrackCand::c_hitsOnSameSensor +
305 SpacePointTrackCand::c_checkedByReferee;
306 EXPECT_EQ(trackCand.getRefereeStatus(), expectedStatus);
307
308
309 // remove one status and test if it actuall gets removed
310 trackCand.removeRefereeStatus(SpacePointTrackCand::c_checkedClean);
311 expectedStatus -= SpacePointTrackCand::c_checkedClean;
312 EXPECT_EQ(trackCand.getRefereeStatus(), expectedStatus);
313 EXPECT_FALSE(trackCand.hasRefereeStatus(SpacePointTrackCand::c_checkedClean));
314 trackCand.removeRefereeStatus(SpacePointTrackCand::c_checkedClean); // remove again and check if nothing changes
315 EXPECT_EQ(trackCand.getRefereeStatus(), expectedStatus);
316
317 EXPECT_TRUE(trackCand.hasRefereeStatus(expectedStatus));
318
319 // test if the status that remains is still set
320 EXPECT_TRUE(trackCand.hasRefereeStatus(SpacePointTrackCand::c_hitsOnSameSensor));
321 EXPECT_TRUE(trackCand.hasHitsOnSameSensor()); // echeck the wrapper function
322
323
324 // check if adding of the same status twice works
325 trackCand.clearRefereeStatus();
326 trackCand.addRefereeStatus(SpacePointTrackCand::c_checkedSameSensors);
327 trackCand.addRefereeStatus(SpacePointTrackCand::c_checkedSameSensors);
328 EXPECT_TRUE(trackCand.hasRefereeStatus(SpacePointTrackCand::c_checkedSameSensors));
329 EXPECT_TRUE(trackCand.checkedSameSensors());
330
331 trackCand.addRefereeStatus(SpacePointTrackCand::c_curlingTrack);
332 EXPECT_TRUE(trackCand.isCurling());
333
334
335 trackCand.clearRefereeStatus();
336 // test that at least n bits are present for storing stuff in the m_refereeStatus (update this test if you add a new flag to the RefereeStatusBit)
337 // WARNING: hardcoded -> make sure to keep this thing up to date!
338 int n = 13;
339 int maxUsedStatus = pow(2, n);
340 trackCand.addRefereeStatus(maxUsedStatus);
341 EXPECT_TRUE(trackCand.hasRefereeStatus(maxUsedStatus));
342
343 int maxN = 15; // unsigned short int has 2 bytes (-> 16 bits) to store information
344 int maxPossibleStatus = pow(2, maxN); // maximum possible status to store
345 trackCand.addRefereeStatus(maxPossibleStatus);
346 EXPECT_TRUE(trackCand.hasRefereeStatus(maxPossibleStatus));
347
348 int impossibleStatus = maxPossibleStatus * 2; // create an integer that is too big to be stored in a unsigned short integer
349 trackCand.clearRefereeStatus();
350 trackCand.setRefereeStatus(impossibleStatus); // this should lead to an overflow in SpacePointTrackCand::m_refereeStatus
351 EXPECT_NE(trackCand.getRefereeStatus(), impossibleStatus); // -> overflow leads this test to fail
352
353 trackCand.clearRefereeStatus();
354 int wrongStatus = 7; // set a wrong status, that causes some of the checks to be true although they shouldn't
355 trackCand.addRefereeStatus(wrongStatus);
356 EXPECT_TRUE(trackCand.hasRefereeStatus(1));
357 EXPECT_TRUE(trackCand.hasRefereeStatus(2));
358 EXPECT_TRUE(trackCand.hasRefereeStatus(4));
359 wrongStatus = 15;
360 trackCand.addRefereeStatus(wrongStatus);
361 EXPECT_TRUE(trackCand.hasRefereeStatus(8));
362 }
363
367 TEST_F(SpacePointTrackCandTest, testRemoveSpacePoints)
368 {
369 // set up SpacePointTrackCand
370 SpacePointTrackCand fullTrackCand;
371
372 // set up some SpacePoints and add them to a SpacePointTrackCand
373 VxdID aVxdID1 = VxdID(1, 1, 1);
374 VXD::SensorInfoBase sensorInfoBase1 = createSensorInfo(aVxdID1, 2.3, 4.2);
375 PXDCluster aCluster = PXDCluster(aVxdID1, 0., 0., 0.1, 0.1, 0, 0, 1, 1, 1, 1, 1, 1);
376 const SpacePoint aPXDSpacePoint = SpacePoint(&aCluster, &sensorInfoBase1);
377 fullTrackCand.addSpacePoint(&aPXDSpacePoint, 1.23); // add a SpacePoint with an arbitrary sorting parameter
378
379 VxdID aVxdID2 = VxdID(2, 2, 2);
380 VXD::SensorInfoBase sensorInfoBase2 = createSensorInfo(aVxdID2, 2.3, 4.2);
381 SVDCluster aUCluster = SVDCluster(aVxdID2, true, -0.23, 0.1, 0.01, 0.001, 1, 1, 1, 1.0);
382 SVDCluster aVCluster = SVDCluster(aVxdID2, false, 0.42, 0.1, 0.01, 0.001, 1, 1, 1, 1.0);
383 std::vector<const SVDCluster*> UVClusterVec1 = { &aUCluster, &aVCluster };
384 std::vector<const SVDCluster*> VClusterVec = { &aVCluster };
385 std::vector<const SVDCluster*> UClusterVec = { &aUCluster };
386 const SpacePoint SVDSpacePoint1 = SpacePoint(UVClusterVec1, &sensorInfoBase2);
387 const SpacePoint SVDSpacePoint2 = SpacePoint(VClusterVec, &sensorInfoBase2);
388 const SpacePoint SVDSpacePoint3 = SpacePoint(UClusterVec, &sensorInfoBase2);
389 fullTrackCand.addSpacePoint(&SVDSpacePoint1, 2.34);
390 fullTrackCand.addSpacePoint(&SVDSpacePoint2, 3.45);
391 fullTrackCand.addSpacePoint(&SVDSpacePoint3, 4.56);
392
393 // set up a second TC, but ommit one SpacePoint
394 SpacePointTrackCand expectedTC;
395 expectedTC.addSpacePoint(&aPXDSpacePoint, 1.23);
396 expectedTC.addSpacePoint(&SVDSpacePoint2, 3.45);
397 expectedTC.addSpacePoint(&SVDSpacePoint3, 4.56);
398
399 // remove SpcePoint from first TrackCand amd compare it with the expected TrackCand
400 fullTrackCand.removeSpacePoint(1);
401 EXPECT_TRUE(expectedTC == fullTrackCand);
402
403 std::vector<double> expectedSortParams = { 1.23, 3.45, 4.56 };
404 std::vector<double> sortParams = fullTrackCand.getSortingParameters();
405 EXPECT_EQ(expectedSortParams.size(), sortParams.size());
406 for (unsigned int i = 0; i < sortParams.size(); ++i) { EXPECT_DOUBLE_EQ(sortParams.at(i), expectedSortParams.at(i)); }
407
408 // try to remove a SpacePoint that is out of bounds
409 ASSERT_THROW(fullTrackCand.removeSpacePoint(fullTrackCand.getNHits()), SpacePointTrackCand::SPTCIndexOutOfBounds);
410 }
411
415 TEST_F(SpacePointTrackCandTest, testGetSortedHits)
416 {
417 // set up some SpacePoints and add them to a SpacePointTrackCand
418 VxdID aVxdID1 = VxdID(1, 1, 1);
419 VXD::SensorInfoBase sensorInfoBase1 = createSensorInfo(aVxdID1, 2.3, 4.2);
420 PXDCluster aCluster = PXDCluster(aVxdID1, 0., 0., 0.1, 0.1, 0, 0, 1, 1, 1, 1, 1, 1);
421 const SpacePoint aPXDSpacePoint = SpacePoint(&aCluster, &sensorInfoBase1);
422
423 VxdID aVxdID2 = VxdID(2, 2, 2);
424 VXD::SensorInfoBase sensorInfoBase2 = createSensorInfo(aVxdID2, 2.3, 4.2);
425 SVDCluster aUCluster = SVDCluster(aVxdID2, true, -0.23, 0.1, 0.01, 0.001, 1, 1, 1, 1.0);
426 SVDCluster aVCluster = SVDCluster(aVxdID2, false, 0.42, 0.1, 0.01, 0.001, 1, 1, 1, 1.0);
427 std::vector<const SVDCluster*> UVClusterVec1 = { &aUCluster, &aVCluster };
428 std::vector<const SVDCluster*> VClusterVec = { &aVCluster };
429 std::vector<const SVDCluster*> UClusterVec = { &aUCluster };
430 const SpacePoint SVDSpacePoint1 = SpacePoint(UVClusterVec1, &sensorInfoBase2);
431 const SpacePoint SVDSpacePoint2 = SpacePoint(VClusterVec, &sensorInfoBase2);
432 const SpacePoint SVDSpacePoint3 = SpacePoint(UClusterVec, &sensorInfoBase2);
433
434 VxdID aVxdId3 = VxdID(3, 3, 3);
435 VXD::SensorInfoBase sensorInfoBase3 = createSensorInfo(aVxdId3, 2.3, 4.2);
436 SVDCluster aUCluster2 = SVDCluster(aVxdId3, true, -0.23, 0.1, 0.01, 0.001, 1, 1, 1, 1.0);
437 SVDCluster aVCluster2 = SVDCluster(aVxdId3, false, 0.42, 0.1, 0.01, 0.001, 1, 1, 1, 1.0);
438 std::vector<const SVDCluster*> UVClusterVec2 = { &aUCluster2, &aVCluster2 };
439 std::vector<const SVDCluster*> VClusterVec2 = { &aVCluster2 };
440 std::vector<const SVDCluster*> UClusterVec2 = { &aUCluster2 };
441 const SpacePoint SVDSpacePoint4 = SpacePoint(UVClusterVec2, &sensorInfoBase3);
442 const SpacePoint SVDSpacePoint5 = SpacePoint(VClusterVec2, &sensorInfoBase3);
443 const SpacePoint SVDSpacePoint6 = SpacePoint(UClusterVec2, &sensorInfoBase3);
444
445
446 SpacePointTrackCand unsortedConstructed;
447 // add a SpacePoint with sorting parameter
448 unsortedConstructed.addSpacePoint(&aPXDSpacePoint, 1.0);
449 // add some SVD SpacePoints in logical order
450 unsortedConstructed.addSpacePoint(&SVDSpacePoint1, 2.34);
451 unsortedConstructed.addSpacePoint(&SVDSpacePoint2, 3.45);
452 unsortedConstructed.addSpacePoint(&SVDSpacePoint3, 4.56);
453 // add some SpacePoints in 'wrong' order
454 unsortedConstructed.addSpacePoint(&SVDSpacePoint4, 5.67);
455 unsortedConstructed.addSpacePoint(&SVDSpacePoint6, 7.89);
456 unsortedConstructed.addSpacePoint(&SVDSpacePoint5, 6.78);
457
458 // set up a SpacePointTrackCands already properly sorted
459 SpacePointTrackCand sortedConstructed;
460 sortedConstructed.addSpacePoint(&aPXDSpacePoint, 1.23);
461 sortedConstructed.addSpacePoint(&SVDSpacePoint1, 2.34);
462 sortedConstructed.addSpacePoint(&SVDSpacePoint2, 3.45);
463 sortedConstructed.addSpacePoint(&SVDSpacePoint3, 4.56);
464 sortedConstructed.addSpacePoint(&SVDSpacePoint4, 5.67);
465 sortedConstructed.addSpacePoint(&SVDSpacePoint5, 6.78);
466 sortedConstructed.addSpacePoint(&SVDSpacePoint6, 7.89);
467
468 // test sorting
469 SpacePointTrackCand sorted = SpacePointTrackCand(unsortedConstructed.getSortedHits());
470 // == compares the spacepoints
471 EXPECT_TRUE(sorted == sortedConstructed);
472
473 SpacePointTrackCand nothingChanged = SpacePointTrackCand(sortedConstructed.getSortedHits());
474 EXPECT_TRUE(nothingChanged == sortedConstructed);
475
476
477 std::vector<double> sortParams1 = { 1.0, 2.0, 3.0 , 4.0, 5.0, 7.0, 6.0};
478 sortedConstructed.setSortingParameters(sortParams1);
479
480 // verify that sorting changed according to new sortParams
481 SpacePointTrackCand unsorted = SpacePointTrackCand(sortedConstructed.getSortedHits());
482 EXPECT_TRUE(unsorted == unsortedConstructed);
483 }
485}
Belle2::Const::ParticleType::getPDGCode
int getPDGCode() const
PDG code.
Definition: Const.h:473
Belle2::Const::electron
static const ChargedStable electron
electron particle
Definition: Const.h:659
Belle2::PXDCluster
The PXD Cluster class This class stores all information about reconstructed PXD clusters The position...
Definition: PXDCluster.h:30
Belle2::SVDCluster
The SVD Cluster class This class stores all information about reconstructed SVD clusters.
Definition: SVDCluster.h:29
Belle2::SpacePointTrackCandTest
Test class for the SpacePointTrackCand class.
Definition: spacePointTrackCand.cc:30
Belle2::SpacePointTrackCandTest::createSensorInfo
VXD::SensorInfoBase createSensorInfo(VxdID aVxdID, double width=1., double length=1., double width2=-1.)
this is a small helper function to create a sensorInfo to be used
Definition: spacePointTrackCand.cc:33
Belle2::SpacePointTrackCand
Storage for (VXD) SpacePoint-based track candidates.
Definition: SpacePointTrackCand.h:40
Belle2::SpacePointTrackCand::getSortingParameters
const std::vector< double > & getSortingParameters() const
get the sorting parameters
Definition: SpacePointTrackCand.h:175
Belle2::SpacePointTrackCand::setSortingParameters
void setSortingParameters(const std::vector< double > &sortParams)
set the sorting parameters
Definition: SpacePointTrackCand.cc:132
Belle2::SpacePointTrackCand::getNHits
unsigned int getNHits() const
get the number of hits (space points) in the track candidate
Definition: SpacePointTrackCand.h:143
Belle2::SpacePointTrackCand::getPdgCode
int getPdgCode() const
get pdg code
Definition: SpacePointTrackCand.h:153
Belle2::SpacePointTrackCand::getHits
const std::vector< const Belle2::SpacePoint * > & getHits() const
get hits (space points) of track candidate
Definition: SpacePointTrackCand.h:120
Belle2::SpacePointTrackCand::removeSpacePoint
void removeSpacePoint(int indexInTrackCand)
remove a SpacePoint (and its sorting parameter) from the SpacePointTrackCand
Definition: SpacePointTrackCand.cc:142
Belle2::SpacePointTrackCand::getRefereeStatus
unsigned short int getRefereeStatus(unsigned short int bitmask=USHRT_MAX) const
Return the refere status code of the SpacePointTrackCand.
Definition: SpacePointTrackCand.h:201
Belle2::SpacePointTrackCand::checkedSameSensors
bool checkedSameSensors() const
Check if the SpacePointTrackCand has been checked for consecutive hits on same sensor.
Definition: SpacePointTrackCand.h:222
Belle2::SpacePointTrackCand::getMcTrackID
int getMcTrackID() const
get the MC Track ID
Definition: SpacePointTrackCand.h:190
Belle2::SpacePointTrackCand::clearRefereeStatus
void clearRefereeStatus()
clear the referee status.
Definition: SpacePointTrackCand.h:339
Belle2::SpacePointTrackCand::removeRefereeStatus
void removeRefereeStatus(unsigned short int bitmask)
remove a referee status
Definition: SpacePointTrackCand.h:336
Belle2::SpacePointTrackCand::c_curlingTrack
@ c_curlingTrack
bit 8: SPTC is curling (resp.
Definition: SpacePointTrackCand.h:80
Belle2::SpacePointTrackCand::c_checkedTrueHits
@ c_checkedTrueHits
bit 5: All SpacePoints of the SPTC have a relation to at least one TrueHit.
Definition: SpacePointTrackCand.h:75
Belle2::SpacePointTrackCand::c_hitsLowDistance
@ c_hitsLowDistance
bit 3: SPTC has two (or more) SpacePoints that are not far enough apart.
Definition: SpacePointTrackCand.h:73
Belle2::SpacePointTrackCand::c_checkedClean
@ c_checkedClean
bit 1: SPTC shows no 'problematic' behaviour.
Definition: SpacePointTrackCand.h:69
Belle2::SpacePointTrackCand::c_initialState
@ c_initialState
This is the initialState, which will always be set in the beginning and at reset.
Definition: SpacePointTrackCand.h:87
Belle2::SpacePointTrackCand::c_isActive
@ c_isActive
bit 11: SPTC is active (i.e.
Definition: SpacePointTrackCand.h:83
Belle2::SpacePointTrackCand::c_checkedSameSensors
@ c_checkedSameSensors
bit 6: It has been checked, if two consecutive SpacePoints are on the same sensor for this SPTC.
Definition: SpacePointTrackCand.h:78
Belle2::SpacePointTrackCand::c_checkedByReferee
@ c_checkedByReferee
bit 0: SPTC has been checked by a Referee (all possible tests).
Definition: SpacePointTrackCand.h:68
Belle2::SpacePointTrackCand::c_hitsOnSameSensor
@ c_hitsOnSameSensor
bit 2: SPTC has two (or more) SpacePoints on same sensor.
Definition: SpacePointTrackCand.h:70
Belle2::SpacePointTrackCand::isCurling
bool isCurling() const
get if the TrackCand is curling.
Definition: SpacePointTrackCand.h:250
Belle2::SpacePointTrackCand::hasHitsOnSameSensor
bool hasHitsOnSameSensor() const
Check if the SpacePointTrackCand contains consecutive SpacePoints that are on the same sensor WARNING...
Definition: SpacePointTrackCand.h:217
Belle2::SpacePointTrackCand::addSpacePoint
void addSpacePoint(const SpacePoint *newSP, double sortParam)
add a new SpacePoint and its according sorting parameter to the track candidate
Definition: SpacePointTrackCand.h:315
Belle2::SpacePointTrackCand::setRefereeStatus
void setRefereeStatus(unsigned short int bitmask)
set referee status (resets the complete to the passed status!)
Definition: SpacePointTrackCand.h:330
Belle2::SpacePointTrackCand::resetRefereeStatus
void resetRefereeStatus()
resets the referee status to the initial value
Definition: SpacePointTrackCand.h:342
Belle2::SpacePointTrackCand::getHitsInRange
const std::vector< const Belle2::SpacePoint * > getHitsInRange(int firstInd, int lastInd) const
get hits (SpacePoints) in range (indices of SpacePoint inside SpacePointTrackCand) including first in...
Definition: SpacePointTrackCand.cc:66
Belle2::SpacePointTrackCand::hasRefereeStatus
bool hasRefereeStatus(unsigned int short bitmask) const
Check if the SpacePointTrackCand has the status characterized by the bitmask.
Definition: SpacePointTrackCand.h:206
Belle2::SpacePointTrackCand::getSortingParametersInRange
const std::vector< double > getSortingParametersInRange(int firstIndex, int lastIndex) const
get the sorting parameters in range (indices of SpacePoints inside SpacePointTrackCand) including fir...
Definition: SpacePointTrackCand.cc:83
Belle2::SpacePointTrackCand::getChargeSeed
double getChargeSeed() const
get charge
Definition: SpacePointTrackCand.h:158
Belle2::SpacePointTrackCand::addRefereeStatus
void addRefereeStatus(unsigned short int bitmask)
add a referee status
Definition: SpacePointTrackCand.h:333
Belle2::SpacePointTrackCand::setPdgCode
void setPdgCode(int pdgCode)
set a hypothesis for the particle by setting a pdgcode (will also set the appropriate charge)
Definition: SpacePointTrackCand.cc:124
Belle2::SpacePointTrackCand::getSortedHits
const std::vector< const Belle2::SpacePoint * > getSortedHits() const
get hits (space points) sorted by their respective sorting parameter
Definition: SpacePointTrackCand.cc:100
Belle2::SpacePoint
SpacePoint typically is build from 1 PXDCluster or 1-2 SVDClusters.
Definition: SpacePoint.h:42
Belle2::VXD::SensorInfoBase
Base class to provide Sensor Information for PXD and SVD.
Definition: SensorInfoBase.h:29
Belle2::VXD::SensorInfoBase::setTransformation
void setTransformation(const TGeoHMatrix &transform, bool reco=false)
Set the transformation matrix of the Sensor.
Definition: SensorInfoBase.h:301
Belle2::VxdID
Class to uniquely identify a any structure of the PXD and SVD.
Definition: VxdID.h:33
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:17
std
STL namespace.