Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages

RecMdcKalTrack Class Reference

#include <RecMdcKalTrack.h>

Inheritance diagram for RecMdcKalTrack:

DstMdcKalTrack DstMdcKalTrack ContainedObject ContainedObject ContainedObject ContainedObject List of all members.

Public Types

enum  PidType {
  null = -1, electron = 0, muon = 1, pion = 2,
  kaon = 3, proton = 4
}
enum  PidType {
  null = -1, electron = 0, muon = 1, pion = 2,
  kaon = 3, proton = 4
}

Public Member Functions

const int charge () const
const int charge () const
const double chi2 () const
const double chi2 () const
virtual const CLID & clID () const
virtual const CLID & clID () const
const double dr (void) const
const double dr (void) const
const double dz (void) const
const double dz (void) const
const HepSymMatrix & err () const
const HepSymMatrix & err () const
const HepSymMatrix & ferr () const
const HepSymMatrix & ferr () const
const HepVector & fhelix () const
const HepVector & fhelix () const
const double fi0 (void) const
const double fi0 (void) const
const int firstLayer () const
const int firstLayer () const
const int getCharge (const int pid) const
const int getCharge (const int pid) const
const double getChisq (const int pid) const
double getChisq (int i, int pid) const
double getChisq (int i, int pid) const
const double getFCpa (void) const
const double getFCpa (void) const
const double getFDr (void) const
const double getFDr (void) const
const double getFDz (void) const
const double getFDz (void) const
const HepSymMatrix & getFError (const int pid) const
const HepSymMatrix & getFError () const
const HepSymMatrix & getFError () const
HepSymMatrix & getFErrorE ()
HepSymMatrix & getFErrorE ()
HepSymMatrix & getFErrorK ()
HepSymMatrix & getFErrorK ()
HepSymMatrix & getFErrorMu ()
HepSymMatrix & getFErrorMu ()
HepSymMatrix & getFErrorP ()
HepSymMatrix & getFErrorP ()
const double getFFi0 (void) const
const double getFFi0 (void) const
const HepVector & getFHelix (const int pid) const
const HepVector & getFHelix () const
const HepVector & getFHelix () const
HepVector & getFHelixE ()
HepVector & getFHelixE ()
HepVector & getFHelixK ()
HepVector & getFHelixK ()
HepVector & getFHelixMu ()
HepVector & getFHelixMu ()
HepVector & getFHelixP ()
HepVector & getFHelixP ()
const int getFirstLayer (const int pid) const
int getFirstLayer (const int i, const int pid) const
int getFirstLayer (const int i, const int pid) const
const double getFiTerm (const int pid) const
const double getFiTerm (const int pid) const
const double getFTanl (void) const
const double getFTanl (void) const
const int getLastLayer (const int pid) const
int getLastLayer (const int i, const int pid) const
int getLastLayer (const int i, const int pid) const
const double getLCpa (void) const
const double getLCpa (void) const
const double getLDr (void) const
const double getLDr (void) const
const double getLDz (void) const
const double getLDz (void) const
double getLength (int pid) const
double getLength (int pid) const
const HepSymMatrix & getLError (const int pid) const
const HepSymMatrix & getLError () const
const HepSymMatrix & getLError (const int pid) const
const HepSymMatrix & getLError () const
HepSymMatrix & getLErrorE ()
HepSymMatrix & getLErrorE ()
HepSymMatrix & getLErrorK ()
HepSymMatrix & getLErrorK ()
HepSymMatrix & getLErrorMu ()
HepSymMatrix & getLErrorMu ()
HepSymMatrix & getLErrorP ()
HepSymMatrix & getLErrorP ()
const double getLFi0 (void) const
const double getLFi0 (void) const
const HepVector & getLHelix (const int pid) const
const HepVector & getLHelix () const
const HepVector & getLHelix (const int pid) const
const HepVector & getLHelix () const
HepVector & getLHelixE ()
HepVector & getLHelixE ()
HepVector & getLHelixK ()
HepVector & getLHelixK ()
HepVector & getLHelixMu ()
HepVector & getLHelixMu ()
HepVector & getLHelixP ()
HepVector & getLHelixP ()
const HepPoint3D & getLPivot (const int pid) const
const HepPoint3D & getLPivot () const
const HepPoint3D & getLPivot (const int pid) const
const HepPoint3D & getLPivot () const
const HepPoint3D & getLPivotE () const
const HepPoint3D & getLPivotE () const
const HepPoint3D & getLPivotK () const
const HepPoint3D & getLPivotK () const
const HepPoint3D & getLPivotMu () const
const HepPoint3D & getLPivotMu () const
const HepPoint3D & getLPivotP () const
const HepPoint3D & getLPivotP () const
const HepPoint3D & getLPoint (const int pid) const
const HepPoint3D & getLPoint () const
const HepPoint3D & getLPoint (const int pid) const
const HepPoint3D & getLPoint () const
const HepPoint3D & getLPointE () const
const HepPoint3D & getLPointE () const
const HepPoint3D & getLPointK () const
const HepPoint3D & getLPointK () const
const HepPoint3D & getLPointMu () const
const HepPoint3D & getLPointMu () const
const HepPoint3D & getLPointP () const
const HepPoint3D & getLPointP () const
const double getLTanl (void) const
const double getLTanl (void) const
double getMass (int pid) const
double getMass (int pid) const
const int getNdf (const int pid) const
int getNdf (int i, int pid) const
int getNdf (int i, int pid) const
int getNhits (int pid) const
int getNhits (int pid) const
const int getNster (const int pid) const
int getNster (const int i, const int pid) const
int getNster (const int i, const int pid) const
double getPathl (int i) const
double getPathl (int i) const
double getPathSM (int pid) const
double getPathSM (int pid) const
const HepPoint3D & getPoca (const int pid) const
const HepPoint3D getPoca () const
const HepPoint3D & getPoca (const int pid) const
const HepPoint3D getPoca () const
const HepPoint3D getPocaE () const
const HepPoint3D getPocaE () const
const HepPoint3D getPocaK () const
const HepPoint3D getPocaK () const
const HepPoint3D getPocaMu () const
const HepPoint3D getPocaMu () const
const HepPoint3D getPocaP () const
const HepPoint3D getPocaP () const
const int getStat (const int pid) const
int getStat (int i, int pid) const
int getStat (int i, int pid) const
const HepSymMatrix getTError () const
const double getTError (const int i) const
const HepSymMatrix getTError () const
const double getTError (const int i) const
const HepVector getTHelix () const
const double getTHelix (const int i) const
const HepVector getTHelix () const
const double getTHelix (const int i) const
double getTof (int pid) const
double getTof (int pid) const
int getTrackId (void) const
int getTrackId (void) const
HelixSegRefVec getVecHelixSegs (void) const
HelixSegRefVec getVecHelixSegs (void) const
const double getZCpa (void) const
const double getZCpa (void) const
const double getZDr (void) const
const double getZDr (void) const
const double getZDz (void) const
const double getZDz (void) const
const HepSymMatrix & getZError (const int pid) const
const HepSymMatrix & getZError () const
const HepSymMatrix & getZError () const
HepSymMatrix & getZErrorE ()
HepSymMatrix & getZErrorE ()
HepSymMatrix & getZErrorK ()
HepSymMatrix & getZErrorK ()
HepSymMatrix & getZErrorMu ()
HepSymMatrix & getZErrorMu ()
HepSymMatrix & getZErrorP ()
HepSymMatrix & getZErrorP ()
const double getZFi0 (void) const
const double getZFi0 (void) const
const HepVector & getZHelix (const int pid) const
const HepVector & getZHelix () const
const HepVector & getZHelix () const
HepVector & getZHelixE ()
HepVector & getZHelixE ()
HepVector & getZHelixK ()
HepVector & getZHelixK ()
HepVector & getZHelixMu ()
HepVector & getZHelixMu ()
HepVector & getZHelixP ()
HepVector & getZHelixP ()
const double getZTanl (void) const
const double getZTanl (void) const
const HepVector & helix () const
const HepVector & helix () const
const double kappa (void) const
const double kappa (void) const
const int lastLayer () const
const int lastLayer () const
const double mass () const
const double mass () const
const int ndof () const
const int ndof () const
const int nster () const
const int nster () const
RecMdcKalTrack & operator= (const DstMdcKalTrack &)
RecMdcKalTrack & operator= (const RecMdcKalTrack &)
RecMdcKalTrack & operator= (const DstMdcKalTrack &)
RecMdcKalTrack & operator= (const RecMdcKalTrack &)
const double p () const
const double p () const
const Hep3Vector p3 () const
const Hep3Vector p3 () const
const HepLorentzVector p4 (double mass) const
const HepLorentzVector p4 () const
const HepLorentzVector p4 (double mass) const
const HepLorentzVector p4 () const
const double phi () const
const double phi () const
const HepPoint3D poca () const
const HepPoint3D poca () const
const double px () const
const double px () const
const double pxy () const
const double pxy () const
const double py () const
const double py () const
const double pz () const
const double pz () const
const double r () const
const double r () const
 RecMdcKalTrack (const DstMdcKalTrack &track)
 RecMdcKalTrack (const RecMdcKalTrack &track)
 RecMdcKalTrack ()
 RecMdcKalTrack (const DstMdcKalTrack &track)
 RecMdcKalTrack (const RecMdcKalTrack &track)
 RecMdcKalTrack ()
