#include "TPolyMarker3D.h"
#include "AliTrackerBase.h"
#include "AliTPCdEdxInfo.h"
-#include "AliPoolsSet.h"
+#include "AliDetectorPID.h"
+#include "TTreeStream.h"
+#include "TObjArray.h"
ClassImp(AliESDtrack)
-AliPoolsSet* AliESDtrack::fgPools = 0;
-
void SetPIDValues(Double_t * dest, const Double_t * src, Int_t n) {
// This function copies "n" PID weights from "scr" to "dest"
// and normalizes their sum to 1 thus producing conditional probabilities.
fITSLabel(0),
fTPCLabel(0),
fTRDLabel(0),
+ fTOFLabel(NULL),
fTOFCalChannel(-1),
fTOFindex(-1),
fHMPIDqn(0),
fHMPIDcluIdx(-1),
fCaloIndex(kEMCALNoMatch),
+ fMassForTracking(0.13957),
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
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
//
- if (!OnlineMode()) {
- AliClonesPool* poolFr = fgPools ? fgPools->GetPoolTrFriend() : 0;
- if (poolFr) { fFriendTrack = new(poolFr->NextFreeSlot()) AliESDfriendTrack(); poolFr->RegisterClone(fFriendTrack);}
- else fFriendTrack = new AliESDfriendTrack();
- }
- //
- for (int i=kNITSchi2Std;i--;) fITSchi2Std[i] = 0;
- for (int 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.;
- }
+ if (!OnlineMode()) fFriendTrack=new AliESDfriendTrack();
+
+ Int_t i;
+ for (i=kNITSchi2Std;i--;) fITSchi2Std[i] = 0;
+ for (i=0; i<AliPID::kSPECIES; i++) fR[i]=fITSr[i]=fTPCr[i]=fTRDr[i]=fTOFr[i]=fHMPIDr[i]=0.;
- for (int i=3;i--;) fKinkIndexes[i]=0;
- for (int i=3;i--;) fV0Indexes[i]=0;
- for (int i=kTRDnPlanes;i--;) fTRDTimBin[i]=0;
- for (int i=4;i--;) {fITSdEdxSamples[i]=0.;}
- for (int i=4;i--;) {fTPCPoints[i]=0;}
- for (int i=3;i--;) {fTOFLabel[i]=-1;}
- for (int i=10;i--;) {fTOFInfo[i]=0;}
- for (int i=12;i--;) {fITSModule[i]=-1;}
+ 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;
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),
+ fMassForTracking(track.fMassForTracking),
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),
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=AliPID::kSPECIES;i--;) {
- fTrackTime[i]=track.fTrackTime[i];
- fR[i]=track.fR[i];
- fITSr[i]=track.fITSr[i];
- fTPCr[i]=track.fTPCr[i];
- }
- for (Int_t i=4;i--;) fITSdEdxSamples[i]=track.fITSdEdxSamples[i];
- for (Int_t i=4;i--;) fTPCPoints[i]=track.fTPCPoints[i];
- for (Int_t i=3;i--;) fKinkIndexes[i]=track.fKinkIndexes[i];
- for (Int_t i=3;i--;) fV0Indexes[i]=track.fV0Indexes[i];
- //
- for (Int_t i=kTRDnPlanes;i--;) fTRDTimBin[i]=track.fTRDTimBin[i];
- AliPoolN* poolN = fgPools ? fgPools->GetPoolN() : 0;
- if (fTRDnSlices) {
- if (poolN) fTRDslices = poolN->BookD32(fTRDnSlices,&fTRDslices);
- else fTRDslices = new Double32_t[fTRDnSlices];
- for (Int_t i=fTRDnSlices;i--;) fTRDslices[i] = track.fTRDslices[i];
- }
- //
- for (Int_t i=AliPID::kSPECIES;i--;) {
- fTRDr[i]=track.fTRDr[i];
- fTOFr[i]=track.fTOFr[i];
- fHMPIDr[i]=track.fHMPIDr[i];
- }
- for (Int_t i=3;i--;) fTOFLabel[i]=track.fTOFLabel[i];
- for (Int_t i=10;i--;) fTOFInfo[i]=track.fTOFInfo[i];
- for (Int_t i=12;i--;) fITSModule[i]=track.fITSModule[i];
-
+ for (Int_t i=kNITSchi2Std;i--;) fITSchi2Std[i] = track.fITSchi2Std[i];
- AliClonesPool* poolETP = fgPools ? fgPools->GetPoolExtTrPar() : 0;
- if (poolETP) {
- if (track.fCp) {fCp = new(poolETP->NextFreeSlot()) AliExternalTrackParam(*track.fCp); poolETP->RegisterClone(fCp);}
- if (track.fIp) {fIp = new(poolETP->NextFreeSlot()) AliExternalTrackParam(*track.fIp); poolETP->RegisterClone(fIp);}
- if (track.fOp) {fOp = new(poolETP->NextFreeSlot()) AliExternalTrackParam(*track.fOp); poolETP->RegisterClone(fOp);}
- if (track.fHMPIDp) {fHMPIDp = new(poolETP->NextFreeSlot()) AliExternalTrackParam(*track.fHMPIDp); poolETP->RegisterClone(fHMPIDp);}
- if (track.fTPCInner) {fTPCInner = new(poolETP->NextFreeSlot()) AliExternalTrackParam(*track.fTPCInner); poolETP->RegisterClone(fTPCInner);}
- }
- else {
- if (track.fCp) fCp=new AliExternalTrackParam(*track.fCp);
- if (track.fIp) fIp=new AliExternalTrackParam(*track.fIp);
- if (track.fOp) fOp=new AliExternalTrackParam(*track.fOp);
- if (track.fHMPIDp) fHMPIDp=new AliExternalTrackParam(*track.fHMPIDp);
- if (track.fTPCInner) fTPCInner=new AliExternalTrackParam(*track.fTPCInner);
+ if(track.fTrackTime){
+ fTrackTime = new Double32_t[AliPID::kSPECIESC];
+ for (Int_t i=0;i<AliPID::kSPECIESC;i++) fTrackTime[i]=track.fTrackTime[i];
}
+
+ for (Int_t i=0;i<AliPID::kSPECIES;i++) fR[i]=track.fR[i];
//
- if (track.fTPCdEdxInfo) {
- AliClonesPool* pooldEdx = fgPools ? fgPools->GetPoolTPCdEdx() : 0;
- if (pooldEdx) {fTPCdEdxInfo = new(pooldEdx->NextFreeSlot()) AliTPCdEdxInfo(*track.fTPCdEdxInfo); pooldEdx->RegisterClone(fTPCdEdxInfo);}
- else fTPCdEdxInfo = new AliTPCdEdxInfo(*track.fTPCdEdxInfo);
- }
+ for (Int_t i=0;i<AliPID::kSPECIES;i++) fITSr[i]=track.fITSr[i];
//
- if (track.fFriendTrack) {
- AliClonesPool* poolFr = fgPools ? fgPools->GetPoolTrFriend() : 0;
- if (poolFr) {fFriendTrack = new(poolFr->NextFreeSlot()) AliESDfriendTrack(*(track.fFriendTrack)); poolFr->RegisterClone(fFriendTrack);}
- else fFriendTrack = new AliESDfriendTrack(*(track.fFriendTrack));
+ for (Int_t i=0;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];
}
-}
-//_______________________________________________________________________
-AliESDtrack::AliESDtrack(AliESDtrack* track, Bool_t detach) :
- 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),
- fTOFCalChannel(track->fTOFCalChannel),
- fTOFindex(track->fTOFindex),
- fHMPIDqn(track->fHMPIDqn),
- fHMPIDcluIdx(track->fHMPIDcluIdx),
- fCaloIndex(track->fCaloIndex),
- fHMPIDtrkTheta(track->fHMPIDtrkTheta),
- fHMPIDtrkPhi(track->fHMPIDtrkPhi),
- fHMPIDsignal(track->fHMPIDsignal),
- 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),
- fTPCsignalS(track->fTPCsignalS),
- fTPCdEdxInfo(0),
- fTRDsignal(track->fTRDsignal),
- fTRDQuality(track->fTRDQuality),
- fTRDBudget(track->fTRDBudget),
- fTOFsignal(track->fTOFsignal),
- 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),
- fTRDnSlices(track->fTRDnSlices),
- fTRDslices(0x0),
- fVertexID(track->fVertexID),
- fESDEvent(track->fESDEvent),
- fCacheNCrossedRows(track->fCacheNCrossedRows),
- fCacheChi2TPCConstrainedVsGlobal(track->fCacheChi2TPCConstrainedVsGlobal),
- fCacheChi2TPCConstrainedVsGlobalVertex(track->fCacheChi2TPCConstrainedVsGlobalVertex)
-{
- //
- //semi-shallow copy constructor with transfer of most of pointers of the source. When detach is true, the dynamic content of
- //of source is set to 0 w/o deletion
- //
- for (Int_t i=kNITSchi2Std;i--;) fITSchi2Std[i] = track->fTrackTime[i];
- for (Int_t i=AliPID::kSPECIES;i--;) {
- fTrackTime[i]=track->fTrackTime[i];
- fR[i]=track->fR[i];
- fITSr[i]=track->fITSr[i];
- fTPCr[i]=track->fTPCr[i];
+ if (fTRDnSlices) {
+ fTRDslices=new Double32_t[fTRDnSlices];
+ for (Int_t i=0; i<fTRDnSlices; i++) fTRDslices[i]=track.fTRDslices[i];
}
- for (Int_t i=4;i--;) fITSdEdxSamples[i]=track->fITSdEdxSamples[i];
- for (Int_t i=4;i--;) fTPCPoints[i]=track->fTPCPoints[i];
- for (Int_t i=3;i--;) fKinkIndexes[i]=track->fKinkIndexes[i];
- for (Int_t i=3;i--;) fV0Indexes[i]=track->fV0Indexes[i];
- //
- for (Int_t i=kTRDnPlanes;i--;) fTRDTimBin[i]=track->fTRDTimBin[i];
- if (fTRDnSlices) fTRDslices = track->fTRDslices;
- //
- for (Int_t i=AliPID::kSPECIES;i--;) {
- fTRDr[i]=track->fTRDr[i];
- fTOFr[i]=track->fTOFr[i];
- fHMPIDr[i]=track->fHMPIDr[i];
+
+ if (track.fDetectorPID) fDetectorPID = new AliDetectorPID(*track.fDetectorPID);
+
+ 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];
+ 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=3;i--;) fTOFLabel[i]=track->fTOFLabel[i];
- for (Int_t i=10;i--;) fTOFInfo[i]=track->fTOFInfo[i];
- for (Int_t i=12;i--;) fITSModule[i]=track->fITSModule[i];
- if (track->fCp) fCp = track->fCp;
- if (track->fIp) fIp = track->fIp;
- if (track->fOp) fOp = track->fOp;
- if (track->fTPCInner) fTPCInner = track->fTPCInner;
- if (track->fHMPIDp) fHMPIDp = track->fHMPIDp;
- //
- if (track->fTPCdEdxInfo) fTPCdEdxInfo = track->fTPCdEdxInfo;
- //
- if (track->fFriendTrack) fFriendTrack = track->fFriendTrack;
- //
- if (detach) {
- track->fTRDslices = 0;
- track->fTRDnSlices = 0;
- track->fCp = track->fIp = track->fTPCInner = track->fOp = track->fHMPIDp = 0;
- track->fTPCdEdxInfo = 0;
- track->fFriendTrack = 0;
+ 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.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];
}
- //
}
//_______________________________________________________________________
fITSLabel(0),
fTPCLabel(0),
fTRDLabel(0),
+ fTOFLabel(NULL),
fTOFCalChannel(-1),
fTOFindex(-1),
fHMPIDqn(0),
fHMPIDcluIdx(-1),
fCaloIndex(kEMCALNoMatch),
+ fMassForTracking(0.13957),
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
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
- for (int i=kNITSchi2Std;i--;) fITSchi2Std[i] = 0;
- for (int 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.;
- }
+ Int_t i;
+ for (i=kNITSchi2Std;i--;) fITSchi2Std[i] = 0;
+ for (i=0; i<AliPID::kSPECIES; i++) fR[i]=fITSr[i]=fTPCr[i]=fTRDr[i]=fTOFr[i]=fHMPIDr[i]=0.;
- for (int i=3;i--;) fKinkIndexes[i]=0;
- for (int i=3;i--;) fV0Indexes[i]=-1;
- for (int i=kTRDnPlanes;i--;) fTRDTimBin[i]=0;
-
- for (int i=4;i--;) {fITSdEdxSamples[i]=0.;}
- for (int i=4;i--;) {fTPCPoints[i]=0;}
- for (int i=3;i--;) {fTOFLabel[i]=-1;}
- for (int i=10;i--;) {fTOFInfo[i]=0;}
- for (int i=12;i--;) {fITSModule[i]=-1;}
+ 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;}
// Set the ID
SetID(track->GetID());
fITSSharedMap=0;
fITSncls=0;
- for(int i=6;i--;) if(HasPointOnITSLayer(i)) fITSncls++;
- //
+ for(i=0; i<6; i++) {
+ if(HasPointOnITSLayer(i)) fITSncls++;
+ }
+
// 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 (int i=AliPID::kSPECIES;i--;) fR[i]=pid[i];
+ if(pid) for (i=0; 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);
+ SetIntegratedTimes(expt);
+ //
+ SetTrackPhiEtaPtOnEMCal(track->GetTrackPhiOnEMCal(),track->GetTrackEtaOnEMCal(),track->GetTrackPtOnEMCal());
+ //
SetLabel(track->GetLabel());
// Set the status
SetStatus(track->GetStatus());
fITSLabel(0),
fTPCLabel(0),
fTRDLabel(0),
+ fTOFLabel(NULL),
fTOFCalChannel(-1),
fTOFindex(-1),
fHMPIDqn(0),
fHMPIDcluIdx(-1),
fCaloIndex(kEMCALNoMatch),
+ fMassForTracking(0.13957),
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
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
- for (int i=kNITSchi2Std;i--;) fITSchi2Std[i] = 0;
- for (int 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.;
- }
+ Int_t i;
+ for (i=kNITSchi2Std;i--;) fITSchi2Std[i] = 0;
+ for (i=0; i<AliPID::kSPECIES; i++) fR[i]=fITSr[i]=fTPCr[i]=fTRDr[i]=fTOFr[i]=fHMPIDr[i]=0.;
- for (int i=3;i--;) fKinkIndexes[i]=0;
- for (int i=3;i--;) fV0Indexes[i]=-1;
- for (int i=kTRDnPlanes;i--;) fTRDTimBin[i]=0;
- for (int i=4;i--;) fITSdEdxSamples[i]=0.;
- for (int i=4;i--;) fTPCPoints[i]=0;
- for (int i=3;i--;) fTOFLabel[i]=-1;
- for (int i=10;i--;) fTOFInfo[i]=0;
- for (int i=12;i--;) fITSModule[i]=-1;
+ 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;}
// Calculate the AliExternalTrackParam content
alpha *= TMath::Pi();
// Covariance matrix: no errors, the parameters are exact
- for (int i=15;i--;) covar[i]=0.;
+ for (i=0; i<15; i++) covar[i]=0.;
// Get the vertex of origin and the momentum
TVector3 ver(part->Vx(),part->Vy(),part->Vz());
// Set the PID
Int_t indexPID = 99;
+ if (pdgCode<0) pdgCode = -pdgCode;
+ for (i=0;i<AliPID::kSPECIES;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 the particle is not valid charged the PID probabilities are set to 0
if (indexPID < AliPID::kSPECIES) {
fR[indexPID]=1.;
fITSr[indexPID]=1.;
}
-//_______________________________________________________________________
-void AliESDtrack::Clear(Option_t* )
-{
- //
- // clean dynamical part
- //
- //printf("Delete track\n");
- AliClonesPool* poolETP = fgPools ? fgPools->GetPoolExtTrPar() : 0;
- fTPCFitMap.Clear();
- fTPCClusterMap.Clear();
- fTPCSharedMap.Clear();
- if (poolETP) {
- if (fIp) poolETP->MarkSlotFree(fIp);
- if (fOp) poolETP->MarkSlotFree(fOp);
- if (fCp) poolETP->MarkSlotFree(fCp);
- if (fTPCInner) poolETP->MarkSlotFree(fTPCInner);
- if (fHMPIDp) poolETP->MarkSlotFree(fHMPIDp);
- }
- else {
- delete fIp;
- delete fTPCInner;
- delete fOp;
- delete fHMPIDp;
- delete fCp;
- }
- fIp = fOp = fCp = fTPCInner = fHMPIDp = 0;
- //
- if (fFriendTrack) {
- AliClonesPool* poolFr = fgPools ? fgPools->GetPoolTrFriend() : 0;
- if (poolFr) poolFr->MarkSlotFree(fFriendTrack);
- else delete fFriendTrack;
- fFriendTrack = 0;
- }
- if (fTPCdEdxInfo) {
- AliClonesPool* pooldEdx = fgPools ? fgPools->GetPoolTPCdEdx() : 0;
- if (pooldEdx) pooldEdx->MarkSlotFree(fTPCdEdxInfo);
- else delete fTPCdEdxInfo;
- fTPCdEdxInfo = 0;
- }
- if(fTRDnSlices) {
- AliPoolN* poolN = fgPools ? fgPools->GetPoolN() : 0;
- if (poolN) poolN->FreeSlot(&fTRDslices);
- else delete[] fTRDslices;
- fTRDslices = 0;
- }
- AliExternalTrackParam::Clear();
-}
-
//_______________________________________________________________________
AliESDtrack::~AliESDtrack(){
//
// This is destructor according Coding Conventrions
//
//printf("Delete track\n");
- Clear();
+ delete fIp;
+ delete fTPCInner;
+ delete fOp;
+ delete fHMPIDp;
+ delete fCp;
+ 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;
+
+ if(fTrackTime) delete[] fTrackTime;
+ if(fTOFLabel) delete[] fTOFLabel;
}
-//_______________________________________________________________________
-AliESDtrack &AliESDtrack::operator=(const AliESDtrack &source)
-{
+AliESDtrack &AliESDtrack::operator=(const AliESDtrack &source){
+
if(&source == this) return *this;
AliExternalTrackParam::operator=(source);
- AliClonesPool* poolETP = fgPools ? fgPools->GetPoolExtTrPar() : 0;
- if (source.fCp) { // we have the trackparam: assign or copy construct
- if (fCp) *fCp = *source.fCp;
- else {
- if (poolETP) {fCp = new(poolETP->NextFreeSlot()) AliExternalTrackParam(*source.fCp); poolETP->RegisterClone(fCp);}
- else fCp = new AliExternalTrackParam(*source.fCp);
- }
- }
- else { // no track param delete the old one
- if (fCp) poolETP ? poolETP->MarkSlotFree(fCp) : delete fCp; fCp = 0;
+
+ if(source.fCp){
+ // we have the trackparam: assign or copy construct
+ if(fCp)*fCp = *source.fCp;
+ else fCp = new AliExternalTrackParam(*source.fCp);
}
- //
- if (source.fIp) { // we have the trackparam: assign or copy construct
- if (fIp) *fIp = *source.fIp;
- else {
- if (poolETP) {fIp = new(poolETP->NextFreeSlot()) AliExternalTrackParam(*source.fIp); poolETP->RegisterClone(fIp);}
- else fIp = new AliExternalTrackParam(*source.fIp);
- }
+ else{
+ // no track param delete the old one
+ delete fCp;
+ fCp = 0;
}
- else { // no track param delete the old one
- if (fIp) poolETP ? poolETP->MarkSlotFree(fIp) : delete fIp; fIp = 0;
+
+ if(source.fIp){
+ // we have the trackparam: assign or copy construct
+ if(fIp)*fIp = *source.fIp;
+ else fIp = new AliExternalTrackParam(*source.fIp);
}
- //
- if (source.fTPCInner) { // we have the trackparam: assign or copy construct
- if (fTPCInner) *fTPCInner = *source.fTPCInner;
- else {
- if (poolETP) {fTPCInner = new(poolETP->NextFreeSlot()) AliExternalTrackParam(*source.fTPCInner);poolETP->RegisterClone(fTPCInner);}
- else fTPCInner = new AliExternalTrackParam(*source.fTPCInner);
- }
+ else{
+ // no track param delete the old one
+ delete fIp;
+ fIp = 0;
}
- else { // no track param delete the old one
- if (fTPCInner) poolETP ? poolETP->MarkSlotFree(fTPCInner) : delete fTPCInner; fTPCInner = 0;
+
+
+ if(source.fTPCInner){
+ // we have the trackparam: assign or copy construct
+ if(fTPCInner) *fTPCInner = *source.fTPCInner;
+ else fTPCInner = new AliExternalTrackParam(*source.fTPCInner);
}
- //
- if (source.fOp) { // we have the trackparam: assign or copy construct
- if (fOp) *fOp = *source.fOp;
- else {
- if (poolETP) {fOp = new(poolETP->NextFreeSlot()) AliExternalTrackParam(*source.fOp); poolETP->RegisterClone(fOp);}
- else fOp = new AliExternalTrackParam(*source.fOp);
- }
+ else{
+ // no track param delete the old one
+ delete fTPCInner;
+ fTPCInner = 0;
}
- else { // no track param delete the old one
- if (fOp) poolETP ? poolETP->MarkSlotFree(fOp) : delete fOp; fOp = 0;
+
+ if(source.fTPCdEdxInfo) {
+ if(fTPCdEdxInfo) *fTPCdEdxInfo = *source.fTPCdEdxInfo;
+ fTPCdEdxInfo = new AliTPCdEdxInfo(*source.fTPCdEdxInfo);
}
- //
- if (source.fHMPIDp) { // we have the trackparam: assign or copy construct
- if (fHMPIDp) *fHMPIDp = *source.fHMPIDp;
- else {
- if (poolETP) {fHMPIDp = new(poolETP->NextFreeSlot()) AliExternalTrackParam(*source.fHMPIDp); poolETP->RegisterClone(fHMPIDp);}
- else fHMPIDp = new AliExternalTrackParam(*source.fHMPIDp);
- }
+
+ if(source.fOp){
+ // we have the trackparam: assign or copy construct
+ if(fOp) *fOp = *source.fOp;
+ else fOp = new AliExternalTrackParam(*source.fOp);
}
- else { // no track param delete the old one
- if (fHMPIDp) poolETP ? poolETP->MarkSlotFree(fHMPIDp) : delete fHMPIDp; fHMPIDp = 0;
+ else{
+ // no track param delete the old one
+ delete fOp;
+ fOp = 0;
}
- //
- AliClonesPool* pooldEdx = fgPools ? fgPools->GetPoolTPCdEdx() : 0;
- if (source.fTPCdEdxInfo) {
- if (fTPCdEdxInfo) *fTPCdEdxInfo = *source.fTPCdEdxInfo;
- else {
- if (pooldEdx) {fTPCdEdxInfo = new(pooldEdx->NextFreeSlot()) AliTPCdEdxInfo(*source.fTPCdEdxInfo); pooldEdx->RegisterClone(fTPCdEdxInfo);}
- else fTPCdEdxInfo = new AliTPCdEdxInfo(*source.fTPCdEdxInfo);
- }
+
+
+ if(source.fHMPIDp){
+ // we have the trackparam: assign or copy construct
+ if(fHMPIDp) *fHMPIDp = *source.fHMPIDp;
+ else fHMPIDp = new AliExternalTrackParam(*source.fHMPIDp);
}
- else { // no dedx info, delete the old one
- if (fTPCdEdxInfo) pooldEdx ? pooldEdx->MarkSlotFree(fTPCdEdxInfo) : delete fTPCdEdxInfo; fTPCdEdxInfo = 0;
+ else{
+ // no track param delete the old one
+ delete fHMPIDp;
+ fHMPIDp = 0;
}
- //
+
// copy also the friend track
// use copy constructor
- AliClonesPool* poolFr = fgPools ? fgPools->GetPoolTrFriend() : 0;
- if (fFriendTrack) poolFr ? poolFr->MarkSlotFree(fFriendTrack) : delete fFriendTrack; fFriendTrack= 0;
- if (source.fFriendTrack) { // we have the trackparam: assign or copy construct
- if (poolFr) {
- fFriendTrack = new(poolFr->NextFreeSlot()) AliESDfriendTrack(*source.fFriendTrack);
- poolFr->RegisterClone(fFriendTrack);
- }
- else fFriendTrack = new AliESDfriendTrack(*source.fFriendTrack);
+ if(source.fFriendTrack){
+ // we have the trackparam: assign or copy construct
+ delete fFriendTrack; fFriendTrack=new AliESDfriendTrack(*source.fFriendTrack);
}
- //
- fTPCFitMap = source.fTPCFitMap;
+ else{
+ // no track param delete the old one
+ delete fFriendTrack; fFriendTrack= 0;
+ }
+
+ fTPCFitMap = source.fTPCFitMap;
fTPCClusterMap = source.fTPCClusterMap;
fTPCSharedMap = source.fTPCSharedMap;
// the simple stuff
fID = source.fID;
fLabel = source.fLabel;
fITSLabel = source.fITSLabel;
- for(int i=12;i--;) fITSModule[i] = source.fITSModule[i];
+ for(int i = 0; i< 12;++i){
+ fITSModule[i] = source.fITSModule[i];
+ }
fTPCLabel = source.fTPCLabel;
fTRDLabel = source.fTRDLabel;
- for(int 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;
fHMPIDqn = source.fHMPIDqn;
fHMPIDcluIdx = source.fHMPIDcluIdx;
fCaloIndex = source.fCaloIndex;
for (int i=kNITSchi2Std;i--;) fITSchi2Std[i] = source.fITSchi2Std[i];
- for(int i=3;i--;) {
+ for(int i = 0; i< 3;++i){
fKinkIndexes[i] = source.fKinkIndexes[i];
fV0Indexes[i] = source.fV0Indexes[i];
}
- //
- for(int i=AliPID::kSPECIES;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];
}
- //
+
+ fMassForTracking = source.fMassForTracking;
+
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;
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=4;i--;) fITSdEdxSamples[i]=source.fITSdEdxSamples[i];
+ 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=4;i--;) fTPCPoints[i] = source.fTPCPoints[i];
+ for(int i = 0; i< 4;++i){
+ fTPCPoints[i] = source.fTPCPoints[i];
+ }
fTRDsignal = source.fTRDsignal;
- for(int i=kTRDnPlanes;i--;) fTRDTimBin[i] = source.fTRDTimBin[i];
- //
- AliPoolN* poolN = fgPools ? fgPools->GetPoolN() : 0;
- if (fTRDnSlices) {
- if (poolN) poolN->FreeSlot(&fTRDslices);
- else delete[] fTRDslices;
- fTRDslices = 0;
+ fTRDNchamberdEdx = source.fTRDNchamberdEdx;
+ fTRDNclusterdEdx = source.fTRDNclusterdEdx;
+
+ for(int i = 0;i < kTRDnPlanes;++i){
+ fTRDTimBin[i] = source.fTRDTimBin[i];
}
- fTRDnSlices = source.fTRDnSlices;
+
+ if(fTRDnSlices)
+ delete[] fTRDslices;
+ fTRDslices=0;
+ fTRDnSlices=source.fTRDnSlices;
if (fTRDnSlices) {
- if (poolN) fTRDslices = poolN->BookD32(fTRDnSlices,&fTRDslices);
- else fTRDslices = new Double32_t[fTRDnSlices];
- fTRDslices = new Double32_t[fTRDnSlices];
- for(int j=fTRDnSlices;j--;) fTRDslices[j] = source.fTRDslices[j];
+ 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=10;i--;) fTOFInfo[i] = source.fTOFInfo[i];
- //
+
+ for(int i = 0;i<10;++i){
+ fTOFInfo[i] = source.fTOFInfo[i];
+ }
+
fHMPIDtrkX = source.fHMPIDtrkX;
fHMPIDtrkY = source.fHMPIDtrkY;
fHMPIDmipX = source.fHMPIDmipX;
fTRDncls0 = source.fTRDncls0;
fTRDntracklets = source.fTRDntracklets;
fVertexID = source.fVertexID;
+
+ 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 {
// this overwrites the virtual TOBject::Copy()
}
+
+
void AliESDtrack::AddCalibObject(TObject * object){
//
// add calib object to the list
//
- if (!fFriendTrack) {
- AliClonesPool* poolFr = fgPools ? fgPools->GetPoolTrFriend() : 0;
- if (poolFr) { fFriendTrack = new(poolFr->NextFreeSlot()) AliESDfriendTrack(); poolFr->RegisterClone(fFriendTrack);}
- else fFriendTrack = new AliESDfriendTrack();
- }
+ if (!fFriendTrack) fFriendTrack = new AliESDfriendTrack;
if (!fFriendTrack) return;
fFriendTrack->AddCalibObject(object);
}
// into the passed ESDtrack object. For consistency fTPCInner is also filled
// again
+
+
// For data produced before r26675
// RelateToVertexTPC was not properly called during reco
// so you'll have to call it again, before FillTPCOnlyTrack
// track->RelateToVertexTPC(esd->GetPrimaryVertexTPC(),esd->GetMagneticField(),kVeryBig);
- if (!fTPCInner) return kFALSE;
+ if(!fTPCInner)return kFALSE;
// fill the TPC track params to the global track parameters
track.Set(fTPCInner->GetX(),fTPCInner->GetAlpha(),fTPCInner->GetParameter(),fTPCInner->GetCovariance());
track.fCdd = fCddTPC;
track.fCdz = fCdzTPC;
track.fCzz = fCzzTPC;
- //
- AliClonesPool* poolETP = fgPools ? fgPools->GetPoolExtTrPar() : 0;
+
// copy the inner params
- if (track.fIp) *track.fIp = *fIp;
- else {
- if (poolETP) {track.fIp = new(poolETP->NextFreeSlot()) AliExternalTrackParam(*fIp); poolETP->RegisterClone(track.fIp);}
- else track.fIp = new AliExternalTrackParam(*fIp);
- }
- //
+ if(track.fIp) *track.fIp = *fIp;
+ else track.fIp = new AliExternalTrackParam(*fIp);
+
// copy the TPCinner parameters
- if (track.fTPCInner) *track.fTPCInner = *fTPCInner;
- else {
- if (poolETP) {track.fTPCInner = new(poolETP->NextFreeSlot()) AliExternalTrackParam(*fTPCInner); poolETP->RegisterClone(track.fTPCInner);}
- else track.fTPCInner = new AliExternalTrackParam(*fTPCInner);
- }
+ if(track.fTPCInner) *track.fTPCInner = *fTPCInner;
+ else track.fTPCInner = new AliExternalTrackParam(*fTPCInner);
track.fdTPC = fdTPC;
track.fzTPC = fzTPC;
track.fCddTPC = fCddTPC;
track.fTPCchi2 = fTPCchi2;
track.fTPCchi2Iter1 = fTPCchi2Iter1;
track.fTPCsignal = fTPCsignal;
+ track.fTPCsignalTuned = fTPCsignalTuned;
track.fTPCsignalS = fTPCsignalS;
- for(int i=4;i--;) track.fTPCPoints[i] = fTPCPoints[i];
+ for(int i = 0;i<4;++i)track.fTPCPoints[i] = fTPCPoints[i];
track.fTPCncls = fTPCncls;
track.fTPCnclsF = fTPCnclsF;
track.fTPCnclsFIter1 = fTPCnclsFIter1;
// PID
- for(int i=AliPID::kSPECIES;i--;){
+ for(int i=0;i<AliPID::kSPECIES;++i){
track.fTPCr[i] = fTPCr[i];
// combined PID is TPC only!
track.fR[i] = fTPCr[i];
track.fTPCFitMap = fTPCFitMap;
track.fTPCClusterMap = fTPCClusterMap;
track.fTPCSharedMap = fTPCSharedMap;
- //
+
+
// reset the flags
track.fFlags = kTPCin;
track.fID = fID;
track.fFlags |= fFlags & kTPCpid; //copy the TPCpid status flag
- for (Int_t i=3;i--;) track.fKinkIndexes[i] = fKinkIndexes[i];
+ for (Int_t i=0;i<3;i++) track.fKinkIndexes[i] = fKinkIndexes[i];
return kTRUE;
- //
+
}
//_______________________________________________________________________
fTrackLength = 0;
- for (Int_t i=AliPID::kSPECIES;i--;) fTrackTime[i] = 0;
- //
- AliClonesPool* poolETP = fgPools ? fgPools->GetPoolExtTrPar() : 0;
+ if(fTrackTime)
+ for (Int_t i=0;i<AliPID::kSPECIESC;i++) fTrackTime[i] = 0;
+
// Reset track parameters constrained to the primary vertex
- if (fCp) poolETP ? poolETP->MarkSlotFree(fCp) : delete fCp; fCp = 0;
+ delete fCp;fCp = 0;
+
// Reset track parameters at the inner wall of TPC
- if (fIp) poolETP ? poolETP->MarkSlotFree(fIp) : delete fIp; fIp = 0;
- // Reset track TPC inner params
- if (fTPCInner) poolETP ? poolETP->MarkSlotFree(fTPCInner) : delete fTPCInner; fTPCInner = 0;
+ delete fIp;fIp = 0;
+ delete fTPCInner;fTPCInner=0;
// Reset track parameters at the inner wall of the TRD
- if (fOp) poolETP ? poolETP->MarkSlotFree(fOp) : delete fOp; fOp = 0;
+ delete fOp;fOp = 0;
// Reset track parameters at the HMPID
- if (fHMPIDp) poolETP ? poolETP->MarkSlotFree(fHMPIDp) : delete fHMPIDp; fHMPIDp = 0;
- //
+ delete fHMPIDp;fHMPIDp = 0;
+
+
// Reset ITS track related information
fITSchi2 = 0;
fITSncls = 0;
fITSClusterMap=0;
fITSSharedMap=0;
fITSsignal = 0;
- for (Int_t i=4;i--;) fITSdEdxSamples[i] = 0.;
- for (Int_t i=AliPID::kSPECIES;i--;) fITSr[i]=0;
+ for (Int_t i=0;i<4;i++) fITSdEdxSamples[i] = 0.;
+ 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=AliPID::kSPECIES;i--;) fTPCr[i]=0;
+ for (Int_t i=0;i<AliPID::kSPECIES;i++) fTPCr[i]=0;
fTPCLabel=0;
- for (Int_t i=4;i--;) fTPCPoints[i] = 0;
- for (Int_t i=3;i--;) fKinkIndexes[i] = 0;
- for (Int_t i=3;i--;) fV0Indexes[i] = 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;
// Reset TRD related track information
fTRDchi2 = 0;
fTRDncls = 0;
fTRDncls0 = 0;
fTRDsignal = 0;
- for (Int_t i=kTRDnPlanes;i--;) fTRDTimBin[i] = 0;
- for (Int_t i=AliPID::kSPECIES;i--;) fTRDr[i] = 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;
fTRDLabel = 0;
fTRDQuality = 0;
fTRDntracklets = 0;
- if(fTRDnSlices) {
- AliPoolN* poolN = fgPools ? fgPools->GetPoolN() : 0;
- if (poolN) poolN->FreeSlot(&fTRDslices);
- else delete[] fTRDslices;
- fTRDslices = 0;
- }
+ if(fTRDnSlices)
+ delete[] fTRDslices;
+ fTRDslices=0x0;
fTRDnSlices=0;
fTRDBudget = 0;
fTOFsignalDx = 999;
fTOFdeltaBC = 999;
fTOFl0l1 = 999;
- for (Int_t i=AliPID::kSPECIES;i--;) fTOFr[i] = 0;
- for (Int_t i=3;i--;) fTOFLabel[i] = -1;
- for (Int_t i=10;i--;) fTOFInfo[i] = 0;
+ 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
fHMPIDchi2 = 0;
fHMPIDqn = 0;
fHMPIDcluIdx = -1;
fHMPIDsignal = 0;
- for (Int_t i=AliPID::kSPECIES;i--;) fHMPIDr[i] = 0;
+ for (Int_t i=0;i<AliPID::kSPECIES;i++) fHMPIDr[i] = 0;
+ fMassForTracking = 0.13957;
fHMPIDtrkTheta = 0;
fHMPIDtrkPhi = 0;
fHMPIDtrkX = 0;
fGlobalChi2 = 0;
fVertexID = -2; // an orphan track
- //
- AliClonesPool* poolFr = fgPools ? fgPools->GetPoolTrFriend() : 0;
- poolFr ? poolFr->MarkSlotFree(fFriendTrack) : delete fFriendTrack; fFriendTrack = 0;
- //
+
+ delete fFriendTrack; fFriendTrack = 0;
}
//_______________________________________________________________________
-Int_t AliESDtrack::GetPID() const
+Int_t AliESDtrack::GetPID(Bool_t tpcOnly) const
{
// Returns the particle most probable id
- int 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
+ Int_t i;
+ const Double32_t *prob = 0;
+ if (tpcOnly) { // check if TPCpid is valid
+ 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
+ prob = fR;
+ for (i=0; i<AliPID::kSPECIES-1; i++) if (prob[i] != prob[i+1]) break;
+ if (i == AliPID::kSPECIES-1) return AliPID::kPion; // 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;
}
//_______________________________________________________________________
-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
if (!IsOn(kTOFout) || !IsOn(kESDpid)) return bcid; // no info
//
double tdif = fTOFsignal;
+ Double_t times[AliPID::kSPECIESC];
+ GetIntegratedTimes(times);
if (IsOn(kTIME)) { // integrated time info is there
- int pid = GetPID();
- tdif -= fTrackTime[pid];
+ int pid = GetPID(pidTPConly);
+
+ 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());
}
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);
+ if (flags==kITSout) fFriendTrack->SetITSOut(*t);
+ if (flags==kTPCout) fFriendTrack->SetTPCOut(*t);
+ if (flags==kTRDrefit) fFriendTrack->SetTRDIn(*t);
}
- AliClonesPool* poolETP = fgPools ? fgPools->GetPoolExtTrPar() : 0;
- //
+
switch (flags) {
- //
+
case kITSin:
fITSchi2Std[0] = t->GetChi2();
//
case kITSout:
fITSchi2Std[1] = t->GetChi2();
- case kITSrefit:
+ case kITSrefit:
+ {
fITSchi2Std[2] = t->GetChi2();
fITSClusterMap=0;
fITSncls=t->GetNumberOfClusters();
if (fFriendTrack) {
- Int_t indexITS[AliESDfriendTrack::kMaxITScluster];
- for (Int_t i=AliESDfriendTrack::kMaxITScluster;i--;) {
+ 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);
+ SETBIT(fITSClusterMap,l);
}
- }
- fFriendTrack->SetITSIndices(indexITS,AliESDfriendTrack::kMaxITScluster);
}
- //
+ fFriendTrack->SetITSIndices(indexITS,AliESDfriendTrack::kMaxITScluster);
+ delete [] indexITS;
+ }
+
fITSchi2=t->GetChi2();
fITSsignal=t->GetPIDsignal();
fITSLabel = t->GetLabel();
// keep in fOp the parameters outside ITS for ITS stand-alone tracks
if (flags==kITSout) {
- if (!fOp) {
- if (poolETP) {fOp = new(poolETP->NextFreeSlot()) AliExternalTrackParam(*t); poolETP->RegisterClone(fOp);}
- else fOp = new AliExternalTrackParam(*t);
- }
- else fOp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
+ 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) {
- if (poolETP) { fTPCInner = new(poolETP->NextFreeSlot()) AliExternalTrackParam(*t); poolETP->RegisterClone(fTPCInner);}
- else fTPCInner = new AliExternalTrackParam(*t);
- fTPCnclsIter1 = t->GetNumberOfClusters();
- fTPCchi2Iter1 = t->GetChi2();
+ fTPCInner=new AliExternalTrackParam(*t);
+ fTPCnclsIter1=t->GetNumberOfClusters();
+ fTPCchi2Iter1=t->GetChi2();
}
- if (!fIp) {
- if (poolETP) { fIp = new(poolETP->NextFreeSlot()) AliExternalTrackParam(*t); poolETP->RegisterClone(fIp);}
- else fIp = new AliExternalTrackParam(*t);
+ if (!fIp) fIp=new AliExternalTrackParam(*t);
+ else
+ fIp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
}
- else fIp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
- //
// Intentionally no break statement; need to set general TPC variables as well
case kTPCout:
+ {
if (flags & kTPCout){
- if (!fOp) {
- if (poolETP) { fOp = new(poolETP->NextFreeSlot()) AliExternalTrackParam(*t); poolETP->RegisterClone(fOp);}
- else fOp = new AliExternalTrackParam(*t);
- }
- else fOp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
+ 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) { // Copy cluster indices
- Int_t indexTPC[AliESDfriendTrack::kMaxTPCcluster];
- for (Int_t i=AliESDfriendTrack::kMaxTPCcluster;i--;) indexTPC[i]=t->GetClusterIndex(i);
+ 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[AliESDfriendTrack::kMaxTRDcluster];
- for (Int_t i=AliESDfriendTrack::kMaxTRDcluster;i--;) indexTRD[i] = -2;
- for (Int_t i=6;i--;) indexTRD[i] = t->GetTrackletIndex(i);
+ 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;
}
- //
- fTRDsignal=t->GetPIDsignal();
+
+ //commented out by Xianguo
+ //fTRDsignal=t->GetPIDsignal();
+ }
break;
- //
case kTRDbackup:
- if (!fOp) {
- if (poolETP) {fOp = new(poolETP->NextFreeSlot()) AliExternalTrackParam(*t); poolETP->RegisterClone(fOp);}
- else fOp = new AliExternalTrackParam(*t);
- }
- else fOp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
+ 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:
case kTRDStop:
break;
case kHMPIDout:
- if (!fHMPIDp) {
- if (poolETP) {fHMPIDp = new(poolETP->NextFreeSlot()) AliExternalTrackParam(*t); poolETP->RegisterClone(fHMPIDp);}
- else fHMPIDp = new AliExternalTrackParam(*t);
- fHMPIDp=new AliExternalTrackParam(*t);
- }
- else fHMPIDp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
+ 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;
}
// This function returns external representation of the track parameters
//---------------------------------------------------------------------
x=GetX();
- for (Int_t i=5;i--;) p[i]=GetParameter()[i];
+ for (Int_t i=0; i<5; i++) p[i]=GetParameter()[i];
}
//_______________________________________________________________________
//---------------------------------------------------------------------
// This function returns external representation of the cov. matrix
//---------------------------------------------------------------------
- for (Int_t i=15;i--;) cov[i]=AliExternalTrackParam::GetCovariance()[i];
+ for (Int_t i=0; i<15; i++) cov[i]=AliExternalTrackParam::GetCovariance()[i];
}
//_______________________________________________________________________
if (!fCp) return kFALSE;
alpha=fCp->GetAlpha();
x=fCp->GetX();
- for (Int_t i=5;i--;) p[i]=fCp->GetParameter()[i];
+ for (Int_t i=0; i<5; i++) p[i]=fCp->GetParameter()[i];
return kTRUE;
}
// This function returns the constrained external cov. matrix
//---------------------------------------------------------------------
if (!fCp) return kFALSE;
- for (Int_t i=15;i--;) c[i]=fCp->GetCovariance()[i];
+ for (Int_t i=0; i<15; i++) c[i]=fCp->GetCovariance()[i];
return kTRUE;
}
if (!fIp) return kFALSE;
alpha=fIp->GetAlpha();
x=fIp->GetX();
- for (Int_t i=5;i--;) p[i]=fIp->GetParameter()[i];
+ for (Int_t i=0; i<5; i++) p[i]=fIp->GetParameter()[i];
return kTRUE;
}
// at the inner layer of TPC
//---------------------------------------------------------------------
if (!fIp) return kFALSE;
- for (Int_t i=15;i--;) cov[i]=fIp->GetCovariance()[i];
+ for (Int_t i=0; i<15; i++) cov[i]=fIp->GetCovariance()[i];
return kTRUE;
}
// This is a direct setter for the outer track parameters
//
SetStatus(flags);
-
if (fOp) delete fOp;
fOp=new AliExternalTrackParam(*p);
}
// This is a direct setter for the outer track parameters
//
SetStatus(flags);
- if (fHMPIDp) *fHMPIDp = *p;
- else {
- AliClonesPool* poolETP = fgPools ? fgPools->GetPoolExtTrPar() : 0;
- if (poolETP) {fHMPIDp = new(poolETP->NextFreeSlot()) AliExternalTrackParam(*p); poolETP->RegisterClone(fHMPIDp);}
- else fHMPIDp = new AliExternalTrackParam(*p);
- }
+ if (fHMPIDp) delete fHMPIDp;
+ fHMPIDp=new AliExternalTrackParam(*p);
}
Bool_t
if (!fOp) return kFALSE;
alpha=fOp->GetAlpha();
x=fOp->GetX();
- for (Int_t i=5;i--;) p[i]=fOp->GetParameter()[i];
+ for (Int_t i=0; i<5; i++) p[i]=fOp->GetParameter()[i];
return kTRUE;
}
if (!fHMPIDp) return kFALSE;
alpha=fHMPIDp->GetAlpha();
x=fHMPIDp->GetX();
- for (Int_t i=5;i--;) p[i]=fHMPIDp->GetParameter()[i];
+ for (Int_t i=0; i<5; i++) p[i]=fHMPIDp->GetParameter()[i];
return kTRUE;
}
// at the inner layer of TRD
//---------------------------------------------------------------------
if (!fOp) return kFALSE;
- for (Int_t i=15;i--;) cov[i]=fOp->GetCovariance()[i];
+ for (Int_t i=0; i<15; i++) cov[i]=fOp->GetCovariance()[i];
return kTRUE;
}
// at the inner layer of TRD
//---------------------------------------------------------------------
if (!fHMPIDp) return kFALSE;
- for (Int_t i=15;i--;) cov[i]=fHMPIDp->GetCovariance()[i];
+ for (Int_t i=0; i<15; i++) cov[i]=fHMPIDp->GetCovariance()[i];
return kTRUE;
}
//_______________________________________________________________________
void AliESDtrack::GetIntegratedTimes(Double_t *times) const {
+ Int_t index = -1;
+
+ if(fNtofClusters>0 && GetESDEvent()){
+ TObjArray *tofclArray = GetESDEvent()->GetTOFcluster();
+ 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){
+ for (Int_t i=0; i<AliPID::kSPECIESC; i++) times[i]=tofcl->GetIntegratedTime(i,index);
+ 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=AliPID::kSPECIES;i--;) times[i]=fTrackTime[i];
+ if(fTrackTime)
+ for (Int_t i=0; i<AliPID::kSPECIESC; i++) times[i]=fTrackTime[i];
+ else
+ for (Int_t i=0; i<AliPID::kSPECIESC; i++) times[i]=0.0;
+}
+//_______________________________________________________________________
+Double_t AliESDtrack::GetIntegratedLength() const{
+ Int_t index = -1;
+ if(fNtofClusters>0 && GetESDEvent()){
+ TObjArray *tofclArray = GetESDEvent()->GetTOFcluster();
+ 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) {
// Sets the array with integrated times for each particle hypotesis
- for (Int_t i=AliPID::kSPECIES;i--;) fTrackTime[i]=times[i];
+ if(!fTrackTime)
+ fTrackTime = new Double32_t[AliPID::kSPECIESC];
+ for (Int_t i=0; i<AliPID::kSPECIESC; i++) fTrackTime[i]=times[i];
}
//_______________________________________________________________________
//_______________________________________________________________________
void AliESDtrack::GetITSpid(Double_t *p) const {
// Gets the probability of each particle type (in ITS)
- for (Int_t i=AliPID::kSPECIES;i--;) p[i]=fITSr[i];
+ for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fITSr[i];
}
//_______________________________________________________________________
//---------------------------------------------------------------------
if (idx && fFriendTrack) {
Int_t *index=fFriendTrack->GetITSindices();
- for (Int_t i=AliESDfriendTrack::kMaxITScluster;i--;) {
+ for (Int_t i=0; i<AliESDfriendTrack::kMaxITScluster; i++) {
if ( (i>=fITSncls) && (i<6) ) idx[i]=-1;
else {
if (index) {
Int_t *index=fFriendTrack->GetTPCindices();
if (index){
- for (Int_t i=AliESDfriendTrack::kMaxTPCcluster;i--;) idx[i]=index[i];
+ for (Int_t i=0; i<AliESDfriendTrack::kMaxTPCcluster; i++) idx[i]=index[i];
}
else {
- for (Int_t i=AliESDfriendTrack::kMaxTPCcluster;i--;) idx[i]=-2;
+ for (Int_t i=0; i<AliESDfriendTrack::kMaxTPCcluster; i++) idx[i]=-2;
}
}
return fTPCncls;
}
//_______________________________________________________________________
-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){
+ 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){
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){
+ 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
+}
+
+
+
+
//_______________________________________________________________________
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::GetTPCpid(Double_t *p) const {
// Gets the probability of each particle type (in TPC)
- for (Int_t i=AliPID::kSPECIES;i--;) p[i]=fTPCr[i];
+ for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fTPCr[i];
}
//_______________________________________________________________________
//---------------------------------------------------------------------
if (idx && fFriendTrack) {
Int_t *index=fFriendTrack->GetTRDindices();
- if (index) for (Int_t i=AliESDfriendTrack::kMaxTRDcluster;i--;) idx[i]=index[i];
- else for (Int_t i=AliESDfriendTrack::kMaxTRDcluster;i--;) idx[i]=-2;
+
+ 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;
}
if (!idx) return GetTRDntracklets();
Int_t *index=fFriendTrack->GetTRDindices();
Int_t n = 0;
- for (Int_t i=0;i<kTRDnPlanes;i++){
+ for (Int_t i=0; i<kTRDnPlanes; i++){
if (index){
if(index[i]>=0) n++;
idx[i]=index[i];
//_______________________________________________________________________
void AliESDtrack::GetTRDpid(Double_t *p) const {
// Gets the probability of each particle type (in TRD)
- for (Int_t i=AliPID::kSPECIES;i--;) p[i]=fTRDr[i];
+ for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fTRDr[i];
}
//_______________________________________________________________________
// return average of the dEdx measurements
Double_t q=0.; Double32_t *s = &fTRDslices[plane*ns];
- for (Int_t i=0;i<ns;i++, s++) if((*s)>0.) q+=(*s);
+ for (Int_t i=0; i<ns; i++, s++) if((*s)>0.) q+=(*s);
return q/ns;
}
void AliESDtrack::SetNumberOfTRDslices(Int_t n) {
//Sets the number of slices used for PID
if (fTRDnSlices) return;
+
fTRDnSlices=n;
- AliPoolN* poolN = fgPools ? fgPools->GetPoolN() : 0;
- if (poolN) fTRDslices = poolN->BookD32(fTRDnSlices,&fTRDslices);
- else fTRDslices = new Double32_t[fTRDnSlices];
- //
+ fTRDslices=new Double32_t[fTRDnSlices];
+
// set-up correctly the allocated memory
memset(fTRDslices, 0, n*sizeof(Double32_t));
- for (Int_t i=GetNumberOfTRDslices();i--;) fTRDslices[i]=-1.;
+ for (Int_t i=GetNumberOfTRDslices(); i--;) fTRDslices[i]=-1.;
}
//____________________________________________________
}
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::SetTOFLabel(const Int_t *p) {
// Sets (in TOF)
- for (Int_t i=3;i--;) fTOFLabel[i]=p[i];
+ 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=AliPID::kSPECIES;i--;) p[i]=fTOFr[i];
+ for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fTOFr[i];
}
//_______________________________________________________________________
void AliESDtrack::GetTOFLabel(Int_t *p) const {
// Gets (in TOF)
- for (Int_t i=3;i--;) p[i]=fTOFLabel[i];
+ if(fNtofClusters>0){
+ TObjArray *tofclArray = GetESDEvent()->GetTOFcluster();
+ 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::GetTOFInfo(Float_t *info) const {
// Gets (in TOF)
- for (Int_t i=10;i--;) info[i]=fTOFInfo[i];
+ for (Int_t i=0; i<10; i++) info[i]=fTOFInfo[i];
}
//_______________________________________________________________________
void AliESDtrack::SetTOFInfo(Float_t*info) {
// Gets (in TOF)
- for (Int_t i=10;i--;) fTOFInfo[i]=info[i];
+ for (Int_t i=0; i<10; i++) fTOFInfo[i]=info[i];
}
}
//_______________________________________________________________________
-void AliESDtrack::SetTPCdEdxInfo(AliTPCdEdxInfo * dEdxInfo)
-{
- // add TPC dedx info
- if (fTPCdEdxInfo) {
- AliClonesPool* pooldEdx = fgPools ? fgPools->GetPoolTPCdEdx() : 0;
- pooldEdx ? pooldEdx->MarkSlotFree(fTPCdEdxInfo) : delete fTPCdEdxInfo;
- }
+void AliESDtrack::SetTPCdEdxInfo(AliTPCdEdxInfo * dEdxInfo){
+ if(fTPCdEdxInfo) delete fTPCdEdxInfo;
fTPCdEdxInfo = dEdxInfo;
}
//_______________________________________________________________________
void AliESDtrack::GetHMPIDpid(Double_t *p) const {
// Gets probabilities of each particle type (in HMPID)
- for (Int_t i=AliPID::kSPECIES;i--;) p[i]=fHMPIDr[i];
+ for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fHMPIDr[i];
}
+
+
//_______________________________________________________________________
void AliESDtrack::SetESDpid(const Double_t *p) {
// Sets the probability of each particle type for the ESD track
//_______________________________________________________________________
void AliESDtrack::GetESDpid(Double_t *p) const {
// Gets probability of each particle type for the ESD track
- for (Int_t i=AliPID::kSPECIES;i--;) p[i]=fR[i];
+ for (Int_t i=0; i<AliPID::kSPECIES; i++) p[i]=fR[i];
}
//_______________________________________________________________________
// 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: ") ;
//
Double_t mpos[3]={0,0,0};
Int_t entries=arrayRef.GetEntries();
- for (Int_t i=entries;i--;){
+ for (Int_t i=0;i<entries;i++){
Double_t pos[3];
((AliExternalTrackParam*)arrayRef.At(i))->GetXYZ(pos);
mpos[0]+=pos[0]/entries;
// Store the dE/dx samples measured by the two SSD and two SDD layers.
// These samples are corrected for the track segment length.
//
- for (Int_t i=4;i--;) fITSdEdxSamples[i]=s[i];
+ for (Int_t i=0; i<4; i++) fITSdEdxSamples[i]=s[i];
}
//_______________________________________________________________________
-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.
//
- for (Int_t i=4;i--;) s[i]=fITSdEdxSamples[i];
+ for (Int_t i=0; i<4; i++) s[i]=fITSdEdxSamples[i];
}
}
// clone for constraining
- AliExternalTrackParam tpcInnerC(*fTPCInner);
+ AliExternalTrackParam* tpcInnerC = new AliExternalTrackParam(*fTPCInner);
+ if (!tpcInnerC) {
+ AliWarning("Clone of TPCInnerParam failed.");
+ return fCacheChi2TPCConstrainedVsGlobal;
+ }
// transform to the track reference frame
- Bool_t isOK = tpcInnerC.Rotate(GetAlpha());
- isOK &= tpcInnerC.PropagateTo(GetX(), b[2]);
+ 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;
}
// constrain TPCinner
- isOK = tpcInnerC.ConstrainToVertex(vtx, b);
+ isOK = tpcInnerC->ConstrainToVertex(vtx, b);
// transform to the track reference frame
- isOK &= tpcInnerC.Rotate(GetAlpha());
- isOK &= tpcInnerC.PropagateTo(GetX(), b[2]);
+ isOK &= tpcInnerC->Rotate(GetAlpha());
+ isOK &= tpcInnerC->PropagateTo(GetX(), b[2]);
if (!isOK) {
AliWarning("ConstrainTPCInner failed.") ;
+ delete tpcInnerC;
+ tpcInnerC = 0;
return fCacheChi2TPCConstrainedVsGlobal;
}
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 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];
+ covarM(ipar,jpar) = GetCovariance()[index]+tpcInnerC->GetCovariance()[index];
}
}
// chi2 distance TPC constrained and TPC+ITS
TMatrixD covarMInv = covarM.Invert();
TMatrixD mat2 = covarMInv*deltaT;
TMatrixD chi2 = delta*mat2;
- //
+
+ delete tpcInnerC;
+ tpcInnerC = 0;
+
fCacheChi2TPCConstrainedVsGlobal = chi2(0,0);
return fCacheChi2TPCConstrainedVsGlobal;
}
-void AliESDtrack::ReleaseESDfriendTrackGently()
+void AliESDtrack::SetDetectorPID(const AliDetectorPID *pid)
{
- // remove friend track
- if (!fFriendTrack) return;
- AliClonesPool* poolFr = fgPools->GetPoolTrFriend();
- poolFr ? poolFr->MarkSlotFree(fFriendTrack) : delete fFriendTrack;
- fFriendTrack=0;
+ //
+ // 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) const {
+ //
+ // 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;
+}
+
+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::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 previous content
+ delete old;
+ old = NULL;
+ }
+
+}
+
+Double_t AliESDtrack::GetTOFsignal() const {
+ if(fNtofClusters>0 && GetESDEvent()){
+ TObjArray *tofclArray = GetESDEvent()->GetTOFcluster();
+ AliESDTOFcluster *tofcl = (AliESDTOFcluster *) tofclArray->At(fTOFcluster[0]);
+
+ return tofcl->GetTime();
+ }
+ else if(fNtofClusters>0) AliInfo("No AliESDEvent available here!\n");
+
+ return fTOFsignal;
}
-void AliESDtrack::PrintTmp()
+Double_t AliESDtrack::GetTOFsignalToT() const
{
+ if(fNtofClusters>0 && GetESDEvent()){
+ TObjArray *tofclArray = GetESDEvent()->GetTOFcluster();
+ 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()){
+ TObjArray *tofclArray = GetESDEvent()->GetTOFcluster();
+ 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()){
+ TObjArray *tofclArray = GetESDEvent()->GetTOFcluster();
+ 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()){
+ TObjArray *tofclArray = GetESDEvent()->GetTOFcluster();
+ 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()){
+ TObjArray *tofclArray = GetESDEvent()->GetTOFcluster();
+ 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()){
+ TObjArray *tofclArray = GetESDEvent()->GetTOFcluster();
+ 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()){
+ TObjArray *tofclArray = GetESDEvent()->GetTOFcluster();
+ AliESDTOFcluster *tofcl = (AliESDTOFcluster *) tofclArray->At(fTOFcluster[0]);
+
+ tofcl->GetTOFchannel();
+ }
+ else if(fNtofClusters>0) AliInfo("No AliESDEvent available here!\n");
+
+ return fTOFCalChannel;
+}
+
+Int_t AliESDtrack::GetTOFcluster() const
+{
+ if(fNtofClusters>0 && GetESDEvent()){
+ TObjArray *tofclArray = GetESDEvent()->GetTOFcluster();
+ AliESDTOFcluster *tofcl = (AliESDTOFcluster *) tofclArray->At(fTOFcluster[0]);
+
+ 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()){
+ TObjArray *tofclArray = GetESDEvent()->GetTOFcluster();
+ 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(){
+ TObjArray *tofclArray = GetESDEvent()->GetTOFcluster();
+
+ 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;
+ }
+ }
+ }
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff