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