[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
//   This is the class to deal with during the phisical analysis of data
//
//      Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch
//-----------------------------------------------------------------

#include "TMath.h"

#include "AliESDtrack.h"
#include "AliKalmanTrack.h"

ClassImp(AliESDtrack)

//_______________________________________________________________________
AliESDtrack::AliESDtrack() : 
fFlags(0), 
fITSncls(0),
fTPCncls(0)
{
  //
  // The default ESD constructor 
  //
  for (Int_t i=0; i<kSPECIES; i++) fR[i]=0.;
}

//_______________________________________________________________________
Float_t AliESDtrack::GetMass() const {
  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(const 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);
  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 {
  for (Int_t i=0; i<kSPECIES; i++) times[i]=fTrackTime[i];
}

//_______________________________________________________________________
void AliESDtrack::SetIntegratedTimes(const Double_t *times) {
  for (Int_t i=0; i<kSPECIES; i++) fTrackTime[i]=times[i];
}

//_______________________________________________________________________
void AliESDtrack::SetITSpid(const Double_t *p) {  
  for (Int_t i=0; i<kSPECIES; i++) fITSr[i]=p[i];
  SetStatus(AliESDtrack::kITSpid);
}

//_______________________________________________________________________
void AliESDtrack::GetITSpid(Double_t *p) const {
  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(UInt_t *idx) const {
  //---------------------------------------------------------------------
  // This function returns indices of the assgined ITS clusters 
  //---------------------------------------------------------------------
  for (Int_t i=0; i<fTPCncls; i++) idx[i]=fTPCindex[i];
  return fTPCncls;
}

//_______________________________________________________________________
void AliESDtrack::SetTPCpid(const Double_t *p) {  
  for (Int_t i=0; i<kSPECIES; i++) fTPCr[i]=p[i];
  SetStatus(AliESDtrack::kTPCpid);
}

//_______________________________________________________________________
void AliESDtrack::GetTPCpid(Double_t *p) const {
  for (Int_t i=0; i<kSPECIES; i++) p[i]=fTPCr[i];
}

//_______________________________________________________________________
void AliESDtrack::SetTRDpid(const Double_t *p) {  
  for (Int_t i=0; i<kSPECIES; i++) fTRDr[i]=p[i];
  SetStatus(AliESDtrack::kTRDpid);
}

//_______________________________________________________________________
void AliESDtrack::GetTRDpid(Double_t *p) const {
  for (Int_t i=0; i<kSPECIES; i++) p[i]=fTRDr[i];
}

//_______________________________________________________________________
void    AliESDtrack::SetTRDpid(Int_t iSpecies, Float_t p)
{
  fTRDr[iSpecies] = p;
}

Float_t AliESDtrack::GetTRDpid(Int_t iSpecies) const
{
  return fTRDr[iSpecies];
}

//_______________________________________________________________________
void AliESDtrack::SetTOFpid(const Double_t *p) {  
  for (Int_t i=0; i<kSPECIES; i++) fTOFr[i]=p[i];
  SetStatus(AliESDtrack::kTOFpid);
}

//_______________________________________________________________________
void AliESDtrack::GetTOFpid(Double_t *p) const {
  for (Int_t i=0; i<kSPECIES; i++) p[i]=fTOFr[i];
}

//_______________________________________________________________________
void AliESDtrack::SetESDpid(const Double_t *p) {  
  for (Int_t i=0; i<kSPECIES; i++) fR[i]=p[i];
  SetStatus(AliESDtrack::kESDpid);
}

//_______________________________________________________________________
void AliESDtrack::GetESDpid(Double_t *p) const {
  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
	18	// This is the class to deal with during the phisical analysis of data
	19	//
	20	// Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch
	21	//-----------------------------------------------------------------
	22
	23	#include "TMath.h"
	24
	25	#include "AliESDtrack.h"
	26	#include "AliKalmanTrack.h"
	27
	28	ClassImp(AliESDtrack)
	29
	30	//_______________________________________________________________________
	31	AliESDtrack::AliESDtrack() :
	32	fFlags(0),
	33	fITSncls(0),
	34	fTPCncls(0)
	35	{
	36	//
	37	// The default ESD constructor
	38	//
	39	for (Int_t i=0; i<kSPECIES; i++) fR[i]=0.;
	40	}
	41
	42	//_______________________________________________________________________
	43	Float_t AliESDtrack::GetMass() const {
	44	Float_t max=0.;
	45	Int_t k=-1;
	46	for (Int_t i=0; i<kSPECIES; i++) {
	47	if (fR[i]>max) {k=i; max=fR[i];}
	48	}
	49	if (k==0) return 0.00051;
	50	if (k==1) return 0.10566;
	51	if (k==2\|\|k==-1) return 0.13957;
	52	if (k==3) return 0.49368;
	53	if (k==4) return 0.93827;
	54	Warning("GetMass()","Undefined mass !");
	55	return 0.13957;
	56	}
	57
	58	//_______________________________________________________________________
	59	Bool_t AliESDtrack::UpdateTrackParams(const AliKalmanTrack *t, ULong_t flags) {
	60	//
	61	// This function updates track's running parameters
	62	//
	63	switch (flags) {
	64	case kITSin: case kITSout: case kITSrefit:
65	fITSncls=t->GetNumberOfClusters();
66	fITSchi2=t->GetChi2();
67	for (Int_t i=0;i<fITSncls;i++) fITSindex[i]=t->GetClusterIndex(i);
68	fITSsignal=t->GetPIDsignal();
69	break;
70	case kTPCin: case kTPCout: case kTPCrefit:
71	fTPCncls=t->GetNumberOfClusters();
72	fTPCchi2=t->GetChi2();
73	for (Int_t i=0;i<fTPCncls;i++) fTPCindex[i]=t->GetClusterIndex(i);
74	fTPCsignal=t->GetPIDsignal();
75	{Double_t mass=t->GetMass(); // preliminary mass setting
76	if (mass>0.5) fR[4]=1.; // used by
77	else if (mass<0.4) fR[2]=1.; // the ITS reconstruction
78	else fR[3]=1.;} //
79	break;
79e94bf8	80	case kTRDin: case kTRDout: case kTRDrefit:
	81	fTRDncls=t->GetNumberOfClusters();
	82	fTRDchi2=t->GetChi2();
	83	fTRDsignal=t->GetPIDsignal();
	84	break;
ae982df3	85	default:
	86	Error("UpdateTrackParams()","Wrong flag !\n");
	87	return kFALSE;
	88	}
	89
	90	SetStatus(flags);
	91	fLabel=t->GetLabel();
	92
	93	if (t->IsStartedTimeIntegral()) {
	94	SetStatus(kTIME);
	95	Double_t times[10];t->GetIntegratedTimes(times); SetIntegratedTimes(times);
	96	SetIntegratedLength(t->GetIntegratedLength());
	97	}
	98
	99	fRalpha=t->GetAlpha();
	100	t->GetExternalParameters(fRx,fRp);
	101	t->GetExternalCovariance(fRc);
	102	return kTRUE;
	103	}
	104
e23730c7	105	//_______________________________________________________________________
	106	void AliESDtrack::GetExternalParametersAt(Double_t x, Double_t p[5]) const {
	107	//---------------------------------------------------------------------
	108	// This function returns external representation of the track parameters
	109	// at the plane x
	110	//---------------------------------------------------------------------
	111	Double_t dx=x-fRx;
	112	Double_t c=fRp[4]/AliKalmanTrack::GetConvConst();
	113	Double_t f1=fRp[2], f2=f1 + c*dx;
	114	Double_t r1=sqrt(1.- f1f1), r2=sqrt(1.- f2f2);
	115
	116	p[0]=fRp[0]+dx*(f1+f2)/(r1+r2);
	117	p[1]=fRp[1]+dx(f1+f2)/(f1r2 + f2r1)fRp[3];
	118	p[2]=fRp[2]+dx*c;
	119	p[3]=fRp[3];
	120	p[4]=fRp[4];
	121	}
	122
ae982df3	123	//_______________________________________________________________________
	124	void AliESDtrack::GetExternalParameters(Double_t &x, Double_t p[5]) const {
	125	//---------------------------------------------------------------------
	126	// This function returns external representation of the track parameters
	127	//---------------------------------------------------------------------
	128	x=fRx;
	129	for (Int_t i=0; i<5; i++) p[i]=fRp[i];
	130	}
	131
	132	Double_t AliESDtrack::GetP() const {
	133	//---------------------------------------------------------------------
	134	// This function returns the track momentum
	135	//---------------------------------------------------------------------
	136	Double_t lam=TMath::ATan(fRp[3]);
	137	Double_t pt=1./TMath::Abs(fRp[4]);
	138	return pt/TMath::Cos(lam);
	139	}
	140
	141	void AliESDtrack::GetPxPyPz(Double_t *p) const {
	142	//---------------------------------------------------------------------
	143	// This function returns the global track momentum components
	144	//---------------------------------------------------------------------
	145	Double_t phi=TMath::ASin(fRp[2]) + fRalpha;
	146	Double_t pt=1./TMath::Abs(fRp[4]);
	147	p[0]=ptTMath::Cos(phi); p[1]=ptTMath::Sin(phi); p[2]=pt*fRp[3];
	148	}
	149
	150	void AliESDtrack::GetXYZ(Double_t *xyz) const {
	151	//---------------------------------------------------------------------
	152	// This function returns the global track position
	153	//---------------------------------------------------------------------
	154	Double_t phi=TMath::ASin(fRp[2]) + fRalpha;
	155	Double_t r=TMath::Sqrt(fRxfRx + fRp[0]fRp[0]);
	156	xyz[0]=rTMath::Cos(phi); xyz[1]=rTMath::Sin(phi); xyz[2]=fRp[1];
	157	}
	158
	159	//_______________________________________________________________________
	160	void AliESDtrack::GetExternalCovariance(Double_t c[15]) const {
	161	//---------------------------------------------------------------------
	162	// This function returns external representation of the cov. matrix
	163	//---------------------------------------------------------------------
	164	for (Int_t i=0; i<15; i++) c[i]=fRc[i];
	165	}
	166
	167	//_______________________________________________________________________
	168	void AliESDtrack::GetIntegratedTimes(Double_t *times) const {
	169	for (Int_t i=0; i<kSPECIES; i++) times[i]=fTrackTime[i];
	170	}
	171
	172	//_______________________________________________________________________
	173	void AliESDtrack::SetIntegratedTimes(const Double_t *times) {
	174	for (Int_t i=0; i<kSPECIES; i++) fTrackTime[i]=times[i];
	175	}
	176
c630aafd	177	//_______________________________________________________________________
	178	void AliESDtrack::SetITSpid(const Double_t *p) {
	179	for (Int_t i=0; i<kSPECIES; i++) fITSr[i]=p[i];
	180	SetStatus(AliESDtrack::kITSpid);
	181	}
	182
	183	//_______________________________________________________________________
	184	void AliESDtrack::GetITSpid(Double_t *p) const {
	185	for (Int_t i=0; i<kSPECIES; i++) p[i]=fITSr[i];
	186	}
	187
ae982df3	188	//_______________________________________________________________________
	189	Int_t AliESDtrack::GetITSclusters(UInt_t *idx) const {
	190	//---------------------------------------------------------------------
	191	// This function returns indices of the assgined ITS clusters
	192	//---------------------------------------------------------------------
	193	for (Int_t i=0; i<fITSncls; i++) idx[i]=fITSindex[i];
	194	return fITSncls;
	195	}
	196
	197	//_______________________________________________________________________
	198	Int_t AliESDtrack::GetTPCclusters(UInt_t *idx) const {
	199	//---------------------------------------------------------------------
	200	// This function returns indices of the assgined ITS clusters
	201	//---------------------------------------------------------------------
	202	for (Int_t i=0; i<fTPCncls; i++) idx[i]=fTPCindex[i];
	203	return fTPCncls;
	204	}
8c6a71ab	205
	206	//_______________________________________________________________________
	207	void AliESDtrack::SetTPCpid(const Double_t *p) {
	208	for (Int_t i=0; i<kSPECIES; i++) fTPCr[i]=p[i];
	209	SetStatus(AliESDtrack::kTPCpid);
	210	}
	211
	212	//_______________________________________________________________________
	213	void AliESDtrack::GetTPCpid(Double_t *p) const {
	214	for (Int_t i=0; i<kSPECIES; i++) p[i]=fTPCr[i];
	215	}
	216
c630aafd	217	//_______________________________________________________________________
	218	void AliESDtrack::SetTRDpid(const Double_t *p) {
	219	for (Int_t i=0; i<kSPECIES; i++) fTRDr[i]=p[i];
	220	SetStatus(AliESDtrack::kTRDpid);
	221	}
	222
	223	//_______________________________________________________________________
	224	void AliESDtrack::GetTRDpid(Double_t *p) const {
	225	for (Int_t i=0; i<kSPECIES; i++) p[i]=fTRDr[i];
	226	}
	227
79e94bf8	228	//_______________________________________________________________________
	229	void AliESDtrack::SetTRDpid(Int_t iSpecies, Float_t p)
	230	{
	231	fTRDr[iSpecies] = p;
	232	}
	233
	234	Float_t AliESDtrack::GetTRDpid(Int_t iSpecies) const
	235	{
	236	return fTRDr[iSpecies];
	237	}
	238
c630aafd	239	//_______________________________________________________________________
	240	void AliESDtrack::SetTOFpid(const Double_t *p) {
	241	for (Int_t i=0; i<kSPECIES; i++) fTOFr[i]=p[i];
	242	SetStatus(AliESDtrack::kTOFpid);
	243	}
	244
	245	//_______________________________________________________________________
	246	void AliESDtrack::GetTOFpid(Double_t *p) const {
	247	for (Int_t i=0; i<kSPECIES; i++) p[i]=fTOFr[i];
	248	}
	249
8c6a71ab	250	//_______________________________________________________________________
	251	void AliESDtrack::SetESDpid(const Double_t *p) {
	252	for (Int_t i=0; i<kSPECIES; i++) fR[i]=p[i];
	253	SetStatus(AliESDtrack::kESDpid);
	254	}
	255
	256	//_______________________________________________________________________
	257	void AliESDtrack::GetESDpid(Double_t *p) const {
	258	for (Int_t i=0; i<kSPECIES; i++) p[i]=fR[i];
	259	}
	260