ROOT logo
AliRoot » ITS » AliITSTPArrayFit

class AliITSTPArrayFit: public TObject

Function Members (Methods)

public:
AliITSTPArrayFit()
AliITSTPArrayFit(Int_t npoints)
AliITSTPArrayFit(const AliITSTPArrayFit& fit)
virtual~AliITSTPArrayFit()
voidTObject::AbstractMethod(const char* method) const
virtual voidTObject::AppendPad(Option_t* option = "")
voidAttachPoints(const AliTrackPointArray* points, Int_t pfirst = -1, Int_t plast = -1)
virtual voidTObject::Browse(TBrowser* b)
voidBuildMaterialLUT(Int_t ntri = 3000)
Double_tCalcChi2NDF() const
Bool_tCalcErrorMatrix()
Double_tCalcParPCA(Int_t ipnt) const
static TClass*Class()
virtual const char*TObject::ClassName() const
virtual voidTObject::Clear(Option_t* = "")
virtual TObject*TObject::Clone(const char* newname = "") const
virtual Int_tTObject::Compare(const TObject* obj) const
Bool_tConverged() const
virtual voidTObject::Copy(TObject& object) const
virtual voidTObject::Delete(Option_t* option = "")MENU
virtual Int_tTObject::DistancetoPrimitive(Int_t px, Int_t py)
virtual voidTObject::Draw(Option_t* option = "")
virtual voidTObject::DrawClass() constMENU
virtual TObject*TObject::DrawClone(Option_t* option = "") constMENU
virtual voidTObject::Dump() constMENU
virtual voidTObject::Error(const char* method, const char* msgfmt) const
virtual voidTObject::Execute(const char* method, const char* params, Int_t* error = 0)
virtual voidTObject::Execute(TMethod* method, TObjArray* params, Int_t* error = 0)
virtual voidTObject::ExecuteEvent(Int_t event, Int_t px, Int_t py)
virtual voidTObject::Fatal(const char* method, const char* msgfmt) const
virtual TObject*TObject::FindObject(const char* name) const
virtual TObject*TObject::FindObject(const TObject* obj) const
Double_tFit(Int_t extQ = 0, Double_t extPT = -1, Double_t extPTerr = 0)
Double_tFitHelix(Int_t extQ = 0, Double_t extPT = -1, Double_t extPTerr = 0)
Bool_tFitHelixCrude(Int_t imposedQ = 0)
Double_tFitLine()
Bool_tFitLineCrude()
Int_tGetAxCID(Int_t id) const
Int_tGetAxID(Int_t id) const
Double_tGetBz() const
Int_tGetCharge() const
Double_tGetChi2NDF() const
Double_t*GetCovI() const
Double_t*GetCovI(Int_t ip) const
Double_tGetCovIScale(Int_t ip) const
voidGetDirCos(Double_t* dircos, Double_t t) const
virtual Option_t*TObject::GetDrawOption() const
voidGetDResDParams(Double_t* dXYZdP, Int_t ipnt)
voidGetDResDParams(Double_t* dXYZdP, const Double_t* xyz, const Double_t* covI = 0, Double_t sclCovI = -1)
voidGetDResDParamsLine(Double_t* dXYZdP, Int_t ipnt) const
voidGetDResDParamsLine(Double_t* dXYZdP, const Double_t* xyz, const Double_t* covI = 0) const
voidGetDResDPos(Double_t* dXYZdP, Int_t ipnt)
voidGetDResDPos(Double_t* dXYZdP, const Double_t* xyz, const Double_t* covI = 0, Double_t sclCovI = -1) const
voidGetDResDPosLine(Double_t* dXYZdP, const Double_t* covI = 0) const
voidGetDResDPosLine(Double_t* dXYZdP, Int_t ipnt) const
static Long_tTObject::GetDtorOnly()
Double_t*GetElsDR() const
Int_t*GetElsId() const
Double_tGetEps() const
Int_tGetFirst() const
virtual const char*TObject::GetIconName() const
Int_tGetLast() const
Double_tGetLineOffset(Int_t axis) const
Double_tGetLineSlope(Int_t axis) const
Double_tGetMass() const
Int_tGetMaxIterations() const
virtual const char*TObject::GetName() const
Int_tGetNIterations() const
static voidGetNormal(Double_t* norm, const Float_t* covMat)
Int_tGetNParams() const
virtual char*TObject::GetObjectInfo(Int_t px, Int_t py) const
static Bool_tTObject::GetObjectStat()
virtual Option_t*TObject::GetOption() const
Double_tGetP() const
Double_tGetParam(Int_t ip) const
Double_t*GetParams() const
Int_tGetParAxis() const
Double_tGetParPCA(const double* xyz, const double* covI = 0, Double_t sclCovI = -1) const
Double_tGetPCA2PlaneInfo(Double_t* xyz, Double_t* dir = 0, Int_t axis = kY, Double_t axval = 0) const
Double_t*GetPoint(Int_t ip) const
AliTrackPointArray*GetPoints() const
voidGetPosition(Double_t* xyz, Double_t t) const
voidGetPosition(Double_t* xyz, Int_t pnt) const
Double_tGetPosition(Double_t* xyzPCA, const AliTrackPoint* pntCovInv, Bool_t useErr = kFALSE) const
Double_tGetPosition(Double_t* xyzPCA, const Double_t* xyz, const Double_t* covI = 0, Double_t sclCovI = -1) const
Double_tGetPt() const
voidGetResiduals(Double_t* res, Int_t ipnt) const
voidGetResiduals(Double_t* xyzPCA, const AliTrackPoint* pntCovInv, Bool_t useErr = kFALSE) const
voidGetResiduals(Double_t* resPCA, const Double_t* xyz, const Double_t* covI = 0, Double_t sclCovI = -1) const
Int_tGetSignQB() const
Double_tGetT(Int_t ip) const
voidGetT0Info(Double_t* xyz, Double_t* dir = 0) const
virtual const char*TObject::GetTitle() const
Double_t*GetTs() const
virtual UInt_tTObject::GetUniqueID() const
virtual Bool_tTObject::HandleTimer(TTimer* timer)
virtual ULong_tTObject::Hash() const
virtual voidTObject::Info(const char* method, const char* msgfmt) const
virtual Bool_tTObject::InheritsFrom(const char* classname) const
virtual Bool_tTObject::InheritsFrom(const TClass* cl) const
virtual voidTObject::Inspect() constMENU
voidTObject::InvertBit(UInt_t f)
Bool_tInvertPointsCovMat()
virtual TClass*IsA() const
Bool_tIsCovIgnored() const
Bool_tIsCovInv() const
Bool_tIsELossON() const
virtual Bool_tTObject::IsEqual(const TObject* obj) const
Bool_tIsFieldON() const
Bool_tIsFitDone() const
virtual Bool_tTObject::IsFolder() const
Bool_tIsHelix() const
Bool_tTObject::IsOnHeap() const
virtual Bool_tTObject::IsSortable() const
Bool_tIsSwitched2Line() const
Bool_tIsTypeCollision() const
Bool_tIsTypeCosmics() const
Bool_tTObject::IsZombie() const
virtual voidTObject::ls(Option_t* option = "") const
voidTObject::MayNotUse(const char* method) const
virtual Bool_tTObject::Notify()
voidTObject::Obsolete(const char* method, const char* asOfVers, const char* removedFromVers) const
static voidTObject::operator delete(void* ptr)
static voidTObject::operator delete(void* ptr, void* vp)
static voidTObject::operator delete[](void* ptr)
static voidTObject::operator delete[](void* ptr, void* vp)
void*TObject::operator new(size_t sz)
void*TObject::operator new(size_t sz, void* vp)
void*TObject::operator new[](size_t sz)
void*TObject::operator new[](size_t sz, void* vp)
AliITSTPArrayFit&operator=(const AliITSTPArrayFit& src)
virtual voidTObject::Paint(Option_t* option = "")
virtual voidTObject::Pop()
virtual voidPrint(Option_t* opt = "") const
virtual Int_tTObject::Read(const char* name)
virtual voidTObject::RecursiveRemove(TObject* obj)
voidReset()
voidTObject::ResetBit(UInt_t f)
voidResetCovIScale(Double_t scl = -1.0)
virtual voidTObject::SaveAs(const char* filename = "", Option_t* option = "") constMENU
virtual voidTObject::SavePrimitive(basic_ostream<char,char_traits<char> >& out, Option_t* option = "")
voidTObject::SetBit(UInt_t f)
voidTObject::SetBit(UInt_t f, Bool_t set)
voidSetBz(Double_t bz)
voidSetCharge(Int_t q = 1)
voidSetCovInv(Bool_t v = kTRUE)
voidSetCovIScale(Int_t ip, Double_t scl = -1.0)
virtual voidTObject::SetDrawOption(Option_t* option = "")MENU
static voidTObject::SetDtorOnly(void* obj)
voidSetELossON(Bool_t v = kTRUE)
voidSetEps(Double_t eps = 1e-6)
Bool_tSetFirstLast(Int_t pfirst = -1, Int_t plast = -1)
voidSetFitDone(Bool_t v = kTRUE)
voidSetIgnoreCov(Bool_t v = kTRUE)
voidSetMass(Double_t m = 0.13957)
voidSetMaxIterations(Int_t n = 20)
voidSetMaxRforHelix(Double_t r)
static voidTObject::SetObjectStat(Bool_t stat)
voidSetParAxis(Int_t ax)
voidSetTypeCollision(Bool_t v = kTRUE)
voidSetTypeCosmics(Bool_t v = kTRUE)
virtual voidTObject::SetUniqueID(UInt_t uid)
virtual voidShowMembers(TMemberInspector&)
virtual voidStreamer(TBuffer&)
voidStreamerNVirtual(TBuffer& ClassDef_StreamerNVirtual_b)
voidSwitch2Line(Bool_t v = kTRUE)
virtual voidTObject::SysError(const char* method, const char* msgfmt) const
Bool_tTObject::TestBit(UInt_t f) const
Int_tTObject::TestBits(UInt_t f) const
virtual voidTObject::UseCurrentStyle()
virtual voidTObject::Warning(const char* method, const char* msgfmt) const
virtual Int_tTObject::Write(const char* name = 0, Int_t option = 0, Int_t bufsize = 0)
virtual Int_tTObject::Write(const char* name = 0, Int_t option = 0, Int_t bufsize = 0) const
protected:
Int_tChoseParAxis() const
virtual voidTObject::DoError(int level, const char* location, const char* fmt, va_list va) const
Double_tGetDRofELoss(Double_t t, Double_t cdip, Double_t rhoL, const Double_t* normS, Double_t& p, Double_t& e) const
Double_tGetDtDParamsLine(Double_t* dtparam, const Double_t* xyz, const Double_t* covI = 0) const
voidGetDtDPosLine(Double_t* dtpos, const Double_t* covI = 0) const
Double_tGetHelixParAtR(Double_t r) const
static Double_tGetMachinePrec()
Double_tGetParPCACircle(Double_t x, Double_t y) const
Double_tGetParPCAHelix(const Double_t* xyz, const Double_t* covI = 0, Double_t sclCovI = -1) const
Double_tGetParPCALine(const Double_t* xyz, const Double_t* covI = 0) const
voidInitAux()
static Bool_tIsZero(Double_t v, Double_t threshold = 1e-16)
voidTObject::MakeZombie()

