#include "TPolyMarker3D.h"
#include "AliTrackerBase.h"
#include "AliTPCdEdxInfo.h"
+#include "AliDetectorPID.h"
+#include "TTreeStream.h"
+#include "TObjArray.h"
ClassImp(AliESDtrack)
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),
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),
fTRDncls(0),
fTRDncls0(0),
fTRDntracklets(0),
+ fTRDNchamberdEdx(0),
+ fTRDNclusterdEdx(0),
fTRDnSlices(0),
fTRDslices(0x0),
fVertexID(-2),// -2 means an orphan track
+ fPIDForTracking(AliPID::kPion),
fESDEvent(0),
fCacheNCrossedRows(-10),
fCacheChi2TPCConstrainedVsGlobal(-10),
- fCacheChi2TPCConstrainedVsGlobalVertex(0)
+ fCacheChi2TPCConstrainedVsGlobalVertex(0),
+ fDetectorPID(0x0),
+ fTrackPhiOnEMCal(-999),
+ fTrackEtaOnEMCal(-999),
+ fTrackPtOnEMCal(-999),
+ fNtofClusters(0),
+ fTOFcluster(NULL)
{
//
// The default ESD constructor
Int_t i;
for (i=kNITSchi2Std;i--;) fITSchi2Std[i] = 0;
- for (i=0; i<AliPID::kSPECIES; i++) {
- fTrackTime[i]=0.;
- fR[i]=0.;
- fITSr[i]=0.;
- fTPCr[i]=0.;
- fTRDr[i]=0.;
- fTOFr[i]=0.;
- fHMPIDr[i]=0.;
- }
for (i=0; i<3; i++) { fKinkIndexes[i]=0;}
for (i=0; i<3; i++) { fV0Indexes[i]=0;}
}
for (i=0;i<4;i++) {fITSdEdxSamples[i]=0.;}
for (i=0;i<4;i++) {fTPCPoints[i]=0;}
- for (i=0;i<3;i++) {fTOFLabel[i]=-1;}
for (i=0;i<10;i++) {fTOFInfo[i]=0;}
for (i=0;i<12;i++) {fITSModule[i]=-1;}
}
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),
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),
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)
+ fCacheChi2TPCConstrainedVsGlobalVertex(track.fCacheChi2TPCConstrainedVsGlobalVertex),
+ fDetectorPID(0x0),
+ fTrackPhiOnEMCal(track.fTrackPhiOnEMCal),
+ fTrackEtaOnEMCal(track.fTrackEtaOnEMCal),
+ fTrackPtOnEMCal(track.fTrackPtOnEMCal),
+ fNtofClusters(track.fNtofClusters),
+ fTOFcluster(NULL)
{
//
//copy constructor
//
- for (Int_t i=kNITSchi2Std;i--;) fITSchi2Std[i] = track.fTrackTime[i];
- for (Int_t i=0;i<AliPID::kSPECIES;i++) fTrackTime[i]=track.fTrackTime[i];
- for (Int_t i=0;i<AliPID::kSPECIES;i++) fR[i]=track.fR[i];
- //
- for (Int_t i=0;i<AliPID::kSPECIES;i++) fITSr[i]=track.fITSr[i];
+ 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];
+ }
//
- for (Int_t i=0;i<AliPID::kSPECIES;i++) fTPCr[i]=track.fTPCr[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<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<AliPID::kSPECIES;i++) fTRDr[i]=track.fTRDr[i];
- for (Int_t i=0;i<AliPID::kSPECIES;i++) fTOFr[i]=track.fTOFr[i];
- 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];
- for (Int_t i=0;i<AliPID::kSPECIES;i++) fHMPIDr[i]=track.fHMPIDr[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.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];
+ }
}
//_______________________________________________________________________
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),
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),
fTRDncls(0),
fTRDncls0(0),
fTRDntracklets(0),
+ fTRDNchamberdEdx(0),
+ fTRDNclusterdEdx(0),
fTRDnSlices(0),
fTRDslices(0x0),
fVertexID(-2), // -2 means an orphan track
+ fPIDForTracking(track->GetPIDForTracking()),
fESDEvent(0),
fCacheNCrossedRows(-10),
fCacheChi2TPCConstrainedVsGlobal(-10),
- fCacheChi2TPCConstrainedVsGlobalVertex(0)
+ fCacheChi2TPCConstrainedVsGlobalVertex(0),
+ fDetectorPID(0x0),
+ fTrackPhiOnEMCal(-999),
+ fTrackEtaOnEMCal(-999),
+ fTrackPtOnEMCal(-999),
+ fNtofClusters(0),
+ fTOFcluster(NULL)
{
//
// ESD track from AliVTrack.
// Reset all the arrays
Int_t i;
for (i=kNITSchi2Std;i--;) fITSchi2Std[i] = 0;
- for (i=0; i<AliPID::kSPECIES; i++) {
- fTrackTime[i]=0.;
- fR[i]=0.;
- fITSr[i]=0.;
- fTPCr[i]=0.;
- fTRDr[i]=0.;
- fTOFr[i]=0.;
- fHMPIDr[i]=0.;
- }
for (i=0; i<3; i++) { fKinkIndexes[i]=0;}
for (i=0; i<3; i++) { fV0Indexes[i]=-1;}
}
for (i=0;i<4;i++) {fITSdEdxSamples[i]=0.;}
for (i=0;i<4;i++) {fTPCPoints[i]=0;}
- for (i=0;i<3;i++) {fTOFLabel[i]=-1;}
for (i=0;i<10;i++) {fTOFInfo[i]=0;}
for (i=0;i<12;i++) {fITSModule[i]=-1;}
- // Set the ID
- SetID(track->GetID());
// Set ITS cluster map
fITSClusterMap=track->GetITSClusterMap();
// Set TPC ncls
fTPCncls=track->GetTPCNcls();
-
-
+ fTPCnclsF=track->GetTPCNclsF();
+ // TPC cluster maps
+ const TBits* bmap = track->GetTPCClusterMapPtr();
+ if (bmap) SetTPCClusterMap(*bmap);
+ bmap = GetTPCFitMapPtr();
+ if (bmap) SetTPCFitMap(*bmap);
+ bmap = GetTPCSharedMapPtr();
+ if (bmap) SetTPCSharedMap(*bmap);
+ //
// Set the combined PID
const Double_t *pid = track->PID();
- if(pid){
- for (i=0; i<AliPID::kSPECIES; i++) fR[i]=pid[i];
+ if(pid) {
+ fR = new Double32_t[AliPID::kSPECIES];
+ for (i=AliPID::kSPECIES; i--;) fR[i]=pid[i];
}
+ //
+ // calo matched cluster id
+ SetEMCALcluster(track->GetEMCALcluster());
// AliESD track label
+ //
+ // PID info
+ fITSsignal = track->GetITSsignal();
+ double itsdEdx[4];
+ track->GetITSdEdxSamples(itsdEdx);
+ SetITSdEdxSamples(itsdEdx);
+ //
+ SetTPCsignal(track->GetTPCsignal(),fTPCsignalS,track->GetTPCsignalN()); // No signalS in AODPi
+ 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());
// Set the status
SetStatus(track->GetStatus());
+ //
+ // Set the ID
+ SetID(track->GetID());
+ //
}
//_______________________________________________________________________
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),
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),
fTRDncls(0),
fTRDncls0(0),
fTRDntracklets(0),
+ fTRDNchamberdEdx(0),
+ fTRDNclusterdEdx(0),
fTRDnSlices(0),
fTRDslices(0x0),
fVertexID(-2), // -2 means an orphan track
+ fPIDForTracking(AliPID::kPion),
fESDEvent(0),
fCacheNCrossedRows(-10),
fCacheChi2TPCConstrainedVsGlobal(-10),
- fCacheChi2TPCConstrainedVsGlobalVertex(0)
+ fCacheChi2TPCConstrainedVsGlobalVertex(0),
+ fDetectorPID(0x0),
+ fTrackPhiOnEMCal(-999),
+ fTrackEtaOnEMCal(-999),
+ fTrackPtOnEMCal(-999),
+ fNtofClusters(0),
+ fTOFcluster(NULL)
{
//
// ESD track from TParticle
// Reset all the arrays
Int_t i;
for (i=kNITSchi2Std;i--;) fITSchi2Std[i] = 0;
- for (i=0; i<AliPID::kSPECIES; i++) {
- fTrackTime[i]=0.;
- fR[i]=0.;
- fITSr[i]=0.;
- fTPCr[i]=0.;
- fTRDr[i]=0.;
- fTOFr[i]=0.;
- fHMPIDr[i]=0.;
- }
for (i=0; i<3; i++) { fKinkIndexes[i]=0;}
for (i=0; i<3; i++) { fV0Indexes[i]=-1;}
}
for (i=0;i<4;i++) {fITSdEdxSamples[i]=0.;}
for (i=0;i<4;i++) {fTPCPoints[i]=0;}
- for (i=0;i<3;i++) {fTOFLabel[i]=-1;}
for (i=0;i<10;i++) {fTOFInfo[i]=0;}
for (i=0;i<12;i++) {fITSModule[i]=-1;}
// Set the PID
Int_t indexPID = 99;
+ if (pdgCode<0) pdgCode = -pdgCode;
+ for (i=0;i<AliPID::kSPECIESC;i++) if (pdgCode==AliPID::ParticleCode(i)) {indexPID = i; break;}
- switch (TMath::Abs(pdgCode)) {
-
- case 11: // electron
- indexPID = 0;
- break;
-
- case 13: // muon
- indexPID = 1;
- break;
-
- case 211: // pion
- indexPID = 2;
- break;
-
- case 321: // kaon
- indexPID = 3;
- break;
-
- case 2212: // proton
- indexPID = 4;
- break;
-
- default:
- break;
- }
-
- // If the particle is not e,mu,pi,K or p the PID probabilities are set to 0
- if (indexPID < AliPID::kSPECIES) {
- fR[indexPID]=1.;
- fITSr[indexPID]=1.;
- fTPCr[indexPID]=1.;
- fTRDr[indexPID]=1.;
- fTOFr[indexPID]=1.;
- fHMPIDr[indexPID]=1.;
+ if (indexPID < AliPID::kSPECIESC) fPIDForTracking = indexPID;
- }
// AliESD track label
SetLabel(part->GetUniqueID());
delete fOp;
delete fHMPIDp;
delete fCp;
- if (fFriendTrack) delete fFriendTrack;
- if (fTPCdEdxInfo) delete fTPCdEdxInfo;
- fFriendTrack=NULL;
+ delete fFriendTrack;
+ delete fTPCdEdxInfo;
if(fTRDnSlices)
delete[] fTRDslices;
+
+ //Reset cached values - needed for TClonesArray in AliESDInputHandler
+ 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){
-
+//_______________________________________________________________________
+AliESDtrack &AliESDtrack::operator=(const AliESDtrack &source)
+{
+ // == operator
if(&source == this) return *this;
AliExternalTrackParam::operator=(source);
}
else{
// no track param delete the old one
- if(fCp)delete fCp;
+ delete fCp;
fCp = 0;
}
}
else{
// no track param delete the old one
- if(fIp)delete fIp;
+ delete fIp;
fIp = 0;
}
}
else{
// no track param delete the old one
- if(fTPCInner)delete fTPCInner;
+ delete fTPCInner;
fTPCInner = 0;
}
}
else{
// no track param delete the old one
- if(fOp)delete fOp;
+ delete fOp;
fOp = 0;
}
}
else{
// no track param delete the old one
- if(fHMPIDp)delete fHMPIDp;
+ delete fHMPIDp;
fHMPIDp = 0;
}
}
fTPCLabel = source.fTPCLabel;
fTRDLabel = source.fTRDLabel;
- for(int i = 0; i< 3;++i){
- fTOFLabel[i] = source.fTOFLabel[i];
+ 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;
fV0Indexes[i] = source.fV0Indexes[i];
}
- for(int i = 0; i< AliPID::kSPECIES;++i){
- fR[i] = source.fR[i];
- fITSr[i] = source.fITSr[i];
- fTPCr[i] = source.fTPCr[i];
- fTRDr[i] = source.fTRDr[i];
- fTOFr[i] = source.fTOFr[i];
- fHMPIDr[i] = source.fHMPIDr[i];
- fTrackTime[i] = source.fTrackTime[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;
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];
fTRDQuality = source.fTRDQuality;
fTRDBudget = source.fTRDBudget;
fTOFsignal = source.fTOFsignal;
+ fTOFsignalTuned = source.fTOFsignalTuned;
fTOFsignalToT = source.fTOFsignalToT;
fTOFsignalRaw = source.fTOFsignalRaw;
fTOFsignalDz = source.fTOFsignalDz;
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;
}
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.fTPCnclsFIter1 = fTPCnclsFIter1;
// PID
- for(int i=0;i<AliPID::kSPECIES;++i){
- track.fTPCr[i] = fTPCr[i];
- // combined PID is TPC only!
- track.fR[i] = fTPCr[i];
+ 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;
fTrackLength = 0;
- for (Int_t i=0;i<AliPID::kSPECIES;i++) fTrackTime[i] = 0;
+ if(fTrackTime)
+ for (Int_t i=0;i<AliPID::kSPECIESC;i++) fTrackTime[i] = 0;
// Reset track parameters constrained to the primary vertex
delete fCp;fCp = 0;
fITSSharedMap=0;
fITSsignal = 0;
for (Int_t i=0;i<4;i++) fITSdEdxSamples[i] = 0.;
- for (Int_t i=0;i<AliPID::kSPECIES;i++) fITSr[i]=0;
+ if (fITSr) for (Int_t i=0;i<AliPID::kSPECIES;i++) fITSr[i]=0;
fITSLabel = 0;
// Reset TPC related track information
fTPCClusterMap = 0;
fTPCSharedMap = 0;
fTPCsignal= 0;
+ fTPCsignalTuned= 0;
fTPCsignalS= 0;
fTPCsignalN= 0;
- for (Int_t i=0;i<AliPID::kSPECIES;i++) fTPCr[i]=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;
fTRDncls = 0;
fTRDncls0 = 0;
fTRDsignal = 0;
+ fTRDNchamberdEdx = 0;
+ fTRDNclusterdEdx = 0;
+
for (Int_t i=0;i<kTRDnPlanes;i++) {
fTRDTimBin[i] = 0;
}
- for (Int_t i=0;i<AliPID::kSPECIES;i++) fTRDr[i] = 0;
+ if (fTRDr) for (Int_t i=0;i<AliPID::kSPECIES;i++) fTRDr[i] = 0;
fTRDLabel = 0;
fTRDQuality = 0;
fTRDntracklets = 0;
fTOFsignalDx = 999;
fTOFdeltaBC = 999;
fTOFl0l1 = 999;
- for (Int_t i=0;i<AliPID::kSPECIES;i++) fTOFr[i] = 0;
- for (Int_t i=0;i<3;i++) fTOFLabel[i] = -1;
+ 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;
// Reset HMPID related track information
fHMPIDqn = 0;
fHMPIDcluIdx = -1;
fHMPIDsignal = 0;
- for (Int_t i=0;i<AliPID::kSPECIES;i++) fHMPIDr[i] = 0;
+ if (fHMPIDr) for (Int_t i=0;i<AliPID::kSPECIES;i++) fHMPIDr[i] = 0;
fHMPIDtrkTheta = 0;
fHMPIDtrkPhi = 0;
fHMPIDtrkX = 0;
fGlobalChi2 = 0;
fVertexID = -2; // an orphan track
-
+ fPIDForTracking = AliPID::kPion;
+ //
delete fFriendTrack; fFriendTrack = 0;
}
//_______________________________________________________________________
-Int_t AliESDtrack::GetPID() const
+Int_t AliESDtrack::GetPID(Bool_t tpcOnly) const
{
- // Returns the particle most probable id
+ // Returns the particle most probable id. For backward compatibility first the prob. arrays
+ // will be checked, but normally the GetPIDForTracking will be returned
Int_t i;
- for (i=0; i<AliPID::kSPECIES-1; i++) if (fR[i] != fR[i+1]) break;
- //
- if (i == AliPID::kSPECIES-1) return AliPID::kPion; // If all the probabilities are equal, return the pion mass
+ const Double32_t *prob = 0;
+ if (tpcOnly) { // check if TPCpid is valid
+ 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; // not valid, try with combined pid
+ }
+ if (!prob) { // either requested TPCpid is not valid or comb.pid is requested
+ 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(); // If all the probabilities are equal, return the pion mass
+ }
//
Float_t max=0.;
Int_t k=-1;
- for (i=0; i<AliPID::kSPECIES; i++) if (fR[i]>max) {k=i; max=fR[i];}
+ for (i=0; i<AliPID::kSPECIES; i++) if (prob[i]>max) {k=i; max=prob[i];}
//
if (k==0) { // dE/dx "crossing points" in the TPC
+ /*
Double_t p=GetP();
if ((p>0.38)&&(p<0.48))
- if (fR[0]<fR[3]*10.) return AliPID::kKaon;
+ if (prob[0]<prob[3]*10.) return AliPID::kKaon;
if ((p>0.75)&&(p<0.85))
- if (fR[0]<fR[4]*10.) return AliPID::kProton;
+ if (prob[0]<prob[4]*10.) return AliPID::kProton;
+ */
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;
- AliWarning("Undefined PID !");
- return AliPID::kPion;
+ // AliWarning("Undefined PID !");
+ return GetPIDForTracking();
}
//_______________________________________________________________________
-Int_t AliESDtrack::GetTOFBunchCrossing(Double_t b) const
+Int_t AliESDtrack::GetTOFBunchCrossing(Double_t b, Bool_t pidTPConly) const
{
// Returns the number of bunch crossings after trigger (assuming 25ns spacing)
const double kSpacing = 25e3; // min interbanch spacing
const double kShift = 0;
Int_t bcid = kTOFBCNA; // defualt one
- if (!IsOn(kTOFout) || !IsOn(kESDpid)) return bcid; // no info
+ if (!IsOn(kTOFout)/* || !IsOn(kESDpid)*/) return bcid; // no info
//
- double tdif = fTOFsignal;
+ double tdif = GetTOFsignal();
if (IsOn(kTIME)) { // integrated time info is there
- int pid = GetPID();
- tdif -= fTrackTime[pid];
+ int pid = GetPID(pidTPConly);
+ Double_t times[AliPID::kSPECIESC];
+ // old esd has only AliPID::kSPECIES times
+ GetIntegratedTimes(times,pid>=AliPID::kSPECIES ? AliPID::kSPECIESC : AliPID::kSPECIES);
+ tdif -= times[pid];
}
else { // assume integrated time info from TOF radius and momentum
const double kRTOF = 385.;
const double kCSpeed = 3.e-2; // cm/ps
double p = GetP();
if (p<0.01) return bcid;
- double m = GetMass();
+ double m = GetMass(pidTPConly);
double curv = GetC(b);
double path = TMath::Abs(curv)>kAlmost0 ? // account for curvature
2./curv*TMath::ASin(kRTOF*curv/2.)*TMath::Sqrt(1.+GetTgl()*GetTgl()) : kRTOF;
if (t->IsStartedTimeIntegral()) {
SetStatus(kTIME);
- Double_t times[10];t->GetIntegratedTimes(times); SetIntegratedTimes(times);
+ Double_t times[AliPID::kSPECIESC];
+ t->GetIntegratedTimes(times);
+ SetIntegratedTimes(times);
SetIntegratedLength(t->GetIntegratedLength());
}
delete [] indexTRD;
}
- fTRDsignal=t->GetPIDsignal();
+ //commented out by Xianguo
+ //fTRDsignal=t->GetPIDsignal();
}
break;
case kTRDbackup:
}
//_______________________________________________________________________
-void AliESDtrack::GetIntegratedTimes(Double_t *times) const {
+void AliESDtrack::GetIntegratedTimes(Double_t *times, Int_t nspec) const
+{
+ // get integrated time for requested N species
+ 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");
+
// Returns the array with integrated times for each particle hypothesis
- for (Int_t i=0; i<AliPID::kSPECIES; i++) times[i]=fTrackTime[i];
+ 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) {
+void AliESDtrack::SetIntegratedTimes(const Double_t *times)
+{
// Sets the array with integrated times for each particle hypotesis
- for (Int_t i=0; i<AliPID::kSPECIES; i++) fTrackTime[i]=times[i];
+ 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) {
+void AliESDtrack::SetITSpid(const Double_t *p)
+{
// Sets values for the probability of each particle type (in ITS)
+ if (!fITSr) fITSr = new Double32_t[AliPID::kSPECIESC];
SetPIDValues(fITSr,p,AliPID::kSPECIES);
SetStatus(AliESDtrack::kITSpid);
}
//_______________________________________________________________________
void AliESDtrack::GetITSpid(Double_t *p) const {
// Gets the probability of each particle type (in ITS)
- for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fITSr[i];
+ for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i] = fITSr ? fITSr[i] : 0;
}
//_______________________________________________________________________
}
//_______________________________________________________________________
-Float_t AliESDtrack::GetTPCClusterInfo(Int_t nNeighbours/*=3*/, Int_t type/*=0*/, Int_t row0, Int_t row1) const
+Float_t AliESDtrack::GetTPCClusterInfo(Int_t nNeighbours/*=3*/, Int_t type/*=0*/, Int_t row0, Int_t row1, Int_t bitType ) const
{
//
// TPC cluster information
// type 0: get fraction of found/findable clusters with neighbourhood definition
// 1: findable clusters with neighbourhood definition
// 2: found clusters
- //
+ // bitType:
+ // 0 - all cluster used
+ // 1 - clusters used for the kalman update
// definition of findable clusters:
// a cluster is defined as findable if there is another cluster
// within +- nNeighbours pad rows. The idea is to overcome threshold
// effects with a very simple algorithm.
//
- if (type==2) return fTPCClusterMap.CountBits();
Int_t found=0;
Int_t findable=0;
Int_t last=-nNeighbours;
+ const TBits & clusterMap = (bitType%2==0) ? fTPCClusterMap : fTPCFitMap;
- Int_t upperBound=fTPCClusterMap.GetNbits();
+ Int_t upperBound=clusterMap.GetNbits();
if (upperBound>row1) upperBound=row1;
for (Int_t i=row0; i<upperBound; ++i){
//look to current row
- if (fTPCClusterMap[i]) {
+ if (clusterMap[i]) {
last=i;
++found;
++findable;
}
//look to nNeighbours after
for (Int_t j=i+1; j<i+1+nNeighbours; ++j){
- if (fTPCClusterMap[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; // undefined type - default value
+}
+
+//_______________________________________________________________________
+Float_t AliESDtrack::GetTPCClusterDensity(Int_t nNeighbours/*=3*/, Int_t type/*=0*/, Int_t row0, Int_t row1, Int_t bitType ) const
+{
+ //
+ // TPC cluster density - only rows where signal before and after given row are used
+ // - slower function
+ // type 0: get fraction of found/findable clusters with neighbourhood definition
+ // 1: findable clusters with neighbourhood definition
+ // 2: found clusters
+ // bitType:
+ // 0 - all cluster used
+ // 1 - clusters used for the kalman update
+ // definition of findable clusters:
+ // a cluster is defined as findable if there is another cluster
+ // within +- nNeighbours pad rows. The idea is to overcome threshold
+ // effects with a very simple algorithm.
+ //
+ 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){
+ 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){
return 0; // undefined type - default value
}
+
+
+
//_______________________________________________________________________
Double_t AliESDtrack::GetTPCdensity(Int_t row0, Int_t row1) const{
//
if (idx>0) found++;
}
Float_t density=0.5;
- if (good>(row1-row0)*0.5) density = Float_t(found)/Float_t(good);
+ 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) {
// Sets values for the probability of each particle type (in TPC)
+ if (!fTPCr) fTPCr = new Double32_t[AliPID::kSPECIES];
SetPIDValues(fTPCr,p,AliPID::kSPECIES);
SetStatus(AliESDtrack::kTPCpid);
}
//_______________________________________________________________________
void AliESDtrack::GetTPCpid(Double_t *p) const {
// Gets the probability of each particle type (in TPC)
- for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fTPCr[i];
+ for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i] = fTPCr ? fTPCr[i] : 0;
}
//_______________________________________________________________________
//_______________________________________________________________________
void AliESDtrack::SetTRDpid(const Double_t *p) {
// Sets values for the probability of each particle type (in TRD)
+ if (!fTRDr) fTRDr = new Double32_t[AliPID::kSPECIES];
SetPIDValues(fTRDr,p,AliPID::kSPECIES);
SetStatus(AliESDtrack::kTRDpid);
}
//_______________________________________________________________________
void AliESDtrack::GetTRDpid(Double_t *p) const {
// Gets the probability of each particle type (in TRD)
- for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fTRDr[i];
+ for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i] = fTRDr ? fTRDr[i]:0;
}
//_______________________________________________________________________
void AliESDtrack::SetTRDpid(Int_t iSpecies, Float_t p)
{
// Sets the probability of particle type iSpecies to p (in TRD)
+ 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
{
// Returns the probability of particle type iSpecies (in TRD)
- return fTRDr[iSpecies];
+ return fTRDr ? fTRDr[iSpecies] : 0;
}
//____________________________________________________
}
Int_t ns=GetNumberOfTRDslices();
if ((slice<0) || (slice>=ns)) {
- AliError("Wrong TRD slice !");
+ AliError(Form("Wrong TRD slice %d/%d, NSlices=%d",plane,slice,ns));
return;
}
Int_t n=plane*ns + slice;
//_______________________________________________________________________
void AliESDtrack::SetTOFpid(const Double_t *p) {
// Sets the probability of each particle type (in TOF)
+ if (!fTOFr) fTOFr = new Double32_t[AliPID::kSPECIES];
SetPIDValues(fTOFr,p,AliPID::kSPECIES);
SetStatus(AliESDtrack::kTOFpid);
}
//_______________________________________________________________________
void AliESDtrack::SetTOFLabel(const Int_t *p) {
- // Sets (in TOF)
- for (Int_t i=0; i<3; i++) fTOFLabel[i]=p[i];
+
+ 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{
+ // Sets (in TOF)
+ 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 {
// Gets probabilities of each particle type (in TOF)
- for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fTOFr[i];
+ for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i] = fTOFr ? fTOFr[i]:0;
}
//_______________________________________________________________________
void AliESDtrack::GetTOFLabel(Int_t *p) const {
// Gets (in TOF)
- for (Int_t i=0; i<3; i++) p[i]=fTOFLabel[i];
+ 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];
+ }
}
//_______________________________________________________________________
//_______________________________________________________________________
void AliESDtrack::SetHMPIDpid(const Double_t *p) {
// Sets the probability of each particle type (in HMPID)
+ if (!fHMPIDr) fHMPIDr = new Double32_t[AliPID::kSPECIES];
SetPIDValues(fHMPIDr,p,AliPID::kSPECIES);
SetStatus(AliESDtrack::kHMPIDpid);
}
//_______________________________________________________________________
void AliESDtrack::GetHMPIDpid(Double_t *p) const {
// Gets probabilities of each particle type (in HMPID)
- for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fHMPIDr[i];
+ for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i] = fHMPIDr ? fHMPIDr[i]:0;
}
//_______________________________________________________________________
void AliESDtrack::SetESDpid(const Double_t *p) {
// Sets the probability of each particle type for the ESD track
+ if (!fR) fR = new Double32_t[AliPID::kSPECIES];
SetPIDValues(fR,p,AliPID::kSPECIES);
SetStatus(AliESDtrack::kESDpid);
}
//_______________________________________________________________________
void AliESDtrack::GetESDpid(Double_t *p) const {
// Gets probability of each particle type for the ESD track
- for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fR[i];
+ for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i] = fR ? fR[i]:0;
}
//_______________________________________________________________________
// Prints info on the track
AliExternalTrackParam::Print();
printf("ESD track info\n") ;
- Double_t p[AliPID::kSPECIESN] ;
+ Double_t p[AliPID::kSPECIES] ;
Int_t index = 0 ;
if( IsOn(kITSpid) ){
printf("From ITS: ") ;
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: ") ;
}
//_______________________________________________________________________
-void AliESDtrack::GetITSdEdxSamples(Double_t *s) const {
+void AliESDtrack::GetITSdEdxSamples(Double_t s[4]) const {
//
// Get the dE/dx samples measured by the two SSD and two SDD layers.
// These samples are corrected for the track segment length.
fCacheChi2TPCConstrainedVsGlobal = chi2(0,0);
return fCacheChi2TPCConstrainedVsGlobal;
}
+
+void AliESDtrack::SetDetectorPID(const AliDetectorPID *pid)
+{
+ //
+ // Set the detector 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 {
+ //
+ // Input parameters:
+ // mode - type of external track parameters
+ // deltaY - user defined "dead region" in cm
+ // deltaZ - user defined "active region" in cm (250 cm drift lenght - 14 cm L1 delay
+ // bz - magnetic field
+ // exbPhi - optional rotation due to the ExB effect
+ // return value:
+ // the length of the track in cm in "active volume" of the TPC
+ //
+ 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) {
+ //
+ // Numerical code to calculate the length of the track in active region of the TPC
+ // ( can be speed up if somebody wants to invest time - analysical version shoult be possible)
+ //
+ // Input parameters:
+ // paramT - external track parameters
+ // deltaY - user defined "dead region" in cm
+ // deltaZ - user defined "active region" in cm (250 cm drift lenght - 14 cm L1 delay
+ // bz - magnetic field
+ // exbPhi - optional rotation due to the ExB effect
+ // return value:
+ // the length of the track in cm in "active volume" of the TPC
+ //
+ 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); // get impact parameter distance to point (0,0)
+ 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]); // radius at current point
+ Double_t phiR0 = TMath::ATan2(xyz[1],xyz[0]); // angle of given point
+ Double_t dPhiR0= -TMath::ASin((dca*dca-2*dca*radius*sign+R0*R0)/(2*R0*(dca-radius*sign)));
+ Double_t phi0 = phiR0-(dPhiR0); // global phi offset to be added
+ //
+ //
+ 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; // global phi
+ Int_t sector = TMath::Nint(9*phi/(TMath::Pi()));
+ Double_t dPhiEdge = phi-(sector*TMath::Pi()/9)+exbPhi; // distance to sector boundary in rphi
+ 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++;
+ }
+ // Double_t deltaZ= dphi*radius;
+ if (pcstream){
+ //should we keep debug possibility ?
+ AliExternalTrackParam paramTcopy=(*paramT);
+ paramR.Rotate(phi);
+ paramR.PropagateTo(R,bz);
+ (*pcstream)<<"debugEdge"<<
+ "R="<<R<< // radius
+ "dphiEdge="<<dPhiEdge<< // distance to edge
+ "phi0="<<phi0<< // phi0 -phi at the track initial position
+ "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 /*ncluster*/,Int_t */*TOFcluster*/){
+ AliInfo("Method has to be implemented!");
+// fNtofClusters=ncluster;
+// if(TOFcluster == fTOFcluster) return;
+// if(fTOFcluster){ // reset previous content
+// delete[] fTOFcluster;
+// fTOFcluster = NULL;
+// fNtofClusters=0;
+// }
+
+// if(ncluster){ // set new content
+// fTOFcluster = new Int_t[fNtofClusters];
+// for(Int_t i=0;i < fNtofClusters;i++) fTOFcluster[i] = TOFcluster[i];
+// }
+// else
+// fTOFcluster = 0;
+}
+
+//____________________________________________
+void AliESDtrack::SuppressTOFMatches()
+{
+ // remove reference to this track from TOF clusters
+ if (!fNtofClusters || !GetESDEvent()) return;
+ TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
+ for (;fNtofClusters--;) {
+ AliESDTOFCluster* clTOF = (AliESDTOFCluster*)tofclArray->At(fTOFcluster[fNtofClusters]);
+ clTOF->SuppressMatchedTrack(GetID());
+ if (!clTOF->GetNMatchableTracks()) { // remove this cluster
+ int last = tofclArray->GetEntriesFast()-1;
+ AliESDTOFCluster* clTOFL = (AliESDTOFCluster*)tofclArray->At(last);
+ if (last != fTOFcluster[fNtofClusters]) {
+ *clTOF = *clTOFL; // move last cluster to the place of eliminated one
+ // fix the references on this cluster
+ clTOF->FixSelfReferences(last,fTOFcluster[fNtofClusters]);
+ }
+ tofclArray->RemoveAt(last);
+ }
+ }
+}
+
+//____________________________________________
+void AliESDtrack::ReplaceTOFTrackID(int oldID, int newID)
+{
+ // replace the ID in TOF clusters references to this track
+ 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)
+{
+ // replace the referenc on TOF cluster oldID by 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)
+{
+ // replace in the ESDTOFCluster associated with this track the id of the corresponding
+ // ESDTOFMatch from oldID to 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; // delete previous content
+
+}
+
+//____________________________________________
+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; // in cm
+ 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; // in cm
+ 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)
+{
+ // set track ID taking care about dependencies
+ if (fNtofClusters) ReplaceTOFTrackID(fID,id);
+ fID=id;
+}
+
+
+Double_t AliESDtrack::GetdEdxInfo(Int_t regionID, Int_t calibID, Int_t qID, Int_t valueID){
+ //
+ // Interface to get the calibrated dEdx information
+ // For details of arguments and return values see
+ // AliTPCdEdxInfo::GetdEdxInfo(Int_t regionID, Int_t calibID, Int_t valueID)
+ //
+ if (!fTPCdEdxInfo) return 0;
+ if (!fIp) return 0;
+ return fTPCdEdxInfo->GetdEdxInfo(fIp, regionID, calibID, qID, valueID);
+}
+