recob::tracking::Plane Class Reference

Class defining a plane for tracking. It provides various functionalities to convert track parameters and covariance matrices from global to local coordinates. More...

#include <TrackingPlane.h>

Classes
struct	TrigCache
	Struct caching trigonometric function results. More...

Public Member Functions
	Plane (const Point_t &planePos, const Vector_t &planeDir)
	Constructor from reference position on the plane and direction orthogonal to the plane. More...
Point_t const &	position () const
	Reference position on the plane. More...
Vector_t const &	direction () const
	Reference direction orthogonal to the plane. More...
SMatrixSym66	Local5DToGlobal6DCovariance (SMatrixSym55 cov5d, bool hasMomentum, const Vector_t &trackMomOrDir) const
	Translate track covariance from local to global coordinates. The track momentum (or direction) is needed to compute the jacobian. Local coordinates are on the plane orthogonal to planeDir (it may be the same direction as the momentum, but the function is generic). More...
SMatrixSym55	Global6DToLocal5DCovariance (SMatrixSym66 cov6d, bool hasMomentum, const Vector_t &trackMomOrDir) const
	Translate track covariance from global to local coordinates. The track momentum (or direction) is needed to compute the jacobian. Local coordinates are on the plane orthogonal to planeDir (it may be the same direction as the momentum, but the function is generic). Warning: some information may be lost in degenerate cases, e.g. the unceratinty along z position when converting to a x-y plane (fixed z) More...
SVector5	Global6DToLocal5DParameters (const SVector6 &par6d) const
	Function to convert parameters from global to local coordinates. Local coordinates are on the plane with origin at planePos and orthogonal to planeDir. It is responsibility of the user to make sure the global position lies on the plane. More...
SVector5	Global6DToLocal5DParameters (const SVector6 &par6d, const Point_t &planePos, const Vector_t &planeDir, const TrigCache &trigCache) const
SVector6	Local5DToGlobal6DParameters (const SVector5 &par5d, bool trackAlongPlaneDir=true) const
	Function to convert parameters from local to global coordinates. Local coordinates are on the plane with origin at planePos and orthogonal to planeDir. trackAlongPlaneDir is as given by trackDir.Dot(planeDir)>0. More...
SVector6	Local5DToGlobal6DParameters (const SVector5 &par5d, const Point_t &planePos, const Vector_t &planeDir, const TrigCache &trigCache, bool trackAlongPlaneDir=true) const
SMatrix65	Local5DToGlobal6DJacobian (bool hasMomentum, const Vector_t &trackMomOrDir) const
	Compute the jacobian to translate track covariance from local to global coordinates. The track momentum (or direction) is needed to compute the jacobian. Local coordinates are on the plane orthogonal to planeDir (it may be the same direction as the momentum, but the function is generic). More...
SMatrix65	Local5DToGlobal6DJacobian (bool hasMomentum, const Vector_t &trackMomOrDir, const Vector_t &planeDir, const TrigCache &trigCache) const
SMatrix56	Global6DToLocal5DJacobian (bool hasMomentum, const Vector_t &trackMomOrDir) const
	Compute the jacobian to translate track covariance from global to local coordinates. The track momentum (or direction) is needed to compute the jacobian. Local coordinates are on the plane orthogonal to planeDir (it may be the same direction as the momentum, but the function is generic). Warning: some information may be lost in degenerate cases, e.g. the unceratinty along z position when converting to a x-y plane (fixed z) More...
SMatrix56	Global6DToLocal5DJacobian (bool hasMomentum, const Vector_t &trackMomOrDir, const Vector_t &planeDir, const TrigCache &trigCache) const
Rotation_t	Global3DToLocal3DRotation () const
	Calculate rotation matrices from global (x,y,z) to local (u,v,w) coordinates. More...
Rotation_t	Global3DToLocal3DRotation (const Vector_t &planeDir, const TrigCache &trigCache) const
Rotation_t	Local3DToGlobal3DRotation () const
	Calculate rotation matrices from local (u,v,w) to global (x,y,z) coordinates. More...
Rotation_t	Local3DToGlobal3DRotation (const Vector_t &planeDir, const TrigCache &trigCache) const
double	cosAlpha () const
	Return cached values of trigonometric function for angles defining the plane. More...
double	sinAlpha () const
double	cosBeta () const
double	sinBeta () const

