#ifndef AliAODTrack_H
#define AliAODTrack_H
#include <TRef.h>
#include <TBits.h>
#include "AliVTrack.h"
#include "AliAODVertex.h"
#include "AliAODRedCov.h"
#include "AliAODPid.h"
#include "AliExternalTrackParam.h"
class AliVVertex;
class AliDetectorPID;
class AliTPCdEdxInfo;
class AliAODEvent;
class AliTOFHeader;
class AliAODTrack : public AliVTrack {
public:
enum AODTrk_t {kUndef = -1,
kPrimary,
kFromDecayVtx,
kOrphan};
enum AODTrkBits_t {
kIsDCA=BIT(14),
kUsedForVtxFit=BIT(15),
kUsedForPrimVtxFit=BIT(16),
kIsTPCConstrained=BIT(17),
kIsHybridTPCCG=BIT(18),
kIsGlobalConstrained=BIT(19),
kIsHybridGCG=BIT(20)
};
enum AODTrkFilterBits_t {
kTrkTPCOnly = BIT(0),
kTrkITSsa = BIT(1),
kTrkITSConstrained = BIT(2),
kTrkElectronsPID = BIT(3),
kTrkGlobalNoDCA = BIT(4),
kTrkGlobal = BIT(5),
kTrkGlobalSDD = BIT(6),
kTrkTPCOnlyConstrained = BIT(7)
};
enum AODTrkPID_t {
kElectron = 0,
kMuon = 1,
kPion = 2,
kKaon = 3,
kProton = 4,
kDeuteron = 5,
kTriton = 6,
kHelium3 = 7,
kAlpha = 8,
kUnknown = 9,
kMostProbable = -1
};
AliAODTrack();
AliAODTrack(Short_t id,
Int_t label,
Double_t p[3],
Bool_t cartesian,
Double_t x[3],
Bool_t dca,
Double_t covMatrix[21],
Short_t q,
UChar_t itsClusMap,
AliAODVertex *prodVertex,
Bool_t usedForVtxFit,
Bool_t usedForPrimVtxFit,
AODTrk_t ttype=kUndef,
UInt_t selectInfo=0,
Float_t chi2perNDF = -999.);
AliAODTrack(Short_t id,
Int_t label,
Float_t p[3],
Bool_t cartesian,
Float_t x[3],
Bool_t dca,
Float_t covMatrix[21],
Short_t q,
UChar_t itsClusMap,
AliAODVertex *prodVertex,
Bool_t usedForVtxFit,
Bool_t usedForPrimVtxFit,
AODTrk_t ttype=kUndef,
UInt_t selectInfo=0,
Float_t chi2perNDF = -999.);
virtual ~AliAODTrack();
AliAODTrack(const AliAODTrack& trk);
AliAODTrack& operator=(const AliAODTrack& trk);
virtual Double_t OneOverPt() const { return (fMomentum[0] != 0.) ? 1./fMomentum[0] : -999.; }
virtual Double_t Phi() const { return fMomentum[1]; }
virtual Double_t Theta() const { return fMomentum[2]; }
virtual Double_t Px() const { return fMomentum[0] * TMath::Cos(fMomentum[1]); }
virtual Double_t Py() const { return fMomentum[0] * TMath::Sin(fMomentum[1]); }
virtual Double_t Pz() const { return fMomentum[0] / TMath::Tan(fMomentum[2]); }
virtual Double_t Pt() const { return fMomentum[0]; }
virtual Double_t P() const { return TMath::Sqrt(Pt()*Pt()+Pz()*Pz()); }
virtual Bool_t PxPyPz(Double_t p[3]) const { p[0] = Px(); p[1] = Py(); p[2] = Pz(); return kTRUE; }
virtual Double_t Xv() const { return GetProdVertex() ? GetProdVertex()->GetX() : -999.; }
virtual Double_t Yv() const { return GetProdVertex() ? GetProdVertex()->GetY() : -999.; }
virtual Double_t Zv() const { return GetProdVertex() ? GetProdVertex()->GetZ() : -999.; }
virtual Bool_t XvYvZv(Double_t x[3]) const { x[0] = Xv(); x[1] = Yv(); x[2] = Zv(); return kTRUE; }
Double_t Chi2perNDF() const { return fChi2perNDF; }
UShort_t GetTPCnclsS(Int_t i0=0,Int_t i1=159) const {
UShort_t cl = fTPCSharedMap.CountBits(i0)-fTPCSharedMap.CountBits(i1);
return cl;
}
UShort_t GetTPCncls(Int_t i0=0,Int_t i1=159) const {
UShort_t cl = fTPCFitMap.CountBits(i0)-fTPCFitMap.CountBits(i1);
if(cl==0)cl = fTPCClusterMap.CountBits(i0)-fTPCClusterMap.CountBits(i1);
return cl;
}
UShort_t GetTPCNcls() const { return GetTPCncls(); }
Int_t GetNcls(Int_t idet) const;
virtual Double_t M() const { return M(GetMostProbablePID()); }
Double_t M(AODTrkPID_t pid) const;
virtual Double_t E() const { return E(GetMostProbablePID()); }
Double_t E(AODTrkPID_t pid) const;
Double_t E(Double_t m) const { return TMath::Sqrt(P()*P() + m*m); }
virtual Double_t Y() const { return Y(GetMostProbablePID()); }
Double_t Y(AODTrkPID_t pid) const;
Double_t Y(Double_t m) const;
virtual Double_t Eta() const { return -TMath::Log(TMath::Tan(0.5 * fMomentum[2])); }
virtual Short_t Charge() const {return fCharge; }
virtual Bool_t PropagateToDCA(const AliVVertex *vtx,
Double_t b, Double_t maxd, Double_t dz[2], Double_t covar[3]);
virtual const Double_t *PID() const { return fPID; }
AODTrkPID_t GetMostProbablePID() const;
void ConvertAliPIDtoAODPID();
void SetDetPID(AliAODPid *aodpid) {fDetPid = aodpid;}
void SetPIDForTracking(Int_t pid) {fPIDForTracking = pid;}
Int_t GetPIDForTracking() const {return fPIDForTracking;}
Double_t GetMassForTracking() const;
template <typename T> void GetPID(T *pid) const {
for(Int_t i=0; i<10; ++i) pid[i] = fPID ? fPID[i]:0;}
template <typename T> void SetPID(const T *pid) {
if (pid) {
if (!fPID) fPID = new Double32_t[10];
for(Int_t i=0; i<10; ++i) fPID[i]=pid[i];
}
else {delete[] fPID; fPID = 0;}
}
Bool_t IsOn(Int_t mask) const {return (fFlags&mask)>0;}
ULong_t GetStatus() const { return GetFlags(); }
ULong_t GetFlags() const { return fFlags; }
Int_t GetID() const { return (Int_t)fID; }
Int_t GetLabel() const { return fLabel; }
void GetTOFLabel(Int_t *p) const;
Char_t GetType() const { return fType;}
Bool_t IsPrimaryCandidate() const;
Bool_t GetUsedForVtxFit() const { return TestBit(kUsedForVtxFit); }
Bool_t GetUsedForPrimVtxFit() const { return TestBit(kUsedForPrimVtxFit); }
Bool_t IsHybridGlobalConstrainedGlobal() const { return TestBit(kIsHybridGCG); }
Bool_t IsHybridTPCConstrainedGlobal() const { return TestBit(kIsHybridTPCCG); }
Bool_t IsTPCOnly() const { return IsTPCConstrained(); }
Bool_t IsTPCConstrained() const { return TestBit(kIsTPCConstrained); }
Bool_t IsGlobalConstrained() const { return TestBit(kIsGlobalConstrained); }
Int_t GetTOFBunchCrossing(Double_t b=0, Bool_t tpcPIDonly=kFALSE) const;
using AliVTrack::GetP;
template <typename T> void GetP(T *p) const {
p[0]=fMomentum[0]; p[1]=fMomentum[1]; p[2]=fMomentum[2];}
Bool_t GetPxPyPz(Double_t *p) const;
template <typename T> Bool_t GetPosition(T *x) const {
x[0]=fPosition[0]; x[1]=fPosition[1]; x[2]=fPosition[2];
return TestBit(kIsDCA);}
template <typename T> void SetCovMatrix(const T *covMatrix) {
if(!fCovMatrix) fCovMatrix=new AliAODRedCov<6>();
fCovMatrix->SetCovMatrix(covMatrix);}
template <typename T> Bool_t GetCovMatrix(T *covMatrix) const {
if(!fCovMatrix) return kFALSE;
fCovMatrix->GetCovMatrix(covMatrix); return kTRUE;}
Bool_t GetXYZ(Double_t *p) const {
return GetPosition(p); }
Bool_t GetXYZAt(Double_t x, Double_t b, Double_t *r) const;
Bool_t GetXYZatR(Double_t xr,Double_t bz, Double_t *xyz=0, Double_t* alpSect=0) const;
Bool_t GetCovarianceXYZPxPyPz(Double_t cv[21]) const {
return GetCovMatrix(cv);}
void RemoveCovMatrix() {delete fCovMatrix; fCovMatrix=NULL;}
Double_t XAtDCA() const { return fPositionAtDCA[0]; }
Double_t YAtDCA() const { return fPositionAtDCA[1]; }
Double_t ZAtDCA() const {
if (IsMuonTrack()) return fPosition[2];
else if (TestBit(kIsDCA)) return fPosition[1];
else return -999.; }
Bool_t XYZAtDCA(Double_t x[3]) const { x[0] = XAtDCA(); x[1] = YAtDCA(); x[2] = ZAtDCA(); return kTRUE; }
Double_t DCA() const {
if (IsMuonTrack()) return TMath::Sqrt(XAtDCA()*XAtDCA() + YAtDCA()*YAtDCA());
else if (TestBit(kIsDCA)) return fPosition[0];
else return -999.; }
Double_t PxAtDCA() const { return fMomentumAtDCA[0]; }
Double_t PyAtDCA() const { return fMomentumAtDCA[1]; }
Double_t PzAtDCA() const { return fMomentumAtDCA[2]; }
Double_t PAtDCA() const { return TMath::Sqrt(PxAtDCA()*PxAtDCA() + PyAtDCA()*PyAtDCA() + PzAtDCA()*PzAtDCA()); }
Bool_t PxPyPzAtDCA(Double_t p[3]) const { p[0] = PxAtDCA(); p[1] = PyAtDCA(); p[2] = PzAtDCA(); return kTRUE; }
Double_t GetRAtAbsorberEnd() const { return fRAtAbsorberEnd; }
UChar_t GetITSClusterMap() const { return (UChar_t)(fITSMuonClusterMap&0xff); }
Int_t GetITSNcls() const;
Bool_t HasPointOnITSLayer(Int_t i) const { return TESTBIT(GetITSClusterMap(),i); }
UShort_t GetHitsPatternInTrigCh() const { return (UShort_t)((fITSMuonClusterMap&0xff00)>>8); }
UInt_t GetMUONClusterMap() const { return (fITSMuonClusterMap&0x3ff0000)>>16; }
UInt_t GetITSMUONClusterMap() const { return fITSMuonClusterMap; }
Bool_t TestFilterBit(UInt_t filterBit) const {return (Bool_t) ((filterBit & fFilterMap) != 0);}
Bool_t TestFilterMask(UInt_t filterMask) const {return (Bool_t) ((filterMask & fFilterMap) == filterMask);}
void SetFilterMap(UInt_t i){fFilterMap = i;}
UInt_t GetFilterMap() const {return fFilterMap;}
const TBits& GetTPCClusterMap() const {return fTPCClusterMap;}
const TBits* GetTPCClusterMapPtr() const {return &fTPCClusterMap;}
const TBits& GetTPCFitMap() const {return fTPCFitMap;}
const TBits* GetTPCFitMapPtr() const {return &fTPCFitMap;}
Float_t GetTPCClusterInfo(Int_t nNeighbours=3, Int_t type=0, Int_t row0=0, Int_t row1=159, Int_t =0) const;
const TBits& GetTPCSharedMap() const {return fTPCSharedMap;}
const TBits* GetTPCSharedMapPtr() const {return &fTPCSharedMap;}
void SetTPCClusterMap(const TBits amap) {fTPCClusterMap = amap;}
void SetTPCSharedMap(const TBits amap) {fTPCSharedMap = amap;}
void SetTPCFitMap(const TBits amap) {fTPCFitMap = amap;}
void SetTPCPointsF(UShort_t findable){fTPCnclsF = findable;}
void SetTPCNCrossedRows(UInt_t n) {fTPCNCrossedRows = n;}
virtual const AliExternalTrackParam * GetInnerParam() const { return NULL; }
virtual const AliExternalTrackParam * GetOuterParam() const { return NULL; }
UShort_t GetTPCNclsF() const { return fTPCnclsF;}
UShort_t GetTPCNCrossedRows() const { return fTPCNCrossedRows;}
Float_t GetTPCFoundFraction() const { return fTPCNCrossedRows>0 ? float(GetTPCNcls())/fTPCNCrossedRows : 0;}
Int_t GetEMCALcluster() const {return fCaloIndex;}
void SetEMCALcluster(Int_t index) {fCaloIndex=index;}
Bool_t IsEMCAL() const {return fFlags&kEMCALmatch;}
Double_t GetTrackPhiOnEMCal() const {return fTrackPhiOnEMCal;}
Double_t GetTrackEtaOnEMCal() const {return fTrackEtaOnEMCal;}
Double_t GetTrackPtOnEMCal() const {return fTrackPtOnEMCal;}
Double_t GetTrackPOnEMCal() const {return TMath::Abs(fTrackEtaOnEMCal) < 1 ? fTrackPtOnEMCal*TMath::CosH(fTrackEtaOnEMCal) : -999;}
void SetTrackPhiEtaPtOnEMCal(Double_t phi,Double_t eta,Double_t pt) {fTrackPhiOnEMCal=phi;fTrackEtaOnEMCal=eta;fTrackPtOnEMCal=pt;}
Int_t GetPHOScluster() const {return fCaloIndex;}
void SetPHOScluster(Int_t index) {fCaloIndex=index;}
Bool_t IsPHOS() const {return fFlags&kPHOSmatch;}
Double_t GetITSsignal() const { return fDetPid?fDetPid->GetITSsignal():0.; }
void GetITSdEdxSamples(Double_t s[4]) const;
Double_t GetTPCsignal() const { return fDetPid?fDetPid->GetTPCsignal():0.; }
Double_t GetTPCsignalTunedOnData() const { return fTPCsignalTuned;}
void SetTPCsignalTunedOnData(Double_t signal) {fTPCsignalTuned = signal;}
UShort_t GetTPCsignalN() const { return fDetPid?fDetPid->GetTPCsignalN():0; }
virtual AliTPCdEdxInfo* GetTPCdEdxInfo() const {return fDetPid?fDetPid->GetTPCdEdxInfo():0;}
Double_t GetTPCmomentum() const { return fDetPid?fDetPid->GetTPCmomentum():0.; }
Double_t GetTPCTgl() const { return fDetPid?fDetPid->GetTPCTgl():0.; }
Double_t GetTOFsignal() const { return fDetPid?fDetPid->GetTOFsignal():0.; }
Double_t GetIntegratedLength() const { return fTrackLength;}
void SetIntegratedLength(Double_t l) {fTrackLength = l;}
Double_t GetTOFsignalTunedOnData() const { return fTOFsignalTuned;}
void SetTOFsignalTunedOnData(Double_t signal) {fTOFsignalTuned = signal;}
Double_t GetHMPIDsignal() const;
Double_t GetHMPIDoccupancy() const;
Int_t GetHMPIDcluIdx() const;
void GetHMPIDtrk(Float_t &x, Float_t &y, Float_t &th, Float_t &ph) const;
void GetHMPIDmip(Float_t &x,Float_t &y,Int_t &q,Int_t &nph) const;
Bool_t GetOuterHmpPxPyPz(Double_t *p) const;
void GetIntegratedTimes(Double_t *times, Int_t nspec=AliPID::kSPECIES) const {if (fDetPid) fDetPid->GetIntegratedTimes(times, nspec);}
Double_t GetTRDslice(Int_t plane, Int_t slice) const;
Double_t GetTRDsignal() const {return fDetPid ? fDetPid->GetTRDsignal() : 0;}
Double_t GetTRDmomentum(Int_t plane, Double_t *=0x0) const;
Double_t GetTRDchi2() const {return fDetPid ? fDetPid->GetTRDChi2() : -1;}
UChar_t GetTRDncls(Int_t layer) const;
UChar_t GetTRDncls() const {return GetTRDncls(-1);}
UChar_t GetTRDntrackletsPID() const;
Int_t GetNumberOfTRDslices() const { return fDetPid?fDetPid->GetTRDnSlices():0; }
void GetHMPIDpid(Double_t *) const { return; }
void SetMFTClusterPattern(ULong_t mftClusterPattern) { fMFTClusterPattern = mftClusterPattern; }
ULong_t GetMFTClusterPattern() { return fMFTClusterPattern; }
const AliAODEvent* GetAODEvent() const {return fAODEvent;}
virtual const AliVEvent* GetEvent() const {return (AliVEvent*)fAODEvent;}
void SetAODEvent(const AliAODEvent* ptr){fAODEvent = ptr;}
const AliTOFHeader* GetTOFHeader() const;
AliAODPid *GetDetPid() const { return fDetPid; }
AliAODVertex *GetProdVertex() const { return (AliAODVertex*)fProdVertex.GetObject(); }
void Print(const Option_t *opt = "") const;
void SetFlags(ULong_t flags) { fFlags = flags; }
void SetStatus(ULong_t flags) { fFlags|=flags; }
void ResetStatus(ULong_t flags) { fFlags&=~flags; }
void SetID(Short_t id) { fID = id; }
void SetLabel(Int_t label) { fLabel = label; }
void SetTOFLabel(const Int_t* p);
template <typename T> void SetPosition(const T *x, Bool_t isDCA = kFALSE);
void SetDCA(Double_t d, Double_t z);
void SetUsedForVtxFit(Bool_t used = kTRUE) { used ? SetBit(kUsedForVtxFit) : ResetBit(kUsedForVtxFit); }
void SetUsedForPrimVtxFit(Bool_t used = kTRUE) { used ? SetBit(kUsedForPrimVtxFit) : ResetBit(kUsedForPrimVtxFit); }
void SetIsTPCOnly(Bool_t b = kTRUE) { SetIsTPCConstrained(b); }
void SetIsTPCConstrained(Bool_t b = kTRUE) { b ? SetBit(kIsTPCConstrained) : ResetBit(kIsTPCConstrained); }
void SetIsHybridTPCConstrainedGlobal(Bool_t hybrid = kTRUE) { hybrid ? SetBit(kIsHybridTPCCG) : ResetBit(kIsHybridTPCCG); }
void SetIsGlobalConstrained(Bool_t b = kTRUE) { b ? SetBit(kIsGlobalConstrained) : ResetBit(kIsGlobalConstrained); }
void SetIsHybridGlobalConstrainedGlobal(Bool_t hybrid = kTRUE) { hybrid ? SetBit(kIsHybridGCG) : ResetBit(kIsHybridGCG); }
void SetOneOverPt(Double_t oneOverPt) { fMomentum[0] = 1. / oneOverPt; }
void SetPt(Double_t pt) { fMomentum[0] = pt; };
void SetPhi(Double_t phi) { fMomentum[1] = phi; }
void SetTheta(Double_t theta) { fMomentum[2] = theta; }
template <typename T> void SetP(const T *p, Bool_t cartesian = kTRUE);
void SetP() {fMomentum[0]=fMomentum[1]=fMomentum[2]=-999.;}
void SetXYAtDCA(Double_t x, Double_t y) {fPositionAtDCA[0] = x; fPositionAtDCA[1] = y;}
void SetPxPyPzAtDCA(Double_t pX, Double_t pY, Double_t pZ) {fMomentumAtDCA[0] = pX; fMomentumAtDCA[1] = pY; fMomentumAtDCA[2] = pZ;}
void SetRAtAbsorberEnd(Double_t r) { fRAtAbsorberEnd = r; }
void SetCharge(Short_t q) { fCharge = q; }
void SetChi2perNDF(Double_t chi2perNDF) { fChi2perNDF = chi2perNDF; }
void SetITSClusterMap(UChar_t itsClusMap) { fITSMuonClusterMap = (fITSMuonClusterMap&0xffffff00)|(((UInt_t)itsClusMap)&0xff); }
void SetHitsPatternInTrigCh(UShort_t hitsPatternInTrigCh) { fITSMuonClusterMap = (fITSMuonClusterMap&0xffff00ff)|((((UInt_t)hitsPatternInTrigCh)&0xff)<<8); }
void SetMuonClusterMap(UInt_t muonClusMap) { fITSMuonClusterMap = (fITSMuonClusterMap&0xfc00ffff)|((muonClusMap&0x3ff)<<16); }
void SetITSMuonClusterMap(UInt_t itsMuonClusMap) { fITSMuonClusterMap = itsMuonClusMap; }
void SetMUONtrigHitsMapTrg(UInt_t muonTrigHitsMap) { fMUONtrigHitsMapTrg = muonTrigHitsMap; }
UInt_t GetMUONTrigHitsMapTrg() const { return fMUONtrigHitsMapTrg; }
void SetMUONtrigHitsMapTrk(UInt_t muonTrigHitsMap) { fMUONtrigHitsMapTrk = muonTrigHitsMap; }
UInt_t GetMUONTrigHitsMapTrk() const { return fMUONtrigHitsMapTrk; }
Int_t GetMuonTrigDevSign() const;
Int_t GetMatchTrigger() const {return fITSMuonClusterMap>>30;}
void SetMatchTrigger(Int_t MatchTrigger);
Bool_t MatchTrigger() const { return (GetMatchTrigger()>0); }
Bool_t MatchTriggerLowPt() const { return (GetMatchTrigger()>1); }
Bool_t MatchTriggerHighPt() const { return (GetMatchTrigger()>2); }
Bool_t MatchTriggerDigits() const;
Double_t GetChi2MatchTrigger() const { return fChi2MatchTrigger;}
void SetChi2MatchTrigger(Double_t Chi2MatchTrigger) {fChi2MatchTrigger = Chi2MatchTrigger; }
Bool_t HitsMuonChamber(Int_t MuonChamber, Int_t cathode = -1) const;
Bool_t IsMuonTrack() const { return ( (GetMUONClusterMap()>0) && !fIsMuonGlobalTrack ) ? kTRUE : kFALSE; }
Bool_t IsMuonGlobalTrack() const { return fIsMuonGlobalTrack; }
void SetIsMuonGlobalTrack(Bool_t isMuonGlobalTrack) { fIsMuonGlobalTrack = isMuonGlobalTrack; }
void Connected(Bool_t flag) {flag ? SETBIT(fITSMuonClusterMap,26) : CLRBIT(fITSMuonClusterMap,26);}
Bool_t IsConnected() const {return TESTBIT(fITSMuonClusterMap,26);}
void SetProdVertex(TObject *vertex) { fProdVertex = vertex; }
void SetType(AODTrk_t ttype) { fType=ttype; }
virtual void SetDetectorPID(const AliDetectorPID *pid);
virtual const AliDetectorPID* GetDetectorPID() const { return fDetectorPID; }
Int_t PdgCode() const {return 0;}
private :
Double32_t fMomentum[3];
Double32_t fPosition[3];
Double32_t fMomentumAtDCA[3];
Double32_t fPositionAtDCA[2];
Double32_t fRAtAbsorberEnd;
Double32_t fChi2perNDF;
Double32_t fChi2MatchTrigger;
Double32_t* fPID;
ULong_t fFlags;
Int_t fLabel;
Int_t fTOFLabel[3];
Double32_t fTrackLength;
UInt_t fITSMuonClusterMap;
UInt_t fMUONtrigHitsMapTrg;
UInt_t fMUONtrigHitsMapTrk;
UInt_t fFilterMap;
TBits fTPCFitMap;
TBits fTPCClusterMap;
TBits fTPCSharedMap;
UShort_t fTPCnclsF;
UShort_t fTPCNCrossedRows;
Short_t fID;
Char_t fCharge;
Char_t fType;
Char_t fPIDForTracking;
Int_t fCaloIndex;
AliAODRedCov<6> *fCovMatrix;
AliAODPid *fDetPid;
mutable const AliDetectorPID* fDetectorPID;
TRef fProdVertex;
Double_t fTrackPhiOnEMCal;
Double_t fTrackEtaOnEMCal;
Double_t fTrackPtOnEMCal;
Bool_t fIsMuonGlobalTrack;
Double_t fTPCsignalTuned;
Double_t fTOFsignalTuned;
ULong_t fMFTClusterPattern;
const AliAODEvent* fAODEvent;
virtual Int_t GetTrackParam ( AliExternalTrackParam &p ) const;
virtual Int_t GetTrackParamRefitted ( AliExternalTrackParam &p ) const;
virtual Int_t GetTrackParamIp ( AliExternalTrackParam &p ) const;
virtual Int_t GetTrackParamTPCInner ( AliExternalTrackParam &p ) const;
virtual Int_t GetTrackParamOp ( AliExternalTrackParam &p ) const;
virtual Int_t GetTrackParamCp ( AliExternalTrackParam &p ) const;
virtual Int_t GetTrackParamITSOut ( AliExternalTrackParam &p ) const;
ClassDef(AliAODTrack, 24);
};
inline Bool_t AliAODTrack::IsPrimaryCandidate() const
{
if (fFilterMap) {
return kTRUE;
} else {
return kFALSE;
}
}
inline Int_t AliAODTrack::GetITSNcls() const
{
Int_t n=0;
for(Int_t i=0;i<6;i++) if(HasPointOnITSLayer(i)) n++;
return n;
}
template <typename T>
void AliAODTrack::SetPosition(const T *x, const Bool_t dca)
{
if (x) {
if (!dca) {
ResetBit(kIsDCA);
fPosition[0] = x[0];
fPosition[1] = x[1];
fPosition[2] = x[2];
} else {
SetBit(kIsDCA);
fPosition[0] = -999.;
fPosition[1] = -999.;
fPosition[2] = -999.;
}
} else {
ResetBit(kIsDCA);
fPosition[0] = -999.;
fPosition[1] = -999.;
fPosition[2] = -999.;
}
}
#endif