Belle II Software  release-05-01-25
CDCFitter2D.icc.h
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 #pragma once
11 
12 #include <tracking/trackFindingCDC/fitting/CDCFitter2D.h>
13 
14 #include <tracking/trackFindingCDC/fitting/CDCObservations2D.h>
15 
16 #include <tracking/trackFindingCDC/eventdata/trajectories/CDCTrajectory2D.h>
17 
18 #include <tracking/trackFindingCDC/fitting/EFitVariance.h>
19 #include <tracking/trackFindingCDC/fitting/EFitPos.h>
20 
21 namespace Belle2 {
26  namespace TrackFindingCDC {
27 
28  template <class AFitMethod>
30  : m_usePosition(true)
31  , m_useOrientation(false)
32  , m_fitVariance(EFitVariance::c_Proper)
33  {
34  }
35 
36  template <class AFitMethod>
38 
39  template <class AFitMethod>
41  {
42  return fit(CDCObservations2D(observations2D));
43  }
44 
45  template <class AFitMethod>
47  {
49  update(result, observations2D);
50  return result;
51  }
52 
53  template <class AFitMethod>
55  const CDCObservations2D& observations2D) const
56  {
57  return update(trajectory2D, CDCObservations2D(observations2D));
58  }
59 
60  template <class AFitMethod>
61  void CDCFitter2D<AFitMethod>::update(CDCTrajectory2D& trajectory2D, CDCObservations2D&& observations2D) const
62  {
63  AFitMethod::update(trajectory2D, observations2D);
64  }
65 
66  template <class AFitMethod>
68  {
69  return fitGeneric(track);
70  }
71 
72  template <class AFitMethod>
74  {
75  return fitGeneric(segment);
76  }
77 
78  template <class AFitMethod>
80  {
81  return fitGeneric(segment);
82  }
83 
84  template <class AFitMethod>
85  CDCTrajectory2D CDCFitter2D<AFitMethod>::fit(const std::vector<const CDCWireHit*>& wireHits) const
86  {
87  return fitGeneric(wireHits);
88  }
89 
90  template <class AFitMethod>
91  CDCTrajectory2D CDCFitter2D<AFitMethod>::fit(const std::vector<const CDCWire*>& wires) const
92  {
93  return fitGeneric(wires);
94  }
95 
96  template <class AFitMethod>
98  {
99  return fitGeneric(wireHits);
100  }
101 
102  template <class AFitMethod>
104  const CDCSegment2D& toSegment) const
105  {
106  return fitGeneric(fromSegment, toSegment);
107  }
108 
109  template <class AFitMethod>
111  const CDCSegment2D& segment) const
112  {
113  updateGeneric(trajectory2D, segment);
114  }
115 
116  template <class AFitMethod>
118  const CDCAxialSegmentPair& axialSegmentPair) const
119  {
120  return updateGeneric(trajectory2D, axialSegmentPair);
121  }
122 
123  template <class AFitMethod>
124  template <class AHits>
126  {
127  CDCTrajectory2D result;
128  updateGeneric(result, hits);
129  return result;
130  }
131 
132  template <class AFitMethod>
133  template <class AStartHits, class AEndHits>
135  CDCFitter2D<AFitMethod>::fitGeneric(const AStartHits& startHits, const AEndHits& endHits) const
136  {
137  CDCTrajectory2D result;
138  updateGeneric(result, startHits, endHits);
139  return result;
140  }
141 
142  template <class AFitMethod>
143  template <class AStartHits, class AEndHits>
145  const AStartHits& startHits,
146  const AEndHits& endHits) const
147  {
148  CDCObservations2D observations2D;
149  observations2D.setFitVariance(m_fitVariance);
150 
151  if (m_usePosition) {
152  observations2D.setFitPos(EFitPos::c_RecoPos);
153  observations2D.appendRange(startHits);
154  }
155  if (m_useOrientation) {
156  observations2D.setFitPos(EFitPos::c_RLDriftCircle);
157  observations2D.appendRange(startHits);
158  }
159 
160  if (m_usePosition) {
161  observations2D.setFitPos(EFitPos::c_RecoPos);
162  observations2D.appendRange(endHits);
163  }
164  if (m_useOrientation) {
165  observations2D.setFitPos(EFitPos::c_RLDriftCircle);
166  observations2D.appendRange(endHits);
167  }
168 
169  if (observations2D.size() < 4) {
170  trajectory2D.clear();
171  } else {
172  AFitMethod::update(trajectory2D, observations2D);
173  }
174  }
175 
176  template <class AFitMethod>
177  template <class AHits>
178  void
179  CDCFitter2D<AFitMethod>::updateGeneric(CDCTrajectory2D& trajectory2D, const AHits& hits) const
180  {
181  CDCObservations2D observations2D;
182  observations2D.setFitVariance(m_fitVariance);
183 
184  if (m_usePosition) {
185  observations2D.setFitPos(EFitPos::c_RecoPos);
186  observations2D.appendRange(hits);
187  }
188  if (m_useOrientation) {
189  observations2D.setFitPos(EFitPos::c_RLDriftCircle);
190  observations2D.appendRange(hits);
191  }
192 
193  if (observations2D.size() < 4) {
194  trajectory2D.clear();
195  } else {
196  AFitMethod::update(trajectory2D, observations2D);
197  }
198  }
199 
200  template <class AFitMethod>
201  void CDCFitter2D<AFitMethod>::useOnlyPosition()
202  {
203  m_usePosition = true;
204  m_useOrientation = false;
205  }
206 
207  template <class AFitMethod>
208  void CDCFitter2D<AFitMethod>::useOnlyOrientation()
209  {
210  m_usePosition = false;
211  m_useOrientation = true;
212  }
213 
214  template <class AFitMethod>
216  {
217  m_usePosition = true;
218  m_useOrientation = true;
219  }
220 
221  template <class AFitMethod>
222  void CDCFitter2D<AFitMethod>::setFitVariance(EFitVariance fitVariance)
223  {
224  m_fitVariance = fitVariance;
225  }
226  }
228 }
Belle2::TrackFindingCDC::CDCObservations2D::size
std::size_t size() const
Returns the number of observations stored.
Definition: CDCObservations2D.h:88
Belle2::TrackFindingCDC::CDCTrack
Class representing a sequence of three dimensional reconstructed hits.
Definition: CDCTrack.h:51
Belle2::TrackFindingCDC::CDCSegment3D
A segment consisting of three dimensional reconstructed hits.
Definition: CDCSegment3D.h:36
Belle2::TrackFindingCDC::CDCTrajectory2D
Particle trajectory as it is seen in xy projection represented as a circle.
Definition: CDCTrajectory2D.h:46
Belle2::TrackFindingCDC::CDCObservations2D::setFitPos
void setFitPos(EFitPos fitPos)
Setter for the indicator that the reconstructed position should be favoured.
Definition: CDCObservations2D.h:330
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::CDCWireHitSegment
A segment consisting of two dimensional reconsturcted hits.
Definition: CDCWireHitSegment.h:34
Belle2::TrackFindingCDC::CDCObservations2D
Class serving as a storage of observed drift circles to present to the Riemann fitter.
Definition: CDCObservations2D.h:53
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::CDCFitter2D
Class implementing a fit for two dimensional trajectory circle using a generic fitting backend.
Definition: CDCFitter2D.h:43
Belle2::TrackFindingCDC::CDCObservations2D::setFitVariance
void setFitVariance(EFitVariance fitVariance)
Setter for the indicator that the drift variance should be used.
Definition: CDCObservations2D.h:336
Belle2::TrackFindingCDC::CDCFitter2D::CDCFitter2D
CDCFitter2D()
Default constructor.
Definition: CDCFitter2D.icc.h:37
Belle2::TrackFindingCDC::CDCSegment2D
A reconstructed sequence of two dimensional hits in one super layer.
Definition: CDCSegment2D.h:40
Belle2::TrackFindingCDC::CDCTrajectory2D::clear
void clear()
Clears all information from this trajectoy.
Definition: CDCTrajectory2D.cc:90