3 #include <Math/SMatrix.h>
4 #include <Math/MatrixFunctions.h>
21 static inline double sqr(
double arg) {
return arg *
arg; }
23 using namespace ROOT::Math;
25 typedef SMatrix<double, 3, 4> Matrix34;
26 typedef SMatrix<double, 4, 5> Matrix45;
27 typedef SMatrix<double, 5, 4> Matrix54;
28 typedef SMatrix<double, 4, 6> Matrix46;
29 typedef SMatrix<double, 6, 4> Matrix64;
30 typedef SMatrix<double, 6, 6, MatRepSym<double, 6> > Matrix6S;
54 using namespace ROOT::Math;
56 double rho2 = pred[2] * pred[2] + 1.;
60 jacobian(0, 1) = pred[0] * pred[2];
63 jacobian(2, 1) = rho2;
66 return Similarity(jacobian, error.
matrix());
75 using namespace ROOT::Math;
77 double perp2 = direction.perp2();
79 double tip = priorPosition.y() *
dir.x() - priorPosition.x() *
dir.y();
80 double l = priorPosition.x() *
dir.x() + priorPosition.y() *
dir.y();
88 jacobian(0, 0) = -
dir.x() *
dir.z();
89 jacobian(1, 0) = -
dir.y();
90 jacobian(0, 1) = -
dir.y() *
dir.z();
91 jacobian(1, 1) =
dir.x();
93 jacobian(0, 3) = -
dir.z() * priorPosition.x();
94 jacobian(1, 3) = priorPosition.y();
95 jacobian(3, 3) = -
dir.y();
96 jacobian(0, 4) = -
dir.z() * priorPosition.y();
97 jacobian(1, 4) = -priorPosition.x();
98 jacobian(3, 4) =
dir.x();
103 origCov.Place_at(priorError.
matrix_new(), 0, 0);
115 double dTheta = std::cosh((
double)direction.eta()) * coneRadius;
117 double r2 = direction.mag2();
119 double perp = direction.perp();
120 double P = direction.x() /
perp;
121 double p = direction.y() /
perp;
122 double T = direction.z() /
r;
124 double h2 = dTheta * dTheta;
125 double d2 = coneRadius * coneRadius;
127 GlobalError cov(r2 * (T*T * P*P * h2 + t*t * p*p * d2),
128 r2 * p*P * (T*T * h2 - t*t * d2),
129 r2 * (T*T * p*p * h2 + t*t * P*P * d2),
134 init(priorPosition, priorError, direction, cov);
148 prediction_(
convert(trajectory)),
149 covariance_(
convert(prediction_, error))
159 covariance_(
convert(prediction_, track.covariance()))
165 using namespace ROOT::Math;
172 jacobian(0, 3) = -
y * lambda -
x *
ip();
174 jacobian(1, 3) =
x * lambda -
y *
ip();
183 using namespace ROOT::Math;
190 jacobian(0, 3) = -
y * lambda -
x *
ip();
192 jacobian(1, 3) =
x * lambda -
y *
ip();
218 double rho2I = 1. /
rho2();
222 jacobian(1, 2) = rho2I;
225 jacobian(4, 0) = rhoI;
226 jacobian(4, 2) = -
z() * rhoI *
cotTheta() * rho2I;
const GlobalPoint origin() const
ROOT::Math::SMatrix< double, 4, 4, ROOT::Math::MatRepSym< double, 4 > > Error
double lambda(const GlobalPoint &point) const
T perp2() const
Squared magnitude of transverse component.
T perp() const
Magnitude of transverse component.
Sin< T >::type sin(const T &t)
FreeTrajectoryState fts(const MagneticField *fieldProvider) const
ROOT::Math::SMatrix< double, 5, 5, ROOT::Math::MatRepSym< double, 5 > > AlgebraicSymMatrix55
const AlgebraicSymMatrix33 & matrix_new() const
GlobalTrajectoryParameters globalTrajectory(const MagneticField *fieldProvider) const
GlobalVector momentum() const
Cos< T >::type cos(const T &t)
void init(const GlobalPoint &priorPosition, const GlobalError &priorError, const GlobalVector &direction, const GlobalError &directionError)
Tan< T >::type tan(const T &t)
math::XYZPoint Point
point in the space
CurvilinearTrajectoryError curvilinearError() const
CartesianError cartesianError(double lambda=0.) const
GlobalPoint position() const
ROOT::Math::DisplacementVector3D< ROOT::Math::Cartesian3D< float >, ROOT::Math::GlobalCoordinateSystemTag > GlobalVector
vector in glovbal coordinate system
Track track(double ndof=0., double chi2=0.) const
CurvilinearTrajectoryParameters curvilinearTrajectory() const
ROOT::Math::PositionVector3D< ROOT::Math::Cartesian3D< float >, ROOT::Math::GlobalCoordinateSystemTag > GlobalPoint
point in global coordinate system
const Error & covariance() const
const AlgebraicSymMatrix55 & matrix() const
Square< F >::type sqr(const F &f)
ROOT::Math::SVector< double, 4 > Vector
math::XYZVector Vector
spatial vector
*vegas h *****************************************************used in the default bin number in original ***version of VEGAS is ***a higher bin number might help to derive a more precise ***grade subtle point
GlobalError positionError(double lambda=0.) const
const GlobalVector direction() const