SmearTraj

class SmearTraj : public TObject

    private:

        Bool_t checkInside(SmearVolume* pCur)
         Int_t circleIntersect(Double_t rv, Double_t* x0, Double_t* y0)
          void makeHelixQuantities(Double_t fld)
      Double_t phaseChange(Double_t newX, Double_t newY)
      Double_t QuadRoot(Double_t a, Double_t b, Double_t c, Bool_t* status)

    public:

                    SmearTraj SmearTraj()
                    SmearTraj SmearTraj(SmearTraj&)
                         void ~SmearTraj()
                      TClass* Class()
                        Int_t GetCharge()
                      McPart* GetMc()
                        Int_t GetMcIx()
                    Double_t* GetNewMom()
                    Double_t* GetNewPos()
                     Double_t GetS()
      SmearTraj::PropagateRet HelixPath(Double_t fld, Double_t s)
      SmearTraj::PropagateRet HelixToCyl(SmearVolume* pCur, Double_t* pS)
              virtual TClass* IsA()
      SmearTraj::PropagateRet LinePath(Double_t s)
      SmearTraj::PropagateRet LineToCyl(SmearVolume* pCur, Double_t* pS)
                         void SetParticle(McPart* pPart, Int_t ix)
                 virtual void ShowMembers(TMemberInspector& insp, char* parent)
                 virtual void Streamer(TBuffer& b)
                         void Update()

  Data Members
    private:

       McPart* pPart       ptr to particle to be smeared
         Int_t particleIx  index of part. to be smeared (in list of same)
         Int_t q           charge
      Double_t iP[3]       position at starting point
      Double_t iM[3]       mom. at starting point
      Double_t newP[3]     position after calling a swim routine
      Double_t newM[3]     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 rCenter     distance from center to origin
      Double_t phiCenter   phi for vector from origin to center of helix
      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

    public:

      static const SmearTraj::PropagateRet INTERSECT_CYLIN      
      static const SmearTraj::PropagateRet INTERSECT_ZMINUS     
      static const SmearTraj::PropagateRet INTERSECT_NONE       
      static const SmearTraj::PropagateRet INTERSECT_ZPLUS      
      static const SmearTraj::PropagateRet INTERSECT_CYLOUT     
      static const SmearTraj::PropagateRet INTERSECT_XYMOM      
      static const SmearTraj::PropagateRet INTERSECT_UNCHARGED  
      static const SmearTraj::PropagateRet INTERSECT_PATHOK     
      static const SmearTraj::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 routine shouldn't find more than two solutions, but can't
 possibly find more than four, so to be safe x0, y0 should be pointers
 to arrays of 4 doubles.

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

Inline Functions

                      SmearTraj SmearTraj()
        SmearTraj::PropagateRet HelixPath(Double_t fld, Double_t s)
        SmearTraj::PropagateRet LinePath(Double_t s)
        SmearTraj::PropagateRet HelixToCyl(SmearVolume* pCur, Double_t* pS)
        SmearTraj::PropagateRet LineToCyl(SmearVolume* pCur, Double_t* pS)
                      Double_t* GetNewPos()
                      Double_t* GetNewMom()
                          Int_t GetCharge()
                       Double_t GetS()
                        McPart* GetMc()
                          Int_t GetMcIx()
                         Bool_t checkInside(SmearVolume* pCur)
                        TClass* Class()
                        TClass* IsA()
                           void ShowMembers(TMemberInspector& insp, char* parent)
                           void Streamer(TBuffer& b)
                      SmearTraj SmearTraj(SmearTraj&)
                           void ~SmearTraj()