void setCharge (const int charge, const int pid)
void setCharge (const int charge, const int pid)
void setChisq (double chisq, int i, int pid)
void setChisq (double chisq, int i, int pid)
void setFError (double *ferror, const int pid)
void setFError (const HepSymMatrix &ferror, const int pid)
void setFError (double *ferror, const int pid)
void setFError (const HepSymMatrix &ferror, const int pid)
void setFHelix (double *fhelix, const int pid)
void setFHelix (const HepVector &fhelix, const int pid)
void setFHelix (double *fhelix, const int pid)
void setFHelix (const HepVector &fhelix, const int pid)
void setFirstLayer (int fL, int i, int pid)
void setFirstLayer (int fL, int i, int pid)
void setFiTerm (double fi, const int pid)
void setFiTerm (double fi, const int pid)
void setLastLayer (int lL, int i, int pid)
void setLastLayer (int lL, int i, int pid)
void setLength (double length, int pid)
void setLength (double length, int pid)
void setLError (double *error, const int pid)
void setLError (const HepSymMatrix &error, const int pid)
void setLError (double *error, const int pid)
void setLError (const HepSymMatrix &error, const int pid)
void setLHelix (double *helix, const int pid)
void setLHelix (const HepVector &helix, const int pid)
void setLHelix (double *helix, const int pid)
void setLHelix (const HepVector &helix, const int pid)
void setLPivot (const HepPoint3D &pivot, const int pid)
void setLPivot (const HepPoint3D &pivot, const int pid)
void setLPoint (const HepPoint3D &point, const int pid)
void setLPoint (const HepPoint3D &point, const int pid)
void setMass (double mass, int pid)
void setMass (double mass, int pid)
void setNdf (int ndf, int i, int pid)
void setNdf (int ndf, int i, int pid)
void setNhits (int nhits, int pid)
void setNhits (int nhits, int pid)
void setNster (int ns, int i, int pid)
void setNster (int ns, int i, int pid)
void setP (const double p, const int pid)
void setP (const double p, const int pid)
void setPathl (double pathl, int i)
void setPathl (double pathl, int i)
void setPathSM (double length, int pid)
void setPathSM (double length, int pid)
void setPhi (const double phi, const int pid)
void setPhi (const double phi, const int pid)
void setPoca (double *poca, const int pid)
void setPoca (const HepPoint3D &poca, const int pid)
void setPoca (double *poca, const int pid)
void setPoca (const HepPoint3D &poca, const int pid)
void setPx (const double px, const int pid)
void setPx (const double px, const int pid)
void setPxy (const double pxy, const int pid)
void setPxy (const double pxy, const int pid)
void setPy (const double py, const int pid)
void setPy (const double py, const int pid)
void setPz (const double pz, const int pid)
void setPz (const double pz, const int pid)
void setR (const double r, const int pid)
void setR (const double r, const int pid)
void setStat (int stat, int i, int pid)
void setStat (int stat, int i, int pid)
void setTError (double error[15])
void setTError (const HepSymMatrix &error)
void setTError (double error[15])
void setTError (const HepSymMatrix &error)
void setTHelix (double helix[5])
void setTHelix (const HepVector &helix)
void setTHelix (double helix[5])
void setTHelix (const HepVector &helix)
void setTheta (const double theta, const int pid)
void setTheta (const double theta, const int pid)
void setTof (double tof, int pid)
void setTof (double tof, int pid)
void setTrackId (int trackId)
void setTrackId (int trackId)
void setVecHelixSegs (const HelixSegRefVec &vechelixsegs)
void setVecHelixSegs (const HelixSegRefVec &vechelixsegs)
void setX (const double x, const int pid)
void setX (const double x, const int pid)
void setY (const double y, const int pid)
void setY (const double y, const int pid)
void setZ (const double z, const int pid)
void setZ (const double z, const int pid)
void setZError (double *error, const int pid)
void setZError (const HepSymMatrix &error, const int pid)
void setZError (double *error, const int pid)
void setZError (const HepSymMatrix &error, const int pid)
void setZHelix (double *helix, const int pid)
void setZHelix (const HepVector &helix, const int pid)
void setZHelix (double *helix, const int pid)
void setZHelix (const HepVector &helix, const int pid)
const int stat () const
const int stat () const
const double tanl (void) const
const double tanl (void) const
const double theta () const
const double theta () const
const int trackId () const
const int trackId () const
const double x (const int i) const
const double x () const
const double x (const int i) const
const double x () const
const HepPoint3D x3 () const
const HepPoint3D x3 () const
const double y (const int i) const
const double y () const
const double y (const int i) const
const double y () const
const double z (const int i) const
const double z () const
const double z (const int i) const
const double z () const
 ~RecMdcKalTrack ()
 ~RecMdcKalTrack ()

Static Public Member Functions

const CLID & classID ()
const CLID & classID ()
PidType getPidType ()
PidType getPidType ()
void setPidType (PidType pidType)
void setPidType (PidType pidType)

Protected Attributes

int m_charge [5]
double m_chisq [2][5]
std::vector< HepSymMatrix > m_ferrors
std::vector< HepSymMatrix > m_ferrors
std::vector< HepVector > m_fhelixs
std::vector< HepVector > m_fhelixs
int m_firstLayer [2][5]
int m_lastLayer [2][5]
int m_ndf [2][5]
int m_nster [2][5]
double m_p [5]
double m_phi [5]
std::vector< HepPoint3D > m_pocas
std::vector< HepPoint3D > m_pocas
double m_px [5]
double m_pxy [5]
double m_py [5]
double m_pz [5]
double m_r [5]
int m_stat [2][5]
double m_theta [5]
int m_trackId
double m_x [5]
double m_y [5]
double m_z [5]
std::vector< HepSymMatrix > m_zerrors
std::vector< HepSymMatrix > m_zerrors
std::vector< HepVector > m_zhelixs
std::vector< HepVector > m_zhelixs

Static Protected Attributes

PidType m_pidType

Private Attributes

double m_fiTerm [5]
double m_length [5]
std::vector< HepSymMatrix > m_lerrors
std::vector< HepSymMatrix > m_lerrors
std::vector< HepVector > m_lhelixs
std::vector< HepVector > m_lhelixs
std::vector< HepPoint3D > m_lpivots
std::vector< HepPoint3D > m_lpivots
std::vector< HepPoint3D > m_lpoints
std::vector< HepPoint3D > m_lpoints
double m_mass [5]
int m_nhits [5]
double m_pathl [43]
double m_pathSM [5]
HepVector m_ta
HepSymMatrix m_tEa
double m_terror [15]
double m_thelix [5]
double m_tof [5]
HelixSegRefVec m_vechelixsegs

Member Enumeration Documentation

enum DstMdcKalTrack::PidType [inherited]
 

Enumeration values:
null 
electron 
muon 
pion 
kaon 
proton  
00050    {
00051      null = -1,
00052      electron = 0,
00053      muon = 1,
00054      pion = 2,
00055      kaon = 3,
00056      proton = 4
00057    };

enum DstMdcKalTrack::PidType [inherited]
 

Enumeration values:
null 
electron 
muon 
pion 
kaon 
proton  
00050    {
00051      null = -1,
00052      electron = 0,
00053      muon = 1,
00054      pion = 2,
00055      kaon = 3,
00056      proton = 4
00057    };

Constructor & Destructor Documentation

RecMdcKalTrack::RecMdcKalTrack (   ) 
  

00011 :DstMdcKalTrack() 
00012 {
00013   HepVector a(5,0);
00014   HepSymMatrix Ea(5,0);
00015   HepPoint3D poca(0,0,0);
00016   HepPoint3D point(0.,0.,0);
00017   HepPoint3D pivot(0.,0.,0);
00018   
00019   m_ta(5,0);
00020   m_tEa(5,0);
00021   m_trackId = -1;
00022   for(int pid=0; pid<5; pid++){
00023     m_lhelixs.push_back(a);
00024     m_lerrors.push_back(Ea);
00025 //    m_fhelixs.push_back(a);
00026 //    m_ferrors.push_back(Ea);
00027     m_lpoints.push_back(point);
00028     m_lpivots.push_back(pivot);
00029     
00030     m_length[pid] = 0.0;
00031     m_tof[pid] = 0.0;
00032     m_nhits[pid] = 0;
00033     m_pathSM[pid] = 0.0;
00034     m_fiTerm[pid] = 0.0;
00035     m_stat[0][pid] = -1;
00036     m_stat[1][pid] = -1;
00037     m_nster[0][pid] = -1;
00038     m_nster[1][pid] = -1;
00039     m_firstLayer[0][pid] = 0;
00040     m_firstLayer[1][pid] = 0;
00041     m_lastLayer[0][pid] = 43; 
00042     m_lastLayer[1][pid] = 43;
00043     m_chisq[0][pid] = 999.0;    
00044     m_chisq[1][pid] = 999.0;   
00045     m_ndf[0][pid] = 0;
00046     m_ndf[1][pid] = 0;
00047   }
00048   for( int i=0; i<43; i++) {   
00049           m_pathl[i] = 0.0;
00050   }
00051   for(int j=0; j<5; j++) {
00052           m_thelix[j] = 0.0;
00053   }
00054   for(int k=0; k<15; k++){
00055           m_terror[k]= 0.;
00056   }
00057 }

RecMdcKalTrack::RecMdcKalTrack (  const RecMdcKalTrack &  track  ) 
  

00061 :DstMdcKalTrack(trk),
00062         m_vechelixsegs(trk.m_vechelixsegs)
00063 {   
00064 }

RecMdcKalTrack::RecMdcKalTrack (  const DstMdcKalTrack &  track  ) 
  

00067 :DstMdcKalTrack(dstrk)
00068 {
00069         HepVector a(5,-99);
00070         HepSymMatrix Ea(5,-99);
00071         HepPoint3D poca(-99.,-99.,-99.);
00072         HepPoint3D point(0.,0.,0);
00073         HepPoint3D pivot(0.,0.,0);
00074  
00075         m_ta(5,0);
00076         m_tEa(5,0);
00077  
00078         //m_trackId = -1;
00079         for(int pid=0; pid<5; pid++){
00080                 //m_pocas.push_back(poca);
00081                 //m_zhelixs.push_back(a);
00082     //m_zerrors.push_back(Ea);
00083     m_lhelixs.push_back(a);
00084     m_lerrors.push_back(Ea);
00085  //   m_fhelixs.push_back(a);
00086  //   m_ferrors.push_back(Ea);
00087     m_lpoints.push_back(point);
00088     m_lpivots.push_back(pivot);
00089     
00090     m_length[pid] = 0.0;
00091     m_tof[pid] = 0.0;
00092     m_nhits[pid] = 0;
00093     m_pathSM[pid] = 0.0;
00094     m_fiTerm[pid] = 0.0;
00095          
00096     m_stat[0][pid] = -1;
00097     m_stat[1][pid] = -1;
00098     m_nster[0][pid] = -1;
00099     m_nster[1][pid] = -1;
00100     m_firstLayer[0][pid] = 0;
00101     m_firstLayer[1][pid] = 0;
00102     m_lastLayer[0][pid] = 43;
00103     m_lastLayer[1][pid] = 43;
00104     m_chisq[0][pid] = 999.0;
00105     m_chisq[1][pid] = 999.0;
00106     m_ndf[0][pid] = 0;
00107     m_ndf[1][pid] = 0;
00108   }
00109   for(int i=0; i<43; i++) {
00110     m_pathl[i] = 0.0;
00111   }
00112   for(int j=0; j<5; j++) {
00113           m_thelix[j] = 0.0;
00114   }
00115   for(int k=0; k<15; k++){
00116           m_terror[k]= 0.;
00117   }
00118 }

