Belle II Software  release-08-01-10
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 
24 using namespace Belle2;
25 using namespace TrackFindingCDC;
26 using namespace PerigeeBinSpec;
27 
28 namespace {
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 
118 namespace {
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 comparision 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 
193 namespace {
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 
310 namespace {
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 comparision 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 comparision 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
Constuct the array of discrete curv 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 Attributre 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
Constuct 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::TEST_F
TEST_F(GlobalLabelTest, LargeNumberOfTimeDependentParameters)
Test large number of time-dep params for registration and retrieval.
Definition: globalLabel.cc:72
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