Trk::JacobianLocalToCurvilinear Class Reference

#include <JacobianLocalToCurvilinear.h>

Inheritance diagram for Trk::JacobianLocalToCurvilinear:

Collaboration diagram for Trk::JacobianLocalToCurvilinear:

Public Member Functions
	JacobianLocalToCurvilinear (const CurvilinearUVT &curvUVT, const Amg::Vector3D &locX, const Amg::Vector3D &locY)
	Constructor for straight line track model. More...
	JacobianLocalToCurvilinear (const Amg::Vector3D &bfield, double qOp, double sinTheta, const CurvilinearUVT &curvUVT, const Amg::Vector3D &locX, const Amg::Vector3D &locY)
	Constructor for helical track model. More...

Detailed Description

This class represents the jacobian for transforming from a local to a curvilinear 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 t \times \vec z}{|\vec t \times \vec z|} \) 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 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 local representations of the track parameters \( (locX, locY, \phi, \theta, q/p) \) and the curvilinear representation \( (u, v, \phi', \theta', q/p') \) can then be expressed as:

For the straight line case:

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

And additionally for the helical case :

\( \frac{\partial \phi'}{\partial x} = \frac{1}{sin\theta'}\cdot(\alpha\cdot Q \cdot(\vec n \cdot u)\codt(\vec t\cdot \vec{locX) \)
\( \frac{\partial \phi'}{\partial y} = \frac{1}{sin\theta'}\cdot(\alpha\cdot Q \cdot(\vec n \cdot u)\codt(\vec t\cdot \vec{locY) \)

\( \frac{\partial \theta'}{\partial x} = - \cdot(\alpha\cdot Q \cdot(\vec n \cdot v)\codt(\vec t\cdot \vec{locX) \)
\( \frac{\partial \theta'}{\partial y} = - \cdot(\alpha\cdot Q \cdot(\vec n \cdot v)\codt(\vec t\cdot \vec{locY) \)

Author

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

Definition at line 66 of file JacobianLocalToCurvilinear.h.

Constructor & Destructor Documentation

JacobianLocalToCurvilinear() [1/2]

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

Constructor for straight line track model.

Definition at line 20 of file JacobianLocalToCurvilinear.cxx.

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

JacobianLocalToCurvilinear() [2/2]

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

Constructor for helical track model.

Definition at line 35 of file JacobianLocalToCurvilinear.cxx.

                                                               :
  AmgMatrix(5,5)()
{
   
   // initialize to zero
   this->setIdentity();
   
   // identical to the straight line case
   (*this)(0,0) = curvUVT.curvU().dot(locX); // d(u)/d(locX)
   (*this)(0,1) = curvUVT.curvU().dot(locY); // d(u)/d(locY)
   (*this)(1,0) = curvUVT.curvV().dot(locX); // d(v)/d(locX)
   (*this)(1,1) = curvUVT.curvV().dot(locY); // d(v)/d(locY)
   // 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
   if(alpha!=0.) n /= alpha;                                // normalization
   double B = bfield.mag();
    
   // -> Psi and pathlength related variables
   double Q   =  - B * Gaudi::Units::c_light * qOp; 
   
   // prepare the parameters
   double tlx = curvUVT.curvT().dot(locX);   // t * locX
   double tly = curvUVT.curvT().dot(locY);   // t * locY
   double nu  = n.dot(curvUVT.curvU());      // n * u
   double nv  = n.dot(curvUVT.curvV());      // n * v
 
   double oneOverSinTheta = 1./sinTheta; // (helix.startParameters().sinTheta());
 
   // fill the components
   (*this)(2,0) =  -alpha*Q*oneOverSinTheta*nu*tlx; // d(phi)/d(locX)
   (*this)(2,1) = - alpha*Q*oneOverSinTheta*nu*tly; // d(phi)/d(locY)
    
   (*this)(3,0) =   alpha*Q*nv*tlx;               // d(theta)/d(locX)
   (*this)(3,1) =   alpha*Q*nv*tly;               // d(theta)/d(locY)
 
}

---

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

• JacobianLocalToCurvilinear.h
• JacobianLocalToCurvilinear.cxx