New representation for the raw PID signal in ITS (first step).

[u/mrichter/AliRoot.git] / STEER / AliESDtrack.cxx

diff --git a/STEER/AliESDtrack.cxx b/STEER/AliESDtrack.cxx
index af2dd60ae8aacb54464a33bd8f7f19bbe0b528ff..bcdf46d871254e88a09cb6a409eabf7af9cd8138 100644 (file)
--- a/STEER/AliESDtrack.cxx
+++ b/STEER/AliESDtrack.cxx
@@ -211,10 +211,10 @@ AliESDtrack::AliESDtrack() :
   fITSClusterMap(0),
   fTRDncls(0),
   fTRDncls0(0),
-  fTRDpidQuality(0),
+  fTRDntracklets(0),
   fTRDnSlices(0),
-  fTRDslices(0x0)
-  
+  fTRDslices(0x0),
+  fVertexID(-2) // -2 means an orphan track 
 {
   //
   // The default ESD constructor 
@@ -235,6 +235,7 @@ AliESDtrack::AliESDtrack() :
   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<3;i++) {fTOFLabel[i]=0;}
   for (i=0;i<10;i++) {fTOFInfo[i]=0;}
@@ -299,9 +300,10 @@ AliESDtrack::AliESDtrack(const AliESDtrack& track):
   fITSClusterMap(track.fITSClusterMap),
   fTRDncls(track.fTRDncls),
   fTRDncls0(track.fTRDncls0),
-  fTRDpidQuality(track.fTRDpidQuality),
+  fTRDntracklets(track.fTRDntracklets),
   fTRDnSlices(track.fTRDnSlices),
-  fTRDslices(0x0)
+  fTRDslices(0x0),
+  fVertexID(track.fVertexID)
 {
   //
   //copy constructor
@@ -312,6 +314,7 @@ AliESDtrack::AliESDtrack(const AliESDtrack& track):
   for (Int_t i=0;i<AliPID::kSPECIES;i++) fITSr[i]=track.fITSr[i]; 
   //
   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];}
@@ -398,9 +401,10 @@ AliESDtrack::AliESDtrack(const AliVTrack *track) :
   fITSClusterMap(0),
   fTRDncls(0),
   fTRDncls0(0),
-  fTRDpidQuality(0),
+  fTRDntracklets(0),
   fTRDnSlices(0),
-  fTRDslices(0x0)
+  fTRDslices(0x0),
+  fVertexID(-2)  // -2 means an orphan track
 {
   //
   // ESD track from AliVTrack.
@@ -431,6 +435,7 @@ AliESDtrack::AliESDtrack(const AliVTrack *track) :
   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<3;i++) {fTOFLabel[i]=0;}
   for (i=0;i<10;i++) {fTOFInfo[i]=0;}
@@ -516,9 +521,10 @@ AliESDtrack::AliESDtrack(TParticle * part) :
   fITSClusterMap(0),
   fTRDncls(0),
   fTRDncls0(0),
-  fTRDpidQuality(0),
+  fTRDntracklets(0),
   fTRDnSlices(0),
-  fTRDslices(0x0)
+  fTRDslices(0x0),
+  fVertexID(-2)  // -2 means an orphan track
 {
   //
   // ESD track from TParticle
@@ -541,6 +547,7 @@ AliESDtrack::AliESDtrack(TParticle * part) :
   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<3;i++) {fTOFLabel[i]=0;}
   for (i=0;i<10;i++) {fTOFInfo[i]=0;}
@@ -779,6 +786,7 @@ AliESDtrack &AliESDtrack::operator=(const AliESDtrack &source){
   fGlobalChi2 = source.fGlobalChi2;      
 
   fITSsignal  = source.fITSsignal;     
+  for (Int_t i=0;i<4;i++) {fITSdEdxSamples[i]=source.fITSdEdxSamples[i];}
   fTPCsignal  = source.fTPCsignal;     
   fTPCsignalS = source.fTPCsignalS;    
   for(int i = 0; i< 4;++i){
@@ -823,7 +831,8 @@ AliESDtrack &AliESDtrack::operator=(const AliESDtrack &source){
   fITSClusterMap = source.fITSClusterMap; 
   fTRDncls   = source.fTRDncls;       
   fTRDncls0  = source.fTRDncls0;      
-  fTRDpidQuality  = source.fTRDpidQuality; 
+  fTRDntracklets  = source.fTRDntracklets; 
+  fVertexID = source.fVertexID;
   return *this;
 }
 
@@ -965,6 +974,7 @@ void AliESDtrack::MakeMiniESDtrack(){
   fITSncls = 0;       
   fITSClusterMap=0;
   fITSsignal = 0;     
+  for (Int_t i=0;i<4;i++) fITSdEdxSamples[i] = 0.;
   for (Int_t i=0;i<AliPID::kSPECIES;i++) fITSr[i]=0; 
   fITSLabel = 0;       
 
@@ -994,7 +1004,7 @@ void AliESDtrack::MakeMiniESDtrack(){
   for (Int_t i=0;i<AliPID::kSPECIES;i++) fTRDr[i] = 0; 
   fTRDLabel = 0;       
   fTRDQuality  = 0;
-  fTRDpidQuality = 0;
+  fTRDntracklets = 0;
   if(fTRDnSlices)
     delete[] fTRDslices;
   fTRDslices=0x0;
@@ -1030,6 +1040,8 @@ void AliESDtrack::MakeMiniESDtrack(){
   // reset global track chi2
   fGlobalChi2 = 0;
 
+  fVertexID = -2; // an orphan track
+
   delete fFriendTrack; fFriendTrack = 0;
 } 
 //_______________________________________________________________________
@@ -1100,6 +1112,9 @@ Bool_t AliESDtrack::UpdateTrackParams(const AliKalmanTrack *t, ULong_t flags){
   }
 
   Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
+  if (flags==kITSout) fFriendTrack->SetITSOut(*t);
+  if (flags==kTPCout) fFriendTrack->SetTPCOut(*t);
+  if (flags==kTRDrefit) fFriendTrack->SetTRDIn(*t);
   
   switch (flags) {
     
@@ -1122,7 +1137,7 @@ Bool_t AliESDtrack::UpdateTrackParams(const AliKalmanTrack *t, ULong_t flags){
       if (!fOp) fOp=new AliExternalTrackParam(*t);
       else 
         fOp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
-    }      
+    }   
     break;
     
   case kTPCin: case kTPCrefit:
@@ -1195,7 +1210,9 @@ Bool_t AliESDtrack::UpdateTrackParams(const AliKalmanTrack *t, ULong_t flags){
     fTPCsignal=t->GetPIDsignal();
     break;
 
-  case kTRDout: case kTRDin: case kTRDrefit:
+  case kTRDin: case kTRDrefit:
+    break;
+  case kTRDout:
     index     = fFriendTrack->GetTRDindices();
     fTRDLabel = t->GetLabel(); 
     fTRDchi2  = t->GetChi2();
@@ -1589,26 +1606,88 @@ Double_t AliESDtrack::GetTRDpid(Int_t iSpecies) const
   return fTRDr[iSpecies];
 }
 
+//____________________________________________________
+Int_t AliESDtrack::GetNumberOfTRDslices() const 
+{
+  // built in backward compatibility
+  Int_t idx = fTRDnSlices - (kTRDnPlanes<<1);
+  return idx<18 ? fTRDnSlices/kTRDnPlanes : idx/kTRDnPlanes;
+}
+
+//____________________________________________________
+Double_t AliESDtrack::GetTRDmomentum(Int_t plane, Double_t *sp) const
+{
+//Returns momentum estimation and optional its error (sp)
+// in TRD layer "plane".
+
+  if (!fTRDnSlices) {
+    AliError("No TRD info allocated for this track !");
+    return -1.;
+  }
+  if ((plane<0) || (plane>=kTRDnPlanes)) {
+    AliError("Info for TRD plane not available!");
+    return -1.;
+  }
+
+  Int_t idx = fTRDnSlices-(kTRDnPlanes<<1)+plane;
+  // Protection for backward compatibility
+  if(idx<(GetNumberOfTRDslices()*kTRDnPlanes)) return -1.;
+
+  if(sp) (*sp) = fTRDslices[idx+kTRDnPlanes];
+  return fTRDslices[idx];
+}
+
+//____________________________________________________
+Double_t  AliESDtrack::GetTRDslice(Int_t plane, Int_t slice) const {
+  //Gets the charge from the slice of the plane
+
+  if(!fTRDslices) {
+    //AliError("No TRD slices allocated for this track !");
+    return -1.;
+  }
+  if ((plane<0) || (plane>=kTRDnPlanes)) {
+    AliError("Info for TRD plane not available !");
+    return -1.;
+  }
+  Int_t ns=GetNumberOfTRDslices();
+  if ((slice<-1) || (slice>=ns)) {
+    //AliError("Wrong TRD slice !");  
+    return -1.;
+  }
+
+  if(slice>=0) return fTRDslices[plane*ns + slice];
+
+  // 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);
+  return q/ns;
+}
+
+//____________________________________________________
 void  AliESDtrack::SetNumberOfTRDslices(Int_t n) {
   //Sets the number of slices used for PID 
-  if (fTRDnSlices != 0) return;
-  fTRDnSlices=kTRDnPlanes*n;
+  if (fTRDnSlices) return;
+
+  fTRDnSlices=n;
   fTRDslices=new Double32_t[fTRDnSlices];
-  for (Int_t i=0; i<fTRDnSlices; i++) fTRDslices[i]=-1.;
+  
+  // set-up correctly the allocated memory
+  memset(fTRDslices, 0, n*sizeof(Double32_t));
+  for (Int_t i=GetNumberOfTRDslices(); i--;) fTRDslices[i]=-1.;
 }
 
+//____________________________________________________
 void  AliESDtrack::SetTRDslice(Double_t q, Int_t plane, Int_t slice) {
   //Sets the charge q in the slice of the plane
-  Int_t ns=GetNumberOfTRDslices();
-  if (ns==0) {
+  if(!fTRDslices) {
     AliError("No TRD slices allocated for this track !");
     return;
   }
-
   if ((plane<0) || (plane>=kTRDnPlanes)) {
-    AliError("Wrong TRD plane !");
+    AliError("Info for TRD plane not allocated !");
     return;
   }
+  Int_t ns=GetNumberOfTRDslices();
   if ((slice<0) || (slice>=ns)) {
     AliError("Wrong TRD slice !");
     return;
@@ -1617,30 +1696,25 @@ void  AliESDtrack::SetTRDslice(Double_t q, Int_t plane, Int_t slice) {
   fTRDslices[n]=q;
 }
 
-Double_t  AliESDtrack::GetTRDslice(Int_t plane, Int_t slice) const {
-  //Gets the charge from the slice of the plane
-  Int_t ns=GetNumberOfTRDslices();
-  if (ns==0) {
-    //AliError("No TRD slices allocated for this track !");
-    return -1.;
-  }
 
-  if ((plane<0) || (plane>=kTRDnPlanes)) {
-    AliError("Wrong TRD plane !");
-    return -1.;
+//____________________________________________________
+void AliESDtrack::SetTRDmomentum(Double_t p, Int_t plane, Double_t *sp)
+{
+  if(!fTRDslices) {
+    AliError("No TRD slices allocated for this track !");
+    return;
   }
-  if ((slice<-1) || (slice>=ns)) {
-    //AliError("Wrong TRD slice !");  
-    return -1.;
+  if ((plane<0) || (plane>=kTRDnPlanes)) {
+    AliError("Info for TRD plane not allocated !");
+    return;
   }
 
-  if (slice==-1) {
-    Double_t q=0.;
-    for (Int_t i=0; i<ns; i++) q+=fTRDslices[plane*ns + i];
-    return q/ns;
-  }
+  Int_t idx = fTRDnSlices-(kTRDnPlanes<<1)+plane;
+  // Protection for backward compatibility
+  if(idx<GetNumberOfTRDslices()*kTRDnPlanes) return;
 
-  return fTRDslices[plane*ns + slice];
+  if(sp) fTRDslices[idx+kTRDnPlanes] = (*sp);
+  fTRDslices[idx] = p;
 }
 
 
@@ -1802,6 +1876,7 @@ Double_t b, Double_t maxd, AliExternalTrackParam *cParam) {
   if (!fCp->Update(p,c)) {delete fCp; fCp=0; return kFALSE;}
   //----------------------------------------
 
+  fVertexID = vtx->GetID();
 
   if (!cParam) return kTRUE;
 
@@ -1911,3 +1986,21 @@ void AliESDtrack::FillPolymarker(TPolyMarker3D *pol, Float_t magF, Float_t minR,
     }
   }
 }
+
+//_______________________________________________________________________
+void AliESDtrack::SetITSdEdxSamples(const Double_t s[4]) {
+  //
+  // 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=0; i<4; i++) fITSdEdxSamples[i]=s[i];
+}
+
+//_______________________________________________________________________
+void AliESDtrack::GetITSdEdxSamples(Double_t *s) 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=0; i<4; i++) s[i]=fITSdEdxSamples[i];
+}