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/Matrix.h"
#include "CLHEP/Matrix/SymMatrix.h"
#include "CLHEP/Matrix/Vector.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_ */