HRungeKutta

class HRungeKutta

    private:

         void cosines(Float_t, Float_t, Double_t*)
       Bool_t decompose(TMatrixD& lu, Double_t& sign, Double_t tol, Int_t& nrZeros)
         void derive(Double_t*, Int_t)
      Float_t distance(Double_t*, Double_t*)
       Bool_t findIntersectionPoint(Double_t*, Double_t*, Double_t*, Double_t*, Double_t*)
         void findMdcIntersectionPoint(Double_t*, Double_t*, Int_t, Double_t*)
       Bool_t fitMdc()
         void gentrkNew(Float_t, Double_t*, Double_t*, Double_t*, Int_t)
         void initMom()
       Bool_t linSys()
         void parSetNew0(Float_t, Float_t, Int_t)
         void parSetNewVar(Float_t, Float_t)
         void rkeqfw(Double_t*, Float_t, Double_t*, Float_t*)
      Float_t rkgtrk(Float_t, Float_t, Double_t*, Double_t*, Int_t kind = 0)

    public:

                      HRungeKutta()
                      HRungeKutta(const HRungeKutta&)
              virtual ~HRungeKutta()
       static TClass* Class()
                 void clear()
               Bool_t fit3Hits(Double_t*, Double_t*, Double_t*, Double_t*, Float_t*, Int_t, Double_t pGuess = 999999999.)
               Bool_t fit4Hits(Double_t*, Double_t*, Double_t*, Double_t*, Float_t*, Int_t, Double_t pGuess = 999999999.)
              Float_t getChi2()
              Float_t getDXtrackFirstMDCFitPos()
              Float_t getDXtrackLastMDCFitPos()
              Float_t getDYtrackFirstMDCFitPos()
              Float_t getDYtrackLastMDCFitPos()
              Float_t getDZtrackFirstMDCFitPos()
              Float_t getDZtrackLastMDCFitPos()
             Double_t getMTol()
                Int_t getNMaxMod()
              Float_t getPfit()
              Float_t getPhiSeg1()
              Float_t getPhiSeg2()
              Float_t getRSeg1()
              Float_t getRSeg2()
              Float_t getThetaSeg1()
              Float_t getThetaSeg2()
              Float_t getTrackLength()
              Float_t getXfit(Int_t iMdc)
              Float_t getXfithit(Int_t iMdc)
              Float_t getXhit(Int_t iMdc)
              Float_t getXtrackFirstMDCFitPos()
              Float_t getXtrackLastMDCFitPos()
              Float_t getXtrackOnMETA()
              Float_t getYfit(Int_t iMdc)
              Float_t getYfithit(Int_t iMdc)
              Float_t getYhit(Int_t iMdc)
              Float_t getYtrackFirstMDCFitPos()
              Float_t getYtrackLastMDCFitPos()
              Float_t getYtrackOnMETA()
              Float_t getZfit(Int_t iMdc)
              Float_t getZSeg1()
              Float_t getZSeg2()
              Float_t getZtrackFirstMDCFitPos()
              Float_t getZtrackLastMDCFitPos()
              Float_t getZtrackOnMETA()
      virtual TClass* IsA() const
         HRungeKutta& operator=(const HRungeKutta&)
                 void setField(HMdcTrackGField*, Float_t)
                 void setFieldFactor(Float_t fpol)
                 void setMdcPosition(Int_t, Int_t, HGeomTransform&)
                 void setMTol(Double_t tol)
         virtual void ShowMembers(TMemberInspector& insp, char* parent)
         virtual void Streamer(TBuffer& b)
                 void StreamerNVirtual(TBuffer& b)
                 void traceToMETA(HGeomVector&, HGeomVector&, HGeomVector*, HGeomVector*)
                 void traceToVertex(HMdcSizesCells*)

Data Members

    private:

      HMdcTrackGField* fieldMap                 pointer to field map
              Double_t fieldScalFact            factor of the magnetic field strength
                Bool_t mdcInstalled[4][6]       remembers which MDCs have known geometry
              Double_t mdcPos[4][6][3]          real position of mdc's in sector coordinate system
              Double_t normVecMdc[4][6][3]      normal vector on each Mdc module in sector coordinate system
              Double_t pointForVertexRec[6][3]  point on virtual plane in front of MDC1 used for vertex reconstruction
              Double_t dzfacMdc[2][6]           factor to calculate dz from dy in the first two MDC planes
              Double_t p0Guess                  initial momentum
               Float_t initialStepSize          initial RK step size
               Float_t stepSizeInc              factor to increase stepsize
               Float_t stepSizeDec              factor to decrease stepsize
               Float_t maxStepSize              maximum stepsize
               Float_t minStepSize              minimum stepsize
               Float_t minPrecision             minimum required precision for a single step
               Float_t maxPrecision             maximum required precision for a single step
                 Int_t maxNumSteps              maximum number of steps
              Double_t maxDist                  maximum distance for straight line approximation
               Float_t pfit                     momentum after RK-fit
               Float_t chi2                     normalized chi^2 after RK-fit
               Float_t trackLength              track length
               Float_t dpar[5]                  variations (momentum, xdir, ydir, xpos, ypos)
               Float_t resolution[8]            resolution
               Float_t sig[8]                   sigmas for hit points
              Double_t hit[4][3]                
              Double_t fit[4][3]                hits and fitted points at mdc's
              Double_t fitdp[4][3]              
              Double_t fitdh[4][3]              
              Double_t fitdv[4][3]              
              Double_t fit1h[4][3]              
              Double_t fit1v[4][3]              fitted positions for derivatives
                 Int_t mdcModules[4]            module number in hit/fit
                 Int_t mdcLookup[4]             index in mdcModules for all 4 modules
              Double_t dydpar[5][8]             derivatives
              Double_t ydata[8]                 difference between fitted and measured hit positions
              Double_t fitpar[5]                fit parameters
                 Int_t ndf                      number of degrees of freedom
                 Int_t nMaxMod                  maximum hit module number (3 or 4)
                 Int_t sector                   sector index
              Double_t dirAtFirstMDC[3]         fitted direction at first MDC
              Double_t posNearLastMDC[3]        fitted direction at last MDC
              Double_t dirAtLastMDC[3]          fitted direction at last MDC
               Float_t stepSizeAtLastMDC        RK step size at last MDC
              Double_t trackPosOnMETA[3]        fitted trajectory point on META
                 Int_t jstep                    step number
              Double_t zSeg1                    
              Double_t rSeg1                    
              Double_t thetaSeg1                
              Double_t phiSeg1                  fitted data for inner segment
              Double_t zSeg2                    
              Double_t rSeg2                    
              Double_t thetaSeg2                
              Double_t phiSeg2                  fitted data for outer segment
               Float_t polbending               polarity of bending (field scaling factor * pfit)
              Double_t mTol                     ! tolerance for invertion of matrix (default : DBL_EPSILON)

