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 fTrackPtOnEMCal*TMath::CosH(fTrackEtaOnEMCal);}
 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  GetTOFsignal()       const { return fDetPid?fDetPid->GetTOFsignal():0.;    }
 300   Double_t  GetIntegratedLength() const { return fTrackLength;}
 301   void      SetIntegratedLength(Double_t l) {fTrackLength = l;}
 302   Double_t  GetTOFsignalTunedOnData() const { return fTOFsignalTuned;}
 303   void      SetTOFsignalTunedOnData(Double_t signal) {fTOFsignalTuned = signal;}
 304   Double_t  GetHMPIDsignal()     const;
 305   Double_t  GetHMPIDoccupancy()  const;
 306
 307   Int_t     GetHMPIDcluIdx()     const;
 308
 309   void GetHMPIDtrk(Float_t &x, Float_t &y, Float_t &th, Float_t &ph) const;
 310   void GetHMPIDmip(Float_t &x,Float_t &y,Int_t &q,Int_t &nph) const;
 311
 312   Bool_t GetOuterHmpPxPyPz(Double_t *p) const;
 313
 314   void      GetIntegratedTimes(Double_t *times) const {if (fDetPid) fDetPid->GetIntegratedTimes(times); }
 315   Double_t  GetTRDslice(Int_t plane, Int_t slice) const;
 316   Double_t  GetTRDsignal()                        const {return fDetPid ? fDetPid->GetTRDsignal() : 0;}
 317   Double_t  GetTRDmomentum(Int_t plane, Double_t */*sp*/=0x0) const;
 318   Double_t  GetTRDchi2()                 const {return fDetPid ? fDetPid->GetTRDChi2() : -1;}
 319   UChar_t   GetTRDncls(Int_t layer)      const;
 320   UChar_t   GetTRDncls()                 const {return GetTRDncls(-1);}
 321   UChar_t   GetTRDntrackletsPID() const;
 322   Int_t     GetNumberOfTRDslices() const { return fDetPid?fDetPid->GetTRDnSlices():0; }
 323   void      GetHMPIDpid(Double_t */*p*/) const { return; } // TODO: To be implemented properly with the new HMPID object
 324
 325   const AliAODEvent* GetAODEvent() const {return fAODEvent;}
 326   void SetAODEvent(const AliAODEvent* ptr){fAODEvent = ptr;}
 327
 328   AliAODPid    *GetDetPid() const { return fDetPid; }
 329   AliAODVertex *GetProdVertex() const { return (AliAODVertex*)fProdVertex.GetObject(); }
 330
 331   // print
 332   void  Print(const Option_t *opt = "") const;
 333
 334   // setters
 335   void SetFlags(ULong_t flags) { fFlags = flags; }
 336   void SetStatus(ULong_t flags) { fFlags|=flags; }
 337   void ResetStatus(ULong_t flags) { fFlags&=~flags; }
 338
 339   void SetID(Short_t id) { fID = id; }
 340   void SetLabel(Int_t label) { fLabel = label; }
 341   void SetTOFLabel(const Int_t* p);
 342   template <typename T> void SetPosition(const T *x, Bool_t isDCA = kFALSE);
 343   void SetDCA(Double_t d, Double_t z);
 344   void SetUsedForVtxFit(Bool_t used = kTRUE) { used ? SetBit(kUsedForVtxFit) : ResetBit(kUsedForVtxFit); }
 345   void SetUsedForPrimVtxFit(Bool_t used = kTRUE) { used ? SetBit(kUsedForPrimVtxFit) : ResetBit(kUsedForPrimVtxFit); }
 346
 347   void SetIsTPCOnly(Bool_t b = kTRUE) { SetIsTPCConstrained(b); }// obsolete bad naming
 348
 349   void SetIsTPCConstrained(Bool_t b = kTRUE) { b ? SetBit(kIsTPCConstrained) : ResetBit(kIsTPCConstrained); }
 350   void SetIsHybridTPCConstrainedGlobal(Bool_t hybrid = kTRUE) { hybrid ? SetBit(kIsHybridTPCCG) : ResetBit(kIsHybridTPCCG); }
 351
 352   void SetIsGlobalConstrained(Bool_t b = kTRUE) { b ? SetBit(kIsGlobalConstrained) : ResetBit(kIsGlobalConstrained); }
 353   void SetIsHybridGlobalConstrainedGlobal(Bool_t hybrid = kTRUE) { hybrid ? SetBit(kIsHybridGCG) : ResetBit(kIsHybridGCG); }
 354
 355
 356
 357   void SetOneOverPt(Double_t oneOverPt) { fMomentum[0] = 1. / oneOverPt; }
 358   void SetPt(Double_t pt) { fMomentum[0] = pt; };
 359   void SetPhi(Double_t phi) { fMomentum[1] = phi; }
 360   void SetTheta(Double_t theta) { fMomentum[2] = theta; }
 361   template <typename T> void SetP(const T *p, Bool_t cartesian = kTRUE);
 362   void SetP() {fMomentum[0]=fMomentum[1]=fMomentum[2]=-999.;}
 363
 364   void SetXYAtDCA(Double_t x, Double_t y) {fPositionAtDCA[0] = x; fPositionAtDCA[1] = y;}
 365   void SetPxPyPzAtDCA(Double_t pX, Double_t pY, Double_t pZ) {fMomentumAtDCA[0] = pX; fMomentumAtDCA[1] = pY; fMomentumAtDCA[2] = pZ;}
 366
 367   void SetRAtAbsorberEnd(Double_t r) { fRAtAbsorberEnd = r; }
 368
 369   void SetCharge(Short_t q) { fCharge = q; }
 370   void SetChi2perNDF(Double_t chi2perNDF) { fChi2perNDF = chi2perNDF; }
 371
 372   void SetITSClusterMap(UChar_t itsClusMap)                 { fITSMuonClusterMap = (fITSMuonClusterMap&0xffffff00)|(((UInt_t)itsClusMap)&0xff); }
 373   void SetHitsPatternInTrigCh(UShort_t hitsPatternInTrigCh) { fITSMuonClusterMap = (fITSMuonClusterMap&0xffff00ff)|((((UInt_t)hitsPatternInTrigCh)&0xff)<<8); }
 374   void SetMuonClusterMap(UInt_t muonClusMap)                { fITSMuonClusterMap = (fITSMuonClusterMap&0xfc00ffff)|((muonClusMap&0x3ff)<<16); }
 375   void SetITSMuonClusterMap(UInt_t itsMuonClusMap)          { fITSMuonClusterMap = itsMuonClusMap; }
 376   void SetMUONtrigHitsMapTrg(UInt_t muonTrigHitsMap) { fMUONtrigHitsMapTrg = muonTrigHitsMap; }
 377   UInt_t GetMUONTrigHitsMapTrg() { return fMUONtrigHitsMapTrg; }
 378   void SetMUONtrigHitsMapTrk(UInt_t muonTrigHitsMap) { fMUONtrigHitsMapTrk = muonTrigHitsMap; }
 379   UInt_t GetMUONTrigHitsMapTrk() { return fMUONtrigHitsMapTrk; }
 380
 381   Int_t GetMatchTrigger() const {return fITSMuonClusterMap>>30;}
 382                                         //  0 Muon track does not match trigger
 383                                         //  1 Muon track match but does not pass pt cut
 384                                         //  2 Muon track match Low pt cut
 385                                         //  3 Muon track match High pt cut
 386   void     SetMatchTrigger(Int_t MatchTrigger);
 387   Bool_t   MatchTrigger() const { return (GetMatchTrigger()>0); }         //  Muon track matches trigger track
 388   Bool_t   MatchTriggerLowPt()   const  { return (GetMatchTrigger()>1); } //  Muon track matches trigger track and passes Low pt cut
 389   Bool_t   MatchTriggerHighPt()  const  { return (GetMatchTrigger()>2); } //  Muon track matches trigger track and passes High pt cut
 390   Bool_t   MatchTriggerDigits()  const;                                   //  Muon track matches trigger digits
 391   Double_t GetChi2MatchTrigger() const  { return fChi2MatchTrigger;}
 392   void     SetChi2MatchTrigger(Double_t Chi2MatchTrigger) {fChi2MatchTrigger = Chi2MatchTrigger; }
 393   Bool_t   HitsMuonChamber(Int_t MuonChamber, Int_t cathode = -1) const;  // Check if track hits Muon chambers
 394   Bool_t   IsMuonTrack() const { return (GetMUONClusterMap()>0) ? kTRUE : kFALSE; }
 395
 396   void     Connected(Bool_t flag) {flag ? SETBIT(fITSMuonClusterMap,26) : CLRBIT(fITSMuonClusterMap,26);}
 397   Bool_t   IsConnected() const {return TESTBIT(fITSMuonClusterMap,26);}
 398
 399   void     SetProdVertex(TObject *vertex) { fProdVertex = vertex; }
 400   void     SetType(AODTrk_t ttype) { fType=ttype; }
 401
 402   // Trasient PID object, is owned by the track
 403   virtual void  SetDetectorPID(const AliDetectorPID *pid);
 404   virtual const AliDetectorPID* GetDetectorPID() const { return fDetectorPID; }
 405
 406   // Dummy
 407   Int_t    PdgCode() const {return 0;}
 408
 409  private :
 410
 411   // Momentum & position
 412   Double32_t    fMomentum[3];       // momemtum stored in pt, phi, theta
 413   Double32_t    fPosition[3];       // position of first point on track or dca
 414
 415   Double32_t    fMomentumAtDCA[3];  // momentum (px,py,pz) at DCA
 416   Double32_t    fPositionAtDCA[2];  // trasverse position (x,y) at DCA
 417
 418   Double32_t    fRAtAbsorberEnd;    // transverse position r at the end of the muon absorber
 419
 420   Double32_t    fChi2perNDF;        // chi2/NDF of momentum fit
 421   Double32_t    fChi2MatchTrigger;  // chi2 of trigger/track matching
 422   Double32_t    fPID[10];           // [0.,1.,8] pointer to PID object
 423
 424   ULong_t       fFlags;             // reconstruction status flags
 425   Int_t         fLabel;             // track label, points back to MC track
 426   Int_t         fTOFLabel[3];       // TOF label
 427   Double32_t    fTrackLength;       // Track length
 428   UInt_t        fITSMuonClusterMap; // map of ITS and muon clusters, one bit per layer
 429                                     // (ITS: bit 1-8, muon trigger: bit 9-16, muon tracker: bit 17-26, muon match trigger: bit 31-32)
 430   UInt_t        fMUONtrigHitsMapTrg; // Muon trigger hits map from trigger
 431   UInt_t        fMUONtrigHitsMapTrk; // Muon trigger hits map from tracker track extrapolation
 432   UInt_t        fFilterMap;         // filter information, one bit per set of cuts
 433
 434   TBits         fTPCFitMap;      // Map of clusters, one bit per padrow; if has a cluster on given padrow which is used in the fit
 435   TBits         fTPCClusterMap;     // Map of clusters, one bit per padrow; 1 if has a cluster on given padrow
 436   TBits         fTPCSharedMap;      // Map of clusters, one bit per padrow; 1 if has a shared cluster on given padrow
 437
 438   UShort_t      fTPCnclsF;          // findable clusters
 439   UShort_t      fTPCNCrossedRows;   // n crossed rows
 440
 441   Short_t       fID;                // unique track ID, points back to the ESD track
 442
 443   Char_t        fCharge;            // particle charge
 444   Char_t        fType;              // Track Type
 445
 446   Int_t         fCaloIndex;         // index of associated EMCAL/PHOS cluster (AliAODCaloCluster)
 447
 448
 449   AliAODRedCov<6> *fCovMatrix;      // covariance matrix (x, y, z, px, py, pz)
 450   AliAODPid    *fDetPid;            // more detailed or detector specific raw pid information
 451   mutable const AliDetectorPID* fDetectorPID; //! transient object to cache calibrated PID information
 452   TRef          fProdVertex;        // vertex of origin
 453
 454   Double_t      fTrackPhiOnEMCal;   // phi of track after being propagated to the EMCal surface (default r = 440 cm)
 455   Double_t      fTrackEtaOnEMCal;   // eta of track after being propagated to the EMCal surface (default r = 440 cm)
 456   Double_t      fTrackPtOnEMCal;    // pt of track after being propagated to the EMCal surface (default r = 440 cm)
 457
 458   Double_t      fTPCsignalTuned;    //! TPC signal tuned on data when using MC
 459   Double_t      fTOFsignalTuned;    //! TOF signal tuned on data when using MC
 460
 461   const AliAODEvent* fAODEvent;     //!
 462
 463   ClassDef(AliAODTrack, 22);
 464 };
 465
 466 inline Bool_t  AliAODTrack::IsPrimaryCandidate() const
 467 {
 468     // True of track passes primary particle selection (independent of type)
 469     //
 470     if (fFilterMap) {
 471         return kTRUE;
 472     } else {
 473         return kFALSE;
 474     }
 475 }
 476
 477 inline Int_t AliAODTrack::GetITSNcls() const
 478 {
 479   // Number of points in ITS
 480   Int_t n=0;
 481   for(Int_t i=0;i<6;i++) if(HasPointOnITSLayer(i)) n++;
 482   return n;
 483 }
 484
 485 //______________________________________________________________________________
 486 template <typename T>
 487 void AliAODTrack::SetPosition(const T *x, const Bool_t dca)
 488 {
 489   // set the position
 490
 491   if (x) {
 492     if (!dca) {
 493       ResetBit(kIsDCA);
 494
 495       fPosition[0] = x[0];
 496       fPosition[1] = x[1];
 497       fPosition[2] = x[2];
 498     } else {
 499       SetBit(kIsDCA);
 500       // don't know any better yet
 501       fPosition[0] = -999.;
 502       fPosition[1] = -999.;
 503       fPosition[2] = -999.;
 504     }
 505   } else {
 506     ResetBit(kIsDCA);
 507
 508     fPosition[0] = -999.;
 509     fPosition[1] = -999.;
 510     fPosition[2] = -999.;
 511   }
 512 }
 513
 514 //template<> void AliAODTrack::SetPosition(const double *, Bool_t);
 515
 516 #endif