Static Public Member Functions
static SVector5	Global6DToLocal5DParameters (const SVector6 &par6d, const Point_t &planePos, const Vector_t &planeDir)
	Function to convert parameters from global to local coordinates. Local coordinates are on the plane with origin at planePos and orthogonal to planeDir. It is responsibility of the user to make sure the global position lies on the plane. More...
static SVector6	Local5DToGlobal6DParameters (const SVector5 &par5d, const Point_t &planePos, const Vector_t &planeDir, bool trackAlongPlaneDir=true)
	Function to convert parameters from local to global coordinates. Local coordinates are on the plane with origin at planePos and orthogonal to planeDir. trackAlongPlaneDir is as given by trackDir.Dot(planeDir)>0. More...
static SMatrix65	Local5DToGlobal6DJacobian (bool hasMomentum, const Vector_t &trackMomOrDir, const Vector_t &planeDir)
	Compute the jacobian to translate track covariance from local to global coordinates. The track momentum (or direction) is needed to compute the jacobian. Local coordinates are on the plane orthogonal to planeDir (it may be the same direction as the momentum, but the function is generic). More...
static SMatrix65	Local5DToGlobal6DJacobian (bool hasMomentum, const SVector6 &par6d, const Vector_t &planeDir)
	Compute the jacobian to translate track covariance from local to global coordinates. The track momentum (or direction) is needed to compute the jacobian. Local coordinates are on the plane orthogonal to planeDir (it may be the same direction as the momentum, but the function is generic). More...
static SMatrix56	Global6DToLocal5DJacobian (bool hasMomentum, const Vector_t &trackMomOrDir, const Vector_t &planeDir)
	Compute the jacobian to translate track covariance from global to local coordinates. The track momentum (or direction) is needed to compute the jacobian. Local coordinates are on the plane orthogonal to planeDir (it may be the same direction as the momentum, but the function is generic). Warning: some information may be lost in degenerate cases, e.g. the unceratinty along z position when converting to a x-y plane (fixed z) More...
static SMatrix56	Global6DToLocal5DJacobian (bool hasMomentum, const SVector6 &par6d, const Vector_t &planeDir)
	Compute the jacobian to translate track covariance from global to local coordinates. The track momentum (or direction) is needed to compute the jacobian. Local coordinates are on the plane orthogonal to planeDir (it may be the same direction as the momentum, but the function is generic). Warning: some information may be lost in degenerate cases, e.g. the unceratinty along z position when converting to a x-y plane (fixed z) More...
static SMatrixSym66	Local5DToGlobal6DCovariance (SMatrixSym55 cov5d, bool hasMomentum, const Vector_t &trackMomOrDir, const Vector_t &planeDir)
	Translate track covariance from local to global coordinates. The track momentum (or direction) is needed to compute the jacobian. Local coordinates are on the plane orthogonal to planeDir (it may be the same direction as the momentum, but the function is generic). More...
static SMatrixSym55	Global6DToLocal5DCovariance (SMatrixSym66 cov6d, bool hasMomentum, const Vector_t &trackMomOrDir, const Vector_t &planeDir)
	Translate track covariance from global to local coordinates. The track momentum (or direction) is needed to compute the jacobian. Local coordinates are on the plane orthogonal to planeDir (it may be the same direction as the momentum, but the function is generic). Warning: some information may be lost in degenerate cases, e.g. the unceratinty along z position when converting to a x-y plane (fixed z) More...
static Rotation_t	Global3DToLocal3DRotation (const Vector_t &planeDir)
	Calculate rotation matrices from global (x,y,z) to local (u,v,w) coordinates. More...
static Rotation_t	Local3DToGlobal3DRotation (const Vector_t &planeDir)
	Calculate rotation matrices from local (u,v,w) to global (x,y,z) coordinates. More...

Private Attributes
Point_t	fPlanePos
	Position of a point on the plane. More...
Vector_t	fPlaneDir
	Direction vector othogonal to the plane. More...
TrigCache	fTrigCache
	Cached trigonometric function values. More...

Detailed Description

Class defining a plane for tracking. It provides various functionalities to convert track parameters and covariance matrices from global to local coordinates.

Author

G. Cerati (FNAL, MicroBooNE)

Date

2017

Version

1.0

The plane is constructed from a point in global coordinates, and a direction unit vector orthogonal to the plane. For instance, they may refer to the position and direction of a trajectory at a given point, or to the center of a wire and the direction orthogonal to both the wire and drift directions.

