TRecExtTrack.h

Go to the documentation of this file.

#ifndef RootEventData_TRecExtTrack_H
#define RootEventData_TRecExtTrack_H 1
 
#include "TObject.h"
#include "TString.h"
using namespace std;
 
class TRecExtTrack : public TObject {
    
public:
    
    TRecExtTrack();
    
    ~TRecExtTrack ();
    
    //modifiers
   void  SetTrackId(const Int_t trackId){ m_trackId = trackId; }
    //Tof layer1:
   void  SetTof1PositionX(const Double_t  Tof1PositionX, const Int_t i=2)  { myTof1PositionX[i]  =  Tof1PositionX; }
   void  SetTof1PositionY(const Double_t  Tof1PositionY, const Int_t i=2)  { myTof1PositionY[i]  =  Tof1PositionY; }
   void  SetTof1PositionZ(const Double_t  Tof1PositionZ, const Int_t i=2)  { myTof1PositionZ[i]  =  Tof1PositionZ; }
   void  SetTof1MomentumX(const Double_t  Tof1MomentumX, const Int_t i=2)  { myTof1MomentumX[i]  =  Tof1MomentumX; }
   void  SetTof1MomentumY(const Double_t  Tof1MomentumY, const Int_t i=2)  { myTof1MomentumY[i]  =  Tof1MomentumY; }
   void  SetTof1MomentumZ(const Double_t  Tof1MomentumZ, const Int_t i=2)  { myTof1MomentumZ[i]  =  Tof1MomentumZ; }
 
   void SetTof1VolumeName(const  TString Tof1VolumeName, const Int_t i=2)    { myTof1VolumeName[i] = Tof1VolumeName;   }
   void SetTof1VolumeNumber(const Int_t Tof1VolumeNumber, const Int_t i=2)  { myTof1VolumeNumber[i] = Tof1VolumeNumber; }
   void SetTof1(const   Double_t  Tof1, const Int_t i=2) { myTof1[i] = Tof1; }
   void SetTof1Path(const   Double_t  Tof1Path, const Int_t i=2) { myTof1Path[i] = Tof1Path; }
   void SetTof1PosSigmaAlongZ(const   Double_t  Tof1PosSigmaAlongZ, const Int_t i=2) { myTof1PosSigmaAlongZ[i] = Tof1PosSigmaAlongZ; }
   void SetTof1PosSigmaAlongT(const   Double_t  Tof1PosSigmaAlongT, const Int_t i=2) { myTof1PosSigmaAlongT[i] = Tof1PosSigmaAlongT; }
   void SetTof1PosSigmaAlongX(const   Double_t  Tof1PosSigmaAlongX, const Int_t i=2) { myTof1PosSigmaAlongX[i] = Tof1PosSigmaAlongX; }
   void SetTof1PosSigmaAlongY(const   Double_t  Tof1PosSigmaAlongY, const Int_t i=2) { myTof1PosSigmaAlongY[i] = Tof1PosSigmaAlongY; }
   void SetTof1ErrorMatrix(const  Double_t Tof1ErrorMatrix[6][6], const Int_t k=2) {
           for (Int_t i = 0 ;i<6 ;i++ )
               for (Int_t j = 0 ;j<6 ;j++ )
                     myTof1ErrorMatrix[k][i][j] = Tof1ErrorMatrix[i][j] ; }
 
    //Tof layer2:
   void  SetTof2PositionX(const Double_t  Tof2PositionX, const Int_t i=2)  { myTof2PositionX[i]  =  Tof2PositionX; }
   void  SetTof2PositionY(const Double_t  Tof2PositionY, const Int_t i=2)  { myTof2PositionY[i]  =  Tof2PositionY; }
   void  SetTof2PositionZ(const Double_t  Tof2PositionZ, const Int_t i=2)  { myTof2PositionZ[i]  =  Tof2PositionZ; }
   void  SetTof2MomentumX(const Double_t  Tof2MomentumX, const Int_t i=2)  { myTof2MomentumX[i]  =  Tof2MomentumX; }
   void  SetTof2MomentumY(const Double_t  Tof2MomentumY, const Int_t i=2)  { myTof2MomentumY[i]  =  Tof2MomentumY; }
   void  SetTof2MomentumZ(const Double_t  Tof2MomentumZ, const Int_t i=2)  { myTof2MomentumZ[i]  =  Tof2MomentumZ; }
 
