ROOT logo
AliRoot » STEER » AliExternalTrackParam

class AliExternalTrackParam: public AliVTrack


Implementation of the external track parameterisation class.

This parameterisation is used to exchange tracks between the detectors.
A set of functions returning the position and the momentum of tracks
in the global coordinate system as well as the track impact parameters
 are implemented.
Origin: I.Belikov, CERN, Jouri.Belikov@cern.ch

Function Members (Methods)

public:
AliExternalTrackParam()
AliExternalTrackParam(const AliExternalTrackParam&)
AliExternalTrackParam(const AliVTrack* vTrack)
AliExternalTrackParam(Double_t x, Double_t alpha, const Double_t* param, const Double_t* covar)
AliExternalTrackParam(Double_t* xyz, Double_t* pxpypz, Double_t* cv, Short_t sign)
virtual~AliExternalTrackParam()
voidTObject::AbstractMethod(const char* method) const
voidAddCovariance(const Double_t* cov)
virtual voidTObject::AppendPad(Option_t* option = "")
static Double_tBetheBlochAleph(Double_t bg, Double_t kp1 = 0.76176e-1, Double_t kp2 = 10.632, Double_t kp3 = 0.13279e-4, Double_t kp4 = 1.8631, Double_t kp5 = 1.9479)
static Double_tBetheBlochGas(Double_t bg)
static Double_tBetheBlochGeant(Double_t bg, Double_t kp0 = 2.33, Double_t kp1 = 0.20, Double_t kp2 = 3.00, Double_t kp3 = 173e-9, Double_t kp4 = 0.49848)
static Double_tBetheBlochSolid(Double_t bg)
virtual voidTObject::Browse(TBrowser* b)
virtual Short_tCharge() const
voidCheckCovariance()
static TClass*Class()
virtual const char*TObject::ClassName() const
virtual voidTObject::Clear(Option_t* = "")
virtual TObject*TObject::Clone(const char* newname = "") const
virtual Int_tAliVParticle::Compare(const TObject* obj) const
virtual voidTObject::Copy(TObject& object) const
Bool_tCorrectForMaterial(Double_t d, Double_t x0, Double_t mass, Double_t (*)(Double_t) f = AliExternalTrackParam::BetheBlochSolid)
Bool_tCorrectForMeanMaterial(Double_t xOverX0, Double_t xTimesRho, Double_t mass, Bool_t anglecorr = kFALSE, Double_t (*)(Double_t) f = AliExternalTrackParam::BetheBlochSolid)
Bool_tCorrectForMeanMaterialdEdx(Double_t xOverX0, Double_t xTimesRho, Double_t mass, Double_t dEdx, Bool_t anglecorr = kFALSE)
Bool_tCorrectForMeanMaterialZA(Double_t xOverX0, Double_t xTimesRho, Double_t mass, Double_t zOverA = 0.49848, Double_t density = 2.33, Double_t exEnergy = 173e-9, Double_t jp1 = 0.20, Double_t jp2 = 3.00, Bool_t anglecorr = kFALSE)
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 voidDrawTrack(Float_t magF, Float_t minR, Float_t maxR, Float_t stepR)
virtual voidTObject::Dump() constMENU
virtual Double_tE() const
virtual voidTObject::Error(const char* method, const char* msgfmt) const
virtual Double_tEta() 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 voidFillPolymarker(TPolyMarker3D* pol, Float_t magf, Float_t minR, Float_t maxR, Float_t stepR)
virtual TObject*TObject::FindObject(const char* name) const
virtual TObject*TObject::FindObject(const TObject* obj) const
static voidg3helx3(Double_t qfield, Double_t step, Double_t* vect)
Double_tGet1P() const
Double_tGetAlpha() const
virtual voidAliVTrack::GetBxByBz(Double_t* b) const
virtual Double_tAliVTrack::GetBz() const
virtual Double_tGetC(Double_t b) const
const Double_t*GetCovariance() const
virtual Bool_tGetCovarianceXYZPxPyPz(Double_t* cv) const
Double_tGetD(Double_t xv, Double_t yv, Double_t b) const
Double_tGetDCA(const AliExternalTrackParam* p, Double_t b, Double_t& xthis, Double_t& xp) const
voidGetDirection(Double_t* d) const
Bool_tGetDistance(AliExternalTrackParam* param2, Double_t x, Double_t* dist, Double_t b)
virtual Option_t*TObject::GetDrawOption() const
static Long_tTObject::GetDtorOnly()
voidGetDZ(Double_t x, Double_t y, Double_t z, Double_t b, Float_t* dz) const
voidGetHelixParameters(Double_t* h, Double_t b) const
virtual const char*TObject::GetIconName() const
virtual Int_tGetID() const
Int_tGetIndex(Int_t i, Int_t j) const
virtual UChar_tGetITSClusterMap() const
virtual Int_tGetLabel() const
Double_tGetLinearD(Double_t xv, Double_t yv) const
static Double_tGetMostProbablePt()
virtual const char*TObject::GetName() const
virtual Int_tAliVTrack::GetNcls(Int_t) const
virtual char*TObject::GetObjectInfo(Int_t px, Int_t py) const
static Bool_tTObject::GetObjectStat()
virtual Option_t*TObject::GetOption() const
virtual const AliExternalTrackParam*AliVTrack::GetOuterParam() const
Double_tGetP() const
const Double_t*GetParameter() const
Double_tGetPredictedChi2(const AliExternalTrackParam* t) const
Double_tGetPredictedChi2(Double_t* p, Double_t* cov) const
Double_tGetPredictedChi2(Double_t* p, Double_t* covyz, Double_t* covxyz) const
virtual Bool_tGetPxPyPz(Double_t* p) const
Bool_tGetPxPyPzAt(Double_t x, Double_t b, Double_t* p) const
Double_t*GetResiduals(Double_t* p, Double_t* cov, Bool_t updated = kTRUE) const
Double_tGetSigma1Pt2() const
Double_tGetSigma1PtSnp() const
Double_tGetSigma1PtTgl() const
Double_tGetSigma1PtY() const
Double_tGetSigma1PtZ() const
Double_tGetSigmaSnp2() const
Double_tGetSigmaSnpY() const
Double_tGetSigmaSnpZ() const
Double_tGetSigmaTgl2() const
Double_tGetSigmaTglSnp() const
Double_tGetSigmaTglY() const
Double_tGetSigmaTglZ() const
Double_tGetSigmaY2() const
Double_tGetSigmaZ2() const
Double_tGetSigmaZY() const
Double_tGetSign() const
Double_tGetSigned1Pt() const
Double_tGetSignedPt() const
Double_tGetSnp() const
Double_tGetSnpAt(Double_t x, Double_t b) const
virtual ULong_tGetStatus() const
Double_tGetTgl() const
virtual const char*TObject::GetTitle() const
virtual UShort_tAliVTrack::GetTPCNcls() const
virtual Double_tAliVTrack::GetTPCsignal() const
virtual UInt_tTObject::GetUniqueID() const
Double_tGetX() const
virtual Bool_tGetXYZ(Double_t* p) const
Bool_tGetXYZAt(Double_t x, Double_t b, Double_t* r) const
Double_tGetY() const
Bool_tGetYAt(Double_t x, Double_t b, Double_t& y) const
Double_tGetZ() const
Bool_tGetZAt(Double_t x, Double_t b, Double_t& z) const
Bool_tAliVParticle::Global2LocalMomentum(Double_t* p, Short_t charge, Double_t& alpha) const
Bool_tAliVParticle::Global2LocalPosition(Double_t* r, Double_t alpha) 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
Bool_tIntersect(Double_t* pnt, Double_t* norm, Double_t bz) const
voidTObject::InvertBit(UInt_t f)
virtual TClass*IsA() const
virtual Bool_tTObject::IsEqual(const TObject* obj) const
virtual Bool_tTObject::IsFolder() const
Bool_tTObject::IsOnHeap() const
virtual Bool_tAliVParticle::IsSortable() const
Bool_tTObject::IsZombie() const
Bool_tAliVParticle::Local2GlobalMomentum(Double_t* p, Double_t alpha) const
Bool_tAliVParticle::Local2GlobalPosition(Double_t* r, Double_t alpha) const
virtual voidTObject::ls(Option_t* option = "") const
virtual Double_tM() const
voidTObject::MayNotUse(const char* method) const
virtual Bool_tTObject::Notify()
virtual Double_tOneOverPt() 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)
AliExternalTrackParam&operator=(const AliExternalTrackParam& trkPar)
virtual Double_tP() const
virtual voidTObject::Paint(Option_t* option = "")
virtual Int_tPdgCode() const
virtual Double_tPhi() const
virtual const Double_t*PID() const
virtual voidTObject::Pop()
virtual voidPrint(Option_t* option = "") const
Bool_tPropagate(Double_t alpha, Double_t x, Double_t b)
voidPropagate(Double_t len, Double_t* x, Double_t* p, Double_t bz) const
Bool_tPropagateBxByBz(Double_t alpha, Double_t x, Double_t* b)
Bool_tPropagateTo(Double_t x, Double_t b)
Bool_tPropagateTo(Double_t* p, Double_t* covyz, Double_t* covxyz, Double_t b)
Bool_tPropagateToBxByBz(Double_t x, const Double_t* b)
Double_tPropagateToDCA(AliExternalTrackParam* p, Double_t b)
virtual Bool_tPropagateToDCA(const AliVVertex* vtx, Double_t b, Double_t maxd, Double_t* dz = 0, Double_t* cov = 0)
Bool_tPropagateToDCABxByBz(const AliVVertex* vtx, Double_t* b, Double_t maxd, Double_t* dz = 0, Double_t* cov = 0)
virtual Double_tPt() const
virtual Double_tPx() const
virtual Bool_tPxPyPz(Double_t* p) const
virtual Double_tPy() const
virtual Double_tPz() const
virtual Int_tTObject::Read(const char* name)
virtual voidTObject::RecursiveRemove(TObject* obj)
voidReset()
voidTObject::ResetBit(UInt_t f)
voidResetCovariance(Double_t s2)
Bool_tRotate(Double_t alpha)
virtual voidTObject::SaveAs(const char* filename = "", Option_t* option = "") constMENU
virtual voidTObject::SavePrimitive(basic_ostream<char,char_traits<char> >& out, Option_t* option = "")
voidSet(Double_t* xyz, Double_t* pxpypz, Double_t* cv, Short_t sign)
voidTObject::SetBit(UInt_t f)
voidTObject::SetBit(UInt_t f, Bool_t set)
virtual voidTObject::SetDrawOption(Option_t* option = "")MENU
static voidTObject::SetDtorOnly(void* obj)
virtual voidAliVTrack::SetID(Short_t)
static voidSetMostProbablePt(Double_t pt)
static voidTObject::SetObjectStat(Bool_t stat)
virtual voidTObject::SetUniqueID(UInt_t uid)
virtual voidShowMembers(TMemberInspector& insp)
virtual voidStreamer(TBuffer& b)
voidStreamerNVirtual(TBuffer& b)
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 Double_tTheta() const
virtual Bool_tTranslate(Double_t* vTrasl, Double_t* covV)
Bool_tUpdate(Double_t* p, Double_t* cov)
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
virtual Double_tXv() const
virtual Bool_tXvYvZv(Double_t* x) const
virtual Double_tY() const
virtual Double_tYv() const
virtual Double_tZv() const
protected:
virtual voidTObject::DoError(int level, const char* location, const char* fmt, va_list va) const
voidTObject::MakeZombie()