Data Members

public:
enum { kFitDoneBit
kCovInvBit
kCosmicsBit
kELossBit
kIgnoreCovBit
kMask
kXX
kXY
kXZ
kYX
kYY
kYZ
kZX
kZY
kZZ
kScl
kNCov
kA0
kB0
kA1
kB1
kD0
kPhi0
kR0
kDZ
kDip
kX
kY
kZ
kMaxParam
kMaxParamSq
kLrBeamPime
kLrSPD1
kLrSPD2
kLrShield1
kLrSDD1
kLrSDD2
kLrShield2
kLrSSD1
kLrSSD2
kMaxLrITS
};
enum TObject::EStatusBits { kCanDelete
kMustCleanup
kObjInCanvas
kIsReferenced
kHasUUID
kCannotPick
kNoContextMenu
kInvalidObject
};
enum TObject::[unnamed] { kIsOnHeap
kNotDeleted
kZombie
kBitMask
kSingleKey
kOverwrite
kWriteDelete
};
protected:
Double_tfBzmagnetic field
Int_tfChargetrack charge +1=+, -1=-
Double_tfChi2NDFfit chi2/NDF
Double_t*fCovI! inverted cov.matrix for each point
Double_t*fCurTtrack parameter for each point
Double_t*fElsDRdelta_Radius for each e-loss layer
Int_t*fElsIdindex of increasing t-ordering in the fCurT
Double_tfEpsprecision
Int_tfFirstPosTid of the first positive t index in fElsId
Int_tfIterreal number of iterations
Double_tfMassassumed particle mass for ELoss Calculation
Int_tfMaxItermax number of iterations
Double_tfMaxRforHelixabove this radius use straight line fit
Int_tfNElsPntnumber of e-loss layers seen by the track
Int_tfNPBookednumber of points booked
Int_tfParAxisparameterization axis
AliParamSolver*fParSolsolver for parametric linearized systems
Double_tfParams[6]fitted params
Double_tfParamsCov[21]fit cov matrix
Int_tfPntFirstfirst point to fit
Int_tfPntLastlast point to fit
Bool_tfSwitch2Linedecided to switch to line
static Double_tfgRhoLITS[9]<rho*L> for each material layer
static const Int_tfgkActiveLrITS[6]list of active layer enums
static const Double_tfgkAlmostZerotiny double
static const Int_tfgkAxisCID[3][6]cov matrix elements for axis selection
static const Int_tfgkAxisID[3][3]permutations of axis
static const Double_tfgkCQConvR = PT/Bz/fgkCQConv with GeV,kGauss,cm
static const Int_tfgkPassivLrITS[3]list of passive layer enums
static const Double_tfgkRLayITS[9]radii of material layers
static const Double_tfgkZSpanITS[9]half Z span of the material layer
const Int_t*fkAxCIDaxis combinations IDs
const Int_t*fkAxIDaxis IDs
const AliTrackPointArray*fkPointscurrent points