RecMdcKalTrack::~RecMdcKalTrack (   ) 
  

00181                                 {
00182 
00183 }

RecMdcKalTrack::RecMdcKalTrack (   ) 
 

RecMdcKalTrack::RecMdcKalTrack (  const RecMdcKalTrack &  track  ) 
 

RecMdcKalTrack::RecMdcKalTrack (  const DstMdcKalTrack &  track  ) 
 

RecMdcKalTrack::~RecMdcKalTrack (   ) 
 

Member Function Documentation

const int DstMdcKalTrack::charge (   )  const [inline, inherited]
  

00065 { return m_charge[m_pidType];}

const int DstMdcKalTrack::charge (   )  const [inline, inherited]
  

00065 { return m_charge[m_pidType];}

const double DstMdcKalTrack::chi2 (   )  const [inline, inherited]
  

00084 {return m_chisq[0][m_pidType];}

const double DstMdcKalTrack::chi2 (   )  const [inline, inherited]
  

00084 {return m_chisq[0][m_pidType];}

const CLID& RecMdcKalTrack::classID (   )  [inline, static]
 

Reimplemented from DstMdcKalTrack.

00037                                       {
00038       return CLID_RecMdcKalTrack;
00039    }

const CLID& RecMdcKalTrack::classID (   )  [inline, static]
 

Reimplemented from DstMdcKalTrack.

00037                                       {
00038       return CLID_RecMdcKalTrack;
00039    }

virtual const CLID& RecMdcKalTrack::clID (   )  const [inline, virtual]
 

Reimplemented from DstMdcKalTrack.

00033                                       {
00034       return RecMdcKalTrack::classID();
00035    }

virtual const CLID& RecMdcKalTrack::clID (   )  const [inline, virtual]
 

Reimplemented from DstMdcKalTrack.

00033                                       {
00034       return RecMdcKalTrack::classID();
00035    }

const double DstMdcKalTrack::dr (  void   )  const [inline, inherited]
  

00090 { return m_zhelixs[m_pidType][0];   }

const double DstMdcKalTrack::dr (  void   )  const [inline, inherited]
  

00090 { return m_zhelixs[m_pidType][0];   }

const double DstMdcKalTrack::dz (  void   )  const [inline, inherited]
  

00093 { return m_zhelixs[m_pidType][3];   }

const double DstMdcKalTrack::dz (  void   )  const [inline, inherited]
  

00093 { return m_zhelixs[m_pidType][3];   }

const HepSymMatrix& DstMdcKalTrack::err (   )  const [inline, inherited]
  

00097 { return m_zerrors[m_pidType];     }

const HepSymMatrix& DstMdcKalTrack::err (   )  const [inline, inherited]
  

00097 { return m_zerrors[m_pidType];     }

const HepSymMatrix& DstMdcKalTrack::ferr (   )  const [inline, inherited]
  

00099 { return m_ferrors[m_pidType];     }

const HepSymMatrix& DstMdcKalTrack::ferr (   )  const [inline, inherited]
  

00099 { return m_ferrors[m_pidType];     }

const HepVector& DstMdcKalTrack::fhelix (   )  const [inline, inherited]
  

00098 { return m_fhelixs[m_pidType];     }

const HepVector& DstMdcKalTrack::fhelix (   )  const [inline, inherited]
  

00098 { return m_fhelixs[m_pidType];     }

const double DstMdcKalTrack::fi0 (  void   )  const [inline, inherited]
  

00091 { return m_zhelixs[m_pidType][1];   }

const double DstMdcKalTrack::fi0 (  void   )  const [inline, inherited]
  

00091 { return m_zhelixs[m_pidType][1];   }

const int DstMdcKalTrack::firstLayer (   )  const [inline, inherited]
  

00087 {return m_firstLayer[0][m_pidType];}

const int DstMdcKalTrack::firstLayer (   )  const [inline, inherited]
  

00087 {return m_firstLayer[0][m_pidType];}

const int DstMdcKalTrack::getCharge (  const int  pid  )  const [inline, inherited]
  

00189 { return m_charge[pid];    }

const int DstMdcKalTrack::getCharge (  const int  pid  )  const [inline, inherited]
  

00189 { return m_charge[pid];    }

const double DstMdcKalTrack::getChisq (  const int  pid  )  const [inline, inherited]
  

00192 { return m_chisq[0][pid];     }

double RecMdcKalTrack::getChisq (  int  i,
int  pid
)  const [inline]
  

00060 { return m_chisq[i][pid];      }

double RecMdcKalTrack::getChisq (  int  i,
int  pid
)  const [inline]
  

00060 { return m_chisq[i][pid];      }

const double RecMdcKalTrack::getFCpa (  void   )  const [inline]
  

00149 { return m_fhelixs[2][2];   }

const double RecMdcKalTrack::getFCpa (  void   )  const [inline]
  

00149 { return m_fhelixs[2][2];   }

const double RecMdcKalTrack::getFDr (  void   )  const [inline]
  

00147 { return m_fhelixs[2][0];   }

const double RecMdcKalTrack::getFDr (  void   )  const [inline]
  

00147 { return m_fhelixs[2][0];   }

const double RecMdcKalTrack::getFDz (  void   )  const [inline]
  

00150 { return m_fhelixs[2][3];   }

const double RecMdcKalTrack::getFDz (  void   )  const [inline]
  

00150 { return m_fhelixs[2][3];   }

const HepSymMatrix& DstMdcKalTrack::getFError (  const int  pid  )  const [inline, inherited]
  

00210                                                     {
00211      return m_ferrors[pid];
00212    }

const HepSymMatrix& RecMdcKalTrack::getFError (   )  const [inline]
  

00069 { return m_ferrors[2]; }

const HepSymMatrix& RecMdcKalTrack::getFError (   )  const [inline]
  

00069 { return m_ferrors[2]; }

HepSymMatrix& RecMdcKalTrack::getFErrorE (   )  [inline]
  

00080 { return m_ferrors[0]; }

HepSymMatrix& RecMdcKalTrack::getFErrorE (   )  [inline]
  

00080 { return m_ferrors[0]; }

HepSymMatrix& RecMdcKalTrack::getFErrorK (   )  [inline]
  

00094 { return m_ferrors[3]; }

HepSymMatrix& RecMdcKalTrack::getFErrorK (   )  [inline]
  

00094 { return m_ferrors[3]; }

HepSymMatrix& RecMdcKalTrack::getFErrorMu (   )  [inline]
  

00087 { return m_ferrors[1]; }

HepSymMatrix& RecMdcKalTrack::getFErrorMu (   )  [inline]
  

00087 { return m_ferrors[1]; }

HepSymMatrix& RecMdcKalTrack::getFErrorP (   )  [inline]
  

00101 { return m_ferrors[4]; }

HepSymMatrix& RecMdcKalTrack::getFErrorP (   )  [inline]
  

00101 { return m_ferrors[4]; }

const double RecMdcKalTrack::getFFi0 (  void   )  const [inline]
  

00148 { return m_fhelixs[2][1];   }

const double RecMdcKalTrack::getFFi0 (  void   )  const [inline]
  

00148 { return m_fhelixs[2][1];   }

const HepVector& DstMdcKalTrack::getFHelix (  const int  pid  )  const [inline, inherited]
  

00207                                                  {
00208      return m_fhelixs[pid];
00209    }

const HepVector& RecMdcKalTrack::getFHelix (   )  const [inline]
  

00068 { return m_fhelixs[2]; }

const HepVector& RecMdcKalTrack::getFHelix (   )  const [inline]
  

00068 { return m_fhelixs[2]; }

HepVector& RecMdcKalTrack::getFHelixE (   )  [inline]
  

00079 { return m_fhelixs[0]; }

HepVector& RecMdcKalTrack::getFHelixE (   )  [inline]
  

00079 { return m_fhelixs[0]; }

HepVector& RecMdcKalTrack::getFHelixK (   )  [inline]
  

00093 { return m_fhelixs[3]; }

HepVector& RecMdcKalTrack::getFHelixK (   )  [inline]
  

00093 { return m_fhelixs[3]; }

HepVector& RecMdcKalTrack::getFHelixMu (   )  [inline]
  

00086 { return m_fhelixs[1]; }

HepVector& RecMdcKalTrack::getFHelixMu (   )  [inline]
  

00086 { return m_fhelixs[1]; }

HepVector& RecMdcKalTrack::getFHelixP (   )  [inline]
  

00100 { return m_fhelixs[4]; }

HepVector& RecMdcKalTrack::getFHelixP (   )  [inline]
  

00100 { return m_fhelixs[4]; }

const int DstMdcKalTrack::getFirstLayer (  const int  pid  )  const [inline, inherited]
  

00194 { return m_firstLayer[0][pid];}

int RecMdcKalTrack::getFirstLayer (  const int  i,
const int  pid
)  const [inline]
  

00058 { return m_firstLayer[i][pid]; }

int RecMdcKalTrack::getFirstLayer (  const int  i,
const int  pid
)  const [inline]
  

00058 { return m_firstLayer[i][pid]; }

const double RecMdcKalTrack::getFiTerm (  const int  pid  )  const [inline]
  

00131 { return m_fiTerm[pid]; }

const double RecMdcKalTrack::getFiTerm (  const int  pid  )  const [inline]
  

00131 { return m_fiTerm[pid]; }

const double RecMdcKalTrack::getFTanl (  void   )  const [inline]
  

00151 { return m_fhelixs[2][4];   }

const double RecMdcKalTrack::getFTanl (  void   )  const [inline]
  

00151 { return m_fhelixs[2][4];   }

const int DstMdcKalTrack::getLastLayer (  const int  pid  )  const [inline, inherited]
  

00195 { return m_lastLayer[0][pid]; }

int RecMdcKalTrack::getLastLayer (  const int  i,
const int  pid
)  const [inline]
  

00059 { return m_lastLayer[i][pid];  }

int RecMdcKalTrack::getLastLayer (  const int  i,
const int  pid
)  const [inline]
  

00059 { return m_lastLayer[i][pid];  }

const double RecMdcKalTrack::getLCpa (  void   )  const [inline]
  

00143 { return m_lhelixs[2][2];   }

