TGeoHelix

class TGeoHelix : public TObject

    public:

                      TGeoHelix()
                      TGeoHelix(Double_t curvature, Double_t step, Int_t charge = 1)
                      TGeoHelix(const TGeoHelix&)
              virtual ~TGeoHelix()
       static TClass* Class()
             Double_t ComputeSafeStep(Double_t epsil = 1E-6) const
      const Double_t* GetCurrentDirection() const
      const Double_t* GetCurrentPoint() const
             Double_t GetStep() const
             Double_t GetTotalCurvature() const
             Double_t GetXYcurvature() const
                 void InitDirection(Double_t dirx, Double_t diry, Double_t dirz, Bool_t is_normalized = kTRUE)
                 void InitDirection(Double_t* dir, Bool_t is_normalized = kTRUE)
                 void InitPoint(Double_t x0, Double_t y0, Double_t z0)
                 void InitPoint(Double_t* point)
      virtual TClass* IsA() const
               Bool_t IsRightHanded() const
           TGeoHelix& operator=(const TGeoHelix&)
                 void ResetStep()
                 void SetCharge(Int_t charge)
                 void SetField(Double_t bx, Double_t by, Double_t bz, Bool_t is_normalized = kTRUE)
                 void SetHelixStep(Double_t hstep)
                 void SetXYcurvature(Double_t curvature)
         virtual void ShowMembers(TMemberInspector& insp, char* parent)
                 void Step(Double_t step)
             Double_t StepToPlane(Double_t* point, Double_t* norm)
         virtual void Streamer(TBuffer& b)
                 void StreamerNVirtual(TBuffer& b)
                 void UpdateHelix()

Data Members

    private:

          Double_t fC             curvature in XY plane
          Double_t fS             Z step of the helix / 2*PI
          Double_t fStep          current step
          Double_t fPhi           phi angle
          Double_t fPointInit[3]  initial point
          Double_t fDirInit[3]    normalized initial direction
          Double_t fPoint[3]      point after a step
          Double_t fDir[3]        direction after a step
          Double_t fB[3]          normalized direction for magnetic field
             Int_t fQ             right/left-handed (+/- 1) - "charge"
      TGeoHMatrix* fMatrix        transformation of local helix frame to MARS   

    public:

      static const TGeoHelix::EGeoHelixTypes kHelixNeedUpdate  
      static const TGeoHelix::EGeoHelixTypes kHelixStraigth    
      static const TGeoHelix::EGeoHelixTypes kHelixCircle      

Class Description

   TGeoHelix - class representing a helix curve

  A helix is a curve defined by the following equations:
     x = (1/c) * COS(q*phi)
     y = (1/c) * SIN(q*phi)
     z = s * alfa
 where:
     c = 1/Rxy  - curvature in XY plane
     phi        - phi angle
     S = 2*PI*s - vertical separation between helix loops
     q = +/- 1  - (+)=left-handed, (-)=right-handed

   In particular, a helix describes the trajectory of a charged particle in magnetic
 field. In such case, the helix is right-handed for negative particle charge.
 To define a helix, one must define:
   - the curvature - positive defined
   - the Z step made after one full turn of the helix
   - the particle charge sign
   - the initial particle position and direction (force normalization to unit)
   - the magnetic field direction

 A helix provides:
   - propagation to a given Z position (in global frame)
   Double_t *point = TGeoHelix::PropagateToZ(Double_t z);
   - propagation to an arbitrary plane, returning also the new point
   - propagation in a geometry until the next crossed surface
   - computation of the total track length along a helix

 Dummy constructor

 Normal constructor

 Destructor

 Compute safe linear step that can be made such that the error
 between linear-helix extrapolation is less than EPSIL.

 Initialize coordinates of a point on the helix

 Initialize particle direction (tangent on the helix in initial point)

 Compute helix total curvature

 Set XY curvature: c = 1/Rxy

 Positive charge means left-handed helix.

 Initialize particle direction (tangent on the helix in initial point)

 Set Z step of the helix on a complete turn. Positive or null.

 Reset current point/direction to initial values

 Make a step from current point along the helix and compute new point, direction and angle
 To reach a plane/ shape boundary, one has to:
  1. Compute the safety to the plane/boundary
  2. Define / update a helix according local field and particle state (position, direction, charge)
  3. Compute the magnetic safety (maximum distance for which the field can be considered constant)
  4. Call TGeoHelix::Step() having as argument the minimum between 1. and 3.
  5. Repeat from 1. until the step to be made is small enough.
  6. Add to the total step the distance along a straigth line from the last point
     to the plane/shape boundary

 Propagate initial point up to a given Z position in MARS.

 Update the local helix matrix.

Inline Functions

        const Double_t* GetCurrentPoint() const
        const Double_t* GetCurrentDirection() const
               Double_t GetXYcurvature() const
               Double_t GetStep() const
                 Bool_t IsRightHanded() const
                TClass* Class()
                TClass* IsA() const
                   void ShowMembers(TMemberInspector& insp, char* parent)
                   void Streamer(TBuffer& b)
                   void StreamerNVirtual(TBuffer& b)
              TGeoHelix TGeoHelix(const TGeoHelix&)
             TGeoHelix& operator=(const TGeoHelix&)