VtTrack.hh

Go to the documentation of this file.

#ifndef __VTTRACK_HH
#define __VTTRACK_HH
// *****************************************************************************
//
// source:
//
// type:      source code
//
// created:   21. Aug 2000
//
// author:    Thorsten Glebe
//            HERA-B Collaboration
//            Max-Planck-Institut fuer Kernphysik
//            Saupfercheckweg 1
//            69117 Heidelberg
//            Germany
//            E-mail: T.Glebe@mpi-hd.mpg.de
//
// Description: Track class
//
// changes:
// 21 Aug 2000 (TG) creation
// 24 Aug 2000 (TG) added ArtePointer declaration
// 04 Sep 2000 (TG) added pt(), theta(), phi(), eta() member function
// 05 Sep 2000 (TG) declared some member functions inline
// 06 Sep 2000 (TG) added xvec(), tvec(), pvec(), E() member functions
// 06 Sep 2000 (TG) added comments
// 12 Sep 2000 (TG) added ex(), ey(), ez(), evec(), rm() member functions
// 10 Okt 2000 (TG) data member t_GM and member function GM() added
// 26 Okt 2000 (TG) added #include <cmath>
// 26 Okt 2000 (TG) #ifndef NO_ARTE added (for integration into CLUE)
// 14 Nov 2000 (TG) added constructors for CLUE (RecoSegment, ArtePointer<RecoTrack>)
// 25 Nov 2000 (TG) added RecoTrack constructor
// 24 Feb 2001 (TG) operator= added, added restmass as default CTOR argument
// 04 Sep 2001 (TG) added TrackIf CTOR
// 17 Okt 2001 (TG) added/improved #defines for ARTE
// 05 Okt 2001 (TG) bug fix: added CINTOBJECT to get cintdict compilation right
// 09 Jan 2002 (TG) changed return type of propagate() to bool
//
// *****************************************************************************
 
#include <iosfwd>
#include "vt++/CMatrix.hh"
#include "vt++/VtVector.hh"
#include "vt++/VtRelationList.hh"
#include "TObject.h"
 
#if defined USE_ROOT
#ifndef __CINT__
#include "smatrix/SMatrix.hh"
#include "smatrix/SVector.hh"
#endif
#endif
 
namespace VERTEX {
  class Kalman;
 
  //============================================================================
  // Class Track
  //============================================================================
  class Track: public RelationList, public TObject
 {
  public:
    Track();
    Track(const Track* const track);
    Track(const Track& rhs);
    Track(const MATRIX::VtVector& v, const MATRIX::CMatrix& c);
    virtual ~Track();
    void set( double x,double y,double z,double tx,double ty,double p, 
    const MATRIX::CMatrix& c);
    Track& operator=(const Track& rhs);
 
    float x()      const;
    float y()      const;
    float x(float z)   const;
    float y(float z)   const;
    float z()      const;
    float tx()     const;
    float ty()     const;
    float p()      const;
    float pt()     const;
    float pz()     const;
    float chi2() const;
    unsigned short int ndf()  const;
    float phi()    const;
    float theta()  const;
    float eta()    const;
    int   charge()   const;
    float energy(double rm = 0.) const;
    float xf(double rm = 0.) const;
    float rap(double rm = 0.) const;
 
#if defined USE_ROOT && !defined CINTOBJECT
    SVector<double,3> xvec() const;
    SVector<double,3> tvec() const;
    SVector<double,3> evec() const;
    SVector<double,3> pvec() const;
    const SMatrix<double,5>& COV() const;
    const SMatrix<double,5>& CINV() const;
#else
    inline MATRIX::VtVector evec() const { return MATRIX::VtVector(ex(),ey(),ez()); }
    inline MATRIX::VtVector tvec() const { return MATRIX::VtVector(tx(),ty(),1.); }
    inline MATRIX::VtVector pvec() const { return MATRIX::VtVector(px(),py(),pz()); }
#endif
 
    float cov_x(double dz=0.)        const;
    float cov_y(double dz=0.)        const;
    float cov_tx()                   const;
    float cov_ty()                   const;
    float cov_p()                    const;
    
    bool isValid() const;
    void valid();
    void invalid();
 
#if defined USE_ROOT
    bool operator==(const Track& rhs) const;
 
//    void collect(vector<Track*>& c) const;
#endif
    bool propagate(const double zz); 
 
    double px()     const;
    double py()     const;
    double ex()     const;
    double ey()     const;
    double ez()     const;
 
    double xerr(double dz = 0)   const;
    double yerr(double dz = 0)   const;
    double txerr()               const;
    double tyerr()               const;
    double perr()                const;
 
 
    const MATRIX::CMatrix&     V()  const;
    const MATRIX::CMatrix&     G()  const;
    const MATRIX::CMatrix&     GM() const;
 
    std::ostream& print( std::ostream& os ) const;
    double rm() const;
    void rm(const double mass);
    double rmCC() const;
    void rmCC(const double mass);
 
    void delete_mom();
 
   //bool operator< (const Track& rhs);
   //int  operator==(const Track& rhs);
 
  private:
    short int           t_Q;      // charge
    double              t_rm;     // rest-mass (in Vt: xmass)
    double              t_rmCC;   // a conjugated mass hypothesis
  protected:
    MATRIX::VtVector    t_p;      // track parameter vector (x,y,z,tx,ty,p)
                  // (in Vt: p(1,...,5) 
    MATRIX::CMatrix     t_V;      // 5x5 covariance matrix of Track
    MATRIX::CMatrix     t_G;      // inverse of t_cov (5x5)
    MATRIX::CMatrix     t_GM;     // inverse of t_cov (4x4, without momentum)
 
  ClassDef(Track,1);
 
 }; // class Track
 
 
  //==============================================================================
  // operator <<
  //==============================================================================
  inline std::ostream& operator<< ( std::ostream& os, const Track& t ) {
    return t.print(os);
  }
 
} // end of namespace VERTEX
 
#ifndef __CINT__
#include "VtTrack.icc"
#endif
#endif