const double RecMdcKalTrack::getLCpa (  void   )  const [inline]
  

00143 { return m_lhelixs[2][2];   }

const double RecMdcKalTrack::getLDr (  void   )  const [inline]
  

00141 { return m_lhelixs[2][0];   }

const double RecMdcKalTrack::getLDr (  void   )  const [inline]
  

00141 { return m_lhelixs[2][0];   }

const double RecMdcKalTrack::getLDz (  void   )  const [inline]
  

00144 { return m_lhelixs[2][3];   }

const double RecMdcKalTrack::getLDz (  void   )  const [inline]
  

00144 { return m_lhelixs[2][3];   }

double RecMdcKalTrack::getLength (  int  pid  )  const [inline]
  

00053 { return m_length[pid];        }

double RecMdcKalTrack::getLength (  int  pid  )  const [inline]
  

00053 { return m_length[pid];        }

const HepSymMatrix& RecMdcKalTrack::getLError (  const int  pid  )  const [inline]
  

00126 { return m_lerrors[pid];}

const HepSymMatrix& RecMdcKalTrack::getLError (   )  const [inline]
  

00071 { return m_lerrors[2]; }

const HepSymMatrix& RecMdcKalTrack::getLError (  const int  pid  )  const [inline]
  

00126 { return m_lerrors[pid];}

const HepSymMatrix& RecMdcKalTrack::getLError (   )  const [inline]
  

00071 { return m_lerrors[2]; }

HepSymMatrix& RecMdcKalTrack::getLErrorE (   )  [inline]
  

00082 { return m_lerrors[0]; }

HepSymMatrix& RecMdcKalTrack::getLErrorE (   )  [inline]
  

00082 { return m_lerrors[0]; }

HepSymMatrix& RecMdcKalTrack::getLErrorK (   )  [inline]
  

00096 { return m_lerrors[3]; }

HepSymMatrix& RecMdcKalTrack::getLErrorK (   )  [inline]
  

00096 { return m_lerrors[3]; }

HepSymMatrix& RecMdcKalTrack::getLErrorMu (   )  [inline]
  

00089 { return m_lerrors[1]; }

HepSymMatrix& RecMdcKalTrack::getLErrorMu (   )  [inline]
  

00089 { return m_lerrors[1]; }

HepSymMatrix& RecMdcKalTrack::getLErrorP (   )  [inline]
  

00103 { return m_lerrors[4]; }

HepSymMatrix& RecMdcKalTrack::getLErrorP (   )  [inline]
  

00103 { return m_lerrors[4]; }

const double RecMdcKalTrack::getLFi0 (  void   )  const [inline]
  

00142 { return m_lhelixs[2][1];   }

const double RecMdcKalTrack::getLFi0 (  void   )  const [inline]
  

00142 { return m_lhelixs[2][1];   }

const HepVector& RecMdcKalTrack::getLHelix (  const int  pid  )  const [inline]
  

00125 { return m_lhelixs[pid];}

const HepVector& RecMdcKalTrack::getLHelix (   )  const [inline]
  

00070 { return m_lhelixs[2]; }

const HepVector& RecMdcKalTrack::getLHelix (  const int  pid  )  const [inline]
  

00125 { return m_lhelixs[pid];}

const HepVector& RecMdcKalTrack::getLHelix (   )  const [inline]
  

00070 { return m_lhelixs[2]; }

HepVector& RecMdcKalTrack::getLHelixE (   )  [inline]
  

00081 { return m_lhelixs[0]; }

HepVector& RecMdcKalTrack::getLHelixE (   )  [inline]
  

00081 { return m_lhelixs[0]; }

HepVector& RecMdcKalTrack::getLHelixK (   )  [inline]
  

00095 { return m_lhelixs[3]; }

HepVector& RecMdcKalTrack::getLHelixK (   )  [inline]
  

00095 { return m_lhelixs[3]; }

HepVector& RecMdcKalTrack::getLHelixMu (   )  [inline]
  

00088 { return m_lhelixs[1]; }

HepVector& RecMdcKalTrack::getLHelixMu (   )  [inline]
  

00088 { return m_lhelixs[1]; }

HepVector& RecMdcKalTrack::getLHelixP (   )  [inline]
  

00102 { return m_lhelixs[4]; }

HepVector& RecMdcKalTrack::getLHelixP (   )  [inline]
  

00102 { return m_lhelixs[4]; }

const HepPoint3D& RecMdcKalTrack::getLPivot (  const int  pid  )  const [inline]
  

00132 { return m_lpivots[pid];}

const HepPoint3D& RecMdcKalTrack::getLPivot (   )  const [inline]
  

00119 { return m_lpivots[2]; }

const HepPoint3D& RecMdcKalTrack::getLPivot (  const int  pid  )  const [inline]
  

00132 { return m_lpivots[pid];}

const HepPoint3D& RecMdcKalTrack::getLPivot (   )  const [inline]
  

00119 { return m_lpivots[2]; }

const HepPoint3D& RecMdcKalTrack::getLPivotE (   )  const [inline]
  

00117 { return m_lpivots[0]; }

const HepPoint3D& RecMdcKalTrack::getLPivotE (   )  const [inline]
  

00117 { return m_lpivots[0]; }

const HepPoint3D& RecMdcKalTrack::getLPivotK (   )  const [inline]
  

00120 { return m_lpivots[3]; }

const HepPoint3D& RecMdcKalTrack::getLPivotK (   )  const [inline]
  

00120 { return m_lpivots[3]; }

const HepPoint3D& RecMdcKalTrack::getLPivotMu (   )  const [inline]
  

00118 { return m_lpivots[1]; }

const HepPoint3D& RecMdcKalTrack::getLPivotMu (   )  const [inline]
  

00118 { return m_lpivots[1]; }

const HepPoint3D& RecMdcKalTrack::getLPivotP (   )  const [inline]
  

00121 { return m_lpivots[4]; }

const HepPoint3D& RecMdcKalTrack::getLPivotP (   )  const [inline]
  

00121 { return m_lpivots[4]; }

const HepPoint3D& RecMdcKalTrack::getLPoint (  const int  pid  )  const [inline]
  

00130 { return m_lpoints[pid];}

const HepPoint3D& RecMdcKalTrack::getLPoint (   )  const [inline]
  

00113 { return m_lpoints[2]; }

const HepPoint3D& RecMdcKalTrack::getLPoint (  const int  pid  )  const [inline]
  

00130 { return m_lpoints[pid];}

const HepPoint3D& RecMdcKalTrack::getLPoint (   )  const [inline]
  

00113 { return m_lpoints[2]; }

const HepPoint3D& RecMdcKalTrack::getLPointE (   )  const [inline]
  

00111 { return m_lpoints[0]; }

const HepPoint3D& RecMdcKalTrack::getLPointE (   )  const [inline]
  

00111 { return m_lpoints[0]; }

const HepPoint3D& RecMdcKalTrack::getLPointK (   )  const [inline]
  

00114 { return m_lpoints[3]; }

const HepPoint3D& RecMdcKalTrack::getLPointK (   )  const [inline]
  

00114 { return m_lpoints[3]; }

const HepPoint3D& RecMdcKalTrack::getLPointMu (   )  const [inline]
  

00112 { return m_lpoints[1]; }

const HepPoint3D& RecMdcKalTrack::getLPointMu (   )  const [inline]
  

00112 { return m_lpoints[1]; }

const HepPoint3D& RecMdcKalTrack::getLPointP (   )  const [inline]
  

00115 { return m_lpoints[4]; }

const HepPoint3D& RecMdcKalTrack::getLPointP (   )  const [inline]
  

00115 { return m_lpoints[4]; }

const double RecMdcKalTrack::getLTanl (  void   )  const [inline]
  

00145 { return m_lhelixs[2][4];   }

const double RecMdcKalTrack::getLTanl (  void   )  const [inline]
  

00145 { return m_lhelixs[2][4];   }

double RecMdcKalTrack::getMass (  int  pid  )  const [inline]
  

00052 { return m_mass[pid];          }

double RecMdcKalTrack::getMass (  int  pid  )  const [inline]
  

00052 { return m_mass[pid];          }

const int DstMdcKalTrack::getNdf (  const int  pid  )  const [inline, inherited]
  

00193 { return m_ndf[0][pid];       }

int RecMdcKalTrack::getNdf (  int  i,
int  pid
)  const [inline]
  

00061 { return m_ndf[i][pid];        }

int RecMdcKalTrack::getNdf (  int  i,
int  pid
)  const [inline]
  

00061 { return m_ndf[i][pid];        }

int RecMdcKalTrack::getNhits (  int  pid  )  const [inline]
  

00055 { return m_nhits[pid];         }

int RecMdcKalTrack::getNhits (  int  pid  )  const [inline]
  

00055 { return m_nhits[pid];         }

const int DstMdcKalTrack::getNster (  const int  pid  )  const [inline, inherited]
  

00191 { return m_nster[0][pid];     }

int RecMdcKalTrack::getNster (  const int  i,
const int  pid
)  const [inline]
  

00057 { return m_nster[i][pid];      }

int RecMdcKalTrack::getNster (  const int  i,
const int  pid
)  const [inline]
  

00057 { return m_nster[i][pid];      }

double RecMdcKalTrack::getPathl (  int  i  )  const [inline]
  

00062 { return m_pathl[i];           }

double RecMdcKalTrack::getPathl (  int  i  )  const [inline]
  

00062 { return m_pathl[i];           }

double RecMdcKalTrack::getPathSM (  int  pid  )  const [inline]
  

00063 { return m_pathSM[pid];        }

double RecMdcKalTrack::getPathSM (  int  pid  )  const [inline]
  

00063 { return m_pathSM[pid];        }

PidType DstMdcKalTrack::getPidType (   )  [inline, static, inherited]
  

00060 {return m_pidType; }

PidType DstMdcKalTrack::getPidType (   )  [inline, static, inherited]
  

00060 {return m_pidType; }

const HepPoint3D& RecMdcKalTrack::getPoca (  const int  pid  )  const [inline]
 

Reimplemented from DstMdcKalTrack.

00129 { return   m_pocas[pid];}

const HepPoint3D RecMdcKalTrack::getPoca (   )  const [inline]
  

00107 { return m_pocas[2]; }

const HepPoint3D& RecMdcKalTrack::getPoca (  const int  pid  )  const [inline]
 

Reimplemented from DstMdcKalTrack.

00129 { return   m_pocas[pid];}

