Belle II Software  release-05-01-25
HelixParameters.cc
1 /**************************************************************************
2  * BASF2 (Belle Analysis Framework 2) *
3  * Copyright(C) 2016 - 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/geometry/UncertainParameters.icc.h>
11 
12 #include <tracking/trackFindingCDC/geometry/HelixParameters.h>
13 
14 #include <tracking/trackFindingCDC/numerics/CovarianceMatrixUtil.h>
15 #include <tracking/trackFindingCDC/numerics/ParameterVectorUtil.h>
16 
17 #include <tracking/trackFindingCDC/numerics/Angle.h>
18 
19 using namespace Belle2;
20 using namespace TrackFindingCDC;
21 
23 
25 {
27 }
28 
30 {
31  using namespace NHelixParameterIndices;
32  return getSubParameterVector<PerigeeUtil::ParameterVector, c_Curv>(helixPar);
33 }
34 
36 {
37  using namespace NHelixParameterIndices;
38  return getSubParameterVector<SZUtil::ParameterVector, c_TanL>(helixPar);
39 }
40 
42  const SZUtil::ParameterVector& szPar)
43 {
44  ParameterVector result = ParameterVectorUtil::stack(perigeePar, szPar);
45  return result;
46 }
47 
49 {
50  using namespace NHelixParameterIndices;
51  return getSubCovarianceMatrix<PerigeeUtil::CovarianceMatrix, c_Curv>(helixCov);
52 }
53 
55 {
56  using namespace NHelixParameterIndices;
57  return getSubCovarianceMatrix<SZUtil::CovarianceMatrix, c_TanL>(helixCov);
58 }
59 
61  const SZUtil::CovarianceMatrix& szCov)
62 {
63  CovarianceMatrix result = CovarianceMatrixUtil::stackBlocks(perigeeCov, szCov);
64  return result;
65 }
66 
68 {
69  return PerigeeAmbiguity::Zero();
70 }
71 
72 double HelixUtil::average(const HelixParameters& fromPar,
73  const HelixCovariance& fromCov,
74  const HelixParameters& toPar,
75  const HelixCovariance& toCov,
76  HelixParameters& avgPar,
77  HelixCovariance& avgCov)
78 {
79  using namespace NHelixParameterIndices;
80  HelixParameters refPar = (fromPar + toPar) / 2.0;
81  refPar[c_Phi0] = AngleUtil::average(fromPar[c_Phi0], toPar[c_Phi0]);
82 
83  HelixParameters relFromPar = fromPar - refPar;
84  AngleUtil::normalise(relFromPar[c_Phi0]);
85 
86  HelixParameters relToPar = toPar - refPar;
87  AngleUtil::normalise(relToPar[c_Phi0]);
88 
89  HelixParameters relAvgPar;
90  double chi2 =
91  CovarianceMatrixUtil::average(relFromPar, fromCov, relToPar, toCov, relAvgPar, avgCov);
92 
93  avgPar = relAvgPar + refPar;
94  AngleUtil::normalise(avgPar[c_Phi0]);
95 
96  return chi2;
97 }
98 
99 double HelixUtil::average(const PerigeeParameters& fromPar,
100  const PerigeeCovariance& fromCov,
101  const PerigeeHelixAmbiguity& fromAmbiguity,
102  const HelixParameters& toPar,
103  const HelixCovariance& toCov,
104  HelixParameters& avgPar,
105  HelixCovariance& avgCov)
106 {
107  auto toAmbiguity = JacobianMatrixUtil::identity<5>();
108 
109  using namespace NPerigeeParameterIndices;
110  PerigeeParameters refPar = (fromPar + toPar.head<3>()) / 2.0;
111  refPar[c_Phi0] = AngleUtil::average(fromPar[c_Phi0], toPar[c_Phi0]);
112 
113  HelixParameters refHelixPar = stack(refPar, toPar.tail<2>());
114 
115  PerigeeParameters relFromPar = fromPar - refPar;
116  AngleUtil::normalise(relFromPar[c_Phi0]);
117 
118  HelixParameters relToPar = toPar - refHelixPar;
119  AngleUtil::normalise(relToPar[c_Phi0]);
120 
121  HelixParameters relAvgPar;
122 
123  // Chi2 value
124  double chi2 = CovarianceMatrixUtil::average(relFromPar,
125  fromCov,
126  fromAmbiguity,
127  relToPar,
128  toCov,
129  toAmbiguity,
130  relAvgPar,
131  avgCov);
132 
133  avgPar = relAvgPar + refHelixPar;
134  AngleUtil::normalise(avgPar[c_Phi0]);
135 
136  return chi2;
137 }
138 
139 double HelixUtil::average(const PerigeeParameters& fromPar,
140  const PerigeeCovariance& fromCov,
141  const PerigeeHelixAmbiguity& fromAmbiguity,
142  const PerigeeParameters& toPar,
143  const PerigeeCovariance& toCov,
144  const PerigeeHelixAmbiguity& toAmbiguity,
145  const SZParameters& szParameters,
146  HelixParameters& avgPar,
147  HelixCovariance& avgCov)
148 {
149  using namespace NPerigeeParameterIndices;
150  PerigeeParameters refPar = (fromPar + toPar) / 2.0;
151  refPar[c_Phi0] = AngleUtil::average(fromPar[c_Phi0], toPar[c_Phi0]);
152 
153  HelixParameters refHelixPar = stack(refPar, szParameters);
154 
155  PerigeeParameters relFromPar = fromPar - refPar;
156  AngleUtil::normalise(relFromPar[c_Phi0]);
157 
158  PerigeeParameters relToPar = toPar - refPar;
159  AngleUtil::normalise(relToPar[c_Phi0]);
160 
161  HelixParameters relAvgPar;
162 
163  // Chi2 value
164  double chi2 = CovarianceMatrixUtil::average(relFromPar,
165  fromCov,
166  fromAmbiguity,
167  relToPar,
168  toCov,
169  toAmbiguity,
170  relAvgPar,
171  avgCov);
172 
173  avgPar = relAvgPar + refHelixPar;
174  AngleUtil::normalise(avgPar[c_Phi0]);
175 
176  return chi2;
177 }
Belle2::TrackFindingCDC::HelixUtil::stack
static HelixUtil::ParameterVector stack(const PerigeeUtil::ParameterVector &perigeePar, const SZUtil::ParameterVector &szPar)
Combine parameters from the xy space and the sz space.
Definition: HelixParameters.cc:41
Belle2::TrackFindingCDC::CovarianceMatrixUtil::stackBlocks
static CovarianceMatrix< N1+N2 > stackBlocks(const CovarianceMatrix< N1 > &block1, const CovarianceMatrix< N2 > &block2)
Combines two covariance matrices by putting them in two blocks on the diagonal of a larger matrix.
Definition: CovarianceMatrixUtil.h:90
Belle2::TrackFindingCDC::CovarianceMatrixUtil::average
static double average(const ParameterVector< N > &par1, const CovarianceMatrix< N > &cov1, const ParameterVector< N > &par2, const CovarianceMatrix< N > &cov2, ParameterVector< N > &par, CovarianceMatrix< N > &cov)
Averages two parameter vectors taking into account their respective covariances.
Definition: CovarianceMatrixUtil.h:156
Belle2::TrackFindingCDC::PlainMatrix::Zero
static PlainMatrix< T, M, N > Zero()
Construct a matrix initialized with zeros.
Definition: PlainMatrix.h:77
Belle2::TrackFindingCDC::AngleUtil::normalise
static void normalise(double &angle)
Normalise an angle inplace to lie in the range from [-pi, pi].
Definition: Angle.h:51
Belle2::TrackFindingCDC::HelixUtil::getSZParameters
static SZUtil::ParameterVector getSZParameters(const ParameterVector &helixPar)
Get sz parameters.
Definition: HelixParameters.cc:35
Belle2::TrackFindingCDC::HelixUtil::average
static double average(const HelixUtil::ParameterVector &fromPar, const HelixUtil::CovarianceMatrix &fromCov, const HelixUtil::ParameterVector &toPar, const HelixUtil::CovarianceMatrix &toCov, HelixUtil::ParameterVector &avgPar, HelixUtil::CovarianceMatrix &avgCov)
Calculates the weighted average between two helix parameter sets with their respective covariance mat...
Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:19
Belle2::TrackFindingCDC::HelixUtil::getPerigeeCovariance
static PerigeeUtil::CovarianceMatrix getPerigeeCovariance(const CovarianceMatrix &helixCov)
Get perigee covariance matrix related to the xy space.
Definition: HelixParameters.cc:48
Belle2::TrackFindingCDC::PerigeeUtil::reversalSigns
static ParameterVector reversalSigns()
Getter for the signs which have to be applied to reverse the traversal direction.
Definition: PerigeeParameters.h:60
Belle2::TrackFindingCDC::HelixUtil::getPerigeeParameters
static PerigeeUtil::ParameterVector getPerigeeParameters(const ParameterVector &helixPar)
Get helix parameters related to the xy space.
Definition: HelixParameters.cc:29
Belle2::TrackFindingCDC::AngleUtil::average
static double average(const double angle1, double angle2)
Combines two angluar values to the one that lies half way between them on the short arc.
Definition: Angle.h:37
Belle2::TrackFindingCDC::HelixUtil::getSZCovariance
static SZUtil::CovarianceMatrix getSZCovariance(const CovarianceMatrix &helixCov)
Get sz covariance matrix.
Definition: HelixParameters.cc:54
Belle2::TrackFindingCDC::UncertainParametersUtil< HelixUtil, EHelixParameter >
Belle2::TrackFindingCDC::PlainMatrix
A matrix implementation to be used as an interface typ through out the track finder.
Definition: PlainMatrix.h:50
Belle2::TrackFindingCDC::SZUtil::reversalSigns
static ParameterVector reversalSigns()
Getter for the signs which have to be applied to reverse the parameters.
Definition: SZParameters.h:57
Belle2::TrackFindingCDC::ParameterVectorUtil::stack
static ParameterVector< N1+N2 > stack(const ParameterVector< N1 > &upperPar, const ParameterVector< N2 > &lowerPar)
Combines two parameter vectors by stacking them over each other.
Definition: ParameterVectorUtil.h:47
Belle2::TrackFindingCDC::HelixUtil::defaultPerigeeAmbiguity
static PerigeeAmbiguity defaultPerigeeAmbiguity()
Initialse a default covariance matrix to zero.
Definition: HelixParameters.cc:67
Belle2::TrackFindingCDC::HelixUtil::stackBlocks
static HelixUtil::CovarianceMatrix stackBlocks(const PerigeeUtil::CovarianceMatrix &perigeeCov, const SZUtil::CovarianceMatrix &szCov)
Combine covariance matrices from the xy space and the sz space in their respective blocks.
Definition: HelixParameters.cc:60
Belle2::TrackFindingCDC::HelixUtil::reversalSigns
static HelixUtil::ParameterVector reversalSigns()
Getter for the signs which have to be applied to reverse the parameters.
Definition: HelixParameters.cc:24