Ext_errmx.h

Go to the documentation of this file.

//
// File: Ext_errmx.h
//
// Description: Extrapolation error matrix( x, y, z, px, py, pz ).
//              The used coordinate system is the cartesian BESIII 
//              coordinate system.
//
//              Modified from BELLE by  Wang Liangliang.
//  
// Date: 2005.3.30
//
// 
 
 
#ifndef _Ext_Errmx_Flag_
#define _Ext_Errmx_Flag_
 
#include    <iosfwd>
 
#ifndef   CLHEP_THREEVECTOR_H
#include "CLHEP/Vector/ThreeVector.h"
#endif
 
#include    "CLHEP/Matrix/Vector.h"
#include    "CLHEP/Matrix/Matrix.h"
#include    "CLHEP/Matrix/SymMatrix.h"
 
using namespace CLHEP;
 
 
static const int Ndim_err(6);       // Error matrix dimension.
 
//  Track error matrix handler.
 
 
class Ext_errmx {
 
public:
  // Constructor
  Ext_errmx();
 
  // Copy constructor
  Ext_errmx( const Ext_errmx &errmx );
 
  // Constructor, initializing by HepSymMatrix error matrix.
  Ext_errmx( const HepSymMatrix &err );
 
  // Destructor
  virtual ~Ext_errmx(){};
 
  // Put the error matrix with a double array format.
  void put_err( const double error[] );
 
  // Put the error matrix with a HepSymMatrix format.
  inline void put_err( const HepSymMatrix &err );
 
  // Get the error matrix from the object.
  inline const HepSymMatrix & get_err() const;
 
  // Get the error along the readout direction.
  double get_plane_err( const Hep3Vector &np, const Hep3Vector &nr ) const;
 
    /** Get the 2D projected error vector on the detector plane.
     \begin{itemize}
     \item np: track direction unit vector.
     \item nr: readout direction unit vector.
     \item nt: ( np x nr ) unit vector.
     \item HepVector(1)= error(sigma) along the nr.
     \item HepVector(2)= error(sigma) along the nt.
    \end{itemize}
    */
  const HepVector & get_plane_errs( const Hep3Vector &np, 
        const Hep3Vector &nr, const Hep3Vector &nt ) const;
 
    /** Get 2D projected track error perpendicular to a given 
     vector at the current point. pv: a given vector, 
     momentum vector for example.
     \begin{itemize}
     \item view=1. 
        \begin{itemize}
         \item Hep3Vector(1)= error(1 sigma) along the direction 
            which is perpendicular to pv on the xy plane.
             \item Hep3Vector(2)= error(1 sigma) along the direction 
            which is (pv) x (HepVector(1) direction).
         \end{itemize}
     \item view=2. 
         \begin{itemize}
         \item Hep3Vector(1)= error(1 sigma) along the direction 
            which is perpendicular to pv on the zy plane.
             \item Hep3Vector(2)= error(1 sigma) along the direction 
            which is (pv) x (HepVector(1) direction).
         \end{itemize}
     \item view=3. 
         \begin{itemize}
         \item Hep3Vector(1)= error(1 sigma) along the direction 
            which is perpendicular to pv on the zx plane.
             \item Hep3Vector(2)= error(1 sigma) along the direction 
            which is (pv) x (HepVector(1) direction).
         \end{itemize}
     \end{itemize}
    */
  const Hep3Vector * get_tvs( const int view, const Hep3Vector &pv ) const; 
 
    /** Get the 2D projected track error perpendicular to 
     a given vector at the current point. pv: a given vector,
     momentum vector, for example.
     \begin{itemize}
     \item Hep3Vector(1)= error(1 sigma) along the direction which is
     perpendicular to pv on the plane formed by pv and z-axis.
     \item Hep3Vector(2)= error(1 sigma) along the direction which is
     (pv) x (HepVector(1) direction).
     \end{itemize}
    */
  const Hep3Vector* get_tvs( const Hep3Vector &pv ) const; 
 
    // Check the validity of the error matrix.
  bool valid( bool msg ) const; 
 
    // = Operator.
  Ext_errmx &operator=( const Ext_errmx &errmx );
 
    // << Operator.
  friend std::ostream &operator<<( std::ostream &s, const Ext_errmx &errmx );
 
 
protected:
 
    // Setup m\_err3 and m\_R for get\_plane\_err(s).
  void set_plane_errs( const Hep3Vector &nx, const Hep3Vector &ny, 
              const Hep3Vector &nz ) const;
 
    // 6x6 symmetry error matrix(x,y,z,px,py,pz).
  HepSymMatrix  m_err;
 
private:
 
  mutable bool      m_valid;    // Valid flag.
  mutable HepSymMatrix  m_err3;     // 3x3 sub error matrix(x,y,z).
  mutable HepVector m_err2;     // 2D projected error.
  mutable Hep3Vector    m_nv[2];    // 2D projected error direction.
  mutable HepMatrix m_R;        // 3x3 rotation matrix: BCS -> TCS
 
};
 
/*
  Put the error matrix.
*/
inline void Ext_errmx::put_err( const HepSymMatrix &err )
{
  m_err = err;
  m_valid = 1;
}
 
/*
  Get the error matrix.
*/
inline const HepSymMatrix & Ext_errmx::get_err() const {
  return m_err;
}
 
#endif /* _Ext_Errmx_Flag_ */