#include <TMath.h>
#include <TParticle.h>
#include <TDatabasePDG.h>
#include <TMatrixD.h>
#include "AliESDVertex.h"
#include "AliESDtrack.h"
#include "AliESDEvent.h"
#include "AliKalmanTrack.h"
#include "AliVTrack.h"
#include "AliLog.h"
#include "AliTrackPointArray.h"
#include "TPolyMarker3D.h"
#include "AliTrackerBase.h"
#include "AliTPCdEdxInfo.h"
#include "AliDetectorPID.h"
#include "TTreeStream.h"
#include "TObjArray.h"
ClassImp(AliESDtrack)
void SetPIDValues(Double_t * dest, const Double_t * src, Int_t n) {
if (n<=0) return;
Float_t uniform = 1./(Float_t)n;
Float_t sum = 0;
for (Int_t i=0; i<n; i++)
if (src[i]>=0) {
sum+=src[i];
dest[i] = src[i];
}
else {
dest[i] = 0;
}
if(sum>0)
for (Int_t i=0; i<n; i++) dest[i] /= sum;
else
for (Int_t i=0; i<n; i++) dest[i] = uniform;
}
AliESDtrack::AliESDtrack() :
AliExternalTrackParam(),
fCp(0),
fIp(0),
fTPCInner(0),
fOp(0),
fHMPIDp(0),
fFriendTrack(NULL),
fTPCFitMap(159),
fTPCClusterMap(159),
fTPCSharedMap(159),
fFlags(0),
fID(0),
fLabel(0),
fITSLabel(0),
fTPCLabel(0),
fTRDLabel(0),
fTOFLabel(NULL),
fTOFCalChannel(-1),
fTOFindex(-1),
fHMPIDqn(0),
fHMPIDcluIdx(-1),
fCaloIndex(kEMCALNoMatch),
fR(0),
fITSr(0),
fTPCr(0),
fTRDr(0),
fTOFr(0),
fHMPIDr(0),
fHMPIDtrkTheta(0),
fHMPIDtrkPhi(0),
fHMPIDsignal(0),
fTrackTime(0),
fTrackLength(0),
fdTPC(0),fzTPC(0),
fCddTPC(0),fCdzTPC(0),fCzzTPC(0),
fCchi2TPC(0),
fD(0),fZ(0),
fCdd(0),fCdz(0),fCzz(0),
fCchi2(0),
fITSchi2(0),
fTPCchi2(0),
fTPCchi2Iter1(0),
fTRDchi2(0),
fTOFchi2(0),
fHMPIDchi2(0),
fGlobalChi2(0),
fITSsignal(0),
fTPCsignal(0),
fTPCsignalTuned(0),
fTPCsignalS(0),
fTPCdEdxInfo(0),
fTRDsignal(0),
fTRDQuality(0),
fTRDBudget(0),
fTOFsignal(99999),
fTOFsignalTuned(99999),
fTOFsignalToT(99999),
fTOFsignalRaw(99999),
fTOFsignalDz(999),
fTOFsignalDx(999),
fTOFdeltaBC(999),
fTOFl0l1(999),
fCaloDx(0),
fCaloDz(0),
fHMPIDtrkX(0),
fHMPIDtrkY(0),
fHMPIDmipX(0),
fHMPIDmipY(0),
fTPCncls(0),
fTPCnclsF(0),
fTPCsignalN(0),
fTPCnclsIter1(0),
fTPCnclsFIter1(0),
fITSncls(0),
fITSClusterMap(0),
fITSSharedMap(0),
fTRDncls(0),
fTRDncls0(0),
fTRDntracklets(0),
fTRDNchamberdEdx(0),
fTRDNclusterdEdx(0),
fTRDnSlices(0),
fTRDslices(0x0),
fVertexID(-2),
fPIDForTracking(AliPID::kPion),
fESDEvent(0),
fCacheNCrossedRows(-10),
fCacheChi2TPCConstrainedVsGlobal(-10),
fCacheChi2TPCConstrainedVsGlobalVertex(0),
fDetectorPID(0x0),
fTrackPhiOnEMCal(-999),
fTrackEtaOnEMCal(-999),
fTrackPtOnEMCal(-999),
fNtofClusters(0),
fTOFcluster(NULL)
{
if (!OnlineMode()) fFriendTrack=new AliESDfriendTrack();
Int_t i;
for (i=kNITSchi2Std;i--;) fITSchi2Std[i] = 0;
for (i=0; i<3; i++) { fKinkIndexes[i]=0;}
for (i=0; i<3; i++) { fV0Indexes[i]=0;}
for (i=0;i<kTRDnPlanes;i++) {
fTRDTimBin[i]=0;
}
for (i=0;i<4;i++) {fITSdEdxSamples[i]=0.;}
for (i=0;i<4;i++) {fTPCPoints[i]=0;}
for (i=0;i<10;i++) {fTOFInfo[i]=0;}
for (i=0;i<12;i++) {fITSModule[i]=-1;}
}
bool AliESDtrack::fgkOnlineMode=false;
AliESDtrack::AliESDtrack(const AliESDtrack& track):
AliExternalTrackParam(track),
fCp(0),
fIp(0),
fTPCInner(0),
fOp(0),
fHMPIDp(0),
fFriendTrack(0),
fTPCFitMap(track.fTPCFitMap),
fTPCClusterMap(track.fTPCClusterMap),
fTPCSharedMap(track.fTPCSharedMap),
fFlags(track.fFlags),
fID(track.fID),
fLabel(track.fLabel),
fITSLabel(track.fITSLabel),
fTPCLabel(track.fTPCLabel),
fTRDLabel(track.fTRDLabel),
fTOFLabel(NULL),
fTOFCalChannel(track.fTOFCalChannel),
fTOFindex(track.fTOFindex),
fHMPIDqn(track.fHMPIDqn),
fHMPIDcluIdx(track.fHMPIDcluIdx),
fCaloIndex(track.fCaloIndex),
fR(0),
fITSr(0),
fTPCr(0),
fTRDr(0),
fTOFr(0),
fHMPIDr(0),
fHMPIDtrkTheta(track.fHMPIDtrkTheta),
fHMPIDtrkPhi(track.fHMPIDtrkPhi),
fHMPIDsignal(track.fHMPIDsignal),
fTrackTime(NULL),
fTrackLength(track.fTrackLength),
fdTPC(track.fdTPC),fzTPC(track.fzTPC),
fCddTPC(track.fCddTPC),fCdzTPC(track.fCdzTPC),fCzzTPC(track.fCzzTPC),
fCchi2TPC(track.fCchi2TPC),
fD(track.fD),fZ(track.fZ),
fCdd(track.fCdd),fCdz(track.fCdz),fCzz(track.fCzz),
fCchi2(track.fCchi2),
fITSchi2(track.fITSchi2),
fTPCchi2(track.fTPCchi2),
fTPCchi2Iter1(track.fTPCchi2Iter1),
fTRDchi2(track.fTRDchi2),
fTOFchi2(track.fTOFchi2),
fHMPIDchi2(track.fHMPIDchi2),
fGlobalChi2(track.fGlobalChi2),
fITSsignal(track.fITSsignal),
fTPCsignal(track.fTPCsignal),
fTPCsignalTuned(track.fTPCsignalTuned),
fTPCsignalS(track.fTPCsignalS),
fTPCdEdxInfo(0),
fTRDsignal(track.fTRDsignal),
fTRDQuality(track.fTRDQuality),
fTRDBudget(track.fTRDBudget),
fTOFsignal(track.fTOFsignal),
fTOFsignalTuned(track.fTOFsignalTuned),
fTOFsignalToT(track.fTOFsignalToT),
fTOFsignalRaw(track.fTOFsignalRaw),
fTOFsignalDz(track.fTOFsignalDz),
fTOFsignalDx(track.fTOFsignalDx),
fTOFdeltaBC(track.fTOFdeltaBC),
fTOFl0l1(track.fTOFl0l1),
fCaloDx(track.fCaloDx),
fCaloDz(track.fCaloDz),
fHMPIDtrkX(track.fHMPIDtrkX),
fHMPIDtrkY(track.fHMPIDtrkY),
fHMPIDmipX(track.fHMPIDmipX),
fHMPIDmipY(track.fHMPIDmipY),
fTPCncls(track.fTPCncls),
fTPCnclsF(track.fTPCnclsF),
fTPCsignalN(track.fTPCsignalN),
fTPCnclsIter1(track.fTPCnclsIter1),
fTPCnclsFIter1(track.fTPCnclsIter1),
fITSncls(track.fITSncls),
fITSClusterMap(track.fITSClusterMap),
fITSSharedMap(track.fITSSharedMap),
fTRDncls(track.fTRDncls),
fTRDncls0(track.fTRDncls0),
fTRDntracklets(track.fTRDntracklets),
fTRDNchamberdEdx(track.fTRDNchamberdEdx),
fTRDNclusterdEdx(track.fTRDNclusterdEdx),
fTRDnSlices(track.fTRDnSlices),
fTRDslices(0x0),
fVertexID(track.fVertexID),
fPIDForTracking(AliPID::kPion),
fESDEvent(track.fESDEvent),
fCacheNCrossedRows(track.fCacheNCrossedRows),
fCacheChi2TPCConstrainedVsGlobal(track.fCacheChi2TPCConstrainedVsGlobal),
fCacheChi2TPCConstrainedVsGlobalVertex(track.fCacheChi2TPCConstrainedVsGlobalVertex),
fDetectorPID(0x0),
fTrackPhiOnEMCal(track.fTrackPhiOnEMCal),
fTrackEtaOnEMCal(track.fTrackEtaOnEMCal),
fTrackPtOnEMCal(track.fTrackPtOnEMCal),
fNtofClusters(track.fNtofClusters),
fTOFcluster(NULL)
{
for (Int_t i=kNITSchi2Std;i--;) fITSchi2Std[i] = track.fITSchi2Std[i];
if(track.fTrackTime){
fTrackTime = new Double32_t[AliPID::kSPECIESC];
for (Int_t i=0;i<AliPID::kSPECIESC;i++) fTrackTime[i]=track.fTrackTime[i];
}
if (track.fR) {
fR = new Double32_t[AliPID::kSPECIES];
for (Int_t i=AliPID::kSPECIES;i--;) fR[i]=track.fR[i];
}
if (track.fITSr) {
fITSr = new Double32_t[AliPID::kSPECIES];
for (Int_t i=AliPID::kSPECIES;i--;) fITSr[i]=track.fITSr[i];
}
if (track.fTPCr) {
fTPCr = new Double32_t[AliPID::kSPECIES];
for (Int_t i=AliPID::kSPECIES;i--;) fTPCr[i]=track.fTPCr[i];
}
for (Int_t i=0;i<4;i++) {fITSdEdxSamples[i]=track.fITSdEdxSamples[i];}
for (Int_t i=0;i<4;i++) {fTPCPoints[i]=track.fTPCPoints[i];}
for (Int_t i=0; i<3;i++) { fKinkIndexes[i]=track.fKinkIndexes[i];}
for (Int_t i=0; i<3;i++) { fV0Indexes[i]=track.fV0Indexes[i];}
for (Int_t i=0;i<kTRDnPlanes;i++) {
fTRDTimBin[i]=track.fTRDTimBin[i];
}
if (fTRDnSlices) {
fTRDslices=new Double32_t[fTRDnSlices];
for (Int_t i=0; i<fTRDnSlices; i++) fTRDslices[i]=track.fTRDslices[i];
}
if (track.fDetectorPID) fDetectorPID = new AliDetectorPID(*track.fDetectorPID);
if (track.fTRDr) {
fTRDr = new Double32_t[AliPID::kSPECIES];
for (Int_t i=AliPID::kSPECIES;i--;) fTRDr[i]=track.fTRDr[i];
}
if (track.fTOFr) {
fTOFr = new Double32_t[AliPID::kSPECIES];
for (Int_t i=AliPID::kSPECIES;i--;) fTOFr[i]=track.fTOFr[i];
}
if(track.fTOFLabel){
if(!fTOFLabel) fTOFLabel = new Int_t[3];
for (Int_t i=0;i<3;i++) fTOFLabel[i]=track.fTOFLabel[i];
}
for (Int_t i=0;i<10;i++) fTOFInfo[i]=track.fTOFInfo[i];
for (Int_t i=0;i<12;i++) fITSModule[i]=track.fITSModule[i];
if (track.fHMPIDr) {
fHMPIDr = new Double32_t[AliPID::kSPECIES];
for (Int_t i=AliPID::kSPECIES;i--;) fHMPIDr[i]=track.fHMPIDr[i];
}
if (track.fCp) fCp=new AliExternalTrackParam(*track.fCp);
if (track.fIp) fIp=new AliExternalTrackParam(*track.fIp);
if (track.fTPCInner) fTPCInner=new AliExternalTrackParam(*track.fTPCInner);
if (track.fOp) fOp=new AliExternalTrackParam(*track.fOp);
if (track.fHMPIDp) fHMPIDp=new AliExternalTrackParam(*track.fHMPIDp);
if (track.fTPCdEdxInfo) fTPCdEdxInfo = new AliTPCdEdxInfo(*track.fTPCdEdxInfo);
if (track.fFriendTrack) fFriendTrack=new AliESDfriendTrack(*(track.fFriendTrack));
if(fNtofClusters > 0){
fTOFcluster = new Int_t[fNtofClusters];
for(Int_t i=0;i < fNtofClusters;i++) fTOFcluster[i] = track.fTOFcluster[i];
}
}
AliESDtrack::AliESDtrack(const AliVTrack *track) :
AliExternalTrackParam(track),
fCp(0),
fIp(0),
fTPCInner(0),
fOp(0),
fHMPIDp(0),
fFriendTrack(0),
fTPCFitMap(159),
fTPCClusterMap(159),
fTPCSharedMap(159),
fFlags(0),
fID(),
fLabel(0),
fITSLabel(0),
fTPCLabel(0),
fTRDLabel(0),
fTOFLabel(NULL),
fTOFCalChannel(-1),
fTOFindex(-1),
fHMPIDqn(0),
fHMPIDcluIdx(-1),
fCaloIndex(kEMCALNoMatch),
fR(0),
fITSr(0),
fTPCr(0),
fTRDr(0),
fTOFr(0),
fHMPIDr(0),
fHMPIDtrkTheta(0),
fHMPIDtrkPhi(0),
fHMPIDsignal(0),
fTrackTime(NULL),
fTrackLength(0),
fdTPC(0),fzTPC(0),
fCddTPC(0),fCdzTPC(0),fCzzTPC(0),
fCchi2TPC(0),
fD(0),fZ(0),
fCdd(0),fCdz(0),fCzz(0),
fCchi2(0),
fITSchi2(0),
fTPCchi2(0),
fTPCchi2Iter1(0),
fTRDchi2(0),
fTOFchi2(0),
fHMPIDchi2(0),
fGlobalChi2(0),
fITSsignal(0),
fTPCsignal(0),
fTPCsignalTuned(0),
fTPCsignalS(0),
fTPCdEdxInfo(0),
fTRDsignal(0),
fTRDQuality(0),
fTRDBudget(0),
fTOFsignal(99999),
fTOFsignalTuned(99999),
fTOFsignalToT(99999),
fTOFsignalRaw(99999),
fTOFsignalDz(999),
fTOFsignalDx(999),
fTOFdeltaBC(999),
fTOFl0l1(999),
fCaloDx(0),
fCaloDz(0),
fHMPIDtrkX(0),
fHMPIDtrkY(0),
fHMPIDmipX(0),
fHMPIDmipY(0),
fTPCncls(0),
fTPCnclsF(0),
fTPCsignalN(0),
fTPCnclsIter1(0),
fTPCnclsFIter1(0),
fITSncls(0),
fITSClusterMap(0),
fITSSharedMap(0),
fTRDncls(0),
fTRDncls0(0),
fTRDntracklets(0),
fTRDNchamberdEdx(0),
fTRDNclusterdEdx(0),
fTRDnSlices(0),
fTRDslices(0x0),
fVertexID(-2),
fPIDForTracking(track->GetPIDForTracking()),
fESDEvent(0),
fCacheNCrossedRows(-10),
fCacheChi2TPCConstrainedVsGlobal(-10),
fCacheChi2TPCConstrainedVsGlobalVertex(0),
fDetectorPID(0x0),
fTrackPhiOnEMCal(-999),
fTrackEtaOnEMCal(-999),
fTrackPtOnEMCal(-999),
fNtofClusters(0),
fTOFcluster(NULL)
{
if (track->InheritsFrom("AliExternalTrackParam")) {
AliError("This is not a copy constructor. Use AliESDtrack(const AliESDtrack &) !");
AliWarning("Calling the default constructor...");
AliESDtrack();
return;
}
Int_t i;
for (i=kNITSchi2Std;i--;) fITSchi2Std[i] = 0;
for (i=0; i<3; i++) { fKinkIndexes[i]=0;}
for (i=0; i<3; i++) { fV0Indexes[i]=-1;}
for (i=0;i<kTRDnPlanes;i++) {
fTRDTimBin[i]=0;
}
for (i=0;i<4;i++) {fITSdEdxSamples[i]=0.;}
for (i=0;i<4;i++) {fTPCPoints[i]=0;}
for (i=0;i<10;i++) {fTOFInfo[i]=0;}
for (i=0;i<12;i++) {fITSModule[i]=-1;}
fITSClusterMap=track->GetITSClusterMap();
fITSSharedMap=0;
fITSncls=0;
for(i=0; i<6; i++) {
if(HasPointOnITSLayer(i)) fITSncls++;
}
fTPCncls=track->GetTPCNcls();
fTPCnclsF=track->GetTPCNclsF();
const TBits* bmap = track->GetTPCClusterMapPtr();
if (bmap) SetTPCClusterMap(*bmap);
bmap = GetTPCFitMapPtr();
if (bmap) SetTPCFitMap(*bmap);
bmap = GetTPCSharedMapPtr();
if (bmap) SetTPCSharedMap(*bmap);
const Double_t *pid = track->PID();
if(pid) {
fR = new Double32_t[AliPID::kSPECIES];
for (i=AliPID::kSPECIES; i--;) fR[i]=pid[i];
}
SetEMCALcluster(track->GetEMCALcluster());
fITSsignal = track->GetITSsignal();
double itsdEdx[4];
track->GetITSdEdxSamples(itsdEdx);
SetITSdEdxSamples(itsdEdx);
SetTPCsignal(track->GetTPCsignal(),fTPCsignalS,track->GetTPCsignalN());
AliTPCdEdxInfo * dEdxInfo = track->GetTPCdEdxInfo();
if (dEdxInfo) SetTPCdEdxInfo(new AliTPCdEdxInfo(*dEdxInfo));
SetTRDsignal(track->GetTRDsignal());
int ntrdsl = track->GetNumberOfTRDslices();
if (ntrdsl>0) {
SetNumberOfTRDslices((ntrdsl+2)*kTRDnPlanes);
for (int ipl=kTRDnPlanes;ipl--;){
for (int isl=ntrdsl;isl--;) SetTRDslice(track->GetTRDslice(ipl,isl),ipl,isl);
Double_t sp, p = track->GetTRDmomentum(ipl, &sp);
SetTRDmomentum(p, ipl, &sp);
}
}
fTRDncls = track->GetTRDncls();
fTRDntracklets &= 0xff & track->GetTRDntrackletsPID();
fTRDchi2 = track->GetTRDchi2();
SetTOFsignal(track->GetTOFsignal());
Double_t expt[AliPID::kSPECIESC];
track->GetIntegratedTimes(expt,AliPID::kSPECIESC);
SetIntegratedTimes(expt);
SetTrackPhiEtaPtOnEMCal(track->GetTrackPhiOnEMCal(),track->GetTrackEtaOnEMCal(),track->GetTrackPtOnEMCal());
SetLabel(track->GetLabel());
SetStatus(track->GetStatus());
SetID(track->GetID());
}
AliESDtrack::AliESDtrack(TParticle * part) :
AliExternalTrackParam(),
fCp(0),
fIp(0),
fTPCInner(0),
fOp(0),
fHMPIDp(0),
fFriendTrack(0),
fTPCFitMap(159),
fTPCClusterMap(159),
fTPCSharedMap(159),
fFlags(0),
fID(0),
fLabel(0),
fITSLabel(0),
fTPCLabel(0),
fTRDLabel(0),
fTOFLabel(NULL),
fTOFCalChannel(-1),
fTOFindex(-1),
fHMPIDqn(0),
fHMPIDcluIdx(-1),
fCaloIndex(kEMCALNoMatch),
fR(0),
fITSr(0),
fTPCr(0),
fTRDr(0),
fTOFr(0),
fHMPIDr(0),
fHMPIDtrkTheta(0),
fHMPIDtrkPhi(0),
fHMPIDsignal(0),
fTrackTime(NULL),
fTrackLength(0),
fdTPC(0),fzTPC(0),
fCddTPC(0),fCdzTPC(0),fCzzTPC(0),
fCchi2TPC(0),
fD(0),fZ(0),
fCdd(0),fCdz(0),fCzz(0),
fCchi2(0),
fITSchi2(0),
fTPCchi2(0),
fTPCchi2Iter1(0),
fTRDchi2(0),
fTOFchi2(0),
fHMPIDchi2(0),
fGlobalChi2(0),
fITSsignal(0),
fTPCsignal(0),
fTPCsignalTuned(0),
fTPCsignalS(0),
fTPCdEdxInfo(0),
fTRDsignal(0),
fTRDQuality(0),
fTRDBudget(0),
fTOFsignal(99999),
fTOFsignalTuned(99999),
fTOFsignalToT(99999),
fTOFsignalRaw(99999),
fTOFsignalDz(999),
fTOFsignalDx(999),
fTOFdeltaBC(999),
fTOFl0l1(999),
fCaloDx(0),
fCaloDz(0),
fHMPIDtrkX(0),
fHMPIDtrkY(0),
fHMPIDmipX(0),
fHMPIDmipY(0),
fTPCncls(0),
fTPCnclsF(0),
fTPCsignalN(0),
fTPCnclsIter1(0),
fTPCnclsFIter1(0),
fITSncls(0),
fITSClusterMap(0),
fITSSharedMap(0),
fTRDncls(0),
fTRDncls0(0),
fTRDntracklets(0),
fTRDNchamberdEdx(0),
fTRDNclusterdEdx(0),
fTRDnSlices(0),
fTRDslices(0x0),
fVertexID(-2),
fPIDForTracking(AliPID::kPion),
fESDEvent(0),
fCacheNCrossedRows(-10),
fCacheChi2TPCConstrainedVsGlobal(-10),
fCacheChi2TPCConstrainedVsGlobalVertex(0),
fDetectorPID(0x0),
fTrackPhiOnEMCal(-999),
fTrackEtaOnEMCal(-999),
fTrackPtOnEMCal(-999),
fNtofClusters(0),
fTOFcluster(NULL)
{
Int_t i;
for (i=kNITSchi2Std;i--;) fITSchi2Std[i] = 0;
for (i=0; i<3; i++) { fKinkIndexes[i]=0;}
for (i=0; i<3; i++) { fV0Indexes[i]=-1;}
for (i=0;i<kTRDnPlanes;i++) {
fTRDTimBin[i]=0;
}
for (i=0;i<4;i++) {fITSdEdxSamples[i]=0.;}
for (i=0;i<4;i++) {fTPCPoints[i]=0;}
for (i=0;i<10;i++) {fTOFInfo[i]=0;}
for (i=0;i<12;i++) {fITSModule[i]=-1;}
Double_t xref;
Double_t alpha;
Double_t param[5];
Double_t covar[15];
alpha = part->Phi()*180./TMath::Pi();
if (alpha<0) alpha+= 360.;
if (alpha>360) alpha -= 360.;
Int_t sector = (Int_t)(alpha/20.);
alpha = 10. + 20.*sector;
alpha /= 180;
alpha *= TMath::Pi();
for (i=0; i<15; i++) covar[i]=0.;
TVector3 ver(part->Vx(),part->Vy(),part->Vz());
TVector3 mom(part->Px(),part->Py(),part->Pz());
ver.RotateZ(-alpha);
mom.RotateZ(-alpha);
xref = ver.X();
Int_t pdgCode = part->GetPdgCode();
Double_t charge =
TDatabasePDG::Instance()->GetParticle(pdgCode)->Charge();
param[0] = ver.Y();
param[1] = ver.Z();
param[2] = TMath::Sin(mom.Phi());
param[3] = mom.Pz()/mom.Pt();
param[4] = TMath::Sign(1/mom.Pt(),charge);
Set(xref, alpha, param, covar);
Int_t indexPID = 99;
if (pdgCode<0) pdgCode = -pdgCode;
for (i=0;i<AliPID::kSPECIESC;i++) if (pdgCode==AliPID::ParticleCode(i)) {indexPID = i; break;}
if (indexPID < AliPID::kSPECIESC) fPIDForTracking = indexPID;
SetLabel(part->GetUniqueID());
}
AliESDtrack::~AliESDtrack(){
delete fIp;
delete fTPCInner;
delete fOp;
delete fHMPIDp;
delete fCp;
delete fFriendTrack;
delete fTPCdEdxInfo;
if(fTRDnSlices)
delete[] fTRDslices;
fCacheNCrossedRows = -10.;
fCacheChi2TPCConstrainedVsGlobal = -10.;
if(fCacheChi2TPCConstrainedVsGlobalVertex) fCacheChi2TPCConstrainedVsGlobalVertex = 0;
if(fTOFcluster)
delete[] fTOFcluster;
fTOFcluster = NULL;
fNtofClusters=0;
delete fDetectorPID;
delete[] fR;
delete[] fITSr;
delete[] fTPCr;
delete[] fTRDr;
delete[] fTOFr;
delete[] fHMPIDr;
if(fTrackTime) delete[] fTrackTime;
if(fTOFLabel) delete[] fTOFLabel;
}
AliESDtrack &AliESDtrack::operator=(const AliESDtrack &source)
{
if(&source == this) return *this;
AliExternalTrackParam::operator=(source);
if(source.fCp){
if(fCp)*fCp = *source.fCp;
else fCp = new AliExternalTrackParam(*source.fCp);
}
else{
delete fCp;
fCp = 0;
}
if(source.fIp){
if(fIp)*fIp = *source.fIp;
else fIp = new AliExternalTrackParam(*source.fIp);
}
else{
delete fIp;
fIp = 0;
}
if(source.fTPCInner){
if(fTPCInner) *fTPCInner = *source.fTPCInner;
else fTPCInner = new AliExternalTrackParam(*source.fTPCInner);
}
else{
delete fTPCInner;
fTPCInner = 0;
}
if(source.fTPCdEdxInfo) {
if(fTPCdEdxInfo) *fTPCdEdxInfo = *source.fTPCdEdxInfo;
fTPCdEdxInfo = new AliTPCdEdxInfo(*source.fTPCdEdxInfo);
}
if(source.fOp){
if(fOp) *fOp = *source.fOp;
else fOp = new AliExternalTrackParam(*source.fOp);
}
else{
delete fOp;
fOp = 0;
}
if(source.fHMPIDp){
if(fHMPIDp) *fHMPIDp = *source.fHMPIDp;
else fHMPIDp = new AliExternalTrackParam(*source.fHMPIDp);
}
else{
delete fHMPIDp;
fHMPIDp = 0;
}
if(source.fFriendTrack){
delete fFriendTrack; fFriendTrack=new AliESDfriendTrack(*source.fFriendTrack);
}
else{
delete fFriendTrack; fFriendTrack= 0;
}
fTPCFitMap = source.fTPCFitMap;
fTPCClusterMap = source.fTPCClusterMap;
fTPCSharedMap = source.fTPCSharedMap;
fFlags = source.fFlags;
fID = source.fID;
fLabel = source.fLabel;
fITSLabel = source.fITSLabel;
for(int i = 0; i< 12;++i){
fITSModule[i] = source.fITSModule[i];
}
fTPCLabel = source.fTPCLabel;
fTRDLabel = source.fTRDLabel;
if(source.fTOFLabel){
if(!fTOFLabel) fTOFLabel = new Int_t[3];
for(int i = 0; i< 3;++i){
fTOFLabel[i] = source.fTOFLabel[i];
}
}
fTOFCalChannel = source.fTOFCalChannel;
fTOFindex = source.fTOFindex;
fHMPIDqn = source.fHMPIDqn;
fHMPIDcluIdx = source.fHMPIDcluIdx;
fCaloIndex = source.fCaloIndex;
for (int i=kNITSchi2Std;i--;) fITSchi2Std[i] = source.fITSchi2Std[i];
for(int i = 0; i< 3;++i){
fKinkIndexes[i] = source.fKinkIndexes[i];
fV0Indexes[i] = source.fV0Indexes[i];
}
if (source.fR) {
if (!fR) fR = new Double32_t[AliPID::kSPECIES];
for (Int_t i=AliPID::kSPECIES;i--;) fR[i]=source.fR[i];
}
else {delete[] fR; fR = 0;}
if (source.fITSr) {
if (!fITSr) fITSr = new Double32_t[AliPID::kSPECIES];
for (Int_t i=AliPID::kSPECIES;i--;) fITSr[i]=source.fITSr[i];
}
else {delete[] fITSr; fITSr = 0;}
if (source.fTPCr) {
if (!fTPCr) fTPCr = new Double32_t[AliPID::kSPECIES];
for (Int_t i=AliPID::kSPECIES;i--;) fTPCr[i]=source.fTPCr[i];
}
else {delete[] fTPCr; fTPCr = 0;}
if (source.fTRDr) {
if (!fTRDr) fTRDr = new Double32_t[AliPID::kSPECIES];
for (Int_t i=AliPID::kSPECIES;i--;) fTRDr[i]=source.fTRDr[i];
}
else {delete[] fTRDr; fTRDr = 0;}
if (source.fTOFr) {
if (!fTOFr) fTOFr = new Double32_t[AliPID::kSPECIES];
for (Int_t i=AliPID::kSPECIES;i--;) fTOFr[i]=source.fTOFr[i];
}
else {delete[] fTOFr; fTOFr = 0;}
if (source.fHMPIDr) {
if (!fHMPIDr) fHMPIDr = new Double32_t[AliPID::kSPECIES];
for (Int_t i=AliPID::kSPECIES;i--;) fHMPIDr[i]=source.fHMPIDr[i];
}
else {delete[] fHMPIDr; fHMPIDr = 0;}
fPIDForTracking = source.fPIDForTracking;
fHMPIDtrkTheta = source.fHMPIDtrkTheta;
fHMPIDtrkPhi = source.fHMPIDtrkPhi;
fHMPIDsignal = source.fHMPIDsignal;
if(fTrackTime){
delete[] fTrackTime;
}
if(source.fTrackTime){
fTrackTime = new Double32_t[AliPID::kSPECIESC];
for(Int_t i=0;i < AliPID::kSPECIESC;i++)
fTrackTime[i] = source.fTrackTime[i];
}
fTrackLength = source. fTrackLength;
fdTPC = source.fdTPC;
fzTPC = source.fzTPC;
fCddTPC = source.fCddTPC;
fCdzTPC = source.fCdzTPC;
fCzzTPC = source.fCzzTPC;
fCchi2TPC = source.fCchi2TPC;
fD = source.fD;
fZ = source.fZ;
fCdd = source.fCdd;
fCdz = source.fCdz;
fCzz = source.fCzz;
fCchi2 = source.fCchi2;
fITSchi2 = source.fITSchi2;
fTPCchi2 = source.fTPCchi2;
fTPCchi2Iter1 = source.fTPCchi2Iter1;
fTRDchi2 = source.fTRDchi2;
fTOFchi2 = source.fTOFchi2;
fHMPIDchi2 = source.fHMPIDchi2;
fGlobalChi2 = source.fGlobalChi2;
fITSsignal = source.fITSsignal;
for (Int_t i=0;i<4;i++) {fITSdEdxSamples[i]=source.fITSdEdxSamples[i];}
fTPCsignal = source.fTPCsignal;
fTPCsignalTuned = source.fTPCsignalTuned;
fTPCsignalS = source.fTPCsignalS;
for(int i = 0; i< 4;++i){
fTPCPoints[i] = source.fTPCPoints[i];
}
fTRDsignal = source.fTRDsignal;
fTRDNchamberdEdx = source.fTRDNchamberdEdx;
fTRDNclusterdEdx = source.fTRDNclusterdEdx;
for(int i = 0;i < kTRDnPlanes;++i){
fTRDTimBin[i] = source.fTRDTimBin[i];
}
if(fTRDnSlices)
delete[] fTRDslices;
fTRDslices=0;
fTRDnSlices=source.fTRDnSlices;
if (fTRDnSlices) {
fTRDslices=new Double32_t[fTRDnSlices];
for(int j = 0;j < fTRDnSlices;++j) fTRDslices[j] = source.fTRDslices[j];
}
fTRDQuality = source.fTRDQuality;
fTRDBudget = source.fTRDBudget;
fTOFsignal = source.fTOFsignal;
fTOFsignalTuned = source.fTOFsignalTuned;
fTOFsignalToT = source.fTOFsignalToT;
fTOFsignalRaw = source.fTOFsignalRaw;
fTOFsignalDz = source.fTOFsignalDz;
fTOFsignalDx = source.fTOFsignalDx;
fTOFdeltaBC = source.fTOFdeltaBC;
fTOFl0l1 = source.fTOFl0l1;
for(int i = 0;i<10;++i){
fTOFInfo[i] = source.fTOFInfo[i];
}
fHMPIDtrkX = source.fHMPIDtrkX;
fHMPIDtrkY = source.fHMPIDtrkY;
fHMPIDmipX = source.fHMPIDmipX;
fHMPIDmipY = source.fHMPIDmipY;
fTPCncls = source.fTPCncls;
fTPCnclsF = source.fTPCnclsF;
fTPCsignalN = source.fTPCsignalN;
fTPCnclsIter1 = source.fTPCnclsIter1;
fTPCnclsFIter1 = source.fTPCnclsFIter1;
fITSncls = source.fITSncls;
fITSClusterMap = source.fITSClusterMap;
fITSSharedMap = source.fITSSharedMap;
fTRDncls = source.fTRDncls;
fTRDncls0 = source.fTRDncls0;
fTRDntracklets = source.fTRDntracklets;
fVertexID = source.fVertexID;
fPIDForTracking = source.fPIDForTracking;
fCacheNCrossedRows = source.fCacheNCrossedRows;
fCacheChi2TPCConstrainedVsGlobal = source.fCacheChi2TPCConstrainedVsGlobal;
fCacheChi2TPCConstrainedVsGlobalVertex = source.fCacheChi2TPCConstrainedVsGlobalVertex;
delete fDetectorPID;
fDetectorPID=0x0;
if (source.fDetectorPID) fDetectorPID = new AliDetectorPID(*source.fDetectorPID);
fTrackPhiOnEMCal= source.fTrackPhiOnEMCal;
fTrackEtaOnEMCal= source.fTrackEtaOnEMCal;
fTrackPtOnEMCal= source.fTrackPtOnEMCal;
if(fTOFcluster){
delete[] fTOFcluster;
}
fNtofClusters = source.fNtofClusters;
if(fNtofClusters > 0){
fTOFcluster = new Int_t[fNtofClusters];
for(Int_t i=0;i < fNtofClusters;i++) fTOFcluster[i] = source.fTOFcluster[i];
}
return *this;
}
void AliESDtrack::Copy(TObject &obj) const {
if(this==&obj)return;
AliESDtrack *robj = dynamic_cast<AliESDtrack*>(&obj);
if(!robj)return;
*robj = *this;
}
void AliESDtrack::AddCalibObject(TObject * object){
if (!fFriendTrack) fFriendTrack = new AliESDfriendTrack;
if (!fFriendTrack) return;
fFriendTrack->AddCalibObject(object);
}
TObject * AliESDtrack::GetCalibObject(Int_t index){
if (!fFriendTrack) return 0;
return fFriendTrack->GetCalibObject(index);
}
Bool_t AliESDtrack::FillTPCOnlyTrack(AliESDtrack &track){
if(!fTPCInner)return kFALSE;
track.Set(fTPCInner->GetX(),fTPCInner->GetAlpha(),fTPCInner->GetParameter(),fTPCInner->GetCovariance());
track.fD = fdTPC;
track.fZ = fzTPC;
track.fCdd = fCddTPC;
track.fCdz = fCdzTPC;
track.fCzz = fCzzTPC;
if(track.fIp) *track.fIp = *fIp;
else track.fIp = new AliExternalTrackParam(*fIp);
if(track.fTPCInner) *track.fTPCInner = *fTPCInner;
else track.fTPCInner = new AliExternalTrackParam(*fTPCInner);
track.fdTPC = fdTPC;
track.fzTPC = fzTPC;
track.fCddTPC = fCddTPC;
track.fCdzTPC = fCdzTPC;
track.fCzzTPC = fCzzTPC;
track.fCchi2TPC = fCchi2TPC;
track.fLabel = fTPCLabel;
track.fTPCLabel = fTPCLabel;
track.fTPCchi2 = fTPCchi2;
track.fTPCchi2Iter1 = fTPCchi2Iter1;
track.fTPCsignal = fTPCsignal;
track.fTPCsignalTuned = fTPCsignalTuned;
track.fTPCsignalS = fTPCsignalS;
for(int i = 0;i<4;++i)track.fTPCPoints[i] = fTPCPoints[i];
track.fTPCncls = fTPCncls;
track.fTPCnclsF = fTPCnclsF;
track.fTPCsignalN = fTPCsignalN;
track.fTPCnclsIter1 = fTPCnclsIter1;
track.fTPCnclsFIter1 = fTPCnclsFIter1;
if (fTPCr) {
if (!track.fTPCr) track.fTPCr = new Double32_t[AliPID::kSPECIES];
for(int i=AliPID::kSPECIES;i--;) track.fTPCr[i] = fTPCr[i];
}
if (fR) {
if (!track.fR) track.fR = new Double32_t[AliPID::kSPECIES];
for(int i=AliPID::kSPECIES;i--;) track.fR[i] = fR[i];
}
track.fTPCFitMap = fTPCFitMap;
track.fTPCClusterMap = fTPCClusterMap;
track.fTPCSharedMap = fTPCSharedMap;
track.fFlags = kTPCin;
track.fID = fID;
track.fFlags |= fFlags & kTPCpid;
for (Int_t i=0;i<3;i++) track.fKinkIndexes[i] = fKinkIndexes[i];
return kTRUE;
}
void AliESDtrack::MakeMiniESDtrack(){
fTrackLength = 0;
if(fTrackTime)
for (Int_t i=0;i<AliPID::kSPECIESC;i++) fTrackTime[i] = 0;
delete fCp;fCp = 0;
delete fIp;fIp = 0;
delete fTPCInner;fTPCInner=0;
delete fOp;fOp = 0;
delete fHMPIDp;fHMPIDp = 0;
fITSchi2 = 0;
fITSncls = 0;
fITSClusterMap=0;
fITSSharedMap=0;
fITSsignal = 0;
for (Int_t i=0;i<4;i++) fITSdEdxSamples[i] = 0.;
if (fITSr) for (Int_t i=0;i<AliPID::kSPECIES;i++) fITSr[i]=0;
fITSLabel = 0;
fTPCchi2 = 0;
fTPCchi2Iter1 = 0;
fTPCncls = 0;
fTPCnclsF = 0;
fTPCnclsIter1 = 0;
fTPCnclsFIter1 = 0;
fTPCFitMap = 0;
fTPCClusterMap = 0;
fTPCSharedMap = 0;
fTPCsignal= 0;
fTPCsignalTuned= 0;
fTPCsignalS= 0;
fTPCsignalN= 0;
if (fTPCr) for (Int_t i=0;i<AliPID::kSPECIES;i++) fTPCr[i] = 0;
fTPCLabel=0;
for (Int_t i=0;i<4;i++) fTPCPoints[i] = 0;
for (Int_t i=0; i<3;i++) fKinkIndexes[i] = 0;
for (Int_t i=0; i<3;i++) fV0Indexes[i] = 0;
fTRDchi2 = 0;
fTRDncls = 0;
fTRDncls0 = 0;
fTRDsignal = 0;
fTRDNchamberdEdx = 0;
fTRDNclusterdEdx = 0;
for (Int_t i=0;i<kTRDnPlanes;i++) {
fTRDTimBin[i] = 0;
}
if (fTRDr) for (Int_t i=0;i<AliPID::kSPECIES;i++) fTRDr[i] = 0;
fTRDLabel = 0;
fTRDQuality = 0;
fTRDntracklets = 0;
if(fTRDnSlices)
delete[] fTRDslices;
fTRDslices=0x0;
fTRDnSlices=0;
fTRDBudget = 0;
fTOFchi2 = 0;
fTOFindex = -1;
fTOFsignal = 99999;
fTOFCalChannel = -1;
fTOFsignalToT = 99999;
fTOFsignalRaw = 99999;
fTOFsignalDz = 999;
fTOFsignalDx = 999;
fTOFdeltaBC = 999;
fTOFl0l1 = 999;
if (fTOFr) for (Int_t i=0;i<AliPID::kSPECIES;i++) fTOFr[i] = 0;
for (Int_t i=0;i<10;i++) fTOFInfo[i] = 0;
fHMPIDchi2 = 0;
fHMPIDqn = 0;
fHMPIDcluIdx = -1;
fHMPIDsignal = 0;
if (fHMPIDr) for (Int_t i=0;i<AliPID::kSPECIES;i++) fHMPIDr[i] = 0;
fHMPIDtrkTheta = 0;
fHMPIDtrkPhi = 0;
fHMPIDtrkX = 0;
fHMPIDtrkY = 0;
fHMPIDmipX = 0;
fHMPIDmipY = 0;
fCaloIndex = kEMCALNoMatch;
fGlobalChi2 = 0;
fVertexID = -2;
fPIDForTracking = AliPID::kPion;
delete fFriendTrack; fFriendTrack = 0;
}
Int_t AliESDtrack::GetPID(Bool_t tpcOnly) const
{
Int_t i;
const Double32_t *prob = 0;
if (tpcOnly) {
if (!fTPCr) return GetPIDForTracking();
prob = fTPCr;
for (i=0; i<AliPID::kSPECIES-1; i++) if (prob[i] != prob[i+1]) break;
if (i == AliPID::kSPECIES-1) prob = 0;
}
if (!prob) {
if (!fR) return GetPIDForTracking();
prob = fR;
for (i=0; i<AliPID::kSPECIES-1; i++) if (prob[i] != prob[i+1]) break;
if (i == AliPID::kSPECIES-1) return GetPIDForTracking();
}
Float_t max=0.;
Int_t k=-1;
for (i=0; i<AliPID::kSPECIES; i++) if (prob[i]>max) {k=i; max=prob[i];}
if (k==0) {
return AliPID::kElectron;
}
if (k==1) return AliPID::kMuon;
if (k==2||k==-1) return AliPID::kPion;
if (k==3) return AliPID::kKaon;
if (k==4) return AliPID::kProton;
return GetPIDForTracking();
}
Int_t AliESDtrack::GetTOFBunchCrossing(Double_t b, Bool_t pidTPConly) const
{
const double kSpacing = 25e3;
const double kShift = 0;
Int_t bcid = kTOFBCNA;
if (!IsOn(kTOFout)) return bcid;
double tdif = GetTOFsignal();
if (IsOn(kTIME)) {
int pid = GetPID(pidTPConly);
Double_t times[AliPID::kSPECIESC];
GetIntegratedTimes(times,pid>=AliPID::kSPECIES ? AliPID::kSPECIESC : AliPID::kSPECIES);
tdif -= times[pid];
}
else {
const double kRTOF = 385.;
const double kCSpeed = 3.e-2;
double p = GetP();
if (p<0.01) return bcid;
double m = GetMass(pidTPConly);
double curv = GetC(b);
double path = TMath::Abs(curv)>kAlmost0 ?
2./curv*TMath::ASin(kRTOF*curv/2.)*TMath::Sqrt(1.+GetTgl()*GetTgl()) : kRTOF;
tdif -= path/kCSpeed*TMath::Sqrt(1.+m*m/(p*p));
}
bcid = TMath::Nint((tdif - kShift)/kSpacing);
return bcid;
}
Double_t AliESDtrack::M() const
{
static Bool_t printerr=kTRUE;
if (printerr) {
AliWarning("WARNING !!! ... THIS WILL BE PRINTED JUST ONCE !!!");
printerr = kFALSE;
AliWarning("This is the ESD mass. Use it with care !");
}
return GetMass();
}
Double_t AliESDtrack::E() const
{
Double_t m = M();
Double_t p = P();
return TMath::Sqrt(p*p + m*m);
}
Double_t AliESDtrack::Y() const
{
Double_t e = E();
Double_t pz = Pz();
if (e != TMath::Abs(pz)) {
return 0.5*TMath::Log((e+pz)/(e-pz));
} else {
return -999.;
}
}
Bool_t AliESDtrack::UpdateTrackParams(const AliKalmanTrack *t, ULong_t flags){
Bool_t rc=kTRUE;
SetStatus(flags);
fLabel=t->GetLabel();
if (t->IsStartedTimeIntegral()) {
SetStatus(kTIME);
Double_t times[AliPID::kSPECIESC];
t->GetIntegratedTimes(times);
SetIntegratedTimes(times);
SetIntegratedLength(t->GetIntegratedLength());
}
Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
if (fFriendTrack) {
if (flags==kITSout) fFriendTrack->SetITSOut(*t);
if (flags==kTPCout) fFriendTrack->SetTPCOut(*t);
if (flags==kTRDrefit) fFriendTrack->SetTRDIn(*t);
}
switch (flags) {
case kITSin:
fITSchi2Std[0] = t->GetChi2();
case kITSout:
fITSchi2Std[1] = t->GetChi2();
case kITSrefit:
{
fITSchi2Std[2] = t->GetChi2();
fITSClusterMap=0;
fITSncls=t->GetNumberOfClusters();
if (fFriendTrack) {
Int_t* indexITS = new Int_t[AliESDfriendTrack::kMaxITScluster];
for (Int_t i=0;i<AliESDfriendTrack::kMaxITScluster;i++) {
indexITS[i]=t->GetClusterIndex(i);
if (i<fITSncls) {
Int_t l=(indexITS[i] & 0xf0000000) >> 28;
SETBIT(fITSClusterMap,l);
}
}
fFriendTrack->SetITSIndices(indexITS,AliESDfriendTrack::kMaxITScluster);
delete [] indexITS;
}
fITSchi2=t->GetChi2();
fITSsignal=t->GetPIDsignal();
fITSLabel = t->GetLabel();
if (flags==kITSout) {
if (!fOp) fOp=new AliExternalTrackParam(*t);
else
fOp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
}
}
break;
case kTPCin: case kTPCrefit:
{
fTPCLabel = t->GetLabel();
if (flags==kTPCin) {
fTPCInner=new AliExternalTrackParam(*t);
fTPCnclsIter1=t->GetNumberOfClusters();
fTPCchi2Iter1=t->GetChi2();
}
if (!fIp) fIp=new AliExternalTrackParam(*t);
else
fIp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
}
case kTPCout:
{
if (flags & kTPCout){
if (!fOp) fOp=new AliExternalTrackParam(*t);
else
fOp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
}
fTPCncls=t->GetNumberOfClusters();
fTPCchi2=t->GetChi2();
if (fFriendTrack) {
Int_t* indexTPC = new Int_t[AliESDfriendTrack::kMaxTPCcluster];
for (Int_t i=0;i<AliESDfriendTrack::kMaxTPCcluster;i++)
indexTPC[i]=t->GetClusterIndex(i);
fFriendTrack->SetTPCIndices(indexTPC,AliESDfriendTrack::kMaxTPCcluster);
delete [] indexTPC;
}
fTPCsignal=t->GetPIDsignal();
}
break;
case kTRDin: case kTRDrefit:
break;
case kTRDout:
{
fTRDLabel = t->GetLabel();
fTRDchi2 = t->GetChi2();
fTRDncls = t->GetNumberOfClusters();
if (fFriendTrack) {
Int_t* indexTRD = new Int_t[AliESDfriendTrack::kMaxTRDcluster];
for (Int_t i=0;i<AliESDfriendTrack::kMaxTRDcluster;i++) indexTRD[i]=-2;
for (Int_t i=0;i<6;i++) indexTRD[i]=t->GetTrackletIndex(i);
fFriendTrack->SetTRDIndices(indexTRD,AliESDfriendTrack::kMaxTRDcluster);
delete [] indexTRD;
}
}
break;
case kTRDbackup:
if (!fOp) fOp=new AliExternalTrackParam(*t);
else
fOp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
fTRDncls0 = t->GetNumberOfClusters();
break;
case kTOFin:
break;
case kTOFout:
break;
case kTRDStop:
break;
case kHMPIDout:
if (!fHMPIDp) fHMPIDp=new AliExternalTrackParam(*t);
else
fHMPIDp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
break;
default:
AliError("Wrong flag !");
return kFALSE;
}
return rc;
}
void AliESDtrack::GetExternalParameters(Double_t &x, Double_t p[5]) const {
x=GetX();
for (Int_t i=0; i<5; i++) p[i]=GetParameter()[i];
}
void AliESDtrack::GetExternalCovariance(Double_t cov[15]) const {
for (Int_t i=0; i<15; i++) cov[i]=AliExternalTrackParam::GetCovariance()[i];
}
Bool_t AliESDtrack::GetConstrainedExternalParameters
(Double_t &alpha, Double_t &x, Double_t p[5]) const {
if (!fCp) return kFALSE;
alpha=fCp->GetAlpha();
x=fCp->GetX();
for (Int_t i=0; i<5; i++) p[i]=fCp->GetParameter()[i];
return kTRUE;
}
Bool_t
AliESDtrack::GetConstrainedExternalCovariance(Double_t c[15]) const {
if (!fCp) return kFALSE;
for (Int_t i=0; i<15; i++) c[i]=fCp->GetCovariance()[i];
return kTRUE;
}
Bool_t
AliESDtrack::GetInnerExternalParameters
(Double_t &alpha, Double_t &x, Double_t p[5]) const {
if (!fIp) return kFALSE;
alpha=fIp->GetAlpha();
x=fIp->GetX();
for (Int_t i=0; i<5; i++) p[i]=fIp->GetParameter()[i];
return kTRUE;
}
Bool_t
AliESDtrack::GetInnerExternalCovariance(Double_t cov[15]) const {
if (!fIp) return kFALSE;
for (Int_t i=0; i<15; i++) cov[i]=fIp->GetCovariance()[i];
return kTRUE;
}
void
AliESDtrack::SetOuterParam(const AliExternalTrackParam *p, ULong_t flags) {
SetStatus(flags);
if (fOp) delete fOp;
fOp=new AliExternalTrackParam(*p);
}
void
AliESDtrack::SetOuterHmpParam(const AliExternalTrackParam *p, ULong_t flags) {
SetStatus(flags);
if (fHMPIDp) delete fHMPIDp;
fHMPIDp=new AliExternalTrackParam(*p);
}
Bool_t
AliESDtrack::GetOuterExternalParameters
(Double_t &alpha, Double_t &x, Double_t p[5]) const {
if (!fOp) return kFALSE;
alpha=fOp->GetAlpha();
x=fOp->GetX();
for (Int_t i=0; i<5; i++) p[i]=fOp->GetParameter()[i];
return kTRUE;
}
Bool_t
AliESDtrack::GetOuterHmpExternalParameters
(Double_t &alpha, Double_t &x, Double_t p[5]) const {
if (!fHMPIDp) return kFALSE;
alpha=fHMPIDp->GetAlpha();
x=fHMPIDp->GetX();
for (Int_t i=0; i<5; i++) p[i]=fHMPIDp->GetParameter()[i];
return kTRUE;
}
Bool_t
AliESDtrack::GetOuterExternalCovariance(Double_t cov[15]) const {
if (!fOp) return kFALSE;
for (Int_t i=0; i<15; i++) cov[i]=fOp->GetCovariance()[i];
return kTRUE;
}
Bool_t
AliESDtrack::GetOuterHmpExternalCovariance(Double_t cov[15]) const {
if (!fHMPIDp) return kFALSE;
for (Int_t i=0; i<15; i++) cov[i]=fHMPIDp->GetCovariance()[i];
return kTRUE;
}
Int_t AliESDtrack::GetNcls(Int_t idet) const
{
Int_t ncls = 0;
switch(idet){
case 0:
ncls = fITSncls;
break;
case 1:
ncls = fTPCncls;
break;
case 2:
ncls = fTRDncls;
break;
case 3:
if (fTOFindex != -1)
ncls = 1;
break;
case 4:
break;
case 5:
if ((fHMPIDcluIdx >= 0) && (fHMPIDcluIdx < 7000000)) {
if ((fHMPIDcluIdx%1000000 != 9999) && (fHMPIDcluIdx%1000000 != 99999)) {
ncls = 1;
}
}
break;
default:
break;
}
return ncls;
}
Int_t AliESDtrack::GetClusters(Int_t idet, Int_t *idx) const
{
Int_t ncls = 0;
switch(idet){
case 0:
ncls = GetITSclusters(idx);
break;
case 1:
ncls = GetTPCclusters(idx);
break;
case 2:
ncls = GetTRDclusters(idx);
break;
case 3:
if (fTOFindex != -1) {
idx[0] = fTOFindex;
ncls = 1;
}
break;
case 4:
break;
case 5:
if ((fHMPIDcluIdx >= 0) && (fHMPIDcluIdx < 7000000)) {
if ((fHMPIDcluIdx%1000000 != 9999) && (fHMPIDcluIdx%1000000 != 99999)) {
idx[0] = GetHMPIDcluIdx();
ncls = 1;
}
}
break;
case 6:
break;
default:
break;
}
return ncls;
}
void AliESDtrack::GetIntegratedTimes(Double_t *times, Int_t nspec) const
{
if (nspec<1) return;
if(fNtofClusters>0 && GetESDEvent()){
TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
AliESDTOFCluster *tofcl = (AliESDTOFCluster *) tofclArray->At(fTOFcluster[0]);
for(int i=tofcl->GetNMatchableTracks();i--;){
if(tofcl->GetTrackIndex(i) == GetID()) {
for (int j=nspec; j--;) times[j]=tofcl->GetIntegratedTime(j,i);
return;
}
}
}
else if(fNtofClusters>0)
AliInfo("No AliESDEvent available here!\n");
if(fTrackTime)
for (int i=nspec; i--;) times[i]=fTrackTime[i];
else
for (int i=AliPID::kSPECIESC; i--;) times[i]=0.0;
}
Double_t AliESDtrack::GetIntegratedLength() const{
Int_t index = -1;
if(fNtofClusters>0 && GetESDEvent()){
TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
AliESDTOFCluster *tofcl = (AliESDTOFCluster *) tofclArray->At(fTOFcluster[0]);
for(Int_t i=0;i < tofcl->GetNMatchableTracks();i++){
if(tofcl->GetTrackIndex(i) == GetID()) index = i;
}
if(fNtofClusters>0 && index > -1)
return tofcl->GetLength(index);
}
else if(fNtofClusters>0) AliInfo("No AliESDEvent available here!\n");
return fTrackLength;
}
void AliESDtrack::SetIntegratedTimes(const Double_t *times)
{
if(!fTrackTime) fTrackTime = new Double32_t[AliPID::kSPECIESC];
for (int i=AliPID::kSPECIESC; i--;) fTrackTime[i]=times[i];
}
void AliESDtrack::SetITSpid(const Double_t *p)
{
if (!fITSr) fITSr = new Double32_t[AliPID::kSPECIESC];
SetPIDValues(fITSr,p,AliPID::kSPECIES);
SetStatus(AliESDtrack::kITSpid);
}
void AliESDtrack::GetITSpid(Double_t *p) const {
for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i] = fITSr ? fITSr[i] : 0;
}
Char_t AliESDtrack::GetITSclusters(Int_t *idx) const {
if (idx && fFriendTrack) {
Int_t *index=fFriendTrack->GetITSindices();
for (Int_t i=0; i<AliESDfriendTrack::kMaxITScluster; i++) {
if ( (i>=fITSncls) && (i<6) ) idx[i]=-1;
else {
if (index) {
idx[i]=index[i];
}
else idx[i]= -2;
}
}
}
return fITSncls;
}
Bool_t AliESDtrack::GetITSModuleIndexInfo(Int_t ilayer,Int_t &idet,Int_t &status,
Float_t &xloc,Float_t &zloc) const {
if(fITSModule[ilayer]==-1) {
idet = -1;
status=0;
xloc=-99.; zloc=-99.;
return kFALSE;
}
Int_t module = fITSModule[ilayer];
idet = Int_t(module/1000000);
module -= idet*1000000;
status = Int_t(module/100000);
module -= status*100000;
Int_t signs = Int_t(module/10000);
module-=signs*10000;
Int_t xInt = Int_t(module/100);
module -= xInt*100;
Int_t zInt = module;
if(signs==1) { xInt*=1; zInt*=1; }
if(signs==2) { xInt*=1; zInt*=-1; }
if(signs==3) { xInt*=-1; zInt*=1; }
if(signs==4) { xInt*=-1; zInt*=-1; }
xloc = 0.1*(Float_t)xInt;
zloc = 0.1*(Float_t)zInt;
if(status==4) idet = -1;
return kTRUE;
}
UShort_t AliESDtrack::GetTPCclusters(Int_t *idx) const {
if (idx && fFriendTrack) {
Int_t *index=fFriendTrack->GetTPCindices();
if (index){
for (Int_t i=0; i<AliESDfriendTrack::kMaxTPCcluster; i++) idx[i]=index[i];
}
else {
for (Int_t i=0; i<AliESDfriendTrack::kMaxTPCcluster; i++) idx[i]=-2;
}
}
return fTPCncls;
}
Float_t AliESDtrack::GetTPCCrossedRows() const
{
if (fCacheNCrossedRows > -1)
return fCacheNCrossedRows;
fCacheNCrossedRows = GetTPCClusterInfo(2, 1);
return fCacheNCrossedRows;
}
Float_t AliESDtrack::GetTPCClusterInfo(Int_t nNeighbours, Int_t type, Int_t row0, Int_t row1, Int_t bitType ) const
{
Int_t found=0;
Int_t findable=0;
Int_t last=-nNeighbours;
const TBits & clusterMap = (bitType%2==0) ? fTPCClusterMap : fTPCFitMap;
Int_t upperBound=clusterMap.GetNbits();
if (upperBound>row1) upperBound=row1;
for (Int_t i=row0; i<upperBound; ++i){
if (clusterMap[i]) {
last=i;
++found;
++findable;
continue;
}
if ((i-last)<=nNeighbours) {
++findable;
continue;
}
for (Int_t j=i+1; j<i+1+nNeighbours; ++j){
if (clusterMap[j]){
++findable;
break;
}
}
}
if (type==2) return found;
if (type==1) return findable;
if (type==0){
Float_t fraction=0;
if (findable>0)
fraction=(Float_t)found/(Float_t)findable;
else
fraction=0;
return fraction;
}
return 0;
}
Float_t AliESDtrack::GetTPCClusterDensity(Int_t nNeighbours, Int_t type, Int_t row0, Int_t row1, Int_t bitType ) const
{
Int_t found=0;
Int_t findable=0;
const TBits & clusterMap = (bitType%2==0) ? fTPCClusterMap : fTPCFitMap;
Int_t upperBound=clusterMap.GetNbits();
if (upperBound>row1) upperBound=row1;
for (Int_t i=row0; i<upperBound; ++i){
Bool_t isUp=kFALSE;
Bool_t isDown=kFALSE;
for (Int_t idelta=1; idelta<=nNeighbours; idelta++){
if (i-idelta>=0 && clusterMap[i-idelta]) isDown=kTRUE;
if (i+idelta<upperBound && clusterMap[i+idelta]) isUp=kTRUE;
}
if (isUp&&isDown){
++findable;
if (clusterMap[i]) ++found;
}
}
if (type==2) return found;
if (type==1) return findable;
if (type==0){
Float_t fraction=0;
if (findable>0)
fraction=(Float_t)found/(Float_t)findable;
else
fraction=0;
return fraction;
}
return 0;
}
Double_t AliESDtrack::GetTPCdensity(Int_t row0, Int_t row1) const{
if (!fFriendTrack) return 0.0;
Int_t good = 0;
Int_t found = 0;
Int_t *index=fFriendTrack->GetTPCindices();
for (Int_t i=row0;i<=row1;i++){
Int_t idx = index[i];
if (idx!=-1) good++;
if (idx>0) found++;
}
Float_t density=0.5;
if (good>TMath::Max((row1-row0)*0.5,0.0)) density = Float_t(found)/Float_t(good);
return density;
}
void AliESDtrack::SetTPCpid(const Double_t *p) {
if (!fTPCr) fTPCr = new Double32_t[AliPID::kSPECIES];
SetPIDValues(fTPCr,p,AliPID::kSPECIES);
SetStatus(AliESDtrack::kTPCpid);
}
void AliESDtrack::GetTPCpid(Double_t *p) const {
for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i] = fTPCr ? fTPCr[i] : 0;
}
UChar_t AliESDtrack::GetTRDclusters(Int_t *idx) const {
if (idx && fFriendTrack) {
Int_t *index=fFriendTrack->GetTRDindices();
if (index) {
for (Int_t i=0; i<AliESDfriendTrack::kMaxTRDcluster; i++) idx[i]=index[i];
}
else {
for (Int_t i=0; i<AliESDfriendTrack::kMaxTRDcluster; i++) idx[i]=-2;
}
}
return fTRDncls;
}
UChar_t AliESDtrack::GetTRDtracklets(Int_t *idx) const {
if (!fFriendTrack) return 0;
if (!idx) return GetTRDntracklets();
Int_t *index=fFriendTrack->GetTRDindices();
Int_t n = 0;
for (Int_t i=0; i<kTRDnPlanes; i++){
if (index){
if(index[i]>=0) n++;
idx[i]=index[i];
}
else idx[i] = -2;
}
return n;
}
void AliESDtrack::SetTRDpid(const Double_t *p) {
if (!fTRDr) fTRDr = new Double32_t[AliPID::kSPECIES];
SetPIDValues(fTRDr,p,AliPID::kSPECIES);
SetStatus(AliESDtrack::kTRDpid);
}
void AliESDtrack::GetTRDpid(Double_t *p) const {
for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i] = fTRDr ? fTRDr[i]:0;
}
void AliESDtrack::SetTRDpid(Int_t iSpecies, Float_t p)
{
if (!fTRDr) {
fTRDr = new Double32_t[AliPID::kSPECIES];
for (Int_t i=AliPID::kSPECIES; i--;) fTRDr[i] = 0;
}
fTRDr[iSpecies] = p;
}
Double_t AliESDtrack::GetTRDpid(Int_t iSpecies) const
{
return fTRDr ? fTRDr[iSpecies] : 0;
}
Int_t AliESDtrack::GetNumberOfTRDslices() const
{
Int_t idx = fTRDnSlices - (kTRDnPlanes<<1);
return idx<18 ? fTRDnSlices/kTRDnPlanes : idx/kTRDnPlanes;
}
Double_t AliESDtrack::GetTRDmomentum(Int_t plane, Double_t *sp) const
{
if (!fTRDnSlices) {
AliDebug(2, "No TRD info allocated for this track.");
return -1.;
}
if ((plane<0) || (plane>=kTRDnPlanes)) {
AliWarning(Form("Request for TRD plane[%d] outside range.", plane));
return -1.;
}
Int_t idx = fTRDnSlices-(kTRDnPlanes<<1)+plane;
if(idx<(GetNumberOfTRDslices()*kTRDnPlanes)) return -1.;
if(sp) (*sp) = fTRDslices[idx+kTRDnPlanes];
return fTRDslices[idx];
}
Double_t AliESDtrack::GetTRDslice(Int_t plane, Int_t slice) const {
if(!fTRDslices) {
return -1.;
}
if ((plane<0) || (plane>=kTRDnPlanes)) {
AliError("Info for TRD plane not available !");
return -1.;
}
Int_t ns=GetNumberOfTRDslices();
if ((slice<-1) || (slice>=ns)) {
return -1.;
}
if(slice>=0) return fTRDslices[plane*ns + slice];
Double_t q=0.; Double32_t *s = &fTRDslices[plane*ns];
for (Int_t i=0; i<ns; i++, s++) if((*s)>0.) q+=(*s);
return q/ns;
}
void AliESDtrack::SetNumberOfTRDslices(Int_t n) {
if (fTRDnSlices) return;
fTRDnSlices=n;
fTRDslices=new Double32_t[fTRDnSlices];
memset(fTRDslices, 0, n*sizeof(Double32_t));
for (Int_t i=GetNumberOfTRDslices(); i--;) fTRDslices[i]=-1.;
}
void AliESDtrack::SetTRDslice(Double_t q, Int_t plane, Int_t slice) {
if(!fTRDslices) {
AliError("No TRD slices allocated for this track !");
return;
}
if ((plane<0) || (plane>=kTRDnPlanes)) {
AliError("Info for TRD plane not allocated !");
return;
}
Int_t ns=GetNumberOfTRDslices();
if ((slice<0) || (slice>=ns)) {
AliError(Form("Wrong TRD slice %d/%d, NSlices=%d",plane,slice,ns));
return;
}
Int_t n=plane*ns + slice;
fTRDslices[n]=q;
}
void AliESDtrack::SetTRDmomentum(Double_t p, Int_t plane, Double_t *sp)
{
if(!fTRDslices) {
AliError("No TRD slices allocated for this track !");
return;
}
if ((plane<0) || (plane>=kTRDnPlanes)) {
AliError("Info for TRD plane not allocated !");
return;
}
Int_t idx = fTRDnSlices-(kTRDnPlanes<<1)+plane;
if(idx<GetNumberOfTRDslices()*kTRDnPlanes) return;
if(sp) fTRDslices[idx+kTRDnPlanes] = (*sp);
fTRDslices[idx] = p;
}
void AliESDtrack::SetTOFpid(const Double_t *p) {
if (!fTOFr) fTOFr = new Double32_t[AliPID::kSPECIES];
SetPIDValues(fTOFr,p,AliPID::kSPECIES);
SetStatus(AliESDtrack::kTOFpid);
}
void AliESDtrack::SetTOFLabel(const Int_t *p) {
if(fNtofClusters>0){
TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
AliESDTOFCluster *tofcl = (AliESDTOFCluster *) tofclArray->At(fTOFcluster[0]);
AliESDTOFHit* hit = tofcl->GetTOFHit(0);
if(hit) hit->SetTOFLabel(p);
}
else{
if(!fTOFLabel) fTOFLabel = new Int_t[3];
for (Int_t i=0; i<3; i++) fTOFLabel[i]=p[i];
}
}
void AliESDtrack::GetTOFpid(Double_t *p) const {
for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i] = fTOFr ? fTOFr[i]:0;
}
void AliESDtrack::GetTOFLabel(Int_t *p) const {
if(fNtofClusters>0){
TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
AliESDTOFCluster *tofcl = (AliESDTOFCluster *) tofclArray->At(fTOFcluster[0]);
for (Int_t i=0; i<3; i++) p[i]=tofcl->GetLabel(i);
}
else{
if(fTOFLabel) for (Int_t i=0; i<3; i++) p[i]=fTOFLabel[i];
else for (int i=3;i--;) p[i] = -1;
}
}
void AliESDtrack::GetTOFInfo(Float_t *info) const {
for (Int_t i=0; i<10; i++) info[i]=fTOFInfo[i];
}
void AliESDtrack::SetTOFInfo(Float_t*info) {
for (Int_t i=0; i<10; i++) fTOFInfo[i]=info[i];
}
void AliESDtrack::SetHMPIDpid(const Double_t *p) {
if (!fHMPIDr) fHMPIDr = new Double32_t[AliPID::kSPECIES];
SetPIDValues(fHMPIDr,p,AliPID::kSPECIES);
SetStatus(AliESDtrack::kHMPIDpid);
}
void AliESDtrack::SetTPCdEdxInfo(AliTPCdEdxInfo * dEdxInfo){
if(fTPCdEdxInfo) delete fTPCdEdxInfo;
fTPCdEdxInfo = dEdxInfo;
}
void AliESDtrack::GetHMPIDpid(Double_t *p) const {
for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i] = fHMPIDr ? fHMPIDr[i]:0;
}
void AliESDtrack::SetESDpid(const Double_t *p) {
if (!fR) fR = new Double32_t[AliPID::kSPECIES];
SetPIDValues(fR,p,AliPID::kSPECIES);
SetStatus(AliESDtrack::kESDpid);
}
void AliESDtrack::GetESDpid(Double_t *p) const {
for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i] = fR ? fR[i]:0;
}
Bool_t AliESDtrack::RelateToVertexTPC(const AliESDVertex *vtx,
Double_t b, Double_t maxd, AliExternalTrackParam *cParam) {
if (!fTPCInner) return kFALSE;
if (!vtx) return kFALSE;
Double_t dz[2],cov[3];
if (!fTPCInner->PropagateToDCA(vtx, b, maxd, dz, cov)) return kFALSE;
fdTPC = dz[0];
fzTPC = dz[1];
fCddTPC = cov[0];
fCdzTPC = cov[1];
fCzzTPC = cov[2];
Double_t covar[6]; vtx->GetCovMatrix(covar);
Double_t p[2]={GetParameter()[0]-dz[0],GetParameter()[1]-dz[1]};
Double_t c[3]={covar[2],0.,covar[5]};
Double_t chi2=GetPredictedChi2(p,c);
if (chi2>kVeryBig) return kFALSE;
fCchi2TPC=chi2;
if (!cParam) return kTRUE;
*cParam = *fTPCInner;
if (!cParam->Update(p,c)) return kFALSE;
return kTRUE;
}
Bool_t AliESDtrack::RelateToVertexTPCBxByBz(const AliESDVertex *vtx,
Double_t b[3], Double_t maxd, AliExternalTrackParam *cParam) {
if (!fTPCInner) return kFALSE;
if (!vtx) return kFALSE;
Double_t dz[2],cov[3];
if (!fTPCInner->PropagateToDCABxByBz(vtx, b, maxd, dz, cov)) return kFALSE;
fdTPC = dz[0];
fzTPC = dz[1];
fCddTPC = cov[0];
fCdzTPC = cov[1];
fCzzTPC = cov[2];
Double_t covar[6]; vtx->GetCovMatrix(covar);
Double_t p[2]={GetParameter()[0]-dz[0],GetParameter()[1]-dz[1]};
Double_t c[3]={covar[2],0.,covar[5]};
Double_t chi2=GetPredictedChi2(p,c);
if (chi2>kVeryBig) return kFALSE;
fCchi2TPC=chi2;
if (!cParam) return kTRUE;
*cParam = *fTPCInner;
if (!cParam->Update(p,c)) return kFALSE;
return kTRUE;
}
Bool_t AliESDtrack::RelateToVertex(const AliESDVertex *vtx,
Double_t b, Double_t maxd, AliExternalTrackParam *cParam) {
if (!vtx) return kFALSE;
Double_t dz[2],cov[3];
if (!PropagateToDCA(vtx, b, maxd, dz, cov)) return kFALSE;
fD = dz[0];
fZ = dz[1];
fCdd = cov[0];
fCdz = cov[1];
fCzz = cov[2];
Double_t covar[6]; vtx->GetCovMatrix(covar);
Double_t p[2]={GetParameter()[0]-dz[0],GetParameter()[1]-dz[1]};
Double_t c[3]={covar[2],0.,covar[5]};
Double_t chi2=GetPredictedChi2(p,c);
if (chi2>kVeryBig) return kFALSE;
fCchi2=chi2;
delete fCp;
fCp=new AliExternalTrackParam(*this);
if (!fCp->Update(p,c)) {delete fCp; fCp=0; return kFALSE;}
fVertexID = vtx->GetID();
if (!cParam) return kTRUE;
*cParam = *this;
if (!cParam->Update(p,c)) return kFALSE;
return kTRUE;
}
Bool_t AliESDtrack::RelateToVertexBxByBz(const AliESDVertex *vtx,
Double_t b[3], Double_t maxd, AliExternalTrackParam *cParam) {
if (!vtx) return kFALSE;
Double_t dz[2],cov[3];
if (!PropagateToDCABxByBz(vtx, b, maxd, dz, cov)) return kFALSE;
fD = dz[0];
fZ = dz[1];
fCdd = cov[0];
fCdz = cov[1];
fCzz = cov[2];
Double_t covar[6]; vtx->GetCovMatrix(covar);
Double_t p[2]={GetParameter()[0]-dz[0],GetParameter()[1]-dz[1]};
Double_t c[3]={covar[2],0.,covar[5]};
Double_t chi2=GetPredictedChi2(p,c);
if (chi2>kVeryBig) return kFALSE;
fCchi2=chi2;
delete fCp;
fCp=new AliExternalTrackParam(*this);
if (!fCp->Update(p,c)) {delete fCp; fCp=0; return kFALSE;}
fVertexID = vtx->GetID();
if (!cParam) return kTRUE;
*cParam = *this;
if (!cParam->Update(p,c)) return kFALSE;
return kTRUE;
}
void AliESDtrack::Print(Option_t *) const {
AliExternalTrackParam::Print();
printf("ESD track info\n") ;
Double_t p[AliPID::kSPECIES] ;
Int_t index = 0 ;
if( IsOn(kITSpid) ){
printf("From ITS: ") ;
GetITSpid(p) ;
for(index = 0 ; index < AliPID::kSPECIES; index++)
printf("%f, ", p[index]) ;
printf("\n signal = %f\n", GetITSsignal()) ;
}
if( IsOn(kTPCpid) ){
printf("From TPC: ") ;
GetTPCpid(p) ;
for(index = 0 ; index < AliPID::kSPECIES; index++)
printf("%f, ", p[index]) ;
printf("\n signal = %f\n", GetTPCsignal()) ;
}
if( IsOn(kTRDpid) ){
printf("From TRD: ") ;
GetTRDpid(p) ;
for(index = 0 ; index < AliPID::kSPECIES; index++)
printf("%f, ", p[index]) ;
printf("\n signal = %f\n", GetTRDsignal()) ;
printf("\n NchamberdEdx = %d\n", GetTRDNchamberdEdx()) ;
printf("\n NclusterdEdx = %d\n", GetTRDNclusterdEdx()) ;
}
if( IsOn(kTOFpid) ){
printf("From TOF: ") ;
GetTOFpid(p) ;
for(index = 0 ; index < AliPID::kSPECIES; index++)
printf("%f, ", p[index]) ;
printf("\n signal = %f\n", GetTOFsignal()) ;
}
if( IsOn(kHMPIDpid) ){
printf("From HMPID: ") ;
GetHMPIDpid(p) ;
for(index = 0 ; index < AliPID::kSPECIES; index++)
printf("%f, ", p[index]) ;
printf("\n signal = %f\n", GetHMPIDsignal()) ;
}
}
void AliESDtrack::FillPolymarker(TPolyMarker3D *pol, Float_t magF, Float_t minR, Float_t maxR, Float_t stepR){
TObjArray arrayRef;
arrayRef.AddLast(new AliExternalTrackParam(*this));
if (fIp) arrayRef.AddLast(new AliExternalTrackParam(*fIp));
if (fOp) arrayRef.AddLast(new AliExternalTrackParam(*fOp));
if (fHMPIDp) arrayRef.AddLast(new AliExternalTrackParam(*fHMPIDp));
Double_t mpos[3]={0,0,0};
Int_t entries=arrayRef.GetEntries();
for (Int_t i=0;i<entries;i++){
Double_t pos[3];
((AliExternalTrackParam*)arrayRef.At(i))->GetXYZ(pos);
mpos[0]+=pos[0]/entries;
mpos[1]+=pos[1]/entries;
mpos[2]+=pos[2]/entries;
}
Float_t fi= TMath::ATan2(mpos[1],mpos[0]);
for (Int_t i=0;i<entries;i++){
Bool_t res = ((AliExternalTrackParam*)arrayRef.At(i))->Rotate(fi);
if (!res) delete arrayRef.RemoveAt(i);
}
Int_t counter=0;
for (Double_t r=minR; r<maxR; r+=stepR){
Double_t sweight=0;
Double_t mlpos[3]={0,0,0};
for (Int_t i=0;i<entries;i++){
Double_t point[3]={0,0,0};
AliExternalTrackParam *param = ((AliExternalTrackParam*)arrayRef.At(i));
if (!param) continue;
if (param->GetXYZAt(r,magF,point)){
Double_t weight = 1./(10.+(r-param->GetX())*(r-param->GetX()));
sweight+=weight;
mlpos[0]+=point[0]*weight;
mlpos[1]+=point[1]*weight;
mlpos[2]+=point[2]*weight;
}
}
if (sweight>0){
mlpos[0]/=sweight;
mlpos[1]/=sweight;
mlpos[2]/=sweight;
pol->SetPoint(counter,mlpos[0],mlpos[1], mlpos[2]);
counter++;
}
}
}
void AliESDtrack::SetITSdEdxSamples(const Double_t s[4]) {
for (Int_t i=0; i<4; i++) fITSdEdxSamples[i]=s[i];
}
void AliESDtrack::GetITSdEdxSamples(Double_t s[4]) const {
for (Int_t i=0; i<4; i++) s[i]=fITSdEdxSamples[i];
}
UShort_t AliESDtrack::GetTPCnclsS(Int_t i0,Int_t i1) const{
return fTPCSharedMap.CountBits(i0)-fTPCSharedMap.CountBits(i1);
}
UShort_t AliESDtrack::GetTPCncls(Int_t i0,Int_t i1) const{
return fTPCClusterMap.CountBits(i0)-fTPCClusterMap.CountBits(i1);
}
Double_t AliESDtrack::GetChi2TPCConstrainedVsGlobal(const AliESDVertex* vtx) const
{
if (fCacheChi2TPCConstrainedVsGlobalVertex == vtx)
return fCacheChi2TPCConstrainedVsGlobal;
fCacheChi2TPCConstrainedVsGlobal = -1;
fCacheChi2TPCConstrainedVsGlobalVertex = vtx;
Double_t x[3];
GetXYZ(x);
Double_t b[3];
AliTrackerBase::GetBxByBz(x,b);
if (!fTPCInner) {
AliWarning("Could not get TPC Inner Param.");
return fCacheChi2TPCConstrainedVsGlobal;
}
AliExternalTrackParam* tpcInnerC = new AliExternalTrackParam(*fTPCInner);
if (!tpcInnerC) {
AliWarning("Clone of TPCInnerParam failed.");
return fCacheChi2TPCConstrainedVsGlobal;
}
Bool_t isOK = tpcInnerC->Rotate(GetAlpha());
isOK &= tpcInnerC->PropagateTo(GetX(), b[2]);
if (!isOK) {
delete tpcInnerC;
tpcInnerC = 0;
AliWarning("Rotation/Propagation of track failed.") ;
return fCacheChi2TPCConstrainedVsGlobal;
}
isOK = tpcInnerC->ConstrainToVertex(vtx, b);
isOK &= tpcInnerC->Rotate(GetAlpha());
isOK &= tpcInnerC->PropagateTo(GetX(), b[2]);
if (!isOK) {
AliWarning("ConstrainTPCInner failed.") ;
delete tpcInnerC;
tpcInnerC = 0;
return fCacheChi2TPCConstrainedVsGlobal;
}
TMatrixD deltaT(5,1);
TMatrixD delta(1,5);
TMatrixD covarM(5,5);
for (Int_t ipar=0; ipar<5; ipar++) {
deltaT(ipar,0) = tpcInnerC->GetParameter()[ipar] - GetParameter()[ipar];
delta(0,ipar) = tpcInnerC->GetParameter()[ipar] - GetParameter()[ipar];
for (Int_t jpar=0; jpar<5; jpar++) {
Int_t index = GetIndex(ipar,jpar);
covarM(ipar,jpar) = GetCovariance()[index]+tpcInnerC->GetCovariance()[index];
}
}
TMatrixD covarMInv = covarM.Invert();
TMatrixD mat2 = covarMInv*deltaT;
TMatrixD chi2 = delta*mat2;
delete tpcInnerC;
tpcInnerC = 0;
fCacheChi2TPCConstrainedVsGlobal = chi2(0,0);
return fCacheChi2TPCConstrainedVsGlobal;
}
void AliESDtrack::SetDetectorPID(const AliDetectorPID *pid)
{
if (fDetectorPID) delete fDetectorPID;
fDetectorPID=pid;
}
Double_t AliESDtrack::GetLengthInActiveZone( Int_t mode, Double_t deltaY, Double_t deltaZ, Double_t bz, Double_t exbPhi , TTreeSRedirector * pcstream) const {
if (mode==0) return GetLengthInActiveZone(this, deltaY,deltaZ,bz, exbPhi,pcstream);
if (mode==1) return GetLengthInActiveZone(fIp, deltaY,deltaZ,bz, exbPhi,pcstream);
if (mode==2) return GetLengthInActiveZone(fOp, deltaY,deltaZ,bz, exbPhi,pcstream);
return 0;
}
Double_t AliESDtrack::GetLengthInActiveZone(const AliExternalTrackParam *paramT, Double_t deltaY, Double_t deltaZ, Double_t bz, Double_t exbPhi , TTreeSRedirector * pcstream) {
const Double_t rIn=85;
const Double_t rOut=245;
Double_t xyz[3], pxyz[3];
if (paramT->GetXYZAt(rIn,bz,xyz)){
paramT->GetPxPyPzAt(rIn,bz,pxyz);
}else{
paramT->GetXYZ(xyz);
paramT->GetPxPyPz(pxyz);
}
Double_t dca = -paramT->GetD(0,0,bz);
Double_t radius= TMath::Abs(1/paramT->GetC(bz));
Double_t sign = paramT->GetSign();
Double_t R0 = TMath::Sqrt(xyz[0]*xyz[0]+xyz[1]*xyz[1]);
Double_t phiR0 = TMath::ATan2(xyz[1],xyz[0]);
Double_t dPhiR0= -TMath::ASin((dca*dca-2*dca*radius*sign+R0*R0)/(2*R0*(dca-radius*sign)));
Double_t phi0 = phiR0-(dPhiR0);
AliExternalTrackParam paramR=(*paramT);
Double_t length=0;
for (Double_t R=rIn; R<=rOut; R++){
Double_t sinPhi=(dca*dca-2*dca*radius*sign+R*R)/(2*R*(dca-radius*sign));
if (TMath::Abs(sinPhi)>=1) continue;
Double_t dphi = -TMath::ASin(sinPhi);
Double_t phi = phi0+dphi;
Int_t sector = TMath::Nint(9*phi/(TMath::Pi()));
Double_t dPhiEdge = phi-(sector*TMath::Pi()/9)+exbPhi;
Double_t dX = R*TMath::Cos(phi)-xyz[0];
Double_t dY = R*TMath::Sin(phi)-xyz[1];
Double_t deltaPhi = 2*TMath::ASin(0.5*TMath::Sqrt(dX*dX+dY*dY)/radius);
Double_t z = xyz[2]+deltaPhi*radius*paramT->GetTgl();
if (TMath::Abs(dPhiEdge*R)>deltaY && TMath::Abs(z)<deltaZ){
length++;
}
if (pcstream){
AliExternalTrackParam paramTcopy=(*paramT);
paramR.Rotate(phi);
paramR.PropagateTo(R,bz);
(*pcstream)<<"debugEdge"<<
"R="<<R<<
"dphiEdge="<<dPhiEdge<<
"phi0="<<phi0<<
"phi="<<phi<<
"z="<<z<<
"pT.="<<¶mTcopy<<
"pR.="<<¶mR<<
"\n";
}
}
return length;
}
Double_t AliESDtrack::GetMassForTracking() const
{
int pid = fPIDForTracking;
if (pid<AliPID::kPion) pid = AliPID::kPion;
double m = AliPID::ParticleMass(pid);
return (fPIDForTracking==AliPID::kHe3 || fPIDForTracking==AliPID::kAlpha) ? -m : m;
}
void AliESDtrack::SetTOFclusterArray(Int_t ,Int_t *){
AliInfo("Method has to be implemented!");
}
void AliESDtrack::SuppressTOFMatches()
{
if (!fNtofClusters || !GetESDEvent()) return;
TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
for (;fNtofClusters--;) {
AliESDTOFCluster* clTOF = (AliESDTOFCluster*)tofclArray->At(fTOFcluster[fNtofClusters]);
clTOF->SuppressMatchedTrack(GetID());
if (!clTOF->GetNMatchableTracks()) {
int last = tofclArray->GetEntriesFast()-1;
AliESDTOFCluster* clTOFL = (AliESDTOFCluster*)tofclArray->At(last);
if (last != fTOFcluster[fNtofClusters]) {
*clTOF = *clTOFL;
clTOF->FixSelfReferences(last,fTOFcluster[fNtofClusters]);
}
tofclArray->RemoveAt(last);
}
}
}
void AliESDtrack::ReplaceTOFTrackID(int oldID, int newID)
{
if (!fNtofClusters || !GetESDEvent()) return;
TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
for (int it=fNtofClusters;it--;) {
AliESDTOFCluster* clTOF = (AliESDTOFCluster*)tofclArray->At(fTOFcluster[it]);
clTOF->ReplaceMatchedTrackID(oldID,newID);
}
}
void AliESDtrack::ReplaceTOFClusterID(int oldID, int newID)
{
if (!fNtofClusters || !GetESDEvent()) return;
for (int it=fNtofClusters;it--;) {
if (fTOFcluster[it] == oldID) {
fTOFcluster[it] = newID;
return;
}
}
}
void AliESDtrack::ReplaceTOFMatchID(int oldID, int newID)
{
if (!fNtofClusters || !GetESDEvent()) return;
TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
for (int it=fNtofClusters;it--;) {
AliESDTOFCluster* clTOF = (AliESDTOFCluster*)tofclArray->At(fTOFcluster[it]);
clTOF->ReplaceMatchID(oldID,newID);
}
}
void AliESDtrack::AddTOFcluster(Int_t icl)
{
fNtofClusters++;
Int_t *old = fTOFcluster;
fTOFcluster = new Int_t[fNtofClusters];
for(Int_t i=0;i < fNtofClusters-1;i++) fTOFcluster[i] = old[i];
fTOFcluster[fNtofClusters-1] = icl;
if(fNtofClusters-1) delete[] old;
}
void AliESDtrack::SetTOFsignal(Double_t tof)
{
if(fNtofClusters>0 && GetESDEvent()){
TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
AliESDTOFCluster *tofcl = (AliESDTOFCluster *) tofclArray->At(fTOFcluster[0]);
AliESDTOFHit* hit = tofcl->GetTOFHit(0);
if(hit) hit->SetTime(tof);
}
else{
if(fNtofClusters>0) AliInfo("No AliESDEvent available here!\n");
fTOFsignal=tof;
}
}
void AliESDtrack::SetTOFCalChannel(Int_t index){
if(fNtofClusters>0 && GetESDEvent()){
TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
AliESDTOFCluster *tofcl = (AliESDTOFCluster *) tofclArray->At(fTOFcluster[0]);
AliESDTOFHit* hit = tofcl->GetTOFHit(0);
if(hit) hit->SetTOFchannel(index);
}
else{
if(fNtofClusters>0) AliInfo("No AliESDEvent available here!\n");
fTOFCalChannel=index;
}
}
void AliESDtrack::SetTOFsignalToT(Double_t ToT){
if(fNtofClusters>0 && GetESDEvent()){
TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
AliESDTOFCluster *tofcl = (AliESDTOFCluster *) tofclArray->At(fTOFcluster[0]);
AliESDTOFHit* hit = tofcl->GetTOFHit(0);
if(hit) hit->SetTOT(ToT);
}
else{
if(fNtofClusters>0) AliInfo("No AliESDEvent available here!\n");
fTOFsignalToT=ToT;
}
}
void AliESDtrack::SetTOFsignalRaw(Double_t tof){
if(fNtofClusters>0 && GetESDEvent()){
TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
AliESDTOFCluster *tofcl = (AliESDTOFCluster *) tofclArray->At(fTOFcluster[0]);
AliESDTOFHit* hit = tofcl->GetTOFHit(0);
if(hit) hit->SetTimeRaw(tof);
}
else{
if(fNtofClusters>0) AliInfo("No AliESDEvent available here!\n");
fTOFsignalRaw=tof;
}
}
void AliESDtrack::SetTOFsignalDz(Double_t dz){
Int_t index = -1;
AliESDTOFCluster *tofcl;
if(fNtofClusters>0 && GetESDEvent()){
TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
tofcl = (AliESDTOFCluster *) tofclArray->At(fTOFcluster[0]);
for(Int_t i=0;i < tofcl->GetNMatchableTracks();i++){
if(tofcl->GetTrackIndex(i) == GetID()) index = i;
}
}
if(index > -1){
AliESDTOFMatch* match = tofcl->GetTOFMatch(index);
if(match){
match->SetDz(dz);
}
}
else{
if(fNtofClusters>0) AliInfo("No AliESDEvent available here!\n");
fTOFsignalDz=dz;
}
}
void AliESDtrack::SetTOFsignalDx(Double_t dx){
Int_t index = -1;
AliESDTOFCluster *tofcl;
if(fNtofClusters>0 && GetESDEvent()){
TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
tofcl = (AliESDTOFCluster *) tofclArray->At(fTOFcluster[0]);
for(Int_t i=0;i < tofcl->GetNMatchableTracks();i++){
if(tofcl->GetTrackIndex(i) == GetID()) index = i;
}
}
if(index > -1){
AliESDTOFMatch* match = tofcl->GetTOFMatch(index);
if(match){
match->SetDx(dx);
}
}
else{
if(fNtofClusters>0) AliInfo("No AliESDEvent available here!\n");
fTOFsignalDx=dx;
}
}
void AliESDtrack::SetTOFDeltaBC(Short_t deltaBC){
if(fNtofClusters>0 && GetESDEvent()){
TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
AliESDTOFCluster *tofcl = (AliESDTOFCluster *) tofclArray->At(fTOFcluster[0]);
AliESDTOFHit* hit = tofcl->GetTOFHit(0);
if(hit) hit->SetDeltaBC(deltaBC);
}
else{
if(fNtofClusters>0) AliInfo("No AliESDEvent available here!\n");
fTOFdeltaBC=deltaBC;
}
}
void AliESDtrack::SetTOFL0L1(Short_t l0l1){
if(fNtofClusters>0 && GetESDEvent()){
TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
AliESDTOFCluster *tofcl = (AliESDTOFCluster *) tofclArray->At(fTOFcluster[0]);
AliESDTOFHit* hit = tofcl->GetTOFHit(0);
if(hit) hit->SetL0L1Latency(l0l1);
}
else{
if(fNtofClusters>0) AliInfo("No AliESDEvent available here!\n");
fTOFl0l1=l0l1;
}
}
Double_t AliESDtrack::GetTOFsignal() const
{
if(fNtofClusters>0 && GetESDEvent()){
TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
AliESDTOFCluster *tofcl = (AliESDTOFCluster *) tofclArray->At(fTOFcluster[0]);
return tofcl->GetTime();
}
else if(fNtofClusters>0) AliInfo("No AliESDEvent available here!\n");
return fTOFsignal;
}
Double_t AliESDtrack::GetTOFsignalToT() const
{
if(fNtofClusters>0 && GetESDEvent()){
TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
AliESDTOFCluster *tofcl = (AliESDTOFCluster *) tofclArray->At(fTOFcluster[0]);
return tofcl->GetTOT();
}
else if(fNtofClusters>0) AliInfo("No AliESDEvent available here!\n");
return fTOFsignalToT;
}
Double_t AliESDtrack::GetTOFsignalRaw() const
{
if(fNtofClusters>0 && GetESDEvent()){
TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
AliESDTOFCluster *tofcl = (AliESDTOFCluster *) tofclArray->At(fTOFcluster[0]);
return tofcl->GetTimeRaw();
}
else if(fNtofClusters>0) AliInfo("No AliESDEvent available here!\n");
return fTOFsignalRaw;
}
Double_t AliESDtrack::GetTOFsignalDz() const
{
AliESDTOFCluster *tofcl;
Int_t index = -1;
if(fNtofClusters>0 && GetESDEvent()){
TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
tofcl = (AliESDTOFCluster *) tofclArray->At(fTOFcluster[0]);
for(Int_t i=0;i < tofcl->GetNMatchableTracks();i++){
if(tofcl->GetTrackIndex(i) == GetID()) index = i;
}
}
else if(fNtofClusters>0) AliInfo("No AliESDEvent available here!\n");
if(fNtofClusters>0 && index > -1){
return tofcl->GetDz(index);
}
return fTOFsignalDz;
}
Double_t AliESDtrack::GetTOFsignalDx() const
{
AliESDTOFCluster *tofcl;
Int_t index = -1;
if(fNtofClusters>0 && GetESDEvent()){
TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
tofcl = (AliESDTOFCluster *) tofclArray->At(fTOFcluster[0]);
for(Int_t i=0;i < tofcl->GetNMatchableTracks();i++){
if(tofcl->GetTrackIndex(i) == GetID()) index = i;
}
}
else if(fNtofClusters>0) AliInfo("No AliESDEvent available here!\n");
if(fNtofClusters>0 && index > -1){
return tofcl->GetDx(index);
}
return fTOFsignalDx;
}
Short_t AliESDtrack::GetTOFDeltaBC() const
{
if(fNtofClusters>0 && GetESDEvent()){
TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
AliESDTOFCluster *tofcl = (AliESDTOFCluster *) tofclArray->At(fTOFcluster[0]);
return tofcl->GetDeltaBC();
}
else if(fNtofClusters>0) AliInfo("No AliESDEvent available here!\n");
return fTOFdeltaBC;
}
Short_t AliESDtrack::GetTOFL0L1() const
{
if(fNtofClusters>0 && GetESDEvent()){
TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
AliESDTOFCluster *tofcl = (AliESDTOFCluster *) tofclArray->At(fTOFcluster[0]);
return tofcl->GetL0L1Latency();
}
else if(fNtofClusters>0) AliInfo("No AliESDEvent available here!\n");
return fTOFl0l1;
}
Int_t AliESDtrack::GetTOFCalChannel() const
{
if(fNtofClusters>0 && GetESDEvent()){
TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
AliESDTOFCluster *tofcl = (AliESDTOFCluster *) tofclArray->At(fTOFcluster[0]);
return tofcl->GetTOFchannel();
}
else if(fNtofClusters>0) AliInfo("No AliESDEvent available here!\n");
return fTOFCalChannel;
}
Int_t AliESDtrack::GetTOFcluster() const
{
if(fNtofClusters>0 && GetESDEvent()){
TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
AliESDTOFCluster *tofcl = (AliESDTOFCluster *) tofclArray->At(fTOFcluster[0]);
return tofcl->GetClusterIndex();
}
else if(fNtofClusters>0) AliInfo("No AliESDEvent available here!\n");
return fTOFindex;
}
Int_t AliESDtrack::GetTOFclusterN() const
{
return fNtofClusters;
}
Bool_t AliESDtrack::IsTOFHitAlreadyMatched() const{
if(fNtofClusters>0 && GetESDEvent()){
TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
AliESDTOFCluster *tofcl = (AliESDTOFCluster *) tofclArray->At(fTOFcluster[0]);
if (tofcl->GetNMatchableTracks() > 1)
return kTRUE;
}
else if(fNtofClusters>0) AliInfo("No AliESDEvent available here!\n");
return kFALSE;
}
void AliESDtrack::ReMapTOFcluster(Int_t ncl,Int_t *mapping){
for(Int_t i=0;i<fNtofClusters;i++){
if(fTOFcluster[i]<ncl && fTOFcluster[i]>-1)
fTOFcluster[i] = mapping[fTOFcluster[i]];
else
AliInfo(Form("TOF cluster re-mapping in AliESDtrack: out of range (%i > %i)\n",fTOFcluster[i],ncl));
}
}
void AliESDtrack::SortTOFcluster(){
TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
for(Int_t i=0;i<fNtofClusters-1;i++){
for(Int_t j=i+1;j<fNtofClusters;j++){
AliESDTOFCluster *tofcl = (AliESDTOFCluster *) tofclArray->At(fTOFcluster[i]);
Int_t index1 = -1;
for(Int_t it=0;it < tofcl->GetNMatchableTracks();it++){
if(tofcl->GetTrackIndex(it) == GetID()) index1 = it;
}
Double_t timedist1 = 10000;
for(Int_t isp=0; isp< AliPID::kSPECIESC;isp++){
Double_t timec = TMath::Abs(tofcl->GetTime() - tofcl->GetIntegratedTime(isp));
if(timec < timedist1) timedist1 = timec;
}
timedist1 *= 0.03;
Double_t radius1 = tofcl->GetDx(index1)*tofcl->GetDx(index1) + tofcl->GetDz(index1)*tofcl->GetDz(index1) + timedist1*timedist1;
AliESDTOFCluster *tofcl2 = (AliESDTOFCluster *) tofclArray->At(fTOFcluster[j]);
Int_t index2 = -1;
for(Int_t it=0;it < tofcl2->GetNMatchableTracks();it++){
if(tofcl2->GetTrackIndex(it) == GetID()) index2 = it;
}
if(index1 == -1 || index2 == -1){
}
Double_t timedist2 = 10000;
for(Int_t isp=0; isp< AliPID::kSPECIESC;isp++){
Double_t timec = TMath::Abs(tofcl2->GetTime() - tofcl2->GetIntegratedTime(isp));
if(timec < timedist2) timedist2 = timec;
}
timedist2 *= 0.03;
Double_t radius2 = tofcl2->GetDx(index2)*tofcl2->GetDx(index2) + tofcl2->GetDz(index2)*tofcl2->GetDz(index2) + timedist2*timedist2;
if(radius2 < radius1){
Int_t change = fTOFcluster[i];
fTOFcluster[i] = fTOFcluster[j];
fTOFcluster[j] = change;
}
}
}
}
const AliTOFHeader* AliESDtrack::GetTOFHeader() const {
return fESDEvent->GetTOFHeader();
}
void AliESDtrack::SetID(Short_t id)
{
if (fNtofClusters) ReplaceTOFTrackID(fID,id);
fID=id;
}
Double_t AliESDtrack::GetdEdxInfo(Int_t regionID, Int_t calibID, Int_t qID, Int_t valueID){
if (!fTPCdEdxInfo) return 0;
if (!fIp) return 0;
return fTPCdEdxInfo->GetdEdxInfo(fIp, regionID, calibID, qID, valueID);
}
Double_t AliESDtrack::GetdEdxInfoTRD(Int_t method, Double_t p0, Double_t p1, Double_t p2){
Int_t nSlicesPerLayer=GetNumberOfTRDslices();
Int_t nSlicesAll=GetNumberOfTRDslices()*kTRDnPlanes;
if (method<=3){
Double_t sumAmp=0;
Int_t sumW=0;
for (Int_t ibin=0; ibin<nSlicesAll; ibin++){
if (fTRDslices[ibin]<=0) continue;
sumW++;
if (method==0) sumAmp+=fTRDslices[ibin];
if (method==1) sumAmp+=TMath::Log(TMath::Abs(fTRDslices[ibin])+p0);
if (method==2) sumAmp+=1/TMath::Sqrt(TMath::Abs(fTRDslices[ibin])+p0);
if (method==3) sumAmp+=TMath::Power(TMath::Abs(fTRDslices[ibin])+p0,p1);
}
if (sumW==0) return 0;
Double_t dEdx=sumAmp/sumW;
if (method==1) dEdx= TMath::Exp(dEdx);
if (method==2) dEdx= 1/(dEdx*dEdx);
if (method==3) dEdx= TMath::Power(dEdx,1/p1);
return dEdx;
}
if (method>3){
Double_t sumWT=0;
Double_t sumW=0;
for (Int_t ibin=0; ibin<nSlicesAll; ibin++){
if (fTRDslices[ibin]<=0) continue;
Double_t time=(ibin%nSlicesPerLayer);
Double_t weight=fTRDslices[ibin];
if (method==5) weight=TMath::Log((weight+p0)/p0);
if (method==6) weight=TMath::Power(weight+p0,p1);
sumWT+=time*weight;
sumW+=weight;
}
if (sumW<=0) return 0;
Double_t meanTime=sumWT/sumW;
return meanTime;
}
return 0;
}