const HepPoint3D RecMdcKalTrack::getPoca (   )  const [inline]
  

00107 { return m_pocas[2]; }

const HepPoint3D RecMdcKalTrack::getPocaE (   )  const [inline]
  

00105 { return m_pocas[0]; }

const HepPoint3D RecMdcKalTrack::getPocaE (   )  const [inline]
  

00105 { return m_pocas[0]; }

const HepPoint3D RecMdcKalTrack::getPocaK (   )  const [inline]
  

00108 { return m_pocas[3]; }

const HepPoint3D RecMdcKalTrack::getPocaK (   )  const [inline]
  

00108 { return m_pocas[3]; }

const HepPoint3D RecMdcKalTrack::getPocaMu (   )  const [inline]
  

00106 { return m_pocas[1]; }

const HepPoint3D RecMdcKalTrack::getPocaMu (   )  const [inline]
  

00106 { return m_pocas[1]; }

const HepPoint3D RecMdcKalTrack::getPocaP (   )  const [inline]
  

00109 { return m_pocas[4]; }

const HepPoint3D RecMdcKalTrack::getPocaP (   )  const [inline]
  

00109 { return m_pocas[4]; }

const int DstMdcKalTrack::getStat (  const int  pid  )  const [inline, inherited]
  

00190 { return m_stat[0][pid];      }

int RecMdcKalTrack::getStat (  int  i,
int  pid
)  const [inline]
  

00056 { return m_stat[i][pid];       }

int RecMdcKalTrack::getStat (  int  i,
int  pid
)  const [inline]
  

00056 { return m_stat[i][pid];       }

const HepSymMatrix RecMdcKalTrack::getTError (   )  const [inline]
  

00075 { return m_tEa; }

const double RecMdcKalTrack::getTError (  const int  i  )  const [inline]
  

00073 { return m_terror[i]; }

const HepSymMatrix RecMdcKalTrack::getTError (   )  const [inline]
  

00075 { return m_tEa; }

const double RecMdcKalTrack::getTError (  const int  i  )  const [inline]
  

00073 { return m_terror[i]; }

const HepVector RecMdcKalTrack::getTHelix (   )  const [inline]
  

00074 { return m_ta; }

const double RecMdcKalTrack::getTHelix (  const int  i  )  const [inline]
  

00072 { return m_thelix[i]; }

const HepVector RecMdcKalTrack::getTHelix (   )  const [inline]
  

00074 { return m_ta; }

const double RecMdcKalTrack::getTHelix (  const int  i  )  const [inline]
  

00072 { return m_thelix[i]; }

double RecMdcKalTrack::getTof (  int  pid  )  const [inline]
  

00054 { return m_tof[pid];           }

double RecMdcKalTrack::getTof (  int  pid  )  const [inline]
  

00054 { return m_tof[pid];           }

int RecMdcKalTrack::getTrackId (  void   )  const [inline]
 

Reimplemented from DstMdcKalTrack.

00051 { return m_trackId;            }

int RecMdcKalTrack::getTrackId (  void   )  const [inline]
 

Reimplemented from DstMdcKalTrack.

00051 { return m_trackId;            }

HelixSegRefVec RecMdcKalTrack::getVecHelixSegs (  void   )  const
 

HelixSegRefVec RecMdcKalTrack::getVecHelixSegs (  void   )  const
  

00173                                                          {
00174   return m_vechelixsegs;
00175 }

const double RecMdcKalTrack::getZCpa (  void   )  const [inline]
  

00137 { return m_zhelixs[2][2];   }

const double RecMdcKalTrack::getZCpa (  void   )  const [inline]
  

00137 { return m_zhelixs[2][2];   }

const double RecMdcKalTrack::getZDr (  void   )  const [inline]
  

00135 { return m_zhelixs[2][0];   }

const double RecMdcKalTrack::getZDr (  void   )  const [inline]
  

00135 { return m_zhelixs[2][0];   }

const double RecMdcKalTrack::getZDz (  void   )  const [inline]
  

00138 { return m_zhelixs[2][3];   }

const double RecMdcKalTrack::getZDz (  void   )  const [inline]
  

00138 { return m_zhelixs[2][3];   }

const HepSymMatrix& DstMdcKalTrack::getZError (  const int  pid  )  const [inline, inherited]
  

00204                                                     {
00205      return m_zerrors[pid];
00206    }

const HepSymMatrix& RecMdcKalTrack::getZError (   )  const [inline]
  

00067 { return m_zerrors[2]; }

const HepSymMatrix& RecMdcKalTrack::getZError (   )  const [inline]
  

00067 { return m_zerrors[2]; }

HepSymMatrix& RecMdcKalTrack::getZErrorE (   )  [inline]
  

00078 { return m_zerrors[0]; }

HepSymMatrix& RecMdcKalTrack::getZErrorE (   )  [inline]
  

00078 { return m_zerrors[0]; }

HepSymMatrix& RecMdcKalTrack::getZErrorK (   )  [inline]
  

00092 { return m_zerrors[3]; }

HepSymMatrix& RecMdcKalTrack::getZErrorK (   )  [inline]
  

00092 { return m_zerrors[3]; }

HepSymMatrix& RecMdcKalTrack::getZErrorMu (   )  [inline]
  

00085 { return m_zerrors[1]; }

HepSymMatrix& RecMdcKalTrack::getZErrorMu (   )  [inline]
  

00085 { return m_zerrors[1]; }

HepSymMatrix& RecMdcKalTrack::getZErrorP (   )  [inline]
  

00099 { return m_zerrors[4]; }

HepSymMatrix& RecMdcKalTrack::getZErrorP (   )  [inline]
  

00099 { return m_zerrors[4]; }

const double RecMdcKalTrack::getZFi0 (  void   )  const [inline]
  

00136 { return m_zhelixs[2][1];   }

const double RecMdcKalTrack::getZFi0 (  void   )  const [inline]
  

00136 { return m_zhelixs[2][1];   }

const HepVector& DstMdcKalTrack::getZHelix (  const int  pid  )  const [inline, inherited]
  

00201                                                  {
00202      return m_zhelixs[pid];
00203    }

const HepVector& RecMdcKalTrack::getZHelix (   )  const [inline]
  

00066 { return m_zhelixs[2]; }

const HepVector& RecMdcKalTrack::getZHelix (   )  const [inline]
  

00066 { return m_zhelixs[2]; }

HepVector& RecMdcKalTrack::getZHelixE (   )  [inline]
  

00077 { return m_zhelixs[0]; }

HepVector& RecMdcKalTrack::getZHelixE (   )  [inline]
  

00077 { return m_zhelixs[0]; }

HepVector& RecMdcKalTrack::getZHelixK (   )  [inline]
  

00091 { return m_zhelixs[3]; }

HepVector& RecMdcKalTrack::getZHelixK (   )  [inline]
  

00091 { return m_zhelixs[3]; }

HepVector& RecMdcKalTrack::getZHelixMu (   )  [inline]
  

00084 { return m_zhelixs[1]; }

HepVector& RecMdcKalTrack::getZHelixMu (   )  [inline]
  

00084 { return m_zhelixs[1]; }

HepVector& RecMdcKalTrack::getZHelixP (   )  [inline]
  

00098 { return m_zhelixs[4]; }

HepVector& RecMdcKalTrack::getZHelixP (   )  [inline]
  

00098 { return m_zhelixs[4]; }

const double RecMdcKalTrack::getZTanl (  void   )  const [inline]
  

00139 { return m_zhelixs[2][4];   }

const double RecMdcKalTrack::getZTanl (  void   )  const [inline]
  

00139 { return m_zhelixs[2][4];   }

const HepVector& DstMdcKalTrack::helix (   )  const [inline, inherited]
  

00096 { return m_zhelixs[m_pidType];     }

const HepVector& DstMdcKalTrack::helix (   )  const [inline, inherited]
  

00096 { return m_zhelixs[m_pidType];     }

const double DstMdcKalTrack::kappa (  void   )  const [inline, inherited]
  

00092 { return m_zhelixs[m_pidType][2];   }

const double DstMdcKalTrack::kappa (  void   )  const [inline, inherited]
  

00092 { return m_zhelixs[m_pidType][2];   }

const int DstMdcKalTrack::lastLayer (   )  const [inline, inherited]
  

00088 {return m_lastLayer[0][m_pidType];}

const int DstMdcKalTrack::lastLayer (   )  const [inline, inherited]
  

00088 {return m_lastLayer[0][m_pidType];}

const double DstMdcKalTrack::mass (   )  const [inline, inherited]
  

00064 { return m_mass[m_pidType];  }

const double DstMdcKalTrack::mass (   )  const [inline, inherited]
  

00064 { return m_mass[m_pidType];  }

const int DstMdcKalTrack::ndof (   )  const [inline, inherited]
  

00085 {return m_ndf[0][m_pidType];}

const int DstMdcKalTrack::ndof (   )  const [inline, inherited]
  

00085 {return m_ndf[0][m_pidType];}

const int DstMdcKalTrack::nster (   )  const [inline, inherited]
  

00086 {return m_nster[0][m_pidType];}

const int DstMdcKalTrack::nster (   )  const [inline, inherited]
  

00086 {return m_nster[0][m_pidType];}

RecMdcKalTrack& RecMdcKalTrack::operator= (  const DstMdcKalTrack &   ) 
 

Reimplemented from DstMdcKalTrack.

RecMdcKalTrack& RecMdcKalTrack::operator= (  const RecMdcKalTrack &   ) 
 

RecMdcKalTrack & RecMdcKalTrack::operator= (  const DstMdcKalTrack &   ) 
 

Reimplemented from DstMdcKalTrack.

