TrackBasis.h

Go to the documentation of this file.

///
/// \file    TrackBasis.h
/// \brief   Construct a track-based (x,y,z) coordinate system
/// \author  messier@indiana.edu
/// \version $Id:$
///
#ifndef BPFIT_TRACKBASEDSYSTEM_H
#define BPFIT_TRACKBASEDSYSTEM_H
#include <vector>
#include "TVector3.h"

namespace bpfit {
  ///
  /// Construct am (x,y,z) coordinate system where track direction
  /// defines the z axis.
  ///
  /// The track-based coordinate system is hoped to be useful for
  /// managing the smooth transition from forward going tracks where
  /// the detector measures x or y as a function of z to highly
  /// transverse tracks where the detector measures z as a function of
  /// x or y.
  ///
  class TrackBasis {
  public:
    ///
    /// Given a list of detector space points (x,y,z) find the primary
    /// track axis.
    ///
    /// @param x  - x track location of hit i
    /// @param y  - y track location of hit i
    /// @param z  - z track location of hit i
    /// @param dx - uncertainty in x
    /// @param dy - uncertainty in y
    /// @param dz - uncertainty in z
    /// @param z1 - on output, "z prime" axis which follows track
    ///
    static void FindAxis(const std::vector<double>& x,
                         const std::vector<double>& y,
                         const std::vector<double>& z,
                         const std::vector<double>& dx,
                         const std::vector<double>& dy,
                         const std::vector<double>& dz,
                         TVector3& z1);
    ///
    /// Construct the basis vectors and rotation matrices
    ///
    /// @param x  - track x coordinates (detector frame)
    /// @param y  - track y coordinates (detector frame)
    /// @param z  - track z coordinates (detector frame)
    /// @param dx - track x uncertainty
    /// @param dy - track y uncertainty
    /// @param dz - track z uncertainty
    /// @param vx - vertex x coordinate (detector frame)
    /// @param vy - vertex y coordinate (detector frame)
    /// @param vz - vertex z coordinate (detector frame)
    ///
    void MakeBasis(const std::vector<double>& x,
                   const std::vector<double>& y,
                   const std::vector<double>& z,
                   const std::vector<double>& dx,
                   const std::vector<double>& dy,
                   const std::vector<double>& dz,
                   double vx, double vy, double vz);

    ///
    /// Set the origin of the new coordinate system
    ///
    /// @param x - x location of origin (detector system)
    /// @param y - y location of origin (detector system)
    /// @param z - z location of origin (detector system)
    ///
    void SetOrigin(double x, double y, double z);
 
    ///
    /// Compare the new basis vectors to the location of the
    /// origin to make sure that the new Z axis points in the
    /// intended direction of the track and adjust the rotation
    /// matricies if needed.
    ///
    /// @param x  - track x coordinates (detector frame)
    /// @param y  - track y coordinates (detector frame)
    /// @param z  - track z coordinates (detector frame)
    /// @param dx - track x uncertainty
    /// @param dy - track y uncertainty
    /// @param dz - track z uncertainty
    ///
    void AdjustBasisDir(const std::vector<double>& x,
                        const std::vector<double>& y,
                        const std::vector<double>& z,
                        const std::vector<double>& dx,
                        const std::vector<double>& dy,
                        const std::vector<double>& dz);
    
    ///
    /// Transform from detector-based system to track-based system
    ///
    /// @param x   - detector-based x location
    /// @param y   - detector-based y location
    /// @param z   - detector-based z location
    /// @param dx  - detector-based x location error
    /// @param dy  - detector-based y location error
    /// @param dz  - detector-based z location error
    /// @param x1  - track-based x location
    /// @param y1  - track-based y location
    /// @param z1  - track-based z location
    /// @param dx1 - track-based dx location error
    /// @param dy1 - track-based dy location error
    /// @param dz1 - track-based dz location error
    ///
    void DetToTrk(double  x,   double  y,   double  z,
                  double  dx,  double  dy,  double  dz,
                  double* x1,  double* y1,  double* z1,
                  double* dx1, double* dy1, double* dz1);

    ///
    /// Transform from track-based system to detector-based system
    ///
    /// @param x   - track-based x location
    /// @param y   - track-based y location
    /// @param z   - track-based z location
    /// @param dx  - track-based x location error
    /// @param dy  - track-based y location error
    /// @param dz  - track-based z location error
    /// @param x1  - detector-based x location
    /// @param y1  - detector-based y location
    /// @param z1  - detector-based z location
    /// @param dx1 - detector-based dx location error
    /// @param dy1 - detector-based dy location error
    /// @param dz1 - detector-based dz location error
    ///
    void TrkToDet(double  x,   double  y,   double  z,
                  double  dx,  double  dy,  double  dz,
                  double* x1,  double* y1,  double* z1,
                  double* dx1, double* dy1, double* dz1);
      
  public:
    TVector3 fO;  ///< System origin in detector coordinates
    TVector3 fX1; ///< x basis vector in detector coordinates
    TVector3 fY1; ///< y basis vector in detector coordinates
    TVector3 fZ1; ///< z basis vector in detector coordinates
    double   fU [3][3]; ///< Transformation matrix
    double   fUT[3][3]; ///< Transpose of transformation matrix
  };
}

#endif // BPFIT_TRACKBASEDSYSTEM_H
////////////////////////////////////////////////////////////////////////