Belle II Software development
Phi0Curv.test.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#include <tracking/trackFindingCDC/testFixtures/TrackFindingCDCTestWithSimpleSimulation.h>
9
10#include <tracking/trackFindingCDC/hough/perigee/AxialLegendreLeafProcessor.h>
11#include <tracking/trackFindingCDC/hough/perigee/AxialLegendreLeafProcessor.icc.h>
12
13#include <tracking/trackFindingCDC/hough/perigee/SimpleRLTaggedWireHitHoughTree.h>
14#include <tracking/trackFindingCDC/hough/perigee/SimpleSegmentHoughTree.h>
15#include <tracking/trackFindingCDC/hough/perigee/StandardBinSpec.h>
16
17#include <tracking/trackFindingCDC/hough/algorithms/InPhi0CurvBox.h>
18
19#include <framework/core/ModuleParamList.templateDetails.h>
20#include <framework/core/ModuleParam.h>
21
22#include <vector>
23
24using namespace Belle2;
25using namespace TrackFindingCDC;
26using namespace PerigeeBinSpec;
27
28namespace {
29 TEST_F(TrackFindingCDCTestWithSimpleSimulation, hough_perigee_phi0_curv_hits)
30 {
31 std::string svgFileName = "phi0_curv_on_hits.svg";
32
33 Helix lowerCurvOriginHelix(0.015, 2.52033, 0, 1, 0);
34 Helix higherCurvOriginHelix(0.027, 3.0718, 0, 0, 0);
35
36 // Helix lowerCurvOriginHelix(0.012, 1.4, 0, 1, 0);
37 // Helix higherCurvOriginHelix(0.027, 3.0718, 0, 0.95, 0);
38
39 simulate({lowerCurvOriginHelix, higherCurvOriginHelix});
40 saveDisplay(svgFileName);
41
42 using SimpleRLTaggedWireHitPhi0CurvHough =
43 SimpleRLTaggedWireHitHoughTree<InPhi0CurvBox, phi0Divisions, curvDivisions>;
44 SimpleRLTaggedWireHitPhi0CurvHough houghTree(maxLevel);
45 using HoughBox = SimpleRLTaggedWireHitPhi0CurvHough::HoughBox;
46
47 const double minWeight = 30.0;
48
49 houghTree.assignArray<DiscretePhi0>(phi0BinsSpec.constructArray(), phi0BinsSpec.getNOverlap());
50 houghTree.assignArray<DiscreteCurv>(curvBinsSpec.constructArray(), curvBinsSpec.getNOverlap());
51 houghTree.initialize();
52
53
54 // Execute the finding a couple of time to find a stable execution time.
55 std::vector< std::pair<HoughBox, std::vector<CDCRLWireHit> > > candidates;
56
57 // Is this still C++? Looks like JavaScript to me :-).
58 TimeItResult timeItResult = timeIt(100, true, [&]() {
59 houghTree.fell();
60 houghTree.seed(m_axialWireHits);
61
62 candidates = houghTree.find(minWeight, maxCurvAcceptance);
63 // candidates = houghTree.findBest(minWeight, maxCurvAcceptance);
64
65 ASSERT_EQ(m_mcTracks.size(), candidates.size());
66 // Check for the parameters of the track candidates
67 // The actual hit numbers are more than 30, but this is somewhat a lower bound
68 for (size_t iCand = 0; iCand < candidates.size(); ++iCand) {
69 EXPECT_GE(candidates[iCand].second.size(), 30);
70 }
71 });
72
74 std::size_t nNodes = houghTree.getTree()->getNNodes();
75 B2DEBUG(100, "Tree generated " << nNodes << " nodes");
76 houghTree.fell();
77 houghTree.raze();
78
79 size_t iColor = 0;
80 for (std::pair<HoughBox, std::vector<CDCRLWireHit> >& candidate : candidates) {
81 const HoughBox& houghBox = candidate.first;
82 const std::vector<CDCRLWireHit>& taggedHits = candidate.second;
83
84 B2DEBUG(100, "Candidate");
85 B2DEBUG(100, "size " << taggedHits.size());
86 B2DEBUG(100, "Phi0 " << houghBox.getLowerBound<DiscretePhi0>()->phi());
87 B2DEBUG(100, "Curv " << houghBox.getLowerBound<DiscreteCurv>());
88 B2DEBUG(100, "Tags of the hits");
89
90 B2DEBUG(100, "Tags of the hits");
91 for (const CDCRLWireHit& rlTaggedWireHit : taggedHits) {
92 B2DEBUG(100, " " <<
93 "rl = " << static_cast<int>(rlTaggedWireHit.getRLInfo()) << " " <<
94 "dl = " << rlTaggedWireHit.getRefDriftLength());
95 }
96
97 for (const CDCRLWireHit& rlTaggedWireHit : taggedHits) {
98 const CDCWireHit& wireHit = rlTaggedWireHit.getWireHit();
99 std::string color = "blue";
100 if (rlTaggedWireHit.getRLInfo() == ERightLeft::c_Right) {
101 color = "green";
102 } else if (rlTaggedWireHit.getRLInfo() == ERightLeft::c_Left) {
103 color = "red";
104 }
105 //EventDataPlotter::AttributeMap strokeAttr {{"stroke", color}};
106 EventDataPlotter::AttributeMap strokeAttr {{"stroke", m_colors[iColor % m_colors.size()] }};
107 draw(wireHit, strokeAttr);
108 }
109 ++iColor;
110 }
111
112 saveDisplay(svgFileName);
113
114 timeItResult.printSummary();
115 }
116}
117
118namespace {
119 TEST_F(TrackFindingCDCTestWithSimpleSimulation, hough_perigee_phi0_curv_on_segments)
120 {
121 std::string svgFileName = "phi0_curv_on_segments.svg";
122
123 Helix lowerCurvOriginHelix(0.015, 2.52033, 0, 1, 0);
124 Helix higherCurvOriginHelix(0.027, 3.0718, 0, 0, 0);
125
126 // Helix lowerCurvOriginHelix(0.012, 1.4, 0, 1, 0);
127 // Helix higherCurvOriginHelix(0.027, 3.0718, 0, 0.95, 0);
128
129 simulate({lowerCurvOriginHelix, higherCurvOriginHelix});
130 saveDisplay(svgFileName);
131
132 using SimpleSegmentPhi0CurvHoughTree =
133 SimpleSegmentHoughTree<InPhi0CurvBox, phi0Divisions, curvDivisions>;
134 SimpleSegmentPhi0CurvHoughTree houghTree(maxLevel);
135 using HoughBox = SimpleSegmentPhi0CurvHoughTree::HoughBox;
136
137 const double minWeight = 30.0;
138
139 houghTree.assignArray<DiscretePhi0>(phi0BinsSpec.constructArray(), phi0BinsSpec.getNOverlap());
140 houghTree.assignArray<DiscreteCurv>(curvBinsSpec.constructArray(), curvBinsSpec.getNOverlap());
141 houghTree.initialize();
142
143 // Execute the finding a couple of time to find a stable execution time.
144 std::vector< std::pair<HoughBox, std::vector<const CDCSegment2D*> > > candidates;
145
146 // Is this still C++? Looks like JavaScript to me :-).
147 TimeItResult timeItResult = timeIt(100, true, [&]() {
148 // Exclude the timing of the resource release for comparison with the Legendre test.
149 houghTree.fell();
150
151 houghTree.seed(m_mcAxialSegment2Ds);
152
153 candidates = houghTree.find(minWeight, maxCurvAcceptance);
154 // candidates = houghTree.findBest(minWeight, maxCurvAcceptance);
155
156 ASSERT_EQ(m_mcTracks.size(), candidates.size());
157
158 // Check for the parameters of the track candidates
159 // The actual hit numbers are more than 4 segment, but this is somewhat a lower bound
160 for (size_t iCand = 0; iCand < candidates.size(); ++iCand) {
161 EXPECT_GE(candidates[iCand].second.size(), 4);
162 }
163 });
164
166 std::size_t nNodes = houghTree.getTree()->getNNodes();
167 B2INFO("Tree generated " << nNodes << " nodes");
168 houghTree.fell();
169 houghTree.raze();
170
171 size_t iColor = 0;
172 for (std::pair<HoughBox, std::vector<const CDCSegment2D*> >& candidate : candidates) {
173 const HoughBox& houghBox = candidate.first;
174 const std::vector<const CDCSegment2D*>& segments = candidate.second;
175
176 B2DEBUG(100, "Candidate");
177 B2DEBUG(100, "size " << segments.size());
178 B2DEBUG(100, "Phi0 " << houghBox.getLowerBound<DiscretePhi0>()->phi());
179 B2DEBUG(100, "Curv " << houghBox.getLowerBound<DiscreteCurv>());
180
181 for (const CDCSegment2D* segment2D : segments) {
182 EventDataPlotter::AttributeMap strokeAttr {{"stroke", m_colors[iColor % m_colors.size()] }};
183 draw(*segment2D, strokeAttr);
184 }
185 ++iColor;
186 }
187 saveDisplay(svgFileName);
188 timeItResult.printSummary();
189 }
190}
191
192
193namespace {
194 TEST_F(TrackFindingCDCTestWithSimpleSimulation, hough_perigee_phi0_curv_hits_using_leaf_processing)
195 {
196 std::string svgFileName = "phi0_curv_on_hits.svg";
197
198 Helix zeroCurvOriginHelix(0.000, 1.52033, 0, -0.5, 0);
199 Helix lowerCurvOriginHelix(0.015, 2.52033, 0, 1, 0);
200 Helix higherCurvOriginHelix(0.027, 3.0718, 3, 0, 0);
201
202 // Helix lowerCurvOriginHelix(0.012, 1.4, 0, 1, 0);
203 // Helix higherCurvOriginHelix(0.027, 3.0718, 0, 0.95, 0);
204
205 simulate({zeroCurvOriginHelix, lowerCurvOriginHelix, higherCurvOriginHelix});
206 saveDisplay(svgFileName);
207
208 using SimpleRLTaggedWireHitPhi0CurvHough =
209 SimpleRLTaggedWireHitHoughTree<InPhi0CurvBox, phi0Divisions, curvDivisions>;
210 SimpleRLTaggedWireHitPhi0CurvHough houghTree(maxLevel, curlCurv);
211
212 houghTree.assignArray<DiscretePhi0>(phi0BinsSpec.constructArray(), phi0BinsSpec.getNOverlap());
213 houghTree.assignArray<DiscreteCurv>(curvBinsSpec.constructArray(), curvBinsSpec.getNOverlap());
214 houghTree.initialize();
215
216 const double minWeight = 30.0;
217 using Node = typename SimpleRLTaggedWireHitPhi0CurvHough::Node;
218 AxialLegendreLeafProcessor<Node> leafProcessor(maxLevel);
219
220 ModuleParamList moduleParamList;
221 const std::string prefix = "";
222 leafProcessor.exposeParameters(&moduleParamList, prefix);
223 moduleParamList.getParameter<double>("minWeight").setDefaultValue(minWeight);
224 moduleParamList.getParameter<double>("maxCurv").setDefaultValue(maxCurvAcceptance);
225
226 // Execute the finding a couple of time to find a stable execution time.
227 std::vector< std::pair<CDCTrajectory2D, std::vector<CDCRLWireHit> > > candidates;
228
229 // Is this still C++? Looks like JavaScript to me :-).
230 TimeItResult timeItResult = this->timeIt(100, true, [&]() {
231 houghTree.fell();
232
233 for (const CDCWireHit* wireHit : m_axialWireHits) {
234 AutomatonCell& automatonCell = wireHit->getAutomatonCell();
235 automatonCell.unsetTakenFlag();
236 automatonCell.unsetTemporaryFlags();
237 }
238
239 houghTree.seed(m_axialWireHits);
240
241 leafProcessor.clear();
242
243 // Make two passes - one with more restrictive curvature
244 moduleParamList.getParameter<double>("maxCurv").setDefaultValue(curlCurv);
245 moduleParamList.getParameter<int>("nRoadSearches").setDefaultValue(2);
246 moduleParamList.getParameter<int>("roadLevel").setDefaultValue(4);
247 leafProcessor.beginWalk();
248 houghTree.findUsing(leafProcessor);
249
250 moduleParamList.getParameter<double>("maxCurv").setDefaultValue(maxCurvAcceptance);
251 moduleParamList.getParameter<int>("nRoadSearches").setDefaultValue(3);
252 moduleParamList.getParameter<int>("roadLevel").setDefaultValue(0);
253 leafProcessor.beginWalk();
254 houghTree.findUsing(leafProcessor);
255
256 candidates = leafProcessor.getCandidates();
257
258 ASSERT_EQ(m_mcTracks.size(), candidates.size());
259 // Check for the parameters of the track candidates
260 // The actual hit numbers are more than 30, but this is somewhat a lower bound
261 for (size_t iCand = 0; iCand < candidates.size(); ++iCand) {
262 EXPECT_GE(candidates[iCand].second.size(), 30);
263 }
264 });
265
267 std::size_t nNodes = houghTree.getTree()->getNNodes();
268 B2DEBUG(100, "Tree generated " << nNodes << " nodes");
269 houghTree.fell();
270 houghTree.raze();
271
272 size_t iColor = 0;
273 for (std::pair<CDCTrajectory2D, std::vector<CDCRLWireHit> >& candidate : candidates) {
274 const CDCTrajectory2D& trajectory2D = candidate.first;
275 const std::vector<CDCRLWireHit >& taggedHits = candidate.second;
276
277 B2DEBUG(100, "Candidate");
278 B2DEBUG(100, "size " << taggedHits.size());
279 B2DEBUG(100, "Impact " << trajectory2D.getGlobalCircle().impact());
280 B2DEBUG(100, "Phi0 " << trajectory2D.getGlobalCircle().phi0());
281 B2DEBUG(100, "Curv " << trajectory2D.getCurvature());
282 B2DEBUG(100, "Support " << trajectory2D.getSupport());
283 B2DEBUG(100, "Tags of the hits");
284
285 for (const CDCRLWireHit& rlTaggedWireHit : taggedHits) {
286 B2DEBUG(100, " rl = " << static_cast<int>(rlTaggedWireHit.getRLInfo()) <<
287 " dl = " << rlTaggedWireHit.getRefDriftLength());
288 }
289
290 for (const CDCRLWireHit& rlTaggedWireHit : taggedHits) {
291 const CDCWireHit wireHit = rlTaggedWireHit.getWireHit();
292 std::string color = "blue";
293 if (rlTaggedWireHit.getRLInfo() == ERightLeft::c_Right) {
294 color = "green";
295 } else if (rlTaggedWireHit.getRLInfo() == ERightLeft::c_Left) {
296 color = "red";
297 }
298 //EventDataPlotter::AttributeMap strokeAttr {{"stroke", color}};
299 EventDataPlotter::AttributeMap strokeAttr {{"stroke", m_colors[iColor % m_colors.size()] }};
300 draw(wireHit, strokeAttr);
301 }
302 draw(trajectory2D);
303 ++iColor;
304 }
305 saveDisplay(svgFileName);
306 timeItResult.printSummary();
307 }
308}
309
310namespace {
311 TEST_F(TrackFindingCDCTestWithSimpleSimulation, hough_perigee_phi0_curv_prepared_event_hits_using_leaf_processing)
312 {
313 std::string svgFileName = "phi0_curv_on_prepared_event_hits_using_leaf_processing.svg";
314 loadPreparedEvent();
315 saveDisplay(svgFileName);
316
317 // Prepare the hough algorithm
318 using SimpleRLTaggedWireHitPhi0CurvHough =
319 SimpleRLTaggedWireHitHoughTree<InPhi0CurvBox, phi0Divisions, curvDivisions>;
320 SimpleRLTaggedWireHitPhi0CurvHough houghTree(maxLevel, curlCurv);
321
322 houghTree.assignArray<DiscretePhi0>(phi0BinsSpec.constructArray(), phi0BinsSpec.getNOverlap());
323 houghTree.assignArray<DiscreteCurv>(curvBinsSpec.constructArray(), curvBinsSpec.getNOverlap());
324 houghTree.initialize();
325
326 const double minWeight = 30.0;
327 using Node = typename SimpleRLTaggedWireHitPhi0CurvHough::Node;
328 AxialLegendreLeafProcessor<Node> leafProcessor(maxLevel);
329
330 ModuleParamList moduleParamList;
331 const std::string prefix = "";
332 leafProcessor.exposeParameters(&moduleParamList, prefix);
333 moduleParamList.getParameter<double>("minWeight").setDefaultValue(minWeight);
334 moduleParamList.getParameter<double>("maxCurv").setDefaultValue(maxCurvAcceptance);
335
336 // Execute the finding a couple of time to find a stable execution time.
337 std::vector< std::pair<CDCTrajectory2D, std::vector<CDCRLWireHit> > > candidates;
338
339 // Is this still C++? Looks like JavaScript to me :-).
340 TimeItResult timeItResult = timeIt(100, true, [&]() {
341 // Exclude the timing of the resource release for comparison with the Legendre test.
342 houghTree.fell();
343
344 for (const CDCWireHit* wireHit : m_axialWireHits) {
345 AutomatonCell& automatonCell = wireHit->getAutomatonCell();
346 automatonCell.unsetTakenFlag();
347 automatonCell.unsetTemporaryFlags();
348 }
349
350 houghTree.seed(m_axialWireHits);
351
352 leafProcessor.clear();
353
354 // Make two passes - one with more restrictive curvature
355 moduleParamList.getParameter<double>("maxCurv").setDefaultValue(curlCurv);
356 moduleParamList.getParameter<int>("nRoadSearches").setDefaultValue(2);
357 moduleParamList.getParameter<int>("roadLevel").setDefaultValue(4);
358 leafProcessor.beginWalk();
359 houghTree.findUsing(leafProcessor);
360
361 moduleParamList.getParameter<double>("maxCurv").setDefaultValue(maxCurvAcceptance);
362 moduleParamList.getParameter<int>("nRoadSearches").setDefaultValue(3);
363 moduleParamList.getParameter<int>("roadLevel").setDefaultValue(0);
364 leafProcessor.beginWalk();
365 houghTree.findUsing(leafProcessor);
366
367 candidates = leafProcessor.getCandidates();
368
369 ASSERT_EQ(m_mcTracks.size(), candidates.size());
370 // Check for the parameters of the track candidates
371 // The actual hit numbers are more than 30, but this is somewhat a lower bound
372 for (size_t iCand = 0; iCand < candidates.size(); ++iCand) {
373 EXPECT_GE(candidates[iCand].second.size(), 30);
374 }
375 });
376
378 std::size_t nNodes = houghTree.getTree()->getNNodes();
379 B2DEBUG(100, "Tree generated " << nNodes << " nodes");
380 houghTree.fell();
381 houghTree.raze();
382
383 size_t iColor = 0;
384 for (std::pair<CDCTrajectory2D, std::vector<CDCRLWireHit> >& candidate : candidates) {
385 const CDCTrajectory2D& trajectory2D = candidate.first;
386 const std::vector<CDCRLWireHit >& taggedHits = candidate.second;
387
388 B2DEBUG(100, "Candidate");
389 B2DEBUG(100, "size " << taggedHits.size());
390 B2DEBUG(100, "Impact " << trajectory2D.getGlobalCircle().impact());
391 B2DEBUG(100, "Phi0 " << trajectory2D.getGlobalCircle().phi0());
392 B2DEBUG(100, "Curv " << trajectory2D.getCurvature());
393 B2DEBUG(100, "Support " << trajectory2D.getSupport());
394 B2DEBUG(100, "Tags of the hits");
395
396 for (const CDCRLWireHit& rlTaggedWireHit : taggedHits) {
397 B2DEBUG(100, " rl = " << static_cast<int>(rlTaggedWireHit.getRLInfo()) <<
398 " dl = " << rlTaggedWireHit.getRefDriftLength());
399 }
400
401 for (const CDCRLWireHit& rlTaggedWireHit : taggedHits) {
402 const CDCWireHit wireHit = rlTaggedWireHit.getWireHit();
403 std::string color = "blue";
404 if (rlTaggedWireHit.getRLInfo() == ERightLeft::c_Right) {
405 color = "green";
406 } else if (rlTaggedWireHit.getRLInfo() == ERightLeft::c_Left) {
407 color = "red";
408 }
409 //EventDataPlotter::AttributeMap strokeAttr {{"stroke", color}};
410 EventDataPlotter::AttributeMap strokeAttr {{"stroke", m_colors[iColor % m_colors.size()] }};
411 draw(wireHit, strokeAttr);
412 }
413 draw(trajectory2D);
414 ++iColor;
415 }
416 saveDisplay(svgFileName);
417 timeItResult.printSummary();
418 }
419
420 // cppcheck-suppress syntaxError
421 TEST_F(TrackFindingCDCTestWithSimpleSimulation, hough_perigee_phi0_curv_prepared_event_hits)
422 {
423 std::string svgFileName = "phi0_curv_on_prepared_event_hits.svg";
424 loadPreparedEvent();
425 saveDisplay(svgFileName);
426
427 using RLTaggedWireHitPhi0CurvHough = SimpleRLTaggedWireHitHoughTree<InPhi0CurvBox, phi0Divisions, curvDivisions>;
428 using Phi0CurvBox = RLTaggedWireHitPhi0CurvHough::HoughBox;
429 RLTaggedWireHitPhi0CurvHough houghTree(maxLevel);
430
431 houghTree.assignArray<DiscretePhi0>(phi0BinsSpec.constructArray(),
432 phi0BinsSpec.getNOverlap());
433
434 houghTree.assignArray<DiscreteCurv>(curvBinsSpec.constructArray(),
435 curvBinsSpec.getNOverlap());
436
437 houghTree.initialize();
438 const double minWeight = 30.0;
439
440 // Execute the finding a couple of time to find a stable execution time.
441 std::vector< std::pair<Phi0CurvBox, std::vector<CDCRLWireHit> > > candidates;
442
443 // Is this still C++? Looks like JavaScript to me :-).
444 TimeItResult timeItResult = timeIt(100, true, [&]() {
445 // Exclude the timing of the resource release for comparison with the Legendre test.
446 houghTree.fell();
447 houghTree.seed(m_axialWireHits);
448
449 candidates = houghTree.find(minWeight, maxCurvAcceptance);
450 //candidates = houghTree.findBest(minWeight, maxCurvAcceptance);
451
452 ASSERT_EQ(m_mcTracks.size(), candidates.size());
453 // Check for the parameters of the track candidates
454 // The actual hit numbers are more than 30, but this is somewhat a lower bound
455 for (size_t iCand = 0; iCand < candidates.size(); ++iCand) {
456 EXPECT_GE(candidates[iCand].second.size(), 30);
457 }
458 });
459
461 std::size_t nNodes = houghTree.getTree()->getNNodes();
462 B2DEBUG(100, "Tree generated " << nNodes << " nodes");
463 houghTree.fell();
464 houghTree.raze();
465
466 size_t iColor = 0;
467 for (std::pair<Phi0CurvBox, std::vector<CDCRLWireHit> >& candidate : candidates) {
468 const Phi0CurvBox& phi0CurvBox = candidate.first;
469 const std::vector<CDCRLWireHit>& taggedHits = candidate.second;
470
471 B2DEBUG(100, "Candidate");
472 B2DEBUG(100, "size " << taggedHits.size());
473 B2DEBUG(100, "Phi0 " << phi0CurvBox.getLowerBound<DiscretePhi0>()->phi());
474 B2DEBUG(100, "Curv " << phi0CurvBox.getLowerBound<DiscreteCurv>());
475 B2DEBUG(100, "Tags of the hits");
476
477 for (const CDCRLWireHit& rlTaggedWireHit : taggedHits) {
478 B2DEBUG(100, " rl = " << static_cast<int>(rlTaggedWireHit.getRLInfo()) <<
479 " dl = " << rlTaggedWireHit.getRefDriftLength());
480 }
481
482 for (const CDCRLWireHit& rlTaggedWireHit : taggedHits) {
483 const CDCWireHit& wireHit = rlTaggedWireHit.getWireHit();
484 std::string color = "blue";
485 if (rlTaggedWireHit.getRLInfo() == ERightLeft::c_Right) {
486 color = "green";
487 } else if (rlTaggedWireHit.getRLInfo() == ERightLeft::c_Left) {
488 color = "red";
489 }
490 //EventDataPlotter::AttributeMap strokeAttr {{"stroke", color}};
491 EventDataPlotter::AttributeMap strokeAttr {{"stroke", m_colors[iColor % m_colors.size()] }};
492 draw(wireHit, strokeAttr);
493 }
494 ++iColor;
495 }
496 saveDisplay(svgFileName);
497 timeItResult.printSummary();
498 }
499}
Belle2::CDC::Helix
Helix parameter class.
Definition: Helix.h:48
Belle2::ModuleParamList
The Module parameter list class.
Definition: ModuleParamList.h:44
Belle2::TrackFindingCDC::AutomatonCell
Cell used by the cellular automata.
Definition: AutomatonCell.h:29
Belle2::TrackFindingCDC::AutomatonCell::unsetTemporaryFlags
void unsetTemporaryFlags()
Resets the assigned, start and cycle marker flag.
Definition: AutomatonCell.h:200
Belle2::TrackFindingCDC::AutomatonCell::unsetTakenFlag
void unsetTakenFlag()
Resets the taken flag to false.
Definition: AutomatonCell.h:230
Belle2::TrackFindingCDC::AxialLegendreLeafProcessor
Predicate class that is feed the nodes in a WeightedHoughTree walk It decides if a node should be fur...
Definition: AxialLegendreLeafProcessor.h:36
Belle2::TrackFindingCDC::CDCRLWireHit
Class representing an oriented hit wire including a hypotheses whether the causing track passes left ...
Definition: CDCRLWireHit.h:41
Belle2::TrackFindingCDC::CDCSegment2D
A reconstructed sequence of two dimensional hits in one super layer.
Definition: CDCSegment2D.h:39
Belle2::TrackFindingCDC::CDCTrajectory2D
Particle trajectory as it is seen in xy projection represented as a circle.
Definition: CDCTrajectory2D.h:36
Belle2::TrackFindingCDC::CDCTrajectory2D::getGlobalCircle
PerigeeCircle getGlobalCircle() const
Getter for the circle in global coordinates.
Definition: CDCTrajectory2D.h:441
Belle2::TrackFindingCDC::CDCTrajectory2D::getSupport
Vector2D getSupport() const
Get the support point of the trajectory in global coordinates.
Definition: CDCTrajectory2D.h:335
Belle2::TrackFindingCDC::CDCTrajectory2D::getCurvature
double getCurvature() const
Getter for the curvature as seen from the xy projection.
Definition: CDCTrajectory2D.h:422
Belle2::TrackFindingCDC::CDCWireHit
Class representing a hit wire in the central drift chamber.
Definition: CDCWireHit.h:55
Belle2::TrackFindingCDC::CurvBinsSpec::constructArray
DiscreteCurv::Array constructArray() const
Construct the array of discrete curve positions.
Definition: CurvRep.h:40
Belle2::TrackFindingCDC::CurvBinsSpec::getNOverlap
int getNOverlap() const
Getter for the overlap in discrete number of positions.
Definition: CurvRep.h:68
Belle2::TrackFindingCDC::DiscreteValue
Representation for a discrete position in an array of discrete positions.
Definition: DiscreteValue.h:23
Belle2::TrackFindingCDC::EventDataPlotter::AttributeMap
PrimitivePlotter::AttributeMap AttributeMap
Forward the Attribute map from the primitive plotter.
Definition: EventDataPlotter.h:59
Belle2::TrackFindingCDC::PerigeeCircle::phi0
double phi0() const
Getter for the azimuth angle of the direction of flight at the perigee.
Definition: PerigeeCircle.h:422
Belle2::TrackFindingCDC::PerigeeCircle::impact
double impact() const
Getter for the signed distance of the origin to the circle.
Definition: PerigeeCircle.h:434
Belle2::TrackFindingCDC::Phi0BinsSpec::constructArray
DiscretePhi0::Array constructArray() const
Construct the array of discrete phi0 positions.
Definition: Phi0Rep.cc:23
Belle2::TrackFindingCDC::Phi0BinsSpec::getNOverlap
int getNOverlap() const
Getter for the overlap in discrete number of positions.
Definition: Phi0Rep.h:47
Belle2::TrackFindingCDC::SimpleHitBasedHoughTree
A convenience class based on a BoxDivisionHoughTree for "hit-like" classes.
Definition: SimpleHitBasedHoughTree.h:32
Belle2::TrackFindingCDC::TimeItResult
Class to capture the time a repeated execution took.
Definition: TimeIt.h:29
Belle2::TrackFindingCDC::TimeItResult::printSummary
void printSummary() const
Print a summary of the collected time to the console.
Definition: TimeIt.h:57
Belle2::ModuleParamList::getParameter
ModuleParam< T > & getParameter(const std::string &name) const
Returns a reference to a parameter.
Definition: ModuleParamList.templateDetails.h:80
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:17