Update master to aliroot
[u/mrichter/AliRoot.git] / STEER / AOD / AliAODTrack.cxx
CommitLineData
df9db588 1/**************************************************************************
2 * Copyright(c) 1998-2007, 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/* $Id$ */
17
18//-------------------------------------------------------------------------
4f6e22bd 19// AOD track implementation of AliVTrack
df9db588 20// Author: Markus Oldenburg, CERN
0c5f89fb 21// Markus.Oldenburg@cern.ch
df9db588 22//-------------------------------------------------------------------------
23
086400fc 24#include <TVector3.h>
8ac4fa64 25#include "AliLog.h"
6dc40b1c 26#include "AliExternalTrackParam.h"
27#include "AliVVertex.h"
00a38d07 28#include "AliDetectorPID.h"
aab77ed0 29#include "AliAODEvent.h"
567624b5 30#include "AliAODHMPIDrings.h"
42fcc729 31#include "AliTOFHeader.h"
567624b5 32
33#include "AliAODTrack.h"
df9db588 34
35ClassImp(AliAODTrack)
36
37//______________________________________________________________________________
38AliAODTrack::AliAODTrack() :
4f6e22bd 39 AliVTrack(),
f43586f0 40 fRAtAbsorberEnd(0.),
1912763f 41 fChi2perNDF(-999.),
9333290e 42 fChi2MatchTrigger(0.),
76b98553 43 fPID(0),
6efb741f 44 fFlags(0),
df9db588 45 fLabel(-999),
a2c30af1 46 fTOFLabel(),
9b5c8b95 47 fTrackLength(0),
1912763f 48 fITSMuonClusterMap(0),
0a2dcc83 49 fMUONtrigHitsMapTrg(0),
50 fMUONtrigHitsMapTrk(0),
9333290e 51 fFilterMap(0),
bcabd0e4 52 fTPCFitMap(),
d999f2e6 53 fTPCClusterMap(),
54 fTPCSharedMap(),
3c01c166 55 fTPCnclsF(0),
820214a7 56 fTPCNCrossedRows(0),
02153d58 57 fID(-999),
9333290e 58 fCharge(-99),
e1c744ca 59 fType(kUndef),
76b98553 60 fPIDForTracking(AliPID::kPion),
a7d9ab9e 61 fCaloIndex(kEMCALNoMatch),
9333290e 62 fCovMatrix(NULL),
7be1db84 63 fDetPid(NULL),
00a38d07 64 fDetectorPID(NULL),
ed15417e 65 fProdVertex(NULL),
66 fTrackPhiOnEMCal(-999),
aab77ed0 67 fTrackEtaOnEMCal(-999),
a29b2a8a 68 fTrackPtOnEMCal(-999),
f7cc8591 69 fIsMuonGlobalTrack(kFALSE), // AU
539a5a59 70 fTPCsignalTuned(0),
a2c30af1 71 fTOFsignalTuned(99999),
f7cc8591 72 fMFTClusterPattern(0), // AU
aab77ed0 73 fAODEvent(NULL)
df9db588 74{
75 // default constructor
76
77 SetP();
78 SetPosition((Float_t*)NULL);
6c954176 79 SetXYAtDCA(-999., -999.);
80 SetPxPyPzAtDCA(-999., -999., -999.);
a2c30af1 81 for (Int_t i = 0; i < 3; i++) {fTOFLabel[i] = -1;}
df9db588 82}
83
84//______________________________________________________________________________
02153d58 85AliAODTrack::AliAODTrack(Short_t id,
df9db588 86 Int_t label,
87 Double_t p[3],
88 Bool_t cartesian,
89 Double_t x[3],
90 Bool_t isDCA,
91 Double_t covMatrix[21],
92 Short_t charge,
93 UChar_t itsClusMap,
df9db588 94 AliAODVertex *prodVertex,
1912763f 95 Bool_t usedForVtxFit,
dc825b15 96 Bool_t usedForPrimVtxFit,
ec40c484 97 AODTrk_t ttype,
862ce351 98 UInt_t selectInfo,
99 Float_t chi2perNDF) :
4f6e22bd 100 AliVTrack(),
f43586f0 101 fRAtAbsorberEnd(0.),
862ce351 102 fChi2perNDF(chi2perNDF),
9333290e 103 fChi2MatchTrigger(0.),
76b98553 104 fPID(0),
6efb741f 105 fFlags(0),
df9db588 106 fLabel(label),
a2c30af1 107 fTOFLabel(),
9b5c8b95 108 fTrackLength(0),
6c954176 109 fITSMuonClusterMap(0),
0a2dcc83 110 fMUONtrigHitsMapTrg(0),
111 fMUONtrigHitsMapTrk(0),
9333290e 112 fFilterMap(selectInfo),
bcabd0e4 113 fTPCFitMap(),
d999f2e6 114 fTPCClusterMap(),
115 fTPCSharedMap(),
3c01c166 116 fTPCnclsF(0),
820214a7 117 fTPCNCrossedRows(0),
02153d58 118 fID(id),
9333290e 119 fCharge(charge),
e1c744ca 120 fType(ttype),
76b98553 121 fPIDForTracking(AliPID::kPion),
a7d9ab9e 122 fCaloIndex(kEMCALNoMatch),
9333290e 123 fCovMatrix(NULL),
7be1db84 124 fDetPid(NULL),
00a38d07 125 fDetectorPID(NULL),
ed15417e 126 fProdVertex(prodVertex),
127 fTrackPhiOnEMCal(-999),
aab77ed0 128 fTrackEtaOnEMCal(-999),
a29b2a8a 129 fTrackPtOnEMCal(-999),
f7cc8591 130 fIsMuonGlobalTrack(kFALSE), // AU
539a5a59 131 fTPCsignalTuned(0),
a2c30af1 132 fTOFsignalTuned(99999),
f7cc8591 133 fMFTClusterPattern(0), // AU
aab77ed0 134 fAODEvent(NULL)
df9db588 135{
136 // constructor
137
138 SetP(p, cartesian);
139 SetPosition(x, isDCA);
6c954176 140 SetXYAtDCA(-999., -999.);
141 SetPxPyPzAtDCA(-999., -999., -999.);
1912763f 142 SetUsedForVtxFit(usedForVtxFit);
dc825b15 143 SetUsedForPrimVtxFit(usedForPrimVtxFit);
df9db588 144 if(covMatrix) SetCovMatrix(covMatrix);
6c954176 145 SetITSClusterMap(itsClusMap);
a2c30af1 146 for (Int_t i=0;i<3;i++) {fTOFLabel[i]=-1;}
df9db588 147}
148
149//______________________________________________________________________________
02153d58 150AliAODTrack::AliAODTrack(Short_t id,
df9db588 151 Int_t label,
152 Float_t p[3],
153 Bool_t cartesian,
154 Float_t x[3],
155 Bool_t isDCA,
156 Float_t covMatrix[21],
157 Short_t charge,
158 UChar_t itsClusMap,
df9db588 159 AliAODVertex *prodVertex,
1912763f 160 Bool_t usedForVtxFit,
dc825b15 161 Bool_t usedForPrimVtxFit,
ec40c484 162 AODTrk_t ttype,
862ce351 163 UInt_t selectInfo,
76b98553 164 Float_t chi2perNDF ) :
4f6e22bd 165 AliVTrack(),
f43586f0 166 fRAtAbsorberEnd(0.),
862ce351 167 fChi2perNDF(chi2perNDF),
9333290e 168 fChi2MatchTrigger(0.),
76b98553 169 fPID(0),
6efb741f 170 fFlags(0),
df9db588 171 fLabel(label),
a2c30af1 172 fTOFLabel(),
9b5c8b95 173 fTrackLength(0),
6c954176 174 fITSMuonClusterMap(0),
0a2dcc83 175 fMUONtrigHitsMapTrg(0),
176 fMUONtrigHitsMapTrk(0),
9333290e 177 fFilterMap(selectInfo),
bcabd0e4 178 fTPCFitMap(),
d999f2e6 179 fTPCClusterMap(),
180 fTPCSharedMap(),
3c01c166 181 fTPCnclsF(0),
820214a7 182 fTPCNCrossedRows(0),
02153d58 183 fID(id),
9333290e 184 fCharge(charge),
e1c744ca 185 fType(ttype),
76b98553 186 fPIDForTracking(AliPID::kPion),
a7d9ab9e 187 fCaloIndex(kEMCALNoMatch),
9333290e 188 fCovMatrix(NULL),
7be1db84 189 fDetPid(NULL),
00a38d07 190 fDetectorPID(NULL),
ed15417e 191 fProdVertex(prodVertex),
192 fTrackPhiOnEMCal(-999),
aab77ed0 193 fTrackEtaOnEMCal(-999),
a29b2a8a 194 fTrackPtOnEMCal(-999),
f7cc8591 195 fIsMuonGlobalTrack(kFALSE), // AU
539a5a59 196 fTPCsignalTuned(0),
a2c30af1 197 fTOFsignalTuned(99999),
f7cc8591 198 fMFTClusterPattern(0), // AU
aab77ed0 199 fAODEvent(NULL)
df9db588 200{
201 // constructor
202
203 SetP(p, cartesian);
204 SetPosition(x, isDCA);
6c954176 205 SetXYAtDCA(-999., -999.);
206 SetPxPyPzAtDCA(-999., -999., -999.);
1912763f 207 SetUsedForVtxFit(usedForVtxFit);
dc825b15 208 SetUsedForPrimVtxFit(usedForPrimVtxFit);
df9db588 209 if(covMatrix) SetCovMatrix(covMatrix);
6c954176 210 SetITSClusterMap(itsClusMap);
a2c30af1 211 for (Int_t i=0;i<3;i++) {fTOFLabel[i]=-1;}
df9db588 212}
213
df9db588 214//______________________________________________________________________________
215AliAODTrack::~AliAODTrack()
216{
217 // destructor
218 delete fCovMatrix;
7450f8ab 219 delete fDetPid;
00a38d07 220 delete fDetectorPID;
1b4891a7 221 if (fPID) {delete[] fPID; fPID = 0;}
df9db588 222}
223
224
225//______________________________________________________________________________
226AliAODTrack::AliAODTrack(const AliAODTrack& trk) :
4f6e22bd 227 AliVTrack(trk),
f43586f0 228 fRAtAbsorberEnd(trk.fRAtAbsorberEnd),
1912763f 229 fChi2perNDF(trk.fChi2perNDF),
9333290e 230 fChi2MatchTrigger(trk.fChi2MatchTrigger),
76b98553 231 fPID(0),
6efb741f 232 fFlags(trk.fFlags),
df9db588 233 fLabel(trk.fLabel),
a2c30af1 234 fTOFLabel(),
9b5c8b95 235 fTrackLength(trk.fTrackLength),
1912763f 236 fITSMuonClusterMap(trk.fITSMuonClusterMap),
0a2dcc83 237 fMUONtrigHitsMapTrg(trk.fMUONtrigHitsMapTrg),
238 fMUONtrigHitsMapTrk(trk.fMUONtrigHitsMapTrk),
9333290e 239 fFilterMap(trk.fFilterMap),
bcabd0e4 240 fTPCFitMap(trk.fTPCFitMap),
d999f2e6 241 fTPCClusterMap(trk.fTPCClusterMap),
242 fTPCSharedMap(trk.fTPCSharedMap),
3c01c166 243 fTPCnclsF(trk.fTPCnclsF),
820214a7 244 fTPCNCrossedRows(trk.fTPCNCrossedRows),
02153d58 245 fID(trk.fID),
9333290e 246 fCharge(trk.fCharge),
e1c744ca 247 fType(trk.fType),
76b98553 248 fPIDForTracking(trk.fPIDForTracking),
a7d9ab9e 249 fCaloIndex(trk.fCaloIndex),
9333290e 250 fCovMatrix(NULL),
7be1db84 251 fDetPid(NULL),
00a38d07 252 fDetectorPID(NULL),
ed15417e 253 fProdVertex(trk.fProdVertex),
254 fTrackPhiOnEMCal(trk.fTrackPhiOnEMCal),
aab77ed0 255 fTrackEtaOnEMCal(trk.fTrackEtaOnEMCal),
a29b2a8a 256 fTrackPtOnEMCal(trk.fTrackPtOnEMCal),
f7cc8591 257 fIsMuonGlobalTrack(trk.fIsMuonGlobalTrack), // AU
539a5a59 258 fTPCsignalTuned(trk.fTPCsignalTuned),
a2c30af1 259 fTOFsignalTuned(trk.fTOFsignalTuned),
f7cc8591 260 fMFTClusterPattern(trk.fMFTClusterPattern), // AU
aab77ed0 261 fAODEvent(trk.fAODEvent)
df9db588 262{
263 // Copy constructor
264
265 trk.GetP(fMomentum);
266 trk.GetPosition(fPosition);
6c954176 267 SetXYAtDCA(trk.XAtDCA(), trk.YAtDCA());
268 SetPxPyPzAtDCA(trk.PxAtDCA(), trk.PyAtDCA(), trk.PzAtDCA());
1912763f 269 SetUsedForVtxFit(trk.GetUsedForVtxFit());
dc825b15 270 SetUsedForPrimVtxFit(trk.GetUsedForPrimVtxFit());
5d62ce04 271 if(trk.fCovMatrix) fCovMatrix=new AliAODRedCov<6>(*trk.fCovMatrix);
7be1db84 272 if(trk.fDetPid) fDetPid=new AliAODPid(*trk.fDetPid);
df9db588 273 SetPID(trk.fPID);
00a38d07 274 if (trk.fDetectorPID) fDetectorPID = new AliDetectorPID(*trk.fDetectorPID);
a2c30af1 275 for (Int_t i = 0; i < 3; i++) {fTOFLabel[i] = trk.fTOFLabel[i];}
df9db588 276}
277
278//______________________________________________________________________________
279AliAODTrack& AliAODTrack::operator=(const AliAODTrack& trk)
280{
281 // Assignment operator
282 if(this!=&trk) {
283
4f6e22bd 284 AliVTrack::operator=(trk);
df9db588 285
286 trk.GetP(fMomentum);
287 trk.GetPosition(fPosition);
6c954176 288 SetXYAtDCA(trk.XAtDCA(), trk.YAtDCA());
289 SetPxPyPzAtDCA(trk.PxAtDCA(), trk.PyAtDCA(), trk.PzAtDCA());
05f9607e 290 fRAtAbsorberEnd = trk.fRAtAbsorberEnd;
291 fChi2perNDF = trk.fChi2perNDF;
292 fChi2MatchTrigger = trk.fChi2MatchTrigger;
76b98553 293 SetPID( trk.fPID );
05f9607e 294 fFlags = trk.fFlags;
295 fLabel = trk.fLabel;
9b5c8b95 296 fTrackLength = trk.fTrackLength;
9333290e 297 fITSMuonClusterMap = trk.fITSMuonClusterMap;
0a2dcc83 298 fMUONtrigHitsMapTrg = trk.fMUONtrigHitsMapTrg;
299 fMUONtrigHitsMapTrk = trk.fMUONtrigHitsMapTrk;
05f9607e 300 fFilterMap = trk.fFilterMap;
bcabd0e4 301 fTPCFitMap = trk.fTPCFitMap;
05f9607e 302 fTPCClusterMap = trk.fTPCClusterMap;
303 fTPCSharedMap = trk.fTPCSharedMap;
304 fTPCnclsF = trk.fTPCnclsF;
820214a7 305 fTPCNCrossedRows = trk.fTPCNCrossedRows;
05f9607e 306 fID = trk.fID;
307 fCharge = trk.fCharge;
308 fType = trk.fType;
76b98553 309 fPIDForTracking = trk.fPIDForTracking;
05f9607e 310 fCaloIndex = trk.fCaloIndex;
ed15417e 311 fTrackPhiOnEMCal = trk.fTrackPhiOnEMCal;
312 fTrackEtaOnEMCal = trk.fTrackEtaOnEMCal;
a29b2a8a 313 fTrackPtOnEMCal = trk.fTrackPtOnEMCal;
f7cc8591 314 fIsMuonGlobalTrack = trk.fIsMuonGlobalTrack; // AU
539a5a59 315 fTPCsignalTuned = trk.fTPCsignalTuned;
a2c30af1 316 fTOFsignalTuned = trk.fTOFsignalTuned;
f7cc8591 317 fMFTClusterPattern = trk.fMFTClusterPattern; // AU
318
df9db588 319 delete fCovMatrix;
5d62ce04 320 if(trk.fCovMatrix) fCovMatrix=new AliAODRedCov<6>(*trk.fCovMatrix);
df9db588 321 else fCovMatrix=NULL;
df9db588 322
05f9607e 323
324 fProdVertex = trk.fProdVertex;
1912763f 325 SetUsedForVtxFit(trk.GetUsedForVtxFit());
dc825b15 326 SetUsedForPrimVtxFit(trk.GetUsedForPrimVtxFit());
7be1db84 327
00a38d07 328 //detector raw signals
7be1db84 329 delete fDetPid;
330 if(trk.fDetPid) fDetPid=new AliAODPid(*trk.fDetPid);
331 else fDetPid=NULL;
05f9607e 332
00a38d07 333 //calibrated PID cache
334 delete fDetectorPID;
335 fDetectorPID=0x0;
336 if (trk.fDetectorPID) fDetectorPID = new AliDetectorPID(*trk.fDetectorPID);
a2c30af1 337 for (Int_t i = 0; i < 3; i++) {fTOFLabel[i] = trk.fTOFLabel[i];}
df9db588 338 }
339
340 return *this;
341}
342
343//______________________________________________________________________________
4697e4fb 344Double_t AliAODTrack::M(AODTrkPID_t pid) const
345{
346 // Returns the mass.
9861edc0 347 // Masses for nuclei don't exist in the PDG tables, therefore they were put by hand.
4697e4fb 348
349 switch (pid) {
350
351 case kElectron :
9861edc0 352 return 0.000510999; //TDatabasePDG::Instance()->GetParticle(11/*::kElectron*/)->Mass();
4697e4fb 353 break;
354
355 case kMuon :
9861edc0 356 return 0.1056584; //TDatabasePDG::Instance()->GetParticle(13/*::kMuonMinus*/)->Mass();
4697e4fb 357 break;
358
359 case kPion :
9861edc0 360 return 0.13957; //TDatabasePDG::Instance()->GetParticle(211/*::kPiPlus*/)->Mass();
4697e4fb 361 break;
362
363 case kKaon :
9861edc0 364 return 0.4937; //TDatabasePDG::Instance()->GetParticle(321/*::kKPlus*/)->Mass();
4697e4fb 365 break;
366
367 case kProton :
9861edc0 368 return 0.9382720; //TDatabasePDG::Instance()->GetParticle(2212/*::kProton*/)->Mass();
4697e4fb 369 break;
370
371 case kDeuteron :
9861edc0 372 return 1.8756; //TDatabasePDG::Instance()->GetParticle(1000010020)->Mass();
4697e4fb 373 break;
374
375 case kTriton :
9861edc0 376 return 2.8089; //TDatabasePDG::Instance()->GetParticle(1000010030)->Mass();
4697e4fb 377 break;
378
379 case kHelium3 :
9861edc0 380 return 2.8084; //TDatabasePDG::Instance()->GetParticle(1000020030)->Mass();
4697e4fb 381 break;
382
383 case kAlpha :
9861edc0 384 return 3.7274; //TDatabasePDG::Instance()->GetParticle(1000020040)->Mass();
4697e4fb 385 break;
386
387 case kUnknown :
388 return -999.;
389 break;
390
391 default :
392 return -999.;
393 }
394}
395
396//______________________________________________________________________________
397Double_t AliAODTrack::E(AODTrkPID_t pid) const
398{
399 // Returns the energy of the particle of a given pid.
400
401 if (pid != kUnknown) { // particle was identified
402 Double_t m = M(pid);
403 return TMath::Sqrt(P()*P() + m*m);
404 } else { // pid unknown
405 return -999.;
406 }
407}
408
409//______________________________________________________________________________
410Double_t AliAODTrack::Y(AODTrkPID_t pid) const
411{
9861edc0 412 // Returns the rapidity of a particle of a given pid.
4697e4fb 413
414 if (pid != kUnknown) { // particle was identified
415 Double_t e = E(pid);
416 Double_t pz = Pz();
417 if (e>=0 && e!=pz) { // energy was positive (e.g. not -999.) and not equal to pz
418 return 0.5*TMath::Log((e+pz)/(e-pz));
419 } else { // energy not known or equal to pz
420 return -999.;
421 }
422 } else { // pid unknown
423 return -999.;
424 }
425}
426
427//______________________________________________________________________________
428Double_t AliAODTrack::Y(Double_t m) const
429{
9861edc0 430 // Returns the rapidity of a particle of a given mass.
4697e4fb 431
432 if (m >= 0.) { // mass makes sense
433 Double_t e = E(m);
434 Double_t pz = Pz();
435 if (e>=0 && e!=pz) { // energy was positive (e.g. not -999.) and not equal to pz
436 return 0.5*TMath::Log((e+pz)/(e-pz));
437 } else { // energy not known or equal to pz
438 return -999.;
439 }
440 } else { // pid unknown
441 return -999.;
442 }
443}
444
a2c30af1 445void AliAODTrack::SetTOFLabel(const Int_t *p) {
446 // Sets (in TOF)
447 for (Int_t i = 0; i < 3; i++) fTOFLabel[i]=p[i];
448}
449
450//_______________________________________________________________________
451void AliAODTrack::GetTOFLabel(Int_t *p) const {
452 // Gets (in TOF)
453 for (Int_t i=0; i<3; i++) p[i]=fTOFLabel[i];
454}
455
4697e4fb 456//______________________________________________________________________________
457AliAODTrack::AODTrkPID_t AliAODTrack::GetMostProbablePID() const
458{
459 // Returns the most probable PID array element.
460
461 Int_t nPID = 10;
7ba6f91a 462 AODTrkPID_t loc = kUnknown;
7ba6f91a 463 Bool_t allTheSame = kTRUE;
76b98553 464 if (fPID) {
465 Double_t max = 0.;
466 for (Int_t iPID = 0; iPID < nPID; iPID++) {
467 if (fPID[iPID] >= max) {
468 if (fPID[iPID] > max) {
469 allTheSame = kFALSE;
470 max = fPID[iPID];
471 loc = (AODTrkPID_t)iPID;
472 } else {
473 allTheSame = kTRUE;
474 }
4697e4fb 475 }
476 }
4697e4fb 477 }
76b98553 478 return allTheSame ? AODTrkPID_t(GetPIDForTracking()) : loc;
4697e4fb 479}
480
481//______________________________________________________________________________
482void AliAODTrack::ConvertAliPIDtoAODPID()
483{
484 // Converts AliPID array.
485 // The numbering scheme is the same for electrons, muons, pions, kaons, and protons.
486 // Everything else has to be set to zero.
76b98553 487 if (fPID) {
488 fPID[kDeuteron] = 0.;
489 fPID[kTriton] = 0.;
490 fPID[kHelium3] = 0.;
491 fPID[kAlpha] = 0.;
492 fPID[kUnknown] = 0.;
493 }
4697e4fb 494 return;
495}
496
497
498//______________________________________________________________________________
cdd730d0 499template <typename T> void AliAODTrack::SetP(const T *p, const Bool_t cartesian)
df9db588 500{
8a1418dc 501 // Set the momentum
df9db588 502
503 if (p) {
504 if (cartesian) {
16b65f2a 505 Double_t pt2 = p[0]*p[0] + p[1]*p[1];
0c5f89fb 506 Double_t pp = TMath::Sqrt(pt2 + p[2]*p[2]);
df9db588 507
16b65f2a 508 fMomentum[0] = TMath::Sqrt(pt2); // pt
b1a9edc8 509 fMomentum[1] = (pt2 != 0.) ? TMath::Pi()+TMath::ATan2(-p[1], -p[0]) : -999; // phi
0c5f89fb 510 fMomentum[2] = (pp != 0.) ? TMath::ACos(p[2] / pp) : -999.; // theta
df9db588 511 } else {
16b65f2a 512 fMomentum[0] = p[0]; // pt
df9db588 513 fMomentum[1] = p[1]; // phi
514 fMomentum[2] = p[2]; // theta
515 }
516 } else {
517 fMomentum[0] = -999.;
518 fMomentum[1] = -999.;
519 fMomentum[2] = -999.;
520 }
521}
522
6e78367a 523/*
df9db588 524//______________________________________________________________________________
cdd730d0 525template <typename T> void AliAODTrack::SetPosition(const T *x, const Bool_t dca)
df9db588 526{
527 // set the position
528
529 if (x) {
530 if (!dca) {
531 ResetBit(kIsDCA);
532
533 fPosition[0] = x[0];
534 fPosition[1] = x[1];
535 fPosition[2] = x[2];
536 } else {
537 SetBit(kIsDCA);
538 // don't know any better yet
539 fPosition[0] = -999.;
540 fPosition[1] = -999.;
541 fPosition[2] = -999.;
542 }
543 } else {
544 ResetBit(kIsDCA);
545
546 fPosition[0] = -999.;
547 fPosition[1] = -999.;
548 fPosition[2] = -999.;
549 }
550}
6e78367a 551*/
df9db588 552//______________________________________________________________________________
553void AliAODTrack::SetDCA(Double_t d, Double_t z)
554{
555 // set the dca
556 fPosition[0] = d;
557 fPosition[1] = z;
558 fPosition[2] = 0.;
559 SetBit(kIsDCA);
560}
561
562//______________________________________________________________________________
563void AliAODTrack::Print(Option_t* /* option */) const
564{
565 // prints information about AliAODTrack
566
567 printf("Object name: %s Track type: %s\n", GetName(), GetTitle());
568 printf(" px = %f\n", Px());
569 printf(" py = %f\n", Py());
570 printf(" pz = %f\n", Pz());
571 printf(" pt = %f\n", Pt());
572 printf(" 1/pt = %f\n", OneOverPt());
573 printf(" theta = %f\n", Theta());
574 printf(" phi = %f\n", Phi());
1912763f 575 printf(" chi2/NDF = %f\n", Chi2perNDF());
df9db588 576 printf(" charge = %d\n", Charge());
df9db588 577}
578
2200238e 579//______________________________________________________________________________
580void AliAODTrack::SetMatchTrigger(Int_t matchTrig)
581{
582 // Set the MUON trigger information
8ac4fa64 583 switch(matchTrig){
e1c744ca 584 case 0: // 0 track does not match trigger
585 fITSMuonClusterMap=fITSMuonClusterMap&0x3fffffff;
586 break;
587 case 1: // 1 track match but does not pass pt cut
588 fITSMuonClusterMap=(fITSMuonClusterMap&0x3fffffff)|0x40000000;
589 break;
590 case 2: // 2 track match Low pt cut
591 fITSMuonClusterMap=(fITSMuonClusterMap&0x3fffffff)|0x80000000;
592 break;
593 case 3: // 3 track match High pt cut
594 fITSMuonClusterMap=fITSMuonClusterMap|0xc0000000;
595 break;
596 default:
597 fITSMuonClusterMap=fITSMuonClusterMap&0x3fffffff;
8ac4fa64 598 AliWarning(Form("unknown case for matchTrig: %d\n",matchTrig));
e1c744ca 599 }
600}
601
2200238e 602//______________________________________________________________________________
603Bool_t AliAODTrack::HitsMuonChamber(Int_t MuonChamber, Int_t cathode) const
604{
605 // return kTRUE if the track fires the given tracking or trigger chamber.
606 // If the chamber is a trigger one:
607 // - if cathode = 0 or 1, the track matches the corresponding cathode
608 // - if cathode = -1, the track matches both cathodes
609
610 if (MuonChamber < 0) return kFALSE;
611
612 if (MuonChamber < 10) return TESTBIT(GetMUONClusterMap(), MuonChamber);
613
614 if (MuonChamber < 14) {
615
616 if (cathode < 0) return TESTBIT(GetHitsPatternInTrigCh(), 13-MuonChamber) &&
617 TESTBIT(GetHitsPatternInTrigCh(), 13-MuonChamber+4);
618
619 if (cathode < 2) return TESTBIT(GetHitsPatternInTrigCh(), 13-MuonChamber+(1-cathode)*4);
620
e1c744ca 621 }
2200238e 622
623 return kFALSE;
e1c744ca 624}
625
2200238e 626//______________________________________________________________________________
627Bool_t AliAODTrack::MatchTriggerDigits() const
628{
629 // return kTRUE if the track matches a digit on both planes of at least 2 trigger chambers
6c954176 630
2200238e 631 Int_t nMatchedChambers = 0;
632 for (Int_t ich=10; ich<14; ich++) if (HitsMuonChamber(ich)) nMatchedChambers++;
633
634 return (nMatchedChambers >= 2);
e1c744ca 635}
c683ddc2 636
6dc40b1c 637//______________________________________________________________________________
ad30e3df 638Int_t AliAODTrack::GetMuonTrigDevSign() const
639{
640 /// Return the sign of the MTR deviation
641
642 Int_t signInfo = (Int_t)((fMUONtrigHitsMapTrg>>30)&0x3);
643 // Dummy value for old AODs which do not have the info
644 if ( signInfo == 0 ) return -999;
645 return signInfo - 2;
646}
647
648//______________________________________________________________________________
6dc40b1c 649Bool_t AliAODTrack::PropagateToDCA(const AliVVertex *vtx,
650 Double_t b, Double_t maxd, Double_t dz[2], Double_t covar[3])
651{
652 // compute impact parameters to the vertex vtx and their covariance matrix
653 // b is the Bz, needed to propagate correctly the track to vertex
654 // only the track parameters are update after the propagation (pos and mom),
655 // not the covariance matrix. This is OK for propagation over short distance
656 // inside the beam pipe.
657 // return kFALSE is something went wrong
658
95764f96 659 // allowed only for tracks inside the beam pipe
660 Float_t xstart2 = fPosition[0]*fPosition[0]+fPosition[1]*fPosition[1];
661 if(xstart2 > 3.*3.) { // outside beampipe radius
6dc40b1c 662 AliError("This method can be used only for propagation inside the beam pipe");
663 return kFALSE;
664 }
665
95764f96 666 // convert to AliExternalTrackParam
667 AliExternalTrackParam etp; etp.CopyFromVTrack(this);
668
669 // propagate
6dc40b1c 670 if(!etp.PropagateToDCA(vtx,b,maxd,dz,covar)) return kFALSE;
671
672 // update track position and momentum
673 Double_t mom[3];
674 etp.GetPxPyPz(mom);
675 SetP(mom,kTRUE);
676 etp.GetXYZ(mom);
677 SetPosition(mom,kFALSE);
678
679
680 return kTRUE;
681}
682
c8fe2783 683//______________________________________________________________________________
684Bool_t AliAODTrack::GetPxPyPz(Double_t p[3]) const
685{
686 //---------------------------------------------------------------------
687 // This function returns the global track momentum components
688 //---------------------------------------------------------------------
689 p[0]=Px(); p[1]=Py(); p[2]=Pz();
690 return kTRUE;
691}
9006fe9c 692
25f906db 693
694//_______________________________________________________________________
695Float_t AliAODTrack::GetTPCClusterInfo(Int_t nNeighbours/*=3*/, Int_t type/*=0*/, Int_t row0, Int_t row1, Int_t bitType ) const
9006fe9c 696{
697 //
25f906db 698 // TPC cluster information
9006fe9c 699 // type 0: get fraction of found/findable clusters with neighbourhood definition
700 // 1: findable clusters with neighbourhood definition
701 // 2: found clusters
25f906db 702 // bitType:
703 // 0 - all cluster used
704 // 1 - clusters used for the kalman update
9006fe9c 705 // definition of findable clusters:
706 // a cluster is defined as findable if there is another cluster
707 // within +- nNeighbours pad rows. The idea is to overcome threshold
708 // effects with a very simple algorithm.
709 //
25f906db 710
9006fe9c 711
712 Int_t found=0;
713 Int_t findable=0;
714 Int_t last=-nNeighbours;
25f906db 715 const TBits & clusterMap = (bitType%2==0) ? fTPCClusterMap : fTPCFitMap;
9006fe9c 716
25f906db 717 Int_t upperBound=clusterMap.GetNbits();
718 if (upperBound>row1) upperBound=row1;
719 for (Int_t i=row0; i<upperBound; ++i){
9006fe9c 720 //look to current row
25f906db 721 if (clusterMap[i]) {
9006fe9c 722 last=i;
723 ++found;
724 ++findable;
725 continue;
726 }
727 //look to nNeighbours before
728 if ((i-last)<=nNeighbours) {
729 ++findable;
730 continue;
731 }
732 //look to nNeighbours after
733 for (Int_t j=i+1; j<i+1+nNeighbours; ++j){
25f906db 734 if (clusterMap[j]){
9006fe9c 735 ++findable;
736 break;
737 }
738 }
739 }
25f906db 740 if (type==2) return found;
9006fe9c 741 if (type==1) return findable;
742
743 if (type==0){
744 Float_t fraction=0;
25f906db 745 if (findable>0)
9006fe9c 746 fraction=(Float_t)found/(Float_t)findable;
25f906db 747 else
9006fe9c 748 fraction=0;
749 return fraction;
25f906db 750 }
9006fe9c 751 return 0; // undefined type - default value
752}
fd21ec8d 753
25f906db 754
fd21ec8d 755//______________________________________________________________________________
756Double_t AliAODTrack::GetTRDslice(Int_t plane, Int_t slice) const {
757 //
758 // return TRD Pid information
759 //
760 if (!fDetPid) return -1;
6736efd5 761 Double32_t *trdSlices=fDetPid->GetTRDslices();
fd21ec8d 762 if (!trdSlices) return -1;
763 if ((plane<0) || (plane>=kTRDnPlanes)) {
764 return -1.;
765 }
766
eb550f5c 767 Int_t ns=fDetPid->GetTRDnSlices();
fd21ec8d 768 if ((slice<-1) || (slice>=ns)) {
769 return -1.;
770 }
771
772 if(slice>=0) return trdSlices[plane*ns + slice];
773
774 // return average of the dEdx measurements
775 Double_t q=0.; Double32_t *s = &trdSlices[plane*ns];
776 for (Int_t i=0; i<ns; i++, s++) if((*s)>0.) q+=(*s);
777 return q/ns;
778}
779
780//______________________________________________________________________________
99e9d5ec 781UChar_t AliAODTrack::GetTRDntrackletsPID() const{
782 //
783 // return number of tracklets calculated from the slices
784 //
785 if(!fDetPid) return -1;
59a8e853 786 return fDetPid->GetTRDntrackletsPID();
787}
99e9d5ec 788
59a8e853 789//______________________________________________________________________________
790UChar_t AliAODTrack::GetTRDncls(Int_t layer) const {
791 //
792 // return number of TRD clusters
793 //
794 if(!fDetPid || layer > 5) return -1;
795 if(layer < 0) return fDetPid->GetTRDncls();
796 else return fDetPid->GetTRDncls(layer);
99e9d5ec 797}
798
799//______________________________________________________________________________
fd21ec8d 800Double_t AliAODTrack::GetTRDmomentum(Int_t plane, Double_t */*sp*/) const
801{
802 //Returns momentum estimation
803 // in TRD layer "plane".
804
805 if (!fDetPid) return -1;
c997f0f9 806 const Double_t *trdMomentum=fDetPid->GetTRDmomentum();
fd21ec8d 807
808 if (!trdMomentum) {
809 return -1.;
810 }
811 if ((plane<0) || (plane>=kTRDnPlanes)) {
812 return -1.;
813 }
814
815 return trdMomentum[plane];
816}
76e6ee6a 817
818//_______________________________________________________________________
1cecd6e3 819Int_t AliAODTrack::GetTOFBunchCrossing(Double_t b, Bool_t) const
76e6ee6a 820{
821 // Returns the number of bunch crossings after trigger (assuming 25ns spacing)
76e6ee6a 822 const double kSpacing = 25e3; // min interbanch spacing
823 const double kShift = 0;
3f2db92f 824 Int_t bcid = kTOFBCNA; // defualt one
a512bf97 825 if (!IsOn(kTOFout) || !IsOn(kESDpid)) return bcid; // no info
826 //
827 double tdif = GetTOFsignal();
828 if (IsOn(kTIME)) { // integrated time info is there
829 int pid = (int)GetMostProbablePID();
830 double ttimes[10];
fc9b31a7 831 GetIntegratedTimes(ttimes, pid>=AliPID::kSPECIES ? AliPID::kSPECIESC : AliPID::kSPECIES);
a512bf97 832 tdif -= ttimes[pid];
833 }
834 else { // assume integrated time info from TOF radius and momentum
835 const double kRTOF = 385.;
836 const double kCSpeed = 3.e-2; // cm/ps
837 double p = P();
838 if (p<0.001) p = 1.0;
839 double m = M();
840 double path = kRTOF; // mean TOF radius
841 if (TMath::Abs(b)>kAlmost0) { // account for curvature
842 double curv = Pt()/(b*kB2C);
843 if (curv>kAlmost0) {
844 double tgl = Pz()/Pt();
845 path = 2./curv*TMath::ASin(kRTOF*curv/2.)*TMath::Sqrt(1.+tgl*tgl);
846 }
847 }
848 tdif -= path/kCSpeed*TMath::Sqrt(1.+m*m/(p*p));
849 }
76e6ee6a 850 bcid = TMath::Nint((tdif - kShift)/kSpacing);
851 return bcid;
852}
086400fc 853
00a38d07 854void AliAODTrack::SetDetectorPID(const AliDetectorPID *pid)
855{
856 //
857 // Set the detector PID
858 //
859 if (fDetectorPID) delete fDetectorPID;
860 fDetectorPID=pid;
861
862}
863
086400fc 864//_____________________________________________________________________________
567624b5 865Double_t AliAODTrack::GetHMPIDsignal() const
866{
867 if(fAODEvent->GetHMPIDringForTrackID(fID)) return fAODEvent->GetHMPIDringForTrackID(fID)->GetHmpSignal();
868 else return -999.;
869}
870
871//_____________________________________________________________________________
872Double_t AliAODTrack::GetHMPIDoccupancy() const
873{
874 if(fAODEvent->GetHMPIDringForTrackID(fID)) return fAODEvent->GetHMPIDringForTrackID(fID)->GetHmpOccupancy();
875 else return -999.;
876}
877
878//_____________________________________________________________________________
879Int_t AliAODTrack::GetHMPIDcluIdx() const
880{
881 if(fAODEvent->GetHMPIDringForTrackID(fID)) return fAODEvent->GetHMPIDringForTrackID(fID)->GetHmpCluIdx();
882 else return -999;
883}
884
885//_____________________________________________________________________________
886void AliAODTrack::GetHMPIDtrk(Float_t &x, Float_t &y, Float_t &th, Float_t &ph) const
887{
888 x = -999; y = -999.; th = -999.; ph = -999.;
889
890 const AliAODHMPIDrings *ring=fAODEvent->GetHMPIDringForTrackID(fID);
891 if(ring){
892 x = ring->GetHmpTrackX();
893 y = ring->GetHmpTrackY();
894 th = ring->GetHmpTrackTheta();
895 ph = ring->GetHmpTrackPhi();
896 }
897}
898
899//_____________________________________________________________________________
900void AliAODTrack::GetHMPIDmip(Float_t &x,Float_t &y,Int_t &q, Int_t &nph) const
901{
902 x = -999; y = -999.; q = -999; nph = -999;
903
904 const AliAODHMPIDrings *ring=fAODEvent->GetHMPIDringForTrackID(fID);
905 if(ring){
906 x = ring->GetHmpMipX();
907 y = ring->GetHmpMipY();
908 q = (Int_t)ring->GetHmpMipCharge();
909 nph = (Int_t)ring->GetHmpNumOfPhotonClusters();
910 }
911}
912
913//_____________________________________________________________________________
914Bool_t AliAODTrack::GetOuterHmpPxPyPz(Double_t *p) const
915{
916 if(fAODEvent->GetHMPIDringForTrackID(fID)) {fAODEvent->GetHMPIDringForTrackID(fID)->GetHmpMom(p); return kTRUE;}
917
918 else return kFALSE;
919}
920//_____________________________________________________________________________
086400fc 921Bool_t AliAODTrack::GetXYZAt(Double_t x, Double_t b, Double_t *r) const
922{
923 //---------------------------------------------------------------------
924 // This function returns the global track position extrapolated to
925 // the radial position "x" (cm) in the magnetic field "b" (kG)
926 //---------------------------------------------------------------------
927
928 //conversion of track parameter representation is
929 //based on the implementation of AliExternalTrackParam::Set(...)
930 //maybe some of this code can be moved to AliVTrack to avoid code duplication
086400fc 931 Double_t alpha=0.0;
932 Double_t radPos2 = fPosition[0]*fPosition[0]+fPosition[1]*fPosition[1];
933 Double_t radMax = 45.; // approximately ITS outer radius
934 if (radPos2 < radMax*radMax) { // inside the ITS
37f42322 935 alpha = fMomentum[1]; //TMath::ATan2(fMomentum[1],fMomentum[0]); // fMom is pt,phi,theta!
086400fc 936 } else { // outside the ITS
937 Float_t phiPos = TMath::Pi()+TMath::ATan2(-fPosition[1], -fPosition[0]);
938 alpha =
939 TMath::DegToRad()*(20*((((Int_t)(phiPos*TMath::RadToDeg()))/20))+10);
940 }
941 //
086400fc 942 // Get the vertex of origin and the momentum
943 TVector3 ver(fPosition[0],fPosition[1],fPosition[2]);
37f42322 944 TVector3 mom(Px(),Py(),Pz());
086400fc 945 //
086400fc 946 // Rotate to the local coordinate system
947 ver.RotateZ(-alpha);
948 mom.RotateZ(-alpha);
949
950 Double_t param0 = ver.Y();
951 Double_t param1 = ver.Z();
952 Double_t param2 = TMath::Sin(mom.Phi());
953 Double_t param3 = mom.Pz()/mom.Pt();
954 Double_t param4 = TMath::Sign(1/mom.Pt(),(Double_t)fCharge);
955
956 //calculate the propagated coordinates
957 //this is based on AliExternalTrackParam::GetXYZAt(Double_t x, Double_t b, Double_t *r)
958 Double_t dx=x-ver.X();
959 if(TMath::Abs(dx)<=kAlmost0) return GetXYZ(r);
960
961 Double_t f1=param2;
962 Double_t f2=f1 + dx*param4*b*kB2C;
963
964 if (TMath::Abs(f1) >= kAlmost1) return kFALSE;
965 if (TMath::Abs(f2) >= kAlmost1) return kFALSE;
966
967 Double_t r1=TMath::Sqrt((1.-f1)*(1.+f1)), r2=TMath::Sqrt((1.-f2)*(1.+f2));
968 r[0] = x;
969 r[1] = param0 + dx*(f1+f2)/(r1+r2);
970 r[2] = param1 + dx*(r2 + f2*(f1+f2)/(r1+r2))*param3;//Thanks to Andrea & Peter
086400fc 971 return Local2GlobalPosition(r,alpha);
972}
973
c8253dd9 974//_____________________________________________________________________________
975Bool_t AliAODTrack::GetXYZatR(Double_t xr,Double_t bz, Double_t *xyz, Double_t* alpSect) const
976{
977 // This method has 3 modes of behaviour
978 // 1) xyz[3] array is provided but alpSect pointer is 0: calculate the position of track intersection
979 // with circle of radius xr and fill it in xyz array
980 // 2) alpSect pointer is provided: find alpha of the sector where the track reaches local coordinate xr
981 // Note that in this case xr is NOT the radius but the local coordinate.
982 // If the xyz array is provided, it will be filled by track lab coordinates at local X in this sector
983 // 3) Neither alpSect nor xyz pointers are provided: just check if the track reaches radius xr
984 //
985 //
986 Double_t alpha=0.0;
987 Double_t radPos2 = fPosition[0]*fPosition[0]+fPosition[1]*fPosition[1];
988 Double_t radMax = 45.; // approximately ITS outer radius
989 if (radPos2 < radMax*radMax) { // inside the ITS
990 alpha = fMomentum[1]; //TMath::ATan2(fMomentum[1],fMomentum[0]); // fMom is pt,phi,theta!
991 } else { // outside the ITS
992 Float_t phiPos = TMath::Pi()+TMath::ATan2(-fPosition[1], -fPosition[0]);
993 alpha =
994 TMath::DegToRad()*(20*((((Int_t)(phiPos*TMath::RadToDeg()))/20))+10);
995 }
996 //
997 // Get the vertex of origin and the momentum
998 TVector3 ver(fPosition[0],fPosition[1],fPosition[2]);
999 TVector3 mom(Px(),Py(),Pz());
1000 //
1001 // Rotate to the local coordinate system
1002 ver.RotateZ(-alpha);
1003 mom.RotateZ(-alpha);
1004 //
1005 Double_t fx = ver.X();
1006 Double_t fy = ver.Y();
1007 Double_t fz = ver.Z();
1008 Double_t sn = TMath::Sin(mom.Phi());
1009 Double_t tgl = mom.Pz()/mom.Pt();
1010 Double_t crv = TMath::Sign(1/mom.Pt(),(Double_t)fCharge)*bz*kB2C;
1011 //
1012 if ( (TMath::Abs(bz))<kAlmost0Field ) crv=0.;
1013 //
1014 // general circle parameterization:
1015 // x = (r0+tR)cos(phi0) - tR cos(t+phi0)
1016 // y = (r0+tR)sin(phi0) - tR sin(t+phi0)
1017 // where qb is the sign of the curvature, tR is the track's signed radius and r0
1018 // is the DCA of helix to origin
1019 //
1020 double tR = 1./crv; // track radius signed
1021 double cs = TMath::Sqrt((1-sn)*(1+sn));
1022 double x0 = fx - sn*tR; // helix center coordinates
1023 double y0 = fy + cs*tR;
1024 double phi0 = TMath::ATan2(y0,x0); // angle of PCA wrt to the origin
1025 if (tR<0) phi0 += TMath::Pi();
1026 if (phi0 > TMath::Pi()) phi0 -= 2.*TMath::Pi();
1027 else if (phi0 <-TMath::Pi()) phi0 += 2.*TMath::Pi();
1028 double cs0 = TMath::Cos(phi0);
1029 double sn0 = TMath::Sin(phi0);
1030 double r0 = x0*cs0 + y0*sn0 - tR; // DCA to origin
1031 double r2R = 1.+r0/tR;
1032 //
1033 //
1034 if (r2R<kAlmost0) return kFALSE; // helix is centered at the origin, no specific intersection with other concetric circle
1035 if (!xyz && !alpSect) return kTRUE;
1036 double xr2R = xr/tR;
1037 double r2Ri = 1./r2R;
1038 // the intersection cos(t) = [1 + (r0/tR+1)^2 - (r0/tR)^2]/[2(1+r0/tR)]
1039 double cosT = 0.5*(r2R + (1-xr2R*xr2R)*r2Ri);
1040 if ( TMath::Abs(cosT)>kAlmost1 ) {
1041 // printf("Does not reach : %f %f\n",r0,tR);
1042 return kFALSE; // track does not reach the radius xr
1043 }
1044 //
1045 double t = TMath::ACos(cosT);
1046 if (tR<0) t = -t;
1047 // intersection point
1048 double xyzi[3];
1049 xyzi[0] = x0 - tR*TMath::Cos(t+phi0);
1050 xyzi[1] = y0 - tR*TMath::Sin(t+phi0);
1051 if (xyz) { // if postition is requested, then z is needed:
1052 double t0 = TMath::ATan2(cs,-sn) - phi0;
1053 double z0 = fz - t0*tR*tgl;
1054 xyzi[2] = z0 + tR*t*tgl;
1055 }
1056 else xyzi[2] = 0;
1057 //
1058 Local2GlobalPosition(xyzi,alpha);
1059 //
1060 if (xyz) {
1061 xyz[0] = xyzi[0];
1062 xyz[1] = xyzi[1];
1063 xyz[2] = xyzi[2];
1064 }
1065 //
1066 if (alpSect) {
1067 double &alp = *alpSect;
1068 // determine the sector of crossing
1069 double phiPos = TMath::Pi()+TMath::ATan2(-xyzi[1],-xyzi[0]);
1070 int sect = ((Int_t)(phiPos*TMath::RadToDeg()))/20;
1071 alp = TMath::DegToRad()*(20*sect+10);
1072 double x2r,f1,f2,r1,r2,dx,dy2dx,yloc=0, ylocMax = xr*TMath::Tan(TMath::Pi()/18); // min max Y within sector at given X
1073 //
1074 while(1) {
1075 Double_t ca=TMath::Cos(alp-alpha), sa=TMath::Sin(alp-alpha);
1076 if ((cs*ca+sn*sa)<0) {
1077 AliDebug(1,Form("Rotation to target sector impossible: local cos(phi) would become %.2f",cs*ca+sn*sa));
1078 return kFALSE;
1079 }
1080 //
1081 f1 = sn*ca - cs*sa;
1082 if (TMath::Abs(f1) >= kAlmost1) {
1083 AliDebug(1,Form("Rotation to target sector impossible: local sin(phi) would become %.2f",f1));
1084 return kFALSE;
1085 }
1086 //
1087 double tmpX = fx*ca + fy*sa;
1088 double tmpY = -fx*sa + fy*ca;
1089 //
1090 // estimate Y at X=xr
1091 dx=xr-tmpX;
1092 x2r = crv*dx;
1093 f2=f1 + x2r;
1094 if (TMath::Abs(f2) >= kAlmost1) {
1095 AliDebug(1,Form("Propagation in target sector failed ! %.10e",f2));
1096 return kFALSE;
1097 }
1098 r1 = TMath::Sqrt((1.-f1)*(1.+f1));
1099 r2 = TMath::Sqrt((1.-f2)*(1.+f2));
1100 dy2dx = (f1+f2)/(r1+r2);
1101 yloc = tmpY + dx*dy2dx;
1102 if (yloc>ylocMax) {alp += 2*TMath::Pi()/18; sect++;}
1103 else if (yloc<-ylocMax) {alp -= 2*TMath::Pi()/18; sect--;}
1104 else break;
1105 if (alp >= TMath::Pi()) alp -= 2*TMath::Pi();
1106 else if (alp < -TMath::Pi()) alp += 2*TMath::Pi();
1107 // if (sect>=18) sect = 0;
1108 // if (sect<=0) sect = 17;
1109 }
1110 //
1111 // if alpha was requested, then recalculate the position at intersection in sector
1112 if (xyz) {
1113 xyz[0] = xr;
1114 xyz[1] = yloc;
1115 if (TMath::Abs(x2r)<0.05) xyz[2] = fz + dx*(r2 + f2*dy2dx)*tgl;
1116 else {
1117 // for small dx/R the linear apporximation of the arc by the segment is OK,
1118 // but at large dx/R the error is very large and leads to incorrect Z propagation
1119 // angle traversed delta = 2*asin(dist_start_end / R / 2), hence the arc is: R*deltaPhi
1120 // The dist_start_end is obtained from sqrt(dx^2+dy^2) = x/(r1+r2)*sqrt(2+f1*f2+r1*r2)
1121 // Similarly, the rotation angle in linear in dx only for dx<<R
1122 double chord = dx*TMath::Sqrt(1+dy2dx*dy2dx); // distance from old position to new one
1123 double rot = 2*TMath::ASin(0.5*chord*crv); // angular difference seen from the circle center
1124 xyz[2] = fz + rot/crv*tgl;
1125 }
1126 Local2GlobalPosition(xyz,alp);
1127 }
1128 }
1129 return kTRUE;
1130 //
1131}
086400fc 1132
74ca66e3 1133//_______________________________________________________
1134void AliAODTrack::GetITSdEdxSamples(Double_t s[4]) const
1135{
1136 // get ITS dedx samples
1137 if (!fDetPid) for (int i=4;i--;) s[i]=0;
1138 else for (int i=4;i--;) s[i] = fDetPid->GetITSdEdxSample(i);
1139}
76b98553 1140
1141//_____________________________________________
1142Double_t AliAODTrack::GetMassForTracking() const
1143{
10d99e43 1144 int pid = fPIDForTracking;
1145 if (pid<AliPID::kPion) pid = AliPID::kPion;
76b98553 1146 double m = AliPID::ParticleMass(fPIDForTracking);
1147 return (fPIDForTracking==AliPID::kHe3 || fPIDForTracking==AliPID::kAlpha) ? -m : m;
1148}
42fcc729 1149//_______________________________________________________
1150const AliTOFHeader* AliAODTrack::GetTOFHeader() const {
1151 return fAODEvent->GetTOFHeader();
1152}
f8356e9e 1153
a01415e2 1154//_______________________________________________________
1155Int_t AliAODTrack::GetNcls(Int_t idet) const
1156{
1157 // Get number of clusters by subdetector index
1158 //
1159 Int_t ncls = 0;
1160 switch(idet){
1161 case 0:
1162 ncls = GetITSNcls();
1163 break;
1164 case 1:
1165 ncls = (Int_t)GetTPCNcls();
1166 break;
1167 case 2:
1168 ncls = (Int_t)GetTRDncls();
1169 break;
1170 case 3:
1171 break;
1172 /*if (fTOFindex != -1)
1173 ncls = 1;*/
1174 break;
1175 case 4: //PHOS
1176 break;
1177 case 5: //HMPID
1178 break;
1179 if ((GetHMPIDcluIdx() >= 0) && (GetHMPIDcluIdx() < 7000000)) {
1180 if ((GetHMPIDcluIdx()%1000000 != 9999) && (GetHMPIDcluIdx()%1000000 != 99999)) {
1181 ncls = 1;
1182 }
1183 }
1184 break;
1185 default:
1186 break;
1187 }
1188 return ncls;
1189}
e72663d5 1190
f8356e9e 1191Int_t AliAODTrack::GetTrackParam ( AliExternalTrackParam & ) const {return 0;}
1192Int_t AliAODTrack::GetTrackParamRefitted ( AliExternalTrackParam & ) const {return 0;}
1193Int_t AliAODTrack::GetTrackParamIp ( AliExternalTrackParam & ) const {return 0;}
1194Int_t AliAODTrack::GetTrackParamTPCInner ( AliExternalTrackParam & ) const {return 0;}
1195Int_t AliAODTrack::GetTrackParamOp ( AliExternalTrackParam & ) const {return 0;}
1196Int_t AliAODTrack::GetTrackParamCp ( AliExternalTrackParam & ) const {return 0;}
1197Int_t AliAODTrack::GetTrackParamITSOut ( AliExternalTrackParam & ) const {return 0;}
1198