/home/bes3soft/bes3soft/Boss/7.0.2/dist/7.0.2/Mdc/MdcRecEvent/MdcRecEvent-00-05-14/MdcRecEvent/RecMdcKalTrack.h

Go to the documentation of this file.

/*
 * @class : RecMdcKalTrack
 *
 *  this class models "Kalman Track" used in Mdc Reconstruction
 *
 *  by wangjk 2006.9
 * 
 * ********************************************************/

#ifndef RECMDCKALTRACK_H
#define RECMDCKALTRACK_H
#include "GaudiKernel/ContainedObject.h"
#include "GaudiKernel/SmartRef.h" 
#include "GaudiKernel/SmartRefVector.h"
#include "GaudiKernel/ObjectVector.h"
#include "EventModel/EventModel.h"
#include "DstEvent/DstMdcKalTrack.h"
#include "CLHEP/Matrix/Vector.h"
#include "CLHEP/Matrix/SymMatrix.h"
#include "CLHEP/Vector/ThreeVector.h"
#include "CLHEP/Geometry/Point3D.h"
#include "RecMdcKalHelixSeg.h"


extern const CLID& CLID_RecMdcKalTrack;  

typedef SmartRefVector<RecMdcKalHelixSeg>  HelixSegRefVec;


class RecMdcKalTrack : public DstMdcKalTrack {

        public:
                virtual const CLID& clID() const   {
                        return RecMdcKalTrack::classID();
                }

                static const CLID& classID()       {
                        return CLID_RecMdcKalTrack;
                }                     
                //constructor and destructor
                RecMdcKalTrack();
                RecMdcKalTrack(const RecMdcKalTrack& track);
                RecMdcKalTrack(const DstMdcKalTrack& track);
                RecMdcKalTrack& operator=(const RecMdcKalTrack&);
                RecMdcKalTrack& operator=(const DstMdcKalTrack&);
                ~RecMdcKalTrack();

                //extractors
                HelixSegRefVec getVecHelixSegs(int pid=-1) const;//2011-05-06

                int getTrackId( void )                        const { return m_trackId;            }
                double getMass( int pid )                     const { return m_mass[pid];          }
                double getLength( int pid )                   const { return m_length[pid];        }
                double getTof( int pid )                      const { return m_tof[pid];           }
                int getNhits( int pid )                       const { return m_nhits[pid];         }
                int getStat( int i, int pid )                 const { return m_stat[i][pid];       }
                int getNster(const int i, const int pid)      const { return m_nster[i][pid];      }
                int getFirstLayer(const int i, const int pid) const { return m_firstLayer[i][pid]; }
                int getLastLayer(const int i, const int pid)  const { return m_lastLayer[i][pid];  } 
                double getChisq( int i, int pid )             const { return m_chisq[i][pid];      }
                int    getNdf( int i, int pid )               const { return m_ndf[i][pid];        }
                double getPathl( int i )                      const { return m_pathl[i];           }
                double getPathSM( int pid)                    const { return m_pathSM[pid];        }


                const HepVector&    getZHelix() const { return m_zhelixs[2]; }
                const HepSymMatrix& getZError() const { return m_zerrors[2]; }
                const HepVector&    getFHelix() const { return m_fhelixs[2]; }
                const HepSymMatrix& getFError() const { return m_ferrors[2]; }
                const HepVector&    getLHelix() const { return m_lhelixs[2]; }
                const HepSymMatrix& getLError() const { return m_lerrors[2]; }   
                const double    getTHelix(const int i) const { return m_thelix[i]; }
                const double    getTError(const int i) const { return m_terror[i]; }
                const HepVector getTHelix()  const { return m_ta; }
                const HepSymMatrix getTError() const { return m_tEa; }

                HepVector&     getZHelixE() { return m_zhelixs[0]; }
                HepSymMatrix&  getZErrorE() { return m_zerrors[0]; }
                HepVector&     getFHelixE() { return m_fhelixs[0]; }
                HepSymMatrix&  getFErrorE() { return m_ferrors[0]; }   
                HepVector&     getLHelixE() { return m_lhelixs[0]; }
                HepSymMatrix&  getLErrorE() { return m_lerrors[0]; }   