Class Charts

Inheritance Chart:
TObject
AliITSTPArrayFit

Function documentation

AliITSTPArrayFit()
 default constructor
AliITSTPArrayFit(Int_t npoints)
 constructor with booking of np points
AliITSTPArrayFit(const AliITSTPArrayFit& fit)
 copy constructor
~AliITSTPArrayFit()
 destructor
void Reset()
 reset to process new track
void AttachPoints(const AliTrackPointArray* points, Int_t pfirst = -1, Int_t plast = -1)
 create from piece of AliTrackPointArray
Bool_t SetFirstLast(Int_t pfirst = -1, Int_t plast = -1)
 set first and last point to fit
Bool_t InvertPointsCovMat()
 invert the cov.matrices of the points
void InitAux()
 init auxiliary space
Bool_t FitLineCrude()
 perform linear fit w/o accounting the errors
 fit is done in the parameterization
 x = res[0] + res[1]*z
 y = res[2] + res[3]*z
 where x,y,z are NOT the lab axes but z is the lab axis along which the track
 has the largest lever arm and x,y are the remaining 2 axis in
 the order of fgkAxisID[z][0], fgkAxisID[z][1]

void SetParAxis(Int_t ax)
 select the axis which will be used as a parameter for the line: longest baseline
Int_t ChoseParAxis() const
 select the variable with largest base as a parameter