00121 {
00122   if( &dstrk != this ){
00123     DstMdcKalTrack::operator=(dstrk);
00124     HepVector a(5,0);
00125     HepSymMatrix Ea(5,0);
00126     HepPoint3D poca(-99.,-99.,-99.);
00127     HepPoint3D point(0.,0.,0.); 
00128     HepPoint3D pivot(0.,0.,0.);
00129     
00130     //m_trackId = -1;
00131     //m_pocas.clear();
00132     //m_zhelixs.clear();
00133     //m_zerrors.clear();
00134     m_lhelixs.clear();
00135     m_lerrors.clear();
00136  //   m_fhelixs.clear();
00137  //   m_ferrors.clear();
00138     m_lpoints.clear();
00139     m_lpivots.clear();
00140     m_ta(5,0) ;  
00141     m_tEa(5,0);
00142     for(int pid=0; pid<5; pid++){
00143       //m_pocas.push_back(poca);
00144       //m_zhelixs.push_back(a);
00145       //m_zerrors.push_back(Ea);
00146       m_lhelixs.push_back(a);
00147       m_lerrors.push_back(Ea);
00148  //     m_fhelixs.push_back(a);
00149  //     m_ferrors.push_back(Ea);
00150       m_lpoints.push_back(point);
00151   
00152       
00153       m_length[pid] = 0.0;
00154       m_tof[pid] = 0.0;
00155       m_nhits[pid] = 0;
00156       m_pathSM[pid] = 0.;
00157       m_fiTerm[pid] = 0.;
00158     }
00159     
00160     for(int i=0; i<43; i++) {
00161       m_pathl[i] = 0.0;
00162     }
00163     for(int j=0; j<5; j++) {
00164           m_thelix[j] = 0.0;
00165     }
00166     for(int k=0; k<15; k++){
00167             m_terror[k]= 0.;
00168     }
00169   }
00170   return  *this;
00171 }

RecMdcKalTrack& RecMdcKalTrack::operator= (  const RecMdcKalTrack &   ) 
 

const double DstMdcKalTrack::p (   )  const [inline, inherited]
  

00082 {return m_p[m_pidType];}

const double DstMdcKalTrack::p (   )  const [inline, inherited]
  

00082 {return m_p[m_pidType];}

const Hep3Vector DstMdcKalTrack::p3 (   )  const [inherited]
 

const Hep3Vector DstMdcKalTrack::p3 (   )  const [inherited]
  

00156                                           {
00157         const Hep3Vector p3( px(), py(), pz() ); 
00158         return p3; 
00159 }

const HepLorentzVector DstMdcKalTrack::p4 (  double  mass  )  const [inherited]
 

const HepLorentzVector DstMdcKalTrack::p4 (   )  const [inherited]
 

const HepLorentzVector DstMdcKalTrack::p4 (  double  mass  )  const [inherited]
  

00151                                                             {
00152   const HepLorentzVector p_LV( px(), py(), pz(), sqrt(pow(v_mass,2)+pow(p(),2)) ); 
00153   return p_LV; 
00154 }

const HepLorentzVector DstMdcKalTrack::p4 (   )  const [inherited]
  

00145                                                {
00146   const HepLorentzVector p_LV( px(), py(), pz(), sqrt(pow(mass(),2)+pow(p(),2)) ); 
00147   return p_LV; 
00148 }

const double DstMdcKalTrack::phi (   )  const [inline, inherited]
  

00071 { return m_phi[m_pidType];   }

const double DstMdcKalTrack::phi (   )  const [inline, inherited]
  

00071 { return m_phi[m_pidType];   }

const HepPoint3D DstMdcKalTrack::poca (   )  const [inline, inherited]
  

00100 { return m_pocas[m_pidType];       }

const HepPoint3D DstMdcKalTrack::poca (   )  const [inline, inherited]
  

00100 { return m_pocas[m_pidType];       }

const double DstMdcKalTrack::px (   )  const [inline, inherited]
  

00067 { return m_px[m_pidType];    }

const double DstMdcKalTrack::px (   )  const [inline, inherited]
  

00067 { return m_px[m_pidType];    }

const double DstMdcKalTrack::pxy (   )  const [inline, inherited]
  

00066 { return m_pxy[m_pidType];   }

const double DstMdcKalTrack::pxy (   )  const [inline, inherited]
  

00066 { return m_pxy[m_pidType];   }

const double DstMdcKalTrack::py (   )  const [inline, inherited]
  

00068 { return m_py[m_pidType];    }

const double DstMdcKalTrack::py (   )  const [inline, inherited]
  

00068 { return m_py[m_pidType];    }

const double DstMdcKalTrack::pz (   )  const [inline, inherited]
  

00069 { return m_pz[m_pidType];    }

const double DstMdcKalTrack::pz (   )  const [inline, inherited]
  

00069 { return m_pz[m_pidType];    }

const double DstMdcKalTrack::r (   )  const [inline, inherited]
  

00081 {return m_r[m_pidType];}

const double DstMdcKalTrack::r (   )  const [inline, inherited]
  

00081 {return m_r[m_pidType];}

void DstMdcKalTrack::setCharge (  const int  charge,
const int  pid
)  [inline, inherited]
  

00109 { m_charge[pid] = charge;}

void DstMdcKalTrack::setCharge (  const int  charge,
const int  pid
)  [inline, inherited]
  

00109 { m_charge[pid] = charge;}

void DstMdcKalTrack::setChisq (  double  chisq,
int  i,
int  pid
)  [inline, inherited]
  

00123 { m_chisq[i][pid] = chisq;  }

void DstMdcKalTrack::setChisq (  double  chisq,
int  i,
int  pid
)  [inline, inherited]
  

00123 { m_chisq[i][pid] = chisq;  }

void DstMdcKalTrack::setFError (  double *  ferror,
const int  pid
)  [inline, inherited]
  

00177                                                  {
00178       int k=0;
00179       HepSymMatrix mat(5);
00180       for(int i=0; i<5 ; i++) {
00181          for(int j=0; j<=i; j++,k++) {
00182          mat[i][j] = ferror[k];
00183          mat[j][i] = ferror[k];     
00184         }      
00185       }
00186       m_ferrors[pid] = mat;
00187    }

void DstMdcKalTrack::setFError (  const HepSymMatrix &  ferror,
const int  pid
)  [inline, inherited]
  

00168                                                              { 
00169       m_ferrors[pid] = ferror;
00170    }

void DstMdcKalTrack::setFError (  double *  ferror,
const int  pid
)  [inline, inherited]
  

00177                                                  {
00178       int k=0;
00179       HepSymMatrix mat(5);
00180       for(int i=0; i<5 ; i++) {
00181          for(int j=0; j<=i; j++,k++) {
00182          mat[i][j] = ferror[k];
00183          mat[j][i] = ferror[k];     
00184         }      
00185       }
00186       m_ferrors[pid] = mat;
00187    }

void DstMdcKalTrack::setFError (  const HepSymMatrix &  ferror,
const int  pid
)  [inline, inherited]
  

00168                                                              { 
00169       m_ferrors[pid] = ferror;
00170    }

void DstMdcKalTrack::setFHelix (  double *  fhelix,
const int  pid
)  [inline, inherited]
  

00171                                                   {
00172       for(int i=0; i<5; i++) {
00173         m_fhelixs[pid][i] = fhelix[i]; 
00174       }
00175    }

void DstMdcKalTrack::setFHelix (  const HepVector &  fhelix,
const int  pid
)  [inline, inherited]
  

00164                                                            {
00165      m_fhelixs[pid] = fhelix;
00166    }

void DstMdcKalTrack::setFHelix (  double *  fhelix,
const int  pid
)  [inline, inherited]
  

00171                                                   {
00172       for(int i=0; i<5; i++) {
00173         m_fhelixs[pid][i] = fhelix[i]; 
00174       }
00175    }

void DstMdcKalTrack::setFHelix (  const HepVector &  fhelix,
const int  pid
)  [inline, inherited]
  

00164                                                            {
00165      m_fhelixs[pid] = fhelix;
00166    }

void DstMdcKalTrack::setFirstLayer (  int  fL,
int  i,
int  pid
)  [inline, inherited]
  

00124 { m_firstLayer[i][pid] = fL; }

void DstMdcKalTrack::setFirstLayer (  int  fL,
int  i,
int  pid
)  [inline, inherited]
  

00124 { m_firstLayer[i][pid] = fL; }

void RecMdcKalTrack::setFiTerm (  double  fi,
const int  pid
)  [inline]
  

00289                                            {
00290      m_fiTerm[pid] = fi;
00291    }

void RecMdcKalTrack::setFiTerm (  double  fi,
const int  pid
)  [inline]
  

00289                                            {
00290      m_fiTerm[pid] = fi;
00291    }

void DstMdcKalTrack::setLastLayer (  int  lL,
int  i,
int  pid
)  [inline, inherited]
  

00125 { m_lastLayer[i][pid] = lL;  }

void DstMdcKalTrack::setLastLayer (  int  lL,
int  i,
int  pid
)  [inline, inherited]
  

00125 { m_lastLayer[i][pid] = lL;  }

void RecMdcKalTrack::setLength (  double  length,
int  pid
)  [inline]
  

00160 { m_length[pid] = length;   }

void RecMdcKalTrack::setLength (  double  length,
int  pid
)  [inline]
  

00160 { m_length[pid] = length;   }

void RecMdcKalTrack::setLError (  double *  error,
const int  pid
)  [inline]
  

00232                                                 {
00233      int k=0;
00234      HepSymMatrix mat(5);
00235      for(int i=0; i<5 ; i++) {
00236        for(int j=0; j<=i; j++,k++) {
00237          mat[i][j] = error[k];
00238          mat[j][i] = error[k];
00239        }
00240      }
00241      m_lerrors[pid] = mat;
00242    }

void RecMdcKalTrack::setLError (  const HepSymMatrix &  error,
const int  pid
)  [inline]
  

00224                                                             {
00225      m_lerrors[pid] = error;
00226    }

void RecMdcKalTrack::setLError (  double *  error,
const int  pid
)  [inline]
  

00232                                                 {
00233      int k=0;
00234      HepSymMatrix mat(5);
00235      for(int i=0; i<5 ; i++) {
00236        for(int j=0; j<=i; j++,k++) {
00237          mat[i][j] = error[k];
00238          mat[j][i] = error[k];
00239        }
00240      }
00241      m_lerrors[pid] = mat;
00242    }

void RecMdcKalTrack::setLError (  const HepSymMatrix &  error,
const int  pid
)  [inline]
  

00224                                                             {
00225      m_lerrors[pid] = error;
00226    }

void RecMdcKalTrack::setLHelix (  double *  helix,
const int  pid
)  [inline]
  

00227                                                  {
00228      for(int i=0; i<5; i++) {
00229        m_lhelixs[pid][i] = helix[i];
00230      }
00231    }

void RecMdcKalTrack::setLHelix (  const HepVector &  helix,
const int  pid
)  [inline]
  

00221                                                           {
00222      m_lhelixs[pid] = helix;
00223    }

void RecMdcKalTrack::setLHelix (  double *  helix,
const int  pid
)  [inline]
  