The plane and parameters are defined along the lines of trkf::SurfXYZPlane, but with a different notation for the angles which are now called alpha and beta to avoid confusion with theta and phi in global spherical coordinates: (alpha, beta) correspond to (alpha := Rotation angle about y'-axis (projected Lorentz angle) = atan2(nx, hypot(ny, nz)), beta := Rotation angle about x-axis (wire angle) = atan2(-ny, nz)) The 3D local positions are defined in terms of the unit vectors u,v,w where w is along the normal direction to the plane, u is perpendicular to w and coplanar to the global x axis and with position sign along the positive sign of x, v forms a right handed orthonormal basis with u and w. The 5D track parameters are u,v,du/dw,dv/dw,1/p: u,v are the local positions, du, dv, and dw are the local directions, and 1/p is the inverse of the track momentum. The global 6D coordinates are formed by the track position and momentum (or direction) at a given point.

The discussion above refers to a detector with drift direction along the x axis; this class will have to be extended for a detector with a different drift direction.

Definition at line 37 of file TrackingPlane.h.

Constructor & Destructor Documentation

recob::tracking::Plane::Plane ( const Point_t &  planePos, const Vector_t &  planeDir  )

inline

Constructor from reference position on the plane and direction orthogonal to the plane.

Definition at line 61 of file TrackingPlane.h.

        : fPlanePos(planePos), fPlaneDir(planeDir.Unit()), fTrigCache(planeDir.Unit()) { }

Member Function Documentation

double recob::tracking::Plane::cosAlpha ( ) const

inline

Return cached values of trigonometric function for angles defining the plane.

Definition at line 120 of file TrackingPlane.h.

{ return fTrigCache.fCosA; }

double recob::tracking::Plane::cosBeta ( ) const

inline

Definition at line 122 of file TrackingPlane.h.

{ return fTrigCache.fCosB; }

Vector_t const& recob::tracking::Plane::direction ( ) const

inline

Reference direction orthogonal to the plane.

Definition at line 70 of file TrackingPlane.h.

{ return fPlaneDir; }

Rotation_t recob::tracking::Plane::Global3DToLocal3DRotation ( ) const

inline

Calculate rotation matrices from global (x,y,z) to local (u,v,w) coordinates.

Definition at line 108 of file TrackingPlane.h.

{ return Global3DToLocal3DRotation(fPlaneDir,fTrigCache); }

Rotation_t recob::tracking::Plane::Global3DToLocal3DRotation	(	const Vector_t &	planeDir,
		const TrigCache &	trigCache
	)		const

Definition at line 159 of file TrackingPlane.cxx.

                                                                                                   {
      const double& sinalpha = trigCache.fSinA;
      const double& cosalpha = trigCache.fCosA;
      const double& sinbeta  = trigCache.fSinB;
      const double& cosbeta  = trigCache.fCosB;
      return {
        cosalpha /* xx */,  sinalpha * sinbeta /* xy */, -sinalpha * cosbeta /* xz */,
        0.0      /* yx */,  cosbeta            /* yy */,  sinbeta            /* yz */,
        sinalpha /* zx */, -cosalpha * sinbeta /* zy */,  cosalpha * cosbeta /* zz */
      };
    }

static Rotation_t recob::tracking::Plane::Global3DToLocal3DRotation ( const Vector_t &  planeDir )

inlinestatic

Calculate rotation matrices from global (x,y,z) to local (u,v,w) coordinates.

Definition at line 159 of file TrackingPlane.h.

                                                                            {
        Plane p(Point_t(), planeDir); return p.Global3DToLocal3DRotation();
      }

SMatrixSym55 recob::tracking::Plane::Global6DToLocal5DCovariance ( SMatrixSym66  cov6d, bool  hasMomentum, const Vector_t &  trackMomOrDir  ) const

inline

Translate track covariance from global to local coordinates. The track momentum (or direction) is needed to compute the jacobian. Local coordinates are on the plane orthogonal to planeDir (it may be the same direction as the momentum, but the function is generic). Warning: some information may be lost in degenerate cases, e.g. the unceratinty along z position when converting to a x-y plane (fixed z)

Definition at line 102 of file TrackingPlane.h.

                                                                                                                                 {
        return Global6DToLocal5DCovariance(cov6d,hasMomentum,trackMomOrDir,fPlaneDir);
      }

static SMatrixSym55 recob::tracking::Plane::Global6DToLocal5DCovariance ( SMatrixSym66  cov6d, bool  hasMomentum, const Vector_t &  trackMomOrDir, const Vector_t &  planeDir  )

inlinestatic

Translate track covariance from global to local coordinates. The track momentum (or direction) is needed to compute the jacobian. Local coordinates are on the plane orthogonal to planeDir (it may be the same direction as the momentum, but the function is generic). Warning: some information may be lost in degenerate cases, e.g. the unceratinty along z position when converting to a x-y plane (fixed z)

Definition at line 155 of file TrackingPlane.h.

                                                                                                                                                     {
        return ROOT::Math::Similarity(Global6DToLocal5DJacobian(hasMomentum,trackMomOrDir,planeDir),cov6d);
      }

SMatrix56 recob::tracking::Plane::Global6DToLocal5DJacobian ( bool  hasMomentum, const Vector_t &  trackMomOrDir  ) const

inline

Compute the jacobian to translate track covariance from global to local coordinates. The track momentum (or direction) is needed to compute the jacobian. Local coordinates are on the plane orthogonal to planeDir (it may be the same direction as the momentum, but the function is generic). Warning: some information may be lost in degenerate cases, e.g. the unceratinty along z position when converting to a x-y plane (fixed z)

Definition at line 92 of file TrackingPlane.h.

{ return Global6DToLocal5DJacobian(hasMomentum, trackMomOrDir,fPlaneDir,fTrigCache); }

SMatrix56 recob::tracking::Plane::Global6DToLocal5DJacobian	(	bool	hasMomentum,
		const Vector_t &	trackMomOrDir,
		const Vector_t &	planeDir,
		const TrigCache &	trigCache
	)		const

Definition at line 112 of file TrackingPlane.cxx.

                                                                                                                                                   {
      const double& sinalpha = trigCache.fSinA;
      const double& cosalpha = trigCache.fCosA;
      const double& sinbeta  = trigCache.fSinB;
      const double& cosbeta  = trigCache.fCosB;
      const double den23 = (cosalpha*(cosbeta*trackMomOrDir.Z() - sinbeta*trackMomOrDir.Y()) + sinalpha*trackMomOrDir.X())*(cosalpha*(cosbeta*trackMomOrDir.Z() - sinbeta*trackMomOrDir.Y()) + sinalpha*trackMomOrDir.X());
      const double den4 = sqrt(trackMomOrDir.X()*trackMomOrDir.X()+trackMomOrDir.Y()*trackMomOrDir.Y()+trackMomOrDir.Z()*trackMomOrDir.Z())*(trackMomOrDir.X()*trackMomOrDir.X()+trackMomOrDir.Y()*trackMomOrDir.Y()+trackMomOrDir.Z()*trackMomOrDir.Z());
      SMatrix56 j;
      //
      j(0,0) = cosalpha;
      j(0,1) = sinalpha*sinbeta ;
      j(0,2) = -sinalpha*cosbeta;
      j(0,3) = 0.;
      j(0,4) = 0.;
      j(0,5) = 0.;
      //
      j(1,0) = 0.;
      j(1,1) = cosbeta;
      j(1,2) = sinbeta;
      j(1,3) = 0.;
      j(1,4) = 0.;
      j(1,5) = 0.;
      //
      j(2,0) = 0.;
      j(2,1) = 0.;
      j(2,2) = 0.;
      j(2,3) = ((cosalpha*cosalpha + sinalpha*sinalpha)*(cosbeta*trackMomOrDir.Z() - sinbeta*trackMomOrDir.Y()))/den23;
      j(2,4) = (sinbeta*trackMomOrDir.X()*(cosalpha*cosalpha + sinalpha*sinalpha))/den23;
      j(2,5) = -(cosbeta*trackMomOrDir.X()*(cosalpha*cosalpha + sinalpha*sinalpha))/den23;
      //
      j(3,0) = 0.;
      j(3,1) = 0.;
      j(3,2) = 0.;
      j(3,3) = -(sinalpha*(cosbeta*trackMomOrDir.Y() + sinbeta*trackMomOrDir.Z()))/den23;
      j(3,4) = (cosalpha*trackMomOrDir.Z()*(cosbeta*cosbeta + sinbeta*sinbeta) + cosbeta*sinalpha*trackMomOrDir.X())/den23;
      j(3,5) = (-cosalpha*cosbeta*cosbeta*trackMomOrDir.Y() - cosalpha*sinbeta*sinbeta*trackMomOrDir.Y() + sinalpha*sinbeta*trackMomOrDir.X())/den23;
      //
      j(4,0) = 0.;
      j(4,1) = 0.;
      j(4,2) = 0.;
      j(4,3) = (hasMomentum ? -trackMomOrDir.X()/den4 : 0.);
      j(4,4) = (hasMomentum ? -trackMomOrDir.Y()/den4 : 0.);
      j(4,5) = (hasMomentum ? -trackMomOrDir.Z()/den4 : 0.);
      //
      return j;
    }

static SMatrix56 recob::tracking::Plane::Global6DToLocal5DJacobian ( bool  hasMomentum, const Vector_t &  trackMomOrDir, const Vector_t &  planeDir  )

inlinestatic

Compute the jacobian to translate track covariance from global to local coordinates. The track momentum (or direction) is needed to compute the jacobian. Local coordinates are on the plane orthogonal to planeDir (it may be the same direction as the momentum, but the function is generic). Warning: some information may be lost in degenerate cases, e.g. the unceratinty along z position when converting to a x-y plane (fixed z)

Definition at line 143 of file TrackingPlane.h.

                                                                                                                            {
        Plane p(Point_t(), planeDir); return p.Global6DToLocal5DJacobian(hasMomentum, trackMomOrDir);
      }

static SMatrix56 recob::tracking::Plane::Global6DToLocal5DJacobian ( bool  hasMomentum, const SVector6 &  par6d, const Vector_t &  planeDir  )

inlinestatic

Compute the jacobian to translate track covariance from global to local coordinates. The track momentum (or direction) is needed to compute the jacobian. Local coordinates are on the plane orthogonal to planeDir (it may be the same direction as the momentum, but the function is generic). Warning: some information may be lost in degenerate cases, e.g. the unceratinty along z position when converting to a x-y plane (fixed z)

Definition at line 147 of file TrackingPlane.h.

                                                                                                                    {
        Plane p(Point_t(), planeDir); return p.Global6DToLocal5DJacobian(hasMomentum, Vector_t(par6d[3],par6d[4],par6d[5]));
      }

SVector5 recob::tracking::Plane::Global6DToLocal5DParameters ( const SVector6 &  par6d ) const

inline

Function to convert parameters from global to local coordinates. Local coordinates are on the plane with origin at planePos and orthogonal to planeDir. It is responsibility of the user to make sure the global position lies on the plane.

Definition at line 74 of file TrackingPlane.h.

{ return Global6DToLocal5DParameters(par6d, fPlanePos, fPlaneDir, fTrigCache); }

SVector5 recob::tracking::Plane::Global6DToLocal5DParameters	(	const SVector6 &	par6d,
		const Point_t &	planePos,
		const Vector_t &	planeDir,
		const TrigCache &	trigCache
	)		const

Definition at line 37 of file TrackingPlane.cxx.

                                                                                                                                                  {
      const double& sinalpha = trigCache.fSinA;
      const double& cosalpha = trigCache.fCosA;
      const double& sinbeta  = trigCache.fSinB;
      const double& cosbeta  = trigCache.fCosB;
      const double pu = par6d[3]*cosalpha + par6d[4]*sinalpha*sinbeta - par6d[5]*sinalpha*cosbeta;
      const double pv = par6d[4]*cosbeta + par6d[5]*sinbeta;
      const double pw = par6d[3]*sinalpha - par6d[4]*cosalpha*sinbeta + par6d[5]*cosalpha*cosbeta;
      const double pval = sqrt(par6d[3]*par6d[3]+par6d[4]*par6d[4]+par6d[5]*par6d[5]);
      SVector5 par5d;
      par5d[0] = (par6d[0]-planePos.X())*cosalpha + (par6d[1]-planePos.Y())*sinalpha*sinbeta - (par6d[2]-planePos.Z())*sinalpha*cosbeta;
      par5d[1] = (par6d[1]-planePos.Y())*cosbeta + (par6d[2]-planePos.Z())*sinbeta;
      par5d[2] = pu/pw;
      par5d[3] = pv/pw;
      par5d[4] = (pval>0 ? 1./pval : 1.);
      return par5d;
    }

static SVector5 recob::tracking::Plane::Global6DToLocal5DParameters ( const SVector6 &  par6d, const Point_t &  planePos, const Vector_t &  planeDir  )

inlinestatic

Function to convert parameters from global to local coordinates. Local coordinates are on the plane with origin at planePos and orthogonal to planeDir. It is responsibility of the user to make sure the global position lies on the plane.

Definition at line 127 of file TrackingPlane.h.

                                                                                                                            {
        Plane p(planePos, planeDir); return p.Global6DToLocal5DParameters(par6d);
      }

Rotation_t recob::tracking::Plane::Local3DToGlobal3DRotation ( ) const

inline

Calculate rotation matrices from local (u,v,w) to global (x,y,z) coordinates.

Definition at line 114 of file TrackingPlane.h.

{ return Local3DToGlobal3DRotation(fPlaneDir,fTrigCache); }

Rotation_t recob::tracking::Plane::Local3DToGlobal3DRotation	(	const Vector_t &	planeDir,
		const TrigCache &	trigCache
	)		const

Definition at line 171 of file TrackingPlane.cxx.

                                                                                                   {
      const double& sinalpha = trigCache.fSinA;
      const double& cosalpha = trigCache.fCosA;
      const double& sinbeta  = trigCache.fSinB;
      const double& cosbeta  = trigCache.fCosB;
      return {
        cosalpha            /* xx */, 0.      /* xy */,  sinalpha           /* xz */,
        sinalpha * sinbeta  /* yx */, cosbeta /* yy */, -cosalpha * sinbeta /* yz */,
        -sinalpha * cosbeta /* zx */, sinbeta /* zy */,  cosalpha * cosbeta /* zz */
      };
    }

static Rotation_t recob::tracking::Plane::Local3DToGlobal3DRotation ( const Vector_t &  planeDir )

inlinestatic

Calculate rotation matrices from local (u,v,w) to global (x,y,z) coordinates.

Definition at line 163 of file TrackingPlane.h.

                                                                            {
        Plane p(Point_t(), planeDir); return p.Local3DToGlobal3DRotation();
      }

SMatrixSym66 recob::tracking::Plane::Local5DToGlobal6DCovariance ( SMatrixSym55  cov5d, bool  hasMomentum, const Vector_t &  trackMomOrDir  ) const

inline

Translate track covariance from local to global coordinates. The track momentum (or direction) is needed to compute the jacobian. Local coordinates are on the plane orthogonal to planeDir (it may be the same direction as the momentum, but the function is generic).

Definition at line 97 of file TrackingPlane.h.

                                                                                                                                 {
        return Local5DToGlobal6DCovariance(cov5d, hasMomentum,trackMomOrDir,fPlaneDir);
      }

static SMatrixSym66 recob::tracking::Plane::Local5DToGlobal6DCovariance ( SMatrixSym55  cov5d, bool  hasMomentum, const Vector_t &  trackMomOrDir, const Vector_t &  planeDir  )

inlinestatic

Translate track covariance from local to global coordinates. The track momentum (or direction) is needed to compute the jacobian. Local coordinates are on the plane orthogonal to planeDir (it may be the same direction as the momentum, but the function is generic).

Definition at line 151 of file TrackingPlane.h.

                                                                                                                                                     {
        return ROOT::Math::Similarity(Local5DToGlobal6DJacobian(hasMomentum,trackMomOrDir,planeDir),cov5d);
      }

SMatrix65 recob::tracking::Plane::Local5DToGlobal6DJacobian ( bool  hasMomentum, const Vector_t &  trackMomOrDir  ) const

inline

Compute the jacobian to translate track covariance from local to global coordinates. The track momentum (or direction) is needed to compute the jacobian. Local coordinates are on the plane orthogonal to planeDir (it may be the same direction as the momentum, but the function is generic).

Definition at line 86 of file TrackingPlane.h.

{ return Local5DToGlobal6DJacobian(hasMomentum, trackMomOrDir,fPlaneDir,fTrigCache); }

SMatrix65 recob::tracking::Plane::Local5DToGlobal6DJacobian	(	bool	hasMomentum,
		const Vector_t &	trackMomOrDir,
		const Vector_t &	planeDir,
		const TrigCache &	trigCache
	)		const

Definition at line 55 of file TrackingPlane.cxx.

                                                                                                                                                          {
      bool trackAlongPlaneDir = trackMomOrDir.Dot(planeDir)>0;
      const double& sinalpha = trigCache.fSinA;
      const double& cosalpha = trigCache.fCosA;
      const double& sinbeta  = trigCache.fSinB;
      const double& cosbeta  = trigCache.fCosB;
      const double pu = trackMomOrDir.X()*cosalpha + trackMomOrDir.Y()*sinalpha*sinbeta - trackMomOrDir.Z()*sinalpha*cosbeta;
      const double pv = trackMomOrDir.Y()*cosbeta + trackMomOrDir.Z()*sinbeta;
      const double pw = trackMomOrDir.X()*sinalpha - trackMomOrDir.Y()*cosalpha*sinbeta + trackMomOrDir.Z()*cosalpha*cosbeta;
      //local parameters 2,3,4
      const double l2 = pu/pw;
      const double l3 = pv/pw;
      const double p2 = trackMomOrDir.X()*trackMomOrDir.X() + trackMomOrDir.Y()*trackMomOrDir.Y() + trackMomOrDir.Z()*trackMomOrDir.Z();
      const double l4 = (hasMomentum ? 1./sqrt(p2) : 1.);
      const double den23 = ( trackAlongPlaneDir ? l4*(l2*l2+l3*l3+1.)*sqrt(l2*l2+l3*l3+1.) : -l4*(l2*l2+l3*l3+1.)*sqrt(l2*l2+l3*l3+1.) );
      const double den4 = l4*l4*sqrt(l2*l2+l3*l3+1.);
      SMatrix65 j;
      //
      j(0,0) = cosalpha;
      j(0,1) = 0.;
      j(0,2) = 0.;
      j(0,3) = 0.;
      j(0,4) = 0.;
      //
      j(1,0) = sinalpha*sinbeta;
      j(1,1) = cosbeta;
      j(1,2) = 0.;
      j(1,3) = 0.;
      j(1,4) = 0.;
      //
      j(2,0) = -sinalpha*cosbeta;
      j(2,1) = sinbeta;
      j(2,2) = 0.;
      j(2,3) = 0.;
      j(2,4) = 0.;
      //
      j(3,0) = 0.;
      j(3,1) = 0.;
      j(3,2) = (cosalpha*(l3*l3+1.) - sinalpha*l2)/den23;
      j(3,3) = -l3*(l2*cosalpha + sinalpha)/den23;
      j(3,4) = (hasMomentum ? -(l2*cosalpha + sinalpha)/den4 : 0.);
      //
      j(4,0) = 0.;
      j(4,1) = 0.;
      j(4,2) = (cosalpha*sinbeta*l2 - cosbeta*l2*l3 + sinalpha*sinbeta*(l3*l3+1.))/den23;
      j(4,3) = (sinbeta*l3*(cosalpha-sinalpha*l2) + cosbeta*(l2*l2+1.))/den23;
      j(4,4) = (hasMomentum ? (cosalpha*sinbeta - cosbeta*l3 - sinalpha*sinbeta*l2)/den4 : 0.);
      //
      j(5,0) = 0.;
      j(5,1) = 0.;
      j(5,2) = -(cosalpha*cosbeta*l2 + cosbeta*sinalpha*l3*l3 + cosbeta*sinalpha + sinbeta*l2*l3)/den23;
      j(5,3) = (-cosalpha*cosbeta*l3 + cosbeta*sinalpha*l2*l3 + sinbeta*l2*l2 + sinbeta)/den23;
      j(5,4) = (hasMomentum ? (-cosalpha*cosbeta + cosbeta*sinalpha*l2 - sinbeta*l3)/den4 : 0.);
      //
      return j;
    }

static SMatrix65 recob::tracking::Plane::Local5DToGlobal6DJacobian ( bool  hasMomentum, const Vector_t &  trackMomOrDir, const Vector_t &  planeDir  )

inlinestatic

Compute the jacobian to translate track covariance from local to global coordinates. The track momentum (or direction) is needed to compute the jacobian. Local coordinates are on the plane orthogonal to planeDir (it may be the same direction as the momentum, but the function is generic).

Definition at line 135 of file TrackingPlane.h.

                                                                                                                            {
        Plane p(Point_t(), planeDir); return p.Local5DToGlobal6DJacobian(hasMomentum, trackMomOrDir);
      }

static SMatrix65 recob::tracking::Plane::Local5DToGlobal6DJacobian ( bool  hasMomentum, const SVector6 &  par6d, const Vector_t &  planeDir  )

inlinestatic

Compute the jacobian to translate track covariance from local to global coordinates. The track momentum (or direction) is needed to compute the jacobian. Local coordinates are on the plane orthogonal to planeDir (it may be the same direction as the momentum, but the function is generic).

Definition at line 139 of file TrackingPlane.h.

                                                                                                                    {
        Plane p(Point_t(), planeDir); return p.Local5DToGlobal6DJacobian(hasMomentum, Vector_t(par6d[3],par6d[4],par6d[5]));
      }

SVector6 recob::tracking::Plane::Local5DToGlobal6DParameters ( const SVector5 &  par5d, bool  trackAlongPlaneDir = true  ) const

inline

Function to convert parameters from local to global coordinates. Local coordinates are on the plane with origin at planePos and orthogonal to planeDir. trackAlongPlaneDir is as given by trackDir.Dot(planeDir)>0.

Definition at line 80 of file TrackingPlane.h.

{ return Local5DToGlobal6DParameters(par5d, fPlanePos, fPlaneDir, fTrigCache, trackAlongPlaneDir); }

SVector6 recob::tracking::Plane::Local5DToGlobal6DParameters	(	const SVector5 &	par5d,
		const Point_t &	planePos,
		const Vector_t &	planeDir,
		const TrigCache &	trigCache,
		bool	trackAlongPlaneDir = true
	)		const

Definition at line 21 of file TrackingPlane.cxx.

                                                                                                                                                                           {
      const double& sinalpha = trigCache.fSinA;
      const double& cosalpha = trigCache.fCosA;
      const double& sinbeta  = trigCache.fSinB;
      const double& cosbeta  = trigCache.fCosB;
      const double denom = (trackAlongPlaneDir ? par5d[4]*std::sqrt(1. + par5d[2]*par5d[2] + par5d[3]*par5d[3]) : -par5d[4]*std::sqrt(1. + par5d[2]*par5d[2] + par5d[3]*par5d[3]) );
      SVector6 par6d;
      par6d[0] = planePos.X() + par5d[0]*cosalpha;
      par6d[1] = planePos.Y() + par5d[0]*sinalpha*sinbeta + par5d[1]*cosbeta;
      par6d[2] = planePos.Z() - par5d[0]*sinalpha*cosbeta + par5d[1]*sinbeta;
      par6d[3] = (par5d[2]*cosalpha + 1.*sinalpha)/denom;
      par6d[4] = (par5d[2]*sinalpha*sinbeta + par5d[3]*cosbeta - cosalpha*sinbeta)/denom;
      par6d[5] = (-par5d[2]*sinalpha*cosbeta + par5d[3]*sinbeta + cosalpha*cosbeta)/denom;
      return par6d;
    }

static SVector6 recob::tracking::Plane::Local5DToGlobal6DParameters ( const SVector5 &  par5d, const Point_t &  planePos, const Vector_t &  planeDir, bool  trackAlongPlaneDir = true  )

inlinestatic

Function to convert parameters from local to global coordinates. Local coordinates are on the plane with origin at planePos and orthogonal to planeDir. trackAlongPlaneDir is as given by trackDir.Dot(planeDir)>0.

Definition at line 131 of file TrackingPlane.h.

                                                                                                                                                            {
        Plane p(planePos, planeDir); return p.Local5DToGlobal6DParameters(par5d, trackAlongPlaneDir);
      }

Point_t const& recob::tracking::Plane::position ( ) const

inline

Reference position on the plane.

Definition at line 66 of file TrackingPlane.h.

{ return fPlanePos; }

double recob::tracking::Plane::sinAlpha ( ) const

inline

Definition at line 121 of file TrackingPlane.h.

{ return fTrigCache.fSinA; }

double recob::tracking::Plane::sinBeta ( ) const

inline

Definition at line 123 of file TrackingPlane.h.

{ return fTrigCache.fSinB; }

Member Data Documentation

Vector_t recob::tracking::Plane::fPlaneDir

private

Direction vector othogonal to the plane.

Definition at line 169 of file TrackingPlane.h.

Point_t recob::tracking::Plane::fPlanePos

private

Position of a point on the plane.

Definition at line 168 of file TrackingPlane.h.

TrigCache recob::tracking::Plane::fTrigCache

private

Cached trigonometric function values.

Definition at line 170 of file TrackingPlane.h.

---

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

• lardataobj/lardataobj/RecoBase/TrackingPlane.h
• lardataobj/lardataobj/RecoBase/TrackingPlane.cxx