Double_t GetPosition(Double_t* xyzPCA, const Double_t* xyz, const Double_t* covI = 0, Double_t sclCovI = -1) const
 calculate the position of the track at PCA to xyz
Double_t GetPosition(Double_t* xyzPCA, const AliTrackPoint* pntCovInv, Bool_t useErr = kFALSE) const
 calculate the position of the track at PCA to pntCovInv
 NOTE: the covariance matrix of the point must be inverted
void GetResiduals(Double_t* xyzPCA, const AliTrackPoint* pntCovInv, Bool_t useErr = kFALSE) const
 calculate the residuals  of the track at PCA to pntCovInv
 NOTE: the covariance matrix of the point must be inverted
void GetResiduals(Double_t* resPCA, const Double_t* xyz, const Double_t* covI = 0, Double_t sclCovI = -1) const
 calculate the residuals of the track at PCA to xyz
Double_t GetParPCALine(const Double_t *xyz, const Double_t *covI/*, Double_t sclCovI*/)
 get parameter for the point with least weighted distance to the point

void GetDResDPosLine(Double_t *dXYZdP, /*const Double_t *xyz,*/ const Double_t *covI/*,Double_t sclCovI*/)
 calculate detivative of the PCA residuals vs point position and fill in user provide
 array in the format {dXdXp,dY/dXp,dZdXp, ... dXdZp,dYdZp,dZdZp}

