c876213d1050dbd42b96aed21b396309345b998d
[u/mrichter/AliRoot.git] / STEER / ESD / 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 //           Implementation of the ESD track class
17 //   ESD = Event Summary Data
18 //   This is the class to deal with during the phisics analysis of data
19 //      Origin: Iouri Belikov, CERN
20 //      e-mail: Jouri.Belikov@cern.ch
21 //
22 //
23 //
24 //  What do you need to know before starting analysis
25 //  (by Marian Ivanov: marian.ivanov@cern.ch)
26 //
27 //
28 //   AliESDtrack:
29 //   1.  What is the AliESDtrack
30 //   2.  What informations do we store
31 //   3.  How to use the information for analysis
32 //   
33 //
34 //   1.AliESDtrack is the container of the information about the track/particle
35 //     reconstructed during Barrel Tracking.
36 //     The track information is propagated from one tracking detector to 
37 //     other using the functionality of AliESDtrack - Current parameters.  
38 //
39 //     No global fit model is used.
40 //     Barrel tracking use Kalman filtering technique, it gives optimal local 
41 //     track parameters at given point under certian assumptions.
42 //             
43 //     Kalman filter take into account additional effect which are 
44 //     difficult to handle using global fit.
45 //     Effects:
46 //        a.) Multiple scattering
47 //        b.) Energy loss
48 //        c.) Non homogenous magnetic field
49 //
50 //     In general case, following barrel detectors are contributing to 
51 //     the Kalman track information:
52 //         a. TPC
53 //         b. ITS
54 //         c. TRD
55 //
56 //      In general 3 reconstruction itteration are performed:
57 //         1. Find tracks   - sequence TPC->ITS
58 //         2. PropagateBack - sequence ITS->TPC->TRD -> Outer PID detectors
59 //         3. Refit invward - sequence TRD->TPC->ITS
60 //      The current tracks are updated after each detector (see bellow).
61 //      In specical cases a track  sanpshots are stored.   
62 // 
63 //
64 //      For some type of analysis (+visualization) track local parameters at 
65 //      different position are neccesary. A snapshots during the track 
66 //      propagation are created.
67 //      (See AliExternalTrackParam class for desctiption of variables and 
68 //      functionality)
69 //      Snapshots:
70 //      a. Current parameters - class itself (AliExternalTrackParam)
71 //         Contributors: general case TRD->TPC->ITS
72 //         Preferable usage:  Decission  - primary or secondary track
73 //         NOTICE - By default the track parameters are stored at the DCA point
74 //                  to the primary vertex. optimal for primary tracks, 
75 //                  far from optimal for secondary tracks.
76 //      b. Constrained parameters - Kalman information updated with 
77 //         the Primary vertex information 
78 //         Contributors: general case TRD->TPC->ITS
79 //         Preferable usage: Use only for tracks selected as primary
80 //         NOTICE - not real constrain - taken as additional measurement 
81 //         with corresponding error
82 //         Function:  
83 //       const AliExternalTrackParam *GetConstrainedParam() const {return fCp;}
84 //      c. Inner parameters -  Track parameters at inner wall of the TPC 
85 //         Contributors: general case TRD->TPC
86 //         function:
87 //           const AliExternalTrackParam *GetInnerParam() const { return fIp;}
88 //
89 //      d. TPCinnerparam  - contributors - TPC only
90 //         Contributors:  TPC
91 //         Preferable usage: Requested for HBT study 
92 //                         (smaller correlations as using also ITS information)
93 //         NOTICE - the track parameters are propagated to the DCA to  
94 //         to primary vertex
95 //         Optimal for primary, far from optimal for secondary tracks
96 //         Function:
97 //    const AliExternalTrackParam *GetTPCInnerParam() const {return fTPCInner;}
98 //     
99 //      e. Outer parameters - 
100 //           Contributors-  general case - ITS-> TPC -> TRD
101 //           The last point - Outer parameters radius is determined
102 //           e.a) Local inclination angle bigger than threshold - 
103 //                Low momenta tracks 
104 //           e.a) Catastrofic energy losss in material
105 //           e.b) Not further improvement (no space points)
106 //           Usage:             
107 //              a.) Tracking: Starting parameter for Refit inward 
108 //              b.) Visualization
109 //              c.) QA
110 //         NOTICE: Should be not used for the physic analysis
111 //         Function:
112 //            const AliExternalTrackParam *GetOuterParam() const { return fOp;}
113 //
114 //-----------------------------------------------------------------
115
116 #include <TMath.h>
117 #include <TParticle.h>
118 #include <TDatabasePDG.h>
119 #include <TMatrixD.h>
120
121 #include "AliESDVertex.h"
122 #include "AliESDtrack.h"
123 #include "AliESDEvent.h"
124 #include "AliKalmanTrack.h"
125 #include "AliVTrack.h"
126 #include "AliLog.h"
127 #include "AliTrackPointArray.h"
128 #include "TPolyMarker3D.h"
129 #include "AliTrackerBase.h"
130 #include "AliTPCdEdxInfo.h"
131 #include "AliDetectorPID.h"
132
133 ClassImp(AliESDtrack)
134
135 void SetPIDValues(Double_t * dest, const Double_t * src, Int_t n) {
136   // This function copies "n" PID weights from "scr" to "dest"
137   // and normalizes their sum to 1 thus producing conditional probabilities.
138   // The negative weights are set to 0.
139   // In case all the weights are non-positive they are replaced by
140   // uniform probabilities
141
142   if (n<=0) return;
143
144   Float_t uniform = 1./(Float_t)n;
145
146   Float_t sum = 0;
147   for (Int_t i=0; i<n; i++) 
148     if (src[i]>=0) {
149       sum+=src[i];
150       dest[i] = src[i];
151     }
152     else {
153       dest[i] = 0;
154     }
155
156   if(sum>0)
157     for (Int_t i=0; i<n; i++) dest[i] /= sum;
158   else
159     for (Int_t i=0; i<n; i++) dest[i] = uniform;
160 }
161
162 //_______________________________________________________________________
163 AliESDtrack::AliESDtrack() : 
164   AliExternalTrackParam(),
165   fCp(0),
166   fIp(0),
167   fTPCInner(0),
168   fOp(0),
169   fHMPIDp(0),  
170   fFriendTrack(NULL),
171   fTPCFitMap(159),//number of padrows
172   fTPCClusterMap(159),//number of padrows
173   fTPCSharedMap(159),//number of padrows
174   fFlags(0),
175   fID(0),
176   fLabel(0),
177   fITSLabel(0),
178   fTPCLabel(0),
179   fTRDLabel(0),
180   fTOFCalChannel(-1),
181   fTOFindex(-1),
182   fHMPIDqn(0),
183   fHMPIDcluIdx(-1),
184   fCaloIndex(kEMCALNoMatch),
185   fHMPIDtrkTheta(0),
186   fHMPIDtrkPhi(0),
187   fHMPIDsignal(0),
188   fTrackLength(0),
189   fdTPC(0),fzTPC(0),
190   fCddTPC(0),fCdzTPC(0),fCzzTPC(0),
191   fCchi2TPC(0),
192   fD(0),fZ(0),
193   fCdd(0),fCdz(0),fCzz(0),
194   fCchi2(0),
195   fITSchi2(0),
196   fTPCchi2(0),
197   fTPCchi2Iter1(0),
198   fTRDchi2(0),
199   fTOFchi2(0),
200   fHMPIDchi2(0),
201   fGlobalChi2(0),
202   fITSsignal(0),
203   fTPCsignal(0),
204   fTPCsignalTuned(0),
205   fTPCsignalS(0),
206   fTPCdEdxInfo(0),
207   fTRDsignal(0),
208   fTRDQuality(0),
209   fTRDBudget(0),
210   fTOFsignal(99999),
211   fTOFsignalToT(99999),
212   fTOFsignalRaw(99999),
213   fTOFsignalDz(999),
214   fTOFsignalDx(999),
215   fTOFdeltaBC(999),
216   fTOFl0l1(999),
217   fCaloDx(0),
218   fCaloDz(0),
219   fHMPIDtrkX(0),
220   fHMPIDtrkY(0),
221   fHMPIDmipX(0),
222   fHMPIDmipY(0),
223   fTPCncls(0),
224   fTPCnclsF(0),
225   fTPCsignalN(0),
226   fTPCnclsIter1(0),
227   fTPCnclsFIter1(0),
228   fITSncls(0),
229   fITSClusterMap(0),
230   fITSSharedMap(0),
231   fTRDncls(0),
232   fTRDncls0(0),
233   fTRDntracklets(0),
234   fTRDNchamberdEdx(0),
235   fTRDNclusterdEdx(0),
236   fTRDnSlices(0),
237   fTRDslices(0x0),
238   fVertexID(-2),// -2 means an orphan track 
239   fESDEvent(0),
240   fCacheNCrossedRows(-10),
241   fCacheChi2TPCConstrainedVsGlobal(-10),
242   fCacheChi2TPCConstrainedVsGlobalVertex(0),
243   fDetectorPID(0x0),
244   fTrackPhiOnEMCal(-999),
245   fTrackEtaOnEMCal(-999)
246 {
247   //
248   // The default ESD constructor 
249   //
250   if (!OnlineMode()) fFriendTrack=new AliESDfriendTrack();
251
252   Int_t i;
253   for (i=kNITSchi2Std;i--;) fITSchi2Std[i] = 0;
254   for (i=0; i<AliPID::kSPECIES; i++) {
255     fTrackTime[i]=0.;
256     fR[i]=0.;
257     fITSr[i]=0.;
258     fTPCr[i]=0.;
259     fTRDr[i]=0.;
260     fTOFr[i]=0.;
261     fHMPIDr[i]=0.;
262   }
263   
264   for (i=0; i<3; i++)   { fKinkIndexes[i]=0;}
265   for (i=0; i<3; i++)   { fV0Indexes[i]=0;}
266   for (i=0;i<kTRDnPlanes;i++) {
267     fTRDTimBin[i]=0;
268   }
269   for (i=0;i<4;i++) {fITSdEdxSamples[i]=0.;}
270   for (i=0;i<4;i++) {fTPCPoints[i]=0;}
271   for (i=0;i<3;i++) {fTOFLabel[i]=-1;}
272   for (i=0;i<10;i++) {fTOFInfo[i]=0;}
273   for (i=0;i<12;i++) {fITSModule[i]=-1;}
274 }
275
276 bool AliESDtrack::fgkOnlineMode=false;
277
278 //_______________________________________________________________________
279 AliESDtrack::AliESDtrack(const AliESDtrack& track):
280   AliExternalTrackParam(track),
281   fCp(0),
282   fIp(0),
283   fTPCInner(0),
284   fOp(0),
285   fHMPIDp(0),  
286   fFriendTrack(0),
287   fTPCFitMap(track.fTPCFitMap),
288   fTPCClusterMap(track.fTPCClusterMap),
289   fTPCSharedMap(track.fTPCSharedMap),
290   fFlags(track.fFlags),
291   fID(track.fID),
292   fLabel(track.fLabel),
293   fITSLabel(track.fITSLabel),
294   fTPCLabel(track.fTPCLabel),
295   fTRDLabel(track.fTRDLabel),
296   fTOFCalChannel(track.fTOFCalChannel),
297   fTOFindex(track.fTOFindex),
298   fHMPIDqn(track.fHMPIDqn),
299   fHMPIDcluIdx(track.fHMPIDcluIdx),
300   fCaloIndex(track.fCaloIndex),
301   fHMPIDtrkTheta(track.fHMPIDtrkTheta),
302   fHMPIDtrkPhi(track.fHMPIDtrkPhi),
303   fHMPIDsignal(track.fHMPIDsignal),
304   fTrackLength(track.fTrackLength),
305   fdTPC(track.fdTPC),fzTPC(track.fzTPC),
306   fCddTPC(track.fCddTPC),fCdzTPC(track.fCdzTPC),fCzzTPC(track.fCzzTPC),
307   fCchi2TPC(track.fCchi2TPC),
308   fD(track.fD),fZ(track.fZ),
309   fCdd(track.fCdd),fCdz(track.fCdz),fCzz(track.fCzz),
310   fCchi2(track.fCchi2),
311   fITSchi2(track.fITSchi2),
312   fTPCchi2(track.fTPCchi2),
313   fTPCchi2Iter1(track.fTPCchi2Iter1),
314   fTRDchi2(track.fTRDchi2),
315   fTOFchi2(track.fTOFchi2),
316   fHMPIDchi2(track.fHMPIDchi2),
317   fGlobalChi2(track.fGlobalChi2),
318   fITSsignal(track.fITSsignal),
319   fTPCsignal(track.fTPCsignal),
320   fTPCsignalTuned(track.fTPCsignalTuned),
321   fTPCsignalS(track.fTPCsignalS),
322   fTPCdEdxInfo(0),
323   fTRDsignal(track.fTRDsignal),
324   fTRDQuality(track.fTRDQuality),
325   fTRDBudget(track.fTRDBudget),
326   fTOFsignal(track.fTOFsignal),
327   fTOFsignalToT(track.fTOFsignalToT),
328   fTOFsignalRaw(track.fTOFsignalRaw),
329   fTOFsignalDz(track.fTOFsignalDz),
330   fTOFsignalDx(track.fTOFsignalDx),
331   fTOFdeltaBC(track.fTOFdeltaBC),
332   fTOFl0l1(track.fTOFl0l1),
333   fCaloDx(track.fCaloDx),
334   fCaloDz(track.fCaloDz),
335   fHMPIDtrkX(track.fHMPIDtrkX),
336   fHMPIDtrkY(track.fHMPIDtrkY),
337   fHMPIDmipX(track.fHMPIDmipX),
338   fHMPIDmipY(track.fHMPIDmipY),
339   fTPCncls(track.fTPCncls),
340   fTPCnclsF(track.fTPCnclsF),
341   fTPCsignalN(track.fTPCsignalN),
342   fTPCnclsIter1(track.fTPCnclsIter1),
343   fTPCnclsFIter1(track.fTPCnclsIter1),
344   fITSncls(track.fITSncls),
345   fITSClusterMap(track.fITSClusterMap),
346   fITSSharedMap(track.fITSSharedMap),
347   fTRDncls(track.fTRDncls),
348   fTRDncls0(track.fTRDncls0),
349   fTRDntracklets(track.fTRDntracklets),
350   fTRDNchamberdEdx(track.fTRDNchamberdEdx),
351   fTRDNclusterdEdx(track.fTRDNclusterdEdx),
352   fTRDnSlices(track.fTRDnSlices),
353   fTRDslices(0x0),
354   fVertexID(track.fVertexID),
355   fESDEvent(track.fESDEvent),
356   fCacheNCrossedRows(track.fCacheNCrossedRows),
357   fCacheChi2TPCConstrainedVsGlobal(track.fCacheChi2TPCConstrainedVsGlobal),
358   fCacheChi2TPCConstrainedVsGlobalVertex(track.fCacheChi2TPCConstrainedVsGlobalVertex),
359   fDetectorPID(0x0),
360   fTrackPhiOnEMCal(track.fTrackPhiOnEMCal),
361   fTrackEtaOnEMCal(track.fTrackEtaOnEMCal)
362 {
363   //
364   //copy constructor
365   //
366   for (Int_t i=kNITSchi2Std;i--;) fITSchi2Std[i] = track.fTrackTime[i];
367   for (Int_t i=0;i<AliPID::kSPECIES;i++) fTrackTime[i]=track.fTrackTime[i];
368   for (Int_t i=0;i<AliPID::kSPECIES;i++)  fR[i]=track.fR[i];
369   //
370   for (Int_t i=0;i<AliPID::kSPECIES;i++) fITSr[i]=track.fITSr[i]; 
371   //
372   for (Int_t i=0;i<AliPID::kSPECIES;i++) fTPCr[i]=track.fTPCr[i]; 
373   for (Int_t i=0;i<4;i++) {fITSdEdxSamples[i]=track.fITSdEdxSamples[i];}
374   for (Int_t i=0;i<4;i++) {fTPCPoints[i]=track.fTPCPoints[i];}
375   for (Int_t i=0; i<3;i++)   { fKinkIndexes[i]=track.fKinkIndexes[i];}
376   for (Int_t i=0; i<3;i++)   { fV0Indexes[i]=track.fV0Indexes[i];}
377   //
378   for (Int_t i=0;i<kTRDnPlanes;i++) {
379     fTRDTimBin[i]=track.fTRDTimBin[i];
380   }
381
382   if (fTRDnSlices) {
383     fTRDslices=new Double32_t[fTRDnSlices];
384     for (Int_t i=0; i<fTRDnSlices; i++) fTRDslices[i]=track.fTRDslices[i];
385   }
386
387   if (track.fDetectorPID) fDetectorPID = new AliDetectorPID(*track.fDetectorPID);
388
389   for (Int_t i=0;i<AliPID::kSPECIES;i++) fTRDr[i]=track.fTRDr[i]; 
390   for (Int_t i=0;i<AliPID::kSPECIES;i++) fTOFr[i]=track.fTOFr[i];
391   for (Int_t i=0;i<3;i++) fTOFLabel[i]=track.fTOFLabel[i];
392   for (Int_t i=0;i<10;i++) fTOFInfo[i]=track.fTOFInfo[i];
393   for (Int_t i=0;i<12;i++) fITSModule[i]=track.fITSModule[i];
394   for (Int_t i=0;i<AliPID::kSPECIES;i++) fHMPIDr[i]=track.fHMPIDr[i];
395
396   if (track.fCp) fCp=new AliExternalTrackParam(*track.fCp);
397   if (track.fIp) fIp=new AliExternalTrackParam(*track.fIp);
398   if (track.fTPCInner) fTPCInner=new AliExternalTrackParam(*track.fTPCInner);
399   if (track.fOp) fOp=new AliExternalTrackParam(*track.fOp);
400   if (track.fHMPIDp) fHMPIDp=new AliExternalTrackParam(*track.fHMPIDp);
401   if (track.fTPCdEdxInfo) fTPCdEdxInfo = new AliTPCdEdxInfo(*track.fTPCdEdxInfo);
402
403   
404   if (track.fFriendTrack) fFriendTrack=new AliESDfriendTrack(*(track.fFriendTrack));
405 }
406
407 //_______________________________________________________________________
408 AliESDtrack::AliESDtrack(const AliVTrack *track) : 
409   AliExternalTrackParam(track),
410   fCp(0),
411   fIp(0),
412   fTPCInner(0),
413   fOp(0),
414   fHMPIDp(0),  
415   fFriendTrack(0),
416   fTPCFitMap(159),//number of padrows
417   fTPCClusterMap(159),//number of padrows
418   fTPCSharedMap(159),//number of padrows
419   fFlags(0),
420   fID(),
421   fLabel(0),
422   fITSLabel(0),
423   fTPCLabel(0),
424   fTRDLabel(0),
425   fTOFCalChannel(-1),
426   fTOFindex(-1),
427   fHMPIDqn(0),
428   fHMPIDcluIdx(-1),
429   fCaloIndex(kEMCALNoMatch),
430   fHMPIDtrkTheta(0),
431   fHMPIDtrkPhi(0),
432   fHMPIDsignal(0),
433   fTrackLength(0),
434   fdTPC(0),fzTPC(0),
435   fCddTPC(0),fCdzTPC(0),fCzzTPC(0),
436   fCchi2TPC(0),
437   fD(0),fZ(0),
438   fCdd(0),fCdz(0),fCzz(0),
439   fCchi2(0),
440   fITSchi2(0),
441   fTPCchi2(0),
442   fTPCchi2Iter1(0),
443   fTRDchi2(0),
444   fTOFchi2(0),
445   fHMPIDchi2(0),
446   fGlobalChi2(0),
447   fITSsignal(0),
448   fTPCsignal(0),
449   fTPCsignalTuned(0),
450   fTPCsignalS(0),
451   fTPCdEdxInfo(0),
452   fTRDsignal(0),
453   fTRDQuality(0),
454   fTRDBudget(0),
455   fTOFsignal(99999),
456   fTOFsignalToT(99999),
457   fTOFsignalRaw(99999),
458   fTOFsignalDz(999),
459   fTOFsignalDx(999),
460   fTOFdeltaBC(999),
461   fTOFl0l1(999),
462   fCaloDx(0),
463   fCaloDz(0),
464   fHMPIDtrkX(0),
465   fHMPIDtrkY(0),
466   fHMPIDmipX(0),
467   fHMPIDmipY(0),
468   fTPCncls(0),
469   fTPCnclsF(0),
470   fTPCsignalN(0),
471   fTPCnclsIter1(0),
472   fTPCnclsFIter1(0),
473   fITSncls(0),
474   fITSClusterMap(0),
475   fITSSharedMap(0),
476   fTRDncls(0),
477   fTRDncls0(0),
478   fTRDntracklets(0),
479   fTRDNchamberdEdx(0),
480   fTRDNclusterdEdx(0),
481   fTRDnSlices(0),
482   fTRDslices(0x0),
483   fVertexID(-2),  // -2 means an orphan track
484   fESDEvent(0),
485   fCacheNCrossedRows(-10),
486   fCacheChi2TPCConstrainedVsGlobal(-10),
487   fCacheChi2TPCConstrainedVsGlobalVertex(0),
488   fDetectorPID(0x0),
489   fTrackPhiOnEMCal(-999),
490   fTrackEtaOnEMCal(-999)
491 {
492   //
493   // ESD track from AliVTrack.
494   // This is not a copy constructor !
495   //
496
497   if (track->InheritsFrom("AliExternalTrackParam")) {
498      AliError("This is not a copy constructor. Use AliESDtrack(const AliESDtrack &) !");
499      AliWarning("Calling the default constructor...");
500      AliESDtrack();
501      return;
502   }
503
504   // Reset all the arrays
505   Int_t i;
506   for (i=kNITSchi2Std;i--;) fITSchi2Std[i] = 0;
507   for (i=0; i<AliPID::kSPECIES; i++) {
508     fTrackTime[i]=0.;
509     fR[i]=0.;
510     fITSr[i]=0.;
511     fTPCr[i]=0.;
512     fTRDr[i]=0.;
513     fTOFr[i]=0.;
514     fHMPIDr[i]=0.;
515   }
516   
517   for (i=0; i<3; i++)   { fKinkIndexes[i]=0;}
518   for (i=0; i<3; i++)   { fV0Indexes[i]=-1;}
519   for (i=0;i<kTRDnPlanes;i++) {
520     fTRDTimBin[i]=0;
521   }
522   for (i=0;i<4;i++) {fITSdEdxSamples[i]=0.;}
523   for (i=0;i<4;i++) {fTPCPoints[i]=0;}
524   for (i=0;i<3;i++) {fTOFLabel[i]=-1;}
525   for (i=0;i<10;i++) {fTOFInfo[i]=0;}
526   for (i=0;i<12;i++) {fITSModule[i]=-1;}
527
528   // Set the ID
529   SetID(track->GetID());
530
531   // Set ITS cluster map
532   fITSClusterMap=track->GetITSClusterMap();
533   fITSSharedMap=0;
534
535   fITSncls=0;
536   for(i=0; i<6; i++) {
537     if(HasPointOnITSLayer(i)) fITSncls++;
538   }
539
540   // Set TPC ncls 
541   fTPCncls=track->GetTPCNcls();
542   fTPCnclsF=track->GetTPCNclsF();
543   // TPC cluster maps
544   const TBits* bmap = track->GetTPCClusterMapPtr();
545   if (bmap) SetTPCClusterMap(*bmap);
546   bmap = GetTPCFitMapPtr();
547   if (bmap) SetTPCFitMap(*bmap);
548   bmap = GetTPCSharedMapPtr();
549   if (bmap) SetTPCSharedMap(*bmap);
550   //
551   // Set the combined PID
552   const Double_t *pid = track->PID();
553   if(pid) for (i=0; i<AliPID::kSPECIES; i++) fR[i]=pid[i];
554   //
555   // calo matched cluster id
556   SetEMCALcluster(track->GetEMCALcluster());
557   // AliESD track label
558   //
559   // PID info
560   fITSsignal = track->GetITSsignal();
561   double itsdEdx[4];
562   track->GetITSdEdxSamples(itsdEdx);
563   SetITSdEdxSamples(itsdEdx);
564   //
565   SetTPCsignal(track->GetTPCsignal(),fTPCsignalS,track->GetTPCsignalN()); // No signalS in AODPi
566   AliTPCdEdxInfo * dEdxInfo = track->GetTPCdEdxInfo();
567   if (dEdxInfo) SetTPCdEdxInfo(new AliTPCdEdxInfo(*dEdxInfo));
568   //
569   SetTRDsignal(track->GetTRDsignal());
570   int ntrdsl = track->GetNumberOfTRDslices();
571   if (ntrdsl>0) {
572     SetNumberOfTRDslices((ntrdsl+2)*kTRDnPlanes);
573     for (int ipl=kTRDnPlanes;ipl--;){
574       for (int isl=ntrdsl;isl--;) SetTRDslice(track->GetTRDslice(ipl,isl),ipl,isl);
575       Double_t sp, p = track->GetTRDmomentum(ipl, &sp);
576       SetTRDmomentum(p, ipl, &sp);
577     }
578   }
579   //
580   fTRDncls = track->GetTRDncls();
581   fTRDntracklets &= 0xff & track->GetTRDntrackletsPID();
582   fTRDchi2 = track->GetTRDchi2();
583   //
584   SetTOFsignal(track->GetTOFsignal());
585   Double_t expt[AliPID::kSPECIES];
586   track->GetIntegratedTimes(expt);
587   SetIntegratedTimes(expt);
588   //
589   SetTrackPhiEtaOnEMCal(track->GetTrackPhiOnEMCal(),track->GetTrackEtaOnEMCal());
590   //
591   SetLabel(track->GetLabel());
592   // Set the status
593   SetStatus(track->GetStatus());
594 }
595
596 //_______________________________________________________________________
597 AliESDtrack::AliESDtrack(TParticle * part) : 
598   AliExternalTrackParam(),
599   fCp(0),
600   fIp(0),
601   fTPCInner(0),
602   fOp(0),
603   fHMPIDp(0),  
604   fFriendTrack(0),
605   fTPCFitMap(159),//number of padrows
606   fTPCClusterMap(159),//number of padrows
607   fTPCSharedMap(159),//number of padrows
608   fFlags(0),
609   fID(0),
610   fLabel(0),
611   fITSLabel(0),
612   fTPCLabel(0),
613   fTRDLabel(0),
614   fTOFCalChannel(-1),
615   fTOFindex(-1),
616   fHMPIDqn(0),
617   fHMPIDcluIdx(-1),
618   fCaloIndex(kEMCALNoMatch),
619   fHMPIDtrkTheta(0),
620   fHMPIDtrkPhi(0),
621   fHMPIDsignal(0),
622   fTrackLength(0),
623   fdTPC(0),fzTPC(0),
624   fCddTPC(0),fCdzTPC(0),fCzzTPC(0),
625   fCchi2TPC(0),
626   fD(0),fZ(0),
627   fCdd(0),fCdz(0),fCzz(0),
628   fCchi2(0),
629   fITSchi2(0),
630   fTPCchi2(0),
631   fTPCchi2Iter1(0),  
632   fTRDchi2(0),
633   fTOFchi2(0),
634   fHMPIDchi2(0),
635   fGlobalChi2(0),
636   fITSsignal(0),
637   fTPCsignal(0),
638   fTPCsignalTuned(0),
639   fTPCsignalS(0),
640   fTPCdEdxInfo(0),
641   fTRDsignal(0),
642   fTRDQuality(0),
643   fTRDBudget(0),
644   fTOFsignal(99999),
645   fTOFsignalToT(99999),
646   fTOFsignalRaw(99999),
647   fTOFsignalDz(999),
648   fTOFsignalDx(999),
649   fTOFdeltaBC(999),
650   fTOFl0l1(999),
651   fCaloDx(0),
652   fCaloDz(0),
653   fHMPIDtrkX(0),
654   fHMPIDtrkY(0),
655   fHMPIDmipX(0),
656   fHMPIDmipY(0),
657   fTPCncls(0),
658   fTPCnclsF(0),
659   fTPCsignalN(0),
660   fTPCnclsIter1(0),
661   fTPCnclsFIter1(0),
662   fITSncls(0),
663   fITSClusterMap(0),
664   fITSSharedMap(0),
665   fTRDncls(0),
666   fTRDncls0(0),
667   fTRDntracklets(0),
668   fTRDNchamberdEdx(0),
669   fTRDNclusterdEdx(0),
670   fTRDnSlices(0),
671   fTRDslices(0x0),
672   fVertexID(-2),  // -2 means an orphan track
673   fESDEvent(0),
674   fCacheNCrossedRows(-10),
675   fCacheChi2TPCConstrainedVsGlobal(-10),
676   fCacheChi2TPCConstrainedVsGlobalVertex(0),
677   fDetectorPID(0x0),
678   fTrackPhiOnEMCal(-999),
679   fTrackEtaOnEMCal(-999)
680 {
681   //
682   // ESD track from TParticle
683   //
684
685   // Reset all the arrays
686   Int_t i;
687   for (i=kNITSchi2Std;i--;) fITSchi2Std[i] = 0;
688   for (i=0; i<AliPID::kSPECIES; i++) {
689     fTrackTime[i]=0.;
690     fR[i]=0.;
691     fITSr[i]=0.;
692     fTPCr[i]=0.;
693     fTRDr[i]=0.;
694     fTOFr[i]=0.;
695     fHMPIDr[i]=0.;
696   }
697   
698   for (i=0; i<3; i++)   { fKinkIndexes[i]=0;}
699   for (i=0; i<3; i++)   { fV0Indexes[i]=-1;}
700   for (i=0;i<kTRDnPlanes;i++) {
701     fTRDTimBin[i]=0;
702   }
703   for (i=0;i<4;i++) {fITSdEdxSamples[i]=0.;}
704   for (i=0;i<4;i++) {fTPCPoints[i]=0;}
705   for (i=0;i<3;i++) {fTOFLabel[i]=-1;}
706   for (i=0;i<10;i++) {fTOFInfo[i]=0;}
707   for (i=0;i<12;i++) {fITSModule[i]=-1;}
708
709   // Calculate the AliExternalTrackParam content
710
711   Double_t xref;
712   Double_t alpha;
713   Double_t param[5];
714   Double_t covar[15];
715
716   // Calculate alpha: the rotation angle of the corresponding local system (TPC sector)
717   alpha = part->Phi()*180./TMath::Pi();
718   if (alpha<0) alpha+= 360.;
719   if (alpha>360) alpha -= 360.;
720
721   Int_t sector = (Int_t)(alpha/20.);
722   alpha = 10. + 20.*sector;
723   alpha /= 180;
724   alpha *= TMath::Pi();
725
726   // Covariance matrix: no errors, the parameters are exact
727   for (i=0; i<15; i++) covar[i]=0.;
728
729   // Get the vertex of origin and the momentum
730   TVector3 ver(part->Vx(),part->Vy(),part->Vz());
731   TVector3 mom(part->Px(),part->Py(),part->Pz());
732
733   // Rotate to the local coordinate system (TPC sector)
734   ver.RotateZ(-alpha);
735   mom.RotateZ(-alpha);
736
737   // X of the referense plane
738   xref = ver.X();
739
740   Int_t pdgCode = part->GetPdgCode();
741
742   Double_t charge = 
743     TDatabasePDG::Instance()->GetParticle(pdgCode)->Charge();
744
745   param[0] = ver.Y();
746   param[1] = ver.Z();
747   param[2] = TMath::Sin(mom.Phi());
748   param[3] = mom.Pz()/mom.Pt();
749   param[4] = TMath::Sign(1/mom.Pt(),charge);
750
751   // Set AliExternalTrackParam
752   Set(xref, alpha, param, covar);
753
754   // Set the PID
755   Int_t indexPID = 99;
756
757   switch (TMath::Abs(pdgCode)) {
758
759   case  11: // electron
760     indexPID = 0;
761     break;
762
763   case 13: // muon
764     indexPID = 1;
765     break;
766
767   case 211: // pion
768     indexPID = 2;
769     break;
770
771   case 321: // kaon
772     indexPID = 3;
773     break;
774
775   case 2212: // proton
776     indexPID = 4;
777     break;
778
779   default:
780     break;
781   }
782
783   // If the particle is not e,mu,pi,K or p the PID probabilities are set to 0
784   if (indexPID < AliPID::kSPECIES) {
785     fR[indexPID]=1.;
786     fITSr[indexPID]=1.;
787     fTPCr[indexPID]=1.;
788     fTRDr[indexPID]=1.;
789     fTOFr[indexPID]=1.;
790     fHMPIDr[indexPID]=1.;
791
792   }
793   // AliESD track label
794   SetLabel(part->GetUniqueID());
795
796 }
797
798 //_______________________________________________________________________
799 AliESDtrack::~AliESDtrack(){ 
800   //
801   // This is destructor according Coding Conventrions 
802   //
803   //printf("Delete track\n");
804   delete fIp; 
805   delete fTPCInner; 
806   delete fOp;
807   delete fHMPIDp;
808   delete fCp; 
809   delete fFriendTrack;
810   delete fTPCdEdxInfo;
811   if(fTRDnSlices)
812     delete[] fTRDslices;
813
814   //Reset cached values - needed for TClonesArray in AliESDInputHandler
815   fCacheNCrossedRows = -10.;
816   fCacheChi2TPCConstrainedVsGlobal = -10.;
817   if(fCacheChi2TPCConstrainedVsGlobalVertex) fCacheChi2TPCConstrainedVsGlobalVertex = 0;
818
819   delete fDetectorPID;
820 }
821
822 AliESDtrack &AliESDtrack::operator=(const AliESDtrack &source){
823   
824
825   if(&source == this) return *this;
826   AliExternalTrackParam::operator=(source);
827
828   
829   if(source.fCp){
830     // we have the trackparam: assign or copy construct
831     if(fCp)*fCp = *source.fCp;
832     else fCp = new AliExternalTrackParam(*source.fCp);
833   }
834   else{
835     // no track param delete the old one
836     delete fCp;
837     fCp = 0;
838   }
839
840   if(source.fIp){
841     // we have the trackparam: assign or copy construct
842     if(fIp)*fIp = *source.fIp;
843     else fIp = new AliExternalTrackParam(*source.fIp);
844   }
845   else{
846     // no track param delete the old one
847     delete fIp;
848     fIp = 0;
849   }
850
851
852   if(source.fTPCInner){
853     // we have the trackparam: assign or copy construct
854     if(fTPCInner) *fTPCInner = *source.fTPCInner;
855     else fTPCInner = new AliExternalTrackParam(*source.fTPCInner);
856   }
857   else{
858     // no track param delete the old one
859     delete fTPCInner;
860     fTPCInner = 0;
861   }
862
863   if(source.fTPCdEdxInfo) {
864     if(fTPCdEdxInfo) *fTPCdEdxInfo = *source.fTPCdEdxInfo;
865     fTPCdEdxInfo = new AliTPCdEdxInfo(*source.fTPCdEdxInfo);
866   }
867
868   if(source.fOp){
869     // we have the trackparam: assign or copy construct
870     if(fOp) *fOp = *source.fOp;
871     else fOp = new AliExternalTrackParam(*source.fOp);
872   }
873   else{
874     // no track param delete the old one
875     delete fOp;
876     fOp = 0;
877   }
878
879   
880   if(source.fHMPIDp){
881     // we have the trackparam: assign or copy construct
882     if(fHMPIDp) *fHMPIDp = *source.fHMPIDp;
883     else fHMPIDp = new AliExternalTrackParam(*source.fHMPIDp);
884   }
885   else{
886     // no track param delete the old one
887     delete fHMPIDp;
888     fHMPIDp = 0;
889   }
890
891   // copy also the friend track 
892   // use copy constructor
893   if(source.fFriendTrack){
894     // we have the trackparam: assign or copy construct
895     delete fFriendTrack; fFriendTrack=new AliESDfriendTrack(*source.fFriendTrack);
896   }
897   else{
898     // no track param delete the old one
899     delete fFriendTrack; fFriendTrack= 0;
900   }
901
902   fTPCFitMap = source.fTPCFitMap; 
903   fTPCClusterMap = source.fTPCClusterMap; 
904   fTPCSharedMap  = source.fTPCSharedMap;  
905   // the simple stuff
906   fFlags    = source.fFlags; 
907   fID       = source.fID;             
908   fLabel    = source.fLabel;
909   fITSLabel = source.fITSLabel;
910   for(int i = 0; i< 12;++i){
911     fITSModule[i] = source.fITSModule[i];
912   }
913   fTPCLabel = source.fTPCLabel; 
914   fTRDLabel = source.fTRDLabel;
915   for(int i = 0; i< 3;++i){
916     fTOFLabel[i] = source.fTOFLabel[i];    
917   }
918   fTOFCalChannel = source.fTOFCalChannel;
919   fTOFindex      = source.fTOFindex;
920   fHMPIDqn       = source.fHMPIDqn;
921   fHMPIDcluIdx   = source.fHMPIDcluIdx; 
922   fCaloIndex    = source.fCaloIndex;
923   for (int i=kNITSchi2Std;i--;) fITSchi2Std[i] = source.fITSchi2Std[i];
924   for(int i = 0; i< 3;++i){
925     fKinkIndexes[i] = source.fKinkIndexes[i]; 
926     fV0Indexes[i]   = source.fV0Indexes[i]; 
927   }
928
929   for(int i = 0; i< AliPID::kSPECIES;++i){
930     fR[i]     = source.fR[i];
931     fITSr[i]  = source.fITSr[i];
932     fTPCr[i]  = source.fTPCr[i];
933     fTRDr[i]  = source.fTRDr[i];
934     fTOFr[i]  = source.fTOFr[i];
935     fHMPIDr[i] = source.fHMPIDr[i];
936     fTrackTime[i] = source.fTrackTime[i];  
937   }
938
939   fHMPIDtrkTheta = source.fHMPIDtrkTheta;
940   fHMPIDtrkPhi   = source.fHMPIDtrkPhi;
941   fHMPIDsignal   = source.fHMPIDsignal; 
942
943   
944   fTrackLength   = source. fTrackLength;
945   fdTPC  = source.fdTPC; 
946   fzTPC  = source.fzTPC; 
947   fCddTPC = source.fCddTPC;
948   fCdzTPC = source.fCdzTPC;
949   fCzzTPC = source.fCzzTPC;
950   fCchi2TPC = source.fCchi2TPC;
951
952   fD  = source.fD; 
953   fZ  = source.fZ; 
954   fCdd = source.fCdd;
955   fCdz = source.fCdz;
956   fCzz = source.fCzz;
957   fCchi2     = source.fCchi2;
958
959   fITSchi2   = source.fITSchi2;             
960   fTPCchi2   = source.fTPCchi2;            
961   fTPCchi2Iter1   = source.fTPCchi2Iter1;            
962   fTRDchi2   = source.fTRDchi2;      
963   fTOFchi2   = source.fTOFchi2;      
964   fHMPIDchi2 = source.fHMPIDchi2;      
965
966   fGlobalChi2 = source.fGlobalChi2;      
967
968   fITSsignal  = source.fITSsignal;     
969   for (Int_t i=0;i<4;i++) {fITSdEdxSamples[i]=source.fITSdEdxSamples[i];}
970   fTPCsignal  = source.fTPCsignal;     
971   fTPCsignalTuned  = source.fTPCsignalTuned;
972   fTPCsignalS = source.fTPCsignalS;    
973   for(int i = 0; i< 4;++i){
974     fTPCPoints[i] = source.fTPCPoints[i];  
975   }
976   fTRDsignal = source.fTRDsignal;
977   fTRDNchamberdEdx = source.fTRDNchamberdEdx;
978   fTRDNclusterdEdx = source.fTRDNclusterdEdx;
979
980   for(int i = 0;i < kTRDnPlanes;++i){
981     fTRDTimBin[i] = source.fTRDTimBin[i];   
982   }
983
984   if(fTRDnSlices)
985     delete[] fTRDslices;
986   fTRDslices=0;
987   fTRDnSlices=source.fTRDnSlices;
988   if (fTRDnSlices) {
989     fTRDslices=new Double32_t[fTRDnSlices];
990     for(int j = 0;j < fTRDnSlices;++j) fTRDslices[j] = source.fTRDslices[j];
991   }
992
993   fTRDQuality =   source.fTRDQuality;     
994   fTRDBudget  =   source.fTRDBudget;      
995   fTOFsignal  =   source.fTOFsignal;     
996   fTOFsignalToT = source.fTOFsignalToT;   
997   fTOFsignalRaw = source.fTOFsignalRaw;  
998   fTOFsignalDz  = source.fTOFsignalDz;      
999   fTOFsignalDx  = source.fTOFsignalDx;      
1000   fTOFdeltaBC   = source.fTOFdeltaBC;
1001   fTOFl0l1      = source.fTOFl0l1;
1002  
1003   for(int i = 0;i<10;++i){
1004     fTOFInfo[i] = source.fTOFInfo[i];    
1005   }
1006
1007   fHMPIDtrkX = source.fHMPIDtrkX; 
1008   fHMPIDtrkY = source.fHMPIDtrkY; 
1009   fHMPIDmipX = source.fHMPIDmipX;
1010   fHMPIDmipY = source.fHMPIDmipY; 
1011
1012   fTPCncls    = source.fTPCncls;      
1013   fTPCnclsF   = source.fTPCnclsF;     
1014   fTPCsignalN = source.fTPCsignalN;   
1015   fTPCnclsIter1    = source.fTPCnclsIter1;      
1016   fTPCnclsFIter1   = source.fTPCnclsFIter1;     
1017
1018   fITSncls = source.fITSncls;       
1019   fITSClusterMap = source.fITSClusterMap; 
1020   fITSSharedMap = source.fITSSharedMap; 
1021   fTRDncls   = source.fTRDncls;       
1022   fTRDncls0  = source.fTRDncls0;      
1023   fTRDntracklets  = source.fTRDntracklets; 
1024   fVertexID = source.fVertexID;
1025
1026   fCacheNCrossedRows = source.fCacheNCrossedRows;
1027   fCacheChi2TPCConstrainedVsGlobal = source.fCacheChi2TPCConstrainedVsGlobal;
1028   fCacheChi2TPCConstrainedVsGlobalVertex = source.fCacheChi2TPCConstrainedVsGlobalVertex;
1029
1030   delete fDetectorPID;
1031   fDetectorPID=0x0;
1032   if (source.fDetectorPID) fDetectorPID = new AliDetectorPID(*source.fDetectorPID);
1033   
1034   fTrackPhiOnEMCal= source.fTrackPhiOnEMCal;
1035   fTrackEtaOnEMCal= source.fTrackEtaOnEMCal;
1036
1037   return *this;
1038 }
1039
1040
1041
1042 void AliESDtrack::Copy(TObject &obj) const {
1043   
1044   // this overwrites the virtual TOBject::Copy()
1045   // to allow run time copying without casting
1046   // in AliESDEvent
1047
1048   if(this==&obj)return;
1049   AliESDtrack *robj = dynamic_cast<AliESDtrack*>(&obj);
1050   if(!robj)return; // not an AliESDtrack
1051   *robj = *this;
1052
1053 }
1054
1055
1056
1057 void AliESDtrack::AddCalibObject(TObject * object){
1058   //
1059   // add calib object to the list
1060   //
1061   if (!fFriendTrack) fFriendTrack  = new AliESDfriendTrack;
1062   if (!fFriendTrack) return;
1063   fFriendTrack->AddCalibObject(object);
1064 }
1065
1066 TObject *  AliESDtrack::GetCalibObject(Int_t index){
1067   //
1068   // return calib objct at given position
1069   //
1070   if (!fFriendTrack) return 0;
1071   return fFriendTrack->GetCalibObject(index);
1072 }
1073
1074
1075 Bool_t AliESDtrack::FillTPCOnlyTrack(AliESDtrack &track){
1076   
1077   // Fills the information of the TPC-only first reconstruction pass
1078   // into the passed ESDtrack object. For consistency fTPCInner is also filled
1079   // again
1080
1081
1082
1083   // For data produced before r26675
1084   // RelateToVertexTPC was not properly called during reco
1085   // so you'll have to call it again, before FillTPCOnlyTrack
1086   //  Float_t p[2],cov[3];
1087   // track->GetImpactParametersTPC(p,cov); 
1088   // if(p[0]==0&&p[1]==0) // <- Default values
1089   //  track->RelateToVertexTPC(esd->GetPrimaryVertexTPC(),esd->GetMagneticField(),kVeryBig);
1090   
1091
1092   if(!fTPCInner)return kFALSE;
1093
1094   // fill the TPC track params to the global track parameters
1095   track.Set(fTPCInner->GetX(),fTPCInner->GetAlpha(),fTPCInner->GetParameter(),fTPCInner->GetCovariance());
1096   track.fD = fdTPC;
1097   track.fZ = fzTPC;
1098   track.fCdd = fCddTPC;
1099   track.fCdz = fCdzTPC;
1100   track.fCzz = fCzzTPC;
1101
1102   // copy the inner params
1103   if(track.fIp) *track.fIp = *fIp;
1104   else track.fIp = new AliExternalTrackParam(*fIp);
1105
1106   // copy the TPCinner parameters
1107   if(track.fTPCInner) *track.fTPCInner = *fTPCInner;
1108   else track.fTPCInner = new AliExternalTrackParam(*fTPCInner);
1109   track.fdTPC   = fdTPC;
1110   track.fzTPC   = fzTPC;
1111   track.fCddTPC = fCddTPC;
1112   track.fCdzTPC = fCdzTPC;
1113   track.fCzzTPC = fCzzTPC;
1114   track.fCchi2TPC = fCchi2TPC;
1115
1116   // copy all other TPC specific parameters
1117
1118   // replace label by TPC label
1119   track.fLabel    = fTPCLabel;
1120   track.fTPCLabel = fTPCLabel;
1121
1122   track.fTPCchi2 = fTPCchi2; 
1123   track.fTPCchi2Iter1 = fTPCchi2Iter1; 
1124   track.fTPCsignal = fTPCsignal;
1125   track.fTPCsignalTuned = fTPCsignalTuned;
1126   track.fTPCsignalS = fTPCsignalS;
1127   for(int i = 0;i<4;++i)track.fTPCPoints[i] = fTPCPoints[i];
1128
1129   track.fTPCncls    = fTPCncls;     
1130   track.fTPCnclsF   = fTPCnclsF;     
1131   track.fTPCsignalN =  fTPCsignalN;
1132   track.fTPCnclsIter1    = fTPCnclsIter1;     
1133   track.fTPCnclsFIter1   = fTPCnclsFIter1;     
1134
1135   // PID 
1136   for(int i=0;i<AliPID::kSPECIES;++i){
1137     track.fTPCr[i] = fTPCr[i];
1138     // combined PID is TPC only!
1139     track.fR[i] = fTPCr[i];
1140   }
1141   track.fTPCFitMap = fTPCFitMap;
1142   track.fTPCClusterMap = fTPCClusterMap;
1143   track.fTPCSharedMap = fTPCSharedMap;
1144
1145
1146   // reset the flags
1147   track.fFlags = kTPCin;
1148   track.fID    = fID;
1149
1150   track.fFlags |= fFlags & kTPCpid; //copy the TPCpid status flag
1151  
1152   for (Int_t i=0;i<3;i++) track.fKinkIndexes[i] = fKinkIndexes[i];
1153   
1154   return kTRUE;
1155     
1156 }
1157
1158 //_______________________________________________________________________
1159 void AliESDtrack::MakeMiniESDtrack(){
1160   // Resets everything except
1161   // fFlags: Reconstruction status flags 
1162   // fLabel: Track label
1163   // fID:  Unique ID of the track
1164   // Impact parameter information
1165   // fR[AliPID::kSPECIES]: combined "detector response probability"
1166   // Running track parameters in the base class (AliExternalTrackParam)
1167   
1168   fTrackLength = 0;
1169
1170   for (Int_t i=0;i<AliPID::kSPECIES;i++) fTrackTime[i] = 0;
1171
1172   // Reset track parameters constrained to the primary vertex
1173   delete fCp;fCp = 0;
1174
1175   // Reset track parameters at the inner wall of TPC
1176   delete fIp;fIp = 0;
1177   delete fTPCInner;fTPCInner=0;
1178   // Reset track parameters at the inner wall of the TRD
1179   delete fOp;fOp = 0;
1180   // Reset track parameters at the HMPID
1181   delete fHMPIDp;fHMPIDp = 0;
1182
1183
1184   // Reset ITS track related information
1185   fITSchi2 = 0;
1186   fITSncls = 0;       
1187   fITSClusterMap=0;
1188   fITSSharedMap=0;
1189   fITSsignal = 0;     
1190   for (Int_t i=0;i<4;i++) fITSdEdxSamples[i] = 0.;
1191   for (Int_t i=0;i<AliPID::kSPECIES;i++) fITSr[i]=0; 
1192   fITSLabel = 0;       
1193
1194   // Reset TPC related track information
1195   fTPCchi2 = 0;       
1196   fTPCchi2Iter1 = 0;       
1197   fTPCncls = 0;       
1198   fTPCnclsF = 0;       
1199   fTPCnclsIter1 = 0;       
1200   fTPCnclsFIter1 = 0;  
1201   fTPCFitMap = 0;       
1202   fTPCClusterMap = 0;  
1203   fTPCSharedMap = 0;  
1204   fTPCsignal= 0;      
1205   fTPCsignalTuned= 0;
1206   fTPCsignalS= 0;      
1207   fTPCsignalN= 0;      
1208   for (Int_t i=0;i<AliPID::kSPECIES;i++) fTPCr[i]=0; 
1209   fTPCLabel=0;       
1210   for (Int_t i=0;i<4;i++) fTPCPoints[i] = 0;
1211   for (Int_t i=0; i<3;i++)   fKinkIndexes[i] = 0;
1212   for (Int_t i=0; i<3;i++)   fV0Indexes[i] = 0;
1213
1214   // Reset TRD related track information
1215   fTRDchi2 = 0;        
1216   fTRDncls = 0;       
1217   fTRDncls0 = 0;       
1218   fTRDsignal = 0;      
1219   fTRDNchamberdEdx = 0;
1220   fTRDNclusterdEdx = 0;
1221
1222   for (Int_t i=0;i<kTRDnPlanes;i++) {
1223     fTRDTimBin[i]  = 0;
1224   }
1225   for (Int_t i=0;i<AliPID::kSPECIES;i++) fTRDr[i] = 0; 
1226   fTRDLabel = 0;       
1227   fTRDQuality  = 0;
1228   fTRDntracklets = 0;
1229   if(fTRDnSlices)
1230     delete[] fTRDslices;
1231   fTRDslices=0x0;
1232   fTRDnSlices=0;
1233   fTRDBudget  = 0;
1234
1235   // Reset TOF related track information
1236   fTOFchi2 = 0;        
1237   fTOFindex = -1;       
1238   fTOFsignal = 99999;      
1239   fTOFCalChannel = -1;
1240   fTOFsignalToT = 99999;
1241   fTOFsignalRaw = 99999;
1242   fTOFsignalDz = 999;
1243   fTOFsignalDx = 999;
1244   fTOFdeltaBC = 999;
1245   fTOFl0l1 = 999;
1246   for (Int_t i=0;i<AliPID::kSPECIES;i++) fTOFr[i] = 0;
1247   for (Int_t i=0;i<3;i++) fTOFLabel[i] = -1;
1248   for (Int_t i=0;i<10;i++) fTOFInfo[i] = 0;
1249
1250   // Reset HMPID related track information
1251   fHMPIDchi2 = 0;     
1252   fHMPIDqn = 0;     
1253   fHMPIDcluIdx = -1;     
1254   fHMPIDsignal = 0;     
1255   for (Int_t i=0;i<AliPID::kSPECIES;i++) fHMPIDr[i] = 0;
1256   fHMPIDtrkTheta = 0;     
1257   fHMPIDtrkPhi = 0;      
1258   fHMPIDtrkX = 0;     
1259   fHMPIDtrkY = 0;      
1260   fHMPIDmipX = 0;
1261   fHMPIDmipY = 0;
1262   fCaloIndex = kEMCALNoMatch;
1263
1264   // reset global track chi2
1265   fGlobalChi2 = 0;
1266
1267   fVertexID = -2; // an orphan track
1268
1269   delete fFriendTrack; fFriendTrack = 0;
1270
1271
1272 //_______________________________________________________________________
1273 Int_t AliESDtrack::GetPID(Bool_t tpcOnly) const 
1274 {
1275   // Returns the particle most probable id
1276   Int_t i;
1277   const Double32_t *prob = 0;
1278   if (tpcOnly) { // check if TPCpid is valid
1279     prob = fTPCr;
1280     for (i=0; i<AliPID::kSPECIES-1; i++) if (prob[i] != prob[i+1]) break;
1281     if (i == AliPID::kSPECIES-1) prob = 0; // not valid, try with combined pid
1282   }
1283   if (!prob) { // either requested TPCpid is not valid or comb.pid is requested 
1284     prob = fR;
1285     for (i=0; i<AliPID::kSPECIES-1; i++) if (prob[i] != prob[i+1]) break;
1286     if (i == AliPID::kSPECIES-1) return AliPID::kPion;  // If all the probabilities are equal, return the pion mass
1287   }
1288   //
1289   Float_t max=0.;
1290   Int_t k=-1;
1291   for (i=0; i<AliPID::kSPECIES; i++) if (prob[i]>max) {k=i; max=prob[i];}
1292   //
1293   if (k==0) { // dE/dx "crossing points" in the TPC
1294     Double_t p=GetP();
1295     if ((p>0.38)&&(p<0.48))
1296       if (prob[0]<prob[3]*10.) return AliPID::kKaon;
1297     if ((p>0.75)&&(p<0.85))
1298       if (prob[0]<prob[4]*10.) return AliPID::kProton;
1299     return AliPID::kElectron;
1300   }
1301   if (k==1) return AliPID::kMuon; 
1302   if (k==2||k==-1) return AliPID::kPion;
1303   if (k==3) return AliPID::kKaon;
1304   if (k==4) return AliPID::kProton;
1305   AliWarning("Undefined PID !");
1306   return AliPID::kPion;
1307 }
1308
1309 //_______________________________________________________________________
1310 Int_t AliESDtrack::GetTOFBunchCrossing(Double_t b, Bool_t pidTPConly) const 
1311 {
1312   // Returns the number of bunch crossings after trigger (assuming 25ns spacing)
1313   const double kSpacing = 25e3; // min interbanch spacing
1314   const double kShift = 0;
1315   Int_t bcid = kTOFBCNA; // defualt one
1316   if (!IsOn(kTOFout) || !IsOn(kESDpid)) return bcid; // no info
1317   //
1318   double tdif = fTOFsignal;
1319   if (IsOn(kTIME)) { // integrated time info is there
1320     int pid = GetPID(pidTPConly);
1321     tdif -= fTrackTime[pid];
1322   }
1323   else { // assume integrated time info from TOF radius and momentum
1324     const double kRTOF = 385.;
1325     const double kCSpeed = 3.e-2; // cm/ps
1326     double p = GetP();
1327     if (p<0.01) return bcid;
1328     double m = GetMass(pidTPConly);
1329     double curv = GetC(b);
1330     double path = TMath::Abs(curv)>kAlmost0 ? // account for curvature
1331       2./curv*TMath::ASin(kRTOF*curv/2.)*TMath::Sqrt(1.+GetTgl()*GetTgl()) : kRTOF;
1332     tdif -= path/kCSpeed*TMath::Sqrt(1.+m*m/(p*p));
1333   }
1334   bcid = TMath::Nint((tdif - kShift)/kSpacing);
1335   return bcid;
1336 }
1337
1338 //______________________________________________________________________________
1339 Double_t AliESDtrack::M() const
1340 {
1341   // Returns the assumed mass
1342   // (the pion mass, if the particle can't be identified properly).
1343   static Bool_t printerr=kTRUE;
1344   if (printerr) {
1345      AliWarning("WARNING !!! ... THIS WILL BE PRINTED JUST ONCE !!!");
1346      printerr = kFALSE;
1347      AliWarning("This is the ESD mass. Use it with care !"); 
1348   }
1349   return GetMass(); 
1350 }
1351   
1352 //______________________________________________________________________________
1353 Double_t AliESDtrack::E() const
1354 {
1355   // Returns the energy of the particle given its assumed mass.
1356   // Assumes the pion mass if the particle can't be identified properly.
1357   
1358   Double_t m = M();
1359   Double_t p = P();
1360   return TMath::Sqrt(p*p + m*m);
1361 }
1362
1363 //______________________________________________________________________________
1364 Double_t AliESDtrack::Y() const
1365 {
1366   // Returns the rapidity of a particle given its assumed mass.
1367   // Assumes the pion mass if the particle can't be identified properly.
1368   
1369   Double_t e = E();
1370   Double_t pz = Pz();
1371   if (e != TMath::Abs(pz)) { // energy was not equal to pz
1372     return 0.5*TMath::Log((e+pz)/(e-pz));
1373   } else { // energy was equal to pz
1374     return -999.;
1375   }
1376 }
1377
1378 //_______________________________________________________________________
1379 Bool_t AliESDtrack::UpdateTrackParams(const AliKalmanTrack *t, ULong_t flags){
1380   //
1381   // This function updates track's running parameters 
1382   //
1383   Bool_t rc=kTRUE;
1384
1385   SetStatus(flags);
1386   fLabel=t->GetLabel();
1387
1388   if (t->IsStartedTimeIntegral()) {
1389     SetStatus(kTIME);
1390     Double_t times[10];t->GetIntegratedTimes(times); SetIntegratedTimes(times);
1391     SetIntegratedLength(t->GetIntegratedLength());
1392   }
1393
1394   Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
1395   if (fFriendTrack) {
1396   if (flags==kITSout) fFriendTrack->SetITSOut(*t);
1397   if (flags==kTPCout) fFriendTrack->SetTPCOut(*t);
1398   if (flags==kTRDrefit) fFriendTrack->SetTRDIn(*t);
1399   }
1400   
1401   switch (flags) {
1402     
1403   case kITSin: 
1404     fITSchi2Std[0] = t->GetChi2();
1405     //
1406   case kITSout: 
1407     fITSchi2Std[1] = t->GetChi2();
1408   case kITSrefit:
1409     {
1410     fITSchi2Std[2] = t->GetChi2();
1411     fITSClusterMap=0;
1412     fITSncls=t->GetNumberOfClusters();
1413     if (fFriendTrack) {
1414     Int_t* indexITS = new Int_t[AliESDfriendTrack::kMaxITScluster];
1415     for (Int_t i=0;i<AliESDfriendTrack::kMaxITScluster;i++) {
1416         indexITS[i]=t->GetClusterIndex(i);
1417
1418         if (i<fITSncls) {
1419           Int_t l=(indexITS[i] & 0xf0000000) >> 28;
1420            SETBIT(fITSClusterMap,l);                 
1421         }
1422     }
1423     fFriendTrack->SetITSIndices(indexITS,AliESDfriendTrack::kMaxITScluster);
1424     delete [] indexITS;
1425     }
1426
1427     fITSchi2=t->GetChi2();
1428     fITSsignal=t->GetPIDsignal();
1429     fITSLabel = t->GetLabel();
1430     // keep in fOp the parameters outside ITS for ITS stand-alone tracks 
1431     if (flags==kITSout) { 
1432       if (!fOp) fOp=new AliExternalTrackParam(*t);
1433       else 
1434         fOp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
1435     }   
1436     }
1437     break;
1438     
1439   case kTPCin: case kTPCrefit:
1440     {
1441     fTPCLabel = t->GetLabel();
1442     if (flags==kTPCin)  {
1443       fTPCInner=new AliExternalTrackParam(*t); 
1444       fTPCnclsIter1=t->GetNumberOfClusters();    
1445       fTPCchi2Iter1=t->GetChi2();
1446     }
1447     if (!fIp) fIp=new AliExternalTrackParam(*t);
1448     else 
1449       fIp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
1450     }
1451     // Intentionally no break statement; need to set general TPC variables as well
1452   case kTPCout:
1453     {
1454     if (flags & kTPCout){
1455       if (!fOp) fOp=new AliExternalTrackParam(*t);
1456       else 
1457         fOp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
1458     }
1459     fTPCncls=t->GetNumberOfClusters();    
1460     fTPCchi2=t->GetChi2();
1461     
1462     if (fFriendTrack) {  // Copy cluster indices
1463       Int_t* indexTPC = new Int_t[AliESDfriendTrack::kMaxTPCcluster];
1464       for (Int_t i=0;i<AliESDfriendTrack::kMaxTPCcluster;i++)         
1465         indexTPC[i]=t->GetClusterIndex(i);
1466       fFriendTrack->SetTPCIndices(indexTPC,AliESDfriendTrack::kMaxTPCcluster);
1467       delete [] indexTPC;
1468     }
1469     fTPCsignal=t->GetPIDsignal();
1470     }
1471     break;
1472
1473   case kTRDin: case kTRDrefit:
1474     break;
1475   case kTRDout:
1476     {
1477     fTRDLabel = t->GetLabel(); 
1478     fTRDchi2  = t->GetChi2();
1479     fTRDncls  = t->GetNumberOfClusters();
1480     if (fFriendTrack) {
1481       Int_t* indexTRD = new Int_t[AliESDfriendTrack::kMaxTRDcluster];
1482       for (Int_t i=0;i<AliESDfriendTrack::kMaxTRDcluster;i++) indexTRD[i]=-2;
1483       for (Int_t i=0;i<6;i++) indexTRD[i]=t->GetTrackletIndex(i);
1484       fFriendTrack->SetTRDIndices(indexTRD,AliESDfriendTrack::kMaxTRDcluster);
1485       delete [] indexTRD;
1486     }    
1487     
1488     //commented out by Xianguo
1489     //fTRDsignal=t->GetPIDsignal();
1490     }
1491     break;
1492   case kTRDbackup:
1493     if (!fOp) fOp=new AliExternalTrackParam(*t);
1494     else 
1495       fOp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
1496     fTRDncls0 = t->GetNumberOfClusters(); 
1497     break;
1498   case kTOFin: 
1499     break;
1500   case kTOFout: 
1501     break;
1502   case kTRDStop:
1503     break;
1504   case kHMPIDout:
1505   if (!fHMPIDp) fHMPIDp=new AliExternalTrackParam(*t);
1506     else 
1507       fHMPIDp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
1508     break;
1509   default: 
1510     AliError("Wrong flag !");
1511     return kFALSE;
1512   }
1513
1514   return rc;
1515 }
1516
1517 //_______________________________________________________________________
1518 void AliESDtrack::GetExternalParameters(Double_t &x, Double_t p[5]) const {
1519   //---------------------------------------------------------------------
1520   // This function returns external representation of the track parameters
1521   //---------------------------------------------------------------------
1522   x=GetX();
1523   for (Int_t i=0; i<5; i++) p[i]=GetParameter()[i];
1524 }
1525
1526 //_______________________________________________________________________
1527 void AliESDtrack::GetExternalCovariance(Double_t cov[15]) const {
1528   //---------------------------------------------------------------------
1529   // This function returns external representation of the cov. matrix
1530   //---------------------------------------------------------------------
1531   for (Int_t i=0; i<15; i++) cov[i]=AliExternalTrackParam::GetCovariance()[i];
1532 }
1533
1534 //_______________________________________________________________________
1535 Bool_t AliESDtrack::GetConstrainedExternalParameters
1536                  (Double_t &alpha, Double_t &x, Double_t p[5]) const {
1537   //---------------------------------------------------------------------
1538   // This function returns the constrained external track parameters
1539   //---------------------------------------------------------------------
1540   if (!fCp) return kFALSE;
1541   alpha=fCp->GetAlpha();
1542   x=fCp->GetX();
1543   for (Int_t i=0; i<5; i++) p[i]=fCp->GetParameter()[i];
1544   return kTRUE;
1545 }
1546
1547 //_______________________________________________________________________
1548 Bool_t 
1549 AliESDtrack::GetConstrainedExternalCovariance(Double_t c[15]) const {
1550   //---------------------------------------------------------------------
1551   // This function returns the constrained external cov. matrix
1552   //---------------------------------------------------------------------
1553   if (!fCp) return kFALSE;
1554   for (Int_t i=0; i<15; i++) c[i]=fCp->GetCovariance()[i];
1555   return kTRUE;
1556 }
1557
1558 Bool_t
1559 AliESDtrack::GetInnerExternalParameters
1560                  (Double_t &alpha, Double_t &x, Double_t p[5]) const {
1561   //---------------------------------------------------------------------
1562   // This function returns external representation of the track parameters 
1563   // at the inner layer of TPC
1564   //---------------------------------------------------------------------
1565   if (!fIp) return kFALSE;
1566   alpha=fIp->GetAlpha();
1567   x=fIp->GetX();
1568   for (Int_t i=0; i<5; i++) p[i]=fIp->GetParameter()[i];
1569   return kTRUE;
1570 }
1571
1572 Bool_t 
1573 AliESDtrack::GetInnerExternalCovariance(Double_t cov[15]) const {
1574  //---------------------------------------------------------------------
1575  // This function returns external representation of the cov. matrix 
1576  // at the inner layer of TPC
1577  //---------------------------------------------------------------------
1578   if (!fIp) return kFALSE;
1579   for (Int_t i=0; i<15; i++) cov[i]=fIp->GetCovariance()[i];
1580   return kTRUE;
1581 }
1582
1583 void 
1584 AliESDtrack::SetOuterParam(const AliExternalTrackParam *p, ULong_t flags) {
1585   //
1586   // This is a direct setter for the outer track parameters
1587   //
1588   SetStatus(flags);
1589   if (fOp) delete fOp;
1590   fOp=new AliExternalTrackParam(*p);
1591 }
1592
1593 void 
1594 AliESDtrack::SetOuterHmpParam(const AliExternalTrackParam *p, ULong_t flags) {
1595   //
1596   // This is a direct setter for the outer track parameters
1597   //
1598   SetStatus(flags);
1599   if (fHMPIDp) delete fHMPIDp;
1600   fHMPIDp=new AliExternalTrackParam(*p);
1601 }
1602
1603 Bool_t 
1604 AliESDtrack::GetOuterExternalParameters
1605                  (Double_t &alpha, Double_t &x, Double_t p[5]) const {
1606   //---------------------------------------------------------------------
1607   // This function returns external representation of the track parameters 
1608   // at the inner layer of TRD
1609   //---------------------------------------------------------------------
1610   if (!fOp) return kFALSE;
1611   alpha=fOp->GetAlpha();
1612   x=fOp->GetX();
1613   for (Int_t i=0; i<5; i++) p[i]=fOp->GetParameter()[i];
1614   return kTRUE;
1615 }
1616
1617 Bool_t 
1618 AliESDtrack::GetOuterHmpExternalParameters
1619                  (Double_t &alpha, Double_t &x, Double_t p[5]) const {
1620   //---------------------------------------------------------------------
1621   // This function returns external representation of the track parameters 
1622   // at the inner layer of TRD
1623   //---------------------------------------------------------------------
1624   if (!fHMPIDp) return kFALSE;
1625   alpha=fHMPIDp->GetAlpha();
1626   x=fHMPIDp->GetX();
1627   for (Int_t i=0; i<5; i++) p[i]=fHMPIDp->GetParameter()[i];
1628   return kTRUE;
1629 }
1630
1631 Bool_t 
1632 AliESDtrack::GetOuterExternalCovariance(Double_t cov[15]) const {
1633  //---------------------------------------------------------------------
1634  // This function returns external representation of the cov. matrix 
1635  // at the inner layer of TRD
1636  //---------------------------------------------------------------------
1637   if (!fOp) return kFALSE;
1638   for (Int_t i=0; i<15; i++) cov[i]=fOp->GetCovariance()[i];
1639   return kTRUE;
1640 }
1641
1642 Bool_t 
1643 AliESDtrack::GetOuterHmpExternalCovariance(Double_t cov[15]) const {
1644  //---------------------------------------------------------------------
1645  // This function returns external representation of the cov. matrix 
1646  // at the inner layer of TRD
1647  //---------------------------------------------------------------------
1648   if (!fHMPIDp) return kFALSE;
1649   for (Int_t i=0; i<15; i++) cov[i]=fHMPIDp->GetCovariance()[i];
1650   return kTRUE;
1651 }
1652
1653 Int_t AliESDtrack::GetNcls(Int_t idet) const
1654 {
1655   // Get number of clusters by subdetector index
1656   //
1657   Int_t ncls = 0;
1658   switch(idet){
1659   case 0:
1660     ncls = fITSncls;
1661     break;
1662   case 1:
1663     ncls = fTPCncls;
1664     break;
1665   case 2:
1666     ncls = fTRDncls;
1667     break;
1668   case 3:
1669     if (fTOFindex != -1)
1670       ncls = 1;
1671     break;
1672   case 4: //PHOS
1673     break;
1674   case 5: //HMPID
1675     if ((fHMPIDcluIdx >= 0) && (fHMPIDcluIdx < 7000000)) {
1676       if ((fHMPIDcluIdx%1000000 != 9999) && (fHMPIDcluIdx%1000000 != 99999)) {
1677         ncls = 1;
1678       }
1679     }    
1680     break;
1681   default:
1682     break;
1683   }
1684   return ncls;
1685 }
1686
1687 Int_t AliESDtrack::GetClusters(Int_t idet, Int_t *idx) const
1688 {
1689   // Get cluster index array by subdetector index
1690   //
1691   Int_t ncls = 0;
1692   switch(idet){
1693   case 0:
1694     ncls = GetITSclusters(idx);
1695     break;
1696   case 1:
1697     ncls = GetTPCclusters(idx);
1698     break;
1699   case 2:
1700     ncls = GetTRDclusters(idx);
1701     break;
1702   case 3:
1703     if (fTOFindex != -1) {
1704       idx[0] = fTOFindex;
1705       ncls = 1;
1706     }
1707     break;
1708   case 4: //PHOS
1709     break;
1710   case 5:
1711     if ((fHMPIDcluIdx >= 0) && (fHMPIDcluIdx < 7000000)) {
1712       if ((fHMPIDcluIdx%1000000 != 9999) && (fHMPIDcluIdx%1000000 != 99999)) {
1713         idx[0] = GetHMPIDcluIdx();
1714         ncls = 1;
1715       }
1716     }    
1717     break;
1718   case 6: //EMCAL
1719     break;
1720   default:
1721     break;
1722   }
1723   return ncls;
1724 }
1725
1726 //_______________________________________________________________________
1727 void AliESDtrack::GetIntegratedTimes(Double_t *times) const {
1728   // Returns the array with integrated times for each particle hypothesis
1729   for (Int_t i=0; i<AliPID::kSPECIES; i++) times[i]=fTrackTime[i];
1730 }
1731
1732 //_______________________________________________________________________
1733 void AliESDtrack::SetIntegratedTimes(const Double_t *times) {
1734   // Sets the array with integrated times for each particle hypotesis
1735   for (Int_t i=0; i<AliPID::kSPECIES; i++) fTrackTime[i]=times[i];
1736 }
1737
1738 //_______________________________________________________________________
1739 void AliESDtrack::SetITSpid(const Double_t *p) {
1740   // Sets values for the probability of each particle type (in ITS)
1741   SetPIDValues(fITSr,p,AliPID::kSPECIES);
1742   SetStatus(AliESDtrack::kITSpid);
1743 }
1744
1745 //_______________________________________________________________________
1746 void AliESDtrack::GetITSpid(Double_t *p) const {
1747   // Gets the probability of each particle type (in ITS)
1748   for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fITSr[i];
1749 }
1750
1751 //_______________________________________________________________________
1752 Char_t AliESDtrack::GetITSclusters(Int_t *idx) const {
1753   //---------------------------------------------------------------------
1754   // This function returns indices of the assgined ITS clusters 
1755   //---------------------------------------------------------------------
1756   if (idx && fFriendTrack) {
1757     Int_t *index=fFriendTrack->GetITSindices();
1758     for (Int_t i=0; i<AliESDfriendTrack::kMaxITScluster; i++) {
1759       if ( (i>=fITSncls) && (i<6) ) idx[i]=-1;
1760       else {
1761         if (index) {
1762           idx[i]=index[i];
1763         }
1764         else idx[i]= -2;
1765       }
1766     }
1767   }
1768   return fITSncls;
1769 }
1770
1771 //_______________________________________________________________________
1772 Bool_t AliESDtrack::GetITSModuleIndexInfo(Int_t ilayer,Int_t &idet,Int_t &status,
1773                                          Float_t &xloc,Float_t &zloc) const {
1774   //----------------------------------------------------------------------
1775   // This function encodes in the module number also the status of cluster association
1776   // "status" can have the following values: 
1777   // 1 "found" (cluster is associated), 
1778   // 2 "dead" (module is dead from OCDB), 
1779   // 3 "skipped" (module or layer forced to be skipped),
1780   // 4 "outinz" (track out of z acceptance), 
1781   // 5 "nocls" (no clusters in the road), 
1782   // 6 "norefit" (cluster rejected during refit), 
1783   // 7 "deadzspd" (holes in z in SPD)
1784   // Also given are the coordinates of the crossing point of track and module
1785   // (in the local module ref. system)
1786   // WARNING: THIS METHOD HAS TO BE SYNCHRONIZED WITH AliITStrackV2::GetModuleIndexInfo()!
1787   //----------------------------------------------------------------------
1788
1789   if(fITSModule[ilayer]==-1) {
1790     idet = -1;
1791     status=0;
1792     xloc=-99.; zloc=-99.;
1793     return kFALSE;
1794   }
1795
1796   Int_t module = fITSModule[ilayer];
1797
1798   idet = Int_t(module/1000000);
1799
1800   module -= idet*1000000;
1801
1802   status = Int_t(module/100000);
1803
1804   module -= status*100000;
1805
1806   Int_t signs = Int_t(module/10000);
1807
1808   module-=signs*10000;
1809
1810   Int_t xInt = Int_t(module/100);
1811   module -= xInt*100;
1812
1813   Int_t zInt = module;
1814
1815   if(signs==1) { xInt*=1; zInt*=1; }
1816   if(signs==2) { xInt*=1; zInt*=-1; }
1817   if(signs==3) { xInt*=-1; zInt*=1; }
1818   if(signs==4) { xInt*=-1; zInt*=-1; }
1819
1820   xloc = 0.1*(Float_t)xInt;
1821   zloc = 0.1*(Float_t)zInt;
1822
1823   if(status==4) idet = -1;
1824
1825   return kTRUE;
1826 }
1827
1828 //_______________________________________________________________________
1829 UShort_t AliESDtrack::GetTPCclusters(Int_t *idx) const {
1830   //---------------------------------------------------------------------
1831   // This function returns indices of the assgined ITS clusters 
1832   //---------------------------------------------------------------------
1833   if (idx && fFriendTrack) {
1834     Int_t *index=fFriendTrack->GetTPCindices();
1835
1836     if (index){
1837       for (Int_t i=0; i<AliESDfriendTrack::kMaxTPCcluster; i++) idx[i]=index[i];
1838     }
1839     else {
1840       for (Int_t i=0; i<AliESDfriendTrack::kMaxTPCcluster; i++) idx[i]=-2;
1841     }
1842   }
1843   return fTPCncls;
1844 }
1845
1846 //_______________________________________________________________________
1847 Float_t AliESDtrack::GetTPCCrossedRows() const
1848 {
1849   // This function calls GetTPCClusterInfo with some default parameters which are used in the track selection and caches the outcome
1850   // because GetTPCClusterInfo is quite time-consuming
1851   
1852   if (fCacheNCrossedRows > -1)
1853     return fCacheNCrossedRows;
1854   
1855   fCacheNCrossedRows = GetTPCClusterInfo(2, 1);
1856   return fCacheNCrossedRows;
1857 }
1858
1859 //_______________________________________________________________________
1860 Float_t AliESDtrack::GetTPCClusterInfo(Int_t nNeighbours/*=3*/, Int_t type/*=0*/, Int_t row0, Int_t row1, Int_t bitType ) const
1861 {
1862   //
1863   // TPC cluster information
1864   // type 0: get fraction of found/findable clusters with neighbourhood definition
1865   //      1: findable clusters with neighbourhood definition
1866   //      2: found clusters
1867   // bitType:
1868   //      0 - all cluster used
1869   //      1 - clusters  used for the kalman update
1870   // definition of findable clusters:
1871   //            a cluster is defined as findable if there is another cluster
1872   //           within +- nNeighbours pad rows. The idea is to overcome threshold
1873   //           effects with a very simple algorithm.
1874   //
1875
1876   
1877   Int_t found=0;
1878   Int_t findable=0;
1879   Int_t last=-nNeighbours;
1880   const TBits & clusterMap = (bitType%2==0) ? fTPCClusterMap : fTPCFitMap;
1881   
1882   Int_t upperBound=clusterMap.GetNbits();
1883   if (upperBound>row1) upperBound=row1;
1884   for (Int_t i=row0; i<upperBound; ++i){
1885     //look to current row
1886     if (clusterMap[i]) {
1887       last=i;
1888       ++found;
1889       ++findable;
1890       continue;
1891     }
1892     //look to nNeighbours before
1893     if ((i-last)<=nNeighbours) {
1894       ++findable;
1895       continue;
1896     }
1897     //look to nNeighbours after
1898     for (Int_t j=i+1; j<i+1+nNeighbours; ++j){
1899       if (clusterMap[j]){
1900         ++findable;
1901         break;
1902       }
1903     }
1904   }
1905   if (type==2) return found;
1906   if (type==1) return findable;
1907   
1908   if (type==0){
1909     Float_t fraction=0;
1910     if (findable>0) 
1911       fraction=(Float_t)found/(Float_t)findable;
1912     else 
1913       fraction=0;
1914     return fraction;
1915   }  
1916   return 0;  // undefined type - default value
1917 }
1918
1919 //_______________________________________________________________________
1920 Float_t AliESDtrack::GetTPCClusterDensity(Int_t nNeighbours/*=3*/, Int_t type/*=0*/, Int_t row0, Int_t row1, Int_t bitType ) const
1921 {
1922   //
1923   // TPC cluster density -  only rows where signal before and after given row are used
1924   //                     -  slower function
1925   // type 0: get fraction of found/findable clusters with neighbourhood definition
1926   //      1: findable clusters with neighbourhood definition
1927   //      2: found clusters
1928   // bitType:
1929   //      0 - all cluster used
1930   //      1 - clusters  used for the kalman update
1931   // definition of findable clusters:
1932   //            a cluster is defined as findable if there is another cluster
1933   //           within +- nNeighbours pad rows. The idea is to overcome threshold
1934   //           effects with a very simple algorithm.
1935   //  
1936   Int_t found=0;
1937   Int_t findable=0;
1938   //  Int_t last=-nNeighbours;
1939   const TBits & clusterMap = (bitType%2==0) ? fTPCClusterMap : fTPCFitMap;
1940   Int_t upperBound=clusterMap.GetNbits();
1941   if (upperBound>row1) upperBound=row1;
1942   for (Int_t i=row0; i<upperBound; ++i){
1943     Bool_t isUp=kFALSE;
1944     Bool_t isDown=kFALSE;
1945     for (Int_t idelta=1; idelta<=nNeighbours; idelta++){
1946       if (i-idelta>=0 && clusterMap[i-idelta]) isDown=kTRUE;
1947       if (i+idelta<upperBound && clusterMap[i+idelta]) isUp=kTRUE;
1948     }
1949     if (isUp&&isDown){
1950       ++findable;
1951       if (clusterMap[i]) ++found;
1952     }
1953   }
1954   if (type==2) return found;
1955   if (type==1) return findable;
1956   
1957   if (type==0){
1958     Float_t fraction=0;
1959     if (findable>0) 
1960       fraction=(Float_t)found/(Float_t)findable;
1961     else 
1962       fraction=0;
1963     return fraction;
1964   }  
1965   return 0;  // undefined type - default value
1966 }
1967
1968
1969
1970
1971 //_______________________________________________________________________
1972 Double_t AliESDtrack::GetTPCdensity(Int_t row0, Int_t row1) const{
1973   //
1974   // GetDensity of the clusters on given region between row0 and row1
1975   // Dead zone effect takin into acoount
1976   //
1977   if (!fFriendTrack) return 0.0;
1978   Int_t good  = 0;
1979   Int_t found = 0;
1980   //  
1981   Int_t *index=fFriendTrack->GetTPCindices();
1982   for (Int_t i=row0;i<=row1;i++){     
1983     Int_t idx = index[i];
1984     if (idx!=-1)  good++;             // track outside of dead zone
1985     if (idx>0)    found++;
1986   }
1987   Float_t density=0.5;
1988   if (good>TMath::Max((row1-row0)*0.5,0.0)) density = Float_t(found)/Float_t(good);
1989   return density;
1990 }
1991
1992 //_______________________________________________________________________
1993 void AliESDtrack::SetTPCpid(const Double_t *p) {  
1994   // Sets values for the probability of each particle type (in TPC)
1995   SetPIDValues(fTPCr,p,AliPID::kSPECIES);
1996   SetStatus(AliESDtrack::kTPCpid);
1997 }
1998
1999 //_______________________________________________________________________
2000 void AliESDtrack::GetTPCpid(Double_t *p) const {
2001   // Gets the probability of each particle type (in TPC)
2002   for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fTPCr[i];
2003 }
2004
2005 //_______________________________________________________________________
2006 UChar_t AliESDtrack::GetTRDclusters(Int_t *idx) const {
2007   //---------------------------------------------------------------------
2008   // This function returns indices of the assgined TRD clusters 
2009   //---------------------------------------------------------------------
2010   if (idx && fFriendTrack) {
2011     Int_t *index=fFriendTrack->GetTRDindices();
2012
2013     if (index) {
2014       for (Int_t i=0; i<AliESDfriendTrack::kMaxTRDcluster; i++) idx[i]=index[i];
2015     }
2016     else {
2017       for (Int_t i=0; i<AliESDfriendTrack::kMaxTRDcluster; i++) idx[i]=-2;
2018     }
2019   }
2020   return fTRDncls;
2021 }
2022
2023 //_______________________________________________________________________
2024 UChar_t AliESDtrack::GetTRDtracklets(Int_t *idx) const {
2025 //
2026 // This function returns the number of TRD tracklets used in tracking
2027 // and it fills the indices of these tracklets in the array "idx" as they 
2028 // are registered in the TRD track list. 
2029 // 
2030 // Caution :
2031 //   1. The idx array has to be allocated with a size >= AliESDtrack::kTRDnPlanes
2032 //   2. The idx array store not only the index but also the layer of the tracklet. 
2033 //      Therefore tracks with TRD gaps contain default values for indices [-1] 
2034
2035   if (!fFriendTrack) return 0;
2036   if (!idx) return GetTRDntracklets();
2037   Int_t *index=fFriendTrack->GetTRDindices();
2038   Int_t n = 0;
2039   for (Int_t i=0; i<kTRDnPlanes; i++){ 
2040     if (index){
2041       if(index[i]>=0) n++;
2042       idx[i]=index[i];
2043     }
2044     else idx[i] = -2;
2045   }
2046   return n;
2047 }
2048
2049 //_______________________________________________________________________
2050 void AliESDtrack::SetTRDpid(const Double_t *p) {  
2051   // Sets values for the probability of each particle type (in TRD)
2052   SetPIDValues(fTRDr,p,AliPID::kSPECIES);
2053   SetStatus(AliESDtrack::kTRDpid);
2054 }
2055
2056 //_______________________________________________________________________
2057 void AliESDtrack::GetTRDpid(Double_t *p) const {
2058   // Gets the probability of each particle type (in TRD)
2059   for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fTRDr[i];
2060 }
2061
2062 //_______________________________________________________________________
2063 void    AliESDtrack::SetTRDpid(Int_t iSpecies, Float_t p)
2064 {
2065   // Sets the probability of particle type iSpecies to p (in TRD)
2066   fTRDr[iSpecies] = p;
2067 }
2068
2069 Double_t AliESDtrack::GetTRDpid(Int_t iSpecies) const
2070 {
2071   // Returns the probability of particle type iSpecies (in TRD)
2072   return fTRDr[iSpecies];
2073 }
2074
2075 //____________________________________________________
2076 Int_t AliESDtrack::GetNumberOfTRDslices() const 
2077 {
2078   // built in backward compatibility
2079   Int_t idx = fTRDnSlices - (kTRDnPlanes<<1);
2080   return idx<18 ? fTRDnSlices/kTRDnPlanes : idx/kTRDnPlanes;
2081 }
2082
2083 //____________________________________________________
2084 Double_t AliESDtrack::GetTRDmomentum(Int_t plane, Double_t *sp) const
2085 {
2086 //Returns momentum estimation and optional its error (sp)
2087 // in TRD layer "plane".
2088
2089   if (!fTRDnSlices) {
2090     AliDebug(2, "No TRD info allocated for this track.");
2091     return -1.;
2092   }
2093   if ((plane<0) || (plane>=kTRDnPlanes)) {
2094     AliWarning(Form("Request for TRD plane[%d] outside range.", plane)); 
2095     return -1.;
2096   }
2097
2098   Int_t idx = fTRDnSlices-(kTRDnPlanes<<1)+plane;
2099   // Protection for backward compatibility
2100   if(idx<(GetNumberOfTRDslices()*kTRDnPlanes)) return -1.;
2101
2102   if(sp) (*sp) = fTRDslices[idx+kTRDnPlanes];
2103   return fTRDslices[idx];
2104 }
2105
2106 //____________________________________________________
2107 Double_t  AliESDtrack::GetTRDslice(Int_t plane, Int_t slice) const {
2108   //Gets the charge from the slice of the plane
2109
2110   if(!fTRDslices) {
2111     //AliError("No TRD slices allocated for this track !");
2112     return -1.;
2113   }
2114   if ((plane<0) || (plane>=kTRDnPlanes)) {
2115     AliError("Info for TRD plane not available !");
2116     return -1.;
2117   }
2118   Int_t ns=GetNumberOfTRDslices();
2119   if ((slice<-1) || (slice>=ns)) {
2120     //AliError("Wrong TRD slice !");  
2121     return -1.;
2122   }
2123
2124   if(slice>=0) return fTRDslices[plane*ns + slice];
2125
2126   // return average of the dEdx measurements
2127   Double_t q=0.; Double32_t *s = &fTRDslices[plane*ns];
2128   for (Int_t i=0; i<ns; i++, s++) if((*s)>0.) q+=(*s);
2129   return q/ns;
2130 }
2131
2132 //____________________________________________________
2133 void  AliESDtrack::SetNumberOfTRDslices(Int_t n) {
2134   //Sets the number of slices used for PID 
2135   if (fTRDnSlices) return;
2136
2137   fTRDnSlices=n;
2138   fTRDslices=new Double32_t[fTRDnSlices];
2139   
2140   // set-up correctly the allocated memory
2141   memset(fTRDslices, 0, n*sizeof(Double32_t));
2142   for (Int_t i=GetNumberOfTRDslices(); i--;) fTRDslices[i]=-1.;
2143 }
2144
2145 //____________________________________________________
2146 void  AliESDtrack::SetTRDslice(Double_t q, Int_t plane, Int_t slice) {
2147   //Sets the charge q in the slice of the plane
2148   if(!fTRDslices) {
2149     AliError("No TRD slices allocated for this track !");
2150     return;
2151   }
2152   if ((plane<0) || (plane>=kTRDnPlanes)) {
2153     AliError("Info for TRD plane not allocated !");
2154     return;
2155   }
2156   Int_t ns=GetNumberOfTRDslices();
2157   if ((slice<0) || (slice>=ns)) {
2158     AliError(Form("Wrong TRD slice %d/%d, NSlices=%d",plane,slice,ns));
2159     return;
2160   }
2161   Int_t n=plane*ns + slice;
2162   fTRDslices[n]=q;
2163 }
2164
2165
2166 //____________________________________________________
2167 void AliESDtrack::SetTRDmomentum(Double_t p, Int_t plane, Double_t *sp)
2168 {
2169   if(!fTRDslices) {
2170     AliError("No TRD slices allocated for this track !");
2171     return;
2172   }
2173   if ((plane<0) || (plane>=kTRDnPlanes)) {
2174     AliError("Info for TRD plane not allocated !");
2175     return;
2176   }
2177
2178   Int_t idx = fTRDnSlices-(kTRDnPlanes<<1)+plane;
2179   // Protection for backward compatibility
2180   if(idx<GetNumberOfTRDslices()*kTRDnPlanes) return;
2181
2182   if(sp) fTRDslices[idx+kTRDnPlanes] = (*sp);
2183   fTRDslices[idx] = p;
2184 }
2185
2186
2187 //_______________________________________________________________________
2188 void AliESDtrack::SetTOFpid(const Double_t *p) {  
2189   // Sets the probability of each particle type (in TOF)
2190   SetPIDValues(fTOFr,p,AliPID::kSPECIES);
2191   SetStatus(AliESDtrack::kTOFpid);
2192 }
2193
2194 //_______________________________________________________________________
2195 void AliESDtrack::SetTOFLabel(const Int_t *p) {  
2196   // Sets  (in TOF)
2197   for (Int_t i=0; i<3; i++) fTOFLabel[i]=p[i];
2198 }
2199
2200 //_______________________________________________________________________
2201 void AliESDtrack::GetTOFpid(Double_t *p) const {
2202   // Gets probabilities of each particle type (in TOF)
2203   for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fTOFr[i];
2204 }
2205
2206 //_______________________________________________________________________
2207 void AliESDtrack::GetTOFLabel(Int_t *p) const {
2208   // Gets (in TOF)
2209   for (Int_t i=0; i<3; i++) p[i]=fTOFLabel[i];
2210 }
2211
2212 //_______________________________________________________________________
2213 void AliESDtrack::GetTOFInfo(Float_t *info) const {
2214   // Gets (in TOF)
2215   for (Int_t i=0; i<10; i++) info[i]=fTOFInfo[i];
2216 }
2217
2218 //_______________________________________________________________________
2219 void AliESDtrack::SetTOFInfo(Float_t*info) {
2220   // Gets (in TOF)
2221   for (Int_t i=0; i<10; i++) fTOFInfo[i]=info[i];
2222 }
2223
2224
2225
2226 //_______________________________________________________________________
2227 void AliESDtrack::SetHMPIDpid(const Double_t *p) {  
2228   // Sets the probability of each particle type (in HMPID)
2229   SetPIDValues(fHMPIDr,p,AliPID::kSPECIES);
2230   SetStatus(AliESDtrack::kHMPIDpid);
2231 }
2232
2233 //_______________________________________________________________________
2234 void  AliESDtrack::SetTPCdEdxInfo(AliTPCdEdxInfo * dEdxInfo){ 
2235   if(fTPCdEdxInfo) delete fTPCdEdxInfo;
2236   fTPCdEdxInfo = dEdxInfo; 
2237 }
2238
2239 //_______________________________________________________________________
2240 void AliESDtrack::GetHMPIDpid(Double_t *p) const {
2241   // Gets probabilities of each particle type (in HMPID)
2242   for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fHMPIDr[i];
2243 }
2244
2245
2246
2247 //_______________________________________________________________________
2248 void AliESDtrack::SetESDpid(const Double_t *p) {  
2249   // Sets the probability of each particle type for the ESD track
2250   SetPIDValues(fR,p,AliPID::kSPECIES);
2251   SetStatus(AliESDtrack::kESDpid);
2252 }
2253
2254 //_______________________________________________________________________
2255 void AliESDtrack::GetESDpid(Double_t *p) const {
2256   // Gets probability of each particle type for the ESD track
2257   for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fR[i];
2258 }
2259
2260 //_______________________________________________________________________
2261 Bool_t AliESDtrack::RelateToVertexTPC(const AliESDVertex *vtx, 
2262 Double_t b, Double_t maxd, AliExternalTrackParam *cParam) {
2263   //
2264   // Try to relate the TPC-only track parameters to the vertex "vtx", 
2265   // if the (rough) transverse impact parameter is not bigger then "maxd". 
2266   //            Magnetic field is "b" (kG).
2267   //
2268   // a) The TPC-only paramters are extapolated to the DCA to the vertex.
2269   // b) The impact parameters and their covariance matrix are calculated.
2270   // c) An attempt to constrain the TPC-only params to the vertex is done.
2271   //    The constrained params are returned via "cParam".
2272   //
2273   // In the case of success, the returned value is kTRUE
2274   // otherwise, it's kFALSE)
2275   // 
2276
2277   if (!fTPCInner) return kFALSE;
2278   if (!vtx) return kFALSE;
2279
2280   Double_t dz[2],cov[3];
2281   if (!fTPCInner->PropagateToDCA(vtx, b, maxd, dz, cov)) return kFALSE;
2282
2283   fdTPC = dz[0];
2284   fzTPC = dz[1];  
2285   fCddTPC = cov[0];
2286   fCdzTPC = cov[1];
2287   fCzzTPC = cov[2];
2288   
2289   Double_t covar[6]; vtx->GetCovMatrix(covar);
2290   Double_t p[2]={GetParameter()[0]-dz[0],GetParameter()[1]-dz[1]};
2291   Double_t c[3]={covar[2],0.,covar[5]};
2292
2293   Double_t chi2=GetPredictedChi2(p,c);
2294   if (chi2>kVeryBig) return kFALSE;
2295
2296   fCchi2TPC=chi2;
2297
2298   if (!cParam) return kTRUE;
2299
2300   *cParam = *fTPCInner;
2301   if (!cParam->Update(p,c)) return kFALSE;
2302
2303   return kTRUE;
2304 }
2305
2306 //_______________________________________________________________________
2307 Bool_t AliESDtrack::RelateToVertexTPCBxByBz(const AliESDVertex *vtx, 
2308 Double_t b[3], Double_t maxd, AliExternalTrackParam *cParam) {
2309   //
2310   // Try to relate the TPC-only track parameters to the vertex "vtx", 
2311   // if the (rough) transverse impact parameter is not bigger then "maxd". 
2312   //
2313   // All three components of the magnetic field ,"b[3]" (kG), 
2314   // are taken into account.
2315   //
2316   // a) The TPC-only paramters are extapolated to the DCA to the vertex.
2317   // b) The impact parameters and their covariance matrix are calculated.
2318   // c) An attempt to constrain the TPC-only params to the vertex is done.
2319   //    The constrained params are returned via "cParam".
2320   //
2321   // In the case of success, the returned value is kTRUE
2322   // otherwise, it's kFALSE)
2323   // 
2324
2325   if (!fTPCInner) return kFALSE;
2326   if (!vtx) return kFALSE;
2327
2328   Double_t dz[2],cov[3];
2329   if (!fTPCInner->PropagateToDCABxByBz(vtx, b, maxd, dz, cov)) return kFALSE;
2330
2331   fdTPC = dz[0];
2332   fzTPC = dz[1];  
2333   fCddTPC = cov[0];
2334   fCdzTPC = cov[1];
2335   fCzzTPC = cov[2];
2336   
2337   Double_t covar[6]; vtx->GetCovMatrix(covar);
2338   Double_t p[2]={GetParameter()[0]-dz[0],GetParameter()[1]-dz[1]};
2339   Double_t c[3]={covar[2],0.,covar[5]};
2340
2341   Double_t chi2=GetPredictedChi2(p,c);
2342   if (chi2>kVeryBig) return kFALSE;
2343
2344   fCchi2TPC=chi2;
2345
2346   if (!cParam) return kTRUE;
2347
2348   *cParam = *fTPCInner;
2349   if (!cParam->Update(p,c)) return kFALSE;
2350
2351   return kTRUE;
2352 }
2353
2354 //_______________________________________________________________________
2355 Bool_t AliESDtrack::RelateToVertex(const AliESDVertex *vtx, 
2356 Double_t b, Double_t maxd, AliExternalTrackParam *cParam) {
2357   //
2358   // Try to relate this track to the vertex "vtx", 
2359   // if the (rough) transverse impact parameter is not bigger then "maxd". 
2360   //            Magnetic field is "b" (kG).
2361   //
2362   // a) The track gets extapolated to the DCA to the vertex.
2363   // b) The impact parameters and their covariance matrix are calculated.
2364   // c) An attempt to constrain this track to the vertex is done.
2365   //    The constrained params are returned via "cParam".
2366   //
2367   // In the case of success, the returned value is kTRUE
2368   // (otherwise, it's kFALSE)
2369   //  
2370
2371   if (!vtx) return kFALSE;
2372
2373   Double_t dz[2],cov[3];
2374   if (!PropagateToDCA(vtx, b, maxd, dz, cov)) return kFALSE;
2375
2376   fD = dz[0];
2377   fZ = dz[1];  
2378   fCdd = cov[0];
2379   fCdz = cov[1];
2380   fCzz = cov[2];
2381   
2382   Double_t covar[6]; vtx->GetCovMatrix(covar);
2383   Double_t p[2]={GetParameter()[0]-dz[0],GetParameter()[1]-dz[1]};
2384   Double_t c[3]={covar[2],0.,covar[5]};
2385
2386   Double_t chi2=GetPredictedChi2(p,c);
2387   if (chi2>kVeryBig) return kFALSE;
2388
2389   fCchi2=chi2;
2390
2391
2392   //--- Could now these lines be removed ? ---
2393   delete fCp;
2394   fCp=new AliExternalTrackParam(*this);  
2395
2396   if (!fCp->Update(p,c)) {delete fCp; fCp=0; return kFALSE;}
2397   //----------------------------------------
2398
2399   fVertexID = vtx->GetID();
2400
2401   if (!cParam) return kTRUE;
2402
2403   *cParam = *this;
2404   if (!cParam->Update(p,c)) return kFALSE; 
2405
2406   return kTRUE;
2407 }
2408
2409 //_______________________________________________________________________
2410 Bool_t AliESDtrack::RelateToVertexBxByBz(const AliESDVertex *vtx, 
2411 Double_t b[3], Double_t maxd, AliExternalTrackParam *cParam) {
2412   //
2413   // Try to relate this track to the vertex "vtx", 
2414   // if the (rough) transverse impact parameter is not bigger then "maxd". 
2415   //            Magnetic field is "b" (kG).
2416   //
2417   // a) The track gets extapolated to the DCA to the vertex.
2418   // b) The impact parameters and their covariance matrix are calculated.
2419   // c) An attempt to constrain this track to the vertex is done.
2420   //    The constrained params are returned via "cParam".
2421   //
2422   // In the case of success, the returned value is kTRUE
2423   // (otherwise, it's kFALSE)
2424   //  
2425
2426   if (!vtx) return kFALSE;
2427
2428   Double_t dz[2],cov[3];
2429   if (!PropagateToDCABxByBz(vtx, b, maxd, dz, cov)) return kFALSE;
2430
2431   fD = dz[0];
2432   fZ = dz[1];  
2433   fCdd = cov[0];
2434   fCdz = cov[1];
2435   fCzz = cov[2];
2436   
2437   Double_t covar[6]; vtx->GetCovMatrix(covar);
2438   Double_t p[2]={GetParameter()[0]-dz[0],GetParameter()[1]-dz[1]};
2439   Double_t c[3]={covar[2],0.,covar[5]};
2440
2441   Double_t chi2=GetPredictedChi2(p,c);
2442   if (chi2>kVeryBig) return kFALSE;
2443
2444   fCchi2=chi2;
2445
2446
2447   //--- Could now these lines be removed ? ---
2448   delete fCp;
2449   fCp=new AliExternalTrackParam(*this);  
2450
2451   if (!fCp->Update(p,c)) {delete fCp; fCp=0; return kFALSE;}
2452   //----------------------------------------
2453
2454   fVertexID = vtx->GetID();
2455
2456   if (!cParam) return kTRUE;
2457
2458   *cParam = *this;
2459   if (!cParam->Update(p,c)) return kFALSE; 
2460
2461   return kTRUE;
2462 }
2463
2464 //_______________________________________________________________________
2465 void AliESDtrack::Print(Option_t *) const {
2466   // Prints info on the track
2467   AliExternalTrackParam::Print();
2468   printf("ESD track info\n") ; 
2469   Double_t p[AliPID::kSPECIES] ;
2470   Int_t index = 0 ; 
2471   if( IsOn(kITSpid) ){
2472     printf("From ITS: ") ; 
2473     GetITSpid(p) ; 
2474     for(index = 0 ; index < AliPID::kSPECIES; index++) 
2475       printf("%f, ", p[index]) ;
2476     printf("\n           signal = %f\n", GetITSsignal()) ;
2477   } 
2478   if( IsOn(kTPCpid) ){
2479     printf("From TPC: ") ; 
2480     GetTPCpid(p) ; 
2481     for(index = 0 ; index < AliPID::kSPECIES; index++) 
2482       printf("%f, ", p[index]) ;
2483     printf("\n           signal = %f\n", GetTPCsignal()) ;
2484   }
2485   if( IsOn(kTRDpid) ){
2486     printf("From TRD: ") ; 
2487     GetTRDpid(p) ; 
2488     for(index = 0 ; index < AliPID::kSPECIES; index++) 
2489       printf("%f, ", p[index]) ;
2490       printf("\n           signal = %f\n", GetTRDsignal()) ;
2491       printf("\n           NchamberdEdx = %d\n", GetTRDNchamberdEdx()) ;
2492       printf("\n           NclusterdEdx = %d\n", GetTRDNclusterdEdx()) ;
2493   }
2494   if( IsOn(kTOFpid) ){
2495     printf("From TOF: ") ; 
2496     GetTOFpid(p) ; 
2497     for(index = 0 ; index < AliPID::kSPECIES; index++) 
2498       printf("%f, ", p[index]) ;
2499     printf("\n           signal = %f\n", GetTOFsignal()) ;
2500   }
2501   if( IsOn(kHMPIDpid) ){
2502     printf("From HMPID: ") ; 
2503     GetHMPIDpid(p) ; 
2504     for(index = 0 ; index < AliPID::kSPECIES; index++) 
2505       printf("%f, ", p[index]) ;
2506     printf("\n           signal = %f\n", GetHMPIDsignal()) ;
2507   }
2508
2509
2510
2511 //
2512 // Draw functionality
2513 // Origin: Marian Ivanov, Marian.Ivanov@cern.ch
2514 //
2515 void AliESDtrack::FillPolymarker(TPolyMarker3D *pol, Float_t magF, Float_t minR, Float_t maxR, Float_t stepR){
2516   //
2517   // Fill points in the polymarker
2518   //
2519   TObjArray arrayRef;
2520   arrayRef.AddLast(new AliExternalTrackParam(*this));
2521   if (fIp) arrayRef.AddLast(new AliExternalTrackParam(*fIp));
2522   if (fOp) arrayRef.AddLast(new AliExternalTrackParam(*fOp));
2523   if (fHMPIDp) arrayRef.AddLast(new AliExternalTrackParam(*fHMPIDp));
2524   //
2525   Double_t mpos[3]={0,0,0};
2526   Int_t entries=arrayRef.GetEntries();
2527   for (Int_t i=0;i<entries;i++){
2528     Double_t pos[3];
2529     ((AliExternalTrackParam*)arrayRef.At(i))->GetXYZ(pos);
2530     mpos[0]+=pos[0]/entries;
2531     mpos[1]+=pos[1]/entries;
2532     mpos[2]+=pos[2]/entries;    
2533   }
2534   // Rotate to the mean position
2535   //
2536   Float_t fi= TMath::ATan2(mpos[1],mpos[0]);
2537   for (Int_t i=0;i<entries;i++){
2538     Bool_t res = ((AliExternalTrackParam*)arrayRef.At(i))->Rotate(fi);
2539     if (!res) delete arrayRef.RemoveAt(i);
2540   }
2541   Int_t counter=0;
2542   for (Double_t r=minR; r<maxR; r+=stepR){
2543     Double_t sweight=0;
2544     Double_t mlpos[3]={0,0,0};
2545     for (Int_t i=0;i<entries;i++){
2546       Double_t point[3]={0,0,0};
2547       AliExternalTrackParam *param = ((AliExternalTrackParam*)arrayRef.At(i));
2548       if (!param) continue;
2549       if (param->GetXYZAt(r,magF,point)){
2550         Double_t weight = 1./(10.+(r-param->GetX())*(r-param->GetX()));
2551         sweight+=weight;
2552         mlpos[0]+=point[0]*weight;
2553         mlpos[1]+=point[1]*weight;
2554         mlpos[2]+=point[2]*weight;
2555       }
2556     }
2557     if (sweight>0){
2558       mlpos[0]/=sweight;
2559       mlpos[1]/=sweight;
2560       mlpos[2]/=sweight;      
2561       pol->SetPoint(counter,mlpos[0],mlpos[1], mlpos[2]);
2562       //      printf("xyz\t%f\t%f\t%f\n",mlpos[0], mlpos[1],mlpos[2]);
2563       counter++;
2564     }
2565   }
2566 }
2567
2568 //_______________________________________________________________________
2569 void AliESDtrack::SetITSdEdxSamples(const Double_t s[4]) {
2570   //
2571   // Store the dE/dx samples measured by the two SSD and two SDD layers.
2572   // These samples are corrected for the track segment length. 
2573   //
2574   for (Int_t i=0; i<4; i++) fITSdEdxSamples[i]=s[i];
2575 }
2576
2577 //_______________________________________________________________________
2578 void AliESDtrack::GetITSdEdxSamples(Double_t s[4]) const {
2579   //
2580   // Get the dE/dx samples measured by the two SSD and two SDD layers.  
2581   // These samples are corrected for the track segment length.
2582   //
2583   for (Int_t i=0; i<4; i++) s[i]=fITSdEdxSamples[i];
2584 }
2585
2586
2587 UShort_t   AliESDtrack::GetTPCnclsS(Int_t i0,Int_t i1) const{
2588   //
2589   // get number of shared TPC clusters
2590   //
2591   return  fTPCSharedMap.CountBits(i0)-fTPCSharedMap.CountBits(i1);
2592 }
2593
2594 UShort_t   AliESDtrack::GetTPCncls(Int_t i0,Int_t i1) const{
2595   //
2596   // get number of TPC clusters
2597   //
2598   return  fTPCClusterMap.CountBits(i0)-fTPCClusterMap.CountBits(i1);
2599 }
2600
2601 //____________________________________________________________________
2602 Double_t AliESDtrack::GetChi2TPCConstrainedVsGlobal(const AliESDVertex* vtx) const
2603 {
2604   // Calculates the chi2 between the TPC track (TPCinner) constrained to the primary vertex and the global track
2605   //
2606   // Returns -1 in case the calculation failed
2607   //
2608   // Value is cached as a non-persistent member.
2609   //
2610   // Code adapted from original code by GSI group (Jacek, Marian, Michael)
2611   
2612   // cache, ignoring that a different vertex might be passed
2613   if (fCacheChi2TPCConstrainedVsGlobalVertex == vtx)
2614     return fCacheChi2TPCConstrainedVsGlobal;
2615   
2616   fCacheChi2TPCConstrainedVsGlobal = -1;
2617   fCacheChi2TPCConstrainedVsGlobalVertex = vtx;
2618   
2619   Double_t x[3];
2620   GetXYZ(x);
2621   Double_t b[3];
2622   AliTrackerBase::GetBxByBz(x,b);
2623
2624   if (!fTPCInner)  { 
2625     AliWarning("Could not get TPC Inner Param.");
2626     return fCacheChi2TPCConstrainedVsGlobal;
2627   }
2628   
2629   // clone for constraining
2630   AliExternalTrackParam* tpcInnerC = new AliExternalTrackParam(*fTPCInner);
2631   if (!tpcInnerC) { 
2632     AliWarning("Clone of TPCInnerParam failed.");
2633     return fCacheChi2TPCConstrainedVsGlobal;  
2634   }
2635   
2636   // transform to the track reference frame 
2637   Bool_t isOK = tpcInnerC->Rotate(GetAlpha());
2638   isOK &= tpcInnerC->PropagateTo(GetX(), b[2]);
2639   if (!isOK) { 
2640     delete tpcInnerC;
2641     tpcInnerC = 0; 
2642     AliWarning("Rotation/Propagation of track failed.") ; 
2643     return fCacheChi2TPCConstrainedVsGlobal;    
2644   }  
2645
2646   // constrain TPCinner 
2647   isOK = tpcInnerC->ConstrainToVertex(vtx, b);
2648   
2649   // transform to the track reference frame 
2650   isOK &= tpcInnerC->Rotate(GetAlpha());
2651   isOK &= tpcInnerC->PropagateTo(GetX(), b[2]);
2652
2653   if (!isOK) {
2654     AliWarning("ConstrainTPCInner failed.") ;
2655     delete tpcInnerC;
2656     tpcInnerC = 0; 
2657     return fCacheChi2TPCConstrainedVsGlobal;  
2658   }
2659   
2660   // calculate chi2 between vi and vj vectors
2661   // with covi and covj covariance matrices
2662   // chi2ij = (vi-vj)^(T)*(covi+covj)^(-1)*(vi-vj)
2663   TMatrixD deltaT(5,1);
2664   TMatrixD delta(1,5);
2665   TMatrixD covarM(5,5);
2666
2667   for (Int_t ipar=0; ipar<5; ipar++) {
2668     deltaT(ipar,0) = tpcInnerC->GetParameter()[ipar] - GetParameter()[ipar];
2669     delta(0,ipar) = tpcInnerC->GetParameter()[ipar] - GetParameter()[ipar];
2670
2671     for (Int_t jpar=0; jpar<5; jpar++) {
2672       Int_t index = GetIndex(ipar,jpar);
2673       covarM(ipar,jpar) = GetCovariance()[index]+tpcInnerC->GetCovariance()[index];
2674     }
2675   }
2676   // chi2 distance TPC constrained and TPC+ITS
2677   TMatrixD covarMInv = covarM.Invert();
2678   TMatrixD mat2 = covarMInv*deltaT;
2679   TMatrixD chi2 = delta*mat2; 
2680   
2681   delete tpcInnerC; 
2682   tpcInnerC = 0;
2683   
2684   fCacheChi2TPCConstrainedVsGlobal = chi2(0,0);
2685   return fCacheChi2TPCConstrainedVsGlobal;
2686 }
2687
2688 void AliESDtrack::SetDetectorPID(const AliDetectorPID *pid)
2689 {
2690   //
2691   // Set the detector PID
2692   //
2693   if (fDetectorPID) delete fDetectorPID;
2694   fDetectorPID=pid;
2695   
2696 }