Data Members

private:
Double32_tfAlphaLocal <-->global coor.system rotation angle
Double32_tfC[15]The track parameter covariance matrix
Double32_tfP[5]The track parameters
Double32_tfXX coordinate for the point of parametrisation
static Double32_tfgMostProbablePt"Most probable" pt

Class Charts

Inheritance Chart:
TObject
AliVParticle
AliVTrack
AliExternalTrackParam
AliEMCALTrack
AliESDtrack
AliKalmanTrack
AliHMPIDtrack
AliITStrackV2
AliITStrackMI
AliITStrackSA
AliTOFtrack
AliTPCtrack
AliTPCseed
 [more...]

Function documentation

AliExternalTrackParam()
 default constructor

AliExternalTrackParam(const AliExternalTrackParam& )
 copy constructor

AliExternalTrackParam& operator=(const AliExternalTrackParam& trkPar)
 assignment operator

AliExternalTrackParam(Double_t x, Double_t alpha, const Double_t* param, const Double_t* covar)
 create external track parameters from given arguments

AliExternalTrackParam(const AliVTrack* vTrack)
 Constructor from virtual track,
 This is not a copy contructor !

AliExternalTrackParam(Double_t x, Double_t alpha, const Double_t* param, const Double_t* covar)
 constructor from the global parameters

