Belle II Software  release-05-01-25
CDCObservations2D.cc
1 /**************************************************************************
2  * BASF2 (Belle Analysis Framework 2) *
3  * Copyright(C) 2014 - 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/fitting/CDCObservations2D.h>
11 
12 #include <tracking/trackFindingCDC/fitting/EigenObservationMatrix.h>
13 
14 #include <tracking/trackFindingCDC/eventdata/tracks/CDCTrack.h>
15 #include <tracking/trackFindingCDC/eventdata/tracks/CDCAxialSegmentPair.h>
16 #include <tracking/trackFindingCDC/eventdata/segments/CDCSegment3D.h>
17 #include <tracking/trackFindingCDC/eventdata/segments/CDCSegment2D.h>
18 #include <tracking/trackFindingCDC/eventdata/segments/CDCWireHitSegment.h>
19 #include <tracking/trackFindingCDC/eventdata/hits/CDCFacet.h>
20 #include <tracking/trackFindingCDC/eventdata/hits/CDCRLWireHitTriple.h>
21 #include <tracking/trackFindingCDC/eventdata/hits/CDCRLWireHitPair.h>
22 #include <tracking/trackFindingCDC/eventdata/hits/CDCRLWireHit.h>
23 #include <tracking/trackFindingCDC/eventdata/hits/CDCWireHit.h>
24 
25 #include <tracking/trackFindingCDC/eventdata/trajectories/CDCTrajectory2D.h>
26 
27 #include <tracking/trackFindingCDC/topology/CDCWire.h>
28 
29 #include <tracking/trackFindingCDC/geometry/Vector2D.h>
30 
31 using namespace Belle2;
32 using namespace TrackFindingCDC;
33 
35 {
37  wireHit.getRefDriftLengthVariance());
38 }
39 
40 std::size_t
41 CDCObservations2D::fill(double x, double y, double signedRadius, double weight)
42 {
43  if (std::isnan(x)) return 0;
44  if (std::isnan(y)) return 0;
45 
46  if (std::isnan(signedRadius)) {
47  B2WARNING("Signed radius is nan. Skipping observation");
48  return 0;
49  }
50 
51  if (std::isnan(weight)) {
52  B2WARNING("Weight is nan. Skipping observation");
53  return 0;
54  }
55 
56  m_observations.push_back(x);
57  m_observations.push_back(y);
58  m_observations.push_back(signedRadius);
59  m_observations.push_back(weight);
60  return 1;
61 }
62 
63 std::size_t
64 CDCObservations2D::fill(const Vector2D& pos2D, double signedRadius, double weight)
65 {
66  return fill(pos2D.x(), pos2D.y(), signedRadius, weight);
67 }
68 
69 std::size_t CDCObservations2D::append(const CDCWireHit& wireHit, ERightLeft rlInfo)
70 {
71  const Vector2D& wireRefPos2D = wireHit.getRefPos2D();
72 
73  double signedDriftLength = 0;
74  if (m_fitPos == EFitPos::c_RLDriftCircle and isValid(rlInfo)) {
75  signedDriftLength = rlInfo * wireHit.getRefDriftLength();
76  } else {
77  signedDriftLength = 0;
78  }
79 
80  double variance = 1;
81  if (m_fitVariance == EFitVariance::c_Unit) {
82  variance = 1;
83  } else if (m_fitVariance == EFitVariance::c_Nominal) {
85  } else if (m_fitVariance == EFitVariance::c_DriftLength) {
86  const double driftLength = wireHit.getRefDriftLength();
87  variance = fabs(driftLength);
88  } else if (m_fitVariance == EFitVariance::c_Pseudo) {
89  variance = getPseudoDriftLengthVariance(wireHit);
90  } else if (m_fitVariance == EFitVariance::c_Proper) {
91  if (abs(rlInfo) != 1) {
92  variance = getPseudoDriftLengthVariance(wireHit);
93  } else {
94  variance = wireHit.getRefDriftLengthVariance();
95  }
96  }
97  return fill(wireRefPos2D, signedDriftLength, 1 / variance);
98 }
99 
100 std::size_t CDCObservations2D::append(const CDCWireHit* wireHit, ERightLeft rlInfo)
101 {
102  if (wireHit) {
103  return append(*(wireHit), rlInfo);
104  } else {
105  return 0;
106  }
107 }
108 
109 std::size_t CDCObservations2D::append(const CDCRLWireHit& rlWireHit)
110 {
111  const ERightLeft rlInfo = rlWireHit.getRLInfo();
112 
113  const double driftLength = rlWireHit.getRefDriftLength();
114  const double driftLengthVariance = rlWireHit.getRefDriftLengthVariance();
115 
116  const Vector2D& wireRefPos2D = rlWireHit.getRefPos2D();
117 
118  double signedDriftLength = 0;
119  if (m_fitPos == EFitPos::c_RLDriftCircle and isValid(rlInfo)) {
120  signedDriftLength = rlInfo * driftLength;
121  } else {
122  signedDriftLength = 0;
123  }
124 
125  double variance = 1;
126  if (m_fitVariance == EFitVariance::c_Unit) {
127  variance = 1;
128  } else if (m_fitVariance == EFitVariance::c_Nominal) {
130  } else if (m_fitVariance == EFitVariance::c_DriftLength) {
131  variance = fabs(driftLength);
132  } else if (m_fitVariance == EFitVariance::c_Pseudo) {
133  variance = getPseudoDriftLengthVariance(driftLength, driftLengthVariance);
134  } else if (m_fitVariance == EFitVariance::c_Proper) {
135  if (abs(rlInfo) != 1) {
136  variance = getPseudoDriftLengthVariance(driftLength, driftLengthVariance);
137  } else {
138  variance = driftLengthVariance;
139  }
140  }
141 
142  return fill(wireRefPos2D, signedDriftLength, 1 / variance);
143 }
144 
145 std::size_t CDCObservations2D::append(const CDCRLWireHitPair& rlWireHitPair)
146 {
147  return append(rlWireHitPair.getFromRLWireHit()) + append(rlWireHitPair.getToRLWireHit());
148 }
149 
150 std::size_t CDCObservations2D::append(const CDCRLWireHitTriple& rlWireHitTriple)
151 {
152  return append(rlWireHitTriple.getStartRLWireHit()) +
153  append(rlWireHitTriple.getMiddleRLWireHit()) + append(rlWireHitTriple.getEndRLWireHit());
154 }
155 
156 std::size_t CDCObservations2D::append(const CDCFacet& facet)
157 {
158  if (m_fitPos == EFitPos::c_RecoPos) {
159  return append(facet.getStartRecoHit2D()) + append(facet.getMiddleRecoHit2D()) +
160  append(facet.getEndRecoHit2D());
161  } else {
162  const CDCRLWireHitTriple& rlWireHitTriple = facet;
163  return append(rlWireHitTriple);
164  }
165 }
166 
167 std::size_t CDCObservations2D::append(const CDCRecoHit2D& recoHit2D)
168 {
169  Vector2D fitPos2D;
170  double signedDriftLength = 0;
171  if (m_fitPos == EFitPos::c_RecoPos) {
172  fitPos2D = recoHit2D.getRecoPos2D();
173  signedDriftLength = 0;
174 
175  // Fall back to the rl circle in case position is not setup
176  if (fitPos2D.hasNAN()) {
177  fitPos2D = recoHit2D.getWire().getRefPos2D();
178  signedDriftLength = recoHit2D.getSignedRefDriftLength();
179  }
180 
181  } else if (m_fitPos == EFitPos::c_RLDriftCircle) {
182  fitPos2D = recoHit2D.getWire().getRefPos2D();
183  signedDriftLength = recoHit2D.getSignedRefDriftLength();
184  } else if (m_fitPos == EFitPos::c_WirePos) {
185  fitPos2D = recoHit2D.getWire().getRefPos2D();
186  signedDriftLength = 0;
187  }
188 
189  const double driftLength = recoHit2D.getRefDriftLength();
190  const ERightLeft rlInfo = recoHit2D.getRLInfo();
191 
192  double variance = recoHit2D.getRefDriftLengthVariance();
193  if (m_fitVariance == EFitVariance::c_Unit) {
194  variance = 1;
195  } else if (m_fitVariance == EFitVariance::c_Nominal) {
197  } else if (m_fitVariance == EFitVariance::c_DriftLength) {
198  variance = std::fabs(driftLength);
199  } else if (m_fitVariance == EFitVariance::c_Pseudo or abs(rlInfo) != 1) {
200  // Fall back to the pseudo variance if the rl information is not known
201  variance = getPseudoDriftLengthVariance(driftLength, variance);
202  } else if (m_fitVariance == EFitVariance::c_Proper) {
203  variance = recoHit2D.getRefDriftLengthVariance();
204  }
205  return fill(fitPos2D, signedDriftLength, 1 / variance);
206 }
207 
208 std::size_t CDCObservations2D::append(const CDCRecoHit3D& recoHit3D)
209 {
210  Vector2D fitPos2D = recoHit3D.getRecoPos2D();
211  double signedDriftLength = 0;
212  if (m_fitPos == EFitPos::c_RecoPos) {
213  fitPos2D = recoHit3D.getRecoPos2D();
214  signedDriftLength = 0;
215  } else if (m_fitPos == EFitPos::c_RLDriftCircle) {
216  fitPos2D = recoHit3D.getRecoWirePos2D();
217  signedDriftLength = recoHit3D.getSignedRecoDriftLength();
218  } else if (m_fitPos == EFitPos::c_WirePos) {
219  fitPos2D = recoHit3D.getRecoWirePos2D();
220  signedDriftLength = 0;
221  }
222 
223  const double driftLength = std::fabs(recoHit3D.getSignedRecoDriftLength());
224  const ERightLeft rlInfo = recoHit3D.getRLInfo();
225 
226  double variance = recoHit3D.getRecoDriftLengthVariance();
227  if (m_fitVariance == EFitVariance::c_Unit) {
228  variance = 1;
229  } else if (m_fitVariance == EFitVariance::c_Nominal) {
231  } else if (m_fitVariance == EFitVariance::c_DriftLength) {
232  variance = std::fabs(driftLength);
233  } else if (m_fitVariance == EFitVariance::c_Pseudo or abs(rlInfo) != 1) {
234  // Fall back to the pseudo variance if the rl information is not known
235  variance = getPseudoDriftLengthVariance(driftLength, variance);
236  } else if (m_fitVariance == EFitVariance::c_Proper) {
237  variance = recoHit3D.getRecoDriftLengthVariance();
238  }
239  return fill(fitPos2D, signedDriftLength, 1 / variance);
240 }
241 
242 std::size_t CDCObservations2D::appendRange(const CDCSegment2D& segment2D)
243 {
244  std::size_t nAppendedHits = 0;
245  for (const CDCRecoHit2D& recoHit2D : segment2D) {
246  nAppendedHits += append(recoHit2D);
247  }
248  return nAppendedHits;
249 }
250 
251 std::size_t CDCObservations2D::appendRange(const CDCSegment3D& segment3D)
252 {
253  std::size_t nAppendedHits = 0;
254  for (const CDCRecoHit3D& recoHit3D : segment3D) {
255  nAppendedHits += append(recoHit3D);
256  }
257  return nAppendedHits;
258 }
259 
260 std::size_t CDCObservations2D::appendRange(const CDCAxialSegmentPair& axialSegmentPair)
261 {
262  std::size_t nAppendedHits = 0;
263  const CDCSegment2D* ptrStartSegment2D = axialSegmentPair.getStartSegment();
264  if (ptrStartSegment2D) {
265  const CDCSegment2D& startSegment2D = *ptrStartSegment2D;
266  nAppendedHits += appendRange(startSegment2D);
267  }
268 
269  const CDCSegment2D* ptrEndSegment2D = axialSegmentPair.getEndSegment();
270  if (ptrEndSegment2D) {
271  const CDCSegment2D& endSegment2D = *ptrEndSegment2D;
272  nAppendedHits += appendRange(endSegment2D);
273  }
274  return nAppendedHits;
275 }
276 
277 std::size_t CDCObservations2D::appendRange(const CDCTrack& track)
278 {
279  std::size_t nAppendedHits = 0;
280  for (const CDCRecoHit3D& recoHit3D : track) {
281  nAppendedHits += append(recoHit3D);
282  }
283  return nAppendedHits;
284 }
285 
286 std::size_t CDCObservations2D::appendRange(const std::vector<const CDCWire*>& wires)
287 {
288  std::size_t nAppendedHits = 0;
289  for (const CDCWire* ptrWire : wires) {
290  if (not ptrWire) continue;
291  const CDCWire& wire = *ptrWire;
292  const Vector2D& wirePos = wire.getRefPos2D();
293  const double driftLength = 0.0;
294  const double weight = 1.0;
295  nAppendedHits += fill(wirePos, driftLength, weight);
296  }
297  return nAppendedHits;
298 }
299 
301 {
302  std::size_t nAppendedHits = 0;
303  for (const CDCWireHit* ptrWireHit : wireHits) {
304  if (not ptrWireHit) continue;
305  const CDCWireHit& wireHit = *ptrWireHit;
306  nAppendedHits += append(wireHit);
307  }
308  return nAppendedHits;
309 }
310 
311 double CDCObservations2D::getTotalPerpS(const CDCTrajectory2D& trajectory2D) const
312 {
313  return trajectory2D.calcArcLength2DBetween(getFrontPos2D(), getBackPos2D());
314 }
315 
317 {
318  std::size_t result = 0;
319  Index nObservations = size();
320 
321  for (Index iObservation = 0; iObservation < nObservations; ++iObservation) {
322  const double driftLength = getDriftLength(iObservation);
323  bool hasDriftLength = (driftLength != 0.0);
324  result += hasDriftLength ? 1 : 0;
325  }
326 
327  return result;
328 }
329 
331 {
332  std::size_t n = size();
333  if (n == 0) return Vector2D(NAN, NAN);
334  std::size_t i = n / 2;
335 
336  if (isEven(n)) {
337  // For even number of observations use the middle one with the bigger distance from IP
338  Vector2D center1(getX(i), getY(i));
339  Vector2D center2(getX(i - 1), getY(i - 1));
340  return center1.normSquared() > center2.normSquared() ? center1 : center2;
341  } else {
342  Vector2D center1(getX(i), getY(i));
343  return center1;
344  }
345 }
346 
348 {
349  Eigen::Matrix<double, 1, 2> eigenOrigin(origin.x(), origin.y());
350  EigenObservationMatrix eigenObservations = getEigenObservationMatrix(this);
351  eigenObservations.leftCols<2>().rowwise() -= eigenOrigin;
352 }
353 
355 {
356  // Pick an observation at the center
357  Vector2D centralPoint = getCentralPoint();
358  passiveMoveBy(centralPoint);
359  return centralPoint;
360 }
Belle2::TrackFindingCDC::CDCObservations2D::size
std::size_t size() const
Returns the number of observations stored.
Definition: CDCObservations2D.h:88
Belle2::TrackFindingCDC::CDCFacet::getMiddleRecoHit2D
CDCRecoHit2D getMiddleRecoHit2D() const
Getter for the second reconstucted hit.
Definition: CDCFacet.cc:117
Belle2::TrackFindingCDC::CDCRecoHit2D::getRefDriftLengthVariance
double getRefDriftLengthVariance() const
Getter for the uncertainty in the drift length at the wire reference position.
Definition: CDCRecoHit2D.h:242
Belle2::TrackFindingCDC::CDCRecoHit3D
Class representing a three dimensional reconstructed hit.
Definition: CDCRecoHit3D.h:62
Belle2::TrackFindingCDC::CDCTrack
Class representing a sequence of three dimensional reconstructed hits.
Definition: CDCTrack.h:51
Belle2::TrackFindingCDC::CDCObservations2D::getX
double getX(int iObservation) const
Getter for the x value of the observation at the given index.
Definition: CDCObservations2D.h:118
Belle2::TrackFindingCDC::CDCAxialSegmentPair::getStartSegment
const CDCAxialSegment2D * getStartSegment() const
Getter for the start segment.
Definition: CDCAxialSegmentPair.h:99
Belle2::TrackFindingCDC::CDCRecoHit3D::getRecoWirePos2D
Vector2D getRecoWirePos2D() const
Returns the position of the wire in the xy plain the reconstructed position is located in.
Definition: CDCRecoHit3D.cc:209
Belle2::TrackFindingCDC::Vector2D
A two dimensional vector which is equipped with functions for correct handeling of orientation relat...
Definition: Vector2D.h:37
Belle2::TrackFindingCDC::CDCWireHit::getRefDriftLength
double getRefDriftLength() const
Getter for the drift length at the reference position of the wire.
Definition: CDCWireHit.h:232
Belle2::TrackFindingCDC::CDCObservations2D::m_observations
std::vector< double > m_observations
Memory for the individual observations.
Definition: CDCObservations2D.h:346
Belle2::TrackFindingCDC::Vector2D::normSquared
double normSquared() const
Calculates .
Definition: Vector2D.h:183
Belle2::TrackFindingCDC::CDCWire::getRefPos2D
const Vector2D & getRefPos2D() const
Getter for the wire reference position for 2D tracking Gives the wire's reference position projected ...
Definition: CDCWire.h:231
Belle2::TrackFindingCDC::CDCRecoHit2D::getRecoPos2D
Vector2D getRecoPos2D() const
Getter for the position in the reference plane.
Definition: CDCRecoHit2D.h:248
Belle2::TrackFindingCDC::Vector2D::y
double y() const
Getter for the y coordinate.
Definition: Vector2D.h:619
Belle2::TrackFindingCDC::CDCWireHit::getRefPos2D
const Vector2D & getRefPos2D() const
The two dimensional reference position (z=0) of the underlying wire.
Definition: CDCWireHit.cc:214
Belle2::TrackFindingCDC::CDCObservations2D::passiveMoveBy
void passiveMoveBy(const Vector2D &origin)
Moves all observations passively such that the given vector becomes to origin of the new coordinate s...
Definition: CDCObservations2D.cc:347
Belle2::TrackFindingCDC::CDCRLWireHit::getRefDriftLength
double getRefDriftLength() const
Getter for the drift length at the reference position of the wire.
Definition: CDCRLWireHit.h:214
Belle2::TrackFindingCDC::CDCRLWireHitPair::getToRLWireHit
CDCRLWireHit & getToRLWireHit()
Getter for the second oriented wire hit.
Definition: CDCRLWireHitPair.h:165
Belle2::TrackFindingCDC::CDCRecoHit2D::getRefDriftLength
double getRefDriftLength() const
Getter for the drift length at the wire reference position.
Definition: CDCRecoHit2D.h:227
Belle2::TrackFindingCDC::NForwardBackward::isValid
bool isValid(EForwardBackward eForwardBackward)
Check whether the given enum instance is one of the valid values.
Definition: EForwardBackward.h:55
Belle2::TrackFindingCDC::CDCWireHit::getRefDriftLengthVariance
double getRefDriftLengthVariance() const
Getter for the variance of the drift length at the reference position of the wire.
Definition: CDCWireHit.h:238
Belle2::TrackFindingCDC::CDCFacet::getStartRecoHit2D
CDCRecoHit2D getStartRecoHit2D() const
Getter for the first reconstucted hit.
Definition: CDCFacet.cc:112
Belle2::TrackFindingCDC::CDCRLWireHitTriple
Class representing a triple of neighboring wire hits.
Definition: CDCRLWireHitTriple.h:45
Belle2::TrackFindingCDC::CDCSegment3D
A segment consisting of three dimensional reconstructed hits.
Definition: CDCSegment3D.h:36
Belle2::TrackFindingCDC::CDCRecoHit3D::getRLInfo
ERightLeft getRLInfo() const
Getter for the right left passage information.
Definition: CDCRecoHit3D.h:277
Belle2::TrackFindingCDC::CDCRecoHit3D::getRecoPos2D
const Vector2D & getRecoPos2D() const
Getter for the 2d position of the hit.
Definition: CDCRecoHit3D.h:307
Belle2::TrackFindingCDC::CDCTrajectory2D
Particle trajectory as it is seen in xy projection represented as a circle.
Definition: CDCTrajectory2D.h:46
Belle2::TrackFindingCDC::CDCAxialSegmentPair::getEndSegment
const CDCAxialSegment2D * getEndSegment() const
Getter for the end segment.
Definition: CDCAxialSegmentPair.h:111
Belle2::TrackFindingCDC::CDCRLWireHitPair::getFromRLWireHit
CDCRLWireHit & getFromRLWireHit()
Getter for the first oriented wire hit.
Definition: CDCRLWireHitPair.h:159
Belle2::TrackFindingCDC::CDCObservations2D::getY
double getY(int iObservation) const
Getter for the y value of the observation at the given index.
Definition: CDCObservations2D.h:124
Belle2::TrackFindingCDC::CDCObservations2D::getTotalPerpS
double getTotalPerpS(const CDCTrajectory2D &trajectory2D) const
Calculate the total transvers travel distance traversed by these observations comparing the travel di...
Definition: CDCObservations2D.cc:311
Belle2::TrackFindingCDC::Vector2D::hasNAN
bool hasNAN() const
Checks if one of the coordinates is NAN.
Definition: Vector2D.h:163
Belle2::TrackFindingCDC::CDCObservations2D::appendRange
std::size_t appendRange(const CDCSegment2D &segment2D)
Appends all reconstructed hits from the two dimensional segment.
Definition: CDCObservations2D.cc:242
Belle2::TrackFindingCDC::CDCRecoHit2D::getWire
const CDCWire & getWire() const
Getter for the wire the reconstructed hit assoziated to.
Definition: CDCRecoHit2D.h:185
Belle2::TrackFindingCDC::CDCWireHitSegment
A segment consisting of two dimensional reconsturcted hits.
Definition: CDCWireHitSegment.h:34
Belle2::TrackFindingCDC::CDCRLWireHit::getRefDriftLengthVariance
double getRefDriftLengthVariance() const
Getter for the variance of the drift length at the reference position of the wire.
Definition: CDCRLWireHit.h:232
Belle2::TrackFindingCDC::CDCRecoHit3D::getRecoDriftLengthVariance
double getRecoDriftLengthVariance() const
Returns the drift length variance next to the reconstructed position.
Definition: CDCRecoHit3D.h:368
Belle2::TrackFindingCDC::CDCTrajectory2D::calcArcLength2DBetween
double calcArcLength2DBetween(const Vector2D &fromPoint, const Vector2D &toPoint) const
Calculate the travel distance between the two given positions Returns the travel distance on the traj...
Definition: CDCTrajectory2D.h:283
Belle2::TrackFindingCDC::CDCRecoHit2D
Class representing a two dimensional reconstructed hit in the central drift chamber.
Definition: CDCRecoHit2D.h:57
Belle2::TrackFindingCDC::CDCRLWireHit::getRLInfo
ERightLeft getRLInfo() const
Getter for the right left passage information.
Definition: CDCRLWireHit.h:244
Belle2::TrackFindingCDC::CDCAxialSegmentPair
Class representing a pair of reconstructed axial segements in adjacent superlayer.
Definition: CDCAxialSegmentPair.h:41
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:19
Belle2::TrackFindingCDC::CDCObservations2D::getBackPos2D
Vector2D getBackPos2D() const
Get the postion of the first observation.
Definition: CDCObservations2D.h:280
Belle2::TrackFindingCDC::CDCRLWireHit
Class representing an oriented hit wire including a hypotheses whether the causing track passes left ...
Definition: CDCRLWireHit.h:51
Belle2::TrackFindingCDC::NRightLeft::ERightLeft
ERightLeft
Enumeration to represent the distinct possibilities of the right left passage.
Definition: ERightLeft.h:35
Belle2::TrackFindingCDC::CDCObservations2D::getDriftLength
double getDriftLength(int iObservation) const
Getter for the signed drift radius of the observation at the given index.
Definition: CDCObservations2D.h:130
Belle2::TrackFindingCDC::CDCRLWireHitTriple::getMiddleRLWireHit
CDCRLWireHit & getMiddleRLWireHit()
Getter for the second oriented wire hit.
Definition: CDCRLWireHitTriple.h:243
Belle2::TrackFindingCDC::CDCFacet
Class representing a triple of neighboring oriented wire with additional trajectory information.
Definition: CDCFacet.h:42
Belle2::TrackFindingCDC::Vector2D::x
double x() const
Getter for the x coordinate.
Definition: Vector2D.h:609
Belle2::TrackFindingCDC::CDCRLWireHitPair
A pair of oriented wire hits.
Definition: CDCRLWireHitPair.h:37
Belle2::TrackFindingCDC::CDCRLWireHit::getRefPos2D
const Vector2D & getRefPos2D() const
The two dimensional reference position of the underlying wire.
Definition: CDCRLWireHit.cc:158
Belle2::TrackFindingCDC::CDCWire
Class representing a sense wire in the central drift chamber.
Definition: CDCWire.h:60
Belle2::TrackFindingCDC::CDCSegment2D
A reconstructed sequence of two dimensional hits in one super layer.
Definition: CDCSegment2D.h:40
Belle2::TrackFindingCDC::CDCRecoHit3D::getSignedRecoDriftLength
double getSignedRecoDriftLength() const
Returns the drift length next to the reconstructed position.
Definition: CDCRecoHit3D.h:356
Belle2::TrackFindingCDC::CDCRLWireHitTriple::getEndRLWireHit
CDCRLWireHit & getEndRLWireHit()
Getter for the third oriented wire hit.
Definition: CDCRLWireHitTriple.h:249
Belle2::TrackFindingCDC::CDCObservations2D::getNObservationsWithDriftRadius
std::size_t getNObservationsWithDriftRadius() const
Returns the number of observations having a drift radius radius.
Definition: CDCObservations2D.cc:316
Belle2::TrackFindingCDC::CDCObservations2D::centralize
Vector2D centralize()
Picks one observation as a reference point and transform all observations to that new origin.
Definition: CDCObservations2D.cc:354
Belle2::TrackFindingCDC::CDCObservations2D::getFrontPos2D
Vector2D getFrontPos2D() const
Get the postion of the first observation.
Definition: CDCObservations2D.h:274
Belle2::TrackFindingCDC::CDCWireHit
Class representing a hit wire in the central drift chamber.
Definition: CDCWireHit.h:65
Belle2::TrackFindingCDC::CDCObservations2D::getPseudoDriftLengthVariance
static double getPseudoDriftLengthVariance(double driftLength, double driftLengthVariance)
Gets the pseudo variance.
Definition: CDCObservations2D.h:78
Belle2::TrackFindingCDC::CDCWireHit::c_simpleDriftLengthVariance
static constexpr const double c_simpleDriftLengthVariance
A default value for the drift length variance if no variance from the drift length translation is ava...
Definition: CDCWireHit.h:74
Belle2::TrackFindingCDC::CDCObservations2D::fill
std::size_t fill(double x, double y, double signedRadius=0.0, double weight=1.0)
Appends the observed position.
Belle2::TrackFindingCDC::CDCObservations2D::m_fitPos
EFitPos m_fitPos
Indicator which positional information should preferably be extracted from hits in calls to append.
Definition: CDCObservations2D.h:353
Belle2::TrackFindingCDC::CDCRecoHit2D::getSignedRefDriftLength
double getSignedRefDriftLength() const
Getter for the drift length at the wire reference position signed with the right left passage hypothe...
Definition: CDCRecoHit2D.h:236
Belle2::TrackFindingCDC::CDCRLWireHitTriple::getStartRLWireHit
CDCRLWireHit & getStartRLWireHit()
Getter for the first oriented wire hit.
Definition: CDCRLWireHitTriple.h:237
Belle2::TrackFindingCDC::CDCObservations2D::m_fitVariance
EFitVariance m_fitVariance
Indicator which variance information should preferably be extracted from hits in calls to append.
Definition: CDCObservations2D.h:360
Belle2::TrackFindingCDC::CDCObservations2D::getCentralPoint
Vector2D getCentralPoint() const
Extracts the observation center that is at the index in the middle.
Definition: CDCObservations2D.cc:330
Belle2::TrackFindingCDC::CDCFacet::getEndRecoHit2D
CDCRecoHit2D getEndRecoHit2D() const
Getter for the third reconstucted hit.
Definition: CDCFacet.cc:122
Belle2::TrackFindingCDC::CDCRecoHit2D::getRLInfo
ERightLeft getRLInfo() const
Getter for the right left passage information.
Definition: CDCRecoHit2D.h:215
Belle2::TrackFindingCDC::CDCObservations2D::append
std::size_t append(const CDCWireHit &wireHit, ERightLeft rlInfo=ERightLeft::c_Unknown)
Appends the hit circle at wire reference position without a right left passage hypotheses.