[u/mrichter/AliRoot.git] / STEER / AliESDtrack.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

//-----------------------------------------------------------------
//           Implementation of the ESD track class
//   ESD = Event Summary Data
//   This is the class to deal with during the phisical analysis of data
//      Origin: Iouri Belikov, CERN
//      e-mail: Jouri.Belikov@cern.ch
//-----------------------------------------------------------------

#include "TMath.h"

#include "AliESDtrack.h"
#include "AliKalmanTrack.h"
#include "../ITS/AliITStrackV2.h"

ClassImp(AliESDtrack)

//_______________________________________________________________________
AliESDtrack::AliESDtrack() : 
fFlags(0),
fLabel(0),
fTrackLength(0),
fStopVertex(0),
fRalpha(0),
fRx(0),
fITSchi2(0),
fITSncls(0),
fITSsignal(0),
fVertexX(0),
fVertexY(0),
fVertexZ(0),
fVertexPx(0),
fVertexPy(0),
fVertexPz(0),
fVertex(kFALSE),
fTPCchi2(0),
fTPCncls(0),
fTPCsignal(0),
fTRDchi2(0),
fTRDncls(0),
fTRDsignal(0),
fTOFchi2(0),
fTOFindex(0),
fTOFsignal(0)
{
  //
  // The default ESD constructor 
  //
  for (Int_t i=0; i<kSPECIES; i++) {
    fTrackTime[i]=0;
    fR[i]=0;
    fITSr[i]=0;
    fTPCr[i]=0;
    fTRDr[i]=0;
    fTOFr[i]=0;
  }
  for (Int_t i=0; i<5; fRp[i++]);
  for (Int_t i=0; i<15; fRc[i++]);
  for (Int_t i=0; i<6; fITSindex[i++]);
  for (Int_t i=0; i<180; fTPCindex[i++]);
}

//_______________________________________________________________________
Float_t AliESDtrack::GetMass() const {
  // Returns the mass of the most probable particle type
  Float_t max=0.;
  Int_t k=-1;
  for (Int_t i=0; i<kSPECIES; i++) {
    if (fR[i]>max) {k=i; max=fR[i];}
  }
  if (k==0) return 0.00051;
  if (k==1) return 0.10566;
  if (k==2||k==-1) return 0.13957;
  if (k==3) return 0.49368;
  if (k==4) return 0.93827;
  Warning("GetMass()","Undefined mass !");
  return 0.13957;
}

//_______________________________________________________________________
Bool_t AliESDtrack::UpdateTrackParams(AliKalmanTrack *t, ULong_t flags) {
  //
  // This function updates track's running parameters 
  //
  switch (flags) {
    
  case kITSin:
  case kITSout: 
  case kITSrefit:
    fITSncls=t->GetNumberOfClusters();
    fITSchi2=t->GetChi2();
    for (Int_t i=0;i<fITSncls;i++) fITSindex[i]=t->GetClusterIndex(i);
    fITSsignal=t->GetPIDsignal();
    break;
    
  case kTPCin: case kTPCout: case kTPCrefit:
    fTPCncls=t->GetNumberOfClusters();
    fTPCchi2=t->GetChi2();
    for (Int_t i=0;i<fTPCncls;i++) fTPCindex[i]=t->GetClusterIndex(i);
    fTPCsignal=t->GetPIDsignal();
    {Double_t mass=t->GetMass();    // preliminary mass setting 
    if (mass>0.5) fR[4]=1.;         //        used by
    else if (mass<0.4) fR[2]=1.;    // the ITS reconstruction
    else fR[3]=1.;}                 //
    break;
  case kTRDin: case kTRDout: case kTRDrefit:
    fTRDncls=t->GetNumberOfClusters();
    fTRDchi2=t->GetChi2();
    fTRDsignal=t->GetPIDsignal();
    break;
  default: 
    Error("UpdateTrackParams()","Wrong flag !\n");
    return kFALSE;
  }

  SetStatus(flags);
  fLabel=t->GetLabel();

  if (t->IsStartedTimeIntegral()) {
    SetStatus(kTIME);
    Double_t times[10];t->GetIntegratedTimes(times); SetIntegratedTimes(times);
    SetIntegratedLength(t->GetIntegratedLength());
  }

  fRalpha=t->GetAlpha();
  t->GetExternalParameters(fRx,fRp);
  t->GetExternalCovariance(fRc);
  
  if (flags == kITSin)
   {
     AliITStrackV2* itstrack = dynamic_cast<AliITStrackV2*>(t);
     if (itstrack)
      {
        itstrack->PropagateTo(3.,0.0028,65.19);
        itstrack->PropagateToVertex();
        
        Double_t ralpha=t->GetAlpha();
        Double_t rx;      // X-coordinate of the track reference plane 
        Double_t rp[5];   // external track parameters  
        t->GetExternalParameters(rx,rp);
   
        Double_t phi=TMath::ASin(rp[2]) + ralpha;
        Double_t pt=1./TMath::Abs(rp[4]);
        Double_t r=TMath::Sqrt(rx*rx + rp[0]*rp[0]);
        
        fVertexX=r*TMath::Cos(phi); 
        fVertexY=r*TMath::Sin(phi); 
        fVertexZ=rp[1]; 
        
        fVertexPx = pt*TMath::Cos(phi); 
        fVertexPy = pt*TMath::Sin(phi); 
        fVertexPz = pt*rp[3]; 
        fVertex = kTRUE;
      }
   }
  
  return kTRUE;
}

