Belle II Software  release-05-01-25
CDCTrajectory3D.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/eventdata/trajectories/CDCTrajectory3D.h>
11 
12 #include <tracking/trackFindingCDC/eventdata/trajectories/CDCTrajectory2D.h>
13 #include <tracking/trackFindingCDC/eventdata/trajectories/CDCTrajectorySZ.h>
14 
15 #include <tracking/trackFindingCDC/eventdata/trajectories/CDCBFieldUtil.h>
16 
17 #include <tracking/trackFindingCDC/topology/CDCWireTopology.h>
18 
19 #include <tracking/trackFindingCDC/geometry/UncertainHelix.h>
20 #include <tracking/trackFindingCDC/geometry/Helix.h>
21 #include <tracking/trackFindingCDC/geometry/HelixParameters.h>
22 #include <tracking/trackFindingCDC/geometry/UncertainPerigeeCircle.h>
23 #include <tracking/trackFindingCDC/geometry/UncertainSZLine.h>
24 #include <tracking/trackFindingCDC/geometry/PerigeeCircle.h>
25 
26 #include <tracking/trackFindingCDC/geometry/Vector3D.h>
27 #include <tracking/trackFindingCDC/geometry/Vector2D.h>
28 
29 #include <tracking/trackFindingCDC/numerics/ESign.h>
30 #include <tracking/trackFindingCDC/numerics/Quadratic.h>
31 
32 #include <tracking/trackFindingCDC/numerics/CovarianceMatrixUtil.h>
33 #include <tracking/trackFindingCDC/numerics/JacobianMatrixUtil.h>
34 #include <tracking/trackFindingCDC/numerics/TMatrixConversion.h>
35 
36 #include <genfit/TrackCand.h>
37 
38 #include <mdst/dataobjects/MCParticle.h>
39 
40 #include <framework/gearbox/Const.h>
41 
42 #include <TMatrixDSym.h>
43 #include <TVector3.h>
44 
45 #include <ostream>
46 
47 using namespace Belle2;
48 using namespace TrackFindingCDC;
49 
51  const CDCTrajectorySZ& trajectorySZ)
52  : m_localOrigin(trajectory2D.getLocalOrigin())
53  , m_localHelix(trajectory2D.getLocalCircle(), trajectorySZ.getSZLine())
54  , m_flightTime(trajectory2D.getFlightTime())
55 {
56 }
57 
59  : CDCTrajectory3D(trajectory2D, CDCTrajectorySZ::basicAssumption())
60 {
61 }
62 
64  const double time,
65  const Vector3D& mom3D,
66  const double charge,
67  const double bZ)
68  : m_localOrigin(pos3D)
69  , m_localHelix(CDCBFieldUtil::absMom2DToCurvature(mom3D.xy().norm(), charge, bZ),
70  mom3D.xy().unit(),
71  0.0,
72  mom3D.cotTheta(),
73  0.0)
74  , m_flightTime(time)
75 {
76 }
77 
79  const double time,
80  const Vector3D& mom3D,
81  const double charge)
82  : CDCTrajectory3D(pos3D, time, mom3D, charge, CDCBFieldUtil::getBFieldZ(pos3D))
83 {
84 }
85 
86 CDCTrajectory3D::CDCTrajectory3D(const MCParticle& mcParticle, const double bZ)
87  : CDCTrajectory3D(Vector3D{mcParticle.getProductionVertex()},
88  mcParticle.getProductionTime(),
89  Vector3D{mcParticle.getMomentum()},
90  mcParticle.getCharge(),
91  bZ)
92 {
93 }
94 
97  mcParticle.getProductionTime(),
98  Vector3D{mcParticle.getMomentum()},
99  mcParticle.getCharge())
100 {
101 }
102 
103 CDCTrajectory3D::CDCTrajectory3D(const genfit::TrackCand& gfTrackCand, const double bZ)
104  : CDCTrajectory3D(Vector3D{gfTrackCand.getPosSeed()},
105  gfTrackCand.getTimeSeed(),
106  Vector3D{gfTrackCand.getMomSeed()},
107  gfTrackCand.getChargeSeed(),
108  bZ)
109 {
110  // Maybe push these out of this function:
111  // Indices of the cartesian coordinates
112  const int iX = 0;
113  const int iY = 1;
114  const int iZ = 2;
115  const int iPx = 3;
116  const int iPy = 4;
117  const int iPz = 5;
118 
119  const TMatrixDSym& seedCov = gfTrackCand.getCovSeed();
120  CovarianceMatrix<6> cov6 = TMatrixConversion::fromTMatrix<6>(seedCov);
121 
122  // 1. Rotate to a system where phi0 = 0
123  JacobianMatrix<6, 6> jacobianRot = JacobianMatrixUtil::zero<6, 6>();
124 
125  const double px = gfTrackCand.getStateSeed()[iPx];
126  const double py = gfTrackCand.getStateSeed()[iPy];
127  const double pt = hypot2(px, py);
128 
129  const double cosPhi0 = px / pt;
130  const double sinPhi0 = py / pt;
131 
132  // Passive rotation matrix by phi0:
133  jacobianRot(iX, iX) = cosPhi0;
134  jacobianRot(iX, iY) = sinPhi0;
135  jacobianRot(iY, iX) = -sinPhi0;
136  jacobianRot(iY, iY) = cosPhi0;
137  jacobianRot(iZ, iZ) = 1.0;
138 
139  jacobianRot(iPx, iPx) = cosPhi0;
140  jacobianRot(iPx, iPy) = sinPhi0;
141  jacobianRot(iPy, iPx) = -sinPhi0;
142  jacobianRot(iPy, iPy) = cosPhi0;
143  jacobianRot(iPz, iPz) = 1.0;
144 
145  // Apply transformation inplace
146  CovarianceMatrixUtil::transport(jacobianRot, cov6);
147 
148  // 2. Translate to perigee parameters
149  JacobianMatrix<5, 6> jacobianReduce = JacobianMatrixUtil::zero<5, 6>();
150 
151  const double invPt = 1 / pt;
152  const double invPtSquared = invPt * invPt;
153  const double pz = gfTrackCand.getStateSeed()[iPz];
154  const double alpha = CDCBFieldUtil::getAlphaFromBField(bZ);
155  const double charge = gfTrackCand.getChargeSeed();
156 
157  using namespace NHelixParameterIndices;
158  jacobianReduce(c_Curv, iPx) = charge * invPtSquared / alpha ;
159  jacobianReduce(c_Phi0, iPy) = invPt;
160  jacobianReduce(c_I, iY) = 1;
161  jacobianReduce(c_TanL, iPx) = - pz * invPtSquared;
162  jacobianReduce(c_TanL, iPz) = invPt;
163  jacobianReduce(c_Z0, iZ) = 1;
164  // Note the column corresponding to iX is completely zero as expectable.
165 
166  CovarianceMatrix<5> cov5 = CovarianceMatrixUtil::transported(jacobianReduce, cov6);
167  const HelixCovariance& helixCovariance = cov5;
168 
169  // The covariance should now be the correct 5x5 covariance matrix.
170  m_localHelix.setHelixCovariance(helixCovariance);
171 }
172 
174  : CDCTrajectory3D(gfTrackCand, CDCBFieldUtil::getBFieldZ(Vector3D{gfTrackCand.getPosSeed()}))
175 {
176 }
177 
178 namespace {
179  CovarianceMatrix<6> calculateCovarianceMatrix(const UncertainHelix& localHelix,
180  const Vector3D& momentum,
181  const ESign charge,
182  const double bZ)
183  {
184  const double impactXY = localHelix->impactXY();
185  const Vector2D& phi0Vec = localHelix->phi0Vec();
186 
187  const double cosPhi0 = phi0Vec.x();
188  const double sinPhi0 = phi0Vec.y();
189 
190  const double curvatureXY = localHelix->curvatureXY();
191  const double tanLambda = localHelix->tanLambda();
192 
193  // 0. Define indices
194  // Maybe push these out of this function:
195  // Indices of the cartesian coordinates
196  const int iX = 0;
197  const int iY = 1;
198  const int iZ = 2;
199  const int iPx = 3;
200  const int iPy = 4;
201  const int iPz = 5;
202 
203  CovarianceMatrix<5> cov5 = localHelix.helixCovariance();
204 
205  // 1. Inflat the perigee covariance to a cartesian covariance where phi0 = 0 is assumed
206  // Jacobian matrix for the translation
207  JacobianMatrix<6, 5> jacobianInflate = JacobianMatrixUtil::zero<6, 5>();
208 
209  const double alpha = CDCBFieldUtil::getAlphaFromBField(bZ);
210  const double chargeAlphaCurv = charge * alpha * curvatureXY;
211  const double chargeAlphaCurv2 = charge * alpha * std::pow(curvatureXY, 2);
212 
213  const double invChargeAlphaCurv = 1.0 / chargeAlphaCurv;
214  const double invChargeAlphaCurv2 = 1.0 / chargeAlphaCurv2;
215 
216  using namespace NHelixParameterIndices;
217  // Position
218  jacobianInflate(iX, c_Phi0) = -impactXY;
219  jacobianInflate(iY, c_I) = 1.0;
220  jacobianInflate(iZ, c_Z0) = 1.0;
221 
222  // Momentum
223  if (bZ == 0) {
224  jacobianInflate(iPx, c_Curv) = 0;
225  jacobianInflate(iPy, c_Phi0) = momentum.cylindricalR();
226  jacobianInflate(iPz, c_Curv) = 0;
227  jacobianInflate(iPz, c_TanL) = momentum.cylindricalR();
228  } else {
229  jacobianInflate(iPx, c_Curv) = invChargeAlphaCurv2;
230  jacobianInflate(iPy, c_Phi0) = - invChargeAlphaCurv;
231  jacobianInflate(iPz, c_Curv) = tanLambda * invChargeAlphaCurv2;
232  jacobianInflate(iPz, c_TanL) = - invChargeAlphaCurv;
233  }
234 
235  // Transform
236  CovarianceMatrix<6> cov6 = CovarianceMatrixUtil::transported(jacobianInflate, cov5);
237 
239  JacobianMatrix<6, 6> jacobianRot = JacobianMatrixUtil::zero<6, 6>();
240 
241  // Active rotation matrix by phi0:
242  jacobianRot(iX, iX) = cosPhi0;
243  jacobianRot(iX, iY) = -sinPhi0;
244  jacobianRot(iY, iX) = sinPhi0;
245  jacobianRot(iY, iY) = cosPhi0;
246  jacobianRot(iZ, iZ) = 1.0;
247 
248  jacobianRot(iPx, iPx) = cosPhi0;
249  jacobianRot(iPx, iPy) = -sinPhi0;
250  jacobianRot(iPy, iPx) = sinPhi0;
251  jacobianRot(iPy, iPy) = cosPhi0;
252  jacobianRot(iPz, iPz) = 1.0;
253 
254  // Apply transformation inplace
255  CovarianceMatrixUtil::transport(jacobianRot, cov6);
256 
257  // 3. Forward the covariance matrix.
258  return cov6;
259  }
260 }
261 
262 
264 {
265  Vector3D position = getSupport();
266  return fillInto(trackCand, CDCBFieldUtil::getBFieldZ(position));
267 }
268 
269 bool CDCTrajectory3D::fillInto(genfit::TrackCand& gfTrackCand, const double bZ) const
270 {
271  // Set the start parameters
272  Vector3D position = getSupport();
273  Vector3D momentum = bZ == 0 ? getFlightDirection3DAtSupport() : getMom3DAtSupport(bZ);
274  ESign charge = getChargeSign();
275 
276  // Do not propagate invalid fits, signal that the fit is invalid to the caller.
277  if (not ESignUtil::isValid(charge) or momentum.hasNAN() or position.hasNAN()) {
278  return false;
279  }
280 
281  gfTrackCand.setPosMomSeed(position, momentum, charge);
282 
283  const CovarianceMatrix<6> cov6 = calculateCovarianceMatrix(getLocalHelix(), momentum, charge, bZ);
284  TMatrixDSym covSeed = TMatrixConversion::toTMatrix(cov6);
285 
286  gfTrackCand.setCovSeed(covSeed);
287 
288  return true;
289 }
290 
292 {
293  // Set the start parameters
294  Vector3D momentum = bZ == 0 ? getFlightDirection3DAtSupport() : getMom3DAtSupport(bZ);
295  ESign charge = getChargeSign();
296  return calculateCovarianceMatrix(getLocalHelix(), momentum, charge, bZ);
297 }
298 
299 bool CDCTrajectory3D::isCurler(double factor) const
300 {
301  const CDCWireTopology& topology = CDCWireTopology::getInstance();
302  return getMaximalCylindricalR() < factor * topology.getOuterCylindricalR();
303 }
304 
306 {
307  return CDCBFieldUtil::ccwInfoToChargeSign(getLocalHelix()->circleXY().orientation());
308 }
309 
310 double CDCTrajectory3D::getAbsMom3D(const double bZ) const
311 {
312  double tanLambda = getLocalHelix()->tanLambda();
313  double factor2DTo3D = hypot2(1, tanLambda);
314  double curvatureXY = getLocalHelix()->curvatureXY();
315  double absMom2D = CDCBFieldUtil::curvatureToAbsMom2D(curvatureXY, bZ);
316  return factor2DTo3D * absMom2D;
317 }
318 
320 {
321  Vector3D position = getSupport();
322  double tanLambda = getLocalHelix()->tanLambda();
323  double factor2DTo3D = hypot2(1, tanLambda);
324  double curvatureXY = getLocalHelix()->curvatureXY();
325  double absMom2D = CDCBFieldUtil::curvatureToAbsMom2D(curvatureXY, position);
326  return factor2DTo3D * absMom2D;
327 }
328 
329 double CDCTrajectory3D::shiftPeriod(int nPeriods)
330 {
331  double arcLength2D = m_localHelix.shiftPeriod(nPeriods);
332  m_flightTime += arcLength2D / Const::speedOfLight;
333  return arcLength2D;
334 }
335 
337 {
338  return CDCTrajectory2D(getLocalOrigin().xy(),
339  getLocalHelix().uncertainCircleXY(),
340  getFlightTime());
341 }
342 
344 {
345  UncertainSZLine globalSZLine = getLocalHelix().uncertainSZLine();
346  globalSZLine.passiveMoveBy(Vector2D(0, -getLocalOrigin().z()));
347  return CDCTrajectorySZ(globalSZLine);
348 }
349 
350 
352 {
353  // Down cast since we do not necessarily wont the covariance matrix transformed as well
354  PerigeeCircle result(getLocalHelix()->circleXY());
355  result.passiveMoveBy(-getLocalOrigin().xy());
356  return result;
357 }
358 
360 {
361  return getLocalHelix().uncertainCircleXY();
362 }
363 
365 {
366  return getLocalHelix().uncertainSZLine();
367 }
368 
369 double CDCTrajectory3D::setLocalOrigin(const Vector3D& localOrigin)
370 {
371  double arcLength2D = calcArcLength2D(localOrigin);
372  double factor2DTo3D = hypot2(1, getTanLambda());
373  double arcLength3D = arcLength2D * factor2DTo3D;
374  m_flightTime += arcLength3D / Const::speedOfLight;
376  m_localOrigin = localOrigin;
377  return arcLength2D;
378 }
379 
380 std::ostream& TrackFindingCDC::operator<<(std::ostream& output, const CDCTrajectory3D& trajectory3D)
381 {
382  return output << "Local origin : " << trajectory3D.getLocalOrigin() << ", "
383  << "local helix : " << trajectory3D.getLocalHelix();
384 }
Belle2::TrackFindingCDC::CDCBFieldUtil::getAlphaFromBField
static double getAlphaFromBField(double bField)
Translater from magnetic field strength in Tesla to the alpha value.
Definition: CDCBFieldUtil.cc:62
Belle2::EvtPDLUtil::charge
double charge(int pdgCode)
Returns electric charge of a particle with given pdg code.
Definition: EvtPDLUtil.cc:46
Belle2::TrackFindingCDC::Vector3D::hasNAN
bool hasNAN() const
Checks if one of the coordinates is NAN.
Definition: Vector3D.h:157
Belle2::TrackFindingCDC::UncertainHelix::shiftPeriod
double shiftPeriod(int nPeriods)
Adjust the arclength measure to start n periods later.
Definition: UncertainHelix.h:337
Belle2::TrackFindingCDC::CDCTrajectory3D::getTanLambda
double getTanLambda() const
Getter for the slope of z over the transverse travel distance s.
Definition: CDCTrajectory3D.h:299
Belle2::Vector3D
HepGeom::Vector3D< double > Vector3D
3D Vector
Definition: Cell.h:35
Belle2::TrackFindingCDC::CovarianceMatrixUtil::transported
static CovarianceMatrix< M > transported(const JacobianMatrix< M, N > &jacobian, const CovarianceMatrix< N > &cov)
Return a copy of the covariance matrix transported with the given jacobian matrix.
Definition: CovarianceMatrixUtil.h:64
Belle2::MCParticle::getCharge
float getCharge() const
Return the particle charge defined in TDatabasePDG.
Definition: MCParticle.cc:35
Belle2::UncertainHelix
This class represents an ideal helix in perigee parameterization including the covariance matrix of t...
Definition: UncertainHelix.h:40
Belle2::operator<<
std::ostream & operator<<(std::ostream &output, const IntervalOfValidity &iov)
Definition: IntervalOfValidity.cc:196
Belle2::TrackFindingCDC::UncertainHelix::uncertainCircleXY
UncertainPerigeeCircle uncertainCircleXY() const
Projects the helix into the xy plain carrying over the relevant parts of the convariance matrix.
Definition: UncertainHelix.h:235
Belle2::TrackFindingCDC::CDCTrajectory3D::CDCTrajectory3D
CDCTrajectory3D()
Default constructor for ROOT compatibility.
Definition: CDCTrajectory3D.h:51
Belle2::TrackFindingCDC::UncertainSZLine::passiveMoveBy
void passiveMoveBy(const Vector2D &bySZ)
Moves the coordinate system by the vector by and calculates the new sz line and its covariance matrix...
Definition: UncertainSZLine.h:193
Belle2::TrackFindingCDC::Helix::curvatureXY
double curvatureXY() const
Getter for the signed curvature in the xy projection.
Definition: Helix.h:214
Belle2::TrackFindingCDC::CDCTrajectory3D::m_flightTime
double m_flightTime
Memory for the estimation of the time at which the particle arrived at the support point.
Definition: CDCTrajectory3D.h:386
Belle2::TrackFindingCDC::Vector2D
A two dimensional vector which is equipped with functions for correct handeling of orientation relat...
Definition: Vector2D.h:37
genfit::TrackCand
Track candidate – seed values and indices.
Definition: TrackCand.h:69
Belle2::TrackFindingCDC::UncertainSZLine
A line in sz where s is the transverse travel distance as seen in the xy projection with uncertaintie...
Definition: UncertainSZLine.h:38
Belle2::TrackFindingCDC::NHelixParameterIndices::c_Curv
@ c_Curv
Constant to address the curvature in the xy plane.
Definition: HelixParameters.h:39
Belle2::TrackFindingCDC::CDCTrajectory3D::getLocalSZLine
UncertainSZLine getLocalSZLine() const
Getter for the sz line starting from the local origin.
Definition: CDCTrajectory3D.cc:364
genfit::TrackCand::getTimeSeed
double getTimeSeed() const
Get the time at which the seed state is defined.
Definition: TrackCand.h:122
genfit::TrackCand::setCovSeed
void setCovSeed(const TMatrixDSym &cov6D)
set the covariance matrix seed (6D).
Definition: TrackCand.h:175
Belle2::TrackFindingCDC::CDCWireTopology::getInstance
static CDCWireTopology & getInstance()
Getter for the singleton instance of the wire topology.
Definition: CDCWireTopology.cc:22
Belle2::TrackFindingCDC::CDCTrajectory3D::m_localOrigin
Vector3D m_localOrigin
Memory for local coordinate origin of the circle representing the trajectory in global coordinates.
Definition: CDCTrajectory3D.h:379
Belle2::TrackFindingCDC::CDCTrajectory3D::setLocalOrigin
double setLocalOrigin(const Vector3D &localOrigin)
Setter for the origin of the local coordinate system.
Definition: CDCTrajectory3D.cc:369
Belle2::TrackFindingCDC::NHelixParameterIndices::c_TanL
@ c_TanL
Constant to address the tan lambda dip out of the xy plane.
Definition: HelixParameters.h:48
Belle2::TrackFindingCDC::Helix::tanLambda
double tanLambda() const
Getter for the proportinality factor from arc length in xy space to z.
Definition: Helix.h:250
Belle2::TrackFindingCDC::ESignUtil::ESign
ESign
Enumeration for the distinct sign values of floating point variables.
Definition: ESign.h:37
Belle2::TrackFindingCDC::ESignUtil::isValid
bool isValid(ESign s)
Returns true if sign is ESign::c_Plus, ESign::c_Minus or ESign::c_Zero.
Definition: ESign.h:56
Belle2::TrackFindingCDC::CDCTrajectorySZ
Linear trajectory in sz space.
Definition: CDCTrajectorySZ.h:41
Belle2::TrackFindingCDC::CDCTrajectory3D::shiftPeriod
double shiftPeriod(int nPeriods)
Adjusts the z0 to the one that lies n periods forward.
Definition: CDCTrajectory3D.cc:329
Belle2::TrackFindingCDC::CDCTrajectory3D::m_localHelix
UncertainHelix m_localHelix
Memory for the generalized circle describing the trajectory in coordinates from the local origin.
Definition: CDCTrajectory3D.h:383
Belle2::TrackFindingCDC::CDCTrajectory2D
Particle trajectory as it is seen in xy projection represented as a circle.
Definition: CDCTrajectory2D.h:46
Belle2::TrackFindingCDC::CDCBFieldUtil::ccwInfoToChargeSign
static ESign ccwInfoToChargeSign(ERotation ccwInfo)
Conversion helper from clockwise or counterclockwise travel to the charge sign.
Definition: CDCBFieldUtil.cc:77
Belle2::CDC::Helix::x
HepPoint3D x(double dPhi=0.) const
returns position after rotating angle dPhi in phi direction.
Definition: Helix.cc:199
genfit::TrackCand::getPosSeed
TVector3 getPosSeed() const
get the seed value for track: pos.
Definition: TrackCand.h:125
Belle2::TrackFindingCDC::CDCTrajectory3D::fillInto
bool fillInto(genfit::TrackCand &trackCand) const
Copies the trajectory information to the Genfit track candidate.
Definition: CDCTrajectory3D.cc:263
Belle2::TrackFindingCDC::CDCBFieldUtil::curvatureToAbsMom2D
static double curvatureToAbsMom2D(double curvature, double bZ)
Conversion helper for two dimensional curvature to momenta.
Definition: CDCBFieldUtil.cc:132
Belle2::Const::speedOfLight
static const double speedOfLight
[cm/ns]
Definition: Const.h:568
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::NHelixParameterIndices::c_Z0
@ c_Z0
Constant to address the z start position.
Definition: HelixParameters.h:51
Belle2::TrackFindingCDC::CDCTrajectory3D::getTrajectory2D
CDCTrajectory2D getTrajectory2D() const
Getter for the two dimensional trajectory.
Definition: CDCTrajectory3D.cc:336
Belle2::TrackFindingCDC::UncertainPerigeeCircle
Adds an uncertainty matrix to the circle in perigee parameterisation.
Definition: UncertainPerigeeCircle.h:39
Belle2::TrackFindingCDC::CDCTrajectory3D::getAbsMom3D
double getAbsMom3D() const
Get the estimation for the absolute value of the transvers momentum.
Definition: CDCTrajectory3D.cc:319
Belle2::TrackFindingCDC::CDCTrajectory3D::getTrajectorySZ
CDCTrajectorySZ getTrajectorySZ() const
Getter for the sz trajectory.
Definition: CDCTrajectory3D.cc:343
Belle2::TrackFindingCDC::CDCTrajectory3D::getMom3DAtSupport
Vector3D getMom3DAtSupport() const
Get the momentum at the start point of the trajectory.
Definition: CDCTrajectory3D.h:216
Belle2::TrackFindingCDC::CDCTrajectory3D::getMaximalCylindricalR
double getMaximalCylindricalR() const
Getter for the maximal distance from the origin.
Definition: CDCTrajectory3D.h:252
Belle2::TrackFindingCDC::CDCTrajectory3D::getCartesianCovariance
CovarianceMatrix< 6 > getCartesianCovariance(double bZ) const
Convert the helix parameters to the cartesian coordinates x,y,z,px,py,pz.
Definition: CDCTrajectory3D.cc:291
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:19
Belle2::TrackFindingCDC::Vector3D
A three dimensional vector.
Definition: Vector3D.h:34
Belle2::MCParticle::getProductionVertex
TVector3 getProductionVertex() const
Return production vertex position.
Definition: MCParticle.h:200
Belle2::TrackFindingCDC::PerigeeCircle
Extension of the generalized circle also caching the perigee coordinates.
Definition: PerigeeCircle.h:46
Belle2::TrackFindingCDC::CDCTrajectory3D::getGlobalCircle
PerigeeCircle getGlobalCircle() const
Getter for the circle in global coordinates.
Definition: CDCTrajectory3D.cc:351
Belle2::TrackFindingCDC::CDCTrajectory3D::getLocalOrigin
const Vector3D & getLocalOrigin() const
Getter for the origin of the local coordinate system.
Definition: CDCTrajectory3D.h:353
Belle2::TrackFindingCDC::CovarianceMatrixUtil::transport
static void transport(const JacobianMatrix< N, N > &jacobian, CovarianceMatrix< N > &cov)
Transport the covariance matrix inplace with the given jacobian matrix.
Definition: CovarianceMatrixUtil.h:57
Belle2::TrackFindingCDC::CDCTrajectory3D::isCurler
bool isCurler(double factor=1) const
Checks if the trajectory leaves the outer radius of the CDC times the given tolerance factor.
Definition: CDCTrajectory3D.cc:299
Belle2::TrackFindingCDC::CDCTrajectory3D::getSupport
Vector3D getSupport() const
Getter for the support point of the trajectory in global coordinates, where arcLength2D = 0.
Definition: CDCTrajectory3D.h:229
Belle2::TrackFindingCDC::CDCBFieldUtil::getBFieldZ
static double getBFieldZ()
Getter for the signed magnetic field stength in z direction at the origin ( in Tesla )
Definition: CDCBFieldUtil.cc:40
Belle2::TrackFindingCDC::CDCTrajectory3D::getFlightDirection3DAtSupport
Vector3D getFlightDirection3DAtSupport() const
Get the unit momentum at the start point of the trajectory.
Definition: CDCTrajectory3D.h:222
genfit::TrackCand::getCovSeed
const TMatrixDSym & getCovSeed() const
get the covariance matrix seed (6D).
Definition: TrackCand.h:131
Belle2::TrackFindingCDC::TMatrixConversion::toTMatrix
static TMatrixDSym toTMatrix(const CovarianceMatrix< N > &cov)
Translate the covariance matrix to the TMatrix representation.
Definition: TMatrixConversion.h:69
Belle2::TrackFindingCDC::CDCTrajectory3D::getChargeSign
ESign getChargeSign() const
Gets the charge sign of the trajectory.
Definition: CDCTrajectory3D.cc:305
Belle2::MCParticle::getMomentum
TVector3 getMomentum() const
Return momentum.
Definition: MCParticle.h:209
Belle2::TrackFindingCDC::CDCTrajectory3D::getLocalCircle
UncertainPerigeeCircle getLocalCircle() const
Getter for the circle in local coordinates.
Definition: CDCTrajectory3D.cc:359
Belle2::TrackFindingCDC::NHelixParameterIndices::c_I
@ c_I
Constant to address the impact parameter.
Definition: HelixParameters.h:45
genfit::TrackCand::getStateSeed
const TVectorD & getStateSeed() const
Returns the 6D seed state; should be in global coordinates.
Definition: TrackCand.h:134
Belle2::TrackFindingCDC::PlainMatrix
A matrix implementation to be used as an interface typ through out the track finder.
Definition: PlainMatrix.h:50
Belle2::MCParticle
A Class to store the Monte Carlo particle information.
Definition: MCParticle.h:43
Belle2::TrackFindingCDC::UncertainHelix::passiveMoveBy
void passiveMoveBy(const Vector3D &by)
Moves the coordinate system by the vector by and calculates the new perigee and its covariance matrix...
Definition: UncertainHelix.h:325
Belle2::TrackFindingCDC::CDCTrajectory3D::getFlightTime
double getFlightTime() const
Getter for the time when the particle reached the support point position.
Definition: CDCTrajectory3D.h:366
Belle2::TrackFindingCDC::CDCWireTopology::getOuterCylindricalR
double getOuterCylindricalR() const
Getter for the outer radius of the outer most wire layer.
Definition: CDCWireTopology.h:481
Belle2::TrackFindingCDC::CDCBFieldUtil
Helper functions to interact with the magnetic field.
Definition: CDCBFieldUtil.h:33
Belle2::TrackFindingCDC::UncertainHelix::uncertainSZLine
UncertainSZLine uncertainSZLine() const
Reduces the helix to an sz line carrying over the relevant parts of the convariance matrix.
Definition: UncertainHelix.h:243
Belle2::TrackFindingCDC::CDCTrajectory3D::getLocalHelix
const UncertainHelix & getLocalHelix() const
Getter for the helix in local coordinates.
Definition: CDCTrajectory3D.h:341
Belle2::TrackFindingCDC::NHelixParameterIndices::c_Phi0
@ c_Phi0
Constant to address the azimuth angle of the direction of flight.
Definition: HelixParameters.h:42
Belle2::TrackFindingCDC::CDCTrajectory3D
Particle full three dimensional trajectory.
Definition: CDCTrajectory3D.h:47
genfit::TrackCand::setPosMomSeed
void setPosMomSeed(const TVector3 &pos, const TVector3 &mom, const double charge)
sets the state to seed the track fitting.
Definition: TrackCand.cc:258
Belle2::TrackFindingCDC::CDCWireTopology
Class representating the sense wire arrangement in the whole of the central drift chamber.
Definition: CDCWireTopology.h:54
Belle2::MCParticle::getProductionTime
float getProductionTime() const
Return production time in ns.
Definition: MCParticle.h:170
genfit::TrackCand::getMomSeed
TVector3 getMomSeed() const
get the seed value for track: mom.
Definition: TrackCand.h:128