LCDSmearTraj

class LCDSmearTraj : public TObject

    private:

               Bool_t checkInside(LCDDetectorVolume* pCur)
                Int_t circleIntersect(Double_t rv, Double_t* p1, Double_t* p2)
                 void makeHelixQuantities(Double_t fld)
             Double_t phaseChange(Double_t newX, Double_t newY)
      static Double_t pythagMinus(const Double_t x, Double_t y)
      static Double_t pythagPlus(const Double_t x, Double_t y)
      static Double_t QuadRoot(const Double_t a, const Double_t b, const Double_t c, Bool_t* status)

    protected:


    public:

                    LCDSmearTraj LCDSmearTraj()
                    LCDSmearTraj LCDSmearTraj(LCDSmearTraj&)
                    virtual void ~LCDSmearTraj()
                  static TClass* Class()
                           Int_t GetCharge()
                        TVector3 GetNewMom()
                        TVector3 GetNewPos()
                        Double_t GetS()
      LCDSmearTraj::PropagateRet HelixPath(Double_t fld, Double_t s)
      LCDSmearTraj::PropagateRet HelixToCyl(LCDDetectorVolume* pCur, Double_t* pS)
                 virtual TClass* IsA() const
      LCDSmearTraj::PropagateRet LinePath(Double_t s)
      LCDSmearTraj::PropagateRet LineToCyl(LCDDetectorVolume* pCur, Double_t* pS)
                            void SetParticleParams(TVector3 pos, TVector3 mom, Int_t charge)
                    virtual void ShowMembers(TMemberInspector& insp, char* parent)
                    virtual void Streamer(TBuffer& b)
                            void StreamerNVirtual(TBuffer& b)
                            void Update()

  Data Members
    private:

         Int_t q          charge
      TVector3 iP         position at starting point
      TVector3 iM         mom. at starting point
      TVector3 newP       position after calling a swim routine
      TVector3 newM       mom. after calling a swim routine
      Double_t momMag     Magnitude of momentum
      Double_t xyMomMag   Mag. of momentum projected to xy-plane
      Double_t sinLambda  
      Double_t cosLambda  
      Double_t rad        radius of helix projected to xy-plane
      Double_t radQ       ..take into account sign of q
      Double_t xCenter    
      Double_t yCenter    ... of helix circle
      Double_t fieldCnv   Parameter derived from mag. field
      Double_t deltaS     delta path length for last piece of propagation
      Double_t totalS     (geometrical) path length traversed by particle

    protected:


    public:

      static const LCDSmearTraj::PropagateRet INTERSECT_CYLIN      
      static const LCDSmearTraj::PropagateRet INTERSECT_ZMINUS     
      static const LCDSmearTraj::PropagateRet INTERSECT_NONE       
      static const LCDSmearTraj::PropagateRet INTERSECT_ZPLUS      
      static const LCDSmearTraj::PropagateRet INTERSECT_CYLOUT     
      static const LCDSmearTraj::PropagateRet INTERSECT_XYMOM      
      static const LCDSmearTraj::PropagateRet INTERSECT_UNCHARGED  
      static const LCDSmearTraj::PropagateRet INTERSECT_PATHOK     
      static const LCDSmearTraj::PropagateRet INTERSECT_ERROR      

Class Description

 SmearTraj

 This class does the work of propagating particles.

 Compute and cache some information about this particle

 Invoke this routine when the result of the last request to propagate is
 is deemed OK.

 For a given field (and momementum magnitude of particle which,
 for current implementation, is constant throughoutn its life)
 compute and store some useful quantities.

 Utility used when swimming linearly to cylinder.  Return
 Smallest positive root, if any.

 This utility is used by SmearTraj::HelixToCy.

 Given two circles, one centered about the origin, find their points of
 intersection.  The return value is the number of solutions found.
 In this application, one circle is the (xy-projection) of a volume
 boundary, always centered about the origin.  The other the helix which
 is typically not centered about the origin.
 This algorithm is due to Rasmus Munk Larsen.

 Return change in phase needed to get to (newX, newY) from
 initial position

 Compute sqrt(x*x + y*y) in maximally stable fashion

 Compute sqrt(x*x - y*y) maximally stable fashion

Inline Functions

                            Bool_t checkInside(LCDDetectorVolume* pCur)
                      LCDSmearTraj LCDSmearTraj()
        LCDSmearTraj::PropagateRet HelixPath(Double_t fld, Double_t s)
        LCDSmearTraj::PropagateRet LinePath(Double_t s)
        LCDSmearTraj::PropagateRet HelixToCyl(LCDDetectorVolume* pCur, Double_t* pS)
        LCDSmearTraj::PropagateRet LineToCyl(LCDDetectorVolume* pCur, Double_t* pS)
                          TVector3 GetNewPos()
                          TVector3 GetNewMom()
                             Int_t GetCharge()
                          Double_t GetS()
                           TClass* Class()
                           TClass* IsA() const
                              void ShowMembers(TMemberInspector& insp, char* parent)
                              void Streamer(TBuffer& b)
                              void StreamerNVirtual(TBuffer& b)
                      LCDSmearTraj LCDSmearTraj(LCDSmearTraj&)
                              void ~LCDSmearTraj()