00227                                                  {
00228      for(int i=0; i<5; i++) {
00229        m_lhelixs[pid][i] = helix[i];
00230      }
00231    }

void RecMdcKalTrack::setLHelix (  const HepVector &  helix,
const int  pid
)  [inline]
  

00221                                                           {
00222      m_lhelixs[pid] = helix;
00223    }

void RecMdcKalTrack::setLPivot (  const HepPoint3D &  pivot,
const int  pid
)  [inline]
  

00294                                                            {
00295      m_lpivots[pid] = pivot;
00296    }

void RecMdcKalTrack::setLPivot (  const HepPoint3D &  pivot,
const int  pid
)  [inline]
  

00294                                                            {
00295      m_lpivots[pid] = pivot;
00296    }

void RecMdcKalTrack::setLPoint (  const HepPoint3D &  point,
const int  pid
)  [inline]
  

00284                                                            {
00285      m_lpoints[pid] = point;
00286    }

void RecMdcKalTrack::setLPoint (  const HepPoint3D &  point,
const int  pid
)  [inline]
  

00284                                                            {
00285      m_lpoints[pid] = point;
00286    }

void RecMdcKalTrack::setMass (  double  mass,
int  pid
)  [inline]
 

Reimplemented from DstMdcKalTrack.

00159 { m_mass[pid] = mass;       }

void RecMdcKalTrack::setMass (  double  mass,
int  pid
)  [inline]
 

Reimplemented from DstMdcKalTrack.

00159 { m_mass[pid] = mass;       }

void DstMdcKalTrack::setNdf (  int  ndf,
int  i,
int  pid
)  [inline, inherited]
  

00127 { m_ndf[i][pid] = ndf;    }

void DstMdcKalTrack::setNdf (  int  ndf,
int  i,
int  pid
)  [inline, inherited]
  

00127 { m_ndf[i][pid] = ndf;    }

void RecMdcKalTrack::setNhits (  int  nhits,
int  pid
)  [inline]
 

Reimplemented from DstMdcKalTrack.

00162 { m_nhits[pid] = nhits;     }

void RecMdcKalTrack::setNhits (  int  nhits,
int  pid
)  [inline]
 

Reimplemented from DstMdcKalTrack.

00162 { m_nhits[pid] = nhits;     }

void DstMdcKalTrack::setNster (  int  ns,
int  i,
int  pid
)  [inline, inherited]
  

00121 { m_nster[i][pid] = ns;     }

void DstMdcKalTrack::setNster (  int  ns,
int  i,
int  pid
)  [inline, inherited]
  

00121 { m_nster[i][pid] = ns;     }

void DstMdcKalTrack::setP (  const double  p,
const int  pid
)  [inline, inherited]
  

00114 { m_p[pid] = p;          }

void DstMdcKalTrack::setP (  const double  p,
const int  pid
)  [inline, inherited]
  

00114 { m_p[pid] = p;          }

void RecMdcKalTrack::setPathl (  double  pathl,
int  i
)  [inline]
  

00169 { m_pathl[i] = pathl;       }

void RecMdcKalTrack::setPathl (  double  pathl,
int  i
)  [inline]
  

00169 { m_pathl[i] = pathl;       }

void RecMdcKalTrack::setPathSM (  double  length,
int  pid
)  [inline]
  

00170 { m_pathSM[pid] = length;   }

void RecMdcKalTrack::setPathSM (  double  length,
int  pid
)  [inline]
  

00170 { m_pathSM[pid] = length;   }

void DstMdcKalTrack::setPhi (  const double  phi,
const int  pid
)  [inline, inherited]
  

00116 { m_phi[pid] = phi;      }

void DstMdcKalTrack::setPhi (  const double  phi,
const int  pid
)  [inline, inherited]
  

00116 { m_phi[pid] = phi;      }

void DstMdcKalTrack::setPidType (  PidType  pidType  )  [inline, static, inherited]
  

00059 {m_pidType = pidType; }

void DstMdcKalTrack::setPidType (  PidType  pidType  )  [inline, static, inherited]
  

00059 {m_pidType = pidType; }

void DstMdcKalTrack::setPoca (  double *  poca,
const int  pid
)  [inline, inherited]
  

00133                                              {
00134      for(int i=0; i<3; i++){
00135        m_pocas[pid][i] = poca[i];
00136      }                                                              
00137    }

void DstMdcKalTrack::setPoca (  const HepPoint3D &  poca,
const int  pid
)  [inline, inherited]
  

00129                                                       {
00130      m_pocas[pid] = poca;
00131    }

void DstMdcKalTrack::setPoca (  double *  poca,
const int  pid
)  [inline, inherited]
  

00133                                              {
00134      for(int i=0; i<3; i++){
00135        m_pocas[pid][i] = poca[i];
00136      }                                                              
00137    }

void DstMdcKalTrack::setPoca (  const HepPoint3D &  poca,
const int  pid
)  [inline, inherited]
  

00129                                                       {
00130      m_pocas[pid] = poca;
00131    }

void DstMdcKalTrack::setPx (  const double  px,
const int  pid
)  [inline, inherited]
  

00111 { m_px[pid] = px;        }

void DstMdcKalTrack::setPx (  const double  px,
const int  pid
)  [inline, inherited]
  

00111 { m_px[pid] = px;        }

void DstMdcKalTrack::setPxy (  const double  pxy,
const int  pid
)  [inline, inherited]
  

00110 { m_pxy[pid] = pxy;      }

void DstMdcKalTrack::setPxy (  const double  pxy,
const int  pid
)  [inline, inherited]
  

00110 { m_pxy[pid] = pxy;      }

void DstMdcKalTrack::setPy (  const double  py,
const int  pid
)  [inline, inherited]
  

00112 { m_py[pid] = py;        }

void DstMdcKalTrack::setPy (  const double  py,
const int  pid
)  [inline, inherited]
  

00112 { m_py[pid] = py;        }

void DstMdcKalTrack::setPz (  const double  pz,
const int  pid
)  [inline, inherited]
  

00113 { m_pz[pid] = pz;        }

void DstMdcKalTrack::setPz (  const double  pz,
const int  pid
)  [inline, inherited]
  

00113 { m_pz[pid] = pz;        }

void DstMdcKalTrack::setR (  const double  r,
const int  pid
)  [inline, inherited]
  

00120 { m_r[pid] = r;          }

void DstMdcKalTrack::setR (  const double  r,
const int  pid
)  [inline, inherited]
  

00120 { m_r[pid] = r;          }

void DstMdcKalTrack::setStat (  int  stat,
int  i,
int  pid
)  [inline, inherited]
  

00122 { m_stat[i][pid] = stat;    }

void DstMdcKalTrack::setStat (  int  stat,
int  i,
int  pid
)  [inline, inherited]
  

00122 { m_stat[i][pid] = stat;    }

void RecMdcKalTrack::setTError (  double  error[15]  )  [inline]
  

00268                                      {
00269            int k=0;
00270      HepSymMatrix mat(5);
00271      for(int i=0; i<5 ; i++) {
00272        for(int j=0; j<=i; j++,k++) {
00273          mat[i][j] = error[k];
00274          mat[j][i] = mat[i][j];
00275        }
00276      }
00277      m_tEa = mat;
00278      
00279      for(int i=0; i<15 ; i++) {
00280          m_terror[i] = error[i];
00281      }
00282    }

void RecMdcKalTrack::setTError (  const HepSymMatrix &  error  )  [inline]
  

00250                                              {
00251            int k=0;
00252            for(int i=0; i<5; i++){
00253                    for(int j=i; j<5; j++){
00254                            m_terror[k] = error[i][j];
00255                            k++;
00256                    }
00257            }
00258       m_tEa = error;
00259    }

void RecMdcKalTrack::setTError (  double  error[15]  )  [inline]
  

00268                                      {
00269            int k=0;
00270      HepSymMatrix mat(5);
00271      for(int i=0; i<5 ; i++) {
00272        for(int j=0; j<=i; j++,k++) {
00273          mat[i][j] = error[k];
00274          mat[j][i] = mat[i][j];
00275        }
00276      }
00277      m_tEa = mat;
00278      
00279      for(int i=0; i<15 ; i++) {
00280          m_terror[i] = error[i];
00281      }
00282    }

void RecMdcKalTrack::setTError (  const HepSymMatrix &  error  )  [inline]
  

00250                                              {
00251            int k=0;
00252            for(int i=0; i<5; i++){
00253                    for(int j=i; j<5; j++){
00254                            m_terror[k] = error[i][j];
00255                            k++;
00256                    }
00257            }
00258       m_tEa = error;
00259    }

void RecMdcKalTrack::setTHelix (  double  helix[5]  )  [inline]
  

00260                                     {
00261            HepVector atemp(5);
00262      for(int i=0; i<5; i++) {
00263        m_thelix[i] = helix[i];
00264        atemp[i] = helix[i];
00265      }
00266      m_ta = atemp;
00267    }

void RecMdcKalTrack::setTHelix (  const HepVector &  helix  )  [inline]
  

00244                                            {
00245            for(int i=0; i<5; i++){
00246                    m_thelix[i] = helix[i];
00247            }
00248       m_ta = helix;
00249    }

void RecMdcKalTrack::setTHelix (  double  helix[5]  )  [inline]
  

00260                                     {
00261            HepVector atemp(5);
00262      for(int i=0; i<5; i++) {
00263        m_thelix[i] = helix[i];
00264        atemp[i] = helix[i];
00265      }
00266      m_ta = atemp;
00267    }

void RecMdcKalTrack::setTHelix (  const HepVector &  helix  )  [inline]
  

00244                                            {
00245            for(int i=0; i<5; i++){
00246                    m_thelix[i] = helix[i];
00247            }
00248       m_ta = helix;
00249    }

void DstMdcKalTrack::setTheta (  const double  theta,
const int  pid
)  [inline, inherited]
  

00115 { m_theta[pid] = theta;  }

void DstMdcKalTrack::setTheta (  const double  theta,
const int  pid
)  [inline, inherited]
  

00115 { m_theta[pid] = theta;  }

void RecMdcKalTrack::setTof (  double  tof,
int  pid
)  [inline]
  

00161 { m_tof[pid] = tof;         }

void RecMdcKalTrack::setTof (  double  tof,
int  pid
)  [inline]
  

00161 { m_tof[pid] = tof;         }

void DstMdcKalTrack::setTrackId (  int  trackId  )  [inline, inherited]
  

