[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"

ClassImp(AliESDtrack)

//_______________________________________________________________________
AliESDtrack::AliESDtrack() : 
fFlags(0),
fLabel(0),
fTrackLength(0),
fStopVertex(0),
fRalpha(0),
fRx(0),
fITSchi2(0),
fITSncls(0),
fITSsignal(0),
fTPCchi2(0),
fTPCncls(0),
fTPCsignal(0),
fTRDchi2(0),
fTRDncls(0),
fTRDsignal(0),
fTOFchi2(0),
fTOFindex(0),
fTOFsignal(-1)
{
  //
  // 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;
  }
  Int_t i;
  for (i=0; i<5; i++)   fRp[i]=0.;
  for (i=0; i<15; i++)  fRc[i]=0.;
  for (i=0; i<6; i++)   fITSindex[i]=0;
  for (i=0; i<180; i++) fTPCindex[i]=0;
}

//_______________________________________________________________________
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 
  //
  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);

  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 kTPCrefit:
    fIalpha=fRalpha;
    fIx=fRx;
    {
      Int_t i;
      for (i=0; i<5; i++) fIp[i]=fRp[i];
      for (i=0; i<15;i++) fIc[i]=fRc[i];
    }
  case kTPCout:
    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 kTRDout:
    { //requested by the PHOS  ("temporary solution")
      Double_t r=474.;
      t->PropagateTo(r,30.,0.);  
      fOalpha=fRalpha;
      fOx=fRx;
      Int_t i;
      for (i=0; i<5; i++) fOp[i]=fRp[i];
      for (i=0; i<15;i++) fOc[i]=fRc[i];
    }
  case kTRDin: case kTRDrefit:
    fTRDncls=t->GetNumberOfClusters();
    fTRDchi2=t->GetChi2();
    for (Int_t i=0;i<fTRDncls;i++) fTRDindex[i]=t->GetClusterIndex(i);
    fTRDsignal=t->GetPIDsignal();
    break;

  default: 
    Error("UpdateTrackParams()","Wrong flag !\n");
    return kFALSE;
  }

  return kTRUE;
}

//_______________________________________________________________________
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::ATan2(fRp[0],fRx) + 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::GetInnerPxPyPz(Double_t *p) const {
  //---------------------------------------------------------------------
  // This function returns the global track momentum components
  // af the entrance of the TPC
  //---------------------------------------------------------------------
  Double_t phi=TMath::ASin(fIp[2]) + fIalpha;
  Double_t pt=1./TMath::Abs(fIp[4]);
  p[0]=pt*TMath::Cos(phi); p[1]=pt*TMath::Sin(phi); p[2]=pt*fIp[3]; 
}

void AliESDtrack::GetInnerXYZ(Double_t *xyz) const {
  //---------------------------------------------------------------------
  // This function returns the global track position
  // af the entrance of the TPC
  //---------------------------------------------------------------------
  Double_t phi=TMath::ATan2(fIp[0],fIx) + fIalpha;
  Double_t r=TMath::Sqrt(fIx*fIx + fIp[0]*fIp[0]);
  xyz[0]=r*TMath::Cos(phi); xyz[1]=r*TMath::Sin(phi); xyz[2]=fIp[1]; 
}

void AliESDtrack::GetOuterPxPyPz(Double_t *p) const {
  //---------------------------------------------------------------------
  // This function returns the global track momentum components
  // af the radius of the PHOS
  //---------------------------------------------------------------------
  Double_t phi=TMath::ASin(fOp[2]) + fOalpha;
  Double_t pt=1./TMath::Abs(fOp[4]);
  p[0]=pt*TMath::Cos(phi); p[1]=pt*TMath::Sin(phi); p[2]=pt*fOp[3]; 
}

void AliESDtrack::GetOuterXYZ(Double_t *xyz) const {
  //---------------------------------------------------------------------
  // This function returns the global track position
  // af the radius of the PHOS
  //---------------------------------------------------------------------
  Double_t phi=TMath::ATan2(fOp[0],fOx) + fOalpha;
  Double_t r=TMath::Sqrt(fOx*fOx + fOp[0]*fOp[0]);
  xyz[0]=r*TMath::Cos(phi); xyz[1]=r*TMath::Sin(phi); xyz[2]=fOp[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];
}

