KFParticle.h

Go to the documentation of this file.

//---------------------------------------------------------------------------------
// The KFParticle class
// .
// @author  S.Gorbunov, I.Kisel
// @version 1.0
// @since   13.05.07
//
// Class to reconstruct and store the decayed particle parameters.
// The method is described in CBM-SOFT note 2007-003,
// ``Reconstruction of decayed particles based on the Kalman filter'',
// http://www.gsi.de/documents/DOC-2007-May-14-1.pdf
//
// This class is ALICE interface to general mathematics in KFParticleBase
//
//  -= Copyright &copy ALICE HLT and CBM L1 Groups =-
//_________________________________________________________________________________
 
#define NonhomogeneousField
// #define HomogeneousField
 
#ifndef ALIKFPARTICLE_H
#define ALIKFPARTICLE_H
 
#include "KFParticleBase.h"
#include "TMath.h"
 
#ifdef HomogeneousField
class AliVTrack;
class AliVVertex;
#endif
 
#ifdef NonhomogeneousField
#include "CbmKF.h"
class CbmKFTrackInterface;
class CbmKFVertexInterface;
#endif
 
class KFParticle : public KFParticleBase
{
 
  public:
    //*
    //*  INITIALIZATION
    //*
 
    //* Set magnetic field for all particles
#ifdef HomogeneousField
    static void SetField(Double_t Bz);
#endif
    //* Constructor (empty)
 
    KFParticle()
        : KFParticleBase()
    {
        ;
    }
 
    //* Destructor (empty)
 
    ~KFParticle() { ; }
 
    //* Construction of mother particle by its 2-3-4 daughters
 
    KFParticle(const KFParticle& d1, const KFParticle& d2, Bool_t gamma = kFALSE);
 
    KFParticle(const KFParticle& d1, const KFParticle& d2, const KFParticle& d3);
 
    KFParticle(const KFParticle& d1, const KFParticle& d2, const KFParticle& d3, const KFParticle& d4);
 
    //* Initialisation from "cartesian" coordinates ( X Y Z Px Py Pz )
    //* Parameters, covariance matrix, charge and PID hypothesis should be provided
 
    void Create(const Double_t Param[], const Double_t Cov[], Int_t Charge, Double_t mass /*Int_t PID*/);
 
#ifdef HomogeneousField
    //* Initialisation from ALICE track, PID hypothesis shoould be provided
 
    KFParticle(const AliVTrack& track, Int_t PID);
 
    //* Initialisation from VVertex
 
    KFParticle(const AliVVertex& vertex);
#endif
 
#ifdef NonhomogeneousField
    KFParticle(CbmKFTrackInterface* Track, Double_t* z0 = 0, Int_t* qHypo = 0, Int_t* PID = 0);
    KFParticle(CbmKFVertexInterface& vertex);
#endif
 
    void CleanDaughtersId() { fDaughtersIds.clear(); }
    void SetNDaughters(int n) { fDaughtersIds.reserve(n); }
    void AddDaughter(int id) { fDaughtersIds.push_back(id); }
 
    //* Initialise covariance matrix and set current parameters to 0.0
 
    void Initialize();
 
    //* Set decay vertex parameters for linearisation
 
    void SetVtxGuess(Double_t x, Double_t y, Double_t z);
 
    //*
    //*  ACCESSORS
    //*
 
    //* Simple accessors
 
    Double_t GetX() const;      //* x of current position
    Double_t GetY() const;      //* y of current position
    Double_t GetZ() const;      //* z of current position
    Double_t GetPx() const;     //* x-compoment of 3-momentum
    Double_t GetPy() const;     //* y-compoment of 3-momentum
    Double_t GetPz() const;     //* z-compoment of 3-momentum
    Double_t GetE() const;      //* energy
    Double_t GetS() const;      //* decay length / momentum
    Int_t GetQ() const;         //* charge
    Double_t GetChi2() const;   //* chi^2
    Int_t GetNDF() const;       //* Number of Degrees of Freedom
 
