Implementing ESD functionality in the NewIO (Yu.Belikov)
[u/mrichter/AliRoot.git] / STEER / AliESDtrack.cxx
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;
80   case kTRDin: case kTRDout: case kTRDrefit:
81     fTRDncls=t->GetNumberOfClusters();
82     fTRDchi2=t->GetChi2();
83     fTRDsignal=t->GetPIDsignal();
84     break;
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
105 //_______________________________________________________________________
106 void AliESDtrack::GetExternalParameters(Double_t &x, Double_t p[5]) const {
107   //---------------------------------------------------------------------
108   // This function returns external representation of the track parameters
109   //---------------------------------------------------------------------
110   x=fRx;
111   for (Int_t i=0; i<5; i++) p[i]=fRp[i];
112 }
113
114 Double_t AliESDtrack::GetP() const {
115   //---------------------------------------------------------------------
116   // This function returns the track momentum
117   //---------------------------------------------------------------------
118   Double_t lam=TMath::ATan(fRp[3]);
119   Double_t pt=1./TMath::Abs(fRp[4]);
120   return pt/TMath::Cos(lam);
121 }
122
123 void AliESDtrack::GetPxPyPz(Double_t *p) const {
124   //---------------------------------------------------------------------
125   // This function returns the global track momentum components
126   //---------------------------------------------------------------------
127   Double_t phi=TMath::ASin(fRp[2]) + fRalpha;
128   Double_t pt=1./TMath::Abs(fRp[4]);
129   p[0]=pt*TMath::Cos(phi); p[1]=pt*TMath::Sin(phi); p[2]=pt*fRp[3]; 
130 }
131
132 void AliESDtrack::GetXYZ(Double_t *xyz) const {
133   //---------------------------------------------------------------------
134   // This function returns the global track position
135   //---------------------------------------------------------------------
136   Double_t phi=TMath::ASin(fRp[2]) + fRalpha;
137   Double_t r=TMath::Sqrt(fRx*fRx + fRp[0]*fRp[0]);
138   xyz[0]=r*TMath::Cos(phi); xyz[1]=r*TMath::Sin(phi); xyz[2]=fRp[1]; 
139 }
140
141 //_______________________________________________________________________
142 void AliESDtrack::GetExternalCovariance(Double_t c[15]) const {
143   //---------------------------------------------------------------------
144   // This function returns external representation of the cov. matrix
145   //---------------------------------------------------------------------
146   for (Int_t i=0; i<15; i++) c[i]=fRc[i];
147 }
148
149 //_______________________________________________________________________
150 void AliESDtrack::GetIntegratedTimes(Double_t *times) const {
151   for (Int_t i=0; i<kSPECIES; i++) times[i]=fTrackTime[i];
152 }
153
154 //_______________________________________________________________________
155 void AliESDtrack::SetIntegratedTimes(const Double_t *times) {
156   for (Int_t i=0; i<kSPECIES; i++) fTrackTime[i]=times[i];
157 }
158
159 //_______________________________________________________________________
160 void AliESDtrack::SetITSpid(const Double_t *p) {  
161   for (Int_t i=0; i<kSPECIES; i++) fITSr[i]=p[i];
162   SetStatus(AliESDtrack::kITSpid);
163 }
164
165 //_______________________________________________________________________
166 void AliESDtrack::GetITSpid(Double_t *p) const {
167   for (Int_t i=0; i<kSPECIES; i++) p[i]=fITSr[i];
168 }
169
170 //_______________________________________________________________________
171 Int_t AliESDtrack::GetITSclusters(UInt_t *idx) const {
172   //---------------------------------------------------------------------
173   // This function returns indices of the assgined ITS clusters 
174   //---------------------------------------------------------------------
175   for (Int_t i=0; i<fITSncls; i++) idx[i]=fITSindex[i];
176   return fITSncls;
177 }
178
179 //_______________________________________________________________________
180 Int_t AliESDtrack::GetTPCclusters(UInt_t *idx) const {
181   //---------------------------------------------------------------------
182   // This function returns indices of the assgined ITS clusters 
183   //---------------------------------------------------------------------
184   for (Int_t i=0; i<fTPCncls; i++) idx[i]=fTPCindex[i];
185   return fTPCncls;
186 }
187
188 //_______________________________________________________________________
189 void AliESDtrack::SetTPCpid(const Double_t *p) {  
190   for (Int_t i=0; i<kSPECIES; i++) fTPCr[i]=p[i];
191   SetStatus(AliESDtrack::kTPCpid);
192 }
193
194 //_______________________________________________________________________
195 void AliESDtrack::GetTPCpid(Double_t *p) const {
196   for (Int_t i=0; i<kSPECIES; i++) p[i]=fTPCr[i];
197 }
198
199 //_______________________________________________________________________
200 void AliESDtrack::SetTRDpid(const Double_t *p) {  
201   for (Int_t i=0; i<kSPECIES; i++) fTRDr[i]=p[i];
202   SetStatus(AliESDtrack::kTRDpid);
203 }
204
205 //_______________________________________________________________________
206 void AliESDtrack::GetTRDpid(Double_t *p) const {
207   for (Int_t i=0; i<kSPECIES; i++) p[i]=fTRDr[i];
208 }
209
210 //_______________________________________________________________________
211 void    AliESDtrack::SetTRDpid(Int_t iSpecies, Float_t p)
212 {
213   fTRDr[iSpecies] = p;
214 }
215
216 Float_t AliESDtrack::GetTRDpid(Int_t iSpecies) const
217 {
218   return fTRDr[iSpecies];
219 }
220
221 //_______________________________________________________________________
222 void AliESDtrack::SetTOFpid(const Double_t *p) {  
223   for (Int_t i=0; i<kSPECIES; i++) fTOFr[i]=p[i];
224   SetStatus(AliESDtrack::kTOFpid);
225 }
226
227 //_______________________________________________________________________
228 void AliESDtrack::GetTOFpid(Double_t *p) const {
229   for (Int_t i=0; i<kSPECIES; i++) p[i]=fTOFr[i];
230 }
231
232 //_______________________________________________________________________
233 void AliESDtrack::SetESDpid(const Double_t *p) {  
234   for (Int_t i=0; i<kSPECIES; i++) fR[i]=p[i];
235   SetStatus(AliESDtrack::kESDpid);
236 }
237
238 //_______________________________________________________________________
239 void AliESDtrack::GetESDpid(Double_t *p) const {
240   for (Int_t i=0; i<kSPECIES; i++) p[i]=fR[i];
241 }
242