//_______________________________________________________________________
Int_t AliESDtrack::GetTRDclusters(UInt_t *idx) const {
  //---------------------------------------------------------------------
  // This function returns indices of the assgined TRD clusters 
  //---------------------------------------------------------------------
  for (Int_t i=0; i<90; i++) idx[i]=fTRDindex[i];  // MI I prefer some constant
  return fTRDncls;
}

//_______________________________________________________________________
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];
}
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"
	28
	29	ClassImp(AliESDtrack)
	30
	31	//_______________________________________________________________________
	32	AliESDtrack::AliESDtrack() :
2bad268c	33	fFlags(0),
	34	fLabel(0),
	35	fTrackLength(0),
	36	fStopVertex(0),
	37	fRalpha(0),
	38	fRx(0),
	39	fITSchi2(0),
ae982df3	40	fITSncls(0),
2bad268c	41	fITSsignal(0),
2bad268c	42	fTPCchi2(0),
05e445cd	43	fTPCncls(0),
2bad268c	44	fTPCsignal(0),
	45	fTRDchi2(0),
	46	fTRDncls(0),
	47	fTRDsignal(0),
	48	fTOFchi2(0),
	49	fTOFindex(0),
bb2ceb1f	50	fTOFsignal(-1)
ae982df3	51	{
	52	//
	53	// The default ESD constructor
	54	//
2bad268c	55	for (Int_t i=0; i<kSPECIES; i++) {
	56	fTrackTime[i]=0;
	57	fR[i]=0;
	58	fITSr[i]=0;
	59	fTPCr[i]=0;
	60	fTRDr[i]=0;
	61	fTOFr[i]=0;
	62	}
bb2ceb1f	63	Int_t i;
	64	for (i=0; i<5; i++) fRp[i]=0.;
	65	for (i=0; i<15; i++) fRc[i]=0.;
	66	for (i=0; i<6; i++) fITSindex[i]=0;
	67	for (i=0; i<180; i++) fTPCindex[i]=0;
ae982df3	68	}
	69
	70	//_______________________________________________________________________
	71	Float_t AliESDtrack::GetMass() const {
4427806c	72	// Returns the mass of the most probable particle type
ae982df3	73	Float_t max=0.;
	74	Int_t k=-1;
	75	for (Int_t i=0; i<kSPECIES; i++) {
	76	if (fR[i]>max) {k=i; max=fR[i];}
	77	}
	78	if (k==0) return 0.00051;
	79	if (k==1) return 0.10566;
	80	if (k==2\|\|k==-1) return 0.13957;
	81	if (k==3) return 0.49368;
	82	if (k==4) return 0.93827;
	83	Warning("GetMass()","Undefined mass !");
	84	return 0.13957;
	85	}
	86
	87	//_______________________________________________________________________
