Belle II Software development
recoTrack.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 <tracking/dataobjects/RecoTrack.h>
10#include <framework/datastore/StoreArray.h>
11#include <framework/geometry/VectorUtil.h>
12
13#include <framework/utilities/TestHelpers.h>
14#include <framework/gearbox/Const.h>
15#include <vector>
16#include <genfit/WireTrackCandHit.h>
17
18using namespace std;
19
20namespace Belle2 {
26 class RecoTrackTest : public ::testing::Test {
27 protected:
29 void SetUp() override
30 {
32 m_storeArrayNameOfRecoTracks = "ILoveRecoTracks";
34 m_storeArrayNameOfPXDHits = "PXDsILike";
36 m_storeArrayNameOfSVDHits = "WhatAboutSVD";
38 m_storeArrayNameOfCDCHits = "CDCHitsAreCool";
40 m_storeArrayNameOfBKLMHits = "KeepBKLMsAlive";
42 m_storeArrayNameOfEKLMHits = "EKLMsAreImportant";
44 m_storeArrayNameOfHitInformation = "ConnectingAll";
45
46 //--- Setup -----------------------------------------------------------------------
47 // We do not use the KLM store arrays to test, if the RecoTrack can be used without them.
48 DataStore::Instance().setInitializeActive(true);
49 StoreArray<PXDCluster> pxdHits(m_storeArrayNameOfPXDHits);
50 pxdHits.registerInDataStore();
51 StoreArray<SVDCluster> svdHits(m_storeArrayNameOfSVDHits);
52 svdHits.registerInDataStore();
53 StoreArray<CDCHit> cdcHits(m_storeArrayNameOfCDCHits);
54 cdcHits.registerInDataStore();
55 StoreArray<RecoTrack> recoTracks(m_storeArrayNameOfRecoTracks);
56 recoTracks.registerInDataStore();
57 StoreArray<RecoHitInformation> recoHitInformations(m_storeArrayNameOfHitInformation);
58 recoHitInformations.registerInDataStore();
59
60 pxdHits.registerRelationTo(recoTracks);
61 svdHits.registerRelationTo(recoTracks);
62 cdcHits.registerRelationTo(recoTracks);
63 recoHitInformations.registerRelationTo(pxdHits);
64 recoHitInformations.registerRelationTo(svdHits);
65 recoHitInformations.registerRelationTo(cdcHits);
66
67 recoTracks.registerRelationTo(recoHitInformations);
68
69 //"CDCHit(tdcCount, adcCount, superLayer, layer, wire)"
70 //Indices range from 0-7
71 cdcHits.appendNew(100, 100, 0, 0, 0);
72 cdcHits.appendNew(100, 100, 2, 0, 0);
73 cdcHits.appendNew(100, 100, 4, 0, 0);
74 cdcHits.appendNew(100, 100, 6, 0, 0);
75 cdcHits.appendNew(100, 100, 8, 0, 0);
76 cdcHits.appendNew(100, 100, 1, 1, 0);
77 cdcHits.appendNew(100, 100, 3, 0, 0);
78 cdcHits.appendNew(100, 100, 5, 0, 0);
79
80 // We add some hits to the track. Then we assure they were added properly and the hit information objects are correct.
81 ROOT::Math::XYZVector position(0, 1, 2);
82 ROOT::Math::XYZVector momentum(-1, -0.5, 1.123);
83 short int charge = 1;
84 m_recoTrack = recoTracks.appendNew(position, momentum, charge,
85 m_storeArrayNameOfPXDHits, m_storeArrayNameOfSVDHits, m_storeArrayNameOfCDCHits,
86 m_storeArrayNameOfBKLMHits, m_storeArrayNameOfEKLMHits, m_storeArrayNameOfHitInformation);
87 m_recoTrack2 = recoTracks.appendNew(position, momentum, charge,
88 m_storeArrayNameOfPXDHits, m_storeArrayNameOfSVDHits, m_storeArrayNameOfCDCHits,
89 m_storeArrayNameOfBKLMHits, m_storeArrayNameOfEKLMHits, m_storeArrayNameOfHitInformation);
90 }
91
92 RecoTrack* m_recoTrack;
93 RecoTrack* m_recoTrack2;
94 std::string m_storeArrayNameOfRecoTracks;
95 std::string m_storeArrayNameOfPXDHits;
96 std::string m_storeArrayNameOfSVDHits;
97 std::string m_storeArrayNameOfCDCHits;
98 std::string m_storeArrayNameOfBKLMHits;
99 std::string m_storeArrayNameOfEKLMHits;
100 std::string m_storeArrayNameOfHitInformation;
101 };
102
104 // cppcheck-suppress syntaxError
105 TEST_F(RecoTrackTest, cdcHit)
106 {
107 StoreArray<CDCHit> cdcHits(m_storeArrayNameOfCDCHits);
108
109 EXPECT_FALSE(m_recoTrack->hasCDCHits());
110
111 // Add three cdc hits to the track
112 m_recoTrack->addCDCHit(cdcHits[0], 1);
113 m_recoTrack->addCDCHit(cdcHits[1], 0, RecoHitInformation::RightLeftInformation::c_right);
114 m_recoTrack->addCDCHit(cdcHits[2], 2);
115
116 EXPECT_TRUE(m_recoTrack->hasCDCHits());
117
118 EXPECT_TRUE(m_recoTrack->hasHit(cdcHits[0]));
119 EXPECT_TRUE(m_recoTrack->hasHit(cdcHits[1]));
120 EXPECT_TRUE(m_recoTrack->hasHit(cdcHits[2]));
121
122 EXPECT_FALSE(m_recoTrack->hasHit(cdcHits[4]));
123
124 ASSERT_EQ(m_recoTrack->getNumberOfCDCHits(), 3);
125 const std::vector<CDCHit*> addedCDCHits = m_recoTrack->getCDCHitList();
126 ASSERT_EQ(addedCDCHits.size(), 3);
127 EXPECT_EQ(addedCDCHits[0], cdcHits[0]);
128 EXPECT_EQ(addedCDCHits[1], cdcHits[1]);
129 EXPECT_EQ(addedCDCHits[2], cdcHits[2]);
130
131 const std::vector<CDCHit*> sortedCDCHits = m_recoTrack->getSortedCDCHitList();
132 ASSERT_EQ(sortedCDCHits.size(), 3);
133 EXPECT_EQ(sortedCDCHits[0], cdcHits[1]);
134 EXPECT_EQ(sortedCDCHits[1], cdcHits[0]);
135 EXPECT_EQ(sortedCDCHits[2], cdcHits[2]);
136
137 // Individual hit information
138 CDCHit* cdcHit = cdcHits[0];
139
140 RecoHitInformation* recoHitInformation = m_recoTrack->getRecoHitInformation(cdcHit);
141 EXPECT_NE(recoHitInformation, nullptr);
142 EXPECT_EQ(recoHitInformation->getTrackingDetector(), RecoHitInformation::RecoHitDetector::c_CDC);
143 EXPECT_EQ(recoHitInformation->getRightLeftInformation(), RecoHitInformation::RightLeftInformation::c_undefinedRightLeftInformation);
144 EXPECT_EQ(recoHitInformation->getFoundByTrackFinder(), RecoHitInformation::OriginTrackFinder::c_undefinedTrackFinder);
145 EXPECT_EQ(recoHitInformation->getSortingParameter(), 1);
146
147 cdcHit = cdcHits[1];
148 recoHitInformation = m_recoTrack->getRecoHitInformation(cdcHit);
149 EXPECT_NE(recoHitInformation, nullptr);
150 EXPECT_EQ(recoHitInformation->getRightLeftInformation(), RecoHitInformation::RightLeftInformation::c_right);
151
152
153
154 // Setter and getter for the reco hit information
155 // with added hits
156 cdcHit = cdcHits[0];
157
158 EXPECT_EQ(m_recoTrack->getTrackingDetector(cdcHit), RecoHitInformation::RecoHitDetector::c_CDC);
159 EXPECT_EQ(m_recoTrack->getRightLeftInformation(cdcHit), RecoHitInformation::RightLeftInformation::c_undefinedRightLeftInformation);
160 EXPECT_EQ(m_recoTrack->getFoundByTrackFinder(cdcHit), RecoHitInformation::OriginTrackFinder::c_undefinedTrackFinder);
161 EXPECT_EQ(m_recoTrack->getSortingParameter(cdcHit), 1);
162
163 EXPECT_NO_THROW(m_recoTrack->setFoundByTrackFinder(cdcHit, RecoHitInformation::OriginTrackFinder::c_SegmentTrackCombiner));
164 EXPECT_NO_THROW(m_recoTrack->setRightLeftInformation(cdcHit, RecoHitInformation::RightLeftInformation::c_left));
165 EXPECT_NO_THROW(m_recoTrack->setSortingParameter(cdcHit, 3));
166
167 EXPECT_EQ(m_recoTrack->getFoundByTrackFinder(cdcHit), RecoHitInformation::OriginTrackFinder::c_SegmentTrackCombiner);
168 EXPECT_EQ(m_recoTrack->getRightLeftInformation(cdcHit), RecoHitInformation::RightLeftInformation::c_left);
169 EXPECT_EQ(m_recoTrack->getSortingParameter(cdcHit), 3);
170
171 // with not added hits
172 cdcHit = cdcHits[4];
173
174 EXPECT_B2FATAL(m_recoTrack->getTrackingDetector(cdcHit));
175 EXPECT_B2FATAL(m_recoTrack->getRightLeftInformation(cdcHit));
176 EXPECT_B2FATAL(m_recoTrack->getFoundByTrackFinder(cdcHit));
177 EXPECT_B2FATAL(m_recoTrack->getSortingParameter(cdcHit));
178
179 EXPECT_B2FATAL(m_recoTrack->setFoundByTrackFinder(cdcHit, RecoHitInformation::OriginTrackFinder::c_SegmentTrackCombiner));
180 EXPECT_B2FATAL(m_recoTrack->setRightLeftInformation(cdcHit, RecoHitInformation::RightLeftInformation::c_left));
181 }
182
184 TEST_F(RecoTrackTest, cdcHitMCFinderCategory)
185 {
186 StoreArray<CDCHit> cdcHits(m_storeArrayNameOfCDCHits);
187
188 EXPECT_FALSE(m_recoTrack->hasCDCHits());
189
190 // Add three cdc hits to the track
191 m_recoTrack->addCDCHit(cdcHits[0], 1, RecoHitInformation::RightLeftInformation::c_right,
192 RecoHitInformation::OriginTrackFinder::c_MCTrackFinderPriorityHit);
193 m_recoTrack->addCDCHit(cdcHits[1], 0, RecoHitInformation::RightLeftInformation::c_right,
194 RecoHitInformation::OriginTrackFinder::c_MCTrackFinderAuxiliaryHit);
195 // the mcfinder prorperty of this hit is not provided explicitly and therefore should be set to undefined
196 m_recoTrack->addCDCHit(cdcHits[2], 2);
197
198 // get the RecoHitInfo and check their category
199 EXPECT_EQ(m_recoTrack->getRecoHitInformation(cdcHits[0])->getFoundByTrackFinder(),
200 RecoHitInformation::OriginTrackFinder::c_MCTrackFinderPriorityHit);
201 EXPECT_EQ(m_recoTrack->getRecoHitInformation(cdcHits[1])->getFoundByTrackFinder(),
202 RecoHitInformation::OriginTrackFinder::c_MCTrackFinderAuxiliaryHit);
203 EXPECT_EQ(m_recoTrack->getRecoHitInformation(cdcHits[2])->getFoundByTrackFinder(),
204 RecoHitInformation::OriginTrackFinder::c_undefinedTrackFinder);
205 }
206
208 TEST_F(RecoTrackTest, testGenfitConversionOne)
209 {
210 // Create a genfit track cand
211 genfit::TrackCand newCreatedTrackCand;
212 ROOT::Math::XYZVector position(4, 23, 5.6);
213 ROOT::Math::XYZVector momentum(4, 23, 5.6);
214 short int charge = 1;
215 // We can not add these parameters immediately - we have to convert them to the perigee parameters
216 newCreatedTrackCand.setPosMomSeed(XYZToTVector(position), XYZToTVector(momentum), charge);
217 newCreatedTrackCand.addHit(new genfit::WireTrackCandHit(Const::CDC, 0, -1, 0, 0));
218 newCreatedTrackCand.addHit(new genfit::WireTrackCandHit(Const::CDC, 1, -1, 1, 0));
219 newCreatedTrackCand.addHit(new genfit::WireTrackCandHit(Const::CDC, 2, -1, 2, 0));
220
221 // convert it to a RecoTrack
222 RecoTrack* recoTrackFromGenfit = RecoTrack::createFromTrackCand(newCreatedTrackCand, m_storeArrayNameOfRecoTracks,
223 m_storeArrayNameOfPXDHits, m_storeArrayNameOfSVDHits, m_storeArrayNameOfCDCHits,
224 m_storeArrayNameOfBKLMHits, m_storeArrayNameOfEKLMHits,
225 m_storeArrayNameOfHitInformation);
226
227 // convert it back
228
229 const genfit::TrackCand& exportedTrackCand = recoTrackFromGenfit->createGenfitTrackCand();
230
231 // Expect equal
232 ASSERT_EQ(exportedTrackCand.getNHits(), newCreatedTrackCand.getNHits());
233 EXPECT_NEAR(exportedTrackCand.getPosSeed().X(), newCreatedTrackCand.getPosSeed().X(), 1E-10);
234 EXPECT_NEAR(exportedTrackCand.getPosSeed().Y(), newCreatedTrackCand.getPosSeed().Y(), 1E-10);
235 EXPECT_NEAR(exportedTrackCand.getPosSeed().Z(), newCreatedTrackCand.getPosSeed().Z(), 1E-10);
236 EXPECT_NEAR(exportedTrackCand.getMomSeed().X(), newCreatedTrackCand.getMomSeed().X(), 1E-10);
237 EXPECT_NEAR(exportedTrackCand.getMomSeed().Y(), newCreatedTrackCand.getMomSeed().Y(), 1E-10);
238 EXPECT_NEAR(exportedTrackCand.getMomSeed().Z(), newCreatedTrackCand.getMomSeed().Z(), 1E-10);
239 EXPECT_EQ(exportedTrackCand.getChargeSeed(), newCreatedTrackCand.getChargeSeed());
240 EXPECT_EQ(exportedTrackCand.getHit(0)->getHitId(), newCreatedTrackCand.getHit(0)->getHitId());
241 EXPECT_EQ(exportedTrackCand.getHit(1)->getSortingParameter(), newCreatedTrackCand.getHit(1)->getSortingParameter());
242 EXPECT_EQ(exportedTrackCand.getHit(2)->getHitId(), newCreatedTrackCand.getHit(2)->getHitId());
243 }
244
246 TEST_F(RecoTrackTest, testGenfitConversionTwo)
247 {
248 EXPECT_FALSE(m_recoTrack->hasCDCHits());
249 StoreArray<CDCHit> cdcHits(m_storeArrayNameOfCDCHits);
250
251 // Add three cdc hits to the track
252 m_recoTrack->addCDCHit(cdcHits[0], 1);
253 m_recoTrack->addCDCHit(cdcHits[1], 0, RecoHitInformation::RightLeftInformation::c_right);
254 m_recoTrack->addCDCHit(cdcHits[2], 2);
255
256 EXPECT_TRUE(m_recoTrack->hasCDCHits());
257
258 const genfit::TrackCand& exportedTrackCand = m_recoTrack->createGenfitTrackCand();
259
260 ASSERT_EQ(exportedTrackCand.getNHits(), m_recoTrack->getNumberOfTotalHits());
261 ASSERT_EQ(m_recoTrack->getNumberOfTotalHits(), 3);
262
263 RecoTrack* recoTrackFromGenfit = RecoTrack::createFromTrackCand(exportedTrackCand, m_storeArrayNameOfRecoTracks,
264 m_storeArrayNameOfPXDHits, m_storeArrayNameOfSVDHits, m_storeArrayNameOfCDCHits,
265 m_storeArrayNameOfBKLMHits, m_storeArrayNameOfEKLMHits,
266 m_storeArrayNameOfHitInformation);
267
268 B2INFO("kjh");
269
270 ASSERT_EQ(recoTrackFromGenfit->getNumberOfCDCHits(), m_recoTrack->getNumberOfCDCHits());
271 const auto& cdcHitListOne = recoTrackFromGenfit->getCDCHitList();
272 const auto& cdcHitListTwo = m_recoTrack->getCDCHitList();
273 ASSERT_EQ(cdcHitListOne.size(), 3);
274 ASSERT_EQ(cdcHitListTwo.size(), 3);
275 }
276
278 TEST_F(RecoTrackTest, copyRecoTrack)
279 {
280 StoreArray<CDCHit> cdcHits(m_storeArrayNameOfCDCHits);
281
282 // Add three cdc hits to the track
283 m_recoTrack->addCDCHit(cdcHits[0], 1);
284 m_recoTrack->addCDCHit(cdcHits[1], 0, RecoHitInformation::RightLeftInformation::c_right);
285 m_recoTrack->addCDCHit(cdcHits[2], 2);
286
287 // create a second RecoTrack
288 StoreArray<RecoTrack> recoTracks(m_storeArrayNameOfRecoTracks);
289
290 auto recoTrack = recoTracks.appendNew(m_recoTrack->getPositionSeed(), m_recoTrack->getMomentumSeed(), m_recoTrack->getChargeSeed(),
291 m_storeArrayNameOfPXDHits, m_storeArrayNameOfSVDHits, m_storeArrayNameOfCDCHits,
292 m_storeArrayNameOfBKLMHits, m_storeArrayNameOfEKLMHits,
293 m_storeArrayNameOfHitInformation);
294 EXPECT_FALSE(recoTrack->hasCDCHits());
295
296 // check if the offset computation of the hit order works as expected
297 size_t offset = 3;
298 recoTrack->addHitsFromRecoTrack(m_recoTrack, offset);
299 ASSERT_EQ(recoTrack->getNumberOfCDCHits(), 3);
300
301 size_t this_i = offset;
302 for (auto pHit : recoTrack->getSortedCDCHitList()) {
303 auto sortParam = recoTrack->getSortingParameter(pHit);
304 ASSERT_EQ(this_i, sortParam);
305 this_i++;
306 }
307 }
308
310 TEST_F(RecoTrackTest, recoHitInformations)
311 {
312 StoreArray<CDCHit> cdcHits(m_storeArrayNameOfCDCHits);
313
314 m_recoTrack->addCDCHit(cdcHits[0], 1);
315
316 // create a second RecoTrack
317 StoreArray<RecoTrack> recoTracks(m_storeArrayNameOfRecoTracks);
318
319 RecoTrack* recoTrack2 = recoTracks.appendNew(m_recoTrack->getPositionSeed(), m_recoTrack->getMomentumSeed(),
320 m_recoTrack->getChargeSeed(),
321 m_storeArrayNameOfPXDHits, m_storeArrayNameOfSVDHits, m_storeArrayNameOfCDCHits,
322 m_storeArrayNameOfBKLMHits, m_storeArrayNameOfEKLMHits,
323 m_storeArrayNameOfHitInformation);
324 recoTrack2->addCDCHit(cdcHits[1], 2);
325
326 ASSERT_EQ(m_recoTrack->getRecoHitInformations().size(), 1);
327 ASSERT_EQ(m_recoTrack->getRecoHitInformations()[0]->getSortingParameter(), 1);
328 ASSERT_EQ(recoTrack2->getRecoHitInformations().size(), 1);
329 ASSERT_EQ(recoTrack2->getRecoHitInformations()[0]->getSortingParameter(), 2);
330 }
331
333 TEST_F(RecoTrackTest, trackTime)
334 {
335 StoreArray<SVDCluster> svdHits(m_storeArrayNameOfSVDHits);
336 StoreArray<CDCHit> cdcHits(m_storeArrayNameOfCDCHits);
337
338 //"SVDCluster(VxdID, isU, position, positionErr, clsTime, clsTimeErr, clsCharge, seedCharge, clsSize, clsSNR, clsChi2, FF)"
339 svdHits.appendNew(Belle2::VxdID("3.1.2"), true, 1.0, 0.01, 0.1, 0.1, 5.0e4, 5.0e4, 1, 50.0, 0.1, 0);
340 svdHits.appendNew(Belle2::VxdID("4.1.2"), true, 1.0, 0.01, 0.2, 0.1, 5.0e4, 5.0e4, 1, 50.0, 0.1, 0);
341 svdHits.appendNew(Belle2::VxdID("5.1.3"), true, 1.0, 0.01, 0.3, 0.1, 5.0e4, 5.0e4, 1, 50.0, 0.1, 0);
342 svdHits.appendNew(Belle2::VxdID("6.1.3"), true, 1.0, 0.01, 0.4, 0.1, 5.0e4, 5.0e4, 1, 50.0, 0.1, 0);
343 svdHits.appendNew(Belle2::VxdID("6.7.7"), true, 1.0, 0.01, 1.0, 0.1, 5.0e4, 5.0e4, 1, 50.0, 0.1, 0);
344 svdHits.appendNew(Belle2::VxdID("5.7.4"), true, 1.0, 0.01, 1.1, 0.1, 5.0e4, 5.0e4, 1, 50.0, 0.1, 0);
345
346 ROOT::Math::XYZVector momentum(0.25, 0.25, 0.05);
347
348 StoreArray<RecoTrack> recoTracks(m_storeArrayNameOfRecoTracks);
349 RecoTrack* recoTrack = recoTracks.appendNew(m_recoTrack->getPositionSeed(), momentum,
350 m_recoTrack->getChargeSeed(),
351 m_storeArrayNameOfPXDHits, m_storeArrayNameOfSVDHits, m_storeArrayNameOfCDCHits,
352 m_storeArrayNameOfBKLMHits, m_storeArrayNameOfEKLMHits,
353 m_storeArrayNameOfHitInformation);
354
355 // SVD Hits
356 recoTrack->addSVDHit(svdHits[0], 0);
357 recoTrack->addSVDHit(svdHits[1], 1);
358 recoTrack->addSVDHit(svdHits[2], 2);
359 recoTrack->addSVDHit(svdHits[3], 3);
360
361 // CDC Hits
362 recoTrack->addCDCHit(cdcHits[0], 4);
363 recoTrack->addCDCHit(cdcHits[1], 5);
364
365 // SVD Hits
366 recoTrack->addSVDHit(svdHits[4], 6);
367 recoTrack->addSVDHit(svdHits[5], 7);
368
369 EXPECT_TRUE(recoTrack->hasSVDHits());
370
371 EXPECT_FALSE(recoTrack->hasOutgoingArmTime());
372 EXPECT_FALSE(recoTrack->hasIngoingArmTime());
373
374 B2INFO("outgoing arm time: " << recoTrack->getOutgoingArmTime());
375 B2INFO("ingoing arm time: " << recoTrack->getIngoingArmTime());
376 B2INFO("difference: " << recoTrack->getInOutArmTimeDifference());
377 EXPECT_NEAR(recoTrack->getIngoingArmTime(), recoTrack->getOutgoingArmTime(), 0.8);
378 EXPECT_NEAR(recoTrack->getIngoingArmTime(), 1.05, 1E-5);
379
380 EXPECT_TRUE(recoTrack->hasOutgoingArmTime());
381 EXPECT_TRUE(recoTrack->hasIngoingArmTime());
382 }
384}
E
R E
internal precision of FFTW codelets
Definition: DiscreteCosineTransform_31points.cc:36
Belle2::CDCHit
Class containing the result of the unpacker in raw data and the result of the digitizer in simulation...
Definition: CDCHit.h:40
Belle2::DataStore::Instance
static DataStore & Instance()
Instance of singleton Store.
Definition: DataStore.cc:54
Belle2::DataStore::setInitializeActive
void setInitializeActive(bool active)
Setter for m_initializeActive.
Definition: DataStore.cc:94
Belle2::RecoHitInformation
This class stores additional information to every CDC/SVD/PXD hit stored in a RecoTrack.
Definition: RecoHitInformation.h:38
Belle2::RecoHitInformation::getRightLeftInformation
RightLeftInformation getRightLeftInformation() const
Get the right-left-information.
Definition: RecoHitInformation.h:228
Belle2::RecoHitInformation::getFoundByTrackFinder
OriginTrackFinder getFoundByTrackFinder() const
Get which track finder has found the track.
Definition: RecoHitInformation.h:204
Belle2::RecoHitInformation::getTrackingDetector
RecoHitDetector getTrackingDetector() const
Get the detector this hit comes from.
Definition: RecoHitInformation.h:240
Belle2::RecoHitInformation::getSortingParameter
unsigned int getSortingParameter() const
Get the sorting parameter.
Definition: RecoHitInformation.h:216
Belle2::RecoTrackTest
Test class for the RecoTrack object.
Definition: recoTrack.cc:26
Belle2::RecoTrackTest::m_storeArrayNameOfHitInformation
std::string m_storeArrayNameOfHitInformation
name of storeArray with hit information
Definition: recoTrack.cc:100
Belle2::RecoTrackTest::m_storeArrayNameOfCDCHits
std::string m_storeArrayNameOfCDCHits
name of storeArray with CDC hits
Definition: recoTrack.cc:97
Belle2::RecoTrackTest::SetUp
void SetUp() override
Setup a "working environment" with store arrays for the hits and the correct relations.
Definition: recoTrack.cc:29
Belle2::RecoTrackTest::m_storeArrayNameOfBKLMHits
std::string m_storeArrayNameOfBKLMHits
name of storeArray with BKLM hits
Definition: recoTrack.cc:98
Belle2::RecoTrackTest::m_storeArrayNameOfRecoTracks
std::string m_storeArrayNameOfRecoTracks
name of recoTracks storeArray
Definition: recoTrack.cc:94
Belle2::RecoTrackTest::m_storeArrayNameOfSVDHits
std::string m_storeArrayNameOfSVDHits
name of storeArray with SVD hits
Definition: recoTrack.cc:96
Belle2::RecoTrackTest::m_recoTrack2
RecoTrack * m_recoTrack2
pointer to other recoTrack
Definition: recoTrack.cc:93
Belle2::RecoTrackTest::m_storeArrayNameOfEKLMHits
std::string m_storeArrayNameOfEKLMHits
name of storeArray with EKLM hits
Definition: recoTrack.cc:99
Belle2::RecoTrackTest::m_recoTrack
RecoTrack * m_recoTrack
pointer to recoTrack
Definition: recoTrack.cc:92
Belle2::RecoTrackTest::m_storeArrayNameOfPXDHits
std::string m_storeArrayNameOfPXDHits
name of storeArray with PXD hits
Definition: recoTrack.cc:95
Belle2::RecoTrack
This is the Reconstruction Event-Data Model Track.
Definition: RecoTrack.h:79
Belle2::RecoTrack::addCDCHit
bool addCDCHit(const UsedCDCHit *cdcHit, const unsigned int sortingParameter, RightLeftInformation rightLeftInformation=RightLeftInformation::c_undefinedRightLeftInformation, OriginTrackFinder foundByTrackFinder=OriginTrackFinder::c_undefinedTrackFinder)
Adds a cdc hit with the given information to the reco track.
Definition: RecoTrack.h:243
Belle2::RecoTrack::getInOutArmTimeDifference
float getInOutArmTimeDifference()
Return the difference between the track times of the ingoing and outgoing arms.
Definition: RecoTrack.h:542
Belle2::RecoTrack::getOutgoingArmTime
float getOutgoingArmTime()
Return the track time of the outgoing arm.
Definition: RecoTrack.h:514
Belle2::RecoTrack::createFromTrackCand
static RecoTrack * createFromTrackCand(const genfit::TrackCand &trackCand, const std::string &storeArrayNameOfRecoTracks="", const std::string &storeArrayNameOfPXDHits="", const std::string &storeArrayNameOfSVDHits="", const std::string &storeArrayNameOfCDCHits="", const std::string &storeArrayNameOfBKLMHits="", const std::string &storeArrayNameOfEKLMHits="", const std::string &storeArrayNameOfRecoHitInformation="", const bool recreateSortingParameters=false)
Create a reco track from a genfit::TrackCand and save it to the given store array.
Definition: RecoTrack.cc:97
Belle2::RecoTrack::getCDCHitList
std::vector< Belle2::RecoTrack::UsedCDCHit * > getCDCHitList() const
Return an unsorted list of cdc hits.
Definition: RecoTrack.h:455
Belle2::RecoTrack::getNumberOfCDCHits
unsigned int getNumberOfCDCHits() const
Return the number of cdc hits.
Definition: RecoTrack.h:427
Belle2::RecoTrack::hasOutgoingArmTime
bool hasOutgoingArmTime()
Check if the outgoing arm time is set.
Definition: RecoTrack.h:563
Belle2::RecoTrack::getIngoingArmTime
float getIngoingArmTime()
Return the track time of the ingoing arm.
Definition: RecoTrack.h:528
Belle2::RecoTrack::createGenfitTrackCand
genfit::TrackCand createGenfitTrackCand() const
Create a genfit::TrackCand out of this reco track and copy all information to the track candidate.
Definition: RecoTrack.cc:178
Belle2::RecoTrack::getRecoHitInformations
std::vector< RecoHitInformation * > getRecoHitInformations(bool getSorted=false) const
Return a list of all RecoHitInformations associated with the RecoTrack.
Definition: RecoTrack.cc:557
Belle2::RecoTrack::hasIngoingArmTime
bool hasIngoingArmTime()
Check if the ingoing arm time is set.
Definition: RecoTrack.h:557
Belle2::RecoTrack::addSVDHit
bool addSVDHit(const UsedSVDHit *svdHit, const unsigned int sortingParameter, OriginTrackFinder foundByTrackFinder=OriginTrackFinder::c_undefinedTrackFinder)
Adds a svd hit with the given information to the reco track.
Definition: RecoTrack.h:272
Belle2::RecoTrack::hasSVDHits
bool hasSVDHits() const
Returns true if the track has svd hits.
Definition: RecoTrack.h:398
Belle2::StoreAccessorBase::registerInDataStore
bool registerInDataStore(DataStore::EStoreFlags storeFlags=DataStore::c_WriteOut)
Register the object/array in the DataStore.
Definition: StoreAccessorBase.h:52
Belle2::StoreArray
Accessor to arrays stored in the data store.
Definition: StoreArray.h:113
Belle2::StoreArray::appendNew
T * appendNew()
Construct a new T object at the end of the array.
Definition: StoreArray.h:246
Belle2::StoreArray::registerRelationTo
bool registerRelationTo(const StoreArray< TO > &toArray, DataStore::EDurability durability=DataStore::c_Event, DataStore::EStoreFlags storeFlags=DataStore::c_WriteOut, const std::string &namedRelation="") const
Register a relation to the given StoreArray.
Definition: StoreArray.h:140
Belle2::VxdID
Class to uniquely identify a any structure of the PXD and SVD.
Definition: VxdID.h:33
Belle2::XYZToTVector
static constexpr auto XYZToTVector
Helper function to convert XYZVector to TVector3.
Definition: VectorUtil.h:24
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:17
std
STL namespace.