void GetDResDParamsLine(Double_t *dXYZdP, const Double_t *xyz, const Double_t *covI/*,Double_t sclCovI*/)
 calculate detivative of the PCA residuals vs line parameters and fill in user provide
 array in the format {dXdP0,dYdP0,dZdP0, ... dXdPn,dYdPn,dZdPn}

Double_t GetDtDParamsLine(Double_t* dtparam, const Double_t* xyz, const Double_t* covI = 0) const
 get t-param detivative over the parameters for the point with least weighted distance to the point

void GetDtDPosLine(Double_t *dtpos,/*const Double_t *xyz,*/ const Double_t *covI)
 get t-param detivative over the parameters for the point with least weighted distance to the point

  Double_t rhs;
  Double_t dx = fParams[kA0]-xyz[ fkAxID[kX] ];
  Double_t dy = fParams[kA1]-xyz[ fkAxID[kY] ];
  Double_t dz =             -xyz[ fkAxID[kZ] ];
void GetDResDParamsLine(Double_t* dXYZdP, Int_t ipnt) const
 calculate detivative of the PCA residuals vs line parameters and fill in user provide
 array in the format {dXdP0,dYdP0,dZdP0, ... dXdPn,dYdPn,dZdPn}

void GetDResDPosLine(Double_t* dXYZdP, Int_t ipnt) const
 calculate detivative of the PCA residuals vs point position and fill in user provide
 array in the format {dXdXp,dY/dXp,dZdXp, ... dXdZp,dYdZp,dZdZp}

void GetDResDParams(Double_t* dXYZdP, Int_t ipnt)
 calculate detivative of the PCA residuals vs track parameters and fill in user provide
 array in the format {dXdP0,dYdP0,dZdP0, ... dXdPn,dYdPn,dZdPn}

void GetDResDPos(Double_t* dXYZdP, Int_t ipnt)
 calculate detivative of the PCA residuals vs point position and fill in user provide
 array in the format {dXdXp,dY/dXp,dZdXp, ... dXdZp,dYdZp,dZdZp}

void GetDResDParams(Double_t* dXYZdP, const Double_t* xyz, const Double_t* covI = 0, Double_t sclCovI = -1)
 get residual detivatives over the track parameters for the point with least weighted distance to the point

void GetDResDPos(Double_t* dXYZdP, const Double_t* xyz, const Double_t* covI = 0, Double_t sclCovI = -1) const
 get residuals detivative over the point position for the point with least weighted distance to the point