ad2f1f2b	88	Bool_t AliESDtrack::UpdateTrackParams(AliKalmanTrack *t, ULong_t flags) {
ae982df3	89	//
	90	// This function updates track's running parameters
	91	//
9b859005	92	SetStatus(flags);
	93	fLabel=t->GetLabel();
	94
	95	if (t->IsStartedTimeIntegral()) {
	96	SetStatus(kTIME);
	97	Double_t times[10];t->GetIntegratedTimes(times); SetIntegratedTimes(times);
	98	SetIntegratedLength(t->GetIntegratedLength());
	99	}
	100
	101	fRalpha=t->GetAlpha();
	102	t->GetExternalParameters(fRx,fRp);
	103	t->GetExternalCovariance(fRc);
	104
ae982df3	105	switch (flags) {
ad2f1f2b	106
9b859005	107	case kITSin: case kITSout: case kITSrefit:
ae982df3	108	fITSncls=t->GetNumberOfClusters();
	109	fITSchi2=t->GetChi2();
	110	for (Int_t i=0;i<fITSncls;i++) fITSindex[i]=t->GetClusterIndex(i);
	111	fITSsignal=t->GetPIDsignal();
	112	break;
ad2f1f2b	113
9b859005	114	case kTPCin: case kTPCrefit:
	115	fIalpha=fRalpha;
	116	fIx=fRx;
	117	{
	118	Int_t i;
	119	for (i=0; i<5; i++) fIp[i]=fRp[i];
	120	for (i=0; i<15;i++) fIc[i]=fRc[i];
	121	}
	122	case kTPCout:
ae982df3	123	fTPCncls=t->GetNumberOfClusters();
	124	fTPCchi2=t->GetChi2();
	125	for (Int_t i=0;i<fTPCncls;i++) fTPCindex[i]=t->GetClusterIndex(i);
	126	fTPCsignal=t->GetPIDsignal();
	127	{Double_t mass=t->GetMass(); // preliminary mass setting
	128	if (mass>0.5) fR[4]=1.; // used by
	129	else if (mass<0.4) fR[2]=1.; // the ITS reconstruction
	130	else fR[3]=1.;} //
	131	break;
9b859005	132
672b5f43	133	case kTRDout:
	134	{ //requested by the PHOS ("temporary solution")
	135	Double_t r=474.;
	136	t->PropagateTo(r,30.,0.);
	137	fOalpha=fRalpha;
	138	fOx=fRx;
	139	Int_t i;
	140	for (i=0; i<5; i++) fOp[i]=fRp[i];
	141	for (i=0; i<15;i++) fOc[i]=fRc[i];
	142	}
	143	case kTRDin: case kTRDrefit:
79e94bf8	144	fTRDncls=t->GetNumberOfClusters();
79e94bf8	145	fTRDchi2=t->GetChi2();
bb2ceb1f	146	for (Int_t i=0;i<fTRDncls;i++) fTRDindex[i]=t->GetClusterIndex(i);
79e94bf8	147	fTRDsignal=t->GetPIDsignal();
79e94bf8	148	break;
9b859005	149
ae982df3	150	default:
	151	Error("UpdateTrackParams()","Wrong flag !\n");
	152	return kFALSE;
	153	}
	154
ae982df3	155	return kTRUE;
	156	}
	157
	158	//_______________________________________________________________________
	159	void AliESDtrack::GetExternalParameters(Double_t &x, Double_t p[5]) const {
	160	//---------------------------------------------------------------------
	161	// This function returns external representation of the track parameters
	162	//---------------------------------------------------------------------
	163	x=fRx;
	164	for (Int_t i=0; i<5; i++) p[i]=fRp[i];
	165	}
	166
	167	Double_t AliESDtrack::GetP() const {
	168	//---------------------------------------------------------------------
	169	// This function returns the track momentum
	170	//---------------------------------------------------------------------
	171	Double_t lam=TMath::ATan(fRp[3]);
	172	Double_t pt=1./TMath::Abs(fRp[4]);
	173	return pt/TMath::Cos(lam);
	174	}
	175
	176	void AliESDtrack::GetPxPyPz(Double_t *p) const {
	177	//---------------------------------------------------------------------
	178	// This function returns the global track momentum components
	179	//---------------------------------------------------------------------
	180	Double_t phi=TMath::ASin(fRp[2]) + fRalpha;
	181	Double_t pt=1./TMath::Abs(fRp[4]);
	182	p[0]=ptTMath::Cos(phi); p[1]=ptTMath::Sin(phi); p[2]=pt*fRp[3];
	183	}
	184
	185	void AliESDtrack::GetXYZ(Double_t *xyz) const {
	186	//---------------------------------------------------------------------
	187	// This function returns the global track position
	188	//---------------------------------------------------------------------
bb2ceb1f	189	Double_t phi=TMath::ATan2(fRp[0],fRx) + fRalpha;
ae982df3	190	Double_t r=TMath::Sqrt(fRxfRx + fRp[0]fRp[0]);
	191	xyz[0]=rTMath::Cos(phi); xyz[1]=rTMath::Sin(phi); xyz[2]=fRp[1];
	192	}
	193