   void SetTof2VolumeName(const  TString Tof2VolumeName, const Int_t i=2)    { myTof2VolumeName[i] = Tof2VolumeName;   }
   void SetTof2VolumeNumber(const Int_t Tof2VolumeNumber, const Int_t i=2)  { myTof2VolumeNumber[i] = Tof2VolumeNumber; }
   void SetTof2(const   Double_t  Tof2, const Int_t i=2) { myTof2[i] = Tof2; }
   void SetTof2Path(const   Double_t  Tof2Path, const Int_t i=2) { myTof2Path[i] = Tof2Path; }
   void SetTof2PosSigmaAlongZ(const   Double_t  Tof2PosSigmaAlongZ, const Int_t i=2) { myTof2PosSigmaAlongZ[i] = Tof2PosSigmaAlongZ; }
   void SetTof2PosSigmaAlongT(const   Double_t  Tof2PosSigmaAlongT, const Int_t i=2) { myTof2PosSigmaAlongT[i] = Tof2PosSigmaAlongT; }
   void SetTof2PosSigmaAlongX(const   Double_t  Tof2PosSigmaAlongX, const Int_t i=2) { myTof2PosSigmaAlongX[i] = Tof2PosSigmaAlongX; }
   void SetTof2PosSigmaAlongY(const   Double_t  Tof2PosSigmaAlongY, const Int_t i=2) { myTof2PosSigmaAlongY[i] = Tof2PosSigmaAlongY; }
   void SetTof2ErrorMatrix(const  Double_t Tof2ErrorMatrix[6][6], const Int_t k=2) {
           for (Int_t i = 0 ;i<6 ;i++ )
               for (Int_t j = 0 ;j<6 ;j++ )
                     myTof2ErrorMatrix[k][i][j] = Tof2ErrorMatrix[i][j] ; }
          
    //Emc:
   void  SetEmcPositionX(const Double_t  EmcPositionX, const Int_t i=2)  { myEmcPositionX[i]  =  EmcPositionX; }
   void  SetEmcPositionY(const Double_t  EmcPositionY, const Int_t i=2)  { myEmcPositionY[i]  =  EmcPositionY; }
   void  SetEmcPositionZ(const Double_t  EmcPositionZ, const Int_t i=2)  { myEmcPositionZ[i]  =  EmcPositionZ; }
   void  SetEmcMomentumX(const Double_t  EmcMomentumX, const Int_t i=2)  { myEmcMomentumX[i]  =  EmcMomentumX; }
   void  SetEmcMomentumY(const Double_t  EmcMomentumY, const Int_t i=2)  { myEmcMomentumY[i]  =  EmcMomentumY; }
   void  SetEmcMomentumZ(const Double_t  EmcMomentumZ, const Int_t i=2)  { myEmcMomentumZ[i]  =  EmcMomentumZ; }
 
   void SetEmcVolumeName(const  TString EmcVolumeName, const Int_t i=2)    { myEmcVolumeName[i] = EmcVolumeName;   }
   void SetEmcVolumeNumber(const Int_t EmcVolumeNumber, const Int_t i=2)  { myEmcVolumeNumber[i] = EmcVolumeNumber; }
 
   void SetEmcPosSigmaAlongTheta(const   Double_t  EmcPosSigmaAlongTheta, const Int_t i=2) { myEmcPosSigmaAlongTheta[i] = EmcPosSigmaAlongTheta; }
   void SetEmcPosSigmaAlongPhi(const   Double_t  EmcPosSigmaAlongPhi, const Int_t i=2) { myEmcPosSigmaAlongPhi[i] = EmcPosSigmaAlongPhi; }
   
   void SetEmcErrorMatrix(const  Double_t EmcErrorMatrix[6][6], const Int_t k=2) {
           for (Int_t i = 0 ;i<6 ;i++ )
               for (Int_t j = 0 ;j<6 ;j++ )
                     myEmcErrorMatrix[k][i][j] = EmcErrorMatrix[i][j] ; }
 
   void SetEmcPath(Double_t path, const Int_t i=2) {myEmcPath[i] = path;}
 