void Set(Double_t* xyz, Double_t* pxpypz, Double_t* cv, Short_t sign)
 create external track parameters from the global parameters
 x,y,z,px,py,pz and their 6x6 covariance matrix
 A.Dainese 10.10.08
void Reset()
 Resets all the parameters to 0

void AddCovariance(const Double_t* cov)
 Add "something" to the track covarince matrix.
 May be needed to account for unknown mis-calibration/mis-alignment

Double_t GetP() const
 This function returns the track momentum
 Results for (nearly) straight tracks are meaningless !

Double_t Get1P() const
 This function returns the 1/(track momentum)

Double_t GetD(Double_t xv, Double_t yv, Double_t b) const
 This function calculates the transverse impact parameter
 with respect to a point with global coordinates (x,y)
 in the magnetic field "b" (kG)

Double_t GetLinearD(Double_t xv, Double_t yv) const
 This function calculates the transverse impact parameter
 with respect to a point with global coordinates (xv,yv)
 neglecting the track curvature.

Double_t BetheBlochAleph(Double_t bg, Double_t kp1 = 0.76176e-1, Double_t kp2 = 10.632, Double_t kp3 = 0.13279e-4, Double_t kp4 = 1.8631, Double_t kp5 = 1.9479)
 This is the empirical ALEPH parameterization of the Bethe-Bloch formula.
 It is normalized to 1 at the minimum.

 bg - beta*gamma

 The default values for the kp* parameters are for ALICE TPC.
 The returned value is in MIP units