                HepVector&    getZHelixMu() { return m_zhelixs[1]; }
                HepSymMatrix& getZErrorMu() { return m_zerrors[1]; }
                HepVector&    getFHelixMu() { return m_fhelixs[1]; }
                HepSymMatrix& getFErrorMu() { return m_ferrors[1]; }   
                HepVector&    getLHelixMu() { return m_lhelixs[1]; }
                HepSymMatrix& getLErrorMu() { return m_lerrors[1]; } 

                HepVector&     getZHelixK() { return m_zhelixs[3]; }
                HepSymMatrix&  getZErrorK() { return m_zerrors[3]; }
                HepVector&     getFHelixK() { return m_fhelixs[3]; }
                HepSymMatrix&  getFErrorK() { return m_ferrors[3]; }   
                HepVector&     getLHelixK() { return m_lhelixs[3]; }
                HepSymMatrix&  getLErrorK() { return m_lerrors[3]; } 

                HepVector&     getZHelixP() { return m_zhelixs[4]; }
                HepSymMatrix&  getZErrorP() { return m_zerrors[4]; }
                HepVector&     getFHelixP() { return m_fhelixs[4]; }
                HepSymMatrix&  getFErrorP() { return m_ferrors[4]; }   
                HepVector&     getLHelixP() { return m_lhelixs[4]; }
                HepSymMatrix&  getLErrorP() { return m_lerrors[4]; }   

                const HepPoint3D getPocaE()  const { return m_pocas[0]; }
                const HepPoint3D getPocaMu() const { return m_pocas[1]; }
                const HepPoint3D getPoca()   const { return m_pocas[2]; }
                const HepPoint3D getPocaK()  const { return m_pocas[3]; }
                const HepPoint3D getPocaP()  const { return m_pocas[4]; }

                const HepPoint3D&  getLPointE()  const { return m_lpoints[0]; }
                const HepPoint3D&  getLPointMu() const { return m_lpoints[1]; }
                const HepPoint3D&  getLPoint()   const { return m_lpoints[2]; }
                const HepPoint3D&  getLPointK()  const { return m_lpoints[3]; }
                const HepPoint3D&  getLPointP()  const { return m_lpoints[4]; }

                const HepPoint3D&  getLPivotE()  const { return m_lpivots[0]; }
                const HepPoint3D&  getLPivotMu() const { return m_lpivots[1]; }
                const HepPoint3D&  getLPivot()   const { return m_lpivots[2]; }
                const HepPoint3D&  getLPivotK()  const { return m_lpivots[3]; }
                const HepPoint3D&  getLPivotP()  const { return m_lpivots[4]; }

                // const HepVector&    getZHelix(const int pid) const { return m_zhelixs[pid];}
                // const HepSymMatrix& getZError(const int pid) const { return m_zerrors[pid];}
                const HepVector&    getLHelix(const int pid) const { return m_lhelixs[pid];}
                const HepSymMatrix& getLError(const int pid) const { return m_lerrors[pid];}
                //const HepVector&    getFHelix(const int pid) const { return m_fhelixs[pid];}
                //const HepSymMatrix& getFError(const int pid) const { return m_ferrors[pid];}
                const HepPoint3D&   getPoca(const int pid)   const { return   m_pocas[pid];}
                const HepPoint3D&   getLPoint(const int pid) const { return m_lpoints[pid];}
                const double        getFiTerm(const int pid) const { return m_fiTerm[pid]; }
                const HepPoint3D&   getLPivot(const int pid) const { return m_lpivots[pid];}


                const double getZDr(void)   const { return m_zhelixs[2][0];   }
                const double getZFi0(void)  const { return m_zhelixs[2][1];   }
                const double getZCpa(void)  const { return m_zhelixs[2][2];   }
                const double getZDz(void)   const { return m_zhelixs[2][3];   }
                const double getZTanl(void) const { return m_zhelixs[2][4];   }