    //Muc:
   void  SetMucPositionX(const Double_t  MucPositionX, const Int_t i=2)  { myMucPositionX[i]  =  MucPositionX; }
   void  SetMucPositionY(const Double_t  MucPositionY, const Int_t i=2)  { myMucPositionY[i]  =  MucPositionY; }
   void  SetMucPositionZ(const Double_t  MucPositionZ, const Int_t i=2)  { myMucPositionZ[i]  =  MucPositionZ; }
   void  SetMucMomentumX(const Double_t  MucMomentumX, const Int_t i=2)  { myMucMomentumX[i]  =  MucMomentumX; }
   void  SetMucMomentumY(const Double_t  MucMomentumY, const Int_t i=2)  { myMucMomentumY[i]  =  MucMomentumY; }
   void  SetMucMomentumZ(const Double_t  MucMomentumZ, const Int_t i=2)  { myMucMomentumZ[i]  =  MucMomentumZ; }
 
   void SetMucVolumeName(const  TString MucVolumeName, const Int_t i=2)    { myMucVolumeName[i] = MucVolumeName;   }
   void SetMucVolumeNumber(const Int_t MucVolumeNumber, const Int_t i=2)  { myMucVolumeNumber[i] = MucVolumeNumber; }
 
   void SetMucPosSigmaAlongZ(const   Double_t  MucPosSigmaAlongZ, const Int_t i=2) { myMucPosSigmaAlongZ[i] = MucPosSigmaAlongZ; }
   void SetMucPosSigmaAlongT(const   Double_t  MucPosSigmaAlongT, const Int_t i=2) { myMucPosSigmaAlongT[i] = MucPosSigmaAlongT; }
   void SetMucPosSigmaAlongX(const   Double_t  MucPosSigmaAlongX, const Int_t i=2) { myMucPosSigmaAlongX[i] = MucPosSigmaAlongX; }
   void SetMucPosSigmaAlongY(const   Double_t  MucPosSigmaAlongY, const Int_t i=2) { myMucPosSigmaAlongY[i] = MucPosSigmaAlongY; }
 
   void SetMucErrorMatrix(const  Double_t MucErrorMatrix[6][6], const Int_t k=2) {
           for (Int_t i = 0 ;i<6 ;i++ )
               for (Int_t j = 0 ;j<6 ;j++ )
                     myMucErrorMatrix[k][i][j] = MucErrorMatrix[i][j] ; }
 
   void SetSize(Int_t size, const Int_t i=2){ mySize[i] = size;}
   void  SetExtMucHit(Double_t PositionX,Double_t PositionY,Double_t PositionZ,Double_t MomentumX,Double_t MomentumY , Double_t MomentumZ, TString VolumeName,Int_t VolumeNumber,Double_t PosSigmaAlongZ,Double_t PosSigmaAlongT,Double_t PosSigmaAlongX,Double_t PosSigmaAlongY,Double_t ErrorMatrix[6][6], const Int_t k=2){
     myPositionX[k].push_back(PositionX);
     myPositionY[k].push_back(PositionY);
     myPositionZ[k].push_back(PositionZ);
     myMomentumX[k].push_back(MomentumX);
     myMomentumY[k].push_back(MomentumY);
     myMomentumZ[k].push_back(MomentumZ);
     myVolumeName[k].push_back(VolumeName);
     myVolumeNumber[k].push_back(VolumeNumber);
     myPosSigmaAlongZ[k].push_back(PosSigmaAlongZ);
     myPosSigmaAlongT[k].push_back(PosSigmaAlongT);
     myPosSigmaAlongX[k].push_back(PosSigmaAlongX);
     myPosSigmaAlongY[k].push_back(PosSigmaAlongY);
     vector<Double_t> vecError;
     for(int i=0;i<6 ;i++)
       for(int j=0;j<6;j++){
        vecError.push_back(ErrorMatrix[i][j]);  
       }
     myErrorMatrix[k].push_back(vecError);
   }
 
    //extractors
  Int_t GetTrackId() const { return m_trackId; }
    //Tof layer1:
  Double_t    GetTof1PositionX(const Int_t i=2)      const   { return  myTof1PositionX[i] ;    }
  Double_t    GetTof1PositionY(const Int_t i=2)      const   { return  myTof1PositionY[i] ;    }
  Double_t    GetTof1PositionZ(const Int_t i=2)      const   { return  myTof1PositionZ[i] ;    }
  Double_t    GetTof1MomentumX(const Int_t i=2)      const   { return  myTof1MomentumX[i] ;    }
  Double_t    GetTof1MomentumY(const Int_t i=2)      const   { return  myTof1MomentumY[i] ;    }
  Double_t    GetTof1MomentumZ(const Int_t i=2)      const   { return  myTof1MomentumZ[i] ;    }
 