    Bool_t GetAtProductionVertex() const { return fAtProductionVertex; }
    void SetAtProductionVertex(Bool_t b) { fAtProductionVertex = b; }
 
#ifdef NonhomogeneousField
    float* GetFieldCoeff() { return fieldRegion; }
    void SetFieldCoeff(float c, int i) { fieldRegion[i] = c; }
#endif
 
    const Double_t& X() const { return fP[0]; }
    const Double_t& Y() const { return fP[1]; }
    const Double_t& Z() const { return fP[2]; }
    const Double_t& Px() const { return fP[3]; }
    const Double_t& Py() const { return fP[4]; }
    const Double_t& Pz() const { return fP[5]; }
    const Double_t& E() const { return fP[6]; }
    const Double_t& S() const { return fP[7]; }
    const Int_t& Q() const { return fQ; }
    const Double_t& Chi2() const { return fChi2; }
    const Int_t& NDF() const { return fNDF; }
 
    Double_t GetParameter(int i) const;
    Double_t GetCovariance(int i) const;
    Double_t GetCovariance(int i, int j) const;
 
    //* Accessors with calculations, value returned w/o error flag
 
    Double_t GetP() const;               //* momentum
    Double_t GetPt() const;              //* transverse momentum
    Double_t GetEta() const;             //* pseudorapidity
    Double_t GetPhi() const;             //* phi
    Double_t GetMomentum() const;        //* momentum (same as GetP() )
    Double_t GetMass() const;            //* mass
    Double_t GetDecayLength() const;     //* decay length
    Double_t GetDecayLengthXY() const;   //* decay length in XY
    Double_t GetLifeTime() const;        //* life time
    Double_t GetR() const;               //* distance to the origin
 
    //* Accessors to estimated errors
 
    Double_t GetErrX() const;               //* x of current position
    Double_t GetErrY() const;               //* y of current position
    Double_t GetErrZ() const;               //* z of current position
    Double_t GetErrPx() const;              //* x-compoment of 3-momentum
    Double_t GetErrPy() const;              //* y-compoment of 3-momentum
    Double_t GetErrPz() const;              //* z-compoment of 3-momentum
    Double_t GetErrE() const;               //* energy
    Double_t GetErrS() const;               //* decay length / momentum
    Double_t GetErrP() const;               //* momentum
    Double_t GetErrPt() const;              //* transverse momentum
    Double_t GetErrEta() const;             //* pseudorapidity
    Double_t GetErrPhi() const;             //* phi
    Double_t GetErrMomentum() const;        //* momentum
    Double_t GetErrMass() const;            //* mass
    Double_t GetErrDecayLength() const;     //* decay length
    Double_t GetErrDecayLengthXY() const;   //* decay length in XY
    Double_t GetErrLifeTime() const;        //* life time
    Double_t GetErrR() const;               //* distance to the origin
 
    //* Accessors with calculations( &value, &estimated sigma )
    //* error flag returned (0 means no error during calculations)
 
    int GetP(Double_t& P, Double_t& SigmaP) const;               //* momentum
    int GetPt(Double_t& Pt, Double_t& SigmaPt) const;            //* transverse momentum
    int GetEta(Double_t& Eta, Double_t& SigmaEta) const;         //* pseudorapidity
    int GetPhi(Double_t& Phi, Double_t& SigmaPhi) const;         //* phi
    int GetMomentum(Double_t& P, Double_t& SigmaP) const;        //* momentum
    int GetMass(Double_t& M, Double_t& SigmaM) const;            //* mass
    int GetDecayLength(Double_t& L, Double_t& SigmaL) const;     //* decay length
    int GetDecayLengthXY(Double_t& L, Double_t& SigmaL) const;   //* decay length in XY
    int GetLifeTime(Double_t& T, Double_t& SigmaT) const;        //* life time
    int GetR(Double_t& R, Double_t& SigmaR) const;               //* R
    Double_t GetRapidity() const { return 0.5 * TMath::Log((fP[6] + fP[5]) / (fP[6] - fP[5])); }
    Double_t GetTheta() const { return TMath::ATan2(GetPt(), fP[5]); }
 
    //*
    //*  MODIFIERS
    //*
 
    Double_t& X();
    Double_t& Y();
    Double_t& Z();
    Double_t& Px();
    Double_t& Py();
    Double_t& Pz();
    Double_t& E();
    Double_t& S();
    Int_t& Q();
    Double_t& Chi2();
    Int_t& NDF();
 
    Double_t& Parameter(int i);
    Double_t& Covariance(int i);
    Double_t& Covariance(int i, int j);
    Double_t* Parameters();
    Double_t* CovarianceMatrix();
 
    //*
    //* CONSTRUCTION OF THE PARTICLE BY ITS DAUGHTERS AND MOTHER
    //* USING THE KALMAN FILTER METHOD
    //*
 
    //* Add daughter to the particle
 
    void AddDaughter(const KFParticle& Daughter);
 
    //* Add daughter via += operator: ex.{ D0; D0+=Pion; D0+= Kaon; }
 
    void operator+=(const KFParticle& Daughter);
 
    //* Set production vertex
 
    void SetProductionVertex(const KFParticle& Vtx);
 
    //* Set mass constraint
 
    void SetMassConstraint(Double_t Mass, Double_t SigmaMass = 0);
 
    //* Set no decay length for resonances
 
    void SetNoDecayLength();
 
    //* Everything in one go
 
    void Construct(const KFParticle* vDaughters[],
                   int nDaughters,
                   const KFParticle* ProdVtx = 0,
                   Double_t Mass = -1,
                   Bool_t IsConstrained = 0);
 
    //*
    //*                   TRANSPORT
    //*
    //*  ( main transportation parameter is S = SignedPath/Momentum )
    //*  ( parameters of decay & production vertices are stored locally )
    //*
 
    //* Transport the particle to its decay vertex
 
    void TransportToDecayVertex();
 
    //* Transport the particle to its production vertex
 
    void TransportToProductionVertex();
 
    //* Transport the particle close to xyz[] point
 
    void TransportToPoint(const Double_t xyz[]);
 
    //* Transport the particle close to VVertex
#ifdef HomogeneousField
    void TransportToVertex(const AliVVertex& v);
#endif
    //* Transport the particle close to another particle p
 
    void TransportToParticle(const KFParticle& p);
 
    //* Transport the particle on dS parameter (SignedPath/Momentum)
 
    void TransportToDS(Double_t dS);
 
    //* Get dS to a certain space point
 
    Double_t GetDStoPoint(const Double_t xyz[]) const;
 
    //* Get dS to other particle p (dSp for particle p also returned)
 
    void GetDStoParticle(const KFParticle& p, Double_t& DS, Double_t& DSp) const;
 
    //* Get dS to other particle p in XY-plane
 
    void GetDStoParticleXY(const KFParticleBase& p, Double_t& DS, Double_t& DSp) const;
 
    //*
    //* OTHER UTILITIES
    //*
 
    //* Calculate distance from another object [cm]
 
    Double_t GetDistanceFromVertex(const Double_t vtx[]) const;
    Double_t GetDistanceFromVertex(const KFParticle& Vtx) const;
#ifdef HomogeneousField
    Double_t GetDistanceFromVertex(const AliVVertex& Vtx) const;
#endif
    Double_t GetDistanceFromParticle(const KFParticle& p) const;
 
    //* Calculate sqrt(Chi2/ndf) deviation from another object
    //* ( v = [xyz]-vertex, Cv=[Cxx,Cxy,Cyy,Cxz,Cyz,Czz]-covariance matrix )
 
    Double_t GetDeviationFromVertex(const Double_t v[], const Double_t Cv[] = 0) const;
    Double_t GetDeviationFromVertex(const KFParticle& Vtx) const;
#ifdef HomogeneousField
    Double_t GetDeviationFromVertex(const AliVVertex& Vtx) const;
#endif
    Double_t GetDeviationFromParticle(const KFParticle& p) const;
 
    //* Calculate distance from another object [cm] in XY-plane
 