//_______________________________________________________________________
void AliESDtrack::GetExternalParametersAt(Double_t x, Double_t p[5]) const {
  //---------------------------------------------------------------------
  // This function returns external representation of the track parameters
  // at the plane x
  //---------------------------------------------------------------------
  Double_t dx=x-fRx;
  Double_t c=fRp[4]/AliKalmanTrack::GetConvConst();
  Double_t f1=fRp[2], f2=f1 + c*dx;
  Double_t r1=sqrt(1.- f1*f1), r2=sqrt(1.- f2*f2);    

  p[0]=fRp[0]+dx*(f1+f2)/(r1+r2);
  p[1]=fRp[1]+dx*(f1+f2)/(f1*r2 + f2*r1)*fRp[3];
  p[2]=fRp[2]+dx*c;
  p[3]=fRp[3];
  p[4]=fRp[4];
}

//_______________________________________________________________________
void AliESDtrack::GetExternalParameters(Double_t &x, Double_t p[5]) const {
  //---------------------------------------------------------------------
  // This function returns external representation of the track parameters
  //---------------------------------------------------------------------
  x=fRx;
  for (Int_t i=0; i<5; i++) p[i]=fRp[i];
}

Double_t AliESDtrack::GetP() const {
  //---------------------------------------------------------------------
  // This function returns the track momentum
  //---------------------------------------------------------------------
  Double_t lam=TMath::ATan(fRp[3]);
  Double_t pt=1./TMath::Abs(fRp[4]);
  return pt/TMath::Cos(lam);
}

void AliESDtrack::GetPxPyPz(Double_t *p) const {
  //---------------------------------------------------------------------
  // This function returns the global track momentum components
  //---------------------------------------------------------------------
  Double_t phi=TMath::ASin(fRp[2]) + fRalpha;
  Double_t pt=1./TMath::Abs(fRp[4]);
  p[0]=pt*TMath::Cos(phi); p[1]=pt*TMath::Sin(phi); p[2]=pt*fRp[3]; 
}

void AliESDtrack::GetXYZ(Double_t *xyz) const {
  //---------------------------------------------------------------------
  // This function returns the global track position
  //---------------------------------------------------------------------
  Double_t phi=TMath::ASin(fRp[2]) + fRalpha;
  Double_t r=TMath::Sqrt(fRx*fRx + fRp[0]*fRp[0]);
  xyz[0]=r*TMath::Cos(phi); xyz[1]=r*TMath::Sin(phi); xyz[2]=fRp[1]; 
}

//_______________________________________________________________________
void AliESDtrack::GetExternalCovariance(Double_t c[15]) const {
  //---------------------------------------------------------------------
  // This function returns external representation of the cov. matrix
  //---------------------------------------------------------------------
  for (Int_t i=0; i<15; i++) c[i]=fRc[i];
}

