Belle II Software  release-05-01-25
CDCTrack.cc
1 /**************************************************************************
2  * BASF2 (Belle Analysis Framework 2) *
3  * Copyright(C) 2012 - Belle II Collaboration *
4  * *
5  * Author: The Belle II Collaboration *
6  * Contributors: Oliver Frost *
7  * *
8  * This software is provided "as is" without any warranty. *
9  **************************************************************************/
10 #include <tracking/trackFindingCDC/eventdata/tracks/CDCTrack.h>
11 
12 #include <tracking/trackFindingCDC/eventdata/tracks/CDCSegmentTriple.h>
13 #include <tracking/trackFindingCDC/eventdata/tracks/CDCSegmentPair.h>
14 #include <tracking/trackFindingCDC/eventdata/segments/CDCSegment3D.h>
15 #include <tracking/trackFindingCDC/eventdata/segments/CDCSegment2D.h>
16 
17 #include <tracking/trackFindingCDC/eventdata/hits/CDCRecoHit3D.h>
18 #include <tracking/trackFindingCDC/eventdata/hits/CDCRecoHit2D.h>
19 #include <tracking/trackFindingCDC/eventdata/hits/CDCWireHit.h>
20 
21 #include <tracking/trackFindingCDC/eventdata/trajectories/CDCTrajectory3D.h>
22 #include <tracking/trackFindingCDC/eventdata/trajectories/CDCTrajectory2D.h>
23 
24 #include <tracking/trackFindingCDC/topology/ISuperLayer.h>
25 
26 #include <tracking/trackFindingCDC/geometry/PerigeeCircle.h>
27 #include <tracking/trackFindingCDC/geometry/UncertainPerigeeCircle.h>
28 #include <tracking/trackFindingCDC/geometry/Vector3D.h>
29 
30 #include <tracking/trackFindingCDC/ca/AutomatonCell.h>
31 
32 #include <tracking/trackFindingCDC/numerics/FloatComparing.h>
33 
34 #include <tracking/trackFindingCDC/utilities/MayBePtr.h>
35 
36 #include <framework/logging/Logger.h>
37 
38 #include <algorithm>
39 #include <utility>
40 #include <cmath>
41 
42 namespace Belle2 {
47  namespace TrackFindingCDC {
48  class CDCRLWireHit;
49  }
51 }
52 
53 using namespace Belle2;
54 using namespace TrackFindingCDC;
55 
56 namespace {
58  void appendReconstructed(const CDCSegment2D* segment,
59  const CDCTrajectory3D& trajectory3D,
60  double perpSOffset,
61  CDCTrack& track)
62  {
63  B2ASSERT("Did not expect segment == nullptr", segment);
64 
65  for (const CDCRecoHit2D& recohit2D : *segment) {
66  track.push_back(CDCRecoHit3D::reconstruct(recohit2D,
67  trajectory3D));
68  track.back().shiftArcLength2D(perpSOffset);
69  }
70  }
71 
72 
85  double appendReconstructedAverage(const CDCSegment2D* segment,
86  const CDCTrajectory3D& trajectory3D,
87  double perpSOffset,
88  const CDCTrajectory3D& parallelTrajectory3D,
89  CDCTrack& track)
90  {
91  B2ASSERT("Did not expect segment == nullptr", segment);
92 
93  const CDCRecoHit2D& firstRecoHit2D = segment->front();
94 
95  CDCRecoHit3D firstRecoHit3D =
96  CDCRecoHit3D::reconstruct(firstRecoHit2D, trajectory3D);
97 
98  double firstPerpS = firstRecoHit3D.getArcLength2D();
99 
100  CDCRecoHit3D parallelFirstRecoHit3D =
101  CDCRecoHit3D::reconstruct(firstRecoHit2D, parallelTrajectory3D);
102 
103  double parallelFirstPerpS = parallelFirstRecoHit3D.getArcLength2D();
104 
105  double parallelPerpSOffSet = firstPerpS + perpSOffset - parallelFirstPerpS;
106 
107  for (const CDCRecoHit2D& recoHit2D : *segment) {
108 
109  CDCRecoHit3D recoHit3D =
110  CDCRecoHit3D::reconstruct(recoHit2D, trajectory3D);
111 
112  recoHit3D.shiftArcLength2D(perpSOffset);
113 
114 
115  CDCRecoHit3D parallelRecoHit3D =
116  CDCRecoHit3D::reconstruct(recoHit2D, parallelTrajectory3D);
117 
118  parallelRecoHit3D.shiftArcLength2D(parallelPerpSOffSet);
119 
120  track.push_back(CDCRecoHit3D::average(recoHit3D, parallelRecoHit3D));
121 
122  }
123 
124  const CDCRecoHit2D& lastRecoHit2D = segment->back() ;
125 
126  CDCRecoHit3D parallelLastRecoHit3D =
127  CDCRecoHit3D::reconstruct(lastRecoHit2D, parallelTrajectory3D);
128 
129  double newPrepSOffset = track.back().getArcLength2D() - parallelLastRecoHit3D.getArcLength2D();
130 
131  return newPrepSOffset;
132  }
133 }
134 
135 CDCTrack::CDCTrack(const std::vector<CDCRecoHit3D>& recoHits3D)
136  : std::vector<CDCRecoHit3D>(recoHits3D)
137 {
138 }
139 
141  m_startTrajectory3D(segment.getTrajectory2D()),
142  m_endTrajectory3D(segment.getTrajectory2D())
143 {
144  if (segment.empty()) return;
145 
146  // Adjust the start point
147  const CDCRecoHit2D& startRecoHit2D = segment.front();
148  const CDCRecoHit2D& endRecoHit2D = segment.back();
149 
150  Vector3D startPos3D(startRecoHit2D.getRecoPos2D(), 0.0);
151  Vector3D endPos3D(endRecoHit2D.getRecoPos2D(), 0.0);
152 
155 
156  for (const CDCRecoHit2D& recoHit2D : segment) {
157  const CDCRLWireHit& rlWireHit = recoHit2D.getRLWireHit();
158  Vector3D recoPos3D(recoHit2D.getRecoPos2D(), 0.0);
159  double perpS = m_startTrajectory3D.calcArcLength2D(recoPos3D);
160  push_back(CDCRecoHit3D(rlWireHit, recoPos3D, perpS));
161  }
162 
163  // TODO: Maybe enhance the estimation of the z coordinate with the superlayer slopes.
164 }
165 
166 CDCTrack CDCTrack::condense(const std::vector<const CDCTrack*>& trackPath)
167 {
168  if (trackPath.empty()) {
169  return CDCTrack();
170  } else if (trackPath.size() == 1) {
171  return CDCTrack(*(trackPath[0]));
172  } else {
173  CDCTrack result;
174  for (const CDCTrack* track : trackPath) {
175  for (const CDCRecoHit3D& recoHit3D : *track) {
176  result.push_back(recoHit3D);
178  }
179  }
180 
181  CDCTrajectory3D startTrajectory3D = trackPath.front()->getStartTrajectory3D();
182  CDCTrajectory3D endTrajectory3D = trackPath.back()->getStartTrajectory3D();
183 
184  double resetPerpSOffset =
185  startTrajectory3D.setLocalOrigin(result.front().getRecoPos3D());
186  result.setStartTrajectory3D(startTrajectory3D);
187 
188  endTrajectory3D.setLocalOrigin(result.back().getRecoPos3D());
189  result.setEndTrajectory3D(endTrajectory3D);
190 
191  for (CDCRecoHit3D& recoHit3D : result) {
192  recoHit3D.shiftArcLength2D(-resetPerpSOffset);
193  }
194 
195  return result;
196  }
197 }
198 
199 CDCTrack CDCTrack::condense(const Path<const CDCSegmentTriple>& segmentTriplePath)
200 {
201  CDCTrack track;
202  // B2DEBUG(200,"Lenght of segmentTripleTrack is " << segmentTripleTrack.size() );
203  if (segmentTriplePath.empty()) return track;
204 
205  Path<const CDCSegmentTriple>::const_iterator itSegmentTriple = segmentTriplePath.begin();
206  const CDCSegmentTriple* firstSegmentTriple = *itSegmentTriple++;
207 
208  // Set the start fits of the track to the ones of the first segment
209  CDCTrajectory3D startTrajectory3D = firstSegmentTriple->getTrajectory3D();
210 
211 
212  double perpSOffset = 0.0;
213  appendReconstructed(firstSegmentTriple->getStartSegment(),
214  firstSegmentTriple->getTrajectory3D(),
215  perpSOffset,
216  track);
217 
218  appendReconstructed(firstSegmentTriple->getMiddleSegment(),
219  firstSegmentTriple->getTrajectory3D(),
220  perpSOffset, track);
221 
222  while (itSegmentTriple != segmentTriplePath.end()) {
223 
224  const CDCSegmentTriple* secondSegmentTriple = *itSegmentTriple++;
225  B2ASSERT("Two segement triples do not overlap in their axial segments",
226  firstSegmentTriple->getEndSegment() == secondSegmentTriple->getStartSegment());
227 
228  perpSOffset = appendReconstructedAverage(firstSegmentTriple->getEndSegment(),
229  firstSegmentTriple->getTrajectory3D(),
230  perpSOffset,
231  secondSegmentTriple->getTrajectory3D(),
232  track);
233 
234  appendReconstructed(secondSegmentTriple->getMiddleSegment(),
235  secondSegmentTriple->getTrajectory3D(),
236  perpSOffset, track);
237 
238  firstSegmentTriple = secondSegmentTriple;
239 
240  }
241 
242  const CDCSegmentTriple* lastSegmentTriple = firstSegmentTriple;
243 
244  appendReconstructed(lastSegmentTriple->getEndSegment(),
245  lastSegmentTriple->getTrajectory3D(),
246  perpSOffset, track);
247 
248  // Set the end fits of the track to the ones of the last segment
249  CDCTrajectory3D endTrajectory3D = lastSegmentTriple->getTrajectory3D();
250 
251  // Set the reference point on the trajectories to the last reconstructed hit
252  double resetPerpSOffset = startTrajectory3D.setLocalOrigin(track.front().getRecoPos3D());
253  track.setStartTrajectory3D(startTrajectory3D);
254 
255  endTrajectory3D.setLocalOrigin(track.back().getRecoPos3D());
256  track.setEndTrajectory3D(endTrajectory3D);
257 
258  for (CDCRecoHit3D& recoHit3D : track) {
259  recoHit3D.shiftArcLength2D(-resetPerpSOffset);
260  }
261 
262  return track;
263 }
264 
265 CDCTrack CDCTrack::condense(const Path<const CDCSegmentPair>& segmentPairPath)
266 {
267  CDCTrack track;
268 
269  //B2DEBUG(200,"Lenght of segmentTripleTrack is " << segmentTripleTrack.size() );
270  if (segmentPairPath.empty()) return track;
271 
272  Path<const CDCSegmentPair>::const_iterator itSegmentPair = segmentPairPath.begin();
273  const CDCSegmentPair* firstSegmentPair = *itSegmentPair++;
274 
275 
276  // Keep the fit of the first segment pair to set it as the fit at the start of the track
277  CDCTrajectory3D startTrajectory3D = firstSegmentPair->getTrajectory3D();
278 
279  double perpSOffset = 0.0;
280  appendReconstructed(firstSegmentPair->getFromSegment(),
281  firstSegmentPair->getTrajectory3D(),
282  perpSOffset, track);
283 
284  while (itSegmentPair != segmentPairPath.end()) {
285 
286  const CDCSegmentPair* secondSegmentPair = *itSegmentPair++;
287 
288  B2ASSERT("Two segement pairs do not overlap in their segments",
289  firstSegmentPair->getToSegment() == secondSegmentPair->getFromSegment());
290 
291  perpSOffset = appendReconstructedAverage(firstSegmentPair->getToSegment(),
292  firstSegmentPair->getTrajectory3D(),
293  perpSOffset,
294  secondSegmentPair->getTrajectory3D(),
295  track);
296 
297  firstSegmentPair = secondSegmentPair;
298  }
299 
300  const CDCSegmentPair* lastSegmentPair = firstSegmentPair;
301  appendReconstructed(lastSegmentPair->getToSegment(),
302  lastSegmentPair->getTrajectory3D(),
303  perpSOffset, track);
304 
305  // Keep the fit of the last segment pair to set it as the fit at the end of the track
306  CDCTrajectory3D endTrajectory3D = lastSegmentPair->getTrajectory3D();
307 
308  // Move the reference point of the start fit to the first observered position
309  double resetPerpSOffset = startTrajectory3D.setLocalOrigin(track.front().getRecoPos3D());
310  track.setStartTrajectory3D(startTrajectory3D);
311 
312  // Move the reference point of the end fit to the last observered position
313  endTrajectory3D.setLocalOrigin(track.back().getRecoPos3D());
314  track.setEndTrajectory3D(endTrajectory3D);
315 
316  for (CDCRecoHit3D& recoHit3D : track) {
317  recoHit3D.shiftArcLength2D(-resetPerpSOffset);
318  }
319 
320  return track;
321 }
322 
323 std::vector<CDCSegment3D> CDCTrack::splitIntoSegments() const
324 {
325  vector<CDCSegment3D> result;
326  ISuperLayer lastISuperLayer = -1;
327  for (const CDCRecoHit3D& recoHit3D : *this) {
328  ISuperLayer iSuperLayer = recoHit3D.getISuperLayer();
329  if (result.empty() or lastISuperLayer != iSuperLayer) {
330  result.emplace_back();
331  }
332  result.back().push_back(recoHit3D);
333  lastISuperLayer = iSuperLayer;
334  }
335  return result;
336 }
337 
339 {
340  if (empty()) return;
341 
342  // Exchange the forward and backward trajectory and reverse them
346 
347  const CDCRecoHit3D& lastRecoHit3D = back();
348  double lastPerpS = lastRecoHit3D.getArcLength2D();
349  double newLastPerpS = m_startTrajectory3D.calcArcLength2D(lastRecoHit3D.getRecoPos3D());
350 
351  // Reverse the left right passage hypotheses and reverse the measured travel distance
352  for (CDCRecoHit3D& recoHit3D : *this) {
353  recoHit3D.reverse();
354  double perpS = recoHit3D.getArcLength2D();
355  recoHit3D.setArcLength2D(newLastPerpS + lastPerpS - perpS);
356  }
357 
358  // Reverse the arrangement of hits.
359  std::reverse(begin(), end());
360 }
361 
363 {
364  CDCTrack reversedTrack(*this);
365  reversedTrack.reverse();
366  return reversedTrack;
367 }
368 
369 MayBePtr<const CDCRecoHit3D> CDCTrack::find(const CDCWireHit& wireHit) const
370 {
371  auto hasWireHit = [&wireHit](const CDCRecoHit3D & recoHit3D) {
372  return recoHit3D.hasWireHit(wireHit);
373  };
374  auto itRecoHit3D = std::find_if(this->begin(), this->end(), hasWireHit);
375  return itRecoHit3D == this->end() ? nullptr : &*itRecoHit3D;
376 }
377 
379 {
381  for (const CDCRecoHit3D& recoHit3D : *this) {
382  const CDCWireHit& wireHit = recoHit3D.getWireHit();
383  wireHit.getAutomatonCell().unsetMaskedFlag();
384  }
385 }
386 
388 {
390  for (const CDCRecoHit3D& recoHit3D : *this) {
391  const CDCWireHit& wireHit = recoHit3D.getWireHit();
392  wireHit.getAutomatonCell().setMaskedFlag();
393  }
394 }
395 
397 {
398  for (const CDCRecoHit3D& recoHit3D : *this) {
399  const CDCWireHit& wireHit = recoHit3D.getWireHit();
400  if (wireHit.getAutomatonCell().hasMaskedFlag()) {
402  return;
403  }
404  }
405 }
406 
407 void CDCTrack::forwardTakenFlag(bool takenFlag) const
408 {
409  for (const CDCRecoHit3D& recoHit3D : *this) {
410  recoHit3D.getWireHit().getAutomatonCell().setTakenFlag(takenFlag);
411  }
412 }
413 
415 {
416  std::stable_sort(begin(),
417  end(),
418  [](const CDCRecoHit3D & recoHit, const CDCRecoHit3D & otherRecoHit) {
419  double arcLength = recoHit.getArcLength2D();
420  double otherArcLength = otherRecoHit.getArcLength2D();
421  return lessFloatHighNaN(arcLength, otherArcLength);
422  });
423 }
424 
425 void CDCTrack::shiftToPositiveArcLengths2D(bool doForAllTracks)
426 {
427  const CDCTrajectory2D& startTrajectory2D = getStartTrajectory3D().getTrajectory2D();
428  if (doForAllTracks or startTrajectory2D.isCurler(1.1)) {
429  const double shiftValue = startTrajectory2D.getLocalCircle()->arcLengthPeriod();
430  if (std::isfinite(shiftValue)) {
431  for (CDCRecoHit3D& recoHit : *this) {
432  if (recoHit.getArcLength2D() < 0) {
433  recoHit.shiftArcLength2D(shiftValue);
434  }
435  }
436  }
437  }
438 }
Belle2::TrackFindingCDC::CDCWireHit::getAutomatonCell
AutomatonCell & getAutomatonCell() const
Mutable getter for the automaton cell.
Definition: CDCWireHit.h:294
Belle2::TrackFindingCDC::CDCTrack::shiftToPositiveArcLengths2D
void shiftToPositiveArcLengths2D(bool doForAllTracks=false)
Set all arcLengths to have positive values by shifting them by pi*radius if they are negative.
Definition: CDCTrack.cc:425
Belle2::TrackFindingCDC::CDCSegmentTriple::getStartSegment
const CDCAxialSegment2D * getStartSegment() const
Getter for the start axial segment.
Definition: CDCSegmentTriple.h:111
Belle2::TrackFindingCDC::CDCTrack::receiveMaskedFlag
void receiveMaskedFlag() const
Check all contained wire hits if one has the masked flag.
Definition: CDCTrack.cc:396
Belle2::TrackFindingCDC::CDCRecoHit3D
Class representing a three dimensional reconstructed hit.
Definition: CDCRecoHit3D.h:62
Belle2::TrackFindingCDC::AutomatonCell::hasMaskedFlag
bool hasMaskedFlag() const
Gets the current state of the masked marker flag.
Definition: AutomatonCell.h:228
Belle2::TrackFindingCDC::CDCTrack
Class representing a sequence of three dimensional reconstructed hits.
Definition: CDCTrack.h:51
Belle2::TrackFindingCDC::CDCSegmentPair
Class representing a pair of one reconstructed axial segement and one stereo segment in adjacent supe...
Definition: CDCSegmentPair.h:44
Belle2::TrackFindingCDC::CDCTrack::getStartTrajectory3D
const CDCTrajectory3D & getStartTrajectory3D() const
Getter for the two dimensional trajectory.
Definition: CDCTrack.h:122
Belle2::TrackFindingCDC::CDCTrajectory2D::getLocalCircle
const UncertainPerigeeCircle & getLocalCircle() const
Getter for the cirlce in local coordinates.
Definition: CDCTrajectory2D.h:466
Belle2::TrackFindingCDC::CDCRecoHit2D::getRecoPos2D
Vector2D getRecoPos2D() const
Getter for the position in the reference plane.
Definition: CDCRecoHit2D.h:248
Belle2::TrackFindingCDC::CDCRecoHit3D::getISuperLayer
ISuperLayer getISuperLayer() const
Getter for the superlayer id.
Definition: CDCRecoHit3D.h:230
Belle2::TrackFindingCDC::CDCSegmentTriple::getMiddleSegment
const CDCStereoSegment2D * getMiddleSegment() const
Getter for the middle stereo segment.
Definition: CDCSegmentTriple.h:123
Belle2::TrackFindingCDC::CDCTrajectory3D::setLocalOrigin
double setLocalOrigin(const Vector3D &localOrigin)
Setter for the origin of the local coordinate system.
Definition: CDCTrajectory3D.cc:369
Belle2::TrackFindingCDC::AutomatonCell::setTakenFlag
void setTakenFlag(bool setTo=true)
Sets the taken flag to the given value. Default value true.
Definition: AutomatonCell.h:234
Belle2::TrackFindingCDC::AutomatonCell::unsetMaskedFlag
void unsetMaskedFlag()
Resets the masked flag to false.
Definition: AutomatonCell.h:222
Belle2::TrackFindingCDC::CDCTrack::forwardTakenFlag
void forwardTakenFlag(bool takenFlag=true) const
Set the taken flag of all hits belonging to this track to the given value (default true),...
Definition: CDCTrack.cc:407
Belle2::TrackFindingCDC::CDCRecoHit3D::reverse
void reverse()
Turns the orientation in place.
Definition: CDCRecoHit3D.cc:164
Belle2::TrackFindingCDC::CDCTrack::m_endTrajectory3D
CDCTrajectory3D m_endTrajectory3D
Memory for the three dimensional trajectory at the end of the track.
Definition: CDCTrack.h:217
Belle2::TrackFindingCDC::CDCRecoHit3D::getWireHit
const CDCWireHit & getWireHit() const
Getter for the wire hit.
Definition: CDCRecoHit3D.h:248
Belle2::TrackFindingCDC::CDCSegmentTriple::getTrajectory3D
const CDCTrajectory3D & getTrajectory3D() const
Getter for the three dimensional helix trajectory.
Definition: CDCSegmentTriple.h:153
Belle2::TrackFindingCDC::CDCRecoHit3D::getArcLength2D
double getArcLength2D() const
Getter for the travel distance in the xy projection.
Definition: CDCRecoHit3D.h:380
Belle2::TrackFindingCDC::CDCTrack::setAndForwardMaskedFlag
void setAndForwardMaskedFlag() const
Set the masked flag of the automaton cell of this segment and forward the masked flag to all containe...
Definition: CDCTrack.cc:387
Belle2::TrackFindingCDC::CDCTrajectory2D::isCurler
bool isCurler(double factor=1) const
Checks if the trajectory leaves the outer radius of the CDC times the given tolerance factor.
Definition: CDCTrajectory2D.cc:267
Belle2::TrackFindingCDC::CDCSegmentTriple::getEndSegment
const CDCAxialSegment2D * getEndSegment() const
Getter for the end axial segment.
Definition: CDCSegmentTriple.h:135
Belle2::TrackFindingCDC::CDCTrack::splitIntoSegments
std::vector< CDCSegment3D > splitIntoSegments() const
Splits the track into segments.
Definition: CDCTrack.cc:323
Belle2::TrackFindingCDC::CDCTrajectory2D
Particle trajectory as it is seen in xy projection represented as a circle.
Definition: CDCTrajectory2D.h:46
Belle2::TrackFindingCDC::CDCSegmentPair::getToSegment
const CDCSegment2D * getToSegment() const
Getter for the to segment.
Definition: CDCSegmentPair.h:132
Belle2::TrackFindingCDC::CDCTrack::reversed
CDCTrack reversed() const
Return a reversed copy of the track.
Definition: CDCTrack.cc:362
Belle2::TrackFindingCDC::CDCTrack::CDCTrack
CDCTrack()=default
Default constructor for ROOT compatibility.
Belle2::TrackFindingCDC::AutomatonCell::setMaskedFlag
void setMaskedFlag(bool setTo=true)
Sets the masked flag to the given value. Default value true.
Definition: AutomatonCell.h:216
Belle2::TrackFindingCDC::CDCTrack::unsetAndForwardMaskedFlag
void unsetAndForwardMaskedFlag() const
Unset the masked flag of the automaton cell of this segment and of all contained wire hits.
Definition: CDCTrack.cc:378
Belle2::TrackFindingCDC::CDCTrajectory3D::calcArcLength2D
double calcArcLength2D(const Vector3D &point) const
Calculate the travel distance from the start position of the trajectory.
Definition: CDCTrajectory3D.h:180
Belle2::TrackFindingCDC::CDCRecoHit3D::average
static CDCRecoHit3D average(const CDCRecoHit3D &first, const CDCRecoHit3D &second)
Constructs the average of two reconstructed hit positions.
Definition: CDCRecoHit3D.cc:141
Belle2::TrackFindingCDC::CDCTrack::condense
static CDCTrack condense(const Path< const CDCTrack > &trackPath)
Concats several tracks from a path.
Belle2::TrackFindingCDC::CDCTrajectory3D::getTrajectory2D
CDCTrajectory2D getTrajectory2D() const
Getter for the two dimensional trajectory.
Definition: CDCTrajectory3D.cc:336
Belle2::TrackFindingCDC::CDCTrack::reverse
void reverse()
Reverse the track inplace.
Definition: CDCTrack.cc:338
Belle2::TrackFindingCDC::CDCRecoHit2D
Class representing a two dimensional reconstructed hit in the central drift chamber.
Definition: CDCRecoHit2D.h:57
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:19
Belle2::TrackFindingCDC::CDCRLWireHit
Class representing an oriented hit wire including a hypotheses whether the causing track passes left ...
Definition: CDCRLWireHit.h:51
Belle2::TrackFindingCDC::CDCTrack::sortByArcLength2D
void sortByArcLength2D()
Sort the recoHits according to their perpS information.
Definition: CDCTrack.cc:414
Belle2::TrackFindingCDC::Vector3D
A three dimensional vector.
Definition: Vector3D.h:34
Belle2::TrackFindingCDC::CDCTrack::m_startTrajectory3D
CDCTrajectory3D m_startTrajectory3D
Memory for the three dimensional trajectory at the start of the track.
Definition: CDCTrack.h:214
Belle2::TrackFindingCDC::CDCRecoHit3D::shiftArcLength2D
void shiftArcLength2D(double arcLength2DOffSet)
Adjust the travel distance by the given value.
Definition: CDCRecoHit3D.h:374
Belle2::TrackFindingCDC::CDCRecoHit3D::setArcLength2D
void setArcLength2D(const double arcLength2D)
Setter for the travel distance in the xy projection.
Definition: CDCRecoHit3D.h:386
Belle2::TrackFindingCDC::CDCSegment2D
A reconstructed sequence of two dimensional hits in one super layer.
Definition: CDCSegment2D.h:40
Belle2::TrackFindingCDC::CDCSegmentPair::getTrajectory3D
CDCTrajectory3D & getTrajectory3D() const
Getter for the three dimensional trajectory.
Definition: CDCSegmentPair.h:213
Belle2::TrackFindingCDC::CDCTrajectory3D::reverse
void reverse()
Reverses the trajectory in place.
Definition: CDCTrajectory3D.h:151
Belle2::TrackFindingCDC::CDCWireHit
Class representing a hit wire in the central drift chamber.
Definition: CDCWireHit.h:65
Belle2::TrackFindingCDC::CDCRecoHit3D::reconstruct
static CDCRecoHit3D reconstruct(const CDCRecoHit2D &recoHit2D, const CDCTrajectory2D &trajectory2D)
Reconstructs the three dimensional hit from the two dimensional and the two dimensional trajectory.
Definition: CDCRecoHit3D.cc:58
Belle2::TrackFindingCDC::CDCSegmentPair::getFromSegment
const CDCSegment2D * getFromSegment() const
Getter for the from segment.
Definition: CDCSegmentPair.h:120
Belle2::TrackFindingCDC::CDCTrack::find
MayBePtr< const CDCRecoHit3D > find(const CDCWireHit &wireHit) const
Finds the first CDCRecoHit3D that is based on the given wire hit - nullptr if none.
Definition: CDCTrack.cc:369
Belle2::TrackFindingCDC::CDCRecoHit3D::getRecoPos3D
const Vector3D & getRecoPos3D() const
Getter for the 3d position of the hit.
Definition: CDCRecoHit3D.h:295
Belle2::TrackFindingCDC::CDCTrack::getAutomatonCell
AutomatonCell & getAutomatonCell() const
Mutable getter for the automaton cell.
Definition: CDCTrack.h:135
Belle2::TrackFindingCDC::CDCTrajectory3D
Particle full three dimensional trajectory.
Definition: CDCTrajectory3D.h:47
Belle2::TrackFindingCDC::PerigeeCircle::arcLengthPeriod
double arcLengthPeriod() const
Getter for the arc length for a full round of the circle.
Definition: PerigeeCircle.h:332
Belle2::TrackFindingCDC::CDCSegmentTriple
Class representing a triple of reconstructed segements in adjacent superlayer.
Definition: CDCSegmentTriple.h:42