    Bool_t GetDistanceFromVertexXY(const Double_t vtx[], Double_t& val, Double_t& err) const;
    Bool_t GetDistanceFromVertexXY(const Double_t vtx[], const Double_t Cv[], Double_t& val, Double_t& err) const;
    Bool_t GetDistanceFromVertexXY(const KFParticle& Vtx, Double_t& val, Double_t& err) const;
#ifdef HomogeneousField
    Bool_t GetDistanceFromVertexXY(const AliVVertex& Vtx, Double_t& val, Double_t& err) const;
#endif
 
    Double_t GetDistanceFromVertexXY(const Double_t vtx[]) const;
    Double_t GetDistanceFromVertexXY(const KFParticle& Vtx) const;
#ifdef HomogeneousField
    Double_t GetDistanceFromVertexXY(const AliVVertex& Vtx) const;
#endif
    Double_t GetDistanceFromParticleXY(const KFParticle& p) const;
 
    //* Calculate sqrt(Chi2/ndf) deviation from another object in XY plane
    //* ( v = [xyz]-vertex, Cv=[Cxx,Cxy,Cyy,Cxz,Cyz,Czz]-covariance matrix )
 
    Double_t GetDeviationFromVertexXY(const Double_t v[], const Double_t Cv[] = 0) const;
    Double_t GetDeviationFromVertexXY(const KFParticle& Vtx) const;
#ifdef HomogeneousField
    Double_t GetDeviationFromVertexXY(const AliVVertex& Vtx) const;
#endif
    Double_t GetDeviationFromParticleXY(const KFParticle& p) const;
 
    //* Calculate opennig angle between two particles
 
    Double_t GetAngle(const KFParticle& p) const;
    Double_t GetAngleXY(const KFParticle& p) const;
    Double_t GetAngleRZ(const KFParticle& p) const;
 
    //* Subtract the particle from the vertex
 
    void SubtractFromVertex(KFParticle& v) const;
 
    //* Special method for creating gammas
 
    void ConstructGamma(const KFParticle& daughter1, const KFParticle& daughter2);
 
    // * Pseudo Proper Time of decay = (r*pt) / |pt| * M/|pt|
    // @primVertex - primary vertex
    // @mass - mass of the mother particle (in the case of "Hb -> JPsi" it would be JPsi mass)
    // @*timeErr2 - squared error of the decay time. If timeErr2 = 0 it isn't calculated
    Double_t GetPseudoProperDecayTime(const KFParticle& primVertex, const Double_t& mass, Double_t* timeErr2 = 0) const;
 
  protected:
    //*
    //*  INTERNAL STUFF
    //*
 
    //* Method to access ALICE field
#ifdef HomogeneousField
    static Double_t GetFieldAlice();
#endif
    //* Other methods required by the abstract KFParticleBase class
 
    void GetFieldValue(const Double_t xyz[], Double_t B[]) const;
    void GetDStoParticle(const KFParticleBase& p, Double_t& DS, Double_t& DSp) const;
    void Transport(Double_t dS, Double_t P[], Double_t C[]) const;
    static void GetExternalTrackParam(const KFParticleBase& p, Double_t& X, Double_t& Alpha, Double_t P[5]);
 
    // void GetDStoParticleALICE( const KFParticleBase &p, Double_t &DS, Double_t &DS1 ) const;
 
  private:
#ifdef HomogeneousField
    static Double_t fgBz;   //* Bz compoment of the magnetic field
#endif
#ifdef NonhomogeneousField
    float fieldRegion[10];
#endif
 
    ClassDef(KFParticle, 1);
};
 
//---------------------------------------------------------------------
//
//     Inline implementation of the KFParticle methods
//
//---------------------------------------------------------------------
 
#ifdef HomogeneousField
inline void KFParticle::SetField(Double_t Bz)
{
    fgBz = Bz;
}
#endif
 
inline KFParticle::KFParticle(const KFParticle& d1, const KFParticle& d2, const KFParticle& d3)
{
    KFParticle mother;
    mother += d1;
    mother += d2;
    mother += d3;
    *this = mother;
}
 