//_______________________________________________________________________
void AliESDtrack::GetIntegratedTimes(Double_t *times) const {
  // Returns the array with integrated times for each particle hypothesis
  for (Int_t i=0; i<kSPECIES; i++) times[i]=fTrackTime[i];
}

//_______________________________________________________________________
void AliESDtrack::SetIntegratedTimes(const Double_t *times) {
  // Sets the array with integrated times for each particle hypotesis
  for (Int_t i=0; i<kSPECIES; i++) fTrackTime[i]=times[i];
}

//_______________________________________________________________________
void AliESDtrack::SetITSpid(const Double_t *p) {
  // Sets values for the probability of each particle type (in ITS)
  for (Int_t i=0; i<kSPECIES; i++) fITSr[i]=p[i];
  SetStatus(AliESDtrack::kITSpid);
}

//_______________________________________________________________________
void AliESDtrack::GetITSpid(Double_t *p) const {
  // Gets the probability of each particle type (in ITS)
  for (Int_t i=0; i<kSPECIES; i++) p[i]=fITSr[i];
}

//_______________________________________________________________________
Int_t AliESDtrack::GetITSclusters(UInt_t *idx) const {
  //---------------------------------------------------------------------
  // This function returns indices of the assgined ITS clusters 
  //---------------------------------------------------------------------
  for (Int_t i=0; i<fITSncls; i++) idx[i]=fITSindex[i];
  return fITSncls;
}

//_______________________________________________________________________
Int_t AliESDtrack::GetTPCclusters(Int_t *idx) const {
  //---------------------------------------------------------------------
  // This function returns indices of the assgined ITS clusters 
  //---------------------------------------------------------------------
  for (Int_t i=0; i<180; i++) idx[i]=fTPCindex[i];  // MI I prefer some constant
  return fTPCncls;
}

//_______________________________________________________________________
void AliESDtrack::SetTPCpid(const Double_t *p) {  
  // Sets values for the probability of each particle type (in TPC)
  for (Int_t i=0; i<kSPECIES; i++) fTPCr[i]=p[i];
  SetStatus(AliESDtrack::kTPCpid);
}

//_______________________________________________________________________
void AliESDtrack::GetTPCpid(Double_t *p) const {
  // Gets the probability of each particle type (in TPC)
  for (Int_t i=0; i<kSPECIES; i++) p[i]=fTPCr[i];
}

//_______________________________________________________________________
void AliESDtrack::SetTRDpid(const Double_t *p) {  
  // Sets values for the probability of each particle type (in TRD)
  for (Int_t i=0; i<kSPECIES; i++) fTRDr[i]=p[i];
  SetStatus(AliESDtrack::kTRDpid);
}

//_______________________________________________________________________
void AliESDtrack::GetTRDpid(Double_t *p) const {
  // Gets the probability of each particle type (in TRD)
  for (Int_t i=0; i<kSPECIES; i++) p[i]=fTRDr[i];
}

//_______________________________________________________________________
void    AliESDtrack::SetTRDpid(Int_t iSpecies, Float_t p)
{
  // Sets the probability of particle type iSpecies to p (in TRD)
  fTRDr[iSpecies] = p;
}

Float_t AliESDtrack::GetTRDpid(Int_t iSpecies) const
{
  // Returns the probability of particle type iSpecies (in TRD)
  return fTRDr[iSpecies];
}

//_______________________________________________________________________
void AliESDtrack::SetTOFpid(const Double_t *p) {  
  // Sets the probability of each particle type (in TOF)
  for (Int_t i=0; i<kSPECIES; i++) fTOFr[i]=p[i];
  SetStatus(AliESDtrack::kTOFpid);
}

//_______________________________________________________________________
void AliESDtrack::GetTOFpid(Double_t *p) const {
  // Gets probabilities of each particle type (in TOF)
  for (Int_t i=0; i<kSPECIES; i++) p[i]=fTOFr[i];
}

//_______________________________________________________________________
void AliESDtrack::SetESDpid(const Double_t *p) {  
  // Sets the probability of each particle type for the ESD track
  for (Int_t i=0; i<kSPECIES; i++) fR[i]=p[i];
  SetStatus(AliESDtrack::kESDpid);
}

