Trk::JacobianLocalAnglesPhiTheta Class Reference

#include <JacobianLocalAnglesPhiTheta.h>

Inheritance diagram for Trk::JacobianLocalAnglesPhiTheta:

Collaboration diagram for Trk::JacobianLocalAnglesPhiTheta:

Public Member Functions
	JacobianLocalAnglesPhiTheta (const double angleXZ, const double angleYZ, const Amg::RotationMatrix3D &rot)
	~JacobianLocalAnglesPhiTheta ()

Detailed Description

This jacobian transforms the local direction representation as given in the Trk::LocalDirection class into the corresponding polar and azimutal angle \( \phi, \theta \), therefor it is of dimension (2x2).

The Rotation given for construction is the one declared by the Surface frame:

Surface::transform()::getRotation()

Author

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

Definition at line 31 of file JacobianLocalAnglesPhiTheta.h.

Constructor & Destructor Documentation

JacobianLocalAnglesPhiTheta()

Trk::JacobianLocalAnglesPhiTheta::JacobianLocalAnglesPhiTheta	(	const double	angleXZ,
		const double	angleYZ,
		const Amg::RotationMatrix3D &	rot
	)

Definition at line 12 of file JacobianLocalAnglesPhiTheta.cxx.

                                                                                                                                     : 
    AmgMatrix(2,2)()
{
 
    this->setIdentity();
 
// Rot is a 3x3 rotation matrix from local 3-vector to global 3-vector
 
    double cx = std::cos(angleXZ);
    double sx = std::sin(angleXZ);
    double cy = std::cos(angleYZ);
    double sy = std::sin(angleYZ); 
    double norm = std::sqrt(cx*sy*cx*sy + cy*sx*cy*sx + sx*sy*sx*sy);
    double zinv = norm/(sx*sy) ;  
//
//  local direction x = cx * sy / norm
//                  y = cy * sx / norm
//                  z = sx * sy / norm 
//
    
// Determine Global theta and phi 
 
    Amg::Vector3D locdir(cx*sy/norm,cy*sx/norm,sx*sy/norm);
    Amg::Vector3D gdir = rot*locdir;
    double phi = gdir.phi();
    double theta = gdir.theta();
//    std::cout << " phi " << phi << " theta " << theta << std::endl; 
    double cp = std::cos(phi);
    double sp = std::sin(phi);
    double ct = std::cos(theta);
    double st = std::sin(theta);
    AmgMatrix(3,2) J2 = AmgMatrix(3,2)::Zero(); // row, column
//
//  derivatives dx/dphi  dx/dtheta  
//              dy/dphi  dy/dtheta
//              dz/dphi  dz/dtheta
//
//              x = std::sin(theta)*std::cos(phi) 
//              y = std::sin(theta)*std::sin(phi) 
//              z = std::cos(theta) 
//
 
    J2(0,0) = -st*sp;
    J2(1,0) = st*cp;
    J2(0,1) = ct*cp;
    J2(1,1) = ct*sp;
    J2(2,1) = -st;
 
    AmgMatrix(2,3) J1 = AmgMatrix(2,3)::Zero();
//
//  derivatives d alphaXZ/dx  d alphaXZ/dy  d alphaXZ/dz   
//              d alphaYZ/dx  d alphaYZ/dy  d alphaYZ/dz  
//
//        tan(alphaXZ) = z / x
//        tan(alhpaYZ) = z / y
//  
 
    J1(0,0) = -sx*sx*zinv;
    J1(1,1) = -sy*sy*zinv;
    J1(0,2) = cx*sx*zinv;
    J1(1,2) = cy*sy*zinv;
 
    const AmgMatrix(3,3)& Rot  = rot;
    AmgMatrix(2,2) Jinv = AmgMatrix(2,2)::Zero();
//
//  Jacobian Inverse: lefthand local righthand global
//
    AmgMatrix(3,3) RI = Rot.inverse(); 
    Jinv = J1*(RI*J2); 
//
//  Default Matrix
//
    (*this)(0,0) = 1.;
    (*this)(0,1) = 0.;
    (*this)(1,0) = 0.;
    (*this)(1,1) = 1.;
//
// Store Jacobian  J:  right hand local
//
//    if (succes==0) {
//      AmgMatrix(2,2) J = Jinv.inverse(succes);
//      if (succes==0) {
//        (*this)(0,0) = J(0,0);
//        (*this)(0,1) = J(0,1);
//        (*this)(1,0) = J(1,0);
//        (*this)(1,1) = J(1,1);
//      }
//    } 
}

~JacobianLocalAnglesPhiTheta()

Trk::JacobianLocalAnglesPhiTheta::~JacobianLocalAnglesPhiTheta ( )

inline

Definition at line 34 of file JacobianLocalAnglesPhiTheta.h.

{}

---

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

• JacobianLocalAnglesPhiTheta.h
• JacobianLocalAnglesPhiTheta.cxx