Double_t BetheBlochGeant(Double_t bg, Double_t kp0 = 2.33, Double_t kp1 = 0.20, Double_t kp2 = 3.00, Double_t kp3 = 173e-9, Double_t kp4 = 0.49848)
 This is the parameterization of the Bethe-Bloch formula inspired by Geant.

 bg  - beta*gamma
 kp0 - density [g/cm^3]
 kp1 - density effect first junction point
 kp2 - density effect second junction point
 kp3 - mean excitation energy [GeV]
 kp4 - mean Z/A

 The default values for the kp* parameters are for silicon.
 The returned value is in [GeV/(g/cm^2)].

Double_t BetheBlochSolid(Double_t bg)
 This is an approximation of the Bethe-Bloch formula,
 reasonable for solid materials.
 All the parameters are, in fact, for Si.
 The returned value is in [GeV/(g/cm^2)]

Double_t BetheBlochGas(Double_t bg)
 This is an approximation of the Bethe-Bloch formula,
 reasonable for gas materials.
 All the parameters are, in fact, for Ne.
 The returned value is in [GeV/(g/cm^2)]

Bool_t Rotate(Double_t alpha)
 Transform this track to the local coord. system rotated
 by angle "alpha" (rad) with respect to the global coord. system.

Bool_t PropagateTo(Double_t x, Double_t b)
 Propagate this track to the plane X=xk (cm) in the field "b" (kG)