//_______________________________________________________________________
void AliESDtrack::GetESDpid(Double_t *p) const {
  // Gets probability of each particle type for the ESD track
  for (Int_t i=0; i<kSPECIES; i++) p[i]=fR[i];
}

void AliESDtrack::GetVertexXYZ(Double_t& x,Double_t& y, Double_t&z) const
{
//returns track position in DCA to vertex  
  x = fVertexX;
  y = fVertexY;
  z = fVertexZ;
}
void AliESDtrack::GetVertexPxPyPz(Double_t& px,Double_t& py, Double_t& pz) const
{
//returns track momentum in DCA to vertex  
  px = fVertexPx;
  py = fVertexPy;
  pz = fVertexPz;
}
Commit	Line	Data
ae982df3	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
	16	//-----------------------------------------------------------------
	17	// Implementation of the ESD track class
4427806c	18	// ESD = Event Summary Data
ae982df3	19	// This is the class to deal with during the phisical analysis of data
4427806c	20	// Origin: Iouri Belikov, CERN
4427806c	21	// e-mail: Jouri.Belikov@cern.ch
ae982df3	22	//-----------------------------------------------------------------
	23
	24	#include "TMath.h"
	25
	26	#include "AliESDtrack.h"
	27	#include "AliKalmanTrack.h"
05e445cd	28	#include "../ITS/AliITStrackV2.h"
ae982df3	29
	30	ClassImp(AliESDtrack)
	31
	32	//_______________________________________________________________________
	33	AliESDtrack::AliESDtrack() :
2bad268c	34	fFlags(0),
	35	fLabel(0),
	36	fTrackLength(0),
	37	fStopVertex(0),
	38	fRalpha(0),
	39	fRx(0),
	40	fITSchi2(0),
ae982df3	41	fITSncls(0),
2bad268c	42	fITSsignal(0),
	43	fVertexX(0),
	44	fVertexY(0),
	45	fVertexZ(0),
	46	fVertexPx(0),
	47	fVertexPy(0),
	48	fVertexPz(0),
	49	fVertex(kFALSE),
	50	fTPCchi2(0),
05e445cd	51	fTPCncls(0),
2bad268c	52	fTPCsignal(0),
	53	fTRDchi2(0),
	54	fTRDncls(0),
	55	fTRDsignal(0),
	56	fTOFchi2(0),
	57	fTOFindex(0),
	58	fTOFsignal(0)
ae982df3	59	{
	60	//
	61	// The default ESD constructor
	62	//
2bad268c	63	for (Int_t i=0; i<kSPECIES; i++) {
	64	fTrackTime[i]=0;
	65	fR[i]=0;
	66	fITSr[i]=0;
	67	fTPCr[i]=0;
	68	fTRDr[i]=0;
	69	fTOFr[i]=0;
	70	}
	71	for (Int_t i=0; i<5; fRp[i++]);
	72	for (Int_t i=0; i<15; fRc[i++]);
	73	for (Int_t i=0; i<6; fITSindex[i++]);
	74	for (Int_t i=0; i<180; fTPCindex[i++]);
ae982df3	75	}
	76
	77	//_______________________________________________________________________
	78	Float_t AliESDtrack::GetMass() const {
4427806c	79	// Returns the mass of the most probable particle type
ae982df3	80	Float_t max=0.;
	81	Int_t k=-1;
	82	for (Int_t i=0; i<kSPECIES; i++) {
	83	if (fR[i]>max) {k=i; max=fR[i];}
	84	}
	85	if (k==0) return 0.00051;
	86	if (k==1) return 0.10566;
	87	if (k==2\|\|k==-1) return 0.13957;
	88	if (k==3) return 0.49368;
	89	if (k==4) return 0.93827;
	90	Warning("GetMass()","Undefined mass !");
	91	return 0.13957;
	92	}
	93
	94	//_______________________________________________________________________
