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
 131   UShort_t GetTPCnclsS(Int_t i0=0,Int_t i1=159)  const {
 132     UShort_t cl = fTPCSharedMap.CountBits(i0)-fTPCSharedMap.CountBits(i1);
 133     return cl;
 134   }
 135
 136   UShort_t GetTPCncls(Int_t i0=0,Int_t i1=159)  const {
 137     UShort_t cl = fTPCFitMap.CountBits(i0)-fTPCFitMap.CountBits(i1);
 138     if(cl==0)cl = fTPCClusterMap.CountBits(i0)-fTPCClusterMap.CountBits(i1);// backward compatibility
 139     return cl;
 140   }
 141
 142   UShort_t GetTPCNcls()  const { return GetTPCncls(); }
 143
 144   virtual Double_t M() const { return M(GetMostProbablePID()); }
 145   Double_t M(AODTrkPID_t pid) const;
 146   virtual Double_t E() const { return E(GetMostProbablePID()); }
 147   Double_t E(AODTrkPID_t pid) const;
 148   Double_t E(Double_t m) const { return TMath::Sqrt(P()*P() + m*m); }
 149   virtual Double_t Y() const { return Y(GetMostProbablePID()); }
 150   Double_t Y(AODTrkPID_t pid) const;
 151   Double_t Y(Double_t m) const;
 152
 153   virtual Double_t Eta() const { return -TMath::Log(TMath::Tan(0.5 * fMomentum[2])); }
 154
 155   virtual Short_t  Charge() const {return fCharge; }
 156
 157   virtual Bool_t   PropagateToDCA(const AliVVertex *vtx,
 158           Double_t b, Double_t maxd, Double_t dz[2], Double_t covar[3]);
 159
 160   // PID
 161   virtual const Double_t *PID() const { return fPID; }
 162   AODTrkPID_t GetMostProbablePID() const;
 163   void ConvertAliPIDtoAODPID();
 164   void SetDetPID(AliAODPid *aodpid) {fDetPid = aodpid;}
 165
 166   template <typename T> void GetPID(T *pid) const {
 167     for(Int_t i=0; i<10; ++i) pid[i]=fPID[i];}
 168
 169   template <typename T> void SetPID(const T *pid) {
 170     if(pid) for(Int_t i=0; i<10; ++i) fPID[i]=pid[i];
 171     else {  for(Int_t i=0; i<10; i++) fPID[i]=0.; fPID[AliAODTrack::kUnknown]=1.;}}
 172
 173   Bool_t IsOn(Int_t mask) const {return (fFlags&mask)>0;}
 174   ULong_t GetStatus() const { return GetFlags(); }
 175   ULong_t GetFlags() const { return fFlags; }
 176
 177   Int_t   GetID() const { return (Int_t)fID; }
 178   Int_t   GetLabel() const { return fLabel; }
 179   void    GetTOFLabel(Int_t *p) const;
 180
 181
 182   Char_t  GetType() const { return fType;}
 183   Bool_t  IsPrimaryCandidate() const;
 184   Bool_t  GetUsedForVtxFit() const { return TestBit(kUsedForVtxFit); }
 185   Bool_t  GetUsedForPrimVtxFit() const { return TestBit(kUsedForPrimVtxFit); }
 186
 187   Bool_t  IsHybridGlobalConstrainedGlobal() const { return TestBit(kIsHybridGCG); }
 188   Bool_t  IsHybridTPCConstrainedGlobal() const { return TestBit(kIsHybridTPCCG); }
 189   Bool_t  IsTPCOnly() const { return IsTPCConstrained(); } // obsolete bad naming
 190   Bool_t  IsTPCConstrained() const { return TestBit(kIsTPCConstrained); }
 191   Bool_t  IsGlobalConstrained() const { return TestBit(kIsGlobalConstrained); }
 192   //
 193   Int_t   GetTOFBunchCrossing(Double_t b=0, Bool_t tpcPIDonly=kFALSE) const;
 194   //
 195   template <typename T> void GetP(T *p) const {
 196     p[0]=fMomentum[0]; p[1]=fMomentum[1]; p[2]=fMomentum[2];}
 197
 198 //  template <typename T> void GetPxPyPz(T *p) const {
 199 //    p[0] = Px(); p[1] = Py(); p[2] = Pz();}
 200   Bool_t GetPxPyPz(Double_t *p) const;
 201
 202   template <typename T> Bool_t GetPosition(T *x) const {
 203     x[0]=fPosition[0]; x[1]=fPosition[1]; x[2]=fPosition[2];
 204     return TestBit(kIsDCA);}
 205
 206   template <typename T> void SetCovMatrix(const T *covMatrix) {
 207     if(!fCovMatrix) fCovMatrix=new AliAODRedCov<6>();
 208     fCovMatrix->SetCovMatrix(covMatrix);}
 209
 210   template <typename T> Bool_t GetCovMatrix(T *covMatrix) const {
 211     if(!fCovMatrix) return kFALSE;
 212     fCovMatrix->GetCovMatrix(covMatrix); return kTRUE;}
 213
 214   Bool_t GetXYZ(Double_t *p) const {
 215     return GetPosition(p); }
 216
 217   Bool_t GetXYZAt(Double_t x, Double_t b, Double_t *r) const;
 218
 219   Bool_t GetCovarianceXYZPxPyPz(Double_t cv[21]) const {
 220     return GetCovMatrix(cv);}
 221
 222   void RemoveCovMatrix() {delete fCovMatrix; fCovMatrix=NULL;}
 223
 224   Double_t XAtDCA() const { return fPositionAtDCA[0]; }
 225   Double_t YAtDCA() const { return fPositionAtDCA[1]; }
 226   Double_t ZAtDCA() const {
 227     if (IsMuonTrack()) return fPosition[2];
 228     else if (TestBit(kIsDCA)) return fPosition[1];
 229     else return -999.; }
 230   Bool_t   XYZAtDCA(Double_t x[3]) const { x[0] = XAtDCA(); x[1] = YAtDCA(); x[2] = ZAtDCA(); return kTRUE; }
 231
 232   Double_t DCA() const {
 233     if (IsMuonTrack()) return TMath::Sqrt(XAtDCA()*XAtDCA() + YAtDCA()*YAtDCA());
 234     else if (TestBit(kIsDCA)) return fPosition[0];
 235     else return -999.; }
 236
 237   Double_t PxAtDCA() const { return fMomentumAtDCA[0]; }
 238   Double_t PyAtDCA() const { return fMomentumAtDCA[1]; }
 239   Double_t PzAtDCA() const { return fMomentumAtDCA[2]; }
 240   Double_t PAtDCA() const { return TMath::Sqrt(PxAtDCA()*PxAtDCA() + PyAtDCA()*PyAtDCA() + PzAtDCA()*PzAtDCA()); }
 241   Bool_t   PxPyPzAtDCA(Double_t p[3]) const { p[0] = PxAtDCA(); p[1] = PyAtDCA(); p[2] = PzAtDCA(); return kTRUE; }
 242
 243   Double_t GetRAtAbsorberEnd() const { return fRAtAbsorberEnd; }
 244
 245   UChar_t  GetITSClusterMap() const       { return (UChar_t)(fITSMuonClusterMap&0xff); }
 246   Int_t    GetITSNcls() const;
 247   Bool_t   HasPointOnITSLayer(Int_t i) const { return TESTBIT(GetITSClusterMap(),i); }
 248   UShort_t GetHitsPatternInTrigCh() const { return (UShort_t)((fITSMuonClusterMap&0xff00)>>8); }
 249   UInt_t   GetMUONClusterMap() const      { return (fITSMuonClusterMap&0x3ff0000)>>16; }
 250   UInt_t   GetITSMUONClusterMap() const   { return fITSMuonClusterMap; }
 251
 252   Bool_t  TestFilterBit(UInt_t filterBit) const {return (Bool_t) ((filterBit & fFilterMap) != 0);}
 253   Bool_t  TestFilterMask(UInt_t filterMask) const {return (Bool_t) ((filterMask & fFilterMap) == filterMask);}
 254   void    SetFilterMap(UInt_t i){fFilterMap = i;}
 255   UInt_t  GetFilterMap() const {return fFilterMap;}
 256
 257   const TBits& GetTPCClusterMap() const {return fTPCClusterMap;}
 258   const TBits* GetTPCClusterMapPtr() const {return &fTPCClusterMap;}
 259   const TBits& GetTPCFitMap() const {return fTPCFitMap;}
 260   const TBits* GetTPCFitMapPtr() const {return &fTPCFitMap;}
 261   Float_t GetTPCClusterInfo(Int_t nNeighbours=3, Int_t type=0, Int_t row0=0, Int_t row1=159, Int_t /*type*/=0) const;
 262
 263   const TBits& GetTPCSharedMap() const {return fTPCSharedMap;}
 264   const TBits* GetTPCSharedMapPtr() const {return &fTPCSharedMap;}
 265   void    SetTPCClusterMap(const TBits amap) {fTPCClusterMap = amap;}
 266   void    SetTPCSharedMap(const TBits amap) {fTPCSharedMap = amap;}
 267   void    SetTPCFitMap(const TBits amap) {fTPCFitMap = amap;}
 268   void    SetTPCPointsF(UShort_t  findable){fTPCnclsF = findable;}
 269   void    SetTPCNCrossedRows(UInt_t n)     {fTPCNCrossedRows = n;}
 270
 271   UShort_t GetTPCNclsF() const { return fTPCnclsF;}
 272   UShort_t GetTPCNCrossedRows()  const { return fTPCNCrossedRows;}
 273   Float_t  GetTPCFoundFraction() const { return fTPCNCrossedRows>0 ? float(GetTPCNcls())/fTPCNCrossedRows : 0;}
 274
 275   // Calorimeter Cluster
 276   Int_t GetEMCALcluster() const {return fCaloIndex;}
 277   void SetEMCALcluster(Int_t index) {fCaloIndex=index;}
 278   Bool_t IsEMCAL() const {return fFlags&kEMCALmatch;}
 279
 280   Double_t GetTrackPhiOnEMCal() const {return fTrackPhiOnEMCal;}
 281   Double_t GetTrackEtaOnEMCal() const {return fTrackEtaOnEMCal;}
 282   Double_t GetTrackPtOnEMCal() const {return fTrackPtOnEMCal;}
 283   Double_t GetTrackPOnEMCal() const {return TMath::Abs(fTrackEtaOnEMCal) < 1 ? fTrackPtOnEMCal*TMath::CosH(fTrackEtaOnEMCal) : -999;}
 284   void SetTrackPhiEtaPtOnEMCal(Double_t phi,Double_t eta,Double_t pt) {fTrackPhiOnEMCal=phi;fTrackEtaOnEMCal=eta;fTrackPtOnEMCal=pt;}
 285
 286   Int_t GetPHOScluster() const {return fCaloIndex;}
 287   void SetPHOScluster(Int_t index) {fCaloIndex=index;}
 288   Bool_t IsPHOS() const {return fFlags&kPHOSmatch;}
 289
 290   //pid signal interface
 291   Double_t  GetITSsignal()       const { return fDetPid?fDetPid->GetITSsignal():0.;    }
 292   void      GetITSdEdxSamples(Double_t s[4]) const;
 293   Double_t  GetTPCsignal()       const { return fDetPid?fDetPid->GetTPCsignal():0.;    }
 294   Double_t  GetTPCsignalTunedOnData() const { return fTPCsignalTuned;}
 295   void      SetTPCsignalTunedOnData(Double_t signal) {fTPCsignalTuned = signal;}
 296   UShort_t  GetTPCsignalN()      const { return fDetPid?fDetPid->GetTPCsignalN():0;    }
 297   virtual AliTPCdEdxInfo* GetTPCdEdxInfo() const {return fDetPid?fDetPid->GetTPCdEdxInfo():0;}
 298   Double_t  GetTPCmomentum()     const { return fDetPid?fDetPid->GetTPCmomentum():0.;  }
 299   Double_t  GetTPCTgl()          const { return fDetPid?fDetPid->GetTPCTgl():0.;  }
 300   Double_t  GetTOFsignal()       const { return fDetPid?fDetPid->GetTOFsignal():0.;    }
 301   Double_t  GetIntegratedLength() const { return fTrackLength;}
 302   void      SetIntegratedLength(Double_t l) {fTrackLength = l;}
 303   Double_t  GetTOFsignalTunedOnData() const { return fTOFsignalTuned;}
 304   void      SetTOFsignalTunedOnData(Double_t signal) {fTOFsignalTuned = signal;}
 305   Double_t  GetHMPIDsignal()     const;
 306   Double_t  GetHMPIDoccupancy()  const;
 307
 308   Int_t     GetHMPIDcluIdx()     const;
 309
 310   void GetHMPIDtrk(Float_t &x, Float_t &y, Float_t &th, Float_t &ph) const;
 311   void GetHMPIDmip(Float_t &x,Float_t &y,Int_t &q,Int_t &nph) const;
 312
 313   Bool_t GetOuterHmpPxPyPz(Double_t *p) const;
 314
 315   void      GetIntegratedTimes(Double_t *times) const {if (fDetPid) fDetPid->GetIntegratedTimes(times); }
 316   Double_t  GetTRDslice(Int_t plane, Int_t slice) const;
 317   Double_t  GetTRDsignal()                        const {return fDetPid ? fDetPid->GetTRDsignal() : 0;}
 318   Double_t  GetTRDmomentum(Int_t plane, Double_t */*sp*/=0x0) const;
 319   Double_t  GetTRDchi2()                 const {return fDetPid ? fDetPid->GetTRDChi2() : -1;}
 320   UChar_t   GetTRDncls(Int_t layer)      const;
 321   UChar_t   GetTRDncls()                 const {return GetTRDncls(-1);}
 322   UChar_t   GetTRDntrackletsPID() const;
 323   Int_t     GetNumberOfTRDslices() const { return fDetPid?fDetPid->GetTRDnSlices():0; }
 324   void      GetHMPIDpid(Double_t */*p*/) const { return; } // TODO: To be implemented properly with the new HMPID object
 325
 326   const AliAODEvent* GetAODEvent() const {return fAODEvent;}
 327   void SetAODEvent(const AliAODEvent* ptr){fAODEvent = ptr;}
 328
 329   AliAODPid    *GetDetPid() const { return fDetPid; }
 330   AliAODVertex *GetProdVertex() const { return (AliAODVertex*)fProdVertex.GetObject(); }
 331
 332   // print
 333   void  Print(const Option_t *opt = "") const;
 334
 335   // setters
 336   void SetFlags(ULong_t flags) { fFlags = flags; }
 337   void SetStatus(ULong_t flags) { fFlags|=flags; }
 338   void ResetStatus(ULong_t flags) { fFlags&=~flags; }
 339
 340   void SetID(Short_t id) { fID = id; }
 341   void SetLabel(Int_t label) { fLabel = label; }
 342   void SetTOFLabel(const Int_t* p);
 343   template <typename T> void SetPosition(const T *x, Bool_t isDCA = kFALSE);
 344   void SetDCA(Double_t d, Double_t z);
 345   void SetUsedForVtxFit(Bool_t used = kTRUE) { used ? SetBit(kUsedForVtxFit) : ResetBit(kUsedForVtxFit); }
 346   void SetUsedForPrimVtxFit(Bool_t used = kTRUE) { used ? SetBit(kUsedForPrimVtxFit) : ResetBit(kUsedForPrimVtxFit); }
 347
 348   void SetIsTPCOnly(Bool_t b = kTRUE) { SetIsTPCConstrained(b); }// obsolete bad naming
 349
 350   void SetIsTPCConstrained(Bool_t b = kTRUE) { b ? SetBit(kIsTPCConstrained) : ResetBit(kIsTPCConstrained); }
 351   void SetIsHybridTPCConstrainedGlobal(Bool_t hybrid = kTRUE) { hybrid ? SetBit(kIsHybridTPCCG) : ResetBit(kIsHybridTPCCG); }
 352
 353   void SetIsGlobalConstrained(Bool_t b = kTRUE) { b ? SetBit(kIsGlobalConstrained) : ResetBit(kIsGlobalConstrained); }
 354   void SetIsHybridGlobalConstrainedGlobal(Bool_t hybrid = kTRUE) { hybrid ? SetBit(kIsHybridGCG) : ResetBit(kIsHybridGCG); }
 355
 356
 357
 358   void SetOneOverPt(Double_t oneOverPt) { fMomentum[0] = 1. / oneOverPt; }
 359   void SetPt(Double_t pt) { fMomentum[0] = pt; };
 360   void SetPhi(Double_t phi) { fMomentum[1] = phi; }
 361   void SetTheta(Double_t theta) { fMomentum[2] = theta; }
 362   template <typename T> void SetP(const T *p, Bool_t cartesian = kTRUE);
 363   void SetP() {fMomentum[0]=fMomentum[1]=fMomentum[2]=-999.;}
 364
 365   void SetXYAtDCA(Double_t x, Double_t y) {fPositionAtDCA[0] = x; fPositionAtDCA[1] = y;}
 366   void SetPxPyPzAtDCA(Double_t pX, Double_t pY, Double_t pZ) {fMomentumAtDCA[0] = pX; fMomentumAtDCA[1] = pY; fMomentumAtDCA[2] = pZ;}
 367
 368   void SetRAtAbsorberEnd(Double_t r) { fRAtAbsorberEnd = r; }
 369
 370   void SetCharge(Short_t q) { fCharge = q; }
 371   void SetChi2perNDF(Double_t chi2perNDF) { fChi2perNDF = chi2perNDF; }
 372
 373   void SetITSClusterMap(UChar_t itsClusMap)                 { fITSMuonClusterMap = (fITSMuonClusterMap&0xffffff00)|(((UInt_t)itsClusMap)&0xff); }
 374   void SetHitsPatternInTrigCh(UShort_t hitsPatternInTrigCh) { fITSMuonClusterMap = (fITSMuonClusterMap&0xffff00ff)|((((UInt_t)hitsPatternInTrigCh)&0xff)<<8); }
 375   void SetMuonClusterMap(UInt_t muonClusMap)                { fITSMuonClusterMap = (fITSMuonClusterMap&0xfc00ffff)|((muonClusMap&0x3ff)<<16); }
 376   void SetITSMuonClusterMap(UInt_t itsMuonClusMap)          { fITSMuonClusterMap = itsMuonClusMap; }
 377   void SetMUONtrigHitsMapTrg(UInt_t muonTrigHitsMap) { fMUONtrigHitsMapTrg = muonTrigHitsMap; }
 378   UInt_t GetMUONTrigHitsMapTrg() { return fMUONtrigHitsMapTrg; }
 379   void SetMUONtrigHitsMapTrk(UInt_t muonTrigHitsMap) { fMUONtrigHitsMapTrk = muonTrigHitsMap; }
 380   UInt_t GetMUONTrigHitsMapTrk() { return fMUONtrigHitsMapTrk; }
 381
 382   Int_t GetMatchTrigger() const {return fITSMuonClusterMap>>30;}
 383                                         //  0 Muon track does not match trigger
 384                                         //  1 Muon track match but does not pass pt cut
 385                                         //  2 Muon track match Low pt cut
 386                                         //  3 Muon track match High pt cut
 387   void     SetMatchTrigger(Int_t MatchTrigger);
 388   Bool_t   MatchTrigger() const { return (GetMatchTrigger()>0); }         //  Muon track matches trigger track
 389   Bool_t   MatchTriggerLowPt()   const  { return (GetMatchTrigger()>1); } //  Muon track matches trigger track and passes Low pt cut
 390   Bool_t   MatchTriggerHighPt()  const  { return (GetMatchTrigger()>2); } //  Muon track matches trigger track and passes High pt cut
 391   Bool_t   MatchTriggerDigits()  const;                                   //  Muon track matches trigger digits
 392   Double_t GetChi2MatchTrigger() const  { return fChi2MatchTrigger;}
 393   void     SetChi2MatchTrigger(Double_t Chi2MatchTrigger) {fChi2MatchTrigger = Chi2MatchTrigger; }
 394   Bool_t   HitsMuonChamber(Int_t MuonChamber, Int_t cathode = -1) const;  // Check if track hits Muon chambers
 395   Bool_t   IsMuonTrack() const { return (GetMUONClusterMap()>0) ? kTRUE : kFALSE; }
 396
 397   void     Connected(Bool_t flag) {flag ? SETBIT(fITSMuonClusterMap,26) : CLRBIT(fITSMuonClusterMap,26);}
 398   Bool_t   IsConnected() const {return TESTBIT(fITSMuonClusterMap,26);}
 399
 400   void     SetProdVertex(TObject *vertex) { fProdVertex = vertex; }
 401   void     SetType(AODTrk_t ttype) { fType=ttype; }
 402
 403   // Trasient PID object, is owned by the track
 404   virtual void  SetDetectorPID(const AliDetectorPID *pid);
 405   virtual const AliDetectorPID* GetDetectorPID() const { return fDetectorPID; }
 406
 407   // Dummy
 408   Int_t    PdgCode() const {return 0;}
 409
 410  private :
 411
 412   // Momentum & position
 413   Double32_t    fMomentum[3];       // momemtum stored in pt, phi, theta
 414   Double32_t    fPosition[3];       // position of first point on track or dca
 415
 416   Double32_t    fMomentumAtDCA[3];  // momentum (px,py,pz) at DCA
 417   Double32_t    fPositionAtDCA[2];  // trasverse position (x,y) at DCA
 418
 419   Double32_t    fRAtAbsorberEnd;    // transverse position r at the end of the muon absorber
 420
 421   Double32_t    fChi2perNDF;        // chi2/NDF of momentum fit
 422   Double32_t    fChi2MatchTrigger;  // chi2 of trigger/track matching
 423   Double32_t    fPID[10];           // [0.,1.,8] pointer to PID object
 424
 425   ULong_t       fFlags;             // reconstruction status flags
 426   Int_t         fLabel;             // track label, points back to MC track
 427   Int_t         fTOFLabel[3];       // TOF label
 428   Double32_t    fTrackLength;       // Track length
 429   UInt_t        fITSMuonClusterMap; // map of ITS and muon clusters, one bit per layer
 430                                     // (ITS: bit 1-8, muon trigger: bit 9-16, muon tracker: bit 17-26, muon match trigger: bit 31-32)
 431   UInt_t        fMUONtrigHitsMapTrg; // Muon trigger hits map from trigger
 432   UInt_t        fMUONtrigHitsMapTrk; // Muon trigger hits map from tracker track extrapolation
 433   UInt_t        fFilterMap;         // filter information, one bit per set of cuts
 434
 435   TBits         fTPCFitMap;      // Map of clusters, one bit per padrow; if has a cluster on given padrow which is used in the fit
 436   TBits         fTPCClusterMap;     // Map of clusters, one bit per padrow; 1 if has a cluster on given padrow
 437   TBits         fTPCSharedMap;      // Map of clusters, one bit per padrow; 1 if has a shared cluster on given padrow
 438
 439   UShort_t      fTPCnclsF;          // findable clusters
 440   UShort_t      fTPCNCrossedRows;   // n crossed rows
 441
 442   Short_t       fID;                // unique track ID, points back to the ESD track
 443
 444   Char_t        fCharge;            // particle charge
 445   Char_t        fType;              // Track Type
 446
 447   Int_t         fCaloIndex;         // index of associated EMCAL/PHOS cluster (AliAODCaloCluster)
 448
 449
 450   AliAODRedCov<6> *fCovMatrix;      // covariance matrix (x, y, z, px, py, pz)
 451   AliAODPid    *fDetPid;            // more detailed or detector specific raw pid information
 452   mutable const AliDetectorPID* fDetectorPID; //! transient object to cache calibrated PID information
 453   TRef          fProdVertex;        // vertex of origin
 454
 455   Double_t      fTrackPhiOnEMCal;   // phi of track after being propagated to the EMCal surface (default r = 440 cm)
 456   Double_t      fTrackEtaOnEMCal;   // eta of track after being propagated to the EMCal surface (default r = 440 cm)
 457   Double_t      fTrackPtOnEMCal;    // pt of track after being propagated to the EMCal surface (default r = 440 cm)
 458
 459   Double_t      fTPCsignalTuned;    //! TPC signal tuned on data when using MC
 460   Double_t      fTOFsignalTuned;    //! TOF signal tuned on data when using MC
 461
 462   const AliAODEvent* fAODEvent;     //!
 463
 464   ClassDef(AliAODTrack, 22);
 465 };
 466
 467 inline Bool_t  AliAODTrack::IsPrimaryCandidate() const
 468 {
 469     // True of track passes primary particle selection (independent of type)
 470     //
 471     if (fFilterMap) {
 472         return kTRUE;
 473     } else {
 474         return kFALSE;
 475     }
 476 }
 477
 478 inline Int_t AliAODTrack::GetITSNcls() const
 479 {
 480   // Number of points in ITS
 481   Int_t n=0;
 482   for(Int_t i=0;i<6;i++) if(HasPointOnITSLayer(i)) n++;
 483   return n;
 484 }
 485
 486 //______________________________________________________________________________
 487 template <typename T>
 488 void AliAODTrack::SetPosition(const T *x, const Bool_t dca)
 489 {
 490   // set the position
 491
 492   if (x) {
 493     if (!dca) {
 494       ResetBit(kIsDCA);
 495
 496       fPosition[0] = x[0];
 497       fPosition[1] = x[1];
 498       fPosition[2] = x[2];
 499     } else {
 500       SetBit(kIsDCA);
 501       // don't know any better yet
 502       fPosition[0] = -999.;
 503       fPosition[1] = -999.;
 504       fPosition[2] = -999.;
 505     }
 506   } else {
 507     ResetBit(kIsDCA);
 508
 509     fPosition[0] = -999.;
 510     fPosition[1] = -999.;
 511     fPosition[2] = -999.;
 512   }
 513 }
 514
 515 //template<> void AliAODTrack::SetPosition(const double *, Bool_t);
 516
 517 #endif