Propagate(Double_t alpha, Double_t x, Double_t b)
 Transform this track to the local coord. system rotated
 by angle "alpha" (rad) with respect to the global coord. system,
 and propagate this track to the plane X=xk (cm) in the field "b" (kG)

void Propagate(Double_t len, Double_t* x, Double_t* p, Double_t bz) const
 Origin: K. Shileev (Kirill.Shileev@cern.ch)
 Extrapolate track along simple helix in magnetic field
 Arguments: len -distance alogn helix, [cm]
            bz  - mag field, [kGaus]
 Returns: x and p contain extrapolated positon and momentum
 The momentum returned for straight-line tracks is meaningless !

Bool_t Intersect(Double_t* pnt, Double_t* norm, Double_t bz) const
 Origin: K. Shileev (Kirill.Shileev@cern.ch)
 Finds point of intersection (if exists) of the helix with the plane.
 Stores result in fX and fP.
 Arguments: planePoint,planeNorm - the plane defined by any plane's point
 and vector, normal to the plane
 Returns: kTrue if helix intersects the plane, kFALSE otherwise.

GetPredictedChi2(Double_t* p, Double_t* cov) const
 Estimate the chi2 of the space point "p" with the cov. matrix "cov"

Double_t * GetResiduals(Double_t* p, Double_t* cov, Bool_t updated = kTRUE) const
 Returns the track residuals with the space point "p" having
 the covariance matrix "cov".
 If "updated" is kTRUE, the track parameters expected to be updated,
 otherwise they must be predicted.

Bool_t Update(Double_t* p, Double_t* cov)
 Update the track parameters with the space point "p" having
 the covariance matrix "cov"

GetHelixParameters(Double_t* h, Double_t b) const
 External track parameters -> helix parameters
 "b" - magnetic field (kG)

Double_t GetDCA(const AliExternalTrackParam* p, Double_t b, Double_t& xthis, Double_t& xp) const
 Returns the (weighed !) distance of closest approach between
 this track and the track "p".
 Other returned values:
   xthis, xt - coordinates of tracks' reference planes at the DCA

