Belle II Software  release-05-01-25
recoTrack.cc
1 /**************************************************************************
2  * BASF2 (Belle Analysis Framework 2) *
3  * Copyright(C) 2015 - Belle II Collaboration *
4  * *
5  * Author: The Belle II Collaboration *
6  * Contributors: Martin Heck, Nils Braun *
7  * *
8  * This software is provided "as is" without any warranty. *
9  **************************************************************************/
10 
11 #include <tracking/dataobjects/RecoTrack.h>
12 #include <framework/datastore/StoreArray.h>
13 
14 #include <framework/utilities/TestHelpers.h>
15 #include <framework/gearbox/Const.h>
16 #include <vector>
17 #include <genfit/WireTrackCandHit.h>
18 
19 
20 using namespace std;
21 
22 namespace Belle2 {
28  class RecoTrackTest : public ::testing::Test {
29  protected:
31  void SetUp() override
32  {
34  m_storeArrayNameOfRecoTracks = "ILoveRecoTracks";
36  m_storeArrayNameOfCDCHits = "CDCHitsAreCool";
38  m_storeArrayNameOfSVDHits = "WhatAboutSVD";
40  m_storeArrayNameOfPXDHits = "PXDsILike";
42  m_storeArrayNameOfBKLMHits = "KeepBKLMsAlive";
44  m_storeArrayNameOfEKLMHits = "EKLMsAreImportant";
46  m_storeArrayNameOfHitInformation = "ConnectingAll";
47 
48  //--- Setup -----------------------------------------------------------------------
49  // We do not use the KLM store arrays to test, if the RecoTrack can be used without them.
50  DataStore::Instance().setInitializeActive(true);
51  StoreArray<CDCHit> cdcHits(m_storeArrayNameOfCDCHits);
52  cdcHits.registerInDataStore();
53  StoreArray<SVDCluster> svdHits(m_storeArrayNameOfSVDHits);
54  svdHits.registerInDataStore();
55  StoreArray<PXDCluster> pxdHits(m_storeArrayNameOfPXDHits);
56  pxdHits.registerInDataStore();
57  StoreArray<RecoTrack> recoTracks(m_storeArrayNameOfRecoTracks);
58  recoTracks.registerInDataStore();
59  StoreArray<RecoHitInformation> recoHitInformations(m_storeArrayNameOfHitInformation);
60  recoHitInformations.registerInDataStore();
61 
62  cdcHits.registerRelationTo(recoTracks);
63  svdHits.registerRelationTo(recoTracks);
64  pxdHits.registerRelationTo(recoTracks);
65  recoHitInformations.registerRelationTo(cdcHits);
66  recoHitInformations.registerRelationTo(svdHits);
67  recoHitInformations.registerRelationTo(pxdHits);
68 
69  recoTracks.registerRelationTo(recoHitInformations);
70 
71  //"CDCHit(tdcCount, adcCount, superLayer, layer, wire)"
72  //Indices range from 0-7
73  cdcHits.appendNew(100, 100, 0, 0, 0);
74  cdcHits.appendNew(100, 100, 2, 0, 0);
75  cdcHits.appendNew(100, 100, 4, 0, 0);
76  cdcHits.appendNew(100, 100, 6, 0, 0);
77  cdcHits.appendNew(100, 100, 8, 0, 0);
78  cdcHits.appendNew(100, 100, 1, 1, 0);
79  cdcHits.appendNew(100, 100, 3, 0, 0);
80  cdcHits.appendNew(100, 100, 5, 0, 0);
81 
82  // We add some hits to the track. Then we assure they were added properly and the hit information objects are correct.
83  TVector3 position(0, 1, 2);
84  TVector3 momentum(-1, -0.5, 1.123);
85  short int charge = 1;
86  m_recoTrack = recoTracks.appendNew(position, momentum, charge,
87  m_storeArrayNameOfCDCHits, m_storeArrayNameOfSVDHits, m_storeArrayNameOfPXDHits,
88  m_storeArrayNameOfBKLMHits, m_storeArrayNameOfEKLMHits, m_storeArrayNameOfHitInformation);
89  m_recoTrack2 = recoTracks.appendNew(position, momentum, charge,
90  m_storeArrayNameOfCDCHits, m_storeArrayNameOfSVDHits, m_storeArrayNameOfPXDHits,
91  m_storeArrayNameOfBKLMHits, m_storeArrayNameOfEKLMHits, m_storeArrayNameOfHitInformation);
92  }
93 
94  RecoTrack* m_recoTrack;
95  RecoTrack* m_recoTrack2;
96  std::string m_storeArrayNameOfRecoTracks;
97  std::string m_storeArrayNameOfCDCHits;
98  std::string m_storeArrayNameOfSVDHits;
99  std::string m_storeArrayNameOfPXDHits;
100  std::string m_storeArrayNameOfBKLMHits;
101  std::string m_storeArrayNameOfEKLMHits;
102  std::string m_storeArrayNameOfHitInformation;
103  };
104 
106  TEST_F(RecoTrackTest, cdcHit)
107  {
108  StoreArray<CDCHit> cdcHits(m_storeArrayNameOfCDCHits);
109 
110  EXPECT_FALSE(m_recoTrack->hasCDCHits());
111 
112  // Add three cdc hits to the track
113  m_recoTrack->addCDCHit(cdcHits[0], 1);
114  m_recoTrack->addCDCHit(cdcHits[1], 0, RecoHitInformation::RightLeftInformation::c_right);
115  m_recoTrack->addCDCHit(cdcHits[2], 2);
116 
117  EXPECT_TRUE(m_recoTrack->hasCDCHits());
118 
119  EXPECT_TRUE(m_recoTrack->hasHit(cdcHits[0]));
120  EXPECT_TRUE(m_recoTrack->hasHit(cdcHits[1]));
121  EXPECT_TRUE(m_recoTrack->hasHit(cdcHits[2]));
122 
123  EXPECT_FALSE(m_recoTrack->hasHit(cdcHits[4]));
124 
125  ASSERT_EQ(m_recoTrack->getNumberOfCDCHits(), 3);
126  const std::vector<CDCHit*> addedCDCHits = m_recoTrack->getCDCHitList();
127  ASSERT_EQ(addedCDCHits.size(), 3);
128  EXPECT_EQ(addedCDCHits[0], cdcHits[0]);
129  EXPECT_EQ(addedCDCHits[1], cdcHits[1]);
130  EXPECT_EQ(addedCDCHits[2], cdcHits[2]);
131 
132  const std::vector<CDCHit*> sortedCDCHits = m_recoTrack->getSortedCDCHitList();
133  ASSERT_EQ(sortedCDCHits.size(), 3);
134  EXPECT_EQ(sortedCDCHits[0], cdcHits[1]);
135  EXPECT_EQ(sortedCDCHits[1], cdcHits[0]);
136  EXPECT_EQ(sortedCDCHits[2], cdcHits[2]);
137 
138  // Individual hit information
139  CDCHit* cdcHit = cdcHits[0];
140 
141  RecoHitInformation* recoHitInformation = m_recoTrack->getRecoHitInformation(cdcHit);
142  EXPECT_NE(recoHitInformation, nullptr);
143  EXPECT_EQ(recoHitInformation->getTrackingDetector(), RecoHitInformation::RecoHitDetector::c_CDC);
144  EXPECT_EQ(recoHitInformation->getRightLeftInformation(), RecoHitInformation::RightLeftInformation::c_undefinedRightLeftInformation);
145  EXPECT_EQ(recoHitInformation->getFoundByTrackFinder(), RecoHitInformation::OriginTrackFinder::c_undefinedTrackFinder);
146  EXPECT_EQ(recoHitInformation->getSortingParameter(), 1);
147 
148  cdcHit = cdcHits[1];
149  recoHitInformation = m_recoTrack->getRecoHitInformation(cdcHit);
150  EXPECT_NE(recoHitInformation, nullptr);
151  EXPECT_EQ(recoHitInformation->getRightLeftInformation(), RecoHitInformation::RightLeftInformation::c_right);
152 
153 
154 
155  // Setter and getter for the reco hit information
156  // with added hits
157  cdcHit = cdcHits[0];
158 
159  EXPECT_EQ(m_recoTrack->getTrackingDetector(cdcHit), RecoHitInformation::RecoHitDetector::c_CDC);
160  EXPECT_EQ(m_recoTrack->getRightLeftInformation(cdcHit), RecoHitInformation::RightLeftInformation::c_undefinedRightLeftInformation);
161  EXPECT_EQ(m_recoTrack->getFoundByTrackFinder(cdcHit), RecoHitInformation::OriginTrackFinder::c_undefinedTrackFinder);
162  EXPECT_EQ(m_recoTrack->getSortingParameter(cdcHit), 1);
163 
164  EXPECT_NO_THROW(m_recoTrack->setFoundByTrackFinder(cdcHit, RecoHitInformation::OriginTrackFinder::c_SegmentTrackCombiner));
165  EXPECT_NO_THROW(m_recoTrack->setRightLeftInformation(cdcHit, RecoHitInformation::RightLeftInformation::c_left));
166  EXPECT_NO_THROW(m_recoTrack->setSortingParameter(cdcHit, 3));
167 
168  EXPECT_EQ(m_recoTrack->getFoundByTrackFinder(cdcHit), RecoHitInformation::OriginTrackFinder::c_SegmentTrackCombiner);
169  EXPECT_EQ(m_recoTrack->getRightLeftInformation(cdcHit), RecoHitInformation::RightLeftInformation::c_left);
170  EXPECT_EQ(m_recoTrack->getSortingParameter(cdcHit), 3);
171 
172  // with not added hits
173  cdcHit = cdcHits[4];
174 
175  EXPECT_B2FATAL(m_recoTrack->getTrackingDetector(cdcHit));
176  EXPECT_B2FATAL(m_recoTrack->getRightLeftInformation(cdcHit));
177  EXPECT_B2FATAL(m_recoTrack->getFoundByTrackFinder(cdcHit));
178  EXPECT_B2FATAL(m_recoTrack->getSortingParameter(cdcHit));
179 
180  EXPECT_B2FATAL(m_recoTrack->setFoundByTrackFinder(cdcHit, RecoHitInformation::OriginTrackFinder::c_SegmentTrackCombiner));
181  EXPECT_B2FATAL(m_recoTrack->setRightLeftInformation(cdcHit, RecoHitInformation::RightLeftInformation::c_left));
182  }
183 
185  TEST_F(RecoTrackTest, cdcHitMCFinderCategory)
186  {
187  StoreArray<CDCHit> cdcHits(m_storeArrayNameOfCDCHits);
188 
189  EXPECT_FALSE(m_recoTrack->hasCDCHits());
190 
191  // Add three cdc hits to the track
192  m_recoTrack->addCDCHit(cdcHits[0], 1, RecoHitInformation::RightLeftInformation::c_right,
193  RecoHitInformation::OriginTrackFinder::c_MCTrackFinderPriorityHit);
194  m_recoTrack->addCDCHit(cdcHits[1], 0, RecoHitInformation::RightLeftInformation::c_right,
195  RecoHitInformation::OriginTrackFinder::c_MCTrackFinderAuxiliaryHit);
196  // the mcfinder prorperty of this hit is not provided explicitly and therefore should be set to undefined
197  m_recoTrack->addCDCHit(cdcHits[2], 2);
198 
199  // get the RecoHitInfo and check their category
200  EXPECT_EQ(m_recoTrack->getRecoHitInformation(cdcHits[0])->getFoundByTrackFinder(),
201  RecoHitInformation::OriginTrackFinder::c_MCTrackFinderPriorityHit);
202  EXPECT_EQ(m_recoTrack->getRecoHitInformation(cdcHits[1])->getFoundByTrackFinder(),
203  RecoHitInformation::OriginTrackFinder::c_MCTrackFinderAuxiliaryHit);
204  EXPECT_EQ(m_recoTrack->getRecoHitInformation(cdcHits[2])->getFoundByTrackFinder(),
205  RecoHitInformation::OriginTrackFinder::c_undefinedTrackFinder);
206  }
207 
209  TEST_F(RecoTrackTest, testGenfitConversionOne)
210  {
211  // Create a genfit track cand
212  genfit::TrackCand newCreatedTrackCand;
213  TVector3 position(4, 23, 5.6);
214  TVector3 momentum(4, 23, 5.6);
215  short int charge = 1;
216  // We can not add these parameters immediately - we hve to convert them to the perigee parameters
217  newCreatedTrackCand.setPosMomSeed(position, momentum, charge);
218  newCreatedTrackCand.addHit(new genfit::WireTrackCandHit(Const::CDC, 0, -1, 0, 0));
219  newCreatedTrackCand.addHit(new genfit::WireTrackCandHit(Const::CDC, 1, -1, 1, 0));
220  newCreatedTrackCand.addHit(new genfit::WireTrackCandHit(Const::CDC, 2, -1, 2, 0));
221 
222  // convert it to a RecoTrack
223  RecoTrack* recoTrackFromGenfit = RecoTrack::createFromTrackCand(newCreatedTrackCand, m_storeArrayNameOfRecoTracks,
224  m_storeArrayNameOfCDCHits, m_storeArrayNameOfSVDHits,
225  m_storeArrayNameOfPXDHits, m_storeArrayNameOfBKLMHits,
226  m_storeArrayNameOfEKLMHits,
227  m_storeArrayNameOfHitInformation);
228 
229  // convert it back
230 
231  const genfit::TrackCand& exportedTrackCand = recoTrackFromGenfit->createGenfitTrackCand();
232 
233  // Expect equal
234  ASSERT_EQ(exportedTrackCand.getNHits(), newCreatedTrackCand.getNHits());
235  EXPECT_NEAR(exportedTrackCand.getPosSeed().X(), newCreatedTrackCand.getPosSeed().X(), 1E-10);
236  EXPECT_NEAR(exportedTrackCand.getPosSeed().Y(), newCreatedTrackCand.getPosSeed().Y(), 1E-10);
237  EXPECT_NEAR(exportedTrackCand.getPosSeed().Z(), newCreatedTrackCand.getPosSeed().Z(), 1E-10);
238  EXPECT_NEAR(exportedTrackCand.getMomSeed().X(), newCreatedTrackCand.getMomSeed().X(), 1E-10);
239  EXPECT_NEAR(exportedTrackCand.getMomSeed().Y(), newCreatedTrackCand.getMomSeed().Y(), 1E-10);
240  EXPECT_NEAR(exportedTrackCand.getMomSeed().Z(), newCreatedTrackCand.getMomSeed().Z(), 1E-10);
241  EXPECT_EQ(exportedTrackCand.getChargeSeed(), newCreatedTrackCand.getChargeSeed());
242  EXPECT_EQ(exportedTrackCand.getHit(0)->getHitId(), newCreatedTrackCand.getHit(0)->getHitId());
243  EXPECT_EQ(exportedTrackCand.getHit(1)->getSortingParameter(), newCreatedTrackCand.getHit(1)->getSortingParameter());
244  EXPECT_EQ(exportedTrackCand.getHit(2)->getHitId(), newCreatedTrackCand.getHit(2)->getHitId());
245  }
246 
248  TEST_F(RecoTrackTest, testGenfitConversionTwo)
249  {
250  EXPECT_FALSE(m_recoTrack->hasCDCHits());
251  StoreArray<CDCHit> cdcHits(m_storeArrayNameOfCDCHits);
252 
253  // Add three cdc hits to the track
254  m_recoTrack->addCDCHit(cdcHits[0], 1);
255  m_recoTrack->addCDCHit(cdcHits[1], 0, RecoHitInformation::RightLeftInformation::c_right);
256  m_recoTrack->addCDCHit(cdcHits[2], 2);
257 
258  EXPECT_TRUE(m_recoTrack->hasCDCHits());
259 
260  const genfit::TrackCand& exportedTrackCand = m_recoTrack->createGenfitTrackCand();
261 
262  ASSERT_EQ(exportedTrackCand.getNHits(), m_recoTrack->getNumberOfTotalHits());
263  ASSERT_EQ(m_recoTrack->getNumberOfTotalHits(), 3);
264 
265  RecoTrack* recoTrackFromGenfit = RecoTrack::createFromTrackCand(exportedTrackCand, m_storeArrayNameOfRecoTracks,
266  m_storeArrayNameOfCDCHits, m_storeArrayNameOfSVDHits,
267  m_storeArrayNameOfPXDHits, m_storeArrayNameOfBKLMHits,
268  m_storeArrayNameOfEKLMHits,
269  m_storeArrayNameOfHitInformation);
270 
271  B2INFO("kjh");
272 
273  ASSERT_EQ(recoTrackFromGenfit->getNumberOfCDCHits(), m_recoTrack->getNumberOfCDCHits());
274  const auto& cdcHitListOne = recoTrackFromGenfit->getCDCHitList();
275  const auto& cdcHitListTwo = m_recoTrack->getCDCHitList();
276  ASSERT_EQ(cdcHitListOne.size(), 3);
277  ASSERT_EQ(cdcHitListTwo.size(), 3);
278  }
279 
281  TEST_F(RecoTrackTest, copyRecoTrack)
282  {
283  StoreArray<CDCHit> cdcHits(m_storeArrayNameOfCDCHits);
284 
285  // Add three cdc hits to the track
286  m_recoTrack->addCDCHit(cdcHits[0], 1);
287  m_recoTrack->addCDCHit(cdcHits[1], 0, RecoHitInformation::RightLeftInformation::c_right);
288  m_recoTrack->addCDCHit(cdcHits[2], 2);
289 
290  // create a second RecoTrack
291  StoreArray<RecoTrack> recoTracks(m_storeArrayNameOfRecoTracks);
292 
293  auto recoTrack = recoTracks.appendNew(m_recoTrack->getPositionSeed(), m_recoTrack->getMomentumSeed(), m_recoTrack->getChargeSeed(),
294  m_storeArrayNameOfCDCHits, m_storeArrayNameOfSVDHits, m_storeArrayNameOfPXDHits,
295  m_storeArrayNameOfBKLMHits, m_storeArrayNameOfBKLMHits,
296  m_storeArrayNameOfHitInformation);
297  EXPECT_FALSE(recoTrack->hasCDCHits());
298 
299  // check if the offset computation of the hit order works as expected
300  size_t offset = 3;
301  recoTrack->addHitsFromRecoTrack(m_recoTrack, offset);
302  ASSERT_EQ(recoTrack->getNumberOfCDCHits(), 3);
303 
304  size_t this_i = offset;
305  for (auto pHit : recoTrack->getSortedCDCHitList()) {
306  auto sortParam = recoTrack->getSortingParameter(pHit);
307  ASSERT_EQ(this_i, sortParam);
308  this_i++;
309  }
310  }
311 
313  TEST_F(RecoTrackTest, recoHitInformations)
314  {
315  StoreArray<CDCHit> cdcHits(m_storeArrayNameOfCDCHits);
316 
317  m_recoTrack->addCDCHit(cdcHits[0], 1);
318 
319  // create a second RecoTrack
320  StoreArray<RecoTrack> recoTracks(m_storeArrayNameOfRecoTracks);
321 
322  RecoTrack* recoTrack2 = recoTracks.appendNew(m_recoTrack->getPositionSeed(), m_recoTrack->getMomentumSeed(),
323  m_recoTrack->getChargeSeed(),
324  m_storeArrayNameOfCDCHits, m_storeArrayNameOfSVDHits, m_storeArrayNameOfPXDHits,
325  m_storeArrayNameOfBKLMHits, m_storeArrayNameOfBKLMHits,
326  m_storeArrayNameOfHitInformation);
327  recoTrack2->addCDCHit(cdcHits[1], 2);
328 
329  ASSERT_EQ(m_recoTrack->getRecoHitInformations().size(), 1);
330  ASSERT_EQ(m_recoTrack->getRecoHitInformations()[0]->getSortingParameter(), 1);
331  ASSERT_EQ(recoTrack2->getRecoHitInformations().size(), 1);
332  ASSERT_EQ(recoTrack2->getRecoHitInformations()[0]->getSortingParameter(), 2);
333  }
335 }
Belle2::StoreArray::appendNew
T * appendNew()
Construct a new T object at the end of the array.
Definition: StoreArray.h:256
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:168
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:150
Belle2::RecoHitInformation::getTrackingDetector
RecoHitDetector getTrackingDetector() const
Get the detector this hit comes from.
Definition: RecoHitInformation.h:248
Belle2::RecoTrackTest::SetUp
void SetUp() override
Setup a "working environment" with store arrays for the hits and the correct relations.
Definition: recoTrack.cc:31
genfit::TrackCand
Track candidate – seed values and indices.
Definition: TrackCand.h:69
Belle2::RecoTrackTest::m_storeArrayNameOfPXDHits
std::string m_storeArrayNameOfPXDHits
name of storeArray with PXD hits
Definition: recoTrack.cc:99
Belle2::RecoTrackTest::m_recoTrack2
RecoTrack * m_recoTrack2
pointer to other recoTrack
Definition: recoTrack.cc:95
Belle2::CDCHit
Class containing the result of the unpacker in raw data and the result of the digitizer in simulation...
Definition: CDCHit.h:51
Belle2::RecoTrack::getCDCHitList
std::vector< Belle2::RecoTrack::UsedCDCHit * > getCDCHitList() const
Return an unsorted list of cdc hits.
Definition: RecoTrack.h:446
Belle2::RecoHitInformation::getRightLeftInformation
RightLeftInformation getRightLeftInformation() const
Get the right-left-information.
Definition: RecoHitInformation.h:236
Belle2::RecoTrackTest::m_storeArrayNameOfHitInformation
std::string m_storeArrayNameOfHitInformation
name of storeArray with hit information
Definition: recoTrack.cc:102
Belle2::TEST_F
TEST_F(RecoTrackTest, recoHitInformations)
Test the getRecoHitInformations() function.
Definition: recoTrack.cc:313
Belle2::RecoTrackTest
Test class for the RecoTrack object.
Definition: recoTrack.cc:28
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:240
genfit::TrackCand::getPosSeed
TVector3 getPosSeed() const
get the seed value for track: pos.
Definition: TrackCand.h:125
Belle2::RecoTrack
This is the Reconstruction Event-Data Model Track.
Definition: RecoTrack.h:78
Belle2::RecoTrackTest::m_storeArrayNameOfSVDHits
std::string m_storeArrayNameOfSVDHits
name of storeArray with SVD hits
Definition: recoTrack.cc:98
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:19
Belle2::RecoHitInformation
This class stores additional information to every CDC/SVD/PXD hit stored in a RecoTrack.
Definition: RecoHitInformation.h:48
Belle2::RecoTrack::getNumberOfCDCHits
unsigned int getNumberOfCDCHits() const
Return the number of cdc hits.
Definition: RecoTrack.h:417
Belle2::RecoTrack::getRecoHitInformations
std::vector< RecoHitInformation * > getRecoHitInformations(bool getSorted=false) const
Return a list of all RecoHitInformations associated with the RecoTrack.
Definition: RecoTrack.cc:531
Belle2::RecoTrackTest::m_storeArrayNameOfRecoTracks
std::string m_storeArrayNameOfRecoTracks
name of recoTracks storeArray
Definition: recoTrack.cc:96
Belle2::RecoHitInformation::getSortingParameter
unsigned int getSortingParameter() const
Get the sorting parameter.
Definition: RecoHitInformation.h:224
Belle2::StoreArray
Accessor to arrays stored in the data store.
Definition: ECLMatchingPerformanceExpertModule.h:33
Belle2::RecoTrackTest::m_storeArrayNameOfBKLMHits
std::string m_storeArrayNameOfBKLMHits
name of storeArray with BKLM hits
Definition: recoTrack.cc:100
Belle2::RecoHitInformation::getFoundByTrackFinder
OriginTrackFinder getFoundByTrackFinder() const
Get which track finder has found the track.
Definition: RecoHitInformation.h:212
genfit::TrackCand::setPosMomSeed
void setPosMomSeed(const TVector3 &pos, const TVector3 &mom, const double charge)
sets the state to seed the track fitting.
Definition: TrackCand.cc:258
Belle2::RecoTrackTest::m_storeArrayNameOfEKLMHits
std::string m_storeArrayNameOfEKLMHits
name of storeArray with EKLM hits
Definition: recoTrack.cc:101
genfit::WireTrackCandHit
Hit object for use in TrackCand.
Definition: WireTrackCandHit.h:34
genfit::TrackCand::getMomSeed
TVector3 getMomSeed() const
get the seed value for track: mom.
Definition: TrackCand.h:128
Belle2::RecoTrackTest::m_recoTrack
RecoTrack * m_recoTrack
pointer to recoTrack
Definition: recoTrack.cc:94
Belle2::RecoTrackTest::m_storeArrayNameOfCDCHits
std::string m_storeArrayNameOfCDCHits
name of storeArray with CDC hits
Definition: recoTrack.cc:97