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