Double_t GetParPCAHelix(const Double_t* xyz, const Double_t* covI = 0, Double_t sclCovI = -1) const
 find track parameter t (eq.2) corresponding to point of closest approach to xyz

Double_t GetParPCACircle(Double_t x, Double_t y) const
 find track parameter t (eq.2) corresponding to point on the circle with closest approach to x,y

Double_t GetHelixParAtR(Double_t r) const
 find helix parameter t (eq.2) corresponding to point on the circle of radius t

Double_t CalcChi2NDF() const
 calculate fit chi2/ndf
void GetResiduals(Double_t* res, Int_t ipnt) const
 calculate residuals at point
void GetPosition(Double_t* xyz, Double_t t) const
 calculate track position for parameter value t
void GetDirCos(Double_t* dircos, Double_t t) const
 calculate track direction cosines for parameter value t
Double_t GetMachinePrec()
 estimate machine precision
Bool_t FitHelixCrude(Int_t imposedQ = 0)
 crude estimate of helix parameters, w/o errors and Eloss.
 Fast Riemann fit: Comp.Phy.Comm.131 (2000) 95

 if charge is not imposed (extQ==0) then it will be determined from the collision type

Double_t FitHelix(Int_t extQ = 0, Double_t extPT = -1, Double_t extPTerr = 0)
 fit by helix accounting for the errors of all coordinates (and energy loss if requested)

 If extQ is non-0, its sign is imposed as a charge of the track
 If extPT>0 and extPTerr>=0, constrain to measured tr.momentum PT
 with corresponding error (err=0 -> rel.err=1e-6)

Double_t FitLine()
 fit by helix accounting for the errors of all coordinates (and energy loss if requested)

void GetNormal(Double_t* norm, const Float_t* covMat)
 obtain the lab normal vector to the sensor from the covariance matrix
 in such a way that when the local frame of the sensor coincides with
 the lab frame, the vector {0,1,0} is obtained
Double_t GetDRofELoss(Double_t t, Double_t cdip, Double_t rhoL, const Double_t* normS, Double_t& p, Double_t& e) const
 Calculate energy loss of the particle at given t-param on the layer with rhoL (thickness*density) with
 normal vector normS in the lab. The particle before eloss has energy "e" and momentum "p"
 cdip = cosine of the dip angle = 1/sqrt(1+tgL^2)
 Return the change DR of the radius due to the ELoss

 NOTE: with B>0 the negative particles propagate along increasing t-param and positive
 particles - against.
 t-param = 0 corresponds to the point of closest approach of the track to the beam.
 Since the fitted helix parameters of the track are defined in this PCA point, when the correction
 is applied upstream of the PCS, the energy must be increased (DR>0) rather than decreased (DR<0)

Double_t GetLineOffset(Int_t axis) const
 return intercept of the parameterization coord = intercept + slope*t for given axis
Double_t GetLineSlope(Int_t axis) const
 return intercept of the parameterization coord = intercept + slope*t for given axis
void Print(Option_t* opt = "") const
 print results of the fit

void BuildMaterialLUT(Int_t ntri = 3000)
 Fill a look-up table with mean material a la AliITSTrackerMI

Double_t GetPCA2PlaneInfo(Double_t* xyz, Double_t* dir = 0, Int_t axis = kY, Double_t axval = 0) const
 calculate the PCA to plane normal ti axis and crossing it at axval
 fill the position and direction cosines at this point

void GetT0Info(Double_t* xyz, Double_t* dir = 0) const
 get direction cosines for t = 0;
Bool_t CalcErrorMatrix()
 compute covariance matrix in lenear approximation of residuals on parameters
Double_t CalcParPCA(Int_t ipnt) const
 get parameter for the point with least weighted distance to the point
