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
  24 class AliAODTrack : public AliVTrack {
  25
  26  public:
  27
  28   enum AODTrk_t {kUndef = -1,
  29                  kPrimary,
  30                  kSecondary,
  31                  kOrphan};
  32
  33   enum AODTrkBits_t {
  34     kIsDCA=BIT(14),   // set if fPosition is the DCA and not the position of the first point
  35     kUsedForVtxFit=BIT(15), // set if this track was used to fit the vertex it is attached to
  36     kUsedForPrimVtxFit=BIT(16), // set if this track was used to fit the primary vertex
  37     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
  38     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
  39     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
  40     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
  41   };
  42
  43
  44   enum AODTrkFilterBits_t {
  45     kTrkTPCOnly            = BIT(0), // Standard TPC only tracks
  46     kTrkITSsa              = BIT(1), // ITS standalone
  47     kTrkITSConstrained     = BIT(2), // Pixel OR necessary for the electrons
  48     kTrkElectronsPID       = BIT(3),    // PID for the electrons
  49     kTrkGlobalNoDCA        = BIT(4), // standard cuts with very loose DCA
  50     kTrkGlobal             = BIT(5),  // standard cuts with tight DCA cut
  51     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
  52     kTrkTPCOnlyConstrained = BIT(7) // TPC only tracks: TPConly information constrained to SPD vertex in the filter below
  53   };
  54
  55
  56   enum AODTrkPID_t {
  57     kElectron     =  0,
  58     kMuon         =  1,
  59     kPion         =  2,
  60     kKaon         =  3,
  61     kProton       =  4,
  62     kDeuteron     =  5,
  63     kTriton       =  6,
  64     kHelium3      =  7,
  65     kAlpha        =  8,
  66     kUnknown      =  9,
  67     kMostProbable = -1
  68   };
  69
  70   AliAODTrack();
  71   AliAODTrack(Short_t id,
  72               Int_t label,
  73               Double_t p[3],
  74               Bool_t cartesian,
  75               Double_t x[3],
  76               Bool_t dca,
  77               Double_t covMatrix[21],
  78               Short_t q,
  79               UChar_t itsClusMap,
  80               Double_t pid[10],
  81               AliAODVertex *prodVertex,
  82               Bool_t usedForVtxFit,
  83               Bool_t usedForPrimVtxFit,
  84               AODTrk_t ttype=kUndef,
  85               UInt_t selectInfo=0,
  86               Float_t chi2perNDF = -999.);
  87
  88   AliAODTrack(Short_t id,
  89               Int_t label,
  90               Float_t p[3],
  91               Bool_t cartesian,
  92               Float_t x[3],
  93               Bool_t dca,
  94               Float_t covMatrix[21],
  95               Short_t q,
  96               UChar_t itsClusMap,
  97               Float_t pid[10],
  98               AliAODVertex *prodVertex,
  99               Bool_t usedForVtxFit,
 100               Bool_t usedForPrimVtxFit,
 101               AODTrk_t ttype=kUndef,
 102               UInt_t selectInfo=0,
 103               Float_t chi2perNDF = -999.);
 104
 105   virtual ~AliAODTrack();
 106   AliAODTrack(const AliAODTrack& trk);
 107   AliAODTrack& operator=(const AliAODTrack& trk);
 108
 109   // kinematics
 110   virtual Double_t OneOverPt() const { return (fMomentum[0] != 0.) ? 1./fMomentum[0] : -999.; }
 111   virtual Double_t Phi()       const { return fMomentum[1]; }
 112   virtual Double_t Theta()     const { return fMomentum[2]; }
 113
 114   virtual Double_t Px() const { return fMomentum[0] * TMath::Cos(fMomentum[1]); }
 115   virtual Double_t Py() const { return fMomentum[0] * TMath::Sin(fMomentum[1]); }
 116   virtual Double_t Pz() const { return fMomentum[0] / TMath::Tan(fMomentum[2]); }
 117   virtual Double_t Pt() const { return fMomentum[0]; }
 118   virtual Double_t P()  const { return TMath::Sqrt(Pt()*Pt()+Pz()*Pz()); }
 119   virtual Bool_t   PxPyPz(Double_t p[3]) const { p[0] = Px(); p[1] = Py(); p[2] = Pz(); return kTRUE; }
 120
 121   virtual Double_t Xv() const { return GetProdVertex() ? GetProdVertex()->GetX() : -999.; }
 122   virtual Double_t Yv() const { return GetProdVertex() ? GetProdVertex()->GetY() : -999.; }
 123   virtual Double_t Zv() const { return GetProdVertex() ? GetProdVertex()->GetZ() : -999.; }
 124   virtual Bool_t   XvYvZv(Double_t x[3]) const { x[0] = Xv(); x[1] = Yv(); x[2] = Zv(); return kTRUE; }
 125
 126   Double_t Chi2perNDF()  const { return fChi2perNDF; }
 127   UShort_t GetTPCNcls()  const {
 128     UShort_t cl = 0;
 129     cl = fTPCFitMap.CountBits();
 130     if(cl==0)return fTPCClusterMap.CountBits();// backward compatibility
 131     return cl;
 132   }
 133
 134   virtual Double_t M() const { return M(GetMostProbablePID()); }
 135   Double_t M(AODTrkPID_t pid) const;
 136   virtual Double_t E() const { return E(GetMostProbablePID()); }
 137   Double_t E(AODTrkPID_t pid) const;
 138   Double_t E(Double_t m) const { return TMath::Sqrt(P()*P() + m*m); }
 139   virtual Double_t Y() const { return Y(GetMostProbablePID()); }
 140   Double_t Y(AODTrkPID_t pid) const;
 141   Double_t Y(Double_t m) const;
 142
 143   virtual Double_t Eta() const { return -TMath::Log(TMath::Tan(0.5 * fMomentum[2])); }
 144
 145   virtual Short_t  Charge() const {return fCharge; }
 146
 147   virtual Bool_t   PropagateToDCA(const AliVVertex *vtx,
 148           Double_t b, Double_t maxd, Double_t dz[2], Double_t covar[3]);
 149
 150   // PID
 151   virtual const Double_t *PID() const { return fPID; }
 152   AODTrkPID_t GetMostProbablePID() const;
 153   void ConvertAliPIDtoAODPID();
 154   void SetDetPID(AliAODPid *aodpid) {fDetPid = aodpid;}
 155
 156   template <class T> void GetPID(T *pid) const {
 157     for(Int_t i=0; i<10; ++i) pid[i]=fPID[i];}
 158
 159   template <class T> void SetPID(const T *pid) {
 160     if(pid) for(Int_t i=0; i<10; ++i) fPID[i]=pid[i];
 161     else {for(Int_t i=0; i<10; fPID[i++]=0.) ; fPID[AliAODTrack::kUnknown]=1.;}}
 162
 163   Bool_t IsOn(Int_t mask) const {return (fFlags&mask)>0;}
 164   ULong_t GetStatus() const { return GetFlags(); }
 165   ULong_t GetFlags() const { return fFlags; }
 166
 167   Int_t   GetID() const { return (Int_t)fID; }
 168   Int_t   GetLabel() const { return fLabel; }
 169   Char_t  GetType() const { return fType;}
 170   Bool_t  IsPrimaryCandidate() const;
 171   Bool_t  GetUsedForVtxFit() const { return TestBit(kUsedForVtxFit); }
 172   Bool_t  GetUsedForPrimVtxFit() const { return TestBit(kUsedForPrimVtxFit); }
 173
 174   Bool_t  IsHybridGlobalConstrainedGlobal() const { return TestBit(kIsHybridGCG); }
 175   Bool_t  IsHybridTPCConstrainedGlobal() const { return TestBit(kIsHybridTPCCG); }
 176   Bool_t  IsTPCOnly() const { return IsTPCConstrained(); } // obsolete bad naming
 177   Bool_t  IsTPCConstrained() const { return TestBit(kIsTPCConstrained); }
 178   Bool_t  IsGlobalConstrained() const { return TestBit(kIsGlobalConstrained); }
 179   //
 180   Int_t   GetTOFBunchCrossing(Double_t b=0) const;
 181   //
 182   template <class T> void GetP(T *p) const {
 183     p[0]=fMomentum[0]; p[1]=fMomentum[1]; p[2]=fMomentum[2];}
 184
 185 //  template <class T> void GetPxPyPz(T *p) const {
 186 //    p[0] = Px(); p[1] = Py(); p[2] = Pz();}
 187   Bool_t GetPxPyPz(Double_t *p) const;
 188
 189   template <class T> Bool_t GetPosition(T *x) const {
 190     x[0]=fPosition[0]; x[1]=fPosition[1]; x[2]=fPosition[2];
 191     return TestBit(kIsDCA);}
 192
 193   template <class T> void SetCovMatrix(const T *covMatrix) {
 194     if(!fCovMatrix) fCovMatrix=new AliAODRedCov<6>();
 195     fCovMatrix->SetCovMatrix(covMatrix);}
 196
 197   template <class T> Bool_t GetCovMatrix(T *covMatrix) const {
 198     if(!fCovMatrix) return kFALSE;
 199     fCovMatrix->GetCovMatrix(covMatrix); return kTRUE;}
 200
 201   Bool_t GetXYZ(Double_t *p) const {
 202     return GetPosition(p); }
 203
 204   Bool_t GetCovarianceXYZPxPyPz(Double_t cv[21]) const {
 205     return GetCovMatrix(cv);}
 206
 207   void RemoveCovMatrix() {delete fCovMatrix; fCovMatrix=NULL;}
 208
 209   Double_t XAtDCA() const { return fPositionAtDCA[0]; }
 210   Double_t YAtDCA() const { return fPositionAtDCA[1]; }
 211   Double_t ZAtDCA() const {
 212     if (IsMuonTrack()) return fPosition[2];
 213     else if (TestBit(kIsDCA)) return fPosition[1];
 214     else return -999.; }
 215   Bool_t   XYZAtDCA(Double_t x[3]) const { x[0] = XAtDCA(); x[1] = YAtDCA(); x[2] = ZAtDCA(); return kTRUE; }
 216
 217   Double_t DCA() const {
 218     if (IsMuonTrack()) return TMath::Sqrt(XAtDCA()*XAtDCA() + YAtDCA()*YAtDCA());
 219     else if (TestBit(kIsDCA)) return fPosition[0];
 220     else return -999.; }
 221
 222   Double_t PxAtDCA() const { return fMomentumAtDCA[0]; }
 223   Double_t PyAtDCA() const { return fMomentumAtDCA[1]; }
 224   Double_t PzAtDCA() const { return fMomentumAtDCA[2]; }
 225   Double_t PAtDCA() const { return TMath::Sqrt(PxAtDCA()*PxAtDCA() + PyAtDCA()*PyAtDCA() + PzAtDCA()*PzAtDCA()); }
 226   Bool_t   PxPyPzAtDCA(Double_t p[3]) const { p[0] = PxAtDCA(); p[1] = PyAtDCA(); p[2] = PzAtDCA(); return kTRUE; }
 227
 228   Double_t GetRAtAbsorberEnd() const { return fRAtAbsorberEnd; }
 229
 230   UChar_t  GetITSClusterMap() const       { return (UChar_t)(fITSMuonClusterMap&0xff); }
 231   Int_t    GetITSNcls() const;
 232   Bool_t   HasPointOnITSLayer(Int_t i) const { return TESTBIT(GetITSClusterMap(),i); }
 233   UShort_t GetHitsPatternInTrigCh() const { return (UShort_t)((fITSMuonClusterMap&0xff00)>>8); }
 234   UInt_t   GetMUONClusterMap() const      { return (fITSMuonClusterMap&0x3ff0000)>>16; }
 235   UInt_t   GetITSMUONClusterMap() const   { return fITSMuonClusterMap; }
 236
 237   Bool_t  TestFilterBit(UInt_t filterBit) const {return (Bool_t) ((filterBit & fFilterMap) != 0);}
 238   Bool_t  TestFilterMask(UInt_t filterMask) const {return (Bool_t) ((filterMask & fFilterMap) == filterMask);}
 239   void    SetFilterMap(UInt_t i){fFilterMap = i;}
 240   UInt_t  GetFilterMap() const {return fFilterMap;}
 241
 242   const TBits& GetTPCClusterMap() const {return fTPCClusterMap;}
 243   const TBits& GetTPCFitMap() const {return fTPCFitMap;}
 244   Float_t GetTPCClusterInfo(Int_t nNeighbours=3, Int_t type=0, Int_t row0=0, Int_t row1=159, Int_t /*type*/=0) const;
 245
 246   const TBits& GetTPCSharedMap() const {return fTPCSharedMap;}
 247   void    SetTPCClusterMap(const TBits amap) {fTPCClusterMap = amap;}
 248   void    SetTPCSharedMap(const TBits amap) {fTPCSharedMap = amap;}
 249   void    SetTPCFitMap(const TBits amap) {fTPCFitMap = amap;}
 250   void    SetTPCPointsF(UShort_t  findable){fTPCnclsF = findable;}
 251
 252   UShort_t GetTPCNclsF() const { return fTPCnclsF;}
 253
 254   // Calorimeter Cluster
 255   Int_t GetEMCALcluster() const {return fCaloIndex;}
 256   void SetEMCALcluster(Int_t index) {fCaloIndex=index;}
 257   Bool_t IsEMCAL() const {return fFlags&kEMCALmatch;}
 258
 259   Int_t GetPHOScluster() const {return fCaloIndex;}
 260   void SetPHOScluster(Int_t index) {fCaloIndex=index;}
 261   Bool_t IsPHOS() const {return fFlags&kPHOSmatch;}
 262
 263   //pid signal interface
 264   Double_t  GetITSsignal()       const { return fDetPid?fDetPid->GetITSsignal():0.;    }
 265   Double_t  GetTPCsignal()       const { return fDetPid?fDetPid->GetTPCsignal():0.;    }
 266   UShort_t  GetTPCsignalN()      const { return fDetPid?fDetPid->GetTPCsignalN():0;    }
 267   Double_t  GetTPCmomentum()     const { return fDetPid?fDetPid->GetTPCmomentum():0.;  }
 268   Double_t  GetTOFsignal()       const { return fDetPid?fDetPid->GetTOFsignal():0.;    }
 269   Double_t  GetHMPIDsignal()     const { return fDetPid?fDetPid->GetHMPIDsignal():0.;  }
 270
 271   void      GetIntegratedTimes(Double_t *times) const {if (fDetPid) fDetPid->GetIntegratedTimes(times); }
 272   Double_t  GetTRDslice(Int_t plane, Int_t slice) const;
 273   Double_t  GetTRDmomentum(Int_t plane, Double_t */*sp*/=0x0) const;
 274   UChar_t   GetTRDncls(Int_t layer = -1) const;
 275   UChar_t   GetTRDntrackletsPID() const;
 276   void      GetHMPIDpid(Double_t *p) const { if (fDetPid) fDetPid->GetHMPIDprobs(p); }
 277
 278
 279   AliAODPid    *GetDetPid() const { return fDetPid; }
 280   AliAODVertex *GetProdVertex() const { return (AliAODVertex*)fProdVertex.GetObject(); }
 281
 282   // print
 283   void  Print(const Option_t *opt = "") const;
 284
 285   // setters
 286   void SetFlags(ULong_t flags) { fFlags = flags; }
 287   void SetStatus(ULong_t flags) { fFlags|=flags; }
 288   void ResetStatus(ULong_t flags) { fFlags&=~flags; }
 289
 290   void SetID(Short_t id) { fID = id; }
 291   void SetLabel(Int_t label) { fLabel = label; }
 292
 293   template <class T> void SetPosition(const T *x, Bool_t isDCA = kFALSE);
 294   void SetDCA(Double_t d, Double_t z);
 295   void SetUsedForVtxFit(Bool_t used = kTRUE) { used ? SetBit(kUsedForVtxFit) : ResetBit(kUsedForVtxFit); }
 296   void SetUsedForPrimVtxFit(Bool_t used = kTRUE) { used ? SetBit(kUsedForPrimVtxFit) : ResetBit(kUsedForPrimVtxFit); }
 297
 298   void SetIsTPCOnly(Bool_t b = kTRUE) { SetIsTPCConstrained(b); }// obsolete bad naming
 299
 300   void SetIsTPCConstrained(Bool_t b = kTRUE) { b ? SetBit(kIsTPCConstrained) : ResetBit(kIsTPCConstrained); }
 301   void SetIsHybridTPCConstrainedGlobal(Bool_t hybrid = kTRUE) { hybrid ? SetBit(kIsHybridTPCCG) : ResetBit(kIsHybridTPCCG); }
 302
 303   void SetIsGlobalConstrained(Bool_t b = kTRUE) { b ? SetBit(kIsGlobalConstrained) : ResetBit(kIsGlobalConstrained); }
 304   void SetIsHybridGlobalConstrainedGlobal(Bool_t hybrid = kTRUE) { hybrid ? SetBit(kIsHybridGCG) : ResetBit(kIsHybridGCG); }
 305
 306
 307
 308   void SetOneOverPt(Double_t oneOverPt) { fMomentum[0] = 1. / oneOverPt; }
 309   void SetPt(Double_t pt) { fMomentum[0] = pt; };
 310   void SetPhi(Double_t phi) { fMomentum[1] = phi; }
 311   void SetTheta(Double_t theta) { fMomentum[2] = theta; }
 312   template <class T> void SetP(const T *p, Bool_t cartesian = kTRUE);
 313   void SetP() {fMomentum[0]=fMomentum[1]=fMomentum[2]=-999.;}
 314
 315   void SetXYAtDCA(Double_t x, Double_t y) {fPositionAtDCA[0] = x; fPositionAtDCA[1] = y;}
 316   void SetPxPyPzAtDCA(Double_t pX, Double_t pY, Double_t pZ) {fMomentumAtDCA[0] = pX; fMomentumAtDCA[1] = pY; fMomentumAtDCA[2] = pZ;}
 317
 318   void SetRAtAbsorberEnd(Double_t r) { fRAtAbsorberEnd = r; }
 319
 320   void SetCharge(Short_t q) { fCharge = q; }
 321   void SetChi2perNDF(Double_t chi2perNDF) { fChi2perNDF = chi2perNDF; }
 322
 323   void SetITSClusterMap(UChar_t itsClusMap)                 { fITSMuonClusterMap = (fITSMuonClusterMap&0xffffff00)|(((UInt_t)itsClusMap)&0xff); }
 324   void SetHitsPatternInTrigCh(UShort_t hitsPatternInTrigCh) { fITSMuonClusterMap = (fITSMuonClusterMap&0xffff00ff)|((((UInt_t)hitsPatternInTrigCh)&0xff)<<8); }
 325   void SetMuonClusterMap(UInt_t muonClusMap)                { fITSMuonClusterMap = (fITSMuonClusterMap&0xfc00ffff)|((muonClusMap&0x3ff)<<16); }
 326   void SetITSMuonClusterMap(UInt_t itsMuonClusMap)          { fITSMuonClusterMap = itsMuonClusMap; }
 327
 328   Int_t GetMatchTrigger() const {return fITSMuonClusterMap>>30;}
 329                                         //  0 Muon track does not match trigger
 330                                         //  1 Muon track match but does not pass pt cut
 331                                         //  2 Muon track match Low pt cut
 332                                         //  3 Muon track match High pt cut
 333   void     SetMatchTrigger(Int_t MatchTrigger);
 334   Bool_t   MatchTrigger() const { return (GetMatchTrigger()>0); }         //  Muon track matches trigger track
 335   Bool_t   MatchTriggerLowPt()   const  { return (GetMatchTrigger()>1); } //  Muon track matches trigger track and passes Low pt cut
 336   Bool_t   MatchTriggerHighPt()  const  { return (GetMatchTrigger()>2); } //  Muon track matches trigger track and passes High pt cut
 337   Bool_t   MatchTriggerDigits()  const;                                   //  Muon track matches trigger digits
 338   Double_t GetChi2MatchTrigger() const  { return fChi2MatchTrigger;}
 339   void     SetChi2MatchTrigger(Double_t Chi2MatchTrigger) {fChi2MatchTrigger = Chi2MatchTrigger; }
 340   Bool_t   HitsMuonChamber(Int_t MuonChamber, Int_t cathode = -1) const;  // Check if track hits Muon chambers
 341   Bool_t   IsMuonTrack() const { return (GetMUONClusterMap()>0) ? kTRUE : kFALSE; }
 342
 343   void     Connected(Bool_t flag) {flag ? SETBIT(fITSMuonClusterMap,26) : CLRBIT(fITSMuonClusterMap,26);}
 344   Bool_t   IsConnected() const {return TESTBIT(fITSMuonClusterMap,26);}
 345
 346   void     SetProdVertex(TObject *vertex) { fProdVertex = vertex; }
 347   void     SetType(AODTrk_t ttype) { fType=ttype; }
 348
 349
 350
 351   // Dummy
 352   Int_t    PdgCode() const {return 0;}
 353
 354  private :
 355
 356   // Momentum & position
 357   Double32_t    fMomentum[3];       // momemtum stored in pt, phi, theta
 358   Double32_t    fPosition[3];       // position of first point on track or dca
 359
 360   Double32_t    fMomentumAtDCA[3];  // momentum (px,py,pz) at DCA
 361   Double32_t    fPositionAtDCA[2];  // trasverse position (x,y) at DCA
 362
 363   Double32_t    fRAtAbsorberEnd;    // transverse position r at the end of the muon absorber
 364
 365   Double32_t    fChi2perNDF;        // chi2/NDF of momentum fit
 366   Double32_t    fChi2MatchTrigger;  // chi2 of trigger/track matching
 367   Double32_t    fPID[10];           // [0.,1.,8] pointer to PID object
 368
 369   ULong_t       fFlags;             // reconstruction status flags
 370   Int_t         fLabel;             // track label, points back to MC track
 371
 372   UInt_t        fITSMuonClusterMap; // map of ITS and muon clusters, one bit per layer
 373                                     // (ITS: bit 1-8, muon trigger: bit 9-16, muon tracker: bit 17-26, muon match trigger: bit 31-32)
 374   UInt_t        fFilterMap;         // filter information, one bit per set of cuts
 375
 376   TBits         fTPCFitMap;      // Map of clusters, one bit per padrow; if has a cluster on given padrow which is used in the fit
 377   TBits         fTPCClusterMap;     // Map of clusters, one bit per padrow; 1 if has a cluster on given padrow
 378   TBits         fTPCSharedMap;      // Map of clusters, one bit per padrow; 1 if has a shared cluster on given padrow
 379
 380   UShort_t      fTPCnclsF;          // findable clusters
 381
 382   Short_t       fID;                // unique track ID, points back to the ESD track
 383
 384   Char_t        fCharge;            // particle charge
 385   Char_t        fType;              // Track Type
 386
 387   Int_t         fCaloIndex;         // index of associated EMCAL/PHOS cluster (AliAODCaloCluster)
 388
 389
 390   AliAODRedCov<6> *fCovMatrix;      // covariance matrix (x, y, z, px, py, pz)
 391   AliAODPid    *fDetPid;            // more detailed or detector specific pid information
 392   TRef          fProdVertex;        // vertex of origin
 393
 394   ClassDef(AliAODTrack, 15);
 395 };
 396
 397 inline Bool_t  AliAODTrack::IsPrimaryCandidate() const
 398 {
 399     // True of track passes primary particle selection (independent of type)
 400     //
 401     if (fFilterMap) {
 402         return kTRUE;
 403     } else {
 404         return kFALSE;
 405     }
 406 }
 407
 408 inline Int_t AliAODTrack::GetITSNcls() const
 409 {
 410   // Number of points in ITS
 411   Int_t n=0;
 412   for(Int_t i=0;i<6;i++) if(HasPointOnITSLayer(i)) n++;
 413   return n;
 414 }
 415
 416 #endif