00107 { m_trackId = trackId;   }

void DstMdcKalTrack::setTrackId (  int  trackId  )  [inline, inherited]
  

00107 { m_trackId = trackId;   }

void RecMdcKalTrack::setVecHelixSegs (  const HelixSegRefVec &  vechelixsegs  ) 
 

void RecMdcKalTrack::setVecHelixSegs (  const HelixSegRefVec &  vechelixsegs  ) 
  

00177                                                                       {
00178   m_vechelixsegs = vechelixsegs;
00179 }

void DstMdcKalTrack::setX (  const double  x,
const int  pid
)  [inline, inherited]
  

00117 { m_x[pid] = x;          }

void DstMdcKalTrack::setX (  const double  x,
const int  pid
)  [inline, inherited]
  

00117 { m_x[pid] = x;          }

void DstMdcKalTrack::setY (  const double  y,
const int  pid
)  [inline, inherited]
  

00118 { m_y[pid] = y;          }

void DstMdcKalTrack::setY (  const double  y,
const int  pid
)  [inline, inherited]
  

00118 { m_y[pid] = y;          }

void DstMdcKalTrack::setZ (  const double  z,
const int  pid
)  [inline, inherited]
  

00119 { m_z[pid] = z;          }

void DstMdcKalTrack::setZ (  const double  z,
const int  pid
)  [inline, inherited]
  

00119 { m_z[pid] = z;          }

void DstMdcKalTrack::setZError (  double *  error,
const int  pid
)  [inline, inherited]
  

00152                                                 {
00153       int k=0;
00154       HepSymMatrix mat(5);
00155       for(int i=0; i<5 ; i++) {
00156          for(int j=0; j<=i; j++,k++) {
00157          mat[i][j] = error[k];
00158          mat[j][i] = error[k];      
00159         }      
00160       }
00161       m_zerrors[pid] = mat;
00162    }

void DstMdcKalTrack::setZError (  const HepSymMatrix &  error,
const int  pid
)  [inline, inherited]
  

00143                                                             { 
00144       m_zerrors[pid] = error;
00145    }

void DstMdcKalTrack::setZError (  double *  error,
const int  pid
)  [inline, inherited]
  

00152                                                 {
00153       int k=0;
00154       HepSymMatrix mat(5);
00155       for(int i=0; i<5 ; i++) {
00156          for(int j=0; j<=i; j++,k++) {
00157          mat[i][j] = error[k];
00158          mat[j][i] = error[k];      
00159         }      
00160       }
00161       m_zerrors[pid] = mat;
00162    }

void DstMdcKalTrack::setZError (  const HepSymMatrix &  error,
const int  pid
)  [inline, inherited]
  

00143                                                             { 
00144       m_zerrors[pid] = error;
00145    }

void DstMdcKalTrack::setZHelix (  double *  helix,
const int  pid
)  [inline, inherited]
  

00146                                                  {
00147       for(int i=0; i<5; i++) {
00148         m_zhelixs[pid][i] = helix[i]; 
00149       }
00150    }

void DstMdcKalTrack::setZHelix (  const HepVector &  helix,
const int  pid
)  [inline, inherited]
  

00139                                                           {
00140      m_zhelixs[pid] = helix;
00141    }

void DstMdcKalTrack::setZHelix (  double *  helix,
const int  pid
)  [inline, inherited]
  

00146                                                  {
00147       for(int i=0; i<5; i++) {
00148         m_zhelixs[pid][i] = helix[i]; 
00149       }
00150    }

void DstMdcKalTrack::setZHelix (  const HepVector &  helix,
const int  pid
)  [inline, inherited]
  

00139                                                           {
00140      m_zhelixs[pid] = helix;
00141    }

const int DstMdcKalTrack::stat (   )  const [inline, inherited]
  

00083 {return m_stat[0][m_pidType];}

const int DstMdcKalTrack::stat (   )  const [inline, inherited]
  

00083 {return m_stat[0][m_pidType];}

const double DstMdcKalTrack::tanl (  void   )  const [inline, inherited]
  

00094 { return m_zhelixs[m_pidType][4];   }

const double DstMdcKalTrack::tanl (  void   )  const [inline, inherited]
  

00094 { return m_zhelixs[m_pidType][4];   }

const double DstMdcKalTrack::theta (   )  const [inline, inherited]
  

00070 { return m_theta[m_pidType]; }

const double DstMdcKalTrack::theta (   )  const [inline, inherited]
  

00070 { return m_theta[m_pidType]; }

const int DstMdcKalTrack::trackId (   )  const [inline, inherited]
  

00063 { return m_trackId;          }

const int DstMdcKalTrack::trackId (   )  const [inline, inherited]
  

00063 { return m_trackId;          }

const double DstMdcKalTrack::x (  const int  i  )  const [inline, inherited]
  

00077 {return m_x[i];}

const double DstMdcKalTrack::x (   )  const [inline, inherited]
  

00073 { return m_x[m_pidType];     }

const double DstMdcKalTrack::x (  const int  i  )  const [inline, inherited]
  

00077 {return m_x[i];}

const double DstMdcKalTrack::x (   )  const [inline, inherited]
  

00073 { return m_x[m_pidType];     }

const HepPoint3D DstMdcKalTrack::x3 (   )  const [inherited]
 

const HepPoint3D DstMdcKalTrack::x3 (   )  const [inherited]
  

00161                                           {
00162         return HepPoint3D(m_x[m_pidType],m_y[m_pidType],m_z[m_pidType]);
00163 }

const double DstMdcKalTrack::y (  const int  i  )  const [inline, inherited]
  

00078 {return m_y[i];}

const double DstMdcKalTrack::y (   )  const [inline, inherited]
  

00074 { return m_y[m_pidType];     }

const double DstMdcKalTrack::y (  const int  i  )  const [inline, inherited]
  

00078 {return m_y[i];}

const double DstMdcKalTrack::y (   )  const [inline, inherited]
  

00074 { return m_y[m_pidType];     }

const double DstMdcKalTrack::z (  const int  i  )  const [inline, inherited]
  

00079 {return m_z[i];}

const double DstMdcKalTrack::z (   )  const [inline, inherited]
  

00075 { return m_z[m_pidType];     }

const double DstMdcKalTrack::z (  const int  i  )  const [inline, inherited]
  

00079 {return m_z[i];}

const double DstMdcKalTrack::z (   )  const [inline, inherited]
  

00075 { return m_z[m_pidType];     }

Member Data Documentation

int DstMdcKalTrack::m_charge [protected, inherited]
 

double DstMdcKalTrack::m_chisq [protected, inherited]
 

std::vector<HepSymMatrix> DstMdcKalTrack::m_ferrors [protected, inherited]
 

std::vector<HepSymMatrix> DstMdcKalTrack::m_ferrors [protected, inherited]
 

std::vector<HepVector> DstMdcKalTrack::m_fhelixs [protected, inherited]
 

std::vector<HepVector> DstMdcKalTrack::m_fhelixs [protected, inherited]
 

int DstMdcKalTrack::m_firstLayer [protected, inherited]
 

double RecMdcKalTrack::m_fiTerm [private]
 

int DstMdcKalTrack::m_lastLayer [protected, inherited]
 

double RecMdcKalTrack::m_length [private]
 

std::vector<HepSymMatrix> RecMdcKalTrack::m_lerrors [private]
 

std::vector<HepSymMatrix> RecMdcKalTrack::m_lerrors [private]
 

std::vector<HepVector> RecMdcKalTrack::m_lhelixs [private]
 

std::vector<HepVector> RecMdcKalTrack::m_lhelixs [private]
 

std::vector<HepPoint3D> RecMdcKalTrack::m_lpivots [private]
 

std::vector<HepPoint3D> RecMdcKalTrack::m_lpivots [private]
 

std::vector<HepPoint3D> RecMdcKalTrack::m_lpoints [private]
 

std::vector<HepPoint3D> RecMdcKalTrack::m_lpoints [private]
 

double RecMdcKalTrack::m_mass [private]
 

Reimplemented from DstMdcKalTrack.

int DstMdcKalTrack::m_ndf [protected, inherited]
 

int RecMdcKalTrack::m_nhits [private]
 

Reimplemented from DstMdcKalTrack.

int DstMdcKalTrack::m_nster [protected, inherited]
 

double DstMdcKalTrack::m_p [protected, inherited]
 

double RecMdcKalTrack::m_pathl [private]
 

double RecMdcKalTrack::m_pathSM [private]
 

double DstMdcKalTrack::m_phi [protected, inherited]
 

PidType DstMdcKalTrack::m_pidType [static, protected, inherited]
 

std::vector<HepPoint3D> DstMdcKalTrack::m_pocas [protected, inherited]
 

std::vector<HepPoint3D> DstMdcKalTrack::m_pocas [protected, inherited]
 

double DstMdcKalTrack::m_px [protected, inherited]
 

double DstMdcKalTrack::m_pxy [protected, inherited]
 

double DstMdcKalTrack::m_py [protected, inherited]
 

double DstMdcKalTrack::m_pz [protected, inherited]
 

double DstMdcKalTrack::m_r [protected, inherited]
 

int DstMdcKalTrack::m_stat [protected, inherited]
 

HepVector RecMdcKalTrack::m_ta [private]
 

HepSymMatrix RecMdcKalTrack::m_tEa [private]
 

double RecMdcKalTrack::m_terror [private]
 

double RecMdcKalTrack::m_thelix [private]
 

double DstMdcKalTrack::m_theta [protected, inherited]
 

double RecMdcKalTrack::m_tof [private]
 

int DstMdcKalTrack::m_trackId [protected, inherited]
 

HelixSegRefVec RecMdcKalTrack::m_vechelixsegs [private]
 

double DstMdcKalTrack::m_x [protected, inherited]
 

double DstMdcKalTrack::m_y [protected, inherited]
 

double DstMdcKalTrack::m_z [protected, inherited]
 

std::vector<HepSymMatrix> DstMdcKalTrack::m_zerrors [protected, inherited]
 

std::vector<HepSymMatrix> DstMdcKalTrack::m_zerrors [protected, inherited]
 

std::vector<HepVector> DstMdcKalTrack::m_zhelixs [protected, inherited]
 

std::vector<HepVector> DstMdcKalTrack::m_zhelixs [protected, inherited]
 

The documentation for this class was generated from the following files:
Generated on Wed Feb 2 16:46:49 2011 for BOSS6.5.5 by  doxygen 1.3.9.1