Double_t GetPt() const
Double_t GetP() const
void GetPosition(Double_t* xyz, Int_t pnt) const
Double_t GetParPCA(const double* xyz, const double* covI = 0, Double_t sclCovI = -1) const
Double_t* GetPoint(Int_t ip) const
Double_t Fit(Int_t extQ = 0, Double_t extPT = -1, Double_t extPTerr = 0)
void SetCovIScale(Int_t ip, Double_t scl = -1.0)
AliITSTPArrayFit& operator=(const AliITSTPArrayFit& src)
AliTrackPointArray* GetPoints() const
void SetBz(Double_t bz)
{fBz = bz;}
Double_t GetBz() const
{return fBz;}
Bool_t IsHelix() const
{return fParAxis<0;}
Bool_t IsFieldON() const
{return TMath::Abs(fBz)>1e-5;}
Bool_t IsTypeCosmics() const
{return TestBit(kCosmicsBit);}
Bool_t IsTypeCollision() const
{return !IsTypeCosmics();}
Int_t GetCharge() const
{return fCharge;}
Int_t GetSignQB() const
{return fBz<0 ? -fCharge:fCharge;}
Double_t GetChi2NDF() const
{return fChi2NDF;}
Bool_t Converged() const
{return fIter<fMaxIter;}
Int_t GetParAxis() const
{return fParAxis;}
Int_t GetAxID(Int_t id) const
{return fkAxID ? fkAxID[id] : -1;}
Int_t GetAxCID(Int_t id) const
{return fkAxCID ? fkAxCID[id] : -1;}
Int_t GetFirst() const
{return fPntFirst;}
Int_t GetLast() const
{return fPntLast;}
Int_t GetNParams() const
{return IsFieldON() ? 5:4;}
Int_t* GetElsId() const
{return fElsId;}
Double_t* GetElsDR() const
{return fElsDR;}
Double_t GetCovIScale(Int_t ip) const
{return ip<fNPBooked ? fCovI[ip*kNCov+kScl] : -1.0;}
Double_t* GetCovI(Int_t ip) const
{return fCovI + kNCov*ip;}
Double_t* GetCovI() const
{return fCovI;}
Double_t* GetParams() const
{return (Double_t*)&fParams[0];}
Double_t GetParam(Int_t ip) const
{return fParams[ip];}
Double_t* GetTs() const
{return (Double_t*)fCurT;}
Double_t GetT(Int_t ip) const
{return fCurT[ip];}
Bool_t IsSwitched2Line() const
{return fSwitch2Line;}
Bool_t IsELossON() const
Bool_t IsFitDone() const
{return TestBit(kFitDoneBit);}
Bool_t IsCovInv() const
{return TestBit(kCovInvBit);}
Bool_t IsCovIgnored() const
Int_t GetMaxIterations() const
{return fMaxIter;}
Int_t GetNIterations() const
{return fIter;}
Double_t GetEps() const
{return fEps;}
Double_t GetMass() const
{return fMass;}
void Switch2Line(Bool_t v = kTRUE)
void SetMaxRforHelix(Double_t r)
{fMaxRforHelix = r>0 ? r : 1e9;}
void SetCharge(Int_t q = 1)
{fCharge = q<0 ? -1:1;}
void SetELossON(Bool_t v = kTRUE)
void SetTypeCosmics(Bool_t v = kTRUE)
void SetTypeCollision(Bool_t v = kTRUE)
void SetFitDone(Bool_t v = kTRUE)
void SetCovInv(Bool_t v = kTRUE)
void SetIgnoreCov(Bool_t v = kTRUE)
void SetMaxIterations(Int_t n = 20)
{fMaxIter = n<2 ? 2:n;}
void SetEps(Double_t eps = 1e-6)
{fEps = eps<0 ? GetMachinePrec() : eps;}
void SetMass(Double_t m = 0.13957)
{fMass = m<5E-4 ? 5E-4 : m;}
void ResetCovIScale(Double_t scl = -1.0)
{for (int i=fNPBooked;i--;) SetCovIScale(i,scl);}
Bool_t IsZero(Double_t v, Double_t threshold = 1e-16)
{return TMath::Abs(v)<threshold; }