9b859005	194	void AliESDtrack::GetInnerPxPyPz(Double_t *p) const {
	195	//---------------------------------------------------------------------
	196	// This function returns the global track momentum components
	197	// af the entrance of the TPC
	198	//---------------------------------------------------------------------
	199	Double_t phi=TMath::ASin(fIp[2]) + fIalpha;
	200	Double_t pt=1./TMath::Abs(fIp[4]);
	201	p[0]=ptTMath::Cos(phi); p[1]=ptTMath::Sin(phi); p[2]=pt*fIp[3];
	202	}
	203
	204	void AliESDtrack::GetInnerXYZ(Double_t *xyz) const {
	205	//---------------------------------------------------------------------
	206	// This function returns the global track position
	207	// af the entrance of the TPC
	208	//---------------------------------------------------------------------
	209	Double_t phi=TMath::ATan2(fIp[0],fIx) + fIalpha;
	210	Double_t r=TMath::Sqrt(fIxfIx + fIp[0]fIp[0]);
	211	xyz[0]=rTMath::Cos(phi); xyz[1]=rTMath::Sin(phi); xyz[2]=fIp[1];
	212	}
	213
672b5f43	214	void AliESDtrack::GetOuterPxPyPz(Double_t *p) const {
	215	//---------------------------------------------------------------------
	216	// This function returns the global track momentum components
	217	// af the radius of the PHOS
	218	//---------------------------------------------------------------------
	219	Double_t phi=TMath::ASin(fOp[2]) + fOalpha;
	220	Double_t pt=1./TMath::Abs(fOp[4]);
	221	p[0]=ptTMath::Cos(phi); p[1]=ptTMath::Sin(phi); p[2]=pt*fOp[3];
	222	}
	223
	224	void AliESDtrack::GetOuterXYZ(Double_t *xyz) const {
	225	//---------------------------------------------------------------------
	226	// This function returns the global track position
	227	// af the radius of the PHOS
	228	//---------------------------------------------------------------------
	229	Double_t phi=TMath::ATan2(fOp[0],fOx) + fOalpha;
	230	Double_t r=TMath::Sqrt(fOxfOx + fOp[0]fOp[0]);
	231	xyz[0]=rTMath::Cos(phi); xyz[1]=rTMath::Sin(phi); xyz[2]=fOp[1];
	232	}
	233
ae982df3	234	//_______________________________________________________________________
	235	void AliESDtrack::GetExternalCovariance(Double_t c[15]) const {
	236	//---------------------------------------------------------------------
	237	// This function returns external representation of the cov. matrix
	238	//---------------------------------------------------------------------
	239	for (Int_t i=0; i<15; i++) c[i]=fRc[i];
	240	}
	241
	242	//_______________________________________________________________________
	243	void AliESDtrack::GetIntegratedTimes(Double_t *times) const {
4427806c	244	// Returns the array with integrated times for each particle hypothesis
ae982df3	245	for (Int_t i=0; i<kSPECIES; i++) times[i]=fTrackTime[i];
	246	}
	247
	248	//_______________________________________________________________________
	249	void AliESDtrack::SetIntegratedTimes(const Double_t *times) {
4427806c	250	// Sets the array with integrated times for each particle hypotesis
ae982df3	251	for (Int_t i=0; i<kSPECIES; i++) fTrackTime[i]=times[i];
	252	}
	253
c630aafd	254	//_______________________________________________________________________
4427806c	255	void AliESDtrack::SetITSpid(const Double_t *p) {
4427806c	256	// Sets values for the probability of each particle type (in ITS)
c630aafd	257	for (Int_t i=0; i<kSPECIES; i++) fITSr[i]=p[i];
	258	SetStatus(AliESDtrack::kITSpid);
	259	}
	260
	261	//_______________________________________________________________________
	262	void AliESDtrack::GetITSpid(Double_t *p) const {
4427806c	263	// Gets the probability of each particle type (in ITS)
c630aafd	264	for (Int_t i=0; i<kSPECIES; i++) p[i]=fITSr[i];
	265	}
	266
ae982df3	267	//_______________________________________________________________________
	268	Int_t AliESDtrack::GetITSclusters(UInt_t *idx) const {
	269	//---------------------------------------------------------------------
	270	// This function returns indices of the assgined ITS clusters
	271	//---------------------------------------------------------------------
	272	for (Int_t i=0; i<fITSncls; i++) idx[i]=fITSindex[i];
	273	return fITSncls;
	274	}
	275
	276	//_______________________________________________________________________