ad2f1f2b	95	Bool_t AliESDtrack::UpdateTrackParams(AliKalmanTrack *t, ULong_t flags) {
ae982df3	96	//
	97	// This function updates track's running parameters
	98	//
	99	switch (flags) {
ad2f1f2b	100
	101	case kITSin:
	102	case kITSout:
	103	case kITSrefit:
ae982df3	104	fITSncls=t->GetNumberOfClusters();
	105	fITSchi2=t->GetChi2();
	106	for (Int_t i=0;i<fITSncls;i++) fITSindex[i]=t->GetClusterIndex(i);
	107	fITSsignal=t->GetPIDsignal();
	108	break;
ad2f1f2b	109
ae982df3	110	case kTPCin: case kTPCout: case kTPCrefit:
	111	fTPCncls=t->GetNumberOfClusters();
	112	fTPCchi2=t->GetChi2();
	113	for (Int_t i=0;i<fTPCncls;i++) fTPCindex[i]=t->GetClusterIndex(i);
	114	fTPCsignal=t->GetPIDsignal();
	115	{Double_t mass=t->GetMass(); // preliminary mass setting
	116	if (mass>0.5) fR[4]=1.; // used by
	117	else if (mass<0.4) fR[2]=1.; // the ITS reconstruction
	118	else fR[3]=1.;} //
	119	break;
79e94bf8	120	case kTRDin: case kTRDout: case kTRDrefit:
	121	fTRDncls=t->GetNumberOfClusters();
	122	fTRDchi2=t->GetChi2();
	123	fTRDsignal=t->GetPIDsignal();
	124	break;
ae982df3	125	default:
	126	Error("UpdateTrackParams()","Wrong flag !\n");
	127	return kFALSE;
	128	}
	129
	130	SetStatus(flags);
	131	fLabel=t->GetLabel();
	132
	133	if (t->IsStartedTimeIntegral()) {
	134	SetStatus(kTIME);
	135	Double_t times[10];t->GetIntegratedTimes(times); SetIntegratedTimes(times);
	136	SetIntegratedLength(t->GetIntegratedLength());
	137	}
	138
	139	fRalpha=t->GetAlpha();
	140	t->GetExternalParameters(fRx,fRp);
	141	t->GetExternalCovariance(fRc);
ad2f1f2b	142
	143	if (flags == kITSin)
	144	{
05e445cd	145	AliITStrackV2* itstrack = dynamic_cast<AliITStrackV2*>(t);
	146	if (itstrack)
	147	{
	148	itstrack->PropagateTo(3.,0.0028,65.19);
	149	itstrack->PropagateToVertex();
	150
	151	Double_t ralpha=t->GetAlpha();
	152	Double_t rx; // X-coordinate of the track reference plane
	153	Double_t rp[5]; // external track parameters
	154	t->GetExternalParameters(rx,rp);
	155
	156	Double_t phi=TMath::ASin(rp[2]) + ralpha;
	157	Double_t pt=1./TMath::Abs(rp[4]);
	158	Double_t r=TMath::Sqrt(rxrx + rp[0]rp[0]);
	159
	160	fVertexX=r*TMath::Cos(phi);
	161	fVertexY=r*TMath::Sin(phi);
	162	fVertexZ=rp[1];
	163
	164	fVertexPx = pt*TMath::Cos(phi);
	165	fVertexPy = pt*TMath::Sin(phi);
	166	fVertexPz = pt*rp[3];
	167	fVertex = kTRUE;
	168	}
ad2f1f2b	169	}
ad2f1f2b	170
ae982df3	171	return kTRUE;
	172	}
	173
e23730c7	174	//_______________________________________________________________________
	175	void AliESDtrack::GetExternalParametersAt(Double_t x, Double_t p[5]) const {
	176	//---------------------------------------------------------------------
	177	// This function returns external representation of the track parameters
	178	// at the plane x
	179	//---------------------------------------------------------------------
	180	Double_t dx=x-fRx;
	181	Double_t c=fRp[4]/AliKalmanTrack::GetConvConst();
	182	Double_t f1=fRp[2], f2=f1 + c*dx;
	183	Double_t r1=sqrt(1.- f1f1), r2=sqrt(1.- f2f2);
	184
	185	p[0]=fRp[0]+dx*(f1+f2)/(r1+r2);
	186	p[1]=fRp[1]+dx(f1+f2)/(f1r2 + f2r1)fRp[3];
	187	p[2]=fRp[2]+dx*c;
	188	p[3]=fRp[3];
	189	p[4]=fRp[4];
	190	}
	191
