ROOT logo
AliRoot » MUON » AliMUONTrackExtrap

class AliMUONTrackExtrap: public TObject

 Class AliMUONTrackExtrap

 Tools for track extrapolation in ALICE dimuon spectrometer
 Author: Philippe Pillot

Function Members (Methods)

public:
AliMUONTrackExtrap()
virtual~AliMUONTrackExtrap()
voidTObject::AbstractMethod(const char* method) const
static voidAddMCSEffect(AliMUONTrackParam* param, Double_t dZ, Double_t x0)
virtual voidTObject::AppendPad(Option_t* option = "")
virtual voidTObject::Browse(TBrowser* b)
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
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)
static Bool_tExtrapOneStepRungekutta(Double_t charge, Double_t step, const Double_t* vect, Double_t* vout)
static voidExtrapToVertex(AliMUONTrackParam* trackParam, Double_t xVtx, Double_t yVtx, Double_t zVtx, Double_t errXVtx, Double_t errYVtx)
static voidExtrapToVertexUncorrected(AliMUONTrackParam* trackParam, Double_t zVtx)
static voidExtrapToVertexWithoutBranson(AliMUONTrackParam* trackParam, Double_t zVtx)
static voidExtrapToVertexWithoutELoss(AliMUONTrackParam* trackParam, Double_t xVtx, Double_t yVtx, Double_t zVtx, Double_t errXVtx, Double_t errYVtx)
static Bool_tExtrapToZ(AliMUONTrackParam* trackParam, Double_t zEnd)
static Bool_tExtrapToZCov(AliMUONTrackParam* trackParam, Double_t zEnd, Bool_t updatePropagator = kFALSE)
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
static Double_tGetBendingMomentumFromImpactParam(Double_t impactParam)
virtual Option_t*TObject::GetDrawOption() const
static Long_tTObject::GetDtorOnly()
virtual const char*TObject::GetIconName() const
static Double_tGetImpactParamFromBendingMomentum(Double_t bendingMomentum)
static Double_tGetMCSAngle2(const AliMUONTrackParam& param, Double_t dZ, Double_t x0)
virtual const char*TObject::GetName() const
virtual char*TObject::GetObjectInfo(Int_t px, Int_t py) const
static Bool_tTObject::GetObjectStat()
virtual Option_t*TObject::GetOption() const
virtual const char*TObject::GetTitle() 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)
virtual TClass*IsA() const
virtual Bool_tTObject::IsEqual(const TObject* obj) const
static Bool_tIsFieldON()
virtual Bool_tTObject::IsFolder() const
Bool_tTObject::IsOnHeap() const
virtual Bool_tTObject::IsSortable() const
Bool_tTObject::IsZombie() const
static voidLinearExtrapToZ(AliMUONTrackParam* trackParam, Double_t zEnd)
static voidLinearExtrapToZCov(AliMUONTrackParam* trackParam, Double_t zEnd, Bool_t updatePropagator = kFALSE)
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)
virtual voidTObject::Paint(Option_t* option = "")
virtual voidTObject::Pop()
virtual voidTObject::Print(Option_t* option = "") const
virtual Int_tTObject::Read(const char* name)
virtual voidTObject::RecursiveRemove(TObject* obj)
voidTObject::ResetBit(UInt_t f)
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)
virtual voidTObject::SetDrawOption(Option_t* option = "")MENU
static voidTObject::SetDtorOnly(void* obj)
static voidSetField()
static voidTObject::SetObjectStat(Bool_t stat)
virtual voidTObject::SetUniqueID(UInt_t uid)
virtual voidShowMembers(TMemberInspector&)
virtual voidStreamer(TBuffer&)
voidStreamerNVirtual(TBuffer& ClassDef_StreamerNVirtual_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
static Double_tTotalMomentumEnergyLoss(AliMUONTrackParam* trackParam, Double_t xVtx, Double_t yVtx, Double_t zVtx)
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:
virtual voidTObject::DoError(int level, const char* location, const char* fmt, va_list va) const
voidTObject::MakeZombie()
private:
AliMUONTrackExtrap(const AliMUONTrackExtrap& trackExtrap)
static voidAddMCSEffectInAbsorber(AliMUONTrackParam* trackParam, Double_t signedPathLength, Double_t f0, Double_t f1, Double_t f2)
static Double_tBetheBloch(Double_t pTotal, Double_t pathLength, Double_t rho, Double_t atomicZ, Double_t atomicZoverA)
static voidConvertTrackParamForExtrap(AliMUONTrackParam* trackParam, Double_t forwardBackward, Double_t* v3)
static voidCorrectELossEffectInAbsorber(AliMUONTrackParam* param, Double_t eLoss, Double_t sigmaELoss2)
static voidCorrectMCSEffectInAbsorber(AliMUONTrackParam* param, Double_t xVtx, Double_t yVtx, Double_t zVtx, Double_t errXVtx, Double_t errYVtx, Double_t absZBeg, Double_t pathLength, Double_t f0, Double_t f1, Double_t f2)
static voidCov2CovP(const TMatrixD& param, TMatrixD& cov)
static voidCovP2Cov(const TMatrixD& param, TMatrixD& cov)
static Double_tEnergyLossFluctuation(Double_t pTotal, Double_t pathLength, Double_t rho, Double_t atomicZoverA)
static voidExtrapOneStepHelix(Double_t charge, Double_t step, const Double_t* vect, Double_t* vout)
static voidExtrapOneStepHelix3(Double_t field, Double_t step, const Double_t* vect, Double_t* vout)
static voidExtrapToVertex(AliMUONTrackParam* trackParam, Double_t xVtx, Double_t yVtx, Double_t zVtx, Double_t errXVtx, Double_t errYVtx, Bool_t correctForMCS, Bool_t correctForEnergyLoss)
static Bool_tExtrapToZHelix(AliMUONTrackParam* trackParam, Double_t Z)
static Bool_tExtrapToZRungekutta(AliMUONTrackParam* trackParam, Double_t Z)
static Bool_tGetAbsorberCorrectionParam(Double_t* trackXYZIn, Double_t* trackXYZOut, Double_t pTotal, Double_t& pathLength, Double_t& f0, Double_t& f1, Double_t& f2, Double_t& meanRho, Double_t& totalELoss, Double_t& sigmaELoss2)
AliMUONTrackExtrap&operator=(const AliMUONTrackExtrap& trackExtrap)
static voidRecoverTrackParam(Double_t* v3, Double_t Charge, AliMUONTrackParam* trackParam)

Data Members

private:
static Bool_tfgFieldON!< kTRUE if the field is switched ON
static Double_tfgSimpleBValue!< magnetic field value at the centre
static const Double_tfgkHelixStepLength!< Step lenght for track extrapolation (used in Helix)
static const Int_tfgkMaxStepNumber!< Maximum number of steps for track extrapolation
static const Double_tfgkRungeKuttaMaxResidue!< Maximal distance (in Z) to destination to stop the track extrapolation (used in Runge-Kutta)
static const Double_tfgkSimpleBLength!< length of the dipole
static const Double_tfgkSimpleBPosition!< position of the dipole
static const Bool_tfgkUseHelix!< Tell whether to use Helix or not (default is Runge-Kutta)

Class Charts

Inheritance Chart:
TObject
AliMUONTrackExtrap

Function documentation

void SetField()
 set field on/off flag;
 set field at the centre of the dipole
Double_t GetImpactParamFromBendingMomentum(Double_t bendingMomentum)
 Returns impact parameter at vertex in bending plane (cm),
 from the signed bending momentum "BendingMomentum" in bending plane (GeV/c),
 using simple values for dipole magnetic field.
 The sign of "BendingMomentum" is the sign of the charge.
GetBendingMomentumFromImpactParam(Double_t impactParam)
 Returns signed bending momentum in bending plane (GeV/c),
 the sign being the sign of the charge for particles moving forward in Z,
 from the impact parameter "ImpactParam" at vertex in bending plane (cm),
 using simple values for dipole magnetic field.
void LinearExtrapToZ(AliMUONTrackParam* trackParam, Double_t zEnd)
 Track parameters linearly extrapolated to the plane at "zEnd".
 On return, results from the extrapolation are updated in trackParam.
void LinearExtrapToZCov(AliMUONTrackParam* trackParam, Double_t zEnd, Bool_t updatePropagator = kFALSE)
 Track parameters and their covariances linearly extrapolated to the plane at "zEnd".
 On return, results from the extrapolation are updated in trackParam.
Bool_t ExtrapToZ(AliMUONTrackParam* trackParam, Double_t zEnd)
 Interface to track parameter extrapolation to the plane at "Z" using Helix or Rungekutta algorithm.
 On return, the track parameters resulting from the extrapolation are updated in trackParam.
Bool_t ExtrapToZHelix(AliMUONTrackParam* trackParam, Double_t Z)
 Track parameter extrapolation to the plane at "Z" using Helix algorithm.
 On return, the track parameters resulting from the extrapolation are updated in trackParam.
Bool_t ExtrapToZRungekutta(AliMUONTrackParam* trackParam, Double_t Z)
 Track parameter extrapolation to the plane at "Z" using Rungekutta algorithm.
 On return, the track parameters resulting from the extrapolation are updated in trackParam.
void ConvertTrackParamForExtrap(AliMUONTrackParam* trackParam, Double_t forwardBackward, Double_t* v3)
 Set vector of Geant3 parameters pointed to by "v3" from track parameters in trackParam.
 Since AliMUONTrackParam is only geometry, one uses "forwardBackward"
 to know whether the particle is going forward (+1) or backward (-1).
void RecoverTrackParam(Double_t* v3, Double_t Charge, AliMUONTrackParam* trackParam)
 Set track parameters in trackParam from Geant3 parameters pointed to by "v3",
 assumed to be calculated for forward motion in Z.
 "InverseBendingMomentum" is signed with "charge".
Bool_t ExtrapToZCov(AliMUONTrackParam* trackParam, Double_t zEnd, Bool_t updatePropagator = kFALSE)
 Track parameters and their covariances extrapolated to the plane at "zEnd".
 On return, results from the extrapolation are updated in trackParam.
void AddMCSEffectInAbsorber(AliMUONTrackParam* trackParam, Double_t signedPathLength, Double_t f0, Double_t f1, Double_t f2)
 Add to the track parameter covariances the effects of multiple Coulomb scattering
 signedPathLength must have the sign of (zOut - zIn) where all other parameters are assumed to be given at zOut.
void CorrectMCSEffectInAbsorber(AliMUONTrackParam* param, Double_t xVtx, Double_t yVtx, Double_t zVtx, Double_t errXVtx, Double_t errYVtx, Double_t absZBeg, Double_t pathLength, Double_t f0, Double_t f1, Double_t f2)
 Correct parameters and corresponding covariances using Branson correction
 - input param are parameters and covariances at the end of absorber
 - output param are parameters and covariances at vertex
 Absorber correction parameters are supposed to be calculated at the current track z-position
void CorrectELossEffectInAbsorber(AliMUONTrackParam* param, Double_t eLoss, Double_t sigmaELoss2)
 Correct parameters for energy loss and add energy loss fluctuation effect to covariances
Bool_t GetAbsorberCorrectionParam(Double_t* trackXYZIn, Double_t* trackXYZOut, Double_t pTotal, Double_t& pathLength, Double_t& f0, Double_t& f1, Double_t& f2, Double_t& meanRho, Double_t& totalELoss, Double_t& sigmaELoss2)
 Parameters used to correct for Multiple Coulomb Scattering and energy loss in absorber
 Calculated assuming a linear propagation from trackXYZIn to trackXYZOut (order is important)
 pathLength: path length between trackXYZIn and trackXYZOut (cm)
 f0:         0th moment of z calculated with the inverse radiation-length distribution
 f1:         1st moment of z calculated with the inverse radiation-length distribution
 f2:         2nd moment of z calculated with the inverse radiation-length distribution
 meanRho:    average density of crossed material (g/cm3)
 totalELoss: total energy loss in absorber
Double_t GetMCSAngle2(const AliMUONTrackParam& param, Double_t dZ, Double_t x0)
 Return the angular dispersion square due to multiple Coulomb scattering
 through a material of thickness "dZ" and of radiation length "x0"
 assuming linear propagation and using the small angle approximation.
void AddMCSEffect(AliMUONTrackParam* param, Double_t dZ, Double_t x0)
 Add to the track parameter covariances the effects of multiple Coulomb scattering
 through a material of thickness "Abs(dZ)" and of radiation length "x0"
 assuming linear propagation and using the small angle approximation.
 dZ = zOut - zIn (sign is important) and "param" is assumed to be given zOut.
 If x0 <= 0., assume dZ = pathLength/x0 and consider the material thickness as negligible.
void ExtrapToVertex(AliMUONTrackParam* trackParam, Double_t xVtx, Double_t yVtx, Double_t zVtx, Double_t errXVtx, Double_t errYVtx, Bool_t correctForMCS, Bool_t correctForEnergyLoss)
 Main method for extrapolation to the vertex:
 Returns the track parameters and covariances resulting from the extrapolation of the current trackParam
 Changes parameters and covariances according to multiple scattering and energy loss corrections:
 if correctForMCS=kTRUE:  compute parameters using Branson correction and add correction resolution to covariances
 if correctForMCS=kFALSE: add parameter dispersion due to MCS in parameter covariances
 if correctForEnergyLoss=kTRUE:  correct parameters for energy loss and add energy loss fluctuation to covariances
 if correctForEnergyLoss=kFALSE: do nothing about energy loss
void ExtrapToVertex(AliMUONTrackParam* trackParam, Double_t xVtx, Double_t yVtx, Double_t zVtx, Double_t errXVtx, Double_t errYVtx)
 Extrapolate track parameters to vertex, corrected for multiple scattering and energy loss effects
 Add branson correction resolution and energy loss fluctuation to parameter covariances
void ExtrapToVertexWithoutELoss(AliMUONTrackParam* trackParam, Double_t xVtx, Double_t yVtx, Double_t zVtx, Double_t errXVtx, Double_t errYVtx)
 Extrapolate track parameters to vertex, corrected for multiple scattering effects only
 Add branson correction resolution to parameter covariances
void ExtrapToVertexWithoutBranson(AliMUONTrackParam* trackParam, Double_t zVtx)
 Extrapolate track parameters to vertex, corrected for energy loss effects only
 Add dispersion due to multiple scattering and energy loss fluctuation to parameter covariances
void ExtrapToVertexUncorrected(AliMUONTrackParam* trackParam, Double_t zVtx)
 Extrapolate track parameters to vertex without multiple scattering and energy loss corrections
 Add dispersion due to multiple scattering to parameter covariances
Double_t TotalMomentumEnergyLoss(AliMUONTrackParam* trackParam, Double_t xVtx, Double_t yVtx, Double_t zVtx)
 Calculate the total momentum energy loss in-between the track position and the vertex assuming a linear propagation
Double_t BetheBloch(Double_t pTotal, Double_t pathLength, Double_t rho, Double_t atomicZ, Double_t atomicZoverA)
 Returns the mean total momentum energy loss of muon with total momentum='pTotal'
 in the absorber layer of lenght='pathLength', density='rho', A='atomicA' and Z='atomicZ'
Double_t EnergyLossFluctuation(Double_t pTotal, Double_t pathLength, Double_t rho, Double_t atomicZoverA)
 Returns the total momentum energy loss fluctuation of muon with total momentum='pTotal'
 in the absorber layer of lenght='pathLength', density='rho', A='atomicA' and Z='atomicZ'
void Cov2CovP(const TMatrixD& param, TMatrixD& cov)
 change coordinate system: (X, SlopeX, Y, SlopeY, q/Pyz) -> (X, SlopeX, Y, SlopeY, q*PTot)
 parameters (param) are given in the (X, SlopeX, Y, SlopeY, q/Pyz) coordinate system
void CovP2Cov(const TMatrixD& param, TMatrixD& cov)
 change coordinate system: (X, SlopeX, Y, SlopeY, q*PTot) -> (X, SlopeX, Y, SlopeY, q/Pyz)
 parameters (param) are given in the (X, SlopeX, Y, SlopeY, q/Pyz) coordinate system
void ExtrapOneStepHelix(Double_t charge, Double_t step, const Double_t* vect, Double_t* vout)
 <pre>
    ******************************************************************
    *                                                                *
    *  Performs the tracking of one step in a magnetic field         *
    *  The trajectory is assumed to be a helix in a constant field   *
    *  taken at the mid point of the step.                           *
    *  Parameters:                                                   *
    *   input                                                        *
    *     STEP =arc length of the step asked                         *
    *     VECT =input vector (position,direction cos and momentum)   *
    *     CHARGE=  electric charge of the particle                   *
    *   output                                                       *
    *     VOUT = same as VECT after completion of the step           *
    *                                                                *
    *    ==>Called by : USER, GUSWIM                               *
    *       Author    m.hansroul  *********                          *
    *       modified  s.egli, s.v.levonian                           *
    *       modified  v.perevoztchikov
    *                                                                *
    ******************************************************************
 </pre>
void ExtrapOneStepHelix3(Double_t field, Double_t step, const Double_t* vect, Double_t* vout)
 <pre>
	******************************************************************
	*								 *
	*	Tracking routine in a constant field oriented		 *
	*	along axis 3						 *
	*	Tracking is performed with a conventional		 *
	*	helix step method					 *
	*								 *
	*    ==>Called by : USER, GUSWIM				 *
	*	Authors    R.Brun, M.Hansroul  *********		 *
	*	Rewritten  V.Perevoztchikov
	*								 *
	******************************************************************
 </pre>
Bool_t ExtrapOneStepRungekutta(Double_t charge, Double_t step, const Double_t* vect, Double_t* vout)
 <pre>
	******************************************************************
	*								 *
	*  Runge-Kutta method for tracking a particle through a magnetic *
	*  field. Uses Nystroem algorithm (See Handbook Nat. Bur. of	 *
	*  Standards, procedure 25.5.20)				 *
	*								 *
	*  Input parameters						 *
	*	CHARGE    Particle charge				 *
	*	STEP	  Step size					 *
	*	VECT	  Initial co-ords,direction cosines,momentum	 *
	*  Output parameters						 *
	*	VOUT	  Output co-ords,direction cosines,momentum	 *
	*  User routine called  					 *
	*	CALL GUFLD(X,F) 					 *
	*								 *
	*    ==>Called by : USER, GUSWIM				 *
	*	Authors    R.Brun, M.Hansroul  *********		 *
	*		   V.Perevoztchikov (CUT STEP implementation)	 *
	*								 *
	*								 *
	******************************************************************
 </pre>
AliMUONTrackExtrap()
 Constructor
{}
virtual ~AliMUONTrackExtrap()
 Destructor
{}
Bool_t IsFieldON()
 return kTRUE if the field is switched ON
{return fgFieldON;}
AliMUONTrackExtrap(const AliMUONTrackExtrap& trackExtrap)
 Functions
 Not implemented
AliMUONTrackExtrap& operator=(const AliMUONTrackExtrap& trackExtrap)
 Not implemented