05e445cd	277	Int_t AliESDtrack::GetTPCclusters(Int_t *idx) const {
ae982df3	278	//---------------------------------------------------------------------
	279	// This function returns indices of the assgined ITS clusters
	280	//---------------------------------------------------------------------
05e445cd	281	for (Int_t i=0; i<180; i++) idx[i]=fTPCindex[i]; // MI I prefer some constant
ae982df3	282	return fTPCncls;
ae982df3	283	}
8c6a71ab	284
	285	//_______________________________________________________________________
	286	void AliESDtrack::SetTPCpid(const Double_t *p) {
4427806c	287	// Sets values for the probability of each particle type (in TPC)
8c6a71ab	288	for (Int_t i=0; i<kSPECIES; i++) fTPCr[i]=p[i];
	289	SetStatus(AliESDtrack::kTPCpid);
	290	}
	291
	292	//_______________________________________________________________________
	293	void AliESDtrack::GetTPCpid(Double_t *p) const {
4427806c	294	// Gets the probability of each particle type (in TPC)
8c6a71ab	295	for (Int_t i=0; i<kSPECIES; i++) p[i]=fTPCr[i];
	296	}
	297
bb2ceb1f	298	//_______________________________________________________________________
	299	Int_t AliESDtrack::GetTRDclusters(UInt_t *idx) const {
	300	//---------------------------------------------------------------------
	301	// This function returns indices of the assgined TRD clusters
	302	//---------------------------------------------------------------------
	303	for (Int_t i=0; i<90; i++) idx[i]=fTRDindex[i]; // MI I prefer some constant
	304	return fTRDncls;
	305	}
	306
c630aafd	307	//_______________________________________________________________________
c630aafd	308	void AliESDtrack::SetTRDpid(const Double_t *p) {
4427806c	309	// Sets values for the probability of each particle type (in TRD)
c630aafd	310	for (Int_t i=0; i<kSPECIES; i++) fTRDr[i]=p[i];
	311	SetStatus(AliESDtrack::kTRDpid);
	312	}
	313
	314	//_______________________________________________________________________
	315	void AliESDtrack::GetTRDpid(Double_t *p) const {
4427806c	316	// Gets the probability of each particle type (in TRD)
c630aafd	317	for (Int_t i=0; i<kSPECIES; i++) p[i]=fTRDr[i];
	318	}
	319
79e94bf8	320	//_______________________________________________________________________
	321	void AliESDtrack::SetTRDpid(Int_t iSpecies, Float_t p)
	322	{
4427806c	323	// Sets the probability of particle type iSpecies to p (in TRD)
79e94bf8	324	fTRDr[iSpecies] = p;
	325	}
	326
	327	Float_t AliESDtrack::GetTRDpid(Int_t iSpecies) const
	328	{
4427806c	329	// Returns the probability of particle type iSpecies (in TRD)
79e94bf8	330	return fTRDr[iSpecies];
	331	}
	332
c630aafd	333	//_______________________________________________________________________
c630aafd	334	void AliESDtrack::SetTOFpid(const Double_t *p) {
4427806c	335	// Sets the probability of each particle type (in TOF)
c630aafd	336	for (Int_t i=0; i<kSPECIES; i++) fTOFr[i]=p[i];
	337	SetStatus(AliESDtrack::kTOFpid);
	338	}
	339
	340	//_______________________________________________________________________
	341	void AliESDtrack::GetTOFpid(Double_t *p) const {
4427806c	342	// Gets probabilities of each particle type (in TOF)
c630aafd	343	for (Int_t i=0; i<kSPECIES; i++) p[i]=fTOFr[i];
	344	}
	345
8c6a71ab	346	//_______________________________________________________________________
8c6a71ab	347	void AliESDtrack::SetESDpid(const Double_t *p) {
4427806c	348	// Sets the probability of each particle type for the ESD track
8c6a71ab	349	for (Int_t i=0; i<kSPECIES; i++) fR[i]=p[i];
	350	SetStatus(AliESDtrack::kESDpid);
	351	}
	352
	353	//_______________________________________________________________________
	354	void AliESDtrack::GetESDpid(Double_t *p) const {
4427806c	355	// Gets probability of each particle type for the ESD track
8c6a71ab	356	for (Int_t i=0; i<kSPECIES; i++) p[i]=fR[i];
	357	}
	358