ae982df3	192	//_______________________________________________________________________
	193	void AliESDtrack::GetExternalParameters(Double_t &x, Double_t p[5]) const {
	194	//---------------------------------------------------------------------
	195	// This function returns external representation of the track parameters
	196	//---------------------------------------------------------------------
	197	x=fRx;
	198	for (Int_t i=0; i<5; i++) p[i]=fRp[i];
	199	}
	200
	201	Double_t AliESDtrack::GetP() const {
	202	//---------------------------------------------------------------------
	203	// This function returns the track momentum
	204	//---------------------------------------------------------------------
	205	Double_t lam=TMath::ATan(fRp[3]);
	206	Double_t pt=1./TMath::Abs(fRp[4]);
	207	return pt/TMath::Cos(lam);
	208	}
	209
	210	void AliESDtrack::GetPxPyPz(Double_t *p) const {
	211	//---------------------------------------------------------------------
	212	// This function returns the global track momentum components
	213	//---------------------------------------------------------------------
	214	Double_t phi=TMath::ASin(fRp[2]) + fRalpha;
	215	Double_t pt=1./TMath::Abs(fRp[4]);
	216	p[0]=ptTMath::Cos(phi); p[1]=ptTMath::Sin(phi); p[2]=pt*fRp[3];
	217	}
	218
	219	void AliESDtrack::GetXYZ(Double_t *xyz) const {
	220	//---------------------------------------------------------------------
	221	// This function returns the global track position
	222	//---------------------------------------------------------------------
	223	Double_t phi=TMath::ASin(fRp[2]) + fRalpha;
	224	Double_t r=TMath::Sqrt(fRxfRx + fRp[0]fRp[0]);
	225	xyz[0]=rTMath::Cos(phi); xyz[1]=rTMath::Sin(phi); xyz[2]=fRp[1];
	226	}
	227
	228	//_______________________________________________________________________
	229	void AliESDtrack::GetExternalCovariance(Double_t c[15]) const {
	230	//---------------------------------------------------------------------
	231	// This function returns external representation of the cov. matrix
	232	//---------------------------------------------------------------------
	233	for (Int_t i=0; i<15; i++) c[i]=fRc[i];
	234	}
	235
	236	//_______________________________________________________________________
	237	void AliESDtrack::GetIntegratedTimes(Double_t *times) const {
4427806c	238	// Returns the array with integrated times for each particle hypothesis
ae982df3	239	for (Int_t i=0; i<kSPECIES; i++) times[i]=fTrackTime[i];
	240	}
	241
	242	//_______________________________________________________________________
	243	void AliESDtrack::SetIntegratedTimes(const Double_t *times) {
4427806c	244	// Sets the array with integrated times for each particle hypotesis
ae982df3	245	for (Int_t i=0; i<kSPECIES; i++) fTrackTime[i]=times[i];
	246	}
	247
c630aafd	248	//_______________________________________________________________________
4427806c	249	void AliESDtrack::SetITSpid(const Double_t *p) {
4427806c	250	// Sets values for the probability of each particle type (in ITS)
c630aafd	251	for (Int_t i=0; i<kSPECIES; i++) fITSr[i]=p[i];
	252	SetStatus(AliESDtrack::kITSpid);
	253	}
	254
	255	//_______________________________________________________________________
	256	void AliESDtrack::GetITSpid(Double_t *p) const {
4427806c	257	// Gets the probability of each particle type (in ITS)
c630aafd	258	for (Int_t i=0; i<kSPECIES; i++) p[i]=fITSr[i];
	259	}
	260
ae982df3	261	//_______________________________________________________________________
	262	Int_t AliESDtrack::GetITSclusters(UInt_t *idx) const {
	263	//---------------------------------------------------------------------
	264	// This function returns indices of the assgined ITS clusters
	265	//---------------------------------------------------------------------
	266	for (Int_t i=0; i<fITSncls; i++) idx[i]=fITSindex[i];
	267	return fITSncls;
	268	}
	269
	270	//_______________________________________________________________________
