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