inline KFParticle::KFParticle(const KFParticle& d1, const KFParticle& d2, const KFParticle& d3, const KFParticle& d4)
{
    KFParticle mother;
    mother += d1;
    mother += d2;
    mother += d3;
    mother += d4;
    *this = mother;
}
 
inline void KFParticle::Initialize()
{
    KFParticleBase::Initialize();
}
 
inline void KFParticle::SetVtxGuess(Double_t x, Double_t y, Double_t z)
{
    KFParticleBase::SetVtxGuess(x, y, z);
}
 
inline Double_t KFParticle::GetX() const
{
    return KFParticleBase::GetX();
}
 
inline Double_t KFParticle::GetY() const
{
    return KFParticleBase::GetY();
}
 
inline Double_t KFParticle::GetZ() const
{
    return KFParticleBase::GetZ();
}
 
inline Double_t KFParticle::GetPx() const
{
    return KFParticleBase::GetPx();
}
 
inline Double_t KFParticle::GetPy() const
{
    return KFParticleBase::GetPy();
}
 
inline Double_t KFParticle::GetPz() const
{
    return KFParticleBase::GetPz();
}
 
inline Double_t KFParticle::GetE() const
{
    return KFParticleBase::GetE();
}
 
inline Double_t KFParticle::GetS() const
{
    return KFParticleBase::GetS();
}
 
inline Int_t KFParticle::GetQ() const
{
    return KFParticleBase::GetQ();
}
 
inline Double_t KFParticle::GetChi2() const
{
    return KFParticleBase::GetChi2();
}
 
inline Int_t KFParticle::GetNDF() const
{
    return KFParticleBase::GetNDF();
}
 
inline Double_t KFParticle::GetParameter(int i) const
{
    return KFParticleBase::GetParameter(i);
}
 
inline Double_t KFParticle::GetCovariance(int i) const
{
    return KFParticleBase::GetCovariance(i);
}
 
inline Double_t KFParticle::GetCovariance(int i, int j) const
{
    return KFParticleBase::GetCovariance(i, j);
}
 
inline Double_t KFParticle::GetP() const
{
    Double_t par, err;
    if (KFParticleBase::GetMomentum(par, err))
        return 0;
    else
        return par;
}
 
inline Double_t KFParticle::GetPt() const
{
    Double_t par, err;
    if (KFParticleBase::GetPt(par, err))
        return 0;
    else
        return par;
}
 
inline Double_t KFParticle::GetEta() const
{
    Double_t par, err;
    if (KFParticleBase::GetEta(par, err))
        return 0;
    else
        return par;
}
 
inline Double_t KFParticle::GetPhi() const
{
    Double_t par, err;
    if (KFParticleBase::GetPhi(par, err))
        return 0;
    else
        return par;
}
 
inline Double_t KFParticle::GetMomentum() const
{
    Double_t par, err;
    if (KFParticleBase::GetMomentum(par, err))
        return 0;
    else
        return par;
}
 
inline Double_t KFParticle::GetMass() const
{
    Double_t par, err;
    if (KFParticleBase::GetMass(par, err))
        return 0;
    else
        return par;
}
 
inline Double_t KFParticle::GetDecayLength() const
{
    Double_t par, err;
    if (KFParticleBase::GetDecayLength(par, err))
        return 0;
    else
        return par;
}
 
inline Double_t KFParticle::GetDecayLengthXY() const
{
    Double_t par, err;
    if (KFParticleBase::GetDecayLengthXY(par, err))
        return 0;
    else
        return par;
}
 
inline Double_t KFParticle::GetLifeTime() const
{
    Double_t par, err;
    if (KFParticleBase::GetLifeTime(par, err))
        return 0;
    else
        return par;
}
 
inline Double_t KFParticle::GetR() const
{
    Double_t par, err;
    if (KFParticleBase::GetR(par, err))
        return 0;
    else
        return par;
}
 
inline Double_t KFParticle::GetErrX() const
{
    return TMath::Sqrt(TMath::Abs(GetCovariance(0, 0)));
}
 
inline Double_t KFParticle::GetErrY() const
{
    return TMath::Sqrt(TMath::Abs(GetCovariance(1, 1)));
}
 