05e445cd	271	Int_t AliESDtrack::GetTPCclusters(Int_t *idx) const {
ae982df3	272	//---------------------------------------------------------------------
	273	// This function returns indices of the assgined ITS clusters
	274	//---------------------------------------------------------------------
05e445cd	275	for (Int_t i=0; i<180; i++) idx[i]=fTPCindex[i]; // MI I prefer some constant
ae982df3	276	return fTPCncls;
ae982df3	277	}
8c6a71ab	278
	279	//_______________________________________________________________________
	280	void AliESDtrack::SetTPCpid(const Double_t *p) {
4427806c	281	// Sets values for the probability of each particle type (in TPC)
8c6a71ab	282	for (Int_t i=0; i<kSPECIES; i++) fTPCr[i]=p[i];
	283	SetStatus(AliESDtrack::kTPCpid);
	284	}
	285
	286	//_______________________________________________________________________
	287	void AliESDtrack::GetTPCpid(Double_t *p) const {
4427806c	288	// Gets the probability of each particle type (in TPC)
8c6a71ab	289	for (Int_t i=0; i<kSPECIES; i++) p[i]=fTPCr[i];
	290	}
	291
c630aafd	292	//_______________________________________________________________________
c630aafd	293	void AliESDtrack::SetTRDpid(const Double_t *p) {
4427806c	294	// Sets values for the probability of each particle type (in TRD)
c630aafd	295	for (Int_t i=0; i<kSPECIES; i++) fTRDr[i]=p[i];
	296	SetStatus(AliESDtrack::kTRDpid);
	297	}
	298
	299	//_______________________________________________________________________
	300	void AliESDtrack::GetTRDpid(Double_t *p) const {
4427806c	301	// Gets the probability of each particle type (in TRD)
c630aafd	302	for (Int_t i=0; i<kSPECIES; i++) p[i]=fTRDr[i];
	303	}
	304
79e94bf8	305	//_______________________________________________________________________
	306	void AliESDtrack::SetTRDpid(Int_t iSpecies, Float_t p)
	307	{
4427806c	308	// Sets the probability of particle type iSpecies to p (in TRD)
79e94bf8	309	fTRDr[iSpecies] = p;
	310	}
	311
	312	Float_t AliESDtrack::GetTRDpid(Int_t iSpecies) const
	313	{
4427806c	314	// Returns the probability of particle type iSpecies (in TRD)
79e94bf8	315	return fTRDr[iSpecies];
	316	}
	317
c630aafd	318	//_______________________________________________________________________
c630aafd	319	void AliESDtrack::SetTOFpid(const Double_t *p) {
4427806c	320	// Sets the probability of each particle type (in TOF)
c630aafd	321	for (Int_t i=0; i<kSPECIES; i++) fTOFr[i]=p[i];
	322	SetStatus(AliESDtrack::kTOFpid);
	323	}
	324
	325	//_______________________________________________________________________
	326	void AliESDtrack::GetTOFpid(Double_t *p) const {
4427806c	327	// Gets probabilities of each particle type (in TOF)
c630aafd	328	for (Int_t i=0; i<kSPECIES; i++) p[i]=fTOFr[i];
	329	}
	330
8c6a71ab	331	//_______________________________________________________________________
8c6a71ab	332	void AliESDtrack::SetESDpid(const Double_t *p) {
4427806c	333	// Sets the probability of each particle type for the ESD track
8c6a71ab	334	for (Int_t i=0; i<kSPECIES; i++) fR[i]=p[i];
	335	SetStatus(AliESDtrack::kESDpid);
	336	}
	337
	338	//_______________________________________________________________________
	339	void AliESDtrack::GetESDpid(Double_t *p) const {
4427806c	340	// Gets probability of each particle type for the ESD track
8c6a71ab	341	for (Int_t i=0; i<kSPECIES; i++) p[i]=fR[i];
	342	}
	343
ad2f1f2b	344	void AliESDtrack::GetVertexXYZ(Double_t& x,Double_t& y, Double_t&z) const
	345	{
	346	//returns track position in DCA to vertex
	347	x = fVertexX;
	348	y = fVertexY;
	349	z = fVertexZ;
	350	}
	351	void AliESDtrack::GetVertexPxPyPz(Double_t& px,Double_t& py, Double_t& pz) const
	352	{
	353	//returns track momentum in DCA to vertex
	354	px = fVertexPx;
	355	py = fVertexPy;
	356	pz = fVertexPz;
	357	}