Class Description

 clears magnetic field definition and vertex position and direction

 sets the field map and the scaling factor

 sets the MDC module position in the sector coordinate system
 calculates the normal vector on the planes

 Input:  position and direction of the two segments u1 and u2,
         array with multiplication factors for errors
         sector number, initial guess for momentum
 From the segments the hit positions are calculated.
 Calls fitMdc for Runge-Kutta track propagation and fitting

 Input:  position and direction of the two segments u1 and u2
         array with multiplication factors for errors
         sector number, initial guess for momentum
 From the segments the hit positions are calculated.
 If the multiplication factors for errors of a hit -1, the hit is discarded.
 Calls fitMdc for Runge-Kutta track propagation and fitting

 calculates the hit points in the MDC module (index mdcN 0..3)
 input:  posline == pos from track piece
 input:  dirline == pos from segment
         mdcN    == module number 0..3
 output: xyz     == hit position in module

 Here we set initial approximation momentum value

 calculates the distance between two points

 RK propagation with initial or last fit parameters
 uv - vertical direction in MDC1
 uh - horizontal direction

 calculates the derivatives (RK propagation with parameter variations)
 uv - vertical direction
 uh - horizontal direction in MDC1

 calculates the direction

 calculates the derivative (hit-fit)/variation

 solves the system of linear equations and sets the new fitting parameters

 propages the track through the MDC system
 p      == momentum
 upos   == initial position
 udir   == initial direction
 hitxyz == hits in chambers
 kind   == type of variation

 one step of track tracing from the position upos in the direction of udir

 calculates 2nd derivative

 propogates the track backwards from first MDC till Z=zVertex plane
 should be called only after RK-minimisation is done

 propagates the track from the last fitted MDC position till track intersection
 with META plane (is defined by META-hit and normal vector to rod's plane
 should be called only after RK-minimisation is done

 upos, udir - "moving point" current position and movement direction vector
 planeR0[3] some point on the plane to which intersection is supposed to happen
 planeNorm[3] perpendicular vector to the plane
 pointIntersect[3] - output - the intersection point of "moving point" with plane

 THis part is copid from ROOT TDecompLU::Decompose() to get
 rid of error message!
 Crout/Doolittle algorithm of LU decomposing a square matrix, with implicit partial
 pivoting.  The decomposition is stored in fLU: U is explicit in the upper triag
 and L is in multiplier form in the subdiagionals .
 Row permutations are mapped out in fIndex. fSign, used for calculating the
 determinant, is +/- 1 for even/odd row permutations. .

Inline Functions

                void ~HRungeKutta()
                void setFieldFactor(Float_t fpol)
             Float_t getPfit()
             Float_t getChi2()
               Int_t getNMaxMod()
             Float_t getXfit(Int_t iMdc)
             Float_t getYfit(Int_t iMdc)
             Float_t getZfit(Int_t iMdc)
             Float_t getXhit(Int_t iMdc)
             Float_t getYhit(Int_t iMdc)
             Float_t getXfithit(Int_t iMdc)
             Float_t getYfithit(Int_t iMdc)
             Float_t getXtrackFirstMDCFitPos()
             Float_t getYtrackFirstMDCFitPos()
             Float_t getZtrackFirstMDCFitPos()
             Float_t getDXtrackFirstMDCFitPos()
             Float_t getDYtrackFirstMDCFitPos()
             Float_t getDZtrackFirstMDCFitPos()
             Float_t getXtrackLastMDCFitPos()
             Float_t getYtrackLastMDCFitPos()
             Float_t getZtrackLastMDCFitPos()
             Float_t getDXtrackLastMDCFitPos()
             Float_t getDYtrackLastMDCFitPos()
             Float_t getDZtrackLastMDCFitPos()
             Float_t getXtrackOnMETA()
             Float_t getYtrackOnMETA()
             Float_t getZtrackOnMETA()
             Float_t getTrackLength()
             Float_t getZSeg1()
             Float_t getRSeg1()
             Float_t getThetaSeg1()
             Float_t getPhiSeg1()
             Float_t getZSeg2()
             Float_t getRSeg2()
             Float_t getThetaSeg2()
             Float_t getPhiSeg2()
                void setMTol(Double_t tol)
            Double_t getMTol()
             TClass* Class()
             TClass* IsA() const
                void ShowMembers(TMemberInspector& insp, char* parent)
                void Streamer(TBuffer& b)
                void StreamerNVirtual(TBuffer& b)
         HRungeKutta HRungeKutta(const HRungeKutta&)
        HRungeKutta& operator=(const HRungeKutta&)