   TString GetTof1VolumeName(const Int_t i=2)   const   { return  myTof1VolumeName[i];   }
   Int_t GetTof1VolumeNumber(const Int_t i=2) const {return myTof1VolumeNumber[i]; }
   Double_t GetTof1(const Int_t i=2) const {return myTof1[i]; }
   Double_t GetTof1Path(const Int_t i=2) const {return myTof1Path[i]; }
   Double_t GetTof1PosSigmaAlongZ(const Int_t i=2) const {return myTof1PosSigmaAlongZ[i];}
   Double_t GetTof1PosSigmaAlongT(const Int_t i=2) const {return myTof1PosSigmaAlongT[i];}
   Double_t GetTof1PosSigmaAlongX(const Int_t i=2) const {return myTof1PosSigmaAlongX[i];}
   Double_t GetTof1PosSigmaAlongY(const Int_t i=2) const {return myTof1PosSigmaAlongY[i];}
   Double_t  GetTof1ErrorMatrix(Int_t i , Int_t j, const Int_t k=2) const {return myTof1ErrorMatrix[k][i][j]; }
 
  //Tof layer2:
  Double_t    GetTof2PositionX(const Int_t i=2)      const   { return  myTof2PositionX[i] ;    }
  Double_t    GetTof2PositionY(const Int_t i=2)      const   { return  myTof2PositionY[i] ;    }
  Double_t    GetTof2PositionZ(const Int_t i=2)      const   { return  myTof2PositionZ[i] ;    }
  Double_t    GetTof2MomentumX(const Int_t i=2)      const   { return  myTof2MomentumX[i] ;    }
  Double_t    GetTof2MomentumY(const Int_t i=2)      const   { return  myTof2MomentumY[i] ;    }
  Double_t    GetTof2MomentumZ(const Int_t i=2)      const   { return  myTof2MomentumZ[i] ;    }
 
   TString GetTof2VolumeName(const Int_t i=2)   const   { return  myTof2VolumeName[i];   }
   Int_t GetTof2VolumeNumber(const Int_t i=2) const {return myTof2VolumeNumber[i]; }
   Double_t GetTof2(const Int_t i=2) const {return myTof2[i]; }
   Double_t GetTof2Path(const Int_t i=2) const {return myTof2Path[i]; }
   Double_t GetTof2PosSigmaAlongZ(const Int_t i=2) const {return myTof2PosSigmaAlongZ[i];}
   Double_t GetTof2PosSigmaAlongT(const Int_t i=2) const {return myTof2PosSigmaAlongT[i];}
   Double_t GetTof2PosSigmaAlongX(const Int_t i=2) const {return myTof2PosSigmaAlongX[i];}
   Double_t GetTof2PosSigmaAlongY(const Int_t i=2) const {return myTof2PosSigmaAlongY[i];}
   Double_t  GetTof2ErrorMatrix(Int_t i , Int_t j, const Int_t k=2) const {return myTof2ErrorMatrix[k][i][j]; }
 
  //Emc
  Double_t    GetEmcPositionX(const Int_t i=2)      const   { return  myEmcPositionX[i] ;    }
  Double_t    GetEmcPositionY(const Int_t i=2)      const   { return  myEmcPositionY[i] ;    }
  Double_t    GetEmcPositionZ(const Int_t i=2)      const   { return  myEmcPositionZ[i] ;    }
  Double_t    GetEmcMomentumX(const Int_t i=2)      const   { return  myEmcMomentumX[i] ;    }
  Double_t    GetEmcMomentumY(const Int_t i=2)      const   { return  myEmcMomentumY[i] ;    }
  Double_t    GetEmcMomentumZ(const Int_t i=2)      const   { return  myEmcMomentumZ[i] ;    }
 
   TString GetEmcVolumeName(const Int_t i=2)   const   { return  myEmcVolumeName[i];   }
   Int_t GetEmcVolumeNumber(const Int_t i=2) const {return myEmcVolumeNumber[i]; }
   Double_t GetEmcPosSigmaAlongTheta(const Int_t i=2) const {return myEmcPosSigmaAlongTheta[i];}
   Double_t GetEmcPosSigmaAlongPhi(const Int_t i=2) const {return myEmcPosSigmaAlongPhi[i];}
   Double_t  GetEmcErrorMatrix(Int_t i , Int_t j, const Int_t k=2) const {return myEmcErrorMatrix[k][i][j]; }
   Double_t emcPath(const Int_t i=2) const {return myEmcPath[i];}
 
