Fixed warnings
[u/mrichter/AliRoot.git] / STEER / AliAODTrack.cxx
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 //-------------------------------------------------------------------------
19 //     AOD track implementation of AliVTrack
20 //     Author: Markus Oldenburg, CERN
21 //     Markus.Oldenburg@cern.ch
22 //-------------------------------------------------------------------------
23
24 #include "AliLog.h"
25 #include "AliAODTrack.h"
26
27 ClassImp(AliAODTrack)
28
29 //______________________________________________________________________________
30 AliAODTrack::AliAODTrack() : 
31   AliVTrack(),
32   fChi2perNDF(-999.),
33   fChi2MatchTrigger(0.),
34   fFlags(0),
35   fLabel(-999),
36   fITSMuonClusterMap(0),
37   fFilterMap(0),
38   fTPCClusterMap(),
39   fTPCSharedMap(),
40   fID(-999),
41   fCharge(-99),
42   fType(kUndef),
43   fCovMatrix(NULL),
44   fDetPid(NULL),
45   fProdVertex(NULL)
46 {
47   // default constructor
48
49   SetP();
50   SetPosition((Float_t*)NULL);
51   SetXYAtDCA(-999., -999.);
52   SetPxPyPzAtDCA(-999., -999., -999.);
53   SetPID((Float_t*)NULL);
54 }
55
56 //______________________________________________________________________________
57 AliAODTrack::AliAODTrack(Short_t id,
58                          Int_t label, 
59                          Double_t p[3],
60                          Bool_t cartesian,
61                          Double_t x[3],
62                          Bool_t isDCA,
63                          Double_t covMatrix[21],
64                          Short_t charge,
65                          UChar_t itsClusMap,
66                          Double_t pid[10],
67                          AliAODVertex *prodVertex,
68                          Bool_t usedForVtxFit,
69                          Bool_t usedForPrimVtxFit,
70                          AODTrk_t ttype,
71                          UInt_t selectInfo,
72                          Float_t chi2perNDF) :
73   AliVTrack(),
74   fChi2perNDF(chi2perNDF),
75   fChi2MatchTrigger(0.),
76   fFlags(0),
77   fLabel(label),
78   fITSMuonClusterMap(0),
79   fFilterMap(selectInfo),
80   fTPCClusterMap(),
81   fTPCSharedMap(),
82   fID(id),
83   fCharge(charge),
84   fType(ttype),
85   fCovMatrix(NULL),
86   fDetPid(NULL),
87   fProdVertex(prodVertex)
88 {
89   // constructor
90  
91   SetP(p, cartesian);
92   SetPosition(x, isDCA);
93   SetXYAtDCA(-999., -999.);
94   SetPxPyPzAtDCA(-999., -999., -999.);
95   SetUsedForVtxFit(usedForVtxFit);
96   SetUsedForPrimVtxFit(usedForPrimVtxFit);
97   if(covMatrix) SetCovMatrix(covMatrix);
98   SetPID(pid);
99   SetITSClusterMap(itsClusMap);
100 }
101
102 //______________________________________________________________________________
103 AliAODTrack::AliAODTrack(Short_t id,
104                          Int_t label, 
105                          Float_t p[3],
106                          Bool_t cartesian,
107                          Float_t x[3],
108                          Bool_t isDCA,
109                          Float_t covMatrix[21],
110                          Short_t charge,
111                          UChar_t itsClusMap,
112                          Float_t pid[10],
113                          AliAODVertex *prodVertex,
114                          Bool_t usedForVtxFit,
115                          Bool_t usedForPrimVtxFit,
116                          AODTrk_t ttype,
117                          UInt_t selectInfo,
118                          Float_t chi2perNDF) :
119   AliVTrack(),
120   fChi2perNDF(chi2perNDF),
121   fChi2MatchTrigger(0.),
122   fFlags(0),
123   fLabel(label),
124   fITSMuonClusterMap(0),
125   fFilterMap(selectInfo),
126   fTPCClusterMap(),
127   fTPCSharedMap(),
128   fID(id),
129   fCharge(charge),
130   fType(ttype),
131   fCovMatrix(NULL),
132   fDetPid(NULL),
133   fProdVertex(prodVertex)
134 {
135   // constructor
136  
137   SetP(p, cartesian);
138   SetPosition(x, isDCA);
139   SetXYAtDCA(-999., -999.);
140   SetPxPyPzAtDCA(-999., -999., -999.);
141   SetUsedForVtxFit(usedForVtxFit);
142   SetUsedForPrimVtxFit(usedForPrimVtxFit);
143   if(covMatrix) SetCovMatrix(covMatrix);
144   SetPID(pid);
145   SetITSClusterMap(itsClusMap);
146 }
147
148 //______________________________________________________________________________
149 AliAODTrack::~AliAODTrack() 
150 {
151   // destructor
152   delete fCovMatrix;
153   delete fDetPid;
154 }
155
156
157 //______________________________________________________________________________
158 AliAODTrack::AliAODTrack(const AliAODTrack& trk) :
159   AliVTrack(trk),
160   fChi2perNDF(trk.fChi2perNDF),
161   fChi2MatchTrigger(trk.fChi2MatchTrigger),
162   fFlags(trk.fFlags),
163   fLabel(trk.fLabel),
164   fITSMuonClusterMap(trk.fITSMuonClusterMap),
165   fFilterMap(trk.fFilterMap),
166   fTPCClusterMap(trk.fTPCClusterMap),
167   fTPCSharedMap(trk.fTPCSharedMap),
168   fID(trk.fID),
169   fCharge(trk.fCharge),
170   fType(trk.fType),
171   fCovMatrix(NULL),
172   fDetPid(NULL),
173   fProdVertex(trk.fProdVertex)
174 {
175   // Copy constructor
176
177   trk.GetP(fMomentum);
178   trk.GetPosition(fPosition);
179   SetXYAtDCA(trk.XAtDCA(), trk.YAtDCA());
180   SetPxPyPzAtDCA(trk.PxAtDCA(), trk.PyAtDCA(), trk.PzAtDCA());
181   SetUsedForVtxFit(trk.GetUsedForVtxFit());
182   SetUsedForPrimVtxFit(trk.GetUsedForPrimVtxFit());
183   if(trk.fCovMatrix) fCovMatrix=new AliAODRedCov<6>(*trk.fCovMatrix);
184   if(trk.fDetPid) fDetPid=new AliAODPid(*trk.fDetPid);
185   SetPID(trk.fPID);
186 }
187
188 //______________________________________________________________________________
189 AliAODTrack& AliAODTrack::operator=(const AliAODTrack& trk)
190 {
191   // Assignment operator
192   if(this!=&trk) {
193
194     AliVTrack::operator=(trk);
195
196     trk.GetP(fMomentum);
197     trk.GetPosition(fPosition);
198     trk.GetPID(fPID);
199
200     SetXYAtDCA(trk.XAtDCA(), trk.YAtDCA());
201     SetPxPyPzAtDCA(trk.PxAtDCA(), trk.PyAtDCA(), trk.PzAtDCA());
202     
203     fChi2perNDF = trk.fChi2perNDF;
204     fChi2MatchTrigger = trk.fChi2MatchTrigger;
205
206     fFlags = trk.fFlags;
207     fLabel = trk.fLabel;    
208     
209     fITSMuonClusterMap = trk.fITSMuonClusterMap;
210     fFilterMap = trk.fFilterMap;
211
212     fID = trk.fID;
213
214     fCharge = trk.fCharge;
215     fType = trk.fType;
216
217     delete fCovMatrix;
218     if(trk.fCovMatrix) fCovMatrix=new AliAODRedCov<6>(*trk.fCovMatrix);
219     else fCovMatrix=NULL;
220     fProdVertex = trk.fProdVertex;
221
222     SetUsedForVtxFit(trk.GetUsedForVtxFit());
223     SetUsedForPrimVtxFit(trk.GetUsedForPrimVtxFit());
224
225     delete fDetPid;
226     if(trk.fDetPid) fDetPid=new AliAODPid(*trk.fDetPid);
227     else fDetPid=NULL;
228   }
229
230   return *this;
231 }
232
233 //______________________________________________________________________________
234 Double_t AliAODTrack::M(AODTrkPID_t pid) const
235 {
236   // Returns the mass.
237   // Masses for nuclei don't exist in the PDG tables, therefore they were put by hand.
238
239   switch (pid) {
240
241   case kElectron :
242     return 0.000510999; //TDatabasePDG::Instance()->GetParticle(11/*::kElectron*/)->Mass();
243     break;
244
245   case kMuon :
246     return 0.1056584; //TDatabasePDG::Instance()->GetParticle(13/*::kMuonMinus*/)->Mass();
247     break;
248
249   case kPion :
250     return 0.13957; //TDatabasePDG::Instance()->GetParticle(211/*::kPiPlus*/)->Mass();
251     break;
252
253   case kKaon :
254     return 0.4937; //TDatabasePDG::Instance()->GetParticle(321/*::kKPlus*/)->Mass();
255     break;
256
257   case kProton :
258     return 0.9382720; //TDatabasePDG::Instance()->GetParticle(2212/*::kProton*/)->Mass();
259     break;
260
261   case kDeuteron :
262     return 1.8756; //TDatabasePDG::Instance()->GetParticle(1000010020)->Mass();
263     break;
264
265   case kTriton :
266     return 2.8089; //TDatabasePDG::Instance()->GetParticle(1000010030)->Mass();
267     break;
268
269   case kHelium3 :
270     return 2.8084; //TDatabasePDG::Instance()->GetParticle(1000020030)->Mass();
271     break;
272
273   case kAlpha :
274     return 3.7274; //TDatabasePDG::Instance()->GetParticle(1000020040)->Mass();
275     break;
276
277   case kUnknown :
278     return -999.;
279     break;
280
281   default :
282     return -999.;
283   }
284 }
285
286 //______________________________________________________________________________
287 Double_t AliAODTrack::E(AODTrkPID_t pid) const
288 {
289   // Returns the energy of the particle of a given pid.
290   
291   if (pid != kUnknown) { // particle was identified
292     Double_t m = M(pid);
293     return TMath::Sqrt(P()*P() + m*m);
294   } else { // pid unknown
295     return -999.;
296   }
297 }
298
299 //______________________________________________________________________________
300 Double_t AliAODTrack::Y(AODTrkPID_t pid) const
301 {
302   // Returns the rapidity of a particle of a given pid.
303   
304   if (pid != kUnknown) { // particle was identified
305     Double_t e = E(pid);
306     Double_t pz = Pz();
307     if (e>=0 && e!=pz) { // energy was positive (e.g. not -999.) and not equal to pz
308       return 0.5*TMath::Log((e+pz)/(e-pz));
309     } else { // energy not known or equal to pz
310       return -999.;
311     }
312   } else { // pid unknown
313     return -999.;
314   }
315 }
316
317 //______________________________________________________________________________
318 Double_t AliAODTrack::Y(Double_t m) const
319 {
320   // Returns the rapidity of a particle of a given mass.
321   
322   if (m >= 0.) { // mass makes sense
323     Double_t e = E(m);
324     Double_t pz = Pz();
325     if (e>=0 && e!=pz) { // energy was positive (e.g. not -999.) and not equal to pz
326       return 0.5*TMath::Log((e+pz)/(e-pz));
327     } else { // energy not known or equal to pz
328       return -999.;
329     }
330   } else { // pid unknown
331     return -999.;
332   }
333 }
334
335 //______________________________________________________________________________
336 AliAODTrack::AODTrkPID_t AliAODTrack::GetMostProbablePID() const 
337 {
338   // Returns the most probable PID array element.
339   
340   Int_t nPID = 10;
341   if (fPID) {
342     AODTrkPID_t loc = kUnknown;
343     Double_t max = 0.;
344     Bool_t allTheSame = kTRUE;
345     
346     for (Int_t iPID = 0; iPID < nPID; iPID++) {
347       if (fPID[iPID] >= max) {
348         if (fPID[iPID] > max) {
349           allTheSame = kFALSE;
350           max = fPID[iPID];
351           loc = (AODTrkPID_t)iPID;
352         } else {
353           allTheSame = kTRUE;
354         }
355       }
356     }
357     
358     return allTheSame ? kUnknown : loc;
359   } else {
360     return kUnknown;
361   }
362 }
363
364 //______________________________________________________________________________
365 void AliAODTrack::ConvertAliPIDtoAODPID()
366 {
367   // Converts AliPID array.
368   // The numbering scheme is the same for electrons, muons, pions, kaons, and protons.
369   // Everything else has to be set to zero.
370
371   fPID[kDeuteron] = 0.;
372   fPID[kTriton]   = 0.;
373   fPID[kHelium3]  = 0.;
374   fPID[kAlpha]    = 0.;
375   fPID[kUnknown]  = 0.;
376   
377   return;
378 }
379
380
381 //______________________________________________________________________________
382 template <class T> void AliAODTrack::SetP(const T *p, const Bool_t cartesian) 
383 {
384   // Set the momentum
385
386   if (p) {
387     if (cartesian) {
388       Double_t pt2 = p[0]*p[0] + p[1]*p[1];
389       Double_t pp  = TMath::Sqrt(pt2 + p[2]*p[2]);
390       
391       fMomentum[0] = TMath::Sqrt(pt2); // pt
392       fMomentum[1] = (pt2 != 0.) ? TMath::Pi()+TMath::ATan2(-p[1], -p[0]) : -999; // phi
393       fMomentum[2] = (pp != 0.) ? TMath::ACos(p[2] / pp) : -999.; // theta
394     } else {
395       fMomentum[0] = p[0];  // pt
396       fMomentum[1] = p[1];  // phi
397       fMomentum[2] = p[2];  // theta
398     }
399   } else {
400     fMomentum[0] = -999.;
401     fMomentum[1] = -999.;
402     fMomentum[2] = -999.;
403   }
404 }
405
406 //______________________________________________________________________________
407 template <class T> void AliAODTrack::SetPosition(const T *x, const Bool_t dca) 
408 {
409   // set the position
410
411   if (x) {
412     if (!dca) {
413       ResetBit(kIsDCA);
414
415       fPosition[0] = x[0];
416       fPosition[1] = x[1];
417       fPosition[2] = x[2];
418     } else {
419       SetBit(kIsDCA);
420       // don't know any better yet
421       fPosition[0] = -999.;
422       fPosition[1] = -999.;
423       fPosition[2] = -999.;
424     }
425   } else {
426     ResetBit(kIsDCA);
427
428     fPosition[0] = -999.;
429     fPosition[1] = -999.;
430     fPosition[2] = -999.;
431   }
432 }
433
434 //______________________________________________________________________________
435 void AliAODTrack::SetDCA(Double_t d, Double_t z) 
436 {
437   // set the dca
438   fPosition[0] = d;
439   fPosition[1] = z;
440   fPosition[2] = 0.;
441   SetBit(kIsDCA);
442 }
443
444 //______________________________________________________________________________
445 void AliAODTrack::Print(Option_t* /* option */) const
446 {
447   // prints information about AliAODTrack
448
449   printf("Object name: %s   Track type: %s\n", GetName(), GetTitle()); 
450   printf("        px = %f\n", Px());
451   printf("        py = %f\n", Py());
452   printf("        pz = %f\n", Pz());
453   printf("        pt = %f\n", Pt());
454   printf("      1/pt = %f\n", OneOverPt());
455   printf("     theta = %f\n", Theta());
456   printf("       phi = %f\n", Phi());
457   printf("  chi2/NDF = %f\n", Chi2perNDF());
458   printf("    charge = %d\n", Charge());
459 }
460
461 //______________________________________________________________________________
462 void AliAODTrack::SetMatchTrigger(Int_t matchTrig)
463 {
464   // Set the MUON trigger information
465   switch(matchTrig){
466     case 0: // 0 track does not match trigger
467       fITSMuonClusterMap=fITSMuonClusterMap&0x3fffffff;
468       break;
469     case 1: // 1 track match but does not pass pt cut
470       fITSMuonClusterMap=(fITSMuonClusterMap&0x3fffffff)|0x40000000;
471       break;
472     case 2: // 2 track match Low pt cut
473       fITSMuonClusterMap=(fITSMuonClusterMap&0x3fffffff)|0x80000000;
474       break;
475     case 3: // 3 track match High pt cut
476       fITSMuonClusterMap=fITSMuonClusterMap|0xc0000000;
477       break;
478     default:
479       fITSMuonClusterMap=fITSMuonClusterMap&0x3fffffff;
480       AliWarning(Form("unknown case for matchTrig: %d\n",matchTrig));
481   }
482 }
483
484 //______________________________________________________________________________
485 Bool_t AliAODTrack::HitsMuonChamber(Int_t MuonChamber, Int_t cathode) const
486 {
487   // return kTRUE if the track fires the given tracking or trigger chamber.
488   // If the chamber is a trigger one:
489   // - if cathode = 0 or 1, the track matches the corresponding cathode
490   // - if cathode = -1, the track matches both cathodes
491   
492   if (MuonChamber < 0) return kFALSE;
493   
494   if (MuonChamber < 10) return TESTBIT(GetMUONClusterMap(), MuonChamber);
495   
496   if (MuonChamber < 14) {
497     
498     if (cathode < 0) return TESTBIT(GetHitsPatternInTrigCh(), 13-MuonChamber) &&
499                             TESTBIT(GetHitsPatternInTrigCh(), 13-MuonChamber+4);
500     
501     if (cathode < 2) return TESTBIT(GetHitsPatternInTrigCh(), 13-MuonChamber+(1-cathode)*4);
502     
503   }
504   
505   return kFALSE;
506 }
507
508 //______________________________________________________________________________
509 Bool_t AliAODTrack::MatchTriggerDigits() const
510 {
511   // return kTRUE if the track matches a digit on both planes of at least 2 trigger chambers
512   
513   Int_t nMatchedChambers = 0;
514   for (Int_t ich=10; ich<14; ich++) if (HitsMuonChamber(ich)) nMatchedChambers++;
515   
516   return (nMatchedChambers >= 2);
517 }
518