                const double getLDr(void)   const { return m_lhelixs[2][0];   }
                const double getLFi0(void)  const { return m_lhelixs[2][1];   }
                const double getLCpa(void)  const { return m_lhelixs[2][2];   }
                const double getLDz(void)   const { return m_lhelixs[2][3];   }
                const double getLTanl(void) const { return m_lhelixs[2][4];   }

                const double getFDr(void)   const { return m_fhelixs[2][0];   }
                const double getFFi0(void)  const { return m_fhelixs[2][1];   }
                const double getFCpa(void)  const { return m_fhelixs[2][2];   }
                const double getFDz(void)   const { return m_fhelixs[2][3];   }
                const double getFTanl(void) const { return m_fhelixs[2][4];   }


                // modifiers
                void setVecHelixSegs(const HelixSegRefVec& vechelixsegs, int pid=-1);// 2011-05-06


                //void setTrackId(int id)                      { m_trackId = id;           }
                void setMass(double mass, int pid)             { m_mass[pid] = mass;       }
                void setLength(double length, int pid)         { m_length[pid] = length;   }
                void setTof(double tof, int pid)               { m_tof[pid] = tof;         }   
                void setNhits(int nhits, int pid)              { m_nhits[pid] = nhits;     }
                //void setStat(int stat, int i, int pid)       { m_stat[i][pid] = stat;    }
                //void setChisq(double chisq, int i, int pid)  { m_chisq[i][pid] = chisq;  }
                //void setNdf(int ndf, int i, int pid)         { m_ndf[i][pid] = ndf;      }
                //void setNster(int nster, int i, int pid)     { m_nster[i][pid] = nster;  }
                //void setFirstLayer(int fL, int i, int pid)   { m_firstLayer[i][pid] = fL;}
                //void setLastLayer(int lL, int i, int pid)    { m_lastLayer[i][pid] = lL; }
                void setPathl(double pathl, int i)             { m_pathl[i] = pathl;       }   
                void setPathSM(double length, int pid)         { m_pathSM[pid] = length;   }


                /*
                   void setZHelix(const HepVector& helix, const int pid)  {
                   m_zhelixs[pid] = helix;
                   }
                   void setZError(const HepSymMatrix& error, const int pid) { 
                   m_zerrors[pid] = error;
                   }
                   void setZHelix(float* helix, const int pid)  {
                   for(int i=0; i<3; i++) {
                   m_zhelixs[pid][i] = helix[i]; 
                   }
                   }
                   void setZError(float* error, const int pid) {
                   int k=0;
                   HepSymMatrix mat(5);
                   for(int i=0; i<5 ; i++) {
                   for(int j=0; j<=i; j++,k++) {
                   mat[i][j] = error[k];
                   mat[j][i] = error[k];            
                   }      
                   }
                   m_zerrors[pid] = mat;
                   }
                 */

                //  void setFHelix(const HepVector& helix, const int pid)  {
                //    m_fhelixs[pid] = helix;
                //  }
                //  void setFError(const HepSymMatrix& error, const int pid) {
                //    m_ferrors[pid] = error;
                //  }
                //  void setFHelix(double* helix, const int pid)  {
                //    for(int i=0; i<5; i++) {
                //      m_fhelixs[pid][i] = helix[i];
                //    }
                //  }
                //  void setFError(double* error, const int pid) {
                //    int k=0;
                //    HepSymMatrix mat(5);
                //    for(int i=0; i<5 ; i++) {
                //      for(int j=0; j<=i; j++,k++) {
                //        mat[i][j] = error[k];
                //        mat[j][i] = error[k];
                //      }
                //    }
                //    m_ferrors[pid] = mat;
                //  }

