Trk::JacobianCurvilinearToLocal Class Reference

This class represents the jacobian for transforming from a curvilinear to a local frame. More...

#include <JacobianCurvilinearToLocal.h>

Inheritance diagram for Trk::JacobianCurvilinearToLocal:

Collaboration diagram for Trk::JacobianCurvilinearToLocal:

Public Member Functions
	JacobianCurvilinearToLocal (const Trk::CurvilinearUVT &curvUVT, const Amg::Vector3D &locX, const Amg::Vector3D &locY, const Amg::Vector3D &locZ)
	Constructor for straight line track model.
	JacobianCurvilinearToLocal (const Amg::Vector3D &bfield, double qOp, double sinTheta, const CurvilinearUVT &curvUVT, const Amg::Vector3D &locX, const Amg::Vector3D &locY, const Amg::Vector3D &locZ)
	Constructor for helix track model.

Detailed Description

This class represents the jacobian for transforming from a curvilinear to a local frame.

The curvilinear frame is defined as follows: Given a direction \( \vec t = \frac{\vec p }{|\vec p |} \) of a track at a specific point, the plane perpenticular to the track may be defined by two vectors \( (\vec u, \vec v) \), denoting \( \vec z \) as the global z-axis and defining: \( \vec{u} = \frac {\vec z \times \vec{t}}{|\vec z \times \vec{t}|} \) and
\( \vec{v} = \vec{t} \times \vec{u} \),
the unit vectors \( (\vec{curv_{i}}) = (\vec{u}, \vec{v}, \vec{t}) \) define at any point of the track a right-handed orthogonal coordinate system (the so-called curvilinear frame)
The local frame on a surface may be represented through two local vectors \( \vec{locX} \) and \( \vec{locY} \) within the plane and one perpenticular vector \( \vec{locZ} \) pointing along the surface's normal.

Detailed Description