Bool_t PropagateToDCA(const AliVVertex* vtx, Double_t b, Double_t maxd, Double_t* dz = 0, Double_t* cov = 0)
 Propagate this track to the DCA to vertex "vtx",
 if the (rough) transverse impact parameter is not bigger then "maxd".
            Magnetic field is "b" (kG).

 a) The track gets extapolated to the DCA to the vertex.
 b) The impact parameters and their covariance matrix are calculated.

    In the case of success, the returned value is kTRUE
    (otherwise, it's kFALSE)

Bool_t PropagateToDCABxByBz(const AliVVertex* vtx, Double_t* b, Double_t maxd, Double_t* dz = 0, Double_t* cov = 0)
 Propagate this track to the DCA to vertex "vtx",
 if the (rough) transverse impact parameter is not bigger then "maxd".

 This function takes into account all three components of the magnetic
 field given by the b[3] arument (kG)

 a) The track gets extapolated to the DCA to the vertex.
 b) The impact parameters and their covariance matrix are calculated.

    In the case of success, the returned value is kTRUE
    (otherwise, it's kFALSE)

void GetDirection(Double_t* d) const
 This function returns a unit vector along the track direction
 in the global coordinate system.

Bool_t GetPxPyPz(Double_t* p) const
 This function returns the global track momentum components
 Results for (nearly) straight tracks are meaningless !

Double_t Px() const
 Returns x-component of momentum
 Result for (nearly) straight tracks is meaningless !

Double_t Py() const
 Returns y-component of momentum
 Result for (nearly) straight tracks is meaningless !

Double_t Xv() const
 Returns x-component of first track point

Double_t Yv() const
 Returns y-component of first track point

Double_t Theta() const
 return theta angle of momentum
Double_t Phi() const
 Returns the azimuthal angle of momentum
 0 <= phi < 2*pi

Double_t M() const
 return particle mass
Double_t E() const
 return particle energy
Double_t Eta() const
 return pseudorapidity
Double_t Y() const
 return rapidity
Bool_t GetXYZ(Double_t* p) const
 This function returns the global track position

Bool_t GetCovarianceXYZPxPyPz(Double_t* cv) const
 This function returns the global covariance matrix of the track params

 Cov(x,x) ... :   cv[0]
 Cov(y,x) ... :   cv[1]  cv[2]
 Cov(z,x) ... :   cv[3]  cv[4]  cv[5]
 Cov(px,x)... :   cv[6]  cv[7]  cv[8]  cv[9]
 Cov(py,x)... :   cv[10] cv[11] cv[12] cv[13] cv[14]
 Cov(pz,x)... :   cv[15] cv[16] cv[17] cv[18] cv[19] cv[20]

 Results for (nearly) straight tracks are meaningless !

GetPxPyPzAt(Double_t x, Double_t b, Double_t* p) const
 This function returns the global track momentum extrapolated to
 the radial position "x" (cm) in the magnetic field "b" (kG)

GetYAt(Double_t x, Double_t b, Double_t& y) const
 This function returns the local Y-coordinate of the intersection
 point between this track and the reference plane "x" (cm).
 Magnetic field "b" (kG)

GetZAt(Double_t x, Double_t b, Double_t& z) const
 This function returns the local Z-coordinate of the intersection
 point between this track and the reference plane "x" (cm).
 Magnetic field "b" (kG)

GetXYZAt(Double_t x, Double_t b, Double_t* r) const
 This function returns the global track position extrapolated to
 the radial position "x" (cm) in the magnetic field "b" (kG)

void Print(Option_t* option = "") const
 print the parameters and the covariance matrix
Double_t GetSnpAt(Double_t x, Double_t b) const
 Get sinus at given x

Bool_t GetDistance(AliExternalTrackParam* param2, Double_t x, Double_t* dist, Double_t b)
 Get the distance between two tracks at the local position x
 working in the local frame of this track.
 Origin :   Marian.Ivanov@cern.ch

void DrawTrack(Float_t magF, Float_t minR, Float_t maxR, Float_t stepR)
 Draw track line

void FillPolymarker(TPolyMarker3D* pol, Float_t magf, Float_t minR, Float_t maxR, Float_t stepR)
 Fill points in the polymarker

Int_t GetIndex(Int_t i, Int_t j) const
void g3helx3(Double_t qfield, Double_t step, Double_t* vect)
 *                                                                *
 *       GEANT3 tracking routine in a constant field oriented     *
 *       along axis 3                                             *
 *       Tracking is performed with a conventional                *
 *       helix step method                                        *
 *                                                                *
 *       Authors    R.Brun, M.Hansroul  *********                 *
 *       Rewritten  V.Perevoztchikov                              *
 *                                                                *
 *       Rewritten in C++ by I.Belikov                            *
 *                                                                *
 *  qfield (kG)       - particle charge times magnetic field      *
 *  step   (cm)       - step length along the helix               *
 *  vect[7](cm,GeV/c) - input/output x, y, z, px/p, py/p ,pz/p, p *
 *                                                                *

Bool_t PropagateToBxByBz(Double_t x, const Double_t* b)
 Extrapolate this track to the plane X=xk in the field b[].

 X [cm] is in the "tracking coordinate system" of this track.
 b[]={Bx,By,Bz} [kG] is in the Global coordidate system.

Bool_t Translate(Double_t* vTrasl, Double_t* covV)
Translation: in the event mixing, the tracks can be shifted
of the difference among primary vertices (vTrasl) and
the covariance matrix is changed accordingly
(covV = covariance of the primary vertex).
Origin: "Romita, Rossella" <R.Romita@gsi.de>

void CheckCovariance()
void ResetCovariance(Double_t s2)
 Reset the covarince matrix to "something big"

virtual ~AliExternalTrackParam()
{}
void SetMostProbablePt(Double_t pt)
Double_t GetMostProbablePt()
{ return fgMostProbablePt; }
const Double_t * GetParameter() const
{return fP;}
const Double_t * GetCovariance() const
{return fC;}
Double_t GetAlpha() const
{return fAlpha;}
Double_t GetX() const
{return fX;}
Double_t GetY() const
{return fP[0];}
Double_t GetZ() const
{return fP[1];}
Double_t GetSnp() const
{return fP[2];}
Double_t GetTgl() const
{return fP[3];}
Double_t GetSigned1Pt() const
{return fP[4];}
Double_t GetSigmaY2() const
{return fC[0];}
Double_t GetSigmaZY() const
{return fC[1];}
Double_t GetSigmaZ2() const
{return fC[2];}
Double_t GetSigmaSnpY() const
{return fC[3];}
Double_t GetSigmaSnpZ() const
{return fC[4];}
Double_t GetSigmaSnp2() const
{return fC[5];}
Double_t GetSigmaTglY() const
{return fC[6];}
Double_t GetSigmaTglZ() const
{return fC[7];}
Double_t GetSigmaTglSnp() const
{return fC[8];}
Double_t GetSigmaTgl2() const
{return fC[9];}
Double_t GetSigma1PtY() const
{return fC[10];}
Double_t GetSigma1PtZ() const
{return fC[11];}
Double_t GetSigma1PtSnp() const
{return fC[12];}
Double_t GetSigma1PtTgl() const
{return fC[13];}
Double_t GetSigma1Pt2() const
{return fC[14];}
Double_t Pz() const
{ return Pt()*GetTgl(); }
Double_t Pt() const
{ return TMath::Abs(GetSignedPt()); }
Double_t P() const
{ return GetP(); }
Bool_t PxPyPz(Double_t* p) const
{ return GetPxPyPz(p); }
Double_t Zv() const
{return GetZ();}
Bool_t XvYvZv(Double_t* x) const
{ return GetXYZ(x); }
Double_t OneOverPt() const
{ return 1./Pt(); }
Short_t Charge() const
{ return (Short_t)GetSign(); }
const Double_t * PID() const
{ return 0x0; }
Int_t GetID() const
 additional functions from AliVTrack
{ return -999; }
UChar_t GetITSClusterMap() const
{return 0; }
ULong_t GetStatus() const
{ return 0; }
Double_t GetSign() const
{return (fP[4]>0) ? 1 : -1;}
Double_t GetSignedPt() const
Double_t GetC(Double_t b) const
{return fP[4]*b*kB2C;}
void GetDZ(Double_t x, Double_t y, Double_t z, Double_t b, Float_t* dz) const
Bool_t CorrectForMeanMaterial(Double_t xOverX0, Double_t xTimesRho, Double_t mass, Bool_t anglecorr = kFALSE, Double_t (*)(Double_t) f = AliExternalTrackParam::BetheBlochSolid)
Bool_t CorrectForMeanMaterialZA(Double_t xOverX0, Double_t xTimesRho, Double_t mass, Double_t zOverA = 0.49848, Double_t density = 2.33, Double_t exEnergy = 173e-9, Double_t jp1 = 0.20, Double_t jp2 = 3.00, Bool_t anglecorr = kFALSE)
 Bethe-Bloch formula parameterizations

Double_t GetPredictedChi2(Double_t* p, Double_t* cov) const
GetPredictedChi2(Double_t* p, Double_t* covyz, Double_t* covxyz) const
PropagateTo(Double_t* p, Double_t* covyz, Double_t* covxyz, Double_t b)
Bool_t PropagateBxByBz(Double_t alpha, Double_t x, Double_t* b)
Double_t PropagateToDCA(AliExternalTrackParam* p, Double_t b)
Bool_t CorrectForMaterial(Double_t d, Double_t x0, Double_t mass, Double_t (*)(Double_t) f = AliExternalTrackParam::BetheBlochSolid)
Deprecated
Int_t GetLabel() const
{return -1;}
Int_t PdgCode() const
{return 0;}
Double_t & Par(Int_t i)
protected:
{return fP[i];}
Double_t & Cov(Int_t i)
{return fC[i];}