                void setLHelix(const HepVector& helix, const int pid)  {
                        m_lhelixs[pid] = helix;
                }
                void setLError(const HepSymMatrix& error, const int pid) {
                        m_lerrors[pid] = error;
                }
                void setLHelix(double* helix, const int pid)  {
                        for(int i=0; i<5; i++) {
                                m_lhelixs[pid][i] = helix[i];
                        }
                }
                void setLError(double* error, const int pid) {
                        int k=0;
                        HepSymMatrix mat(5);
                        for(int i=0; i<5 ; i++) {
                                for(int j=0; j<=i; j++,k++) {
                                        mat[i][j] = error[k];
                                        mat[j][i] = error[k];
                                }
                        }
                        m_lerrors[pid] = mat;
                }

                void setTHelix(const HepVector& helix)  {
                        for(int i=0; i<5; i++){
                                m_thelix[i] = helix[i];
                        }
                        m_ta = helix;
                }
                void setTError(const HepSymMatrix& error) {
                        int k=0;
                        for(int i=0; i<5; i++){
                                for(int j=i; j<5; j++){
                                        m_terror[k] = error[i][j];
                                        k++;
                                }
                        }
                        m_tEa = error;
                }
                void setTHelix(double helix[5])  {
                        HepVector atemp(5);
                        for(int i=0; i<5; i++) {
                                m_thelix[i] = helix[i];
                                atemp[i] = helix[i];
                        }
                        m_ta = atemp;
                }
                void setTError(double error[15] ) {
                        int k=0;
                        HepSymMatrix mat(5);
                        for(int i=0; i<5 ; i++) {
                                for(int j=0; j<=i; j++,k++) {
                                        mat[i][j] = error[k];
                                        mat[j][i] = mat[i][j];
                                }
                        }
                        m_tEa = mat;

                        for(int i=0; i<15 ; i++) {
                                m_terror[i] = error[i];
                        }
                }

                void setLPoint(const HepPoint3D& point, const int pid)  {
                        m_lpoints[pid] = point;
                }


                void setFiTerm(double fi, const int pid){
                        m_fiTerm[pid] = fi;
                }


                void setLPivot(const HepPoint3D& pivot, const int pid)  {
                        m_lpivots[pid] = pivot;
                }


                /*
                   void setPoca(const HepPoint3D& poca, const int pid)  {
                   m_pocas[pid] = poca;
                   }
                   void setPoca(float* poca, const int pid)  {
                   for(int i=0; i<3; i++) {
                   m_pocas[pid][i] = poca[i];                 
                   }
                   }
                 */

        private:
                HelixSegRefVec m_vechelixsegs[5];// add 5 hypotheses by wangll 2011-05-06
                int pidSeg;// added by wangll 2011-05-06
                //int    m_trackId;
                double m_mass[5];     // mass assumption during the fit 
                //track path length from closest point to coord. origin to the last hit
                double m_length[5]; 
                double m_tof[5];      // time of flight correspond to length; 
                int    m_nhits[5];      // number of total hits contained 
                // status flag 0:filter 1: smoother, convention: -1:as default; 0:kalfit OK; 1: kalfit abandoned
                // int    m_stat[2][5]; 
                // int    m_nster[2][5];
                // int    m_firstLayer[2][5];
                // int    m_lastLayer[2][5];
                // double m_chisq[2][5]; // chi square of fit 0:filter 1:smoother 
                // int    m_ndf[2][5];   // degree of freedom for the fit 0:filter 1:smoother 
                double m_pathl[43];   // path length in each layer
                double m_pathSM[5];
                double m_fiTerm[5];

                // std::vector<HepPoint3D> m_pocas; 
                // std::vector<HepVector> m_zhelixs; 
                // std::vector<HepSymMatrix> m_zerrors; 

                std::vector<HepPoint3D>   m_lpivots;
                std::vector<HepPoint3D>   m_lpoints;

                //std::vector<HepVector>    m_fhelixs;
                //std::vector<HepSymMatrix> m_ferrors;
                std::vector<HepVector>    m_lhelixs;
                std::vector<HepSymMatrix> m_lerrors;
                double  m_thelix[5];
                double  m_terror[15];
                HepVector  m_ta;
                HepSymMatrix m_tEa;

};

typedef ObjectVector<RecMdcKalTrack> RecMdcKalTrackCol;

#endif

---