   //Muc
  Double_t    GetMucPositionX(const Int_t i=2)      const   { return  myMucPositionX[i] ;    }
  Double_t    GetMucPositionY(const Int_t i=2)      const   { return  myMucPositionY[i] ;    }
  Double_t    GetMucPositionZ(const Int_t i=2)      const   { return  myMucPositionZ[i] ;    }
  Double_t    GetMucMomentumX(const Int_t i=2)      const   { return  myMucMomentumX[i] ;    }
  Double_t    GetMucMomentumY(const Int_t i=2)      const   { return  myMucMomentumY[i] ;    }
  Double_t    GetMucMomentumZ(const Int_t i=2)      const   { return  myMucMomentumZ[i] ;    }
 
   TString GetMucVolumeName(const Int_t i=2)   const   { return  myMucVolumeName[i];   }
   Int_t GetMucVolumeNumber(const Int_t i=2) const {return myMucVolumeNumber[i]; }
   Double_t GetMucPosSigmaAlongZ(const Int_t i=2) const {return myMucPosSigmaAlongZ[i];}
   Double_t GetMucPosSigmaAlongT(const Int_t i=2) const {return myMucPosSigmaAlongT[i];}
   Double_t GetMucPosSigmaAlongX(const Int_t i=2) const {return myMucPosSigmaAlongX[i];}
   Double_t GetMucPosSigmaAlongY(const Int_t i=2) const {return myMucPosSigmaAlongY[i];}
   Double_t  GetMucErrorMatrix(Int_t i , Int_t j, const Int_t k=2) const {return myMucErrorMatrix[k][i][j]; }
   
   // ExtMucHitVet
   Int_t    GetSize(const Int_t i=2) const {return mySize[i];};
   Double_t GetPositionX(Int_t i, const Int_t k=2) const {return myPositionX[k][i]; }
   Double_t GetPositionY(Int_t i, const Int_t k=2) const {return myPositionY[k][i]; }
   Double_t GetPositionZ(Int_t i, const Int_t k=2) const {return myPositionZ[k][i]; }
   Double_t GetMomentumX(Int_t i, const Int_t k=2) const {return myMomentumX[k][i];}
   Double_t GetMomentumY(Int_t i, const Int_t k=2) const {return myMomentumY[k][i];}
   Double_t GetMomentumZ(Int_t i, const Int_t k=2) const {return myMomentumZ[k][i];}
   TString GetVolumeName(Int_t i, const Int_t k=2) const {return myVolumeName[k][i];}
   Int_t GetVolumeNumber(Int_t i, const Int_t k=2) const {return myVolumeNumber[k][i];}
   Double_t GetPosSigmaAlongZ(Int_t i, const Int_t k=2) const {return myPosSigmaAlongZ[k][i];}
   Double_t GetPosSigmaAlongT(Int_t i, const Int_t k=2) const {return myPosSigmaAlongT[k][i];}
   Double_t GetPosSigmaAlongX(Int_t i, const Int_t k=2) const {return myPosSigmaAlongX[k][i];}
   Double_t GetPosSigmaAlongY(Int_t i, const Int_t k=2) const {return myPosSigmaAlongY[k][i];}
   vector<Double_t> GetErrorMatrix(Int_t i, const Int_t k=2) const {return myErrorMatrix[k][i];}
   
   
   
private:
 
    //Tof TrkExt data.
        Int_t    m_trackId;       //Track Id wensp Add 2005-10-19
    //
    //Tof layer1:
    Double_t  myTof1PositionX[5]; //Position when the particle enters the TOF layer1.
    Double_t  myTof1PositionY[5]; //Position when the particle enters the TOF layer1
    Double_t  myTof1PositionZ[5]; //Position when the particle enters the TOF layer1
    Double_t myTof1MomentumX[5];//Momentum when the particle enters the TOF layer1.
    Double_t myTof1MomentumY[5];//Momentum when the particle enters the TOF layer1.
    Double_t myTof1MomentumZ[5];//Momentum when the particle enters the TOF layer1.
 
