STEER/AOD/AliAODTrack.h

   1 #ifndef AliAODTrack_H
   2 #define AliAODTrack_H
   3 /* Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
   4  * See cxx source for full Copyright notice                               */
   5
   6 /* $Id$ */
   7
   8 //-------------------------------------------------------------------------
   9 //     AOD track implementation of AliVTrack
  10 //     Author: Markus Oldenburg, CERN
  11 //-------------------------------------------------------------------------
  12
  13 #include <TRef.h>
  14 #include <TBits.h>
  15
  16 #include "AliVTrack.h"
  17 #include "AliAODVertex.h"
  18 #include "AliAODRedCov.h"
  19 #include "AliAODPid.h"
  20
  21
  22 class AliVVertex;
  23 class AliDetectorPID;
  24 class AliTPCdEdxInfo;
  25 class AliAODEvent;
  26
  27 class AliAODTrack : public AliVTrack {
  28
  29  public:
  30
  31   enum AODTrk_t {kUndef = -1,
  32                  kPrimary,
  33                  kSecondary,
  34                  kOrphan};
  35
  36   enum AODTrkBits_t {
  37     kIsDCA=BIT(14),   // set if fPosition is the DCA and not the position of the first point
  38     kUsedForVtxFit=BIT(15), // set if this track was used to fit the vertex it is attached to
  39     kUsedForPrimVtxFit=BIT(16), // set if this track was used to fit the primary vertex
  40     kIsTPCConstrained=BIT(17), // set if this track is a SA TPC track constrained to the SPD vertex, needs to be skipped in any track loop to avoid double counting
  41     kIsHybridTPCCG=BIT(18), // set if this track can be used as a hybrid track i.e. Gbobal tracks with certain slecetion plus the TPC constrained tracks that did not pass the selection
  42     kIsGlobalConstrained=BIT(19), // set if this track is a global track constrained to the vertex, needs to be skipped in any track loop to avoid double counting
  43     kIsHybridGCG=BIT(20)// set if this track can be used as a hybrid track i.e. tracks with certain slecetion plus the global constraint tracks that did not pass the selection
  44   };
  45
  46
  47   enum AODTrkFilterBits_t {
  48     kTrkTPCOnly            = BIT(0), // Standard TPC only tracks
  49     kTrkITSsa              = BIT(1), // ITS standalone
  50     kTrkITSConstrained     = BIT(2), // Pixel OR necessary for the electrons
  51     kTrkElectronsPID       = BIT(3),    // PID for the electrons
  52     kTrkGlobalNoDCA        = BIT(4), // standard cuts with very loose DCA
  53     kTrkGlobal             = BIT(5),  // standard cuts with tight DCA cut
  54     kTrkGlobalSDD          = BIT(6), // standard cuts with tight DCA but with requiring the first SDD cluster instead of an SPD cluster tracks selected by this cut are exclusive to those selected by the previous cut
  55     kTrkTPCOnlyConstrained = BIT(7) // TPC only tracks: TPConly information constrained to SPD vertex in the filter below
  56   };
  57
  58
  59   enum AODTrkPID_t {
  60     kElectron     =  0,
  61     kMuon         =  1,
  62     kPion         =  2,
  63     kKaon         =  3,
  64     kProton       =  4,
  65     kDeuteron     =  5,
  66     kTriton       =  6,
  67     kHelium3      =  7,
  68     kAlpha        =  8,
  69     kUnknown      =  9,
  70     kMostProbable = -1
  71   };
  72
  73   AliAODTrack();
  74   AliAODTrack(Short_t id,
  75               Int_t label,
  76               Double_t p[3],
  77               Bool_t cartesian,
  78               Double_t x[3],
  79               Bool_t dca,
  80               Double_t covMatrix[21],
  81               Short_t q,
  82               UChar_t itsClusMap,
  83               Double_t pid[10],
  84               AliAODVertex *prodVertex,
  85               Bool_t usedForVtxFit,
  86               Bool_t usedForPrimVtxFit,
  87               AODTrk_t ttype=kUndef,
  88               UInt_t selectInfo=0,
  89               Float_t chi2perNDF = -999.);
  90
  91   AliAODTrack(Short_t id,
  92               Int_t label,
  93               Float_t p[3],
  94               Bool_t cartesian,
  95               Float_t x[3],
  96               Bool_t dca,
  97               Float_t covMatrix[21],
  98               Short_t q,
  99               UChar_t itsClusMap,
 100               Float_t pid[10],
 101               AliAODVertex *prodVertex,
 102               Bool_t usedForVtxFit,
 103               Bool_t usedForPrimVtxFit,
 104               AODTrk_t ttype=kUndef,
 105               UInt_t selectInfo=0,
 106               Float_t chi2perNDF = -999.);
 107
 108   virtual ~AliAODTrack();
 109   AliAODTrack(const AliAODTrack& trk);
 110   AliAODTrack& operator=(const AliAODTrack& trk);
 111
 112   // kinematics
 113   virtual Double_t OneOverPt() const { return (fMomentum[0] != 0.) ? 1./fMomentum[0] : -999.; }
 114   virtual Double_t Phi()       const { return fMomentum[1]; }
 115   virtual Double_t Theta()     const { return fMomentum[2]; }
 116
 117   virtual Double_t Px() const { return fMomentum[0] * TMath::Cos(fMomentum[1]); }
 118   virtual Double_t Py() const { return fMomentum[0] * TMath::Sin(fMomentum[1]); }
 119   virtual Double_t Pz() const { return fMomentum[0] / TMath::Tan(fMomentum[2]); }
 120   virtual Double_t Pt() const { return fMomentum[0]; }
 121   virtual Double_t P()  const { return TMath::Sqrt(Pt()*Pt()+Pz()*Pz()); }
 122   virtual Bool_t   PxPyPz(Double_t p[3]) const { p[0] = Px(); p[1] = Py(); p[2] = Pz(); return kTRUE; }
 123
 124   virtual Double_t Xv() const { return GetProdVertex() ? GetProdVertex()->GetX() : -999.; }
 125   virtual Double_t Yv() const { return GetProdVertex() ? GetProdVertex()->GetY() : -999.; }
 126   virtual Double_t Zv() const { return GetProdVertex() ? GetProdVertex()->GetZ() : -999.; }
 127   virtual Bool_t   XvYvZv(Double_t x[3]) const { x[0] = Xv(); x[1] = Yv(); x[2] = Zv(); return kTRUE; }
 128
 129   Double_t Chi2perNDF()  const { return fChi2perNDF; }
 130   UShort_t GetTPCNcls()  const {
 131     UShort_t cl = fTPCFitMap.CountBits();
 132     if(cl==0)cl = fTPCClusterMap.CountBits();// backward compatibility
 133     return cl;
 134   }
 135
 136   virtual Double_t M() const { return M(GetMostProbablePID()); }
 137   Double_t M(AODTrkPID_t pid) const;
 138   virtual Double_t E() const { return E(GetMostProbablePID()); }
 139   Double_t E(AODTrkPID_t pid) const;
 140   Double_t E(Double_t m) const { return TMath::Sqrt(P()*P() + m*m); }
 141   virtual Double_t Y() const { return Y(GetMostProbablePID()); }
 142   Double_t Y(AODTrkPID_t pid) const;
 143   Double_t Y(Double_t m) const;
 144
 145   virtual Double_t Eta() const { return -TMath::Log(TMath::Tan(0.5 * fMomentum[2])); }
 146
 147   virtual Short_t  Charge() const {return fCharge; }
 148
 149   virtual Bool_t   PropagateToDCA(const AliVVertex *vtx,
 150           Double_t b, Double_t maxd, Double_t dz[2], Double_t covar[3]);
 151
 152   // PID
 153   virtual const Double_t *PID() const { return fPID; }
 154   AODTrkPID_t GetMostProbablePID() const;
 155   void ConvertAliPIDtoAODPID();
 156   void SetDetPID(AliAODPid *aodpid) {fDetPid = aodpid;}
 157
 158   template <typename T> void GetPID(T *pid) const {
 159     for(Int_t i=0; i<10; ++i) pid[i]=fPID[i];}
 160
 161   template <typename T> void SetPID(const T *pid) {
 162     if(pid) for(Int_t i=0; i<10; ++i) fPID[i]=pid[i];
 163     else {  for(Int_t i=0; i<10; i++) fPID[i]=0.; fPID[AliAODTrack::kUnknown]=1.;}}
 164
 165   Bool_t IsOn(Int_t mask) const {return (fFlags&mask)>0;}
 166   ULong_t GetStatus() const { return GetFlags(); }
 167   ULong_t GetFlags() const { return fFlags; }
 168
 169   Int_t   GetID() const { return (Int_t)fID; }
 170   Int_t   GetLabel() const { return fLabel; }
 171   Char_t  GetType() const { return fType;}
 172   Bool_t  IsPrimaryCandidate() const;
 173   Bool_t  GetUsedForVtxFit() const { return TestBit(kUsedForVtxFit); }
 174   Bool_t  GetUsedForPrimVtxFit() const { return TestBit(kUsedForPrimVtxFit); }
 175
 176   Bool_t  IsHybridGlobalConstrainedGlobal() const { return TestBit(kIsHybridGCG); }
 177   Bool_t  IsHybridTPCConstrainedGlobal() const { return TestBit(kIsHybridTPCCG); }
 178   Bool_t  IsTPCOnly() const { return IsTPCConstrained(); } // obsolete bad naming
 179   Bool_t  IsTPCConstrained() const { return TestBit(kIsTPCConstrained); }
 180   Bool_t  IsGlobalConstrained() const { return TestBit(kIsGlobalConstrained); }
 181   //
 182   Int_t   GetTOFBunchCrossing(Double_t b=0, Bool_t tpcPIDonly=kFALSE) const;
 183   //
 184   template <typename T> void GetP(T *p) const {
 185     p[0]=fMomentum[0]; p[1]=fMomentum[1]; p[2]=fMomentum[2];}
 186
 187 //  template <typename T> void GetPxPyPz(T *p) const {
 188 //    p[0] = Px(); p[1] = Py(); p[2] = Pz();}
 189   Bool_t GetPxPyPz(Double_t *p) const;
 190
 191   template <typename T> Bool_t GetPosition(T *x) const {
 192     x[0]=fPosition[0]; x[1]=fPosition[1]; x[2]=fPosition[2];
 193     return TestBit(kIsDCA);}
 194
 195   template <typename T> void SetCovMatrix(const T *covMatrix) {
 196     if(!fCovMatrix) fCovMatrix=new AliAODRedCov<6>();
 197     fCovMatrix->SetCovMatrix(covMatrix);}
 198
 199   template <typename T> Bool_t GetCovMatrix(T *covMatrix) const {
 200     if(!fCovMatrix) return kFALSE;
 201     fCovMatrix->GetCovMatrix(covMatrix); return kTRUE;}
 202
 203   Bool_t GetXYZ(Double_t *p) const {
 204     return GetPosition(p); }
 205
 206   Bool_t GetXYZAt(Double_t x, Double_t b, Double_t *r) const;
 207
 208   Bool_t GetCovarianceXYZPxPyPz(Double_t cv[21]) const {
 209     return GetCovMatrix(cv);}
 210
 211   void RemoveCovMatrix() {delete fCovMatrix; fCovMatrix=NULL;}
 212
 213   Double_t XAtDCA() const { return fPositionAtDCA[0]; }
 214   Double_t YAtDCA() const { return fPositionAtDCA[1]; }
 215   Double_t ZAtDCA() const {
 216     if (IsMuonTrack()) return fPosition[2];
 217     else if (TestBit(kIsDCA)) return fPosition[1];
 218     else return -999.; }
 219   Bool_t   XYZAtDCA(Double_t x[3]) const { x[0] = XAtDCA(); x[1] = YAtDCA(); x[2] = ZAtDCA(); return kTRUE; }
 220
 221   Double_t DCA() const {
 222     if (IsMuonTrack()) return TMath::Sqrt(XAtDCA()*XAtDCA() + YAtDCA()*YAtDCA());
 223     else if (TestBit(kIsDCA)) return fPosition[0];
 224     else return -999.; }
 225
 226   Double_t PxAtDCA() const { return fMomentumAtDCA[0]; }
 227   Double_t PyAtDCA() const { return fMomentumAtDCA[1]; }
 228   Double_t PzAtDCA() const { return fMomentumAtDCA[2]; }
 229   Double_t PAtDCA() const { return TMath::Sqrt(PxAtDCA()*PxAtDCA() + PyAtDCA()*PyAtDCA() + PzAtDCA()*PzAtDCA()); }
 230   Bool_t   PxPyPzAtDCA(Double_t p[3]) const { p[0] = PxAtDCA(); p[1] = PyAtDCA(); p[2] = PzAtDCA(); return kTRUE; }
 231
 232   Double_t GetRAtAbsorberEnd() const { return fRAtAbsorberEnd; }
 233
 234   UChar_t  GetITSClusterMap() const       { return (UChar_t)(fITSMuonClusterMap&0xff); }
 235   Int_t    GetITSNcls() const;
 236   Bool_t   HasPointOnITSLayer(Int_t i) const { return TESTBIT(GetITSClusterMap(),i); }
 237   UShort_t GetHitsPatternInTrigCh() const { return (UShort_t)((fITSMuonClusterMap&0xff00)>>8); }
 238   UInt_t   GetMUONClusterMap() const      { return (fITSMuonClusterMap&0x3ff0000)>>16; }
 239   UInt_t   GetITSMUONClusterMap() const   { return fITSMuonClusterMap; }
 240
 241   Bool_t  TestFilterBit(UInt_t filterBit) const {return (Bool_t) ((filterBit & fFilterMap) != 0);}
 242   Bool_t  TestFilterMask(UInt_t filterMask) const {return (Bool_t) ((filterMask & fFilterMap) == filterMask);}
 243   void    SetFilterMap(UInt_t i){fFilterMap = i;}
 244   UInt_t  GetFilterMap() const {return fFilterMap;}
 245
 246   const TBits& GetTPCClusterMap() const {return fTPCClusterMap;}
 247   const TBits* GetTPCClusterMapPtr() const {return &fTPCClusterMap;}
 248   const TBits& GetTPCFitMap() const {return fTPCFitMap;}
 249   const TBits* GetTPCFitMapPtr() const {return &fTPCFitMap;}
 250   Float_t GetTPCClusterInfo(Int_t nNeighbours=3, Int_t type=0, Int_t row0=0, Int_t row1=159, Int_t /*type*/=0) const;
 251
 252   const TBits& GetTPCSharedMap() const {return fTPCSharedMap;}
 253   const TBits* GetTPCSharedMapPtr() const {return &fTPCSharedMap;}
 254   void    SetTPCClusterMap(const TBits amap) {fTPCClusterMap = amap;}
 255   void    SetTPCSharedMap(const TBits amap) {fTPCSharedMap = amap;}
 256   void    SetTPCFitMap(const TBits amap) {fTPCFitMap = amap;}
 257   void    SetTPCPointsF(UShort_t  findable){fTPCnclsF = findable;}
 258   void    SetTPCNCrossedRows(UInt_t n)     {fTPCNCrossedRows = n;}
 259
 260   UShort_t GetTPCNclsF() const { return fTPCnclsF;}
 261   UShort_t GetTPCNCrossedRows()  const { return fTPCNCrossedRows;}
 262   Float_t  GetTPCFoundFraction() const { return fTPCNCrossedRows>0 ? float(GetTPCNcls())/fTPCNCrossedRows : 0;}
 263
 264   // Calorimeter Cluster
 265   Int_t GetEMCALcluster() const {return fCaloIndex;}
 266   void SetEMCALcluster(Int_t index) {fCaloIndex=index;}
 267   Bool_t IsEMCAL() const {return fFlags&kEMCALmatch;}
 268
 269   Double_t GetTrackPhiOnEMCal() const {return fTrackPhiOnEMCal;}
 270   Double_t GetTrackEtaOnEMCal() const {return fTrackEtaOnEMCal;}
 271   void SetTrackPhiEtaOnEMCal(Double_t phi,Double_t eta) {fTrackPhiOnEMCal=phi;fTrackEtaOnEMCal=eta;}
 272
 273   Int_t GetPHOScluster() const {return fCaloIndex;}
 274   void SetPHOScluster(Int_t index) {fCaloIndex=index;}
 275   Bool_t IsPHOS() const {return fFlags&kPHOSmatch;}
 276
 277   //pid signal interface
 278   Double_t  GetITSsignal()       const { return fDetPid?fDetPid->GetITSsignal():0.;    }
 279   void      GetITSdEdxSamples(Double_t s[4]) const;
 280   Double_t  GetTPCsignal()       const { return fDetPid?fDetPid->GetTPCsignal():0.;    }
 281   Double_t  GetTPCsignalTunedOnData() const { return fTPCsignalTuned;}
 282   void      SetTPCsignalTunedOnData(Double_t signal) {fTPCsignalTuned = signal;}
 283   UShort_t  GetTPCsignalN()      const { return fDetPid?fDetPid->GetTPCsignalN():0;    }
 284   virtual AliTPCdEdxInfo* GetTPCdEdxInfo() const {return fDetPid?fDetPid->GetTPCdEdxInfo():0;}
 285   Double_t  GetTPCmomentum()     const { return fDetPid?fDetPid->GetTPCmomentum():0.;  }
 286   Double_t  GetTOFsignal()       const { return fDetPid?fDetPid->GetTOFsignal():0.;    }
 287   Double_t  GetHMPIDsignal()     const;
 288   Double_t  GetHMPIDoccupancy()  const;
 289
 290   Int_t     GetHMPIDcluIdx()     const;
 291
 292   void GetHMPIDtrk(Float_t &x, Float_t &y, Float_t &th, Float_t &ph) const;
 293   void GetHMPIDmip(Float_t &x,Float_t &y,Int_t &q,Int_t &nph) const;
 294
 295   Bool_t GetOuterHmpPxPyPz(Double_t *p) const;
 296
 297   void      GetIntegratedTimes(Double_t *times) const {if (fDetPid) fDetPid->GetIntegratedTimes(times); }
 298   Double_t  GetTRDslice(Int_t plane, Int_t slice) const;
 299   Double_t  GetTRDsignal()                        const {return fDetPid ? fDetPid->GetTRDsignal() : 0;}
 300   Double_t  GetTRDmomentum(Int_t plane, Double_t */*sp*/=0x0) const;
 301   Double_t  GetTRDchi2()                 const {return fDetPid ? fDetPid->GetTRDChi2() : -1;}
 302   UChar_t   GetTRDncls(Int_t layer)      const;
 303   UChar_t   GetTRDncls()                 const {return GetTRDncls(-1);}
 304   UChar_t   GetTRDntrackletsPID() const;
 305   Int_t     GetNumberOfTRDslices() const { return fDetPid?fDetPid->GetTRDnSlices():0; }
 306   void      GetHMPIDpid(Double_t */*p*/) const { return; } // TODO: To be implemented properly with the new HMPID object
 307
 308   const AliAODEvent* GetAODEvent() const {return fAODEvent;}
 309   void SetAODEvent(const AliAODEvent* ptr){fAODEvent = ptr;}
 310
 311   AliAODPid    *GetDetPid() const { return fDetPid; }
 312   AliAODVertex *GetProdVertex() const { return (AliAODVertex*)fProdVertex.GetObject(); }
 313
 314   // print
 315   void  Print(const Option_t *opt = "") const;
 316
 317   // setters
 318   void SetFlags(ULong_t flags) { fFlags = flags; }
 319   void SetStatus(ULong_t flags) { fFlags|=flags; }
 320   void ResetStatus(ULong_t flags) { fFlags&=~flags; }
 321
 322   void SetID(Short_t id) { fID = id; }
 323   void SetLabel(Int_t label) { fLabel = label; }
 324
 325   template <typename T> void SetPosition(const T *x, Bool_t isDCA = kFALSE);
 326   void SetDCA(Double_t d, Double_t z);
 327   void SetUsedForVtxFit(Bool_t used = kTRUE) { used ? SetBit(kUsedForVtxFit) : ResetBit(kUsedForVtxFit); }
 328   void SetUsedForPrimVtxFit(Bool_t used = kTRUE) { used ? SetBit(kUsedForPrimVtxFit) : ResetBit(kUsedForPrimVtxFit); }
 329
 330   void SetIsTPCOnly(Bool_t b = kTRUE) { SetIsTPCConstrained(b); }// obsolete bad naming
 331
 332   void SetIsTPCConstrained(Bool_t b = kTRUE) { b ? SetBit(kIsTPCConstrained) : ResetBit(kIsTPCConstrained); }
 333   void SetIsHybridTPCConstrainedGlobal(Bool_t hybrid = kTRUE) { hybrid ? SetBit(kIsHybridTPCCG) : ResetBit(kIsHybridTPCCG); }
 334
 335   void SetIsGlobalConstrained(Bool_t b = kTRUE) { b ? SetBit(kIsGlobalConstrained) : ResetBit(kIsGlobalConstrained); }
 336   void SetIsHybridGlobalConstrainedGlobal(Bool_t hybrid = kTRUE) { hybrid ? SetBit(kIsHybridGCG) : ResetBit(kIsHybridGCG); }
 337
 338
 339
 340   void SetOneOverPt(Double_t oneOverPt) { fMomentum[0] = 1. / oneOverPt; }
 341   void SetPt(Double_t pt) { fMomentum[0] = pt; };
 342   void SetPhi(Double_t phi) { fMomentum[1] = phi; }
 343   void SetTheta(Double_t theta) { fMomentum[2] = theta; }
 344   template <typename T> void SetP(const T *p, Bool_t cartesian = kTRUE);
 345   void SetP() {fMomentum[0]=fMomentum[1]=fMomentum[2]=-999.;}
 346
 347   void SetXYAtDCA(Double_t x, Double_t y) {fPositionAtDCA[0] = x; fPositionAtDCA[1] = y;}
 348   void SetPxPyPzAtDCA(Double_t pX, Double_t pY, Double_t pZ) {fMomentumAtDCA[0] = pX; fMomentumAtDCA[1] = pY; fMomentumAtDCA[2] = pZ;}
 349
 350   void SetRAtAbsorberEnd(Double_t r) { fRAtAbsorberEnd = r; }
 351
 352   void SetCharge(Short_t q) { fCharge = q; }
 353   void SetChi2perNDF(Double_t chi2perNDF) { fChi2perNDF = chi2perNDF; }
 354
 355   void SetITSClusterMap(UChar_t itsClusMap)                 { fITSMuonClusterMap = (fITSMuonClusterMap&0xffffff00)|(((UInt_t)itsClusMap)&0xff); }
 356   void SetHitsPatternInTrigCh(UShort_t hitsPatternInTrigCh) { fITSMuonClusterMap = (fITSMuonClusterMap&0xffff00ff)|((((UInt_t)hitsPatternInTrigCh)&0xff)<<8); }
 357   void SetMuonClusterMap(UInt_t muonClusMap)                { fITSMuonClusterMap = (fITSMuonClusterMap&0xfc00ffff)|((muonClusMap&0x3ff)<<16); }
 358   void SetITSMuonClusterMap(UInt_t itsMuonClusMap)          { fITSMuonClusterMap = itsMuonClusMap; }
 359   void SetMUONtrigHitsMapTrg(UInt_t muonTrigHitsMap) { fMUONtrigHitsMapTrg = muonTrigHitsMap; }
 360   UInt_t GetMUONTrigHitsMapTrg() { return fMUONtrigHitsMapTrg; }
 361   void SetMUONtrigHitsMapTrk(UInt_t muonTrigHitsMap) { fMUONtrigHitsMapTrk = muonTrigHitsMap; }
 362   UInt_t GetMUONTrigHitsMapTrk() { return fMUONtrigHitsMapTrk; }
 363
 364   Int_t GetMatchTrigger() const {return fITSMuonClusterMap>>30;}
 365                                         //  0 Muon track does not match trigger
 366                                         //  1 Muon track match but does not pass pt cut
 367                                         //  2 Muon track match Low pt cut
 368                                         //  3 Muon track match High pt cut
 369   void     SetMatchTrigger(Int_t MatchTrigger);
 370   Bool_t   MatchTrigger() const { return (GetMatchTrigger()>0); }         //  Muon track matches trigger track
 371   Bool_t   MatchTriggerLowPt()   const  { return (GetMatchTrigger()>1); } //  Muon track matches trigger track and passes Low pt cut
 372   Bool_t   MatchTriggerHighPt()  const  { return (GetMatchTrigger()>2); } //  Muon track matches trigger track and passes High pt cut
 373   Bool_t   MatchTriggerDigits()  const;                                   //  Muon track matches trigger digits
 374   Double_t GetChi2MatchTrigger() const  { return fChi2MatchTrigger;}
 375   void     SetChi2MatchTrigger(Double_t Chi2MatchTrigger) {fChi2MatchTrigger = Chi2MatchTrigger; }
 376   Bool_t   HitsMuonChamber(Int_t MuonChamber, Int_t cathode = -1) const;  // Check if track hits Muon chambers
 377   Bool_t   IsMuonTrack() const { return (GetMUONClusterMap()>0) ? kTRUE : kFALSE; }
 378
 379   void     Connected(Bool_t flag) {flag ? SETBIT(fITSMuonClusterMap,26) : CLRBIT(fITSMuonClusterMap,26);}
 380   Bool_t   IsConnected() const {return TESTBIT(fITSMuonClusterMap,26);}
 381
 382   void     SetProdVertex(TObject *vertex) { fProdVertex = vertex; }
 383   void     SetType(AODTrk_t ttype) { fType=ttype; }
 384
 385   // Trasient PID object, is owned by the track
 386   virtual void  SetDetectorPID(const AliDetectorPID *pid);
 387   virtual const AliDetectorPID* GetDetectorPID() const { return fDetectorPID; }
 388
 389   // Dummy
 390   Int_t    PdgCode() const {return 0;}
 391
 392  private :
 393
 394   // Momentum & position
 395   Double32_t    fMomentum[3];       // momemtum stored in pt, phi, theta
 396   Double32_t    fPosition[3];       // position of first point on track or dca
 397
 398   Double32_t    fMomentumAtDCA[3];  // momentum (px,py,pz) at DCA
 399   Double32_t    fPositionAtDCA[2];  // trasverse position (x,y) at DCA
 400
 401   Double32_t    fRAtAbsorberEnd;    // transverse position r at the end of the muon absorber
 402
 403   Double32_t    fChi2perNDF;        // chi2/NDF of momentum fit
 404   Double32_t    fChi2MatchTrigger;  // chi2 of trigger/track matching
 405   Double32_t    fPID[10];           // [0.,1.,8] pointer to PID object
 406
 407   ULong_t       fFlags;             // reconstruction status flags
 408   Int_t         fLabel;             // track label, points back to MC track
 409
 410   UInt_t        fITSMuonClusterMap; // map of ITS and muon clusters, one bit per layer
 411                                     // (ITS: bit 1-8, muon trigger: bit 9-16, muon tracker: bit 17-26, muon match trigger: bit 31-32)
 412   UInt_t        fMUONtrigHitsMapTrg; // Muon trigger hits map from trigger
 413   UInt_t        fMUONtrigHitsMapTrk; // Muon trigger hits map from tracker track extrapolation
 414   UInt_t        fFilterMap;         // filter information, one bit per set of cuts
 415
 416   TBits         fTPCFitMap;      // Map of clusters, one bit per padrow; if has a cluster on given padrow which is used in the fit
 417   TBits         fTPCClusterMap;     // Map of clusters, one bit per padrow; 1 if has a cluster on given padrow
 418   TBits         fTPCSharedMap;      // Map of clusters, one bit per padrow; 1 if has a shared cluster on given padrow
 419
 420   UShort_t      fTPCnclsF;          // findable clusters
 421   UShort_t      fTPCNCrossedRows;   // n crossed rows
 422
 423   Short_t       fID;                // unique track ID, points back to the ESD track
 424
 425   Char_t        fCharge;            // particle charge
 426   Char_t        fType;              // Track Type
 427
 428   Int_t         fCaloIndex;         // index of associated EMCAL/PHOS cluster (AliAODCaloCluster)
 429
 430
 431   AliAODRedCov<6> *fCovMatrix;      // covariance matrix (x, y, z, px, py, pz)
 432   AliAODPid    *fDetPid;            // more detailed or detector specific raw pid information
 433   mutable const AliDetectorPID* fDetectorPID; //! transient object to cache calibrated PID information
 434   TRef          fProdVertex;        // vertex of origin
 435
 436   Double_t      fTrackPhiOnEMCal;   // phi of track after being propagated to 430cm
 437   Double_t      fTrackEtaOnEMCal;   // eta of track after being propagated to 430cm
 438
 439   Double_t      fTPCsignalTuned;    //! TPC signal tuned on data when using MC
 440
 441   const AliAODEvent* fAODEvent;     //!
 442
 443   ClassDef(AliAODTrack, 19);
 444 };
 445
 446 inline Bool_t  AliAODTrack::IsPrimaryCandidate() const
 447 {
 448     // True of track passes primary particle selection (independent of type)
 449     //
 450     if (fFilterMap) {
 451         return kTRUE;
 452     } else {
 453         return kFALSE;
 454     }
 455 }
 456
 457 inline Int_t AliAODTrack::GetITSNcls() const
 458 {
 459   // Number of points in ITS
 460   Int_t n=0;
 461   for(Int_t i=0;i<6;i++) if(HasPointOnITSLayer(i)) n++;
 462   return n;
 463 }
 464
 465 //______________________________________________________________________________
 466 template <typename T>
 467 void AliAODTrack::SetPosition(const T *x, const Bool_t dca)
 468 {
 469   // set the position
 470
 471   if (x) {
 472     if (!dca) {
 473       ResetBit(kIsDCA);
 474
 475       fPosition[0] = x[0];
 476       fPosition[1] = x[1];
 477       fPosition[2] = x[2];
 478     } else {
 479       SetBit(kIsDCA);
 480       // don't know any better yet
 481       fPosition[0] = -999.;
 482       fPosition[1] = -999.;
 483       fPosition[2] = -999.;
 484     }
 485   } else {
 486     ResetBit(kIsDCA);
 487
 488     fPosition[0] = -999.;
 489     fPosition[1] = -999.;
 490     fPosition[2] = -999.;
 491   }
 492 }
 493
 494 //template<> void AliAODTrack::SetPosition(const double *, Bool_t);
 495
 496 #endif