The non-zero elements of the jacobian for the transformation between the curvilinear representation \( (u, v, \phi', \theta', q/p') \) and the local representations of the track parameters \( (locX, locY, \phi, \theta, q/p) \) can then be expressed as:

for the straight line case:

\( \frac{\partial locX}{\partial u} = \frac{\vec{locY} \cdot \vec{v}}{\vec{locZ} \cdot \vec{t}} \)
\( \frac{\partial locX}{\partial v} = - \frac{\vec{locY} \cdot \vec{u}}{\vec{locZ} \cdot \vec{t}} \)
\( \frac{\partial locY}{\partial u} = - \frac{\vec{locX} \cdot \vec{v}}{\vec{locZ} \cdot \vec{t}} \)
\( \frac{\partial locY}{\partial v} = \frac{\vec{locX} \cdot \vec{u}}{\vec{locZ} \cdot \vec{t}} \)
\( \frac{\partial \phi}{\partial \phi'} = 1 \)
\( \frac{\partial \theta}{\partial \theta'} = 1 \)
\( \frac{\partial (q/p)}{\partial (q/p)'} = 1 \)

and additionally for the helix case:

\( \frac{\partial\phi}{\partial u} = \frac{\alpha\cdot Q}{\sin\theta} \cdot (\vec{u}\cdot\vec{n})\frac{\vec{u}\cdot\vec{locZ}}{\vec{locZ} \cdot \vec{t}} \)
\( \frac{\partial\phi{\partial v} = \frac{\alpha\cdot Q}{\sin\theta} \cdot (\vec{u}\cdot\vec{n})\frac{\vec{v}\cdot\vec{locZ}}{\vec{locZ} \cdot \vec{t}} \)
\( \frac{\partial\theta}{\partial u} = -\alpha\cdot Q \cot (\vec{v}\cdot\vec{n})\frac{\vec{u}\cdot\vec{locZ}}{\vec{locZ} \cdot \vec{t}} \)
\( \frac{\partial\theta}{\partial v} = -\alpha\cdot Q \cot (\vec{v}\cdot\vec{n})\frac{\vec{v}\cdot\vec{locZ}}{\vec{locZ} \cdot \vec{t}}\)

Author

Andre.nosp@m.as.S.nosp@m.alzbu.nosp@m.rger.nosp@m.@cern.nosp@m..ch

Definition at line 74 of file JacobianCurvilinearToLocal.h.

Constructor & Destructor Documentation

JacobianCurvilinearToLocal() [1/2]

Trk::JacobianCurvilinearToLocal::JacobianCurvilinearToLocal	(	const Trk::CurvilinearUVT &	curvUVT,
		const Amg::Vector3D &	locX,
		const Amg::Vector3D &	locY,
		const Amg::Vector3D &	locZ )

Constructor for straight line track model.

Calculates the Jacobian for straight line track model.

Definition at line 24 of file JacobianCurvilinearToLocal.cxx.

                                                              :
  AmgMatrix(5,5)()
{
    //initialize to zero
    this->setIdentity();
 
    double locZdotCurvT = locZ.dot(curvUVT.curvT());
    (*this)(0,0) =   curvUVT.curvV().dot(locY)/locZdotCurvT;    // d(locX)/d(u)
    (*this)(0,1) =   - curvUVT.curvU().dot(locY)/locZdotCurvT;  // d(locX)/d(v)
    (*this)(1,0) =   - curvUVT.curvV().dot(locX)/locZdotCurvT;  // d(locY)/d(u)
    (*this)(1,1) =   curvUVT.curvU().dot(locX)/locZdotCurvT;    // d(locY)/d(v)
 
}

JacobianCurvilinearToLocal() [2/2]

Trk::JacobianCurvilinearToLocal::JacobianCurvilinearToLocal	(	const Amg::Vector3D &	bfield,
		double	qOp,
		double	sinTheta,
		const CurvilinearUVT &	curvUVT,
		const Amg::Vector3D &	locX,
		const Amg::Vector3D &	locY,
		const Amg::Vector3D &	locZ )

Constructor for helix track model.

Calculates the Jacobian for helical track model.

Definition at line 45 of file JacobianCurvilinearToLocal.cxx.

  : AmgMatrix(5, 5)()
{
    this->setIdentity();
    
    // prepare the dot products
    double oneOverZt = 1./locZ.dot(curvUVT.curvT());   // 1./locZ * t
    double ux           = curvUVT.curvU().dot(locX);   // u * locX
    double uy           = curvUVT.curvU().dot(locY);   // u * locY
    double uz           = curvUVT.curvU().dot(locZ);   // u * locZ
    double vx           = curvUVT.curvV().dot(locX);   // v * locX
    double vy           = curvUVT.curvV().dot(locY);   // v * locY
    double vz           = curvUVT.curvV().dot(locZ);   // v * locZ
    // specific for the helix
    const Amg::Vector3D& h = bfield.normalized();
    Amg::Vector3D n(h.cross(curvUVT.curvT()));   // direction normal to track and magnetic field direction
    double alpha = n.mag();                    // | h x t | projection of track normal to magnetic field direction
    n /= alpha;                                // normalization
    double B = bfield.mag();
    
    // -> Psi and pathlength related variables
    double Q   =  - B * Gaudi::Units::c_light * qOp; 
    double alphaQ = alpha*Q;    
 
    double un = curvUVT.curvU().dot(n);
    double vn = curvUVT.curvV().dot(n);
    // fill the components
    (*this)(0,0) =     vy*oneOverZt;                   // d(locX)/d(u)
    (*this)(0,1) =   - uy*oneOverZt;                   // d(locX)/d(v)
    (*this)(1,0) =   - vx*oneOverZt;                   // d(locY)/d(u)
    (*this)(1,1) =     ux*oneOverZt;                   // d(locY)/d(v)
    (*this)(2,0) =   - alphaQ/sinTheta*un*uz*oneOverZt;  // d(phi)/d(u)
    (*this)(2,1) =   - alphaQ/sinTheta*un*vz*oneOverZt;  // d(phi)/d(v)
    (*this)(3,0) =     alphaQ*vn*uz*oneOverZt;          // d(theta)/d(v)
    (*this)(3,1) =     alphaQ*vn*vz*oneOverZt;          // d(theta)/d(v)  
 
}

---

The documentation for this class was generated from the following files:

• JacobianCurvilinearToLocal.h
• JacobianCurvilinearToLocal.cxx