    TString myTof1VolumeName[5];//Scintillator volume name
    Int_t  myTof1VolumeNumber[5];//Scintillator volume number
    Double_t myTof1[5];//Time of flight
    Double_t myTof1Path[5];//Path of flight
    Double_t myTof1PosSigmaAlongZ[5];//Sigma Z
    Double_t myTof1PosSigmaAlongT[5];//Sigma along Z x R
    Double_t myTof1PosSigmaAlongX[5];//Sigma X
    Double_t  myTof1PosSigmaAlongY[5];//Sigma Y
    Double_t myTof1ErrorMatrix[5][6][6]; //Error matrix 6x6 (x,p)
 
    //Tof layer2:
    Double_t  myTof2PositionX[5]; //Position when the particle enters the TOF layer2.
    Double_t  myTof2PositionY[5]; //Position when the particle enters the TOF layer2
    Double_t  myTof2PositionZ[5]; //Position when the particle enters the TOF layer2
    Double_t myTof2MomentumX[5];//Momentum when the particle enters the TOF layer2
    Double_t myTof2MomentumY[5];//Momentum when the particle enters the TOF layer2
    Double_t myTof2MomentumZ[5];//Momentum when the particle enters the TOF layer2
 
    TString myTof2VolumeName[5];//Scintillator volume name
    Int_t  myTof2VolumeNumber[5];//Scintillator volume number
    Double_t myTof2[5];//Time of flight
    Double_t myTof2Path[5];//Path of flight
    Double_t myTof2PosSigmaAlongZ[5];//Sigma Z
    Double_t myTof2PosSigmaAlongT[5];//Sigma along Z x R
    Double_t myTof2PosSigmaAlongX[5];//Sigma X
    Double_t  myTof2PosSigmaAlongY[5];//Sigma Y
    Double_t myTof2ErrorMatrix[5][6][6]; //Error matrix 6x6 (x,p)
 
    //Emc TrkExt data,which is similar to TOF data.
    Double_t  myEmcPositionX[5]; //Position 2.
    Double_t  myEmcPositionY[5]; //Position 2
    Double_t  myEmcPositionZ[5]; //Position 2
    Double_t myEmcMomentumX[5];//Momentum 
    Double_t myEmcMomentumY[5];//Momentum 
    Double_t myEmcMomentumZ[5];//Momentum 
 
    TString myEmcVolumeName[5];//Scintillator volume name
    Int_t  myEmcVolumeNumber[5];//Scintillator volume number
    Double_t myEmcPosSigmaAlongTheta[5];
    Double_t myEmcPosSigmaAlongPhi[5];
    Double_t myEmcErrorMatrix[5][6][6]; //Error matrix 6x6 (x,p)
 
    Double_t myEmcPath[5];
 
    //Muc TrkExt data,which is similar to TOF data.
    Double_t  myMucPositionX[5]; //Position 2.
    Double_t  myMucPositionY[5]; //Position 2
    Double_t  myMucPositionZ[5]; //Position 2
    Double_t myMucMomentumX[5];//Momentum 
    Double_t myMucMomentumY[5];//Momentum 
    Double_t myMucMomentumZ[5];//Momentum 
 
    TString myMucVolumeName[5];//Scintillator volume name
    Int_t  myMucVolumeNumber[5];//Scintillator volume number
 
    Double_t myMucPosSigmaAlongZ[5];
    Double_t myMucPosSigmaAlongT[5];
    Double_t myMucPosSigmaAlongX[5];
    Double_t myMucPosSigmaAlongY[5];
    Double_t myMucErrorMatrix[5][6][6];
 
  // for  ExtMucHitVec
  Int_t mySize[5]; //size of the vector 
  vector<Double_t> myPositionX[5];
  vector<Double_t> myPositionY[5];
  vector<Double_t> myPositionZ[5];
  vector<Double_t> myMomentumX[5];
  vector<Double_t> myMomentumY[5];
  vector<Double_t> myMomentumZ[5];
  vector<TString>  myVolumeName[5];
  vector<Int_t>    myVolumeNumber[5];
  vector<Double_t> myPosSigmaAlongZ[5];
  vector<Double_t> myPosSigmaAlongT[5];
  vector<Double_t> myPosSigmaAlongX[5];
  vector<Double_t> myPosSigmaAlongY[5];
  vector< vector<Double_t> > myErrorMatrix[5];
  
 
    ClassDef(TRecExtTrack,3)
};
 
#endif