inline Double_t KFParticle::GetErrZ() const
{
    return TMath::Sqrt(TMath::Abs(GetCovariance(2, 2)));
}
 
inline Double_t KFParticle::GetErrPx() const
{
    return TMath::Sqrt(TMath::Abs(GetCovariance(3, 3)));
}
 
inline Double_t KFParticle::GetErrPy() const
{
    return TMath::Sqrt(TMath::Abs(GetCovariance(4, 4)));
}
 
inline Double_t KFParticle::GetErrPz() const
{
    return TMath::Sqrt(TMath::Abs(GetCovariance(5, 5)));
}
 
inline Double_t KFParticle::GetErrE() const
{
    return TMath::Sqrt(TMath::Abs(GetCovariance(6, 6)));
}
 
inline Double_t KFParticle::GetErrS() const
{
    return TMath::Sqrt(TMath::Abs(GetCovariance(7, 7)));
}
 
inline Double_t KFParticle::GetErrP() const
{
    Double_t par, err;
    if (KFParticleBase::GetMomentum(par, err))
        return 1.e10;
    else
        return err;
}
 
inline Double_t KFParticle::GetErrPt() const
{
    Double_t par, err;
    if (KFParticleBase::GetPt(par, err))
        return 1.e10;
    else
        return err;
}
 
inline Double_t KFParticle::GetErrEta() const
{
    Double_t par, err;
    if (KFParticleBase::GetEta(par, err))
        return 1.e10;
    else
        return err;
}
 
inline Double_t KFParticle::GetErrPhi() const
{
    Double_t par, err;
    if (KFParticleBase::GetPhi(par, err))
        return 1.e10;
    else
        return err;
}
 
inline Double_t KFParticle::GetErrMomentum() const
{
    Double_t par, err;
    if (KFParticleBase::GetMomentum(par, err))
        return 1.e10;
    else
        return err;
}
 
inline Double_t KFParticle::GetErrMass() const
{
    Double_t par, err;
    if (KFParticleBase::GetMass(par, err))
        return 1.e10;
    else
        return err;
}
 
inline Double_t KFParticle::GetErrDecayLength() const
{
    Double_t par, err;
    if (KFParticleBase::GetDecayLength(par, err))
        return 1.e10;
    else
        return err;
}
 
inline Double_t KFParticle::GetErrDecayLengthXY() const
{
    Double_t par, err;
    if (KFParticleBase::GetDecayLengthXY(par, err))
        return 1.e10;
    else
        return err;
}
 
inline Double_t KFParticle::GetErrLifeTime() const
{
    Double_t par, err;
    if (KFParticleBase::GetLifeTime(par, err))
        return 1.e10;
    else
        return err;
}
 
inline Double_t KFParticle::GetErrR() const
{
    Double_t par, err;
    if (KFParticleBase::GetR(par, err))
        return 1.e10;
    else
        return err;
}
 
inline int KFParticle::GetP(Double_t& P, Double_t& SigmaP) const
{
    return KFParticleBase::GetMomentum(P, SigmaP);
}
 
inline int KFParticle::GetPt(Double_t& Pt, Double_t& SigmaPt) const
{
    return KFParticleBase::GetPt(Pt, SigmaPt);
}
 
inline int KFParticle::GetEta(Double_t& Eta, Double_t& SigmaEta) const
{
    return KFParticleBase::GetEta(Eta, SigmaEta);
}
 
inline int KFParticle::GetPhi(Double_t& Phi, Double_t& SigmaPhi) const
{
    return KFParticleBase::GetPhi(Phi, SigmaPhi);
}
 
inline int KFParticle::GetMomentum(Double_t& P, Double_t& SigmaP) const
{
    return KFParticleBase::GetMomentum(P, SigmaP);
}
 
inline int KFParticle::GetMass(Double_t& M, Double_t& SigmaM) const
{
    return KFParticleBase::GetMass(M, SigmaM);
}
 
inline int KFParticle::GetDecayLength(Double_t& L, Double_t& SigmaL) const
{
    return KFParticleBase::GetDecayLength(L, SigmaL);
}
 
