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