#define ALIKFPARTICLE_H
#include "AliKFParticleBase.h"
-#include "AliESDVertex.h"
-
-class AliExternalTrackParam;
+#include "TMath.h"
+class AliVTrack;
+class AliVVertex;
class AliKFParticle :public AliKFParticleBase
{
//* INITIALIZATION
//*
+ //* Set magnetic field for all particles
+
+ static void SetField( Double_t Bz );
+
//* Constructor (empty)
- AliKFParticle():AliKFParticleBase(), fBz(0) {}
+ AliKFParticle():AliKFParticleBase(){ ; }
//* Destructor (empty)
- ~AliKFParticle(){}
+ ~AliKFParticle(){ ; }
- //* Initialisation from ALICE track, PID hypothesis can be provided
+ //* Construction of mother particle by its 2-3-4 daughters
- AliKFParticle( const AliExternalTrackParam &track, Double_t bz, Int_t PID = 211 );
+ AliKFParticle( const AliKFParticle &d1, const AliKFParticle &d2 );
+
+ AliKFParticle( const AliKFParticle &d1, const AliKFParticle &d2,
+ const AliKFParticle &d3 );
+
+ AliKFParticle( const AliKFParticle &d1, const AliKFParticle &d2,
+ const AliKFParticle &d3, const AliKFParticle &d4 );
+
+ //* Initialisation from "cartesian" coordinates ( X Y Z Px Py Pz )
+ //* Parameters, covariance matrix, charge and PID hypothesis should be provided
- //* Initialisation from ESD vertex
+ void Create( const Double_t Param[], const Double_t Cov[], Int_t Charge, Int_t PID );
- AliKFParticle( const AliESDVertex &vertex, Double_t bz );
+ //* Initialisation from ALICE track, PID hypothesis shoould be provided
- void SetBz(Double_t bz) {fBz=bz;}
- Double_t GetBz() const {return fBz;}
+ AliKFParticle( const AliVTrack &track, Int_t PID );
- //* Copy vertex part to ESD vertex
+ //* Initialisation from VVertex
- void CopyToESDVertex( AliESDVertex &Vtx ) const ;
+ AliKFParticle( const AliVVertex &vertex );
//* Initialise covariance matrix and set current parameters to 0.0
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 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 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 GetMomentum ( Double_t &P, Double_t &SigmaP ) const ;
- int GetMass ( Double_t &M, Double_t &SigmaM ) const ;
- int GetDecayLength ( Double_t &L, Double_t &SigmaL ) const ;
- int GetLifeTime ( Double_t &T, Double_t &SigmaT ) const ;
+ 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 GetLifeTime ( Double_t &T, Double_t &SigmaT ) const ; //* life time
+ int GetR ( Double_t &R, Double_t &SigmaR ) const ; //* R
+
//*
//* MODIFIERS
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
//*
- //* Simple way to construct particles ex. D0 = Pion + Kaon;
+ //* Add daughter to the particle
- AliKFParticle operator +( const AliKFParticle &Daughter ) const;
-
- void operator +=( const AliKFParticle &Daughter );
+ void AddDaughter( const AliKFParticle &Daughter );
- //* Add daughter track to the particle
+ //* Add daughter via += operator: ex.{ D0; D0+=Pion; D0+= Kaon; }
- void AddDaughter( const AliKFParticle &Daughter );
+ void operator +=( const AliKFParticle &Daughter );
//* Set production vertex
void SetProductionVertex( const AliKFParticle &Vtx );
- //* Set hard mass constraint
+ //* Set mass constraint
- void SetMassConstraint( Double_t Mass );
+ void SetMassConstraint( Double_t Mass, Double_t SigmaMass = 0 );
+ //* Set no decay length for resonances
+
+ void SetNoDecayLength();
+
//* Everything in one go
void Construct( const AliKFParticle *vDaughters[], int NDaughters,
- const AliKFParticle *ProdVtx=0, Double_t Mass=-1 );
+ const AliKFParticle *ProdVtx=0, Double_t Mass=-1, Bool_t IsConstrained=0 );
//*
//* TRANSPORT
void TransportToPoint( const Double_t xyz[] );
- //* Transport the particle close to ESD vertex
+ //* Transport the particle close to VVertex
- void TransportToVertex( const AliESDVertex &v );
+ void TransportToVertex( const AliVVertex &v );
//* Transport the particle close to another particle p
void GetDStoParticle( const AliKFParticle &p,
Double_t &DS, Double_t &DSp ) const ;
+ //* Get dS to other particle p in XY-plane
+
+ void GetDStoParticleXY( const AliKFParticleBase &p,
+ Double_t &DS, Double_t &DSp ) const ;
+
//*
//* OTHER UTILITIES
//*
Double_t GetDistanceFromVertex( const Double_t vtx[] ) const ;
Double_t GetDistanceFromVertex( const AliKFParticle &Vtx ) const ;
- Double_t GetDistanceFromVertex( const AliESDVertex &Vtx ) const ;
+ Double_t GetDistanceFromVertex( const AliVVertex &Vtx ) const ;
Double_t GetDistanceFromParticle( const AliKFParticle &p ) const ;
//* Calculate sqrt(Chi2/ndf) deviation from another object
Double_t GetDeviationFromVertex( const Double_t v[], const Double_t Cv[]=0 ) const ;
Double_t GetDeviationFromVertex( const AliKFParticle &Vtx ) const ;
- Double_t GetDeviationFromVertex( const AliESDVertex &Vtx ) const ;
+ Double_t GetDeviationFromVertex( const AliVVertex &Vtx ) const ;
Double_t GetDeviationFromParticle( const AliKFParticle &p ) const ;
+
+ //* Calculate distance from another object [cm] in XY-plane
+
+ Double_t GetDistanceFromVertexXY( const Double_t vtx[] ) const ;
+ Double_t GetDistanceFromVertexXY( const AliKFParticle &Vtx ) const ;
+ Double_t GetDistanceFromVertexXY( const AliVVertex &Vtx ) const ;
+ Double_t GetDistanceFromParticleXY( const AliKFParticle &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 AliKFParticle &Vtx ) const ;
+ Double_t GetDeviationFromVertexXY( const AliVVertex &Vtx ) const ;
+ Double_t GetDeviationFromParticleXY( const AliKFParticle &p ) const ;
+
+ //* Calculate opennig angle between two particles
+
+ Double_t GetAngle ( const AliKFParticle &p ) const ;
+ Double_t GetAngleXY( const AliKFParticle &p ) const ;
+ Double_t GetAngleRZ( const AliKFParticle &p ) const ;
//* Subtract the particle from the vertex
void SubtractFromVertex( AliKFParticle &v ) const ;
- void SubtractFromVertex( AliESDVertex &v ) const ;
-
protected:
//*
//* INTERNAL STUFF
- //*
+ //*
//* Method to access ALICE field
- Double_t GetFieldAlice() const ;
+ static Double_t GetFieldAlice();
//* Other methods required by the abstract AliKFParticleBase class
void GetFieldValue( const Double_t xyz[], Double_t B[] ) const ;
void GetDStoParticle( const AliKFParticleBase &p, Double_t &DS, Double_t &DSp )const ;
void Transport( Double_t dS, Double_t P[], Double_t C[] ) const ;
+ static void GetExternalTrackParam( const AliKFParticleBase &p, Double_t &X, Double_t &Alpha, Double_t P[5] ) ;
+
+ //void GetDStoParticleALICE( const AliKFParticleBase &p, Double_t &DS, Double_t &DS1 ) const;
+
+
+ private:
-private:
- Double_t fBz; // Bz compoment of the magnetic field
+ static Double_t fgBz; //* Bz compoment of the magnetic field
- ClassDef( AliKFParticle, 2 );
+ ClassDef( AliKFParticle, 1 );
};
//---------------------------------------------------------------------
+inline void AliKFParticle::SetField( Double_t Bz )
+{
+ fgBz = -Bz;//!!!
+}
+
+
+inline AliKFParticle::AliKFParticle( const AliKFParticle &d1,
+ const AliKFParticle &d2 )
+{
+ AliKFParticle mother;
+ mother+= d1;
+ mother+= d2;
+ *this = mother;
+}
+
+inline AliKFParticle::AliKFParticle( const AliKFParticle &d1,
+ const AliKFParticle &d2,
+ const AliKFParticle &d3 )
+{
+ AliKFParticle mother;
+ mother+= d1;
+ mother+= d2;
+ mother+= d3;
+ *this = mother;
+}
+
+inline AliKFParticle::AliKFParticle( const AliKFParticle &d1,
+ const AliKFParticle &d2,
+ const AliKFParticle &d3,
+ const AliKFParticle &d4 )
+{
+ AliKFParticle mother;
+ mother+= d1;
+ mother+= d2;
+ mother+= d3;
+ mother+= d4;
+ *this = mother;
+}
+
inline void AliKFParticle::Initialize()
{
return AliKFParticleBase::GetCovariance(i,j);
}
+
+inline Double_t AliKFParticle::GetP () const
+{
+ Double_t par, err;
+ if( AliKFParticleBase::GetMomentum( par, err ) ) return 0;
+ else return par;
+}
+
+inline Double_t AliKFParticle::GetPt () const
+{
+ Double_t par, err;
+ if( AliKFParticleBase::GetPt( par, err ) ) return 0;
+ else return par;
+}
+
+inline Double_t AliKFParticle::GetEta () const
+{
+ Double_t par, err;
+ if( AliKFParticleBase::GetEta( par, err ) ) return 0;
+ else return par;
+}
+
+inline Double_t AliKFParticle::GetPhi () const
+{
+ Double_t par, err;
+ if( AliKFParticleBase::GetPhi( par, err ) ) return 0;
+ else return par;
+}
+
+inline Double_t AliKFParticle::GetMomentum () const
+{
+ Double_t par, err;
+ if( AliKFParticleBase::GetMomentum( par, err ) ) return 0;
+ else return par;
+}
+
+inline Double_t AliKFParticle::GetMass () const
+{
+ Double_t par, err;
+ if( AliKFParticleBase::GetMass( par, err ) ) return 0;
+ else return par;
+}
+
+inline Double_t AliKFParticle::GetDecayLength () const
+{
+ Double_t par, err;
+ if( AliKFParticleBase::GetDecayLength( par, err ) ) return 0;
+ else return par;
+}
+
+inline Double_t AliKFParticle::GetLifeTime () const
+{
+ Double_t par, err;
+ if( AliKFParticleBase::GetLifeTime( par, err ) ) return 0;
+ else return par;
+}
+
+inline Double_t AliKFParticle::GetR () const
+{
+ Double_t par, err;
+ if( AliKFParticleBase::GetR( par, err ) ) return 0;
+ else return par;
+}
+
+inline Double_t AliKFParticle::GetErrX () const
+{
+ return TMath::Sqrt(TMath::Abs( GetCovariance(0,0) ));
+}
+
+inline Double_t AliKFParticle::GetErrY () const
+{
+ return TMath::Sqrt(TMath::Abs( GetCovariance(1,1) ));
+}
+
+inline Double_t AliKFParticle::GetErrZ () const
+{
+ return TMath::Sqrt(TMath::Abs( GetCovariance(2,2) ));
+}
+
+inline Double_t AliKFParticle::GetErrPx () const
+{
+ return TMath::Sqrt(TMath::Abs( GetCovariance(3,3) ));
+}
+
+inline Double_t AliKFParticle::GetErrPy () const
+{
+ return TMath::Sqrt(TMath::Abs( GetCovariance(4,4) ));
+}
+
+inline Double_t AliKFParticle::GetErrPz () const
+{
+ return TMath::Sqrt(TMath::Abs( GetCovariance(5,5) ));
+}
+
+inline Double_t AliKFParticle::GetErrE () const
+{
+ return TMath::Sqrt(TMath::Abs( GetCovariance(6,6) ));
+}
+
+inline Double_t AliKFParticle::GetErrS () const
+{
+ return TMath::Sqrt(TMath::Abs( GetCovariance(7,7) ));
+}
+
+inline Double_t AliKFParticle::GetErrP () const
+{
+ Double_t par, err;
+ if( AliKFParticleBase::GetMomentum( par, err ) ) return 1.e10;
+ else return err;
+}
+
+inline Double_t AliKFParticle::GetErrPt () const
+{
+ Double_t par, err;
+ if( AliKFParticleBase::GetPt( par, err ) ) return 1.e10;
+ else return err;
+}
+
+inline Double_t AliKFParticle::GetErrEta () const
+{
+ Double_t par, err;
+ if( AliKFParticleBase::GetEta( par, err ) ) return 1.e10;
+ else return err;
+}
+
+inline Double_t AliKFParticle::GetErrPhi () const
+{
+ Double_t par, err;
+ if( AliKFParticleBase::GetPhi( par, err ) ) return 1.e10;
+ else return err;
+}
+
+inline Double_t AliKFParticle::GetErrMomentum () const
+{
+ Double_t par, err;
+ if( AliKFParticleBase::GetMomentum( par, err ) ) return 1.e10;
+ else return err;
+}
+
+inline Double_t AliKFParticle::GetErrMass () const
+{
+ Double_t par, err;
+ if( AliKFParticleBase::GetMass( par, err ) ) return 1.e10;
+ else return err;
+}
+
+inline Double_t AliKFParticle::GetErrDecayLength () const
+{
+ Double_t par, err;
+ if( AliKFParticleBase::GetDecayLength( par, err ) ) return 1.e10;
+ else return err;
+}
+
+inline Double_t AliKFParticle::GetErrLifeTime () const
+{
+ Double_t par, err;
+ if( AliKFParticleBase::GetLifeTime( par, err ) ) return 1.e10;
+ else return err;
+}
+
+inline Double_t AliKFParticle::GetErrR () const
+{
+ Double_t par, err;
+ if( AliKFParticleBase::GetR( par, err ) ) return 1.e10;
+ else return err;
+}
+
+
+inline int AliKFParticle::GetP( Double_t &P, Double_t &SigmaP ) const
+{
+ return AliKFParticleBase::GetMomentum( P, SigmaP );
+}
+
+inline int AliKFParticle::GetPt( Double_t &Pt, Double_t &SigmaPt ) const
+{
+ return AliKFParticleBase::GetPt( Pt, SigmaPt );
+}
+
+inline int AliKFParticle::GetEta( Double_t &Eta, Double_t &SigmaEta ) const
+{
+ return AliKFParticleBase::GetEta( Eta, SigmaEta );
+}
+
+inline int AliKFParticle::GetPhi( Double_t &Phi, Double_t &SigmaPhi ) const
+{
+ return AliKFParticleBase::GetPhi( Phi, SigmaPhi );
+}
+
inline int AliKFParticle::GetMomentum( Double_t &P, Double_t &SigmaP ) const
{
return AliKFParticleBase::GetMomentum( P, SigmaP );
return AliKFParticleBase::GetLifeTime( T, SigmaT );
}
+inline int AliKFParticle::GetR( Double_t &R, Double_t &SigmaR ) const
+{
+ return AliKFParticleBase::GetR( R, SigmaR );
+}
+
inline Double_t & AliKFParticle::X()
{
return AliKFParticleBase::X();
return AliKFParticleBase::Covariance(i,j);
}
+inline Double_t * AliKFParticle::Parameters ()
+{
+ return fP;
+}
+
+inline Double_t * AliKFParticle::CovarianceMatrix()
+{
+ return fC;
+}
+
inline void AliKFParticle::operator +=( const AliKFParticle &Daughter )
{
AliKFParticleBase::operator +=( Daughter );
}
-inline AliKFParticle AliKFParticle::operator +( const AliKFParticle &Daughter ) const
-{
- AliKFParticle tmp;
- const AliKFParticle *v[2] = {this, &Daughter };
- tmp.Construct( v,2);
- return tmp;
-}
inline void AliKFParticle::AddDaughter( const AliKFParticle &Daughter )
{
AliKFParticleBase::SetProductionVertex( Vtx );
}
-inline void AliKFParticle::SetMassConstraint( Double_t Mass )
+inline void AliKFParticle::SetMassConstraint( Double_t Mass, Double_t SigmaMass )
{
- AliKFParticleBase::SetMassConstraint( Mass );
+ AliKFParticleBase::SetMassConstraint( Mass, SigmaMass );
}
-
+
+inline void AliKFParticle::SetNoDecayLength()
+{
+ AliKFParticleBase::SetNoDecayLength();
+}
+
inline void AliKFParticle::Construct( const AliKFParticle *vDaughters[], int NDaughters,
- const AliKFParticle *ProdVtx, Double_t Mass )
+ const AliKFParticle *ProdVtx, Double_t Mass, Bool_t IsConstrained )
{
AliKFParticleBase::Construct( ( const AliKFParticleBase**)vDaughters, NDaughters,
- ( const AliKFParticleBase*)ProdVtx, Mass );
+ ( const AliKFParticleBase*)ProdVtx, Mass, IsConstrained );
}
inline void AliKFParticle::TransportToDecayVertex()
TransportToDS( GetDStoPoint(xyz) );
}
-inline void AliKFParticle::TransportToVertex( const AliESDVertex &v )
+inline void AliKFParticle::TransportToVertex( const AliVVertex &v )
{
- TransportToPoint( AliKFParticle(v,fBz).fP );
+ TransportToPoint( AliKFParticle(v).fP );
}
inline void AliKFParticle::TransportToParticle( const AliKFParticle &p )
{
return AliKFParticleBase::GetDStoPointBz( GetFieldAlice(), xyz );
}
+
inline void AliKFParticle::GetDStoParticle( const AliKFParticle &p,
- Double_t &DS, Double_t &DSp ) const
+ Double_t &DS, Double_t &DSp ) const
{
- return AliKFParticleBase::GetDStoParticleBz( GetFieldAlice(), p, DS,DSp);
+ GetDStoParticleXY( p, DS, DSp );
}
return AliKFParticleBase::GetDeviationFromVertex( Vtx );
}
-inline Double_t AliKFParticle::GetDistanceFromVertex( const AliESDVertex &Vtx ) const
+inline Double_t AliKFParticle::GetDistanceFromVertex( const AliVVertex &Vtx ) const
{
- return GetDistanceFromVertex( AliKFParticle(Vtx,fBz) );
+ return GetDistanceFromVertex( AliKFParticle(Vtx) );
}
-inline Double_t AliKFParticle::GetDeviationFromVertex( const AliESDVertex &Vtx ) const
+inline Double_t AliKFParticle::GetDeviationFromVertex( const AliVVertex &Vtx ) const
{
- return GetDeviationFromVertex( AliKFParticle(Vtx,fBz) );
+ return GetDeviationFromVertex( AliKFParticle(Vtx) );
}
inline Double_t AliKFParticle::GetDistanceFromParticle( const AliKFParticle &p ) const
{
- return AliKFParticleBase::GetDistanceFromParticleBz( GetFieldAlice(), p);
+ return AliKFParticleBase::GetDistanceFromParticle( p );
}
inline Double_t AliKFParticle::GetDeviationFromParticle( const AliKFParticle &p ) const
{
- return AliKFParticleBase::GetDeviationFromParticleBz( GetFieldAlice(),p);
+ return AliKFParticleBase::GetDeviationFromParticle( p );
}
inline void AliKFParticle::SubtractFromVertex( AliKFParticle &v ) const
AliKFParticleBase::SubtractFromVertex( v.fP, v.fC, v.fChi2, v.fNDF);
}
-inline void AliKFParticle::SubtractFromVertex( AliESDVertex &v ) const
-{
- AliKFParticle vTmp(v,fBz);
- SubtractFromVertex( vTmp );
- v = AliESDVertex( vTmp.fP, vTmp.fC, vTmp.fChi2, (vTmp.fNDF +3)/2, v.GetName() );
-}
-
-inline void AliKFParticle::CopyToESDVertex( AliESDVertex &v ) const
-{
- AliKFParticle vTmp=*this;
- v = AliESDVertex( vTmp.fP, vTmp.fC, vTmp.fChi2, (vTmp.fNDF +3)/2 );
-}
-
-inline Double_t AliKFParticle::GetFieldAlice() const
+inline Double_t AliKFParticle::GetFieldAlice()
{
- return fBz;
+ return fgBz;
}
inline void AliKFParticle::GetFieldValue( const Double_t * /*xyz*/, Double_t B[] ) const
}
inline void AliKFParticle::GetDStoParticle( const AliKFParticleBase &p,
- Double_t &DS, Double_t &DSp )const
+ Double_t &DS, Double_t &DSp )const
{
- return AliKFParticleBase::GetDStoParticleBz( GetFieldAlice(), p, DS,DSp);
+ GetDStoParticleXY( p, DS, DSp );
+}
+
+inline void AliKFParticle::GetDStoParticleXY( const AliKFParticleBase &p,
+ Double_t &DS, Double_t &DSp ) const
+{
+ AliKFParticleBase::GetDStoParticleBz( GetFieldAlice(), p, DS, DSp ) ;
+ //GetDStoParticleALICE( p, DS, DSp ) ;
}
inline void AliKFParticle::Transport( Double_t dS, Double_t P[], Double_t C[] ) const
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff