fITSLabel(0),
fTPCLabel(0),
fTRDLabel(0),
- fTOFCalChannel(0),
+ fTOFCalChannel(-1),
fTOFindex(-1),
fHMPIDqn(0),
fHMPIDcluIdx(-1),
- fEMCALindex(kEMCALNoMatch),
+ fCaloIndex(kEMCALNoMatch),
fHMPIDtrkTheta(0),
fHMPIDtrkPhi(0),
fHMPIDsignal(0),
fCchi2(0),
fITSchi2(0),
fTPCchi2(0),
+ fTPCchi2Iter1(0),
fTRDchi2(0),
fTOFchi2(0),
fHMPIDchi2(0),
fTRDsignal(0),
fTRDQuality(0),
fTRDBudget(0),
- fTOFsignal(0),
- fTOFsignalToT(0),
- fTOFsignalRaw(0),
- fTOFsignalDz(0),
- fTOFsignalDx(0),
+ fTOFsignal(99999),
+ fTOFsignalToT(99999),
+ fTOFsignalRaw(99999),
+ fTOFsignalDz(999),
+ fTOFsignalDx(999),
+ fTOFdeltaBC(999),
+ fTOFl0l1(999),
+ fCaloDx(0),
+ fCaloDz(0),
fHMPIDtrkX(0),
fHMPIDtrkY(0),
fHMPIDmipX(0),
fTPCncls(0),
fTPCnclsF(0),
fTPCsignalN(0),
+ fTPCnclsIter1(0),
+ fTPCnclsFIter1(0),
fITSncls(0),
fITSClusterMap(0),
fTRDncls(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]=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;}
}
fTOFindex(track.fTOFindex),
fHMPIDqn(track.fHMPIDqn),
fHMPIDcluIdx(track.fHMPIDcluIdx),
- fEMCALindex(track.fEMCALindex),
+ fCaloIndex(track.fCaloIndex),
fHMPIDtrkTheta(track.fHMPIDtrkTheta),
fHMPIDtrkPhi(track.fHMPIDtrkPhi),
fHMPIDsignal(track.fHMPIDsignal),
fCchi2(track.fCchi2),
fITSchi2(track.fITSchi2),
fTPCchi2(track.fTPCchi2),
+ fTPCchi2Iter1(track.fTPCchi2Iter1),
fTRDchi2(track.fTRDchi2),
fTOFchi2(track.fTOFchi2),
fHMPIDchi2(track.fHMPIDchi2),
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),
fTPCncls(track.fTPCncls),
fTPCnclsF(track.fTPCnclsF),
fTPCsignalN(track.fTPCsignalN),
+ fTPCnclsIter1(track.fTPCnclsIter1),
+ fTPCnclsFIter1(track.fTPCnclsIter1),
fITSncls(track.fITSncls),
fITSClusterMap(track.fITSClusterMap),
fTRDncls(track.fTRDncls),
fITSLabel(0),
fTPCLabel(0),
fTRDLabel(0),
- fTOFCalChannel(0),
+ fTOFCalChannel(-1),
fTOFindex(-1),
fHMPIDqn(0),
fHMPIDcluIdx(-1),
- fEMCALindex(kEMCALNoMatch),
+ fCaloIndex(kEMCALNoMatch),
fHMPIDtrkTheta(0),
fHMPIDtrkPhi(0),
fHMPIDsignal(0),
fCchi2(0),
fITSchi2(0),
fTPCchi2(0),
+ fTPCchi2Iter1(0),
fTRDchi2(0),
fTOFchi2(0),
fHMPIDchi2(0),
fTRDsignal(0),
fTRDQuality(0),
fTRDBudget(0),
- fTOFsignal(0),
- fTOFsignalToT(0),
- fTOFsignalRaw(0),
- fTOFsignalDz(0),
- fTOFsignalDx(0),
+ fTOFsignal(99999),
+ fTOFsignalToT(99999),
+ fTOFsignalRaw(99999),
+ fTOFsignalDz(999),
+ fTOFsignalDx(999),
+ fTOFdeltaBC(999),
+ fTOFl0l1(999),
+ fCaloDx(0),
+ fCaloDz(0),
fHMPIDtrkX(0),
fHMPIDtrkY(0),
fHMPIDmipX(0),
fTPCncls(0),
fTPCnclsF(0),
fTPCsignalN(0),
+ fTPCnclsIter1(0),
+ fTPCnclsFIter1(0),
fITSncls(0),
fITSClusterMap(0),
fTRDncls(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]=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;}
if(HasPointOnITSLayer(i)) fITSncls++;
}
+ // Set TPC ncls
+ fTPCncls=track->GetTPCNcls();
+
+
// Set the combined PID
const Double_t *pid = track->PID();
if(pid){
fITSLabel(0),
fTPCLabel(0),
fTRDLabel(0),
- fTOFCalChannel(0),
+ fTOFCalChannel(-1),
fTOFindex(-1),
fHMPIDqn(0),
fHMPIDcluIdx(-1),
- fEMCALindex(kEMCALNoMatch),
+ fCaloIndex(kEMCALNoMatch),
fHMPIDtrkTheta(0),
fHMPIDtrkPhi(0),
fHMPIDsignal(0),
fCchi2(0),
fITSchi2(0),
fTPCchi2(0),
+ fTPCchi2Iter1(0),
fTRDchi2(0),
fTOFchi2(0),
fHMPIDchi2(0),
fTRDsignal(0),
fTRDQuality(0),
fTRDBudget(0),
- fTOFsignal(0),
- fTOFsignalToT(0),
- fTOFsignalRaw(0),
- fTOFsignalDz(0),
- fTOFsignalDx(0),
+ fTOFsignal(99999),
+ fTOFsignalToT(99999),
+ fTOFsignalRaw(99999),
+ fTOFsignalDz(999),
+ fTOFsignalDx(999),
+ fTOFdeltaBC(999),
+ fTOFl0l1(999),
+ fCaloDx(0),
+ fCaloDz(0),
fHMPIDtrkX(0),
fHMPIDtrkY(0),
fHMPIDmipX(0),
fTPCncls(0),
fTPCnclsF(0),
fTPCsignalN(0),
+ fTPCnclsIter1(0),
+ fTPCnclsFIter1(0),
fITSncls(0),
fITSClusterMap(0),
fTRDncls(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]=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;}
fTOFindex = source.fTOFindex;
fHMPIDqn = source.fHMPIDqn;
fHMPIDcluIdx = source.fHMPIDcluIdx;
- fEMCALindex = source.fEMCALindex;
+ fCaloIndex = source.fCaloIndex;
for(int i = 0; i< 3;++i){
fKinkIndexes[i] = source.fKinkIndexes[i];
fITSchi2 = source.fITSchi2;
fTPCchi2 = source.fTPCchi2;
+ fTPCchi2Iter1 = source.fTPCchi2Iter1;
fTRDchi2 = source.fTRDchi2;
fTOFchi2 = source.fTOFchi2;
fHMPIDchi2 = source.fHMPIDchi2;
fTOFsignalRaw = source.fTOFsignalRaw;
fTOFsignalDz = source.fTOFsignalDz;
fTOFsignalDx = source.fTOFsignalDx;
-
+ fTOFdeltaBC = source.fTOFdeltaBC;
+ fTOFl0l1 = source.fTOFl0l1;
+
for(int i = 0;i<10;++i){
fTOFInfo[i] = source.fTOFInfo[i];
}
fTPCncls = source.fTPCncls;
fTPCnclsF = source.fTPCnclsF;
fTPCsignalN = source.fTPCsignalN;
+ fTPCnclsIter1 = source.fTPCnclsIter1;
+ fTPCnclsFIter1 = source.fTPCnclsFIter1;
fITSncls = source.fITSncls;
fITSClusterMap = source.fITSClusterMap;
track.fTPCLabel = fTPCLabel;
track.fTPCchi2 = fTPCchi2;
+ track.fTPCchi2Iter1 = fTPCchi2Iter1;
track.fTPCsignal = fTPCsignal;
track.fTPCsignalS = fTPCsignalS;
for(int i = 0;i<4;++i)track.fTPCPoints[i] = fTPCPoints[i];
track.fTPCncls = fTPCncls;
track.fTPCnclsF = fTPCnclsF;
track.fTPCsignalN = fTPCsignalN;
+ track.fTPCnclsIter1 = fTPCnclsIter1;
+ track.fTPCnclsFIter1 = fTPCnclsFIter1;
// PID
for(int i=0;i<AliPID::kSPECIES;++i){
// Reset TPC related track information
fTPCchi2 = 0;
+ fTPCchi2Iter1 = 0;
fTPCncls = 0;
fTPCnclsF = 0;
+ fTPCnclsIter1 = 0;
+ fTPCnclsFIter1 = 0;
fTPCClusterMap = 0;
fTPCSharedMap = 0;
fTPCsignal= 0;
// Reset TOF related track information
fTOFchi2 = 0;
fTOFindex = -1;
- fTOFsignal = 0;
- fTOFCalChannel = 0;
- fTOFsignalToT = 0;
- fTOFsignalRaw = 0;
- fTOFsignalDz = 0;
- fTOFsignalDx = 0;
+ fTOFsignal = 99999;
+ fTOFCalChannel = -1;
+ fTOFsignalToT = 99999;
+ fTOFsignalRaw = 99999;
+ fTOFsignalDz = 999;
+ 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] = 0;
+ for (Int_t i=0;i<3;i++) fTOFLabel[i] = -1;
for (Int_t i=0;i<10;i++) fTOFInfo[i] = 0;
// Reset HMPID related track information
fHMPIDtrkY = 0;
fHMPIDmipX = 0;
fHMPIDmipY = 0;
- fEMCALindex = kEMCALNoMatch;
+ fCaloIndex = kEMCALNoMatch;
// reset global track chi2
fGlobalChi2 = 0;
//_______________________________________________________________________
Double_t AliESDtrack::GetMass() const {
// Returns the mass of the most probable particle type
+
+ Int_t i;
+ for (i=0; i<AliPID::kSPECIES-1; i++) {
+ if (fR[i] != fR[i+1]) break;
+ }
+ // If all the probabilities are equal, return the pion mass
+ if (i == AliPID::kSPECIES-1) return AliPID::ParticleMass(AliPID::kPion);
+
Float_t max=0.;
Int_t k=-1;
- for (Int_t i=0; i<AliPID::kSPECIES; i++) {
+ for (i=0; i<AliPID::kSPECIES; i++) {
if (fR[i]>max) {k=i; max=fR[i];}
}
if (k==0) { // dE/dx "crossing points" in the TPC
return AliPID::ParticleMass(AliPID::kPion);
}
+//______________________________________________________________________________
+Double_t AliESDtrack::M() const
+{
+ // Returns the assumed mass
+ // (the pion mass, if the particle can't be identified properly).
+
+ AliWarning("This is the ESD mass. Use it with care !");
+ return GetMass();
+}
+
//______________________________________________________________________________
Double_t AliESDtrack::E() const
{
//
// This function updates track's running parameters
//
- Int_t *index=0;
Bool_t rc=kTRUE;
SetStatus(flags);
switch (flags) {
case kITSin: case kITSout: case kITSrefit:
+ {
fITSClusterMap=0;
fITSncls=t->GetNumberOfClusters();
- index=fFriendTrack->GetITSindices();
+ Int_t* indexITS = new Int_t[AliESDfriendTrack::kMaxITScluster];
for (Int_t i=0;i<AliESDfriendTrack::kMaxITScluster;i++) {
- index[i]=t->GetClusterIndex(i);
+ indexITS[i]=t->GetClusterIndex(i);
+
if (i<fITSncls) {
- Int_t l=(index[i] & 0xf0000000) >> 28;
+ Int_t l=(indexITS[i] & 0xf0000000) >> 28;
SETBIT(fITSClusterMap,l);
}
}
+ fFriendTrack->SetITSIndices(indexITS,AliESDfriendTrack::kMaxITScluster);
+ delete [] indexITS;
+
fITSchi2=t->GetChi2();
fITSsignal=t->GetPIDsignal();
fITSLabel = t->GetLabel();
else
fOp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
}
+ }
break;
case kTPCin: case kTPCrefit:
+ {
fTPCLabel = t->GetLabel();
- if (flags==kTPCin) fTPCInner=new AliExternalTrackParam(*t);
+ if (flags==kTPCin) {
+ fTPCInner=new AliExternalTrackParam(*t);
+ fTPCnclsIter1=t->GetNumberOfClusters();
+ fTPCchi2Iter1=t->GetChi2();
+ }
if (!fIp) fIp=new AliExternalTrackParam(*t);
else
fIp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
+ }
case kTPCout:
- index=fFriendTrack->GetTPCindices();
+ {
+ Int_t* indexTPC = new Int_t[AliESDfriendTrack::kMaxTPCcluster];
if (flags & kTPCout){
if (!fOp) fOp=new AliExternalTrackParam(*t);
else
// for (Int_t i=0;i<fTPCncls;i++)
for (Int_t i=0;i<AliESDfriendTrack::kMaxTPCcluster;i++)
{
- index[i]=t->GetClusterIndex(i);
- Int_t idx = index[i];
+ indexTPC[i]=t->GetClusterIndex(i);
+ Int_t idx = indexTPC[i];
if (idx<0) continue;
}
// End Of Piotr's Cluster Map for HBT
}
+ fFriendTrack->SetTPCIndices(indexTPC,AliESDfriendTrack::kMaxTPCcluster);
+ delete [] indexTPC;
+
}
fTPCsignal=t->GetPIDsignal();
+ }
break;
case kTRDin: case kTRDrefit:
break;
case kTRDout:
- index = fFriendTrack->GetTRDindices();
+ {
fTRDLabel = t->GetLabel();
fTRDchi2 = t->GetChi2();
fTRDncls = t->GetNumberOfClusters();
- for (Int_t i=0;i<6;i++) index[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();
+ }
break;
case kTRDbackup:
if (!fOp) fOp=new AliExternalTrackParam(*t);
//---------------------------------------------------------------------
// This function returns indices of the assgined ITS clusters
//---------------------------------------------------------------------
- if (idx!=0) {
- Int_t *index=fFriendTrack->GetITSindices();
- for (Int_t i=0; i<AliESDfriendTrack::kMaxITScluster; i++) {
- if ( (i>=fITSncls) && (i<6) ) idx[i]=-1;
- else idx[i]=index[i];
- }
+ if (idx) {
+ Int_t *index=fFriendTrack->GetITSindices();
+ for (Int_t i=0; i<AliESDfriendTrack::kMaxITScluster; i++) {
+ if ( (i>=fITSncls) && (i<6) ) idx[i]=-1;
+ else {
+ if (index) {
+ idx[i]=index[i];
+ }
+ else idx[i]= -2;
+ }
+ }
}
return fITSncls;
}
//---------------------------------------------------------------------
// This function returns indices of the assgined ITS clusters
//---------------------------------------------------------------------
- if (idx!=0) {
+ if (idx) {
Int_t *index=fFriendTrack->GetTPCindices();
- for (Int_t i=0; i<AliESDfriendTrack::kMaxTPCcluster; i++) idx[i]=index[i];
+
+ if (index){
+ for (Int_t i=0; i<AliESDfriendTrack::kMaxTPCcluster; i++) idx[i]=index[i];
+ }
+ else {
+ for (Int_t i=0; i<AliESDfriendTrack::kMaxTPCcluster; i++) idx[i]=-2;
+ }
}
return fTPCncls;
}
+//_______________________________________________________________________
+Float_t AliESDtrack::GetTPCClusterInfo(Int_t nNeighbours/*=3*/, Int_t type/*=0*/) const
+{
+ //
+ // TPC cluster information
+ // type 0: get fraction of found/findable clusters with neighbourhood definition
+ // 1: findable clusters with neighbourhood definition
+ // 2: found clusters
+ //
+ // 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;
+
+ for (Int_t i=0; i<159; ++i){
+ //look to current row
+ if (fTPCClusterMap[i]) {
+ last=i;
+ ++found;
+ ++findable;
+ continue;
+ }
+ //look to nNeighbours before
+ if ((i-last)<=nNeighbours) {
+ ++findable;
+ continue;
+ }
+ //look to nNeighbours after
+ for (Int_t j=i+1; j<i+1+nNeighbours; ++j){
+ if (fTPCClusterMap[j]){
+ ++findable;
+ break;
+ }
+ }
+ }
+ 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{
//
// GetDensity of the clusters on given region between row0 and row1
//---------------------------------------------------------------------
// This function returns indices of the assgined TRD clusters
//---------------------------------------------------------------------
- if (idx!=0) {
- Int_t *index=fFriendTrack->GetTRDindices();
- for (Int_t i=0; i<AliESDfriendTrack::kMaxTRDcluster; i++) idx[i]=index[i];
+ if (idx) {
+ Int_t *index=fFriendTrack->GetTRDindices();
+
+ if (index) {
+ for (Int_t i=0; i<AliESDfriendTrack::kMaxTRDcluster; i++) idx[i]=index[i];
+ }
+ else {
+ for (Int_t i=0; i<AliESDfriendTrack::kMaxTRDcluster; i++) idx[i]=-2;
+ }
}
return fTRDncls;
}
// Therefore tracks with TRD gaps contain default values for indices [-1]
if (!idx) return GetTRDntracklets();
- Int_t *index=fFriendTrack->GetTRDindices(), n(0);
+ Int_t *index=fFriendTrack->GetTRDindices();
+ Int_t n = 0;
for (Int_t i=0; i<kTRDnPlanes; i++){
- if(index[i]>=0) n++;
- idx[i]=index[i];
+ if (index){
+ if(index[i]>=0) n++;
+ idx[i]=index[i];
+ }
+ else idx[i] = -2;
}
return n;
}
// in TRD layer "plane".
if (!fTRDnSlices) {
- AliError("No TRD info allocated for this track !");
+ AliDebug(2, "No TRD info allocated for this track.");
return -1.;
}
if ((plane<0) || (plane>=kTRDnPlanes)) {
- AliError("Info for TRD plane not available!");
+ AliWarning(Form("Request for TRD plane[%d] outside range.", plane));
return -1.;
}
//
for (Int_t i=0; i<4; i++) s[i]=fITSdEdxSamples[i];
}
+
+
+UShort_t AliESDtrack::GetTPCnclsS(Int_t i0,Int_t i1) const{
+ //
+ // get number of shared TPC clusters
+ //
+ return fTPCSharedMap.CountBits(i0)-fTPCSharedMap.CountBits(i1);
+}
+
+UShort_t AliESDtrack::GetTPCncls(Int_t i0,Int_t i1) const{
+ //
+ // get number of TPC clusters
+ //
+ return fTPCClusterMap.CountBits(i0)-fTPCClusterMap.CountBits(i1);
+}