T49Trkstep

class T49Trkstep : public TObject

    public:

                      T49Trkstep()
                      T49Trkstep(const T49Trkstep&)
              virtual ~T49Trkstep()
       static TClass* Class()
              Float_t GetCharge()
                Int_t GetCheck()
                Int_t GetFixStep()
              Float_t GetPx()
              Float_t GetPy()
              Float_t GetPz()
              Float_t GetStepSize()
              Float_t GetX()
              Float_t GetY()
              Float_t GetZ()
                Int_t InitDS(Char_t* dspack_server = "")
      virtual TClass* IsA() const
          T49Trkstep& operator=(const T49Trkstep&)
                 void SetCharge(Float_t q)
                 void SetCheck(Int_t check)
                 void SetFixStep(Int_t step)
                 void SetKeys(Char_t* key1, Char_t* key3, Char_t* key4, Char_t* key5, Char_t* key6, Char_t* key7)
                 void SetKeys96STDp()
                 void SetP(Float_t px, Float_t py, Float_t pz)
                 void SetPos(Float_t x, Float_t y, Float_t z)
                 void SetStepSize(Float_t size)
         virtual void ShowMembers(TMemberInspector& insp, char* parent)
         virtual void Streamer(TBuffer& b)
                 void StreamerNVirtual(TBuffer& b)
                Int_t TrackTo(Float_t z)

Data Members

    private:

      Float_t fCharge     Track charge
      Float_t fXstart[3]  Initial position
      Float_t fPstart[3]  Momentum components at the initial point
      Float_t fXstop[3]   Final position
      Float_t fPstop[3]   Momentum components at the final point
        Int_t fFixStep    1: track in fixed steps of fStepSize. 0: use adaptive step size algorithm
      Float_t fStepSize   Distance (cm) to be used in fixed step approach
        Int_t fCheck      1: check against bounds of field map. 0: don't - you know where you're going

Class Description

                                                                   
    T49Trkstep provides an interface to NA49-trkstep.              
    It allows to extrapolate a track defined by its momentum       
    components by swimming through the magnetic field.             
    The field is read from the NA49 database, which requires that  
    the appropriate keys are set.                                  
                                                                   
    An example application might look like this:                   
                                                                   
       T49Trkstep *T = new T49Trkstep();                           
       T->SetKeys("1458","RU96","V96C","COMB/STD+","FULL","R95A"); 
       T->InitDS("trkstep");                                       
       T->SetCharge(1);                                            
       T->SetPos(0,0,-580);                                        
       T->SetP(0.1,0.05,10.0);                                     
       T->TrackTo(-570);                                           
       T->GetZ();                                                  
                                                                   
    Based on TMvlTracker by Marco van Leeuwen                      
                                                                   

 T49Trkstep default constructor
 Initializes T49Trkstep with the adaptive step size algorithm,
 field boundary checking, and track charge = +1.

 Sets the keys

 Sets the default keys for the 96 std+ central Pb+Pb data

 Initializes the database

 Tracks a given track to the chosen z-position.
 Return values:  0 = successful
                 1 = track left magnetic field map
                 2 = too many steps ( maximum 500 )
                 3 = track changed direction ( spiral track )
                 4 = could not get bmap bounds from HEPDB
                 5 = zero input momentum

 Sets the momentum components of the track

 Sets the starting position of the track

Inline Functions

               void ~T49Trkstep()
               void SetCharge(Float_t q)
               void SetFixStep(Int_t step)
               void SetStepSize(Float_t size)
               void SetCheck(Int_t check)
            Float_t GetPx()
            Float_t GetPy()
            Float_t GetPz()
            Float_t GetX()
            Float_t GetY()
            Float_t GetZ()
            Float_t GetCharge()
              Int_t GetFixStep()
            Float_t GetStepSize()
              Int_t GetCheck()
            TClass* Class()
            TClass* IsA() const
               void ShowMembers(TMemberInspector& insp, char* parent)
               void Streamer(TBuffer& b)
               void StreamerNVirtual(TBuffer& b)
         T49Trkstep T49Trkstep(const T49Trkstep&)
        T49Trkstep& operator=(const T49Trkstep&)