inline int KFParticle::GetDecayLengthXY(Double_t& L, Double_t& SigmaL) const
{
    return KFParticleBase::GetDecayLengthXY(L, SigmaL);
}
 
inline int KFParticle::GetLifeTime(Double_t& T, Double_t& SigmaT) const
{
    return KFParticleBase::GetLifeTime(T, SigmaT);
}
 
inline int KFParticle::GetR(Double_t& R, Double_t& SigmaR) const
{
    return KFParticleBase::GetR(R, SigmaR);
}
 
inline Double_t& KFParticle::X()
{
    return KFParticleBase::X();
}
 
inline Double_t& KFParticle::Y()
{
    return KFParticleBase::Y();
}
 
inline Double_t& KFParticle::Z()
{
    return KFParticleBase::Z();
}
 
inline Double_t& KFParticle::Px()
{
    return KFParticleBase::Px();
}
 
inline Double_t& KFParticle::Py()
{
    return KFParticleBase::Py();
}
 
inline Double_t& KFParticle::Pz()
{
    return KFParticleBase::Pz();
}
 
inline Double_t& KFParticle::E()
{
    return KFParticleBase::E();
}
 
inline Double_t& KFParticle::S()
{
    return KFParticleBase::S();
}
 
inline Int_t& KFParticle::Q()
{
    return KFParticleBase::Q();
}
 
inline Double_t& KFParticle::Chi2()
{
    return KFParticleBase::Chi2();
}
 
inline Int_t& KFParticle::NDF()
{
    return KFParticleBase::NDF();
}
 
inline Double_t& KFParticle::Parameter(int i)
{
    return KFParticleBase::Parameter(i);
}
 
inline Double_t& KFParticle::Covariance(int i)
{
    return KFParticleBase::Covariance(i);
}
 
inline Double_t& KFParticle::Covariance(int i, int j)
{
    return KFParticleBase::Covariance(i, j);
}
 
inline Double_t* KFParticle::Parameters()
{
    return fP;
}
 
inline Double_t* KFParticle::CovarianceMatrix()
{
    return fC;
}
 
inline void KFParticle::operator+=(const KFParticle& Daughter)
{
    KFParticleBase::operator+=(Daughter);
}
 
inline void KFParticle::AddDaughter(const KFParticle& Daughter)
{
    KFParticleBase::AddDaughter(Daughter);
}
 
inline void KFParticle::SetProductionVertex(const KFParticle& Vtx)
{
    KFParticleBase::SetProductionVertex(Vtx);
}
 
inline void KFParticle::SetMassConstraint(Double_t Mass, Double_t SigmaMass)
{
    KFParticleBase::SetMassConstraint(Mass, SigmaMass);
}
 
inline void KFParticle::SetNoDecayLength()
{
    KFParticleBase::SetNoDecayLength();
}
 
inline void KFParticle::Construct(const KFParticle* vDaughters[],
                                  int nDaughters,
                                  const KFParticle* ProdVtx,
                                  Double_t Mass,
                                  Bool_t IsConstrained)
{
    KFParticleBase::Construct((const KFParticleBase**)vDaughters, nDaughters, (const KFParticleBase*)ProdVtx, Mass,
                              IsConstrained);
}
 
inline void KFParticle::TransportToDecayVertex()
{
    KFParticleBase::TransportToDecayVertex();
}
 
inline void KFParticle::TransportToProductionVertex()
{
    KFParticleBase::TransportToProductionVertex();
}
 
inline void KFParticle::TransportToPoint(const Double_t xyz[])
{
    TransportToDS(GetDStoPoint(xyz));
}
#ifdef HomogeneousField
inline void KFParticle::TransportToVertex(const AliVVertex& v)
{
    TransportToPoint(KFParticle(v).fP);
}
#endif
inline void KFParticle::TransportToParticle(const KFParticle& p)
{
    Double_t dS, dSp;
    GetDStoParticle(p, dS, dSp);
    TransportToDS(dS);
}
 
inline void KFParticle::TransportToDS(Double_t dS)
{
    KFParticleBase::TransportToDS(dS);
}
 
inline Double_t KFParticle::GetDStoPoint(const Double_t xyz[]) const
{
#ifdef HomogeneousField
    return KFParticleBase::GetDStoPointBz(GetFieldAlice(), xyz);
#endif
#ifdef NonhomogeneousField
    return KFParticleBase::GetDStoPointCBM(xyz);
#endif
}
 
inline void KFParticle::GetDStoParticle(const KFParticle& p, Double_t& DS, Double_t& DSp) const
{
    GetDStoParticleXY(p, DS, DSp);
}
 
inline Double_t KFParticle::GetDistanceFromVertex(const Double_t vtx[]) const
{
    return KFParticleBase::GetDistanceFromVertex(vtx);
}
 
inline Double_t KFParticle::GetDeviationFromVertex(const Double_t v[], const Double_t Cv[]) const
{
    return KFParticleBase::GetDeviationFromVertex(v, Cv);
}
 
inline Double_t KFParticle::GetDistanceFromVertex(const KFParticle& Vtx) const
{
    return KFParticleBase::GetDistanceFromVertex(Vtx);
}
 
inline Double_t KFParticle::GetDeviationFromVertex(const KFParticle& Vtx) const
{
    return KFParticleBase::GetDeviationFromVertex(Vtx);
}
#ifdef HomogeneousField
inline Double_t KFParticle::GetDistanceFromVertex(const AliVVertex& Vtx) const
{
    return GetDistanceFromVertex(KFParticle(Vtx));
}
 
inline Double_t KFParticle::GetDeviationFromVertex(const AliVVertex& Vtx) const
{
    return GetDeviationFromVertex(KFParticle(Vtx));
}
#endif
inline Double_t KFParticle::GetDistanceFromParticle(const KFParticle& p) const
{
    return KFParticleBase::GetDistanceFromParticle(p);
}
 
inline Double_t KFParticle::GetDeviationFromParticle(const KFParticle& p) const
{
    return KFParticleBase::GetDeviationFromParticle(p);
}
 
inline void KFParticle::SubtractFromVertex(KFParticle& v) const
{
    KFParticleBase::SubtractFromVertex(v);
}
 
#ifdef HomogeneousField
inline Double_t KFParticle::GetFieldAlice()
{
    return fgBz;
}
#endif
 
#ifdef HomogeneousField
inline void KFParticle::GetFieldValue(const Double_t* /*xyz*/, Double_t B[]) const
{
    B[0] = B[1] = 0;
    B[2] = GetFieldAlice();
}
#endif
 
#ifdef NonhomogeneousField
inline void KFParticle::GetFieldValue(const Double_t xyz[], Double_t B[]) const
{
    FairField* MF = CbmKF::Instance()->GetMagneticField();
    MF->GetFieldValue(xyz, B);
}
#endif
 
inline void KFParticle::GetDStoParticle(const KFParticleBase& p, Double_t& DS, Double_t& DSp) const
{
    GetDStoParticleXY(p, DS, DSp);
}
 
inline void KFParticle::GetDStoParticleXY(const KFParticleBase& p, Double_t& DS, Double_t& DSp) const
{
#ifdef HomogeneousField
    KFParticleBase::GetDStoParticleBz(GetFieldAlice(), p, DS, DSp);
#endif
#ifdef NonhomogeneousField
    KFParticleBase::GetDStoParticleCBM(p, DS, DSp);
#endif
    // GetDStoParticleALICE( p, DS, DSp ) ;
}
 
inline void KFParticle::Transport(Double_t dS, Double_t P[], Double_t C[]) const
{
#ifdef HomogeneousField
    KFParticleBase::TransportBz(GetFieldAlice(), dS, P, C);
#endif
#ifdef NonhomogeneousField
    KFParticleBase::TransportCBM(dS, P, C);
#endif
}
 
inline void KFParticle::ConstructGamma(const KFParticle& daughter1, const KFParticle& daughter2)
{
#ifdef HomogeneousField
    KFParticleBase::ConstructGammaBz(daughter1, daughter2, GetFieldAlice());
#endif
}
 
#endif