Moving non-persistent data to AliESDfriend (Yu.Belikov)
authorhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 25 Apr 2006 12:41:16 +0000 (12:41 +0000)
committerhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 25 Apr 2006 12:41:16 +0000 (12:41 +0000)
ITS/AliITStrackMI.cxx
PHOS/AliPHOSTrackSegmentMakerv1.cxx
STEER/AliAlignmentTracks.cxx
STEER/AliESDfriend.cxx
STEER/AliESDfriendTrack.cxx
STEER/AliESDfriendTrack.h
STEER/AliESDpid.cxx
STEER/AliESDtrack.cxx
STEER/AliESDtrack.h
STEER/CheckESD.C

index ecbdd6e..c3ab695 100644 (file)
@@ -77,7 +77,7 @@ AliITStrackV2(t,c) {
 
 void AliITStrackMI::UpdateESDtrack(ULong_t flags) {
   fESDtrack->UpdateTrackParams(this,flags);
-  if (flags == AliESDtrack::kITSin) fESDtrack->SetITSChi2MIP(fChi2MIP);
+  //if (flags == AliESDtrack::kITSin) fESDtrack->SetITSChi2MIP(fChi2MIP);
 }
 
 //____________________________________________________________________________
index df03c7c..44ca8d4 100644 (file)
@@ -17,6 +17,9 @@
 /* History of cvs commits:
  *
  * $Log$
+ * Revision 1.78  2005/11/18 13:04:51  hristov
+ * Bug fix
+ *
  * Revision 1.77  2005/11/17 23:34:36  hristov
  * Corrected logics
  *
@@ -201,8 +204,6 @@ Float_t  AliPHOSTrackSegmentMakerv1::GetDistanceInPHOSPlane(AliPHOSEmcRecPoint *
       AliESDtrack *track;
       for (Int_t iTrack=0; iTrack<nTracks; iTrack++) {
        track = fESD->GetTrack(iTrack);
-       if (track->IsPHOS()) 
-         continue ; //Skip the PHOS tracks
        if (!track->GetXYZAt(rPHOS, fESD->GetMagneticField(), xyz))
            continue; //track coord on the cylinder of PHOS radius
        if ((TMath::Abs(xyz[0])+TMath::Abs(xyz[1])+TMath::Abs(xyz[2]))<=0)
index 1aa1a30..3883cdb 100644 (file)
@@ -183,7 +183,7 @@ void AliAlignmentTracks::ProcessESD()
   }
 
   TTree *pointsTree = new TTree("spTree", "Tree with track space point arrays");
-  AliTrackPointArray *array = 0;
+  const AliTrackPointArray *array = 0;
   pointsTree->Branch("SP","AliTrackPointArray", &array);
 
   Int_t ievent = 0;
index f8b9efa..ea8e1de 100644 (file)
@@ -49,7 +49,9 @@ fTracks("AliESDfriendTrack",event.GetNumberOfTracks()) {
 
   for (Int_t i=0; i<ntrk; i++) {
     const AliESDtrack *t=event.GetTrack(i);
-    new (fTracks[fTracks.GetEntriesFast()]) AliESDfriendTrack(*t); 
+    AliESDfriendTrack *ft=(AliESDfriendTrack *)t->GetFriendTrack();
+    ft->Set1P(t->Get1P());
+    new (fTracks[fTracks.GetEntriesFast()]) AliESDfriendTrack(*ft); 
   }
 }
 
index 72e7b79..79ec33d 100644 (file)
 //-------------------------------------------------------------------------
 #include "AliTrackPointArray.h"
 #include "AliESDfriendTrack.h"
-#include "AliESD.h"
+#include "AliKalmanTrack.h"
 
 ClassImp(AliESDfriendTrack)
 
-  AliESDfriendTrack::AliESDfriendTrack(): TObject(), f1P(0), fPoints(0) {
+AliESDfriendTrack::AliESDfriendTrack(): 
+TObject(), 
+f1P(0), 
+fPoints(0), 
+fITStrack(0),
+fTRDtrack(0)
+{
   //
   // Default constructor
   //
   Int_t i;
-  for (i=0; i<AliESDtrack::kMaxITScluster; i++) fITSindex[i]=-2;
-  for (i=0; i<AliESDtrack::kMaxTPCcluster; i++) fTPCindex[i]=-2;
-  for (i=0; i<AliESDtrack::kMaxTRDcluster; i++) fTRDindex[i]=-2;
+  for (i=0; i<kMaxITScluster; i++) fITSindex[i]=-2;
+  for (i=0; i<kMaxTPCcluster; i++) fTPCindex[i]=-2;
+  for (i=0; i<kMaxTRDcluster; i++) fTRDindex[i]=-2;
 }
 
 AliESDfriendTrack::AliESDfriendTrack(const AliESDfriendTrack &t): 
 TObject(t),
 f1P(t.f1P),
-fPoints(0)
+fPoints(0),
+fITStrack(0),
+fTRDtrack(0)
 {
   //
   // Copy constructor
   //
   Int_t i;
-  for (i=0; i<AliESDtrack::kMaxITScluster; i++) fITSindex[i]=t.fITSindex[i];
-  for (i=0; i<AliESDtrack::kMaxTPCcluster; i++) fTPCindex[i]=t.fTPCindex[i];
-  for (i=0; i<AliESDtrack::kMaxTRDcluster; i++) fTRDindex[i]=t.fTRDindex[i];
+  for (i=0; i<kMaxITScluster; i++) fITSindex[i]=t.fITSindex[i];
+  for (i=0; i<kMaxTPCcluster; i++) fTPCindex[i]=t.fTPCindex[i];
+  for (i=0; i<kMaxTRDcluster; i++) fTRDindex[i]=t.fTRDindex[i];
   if (t.fPoints) fPoints=new AliTrackPointArray(*t.fPoints);
 }
 
-AliESDfriendTrack::AliESDfriendTrack(const AliESDtrack &t): 
-TObject(t),
-f1P(t.Get1P()),
-fPoints(0) 
-{
+AliESDfriendTrack::~AliESDfriendTrack() {
   //
-  // Extracts the complementary info from the ESD track
+  // Simple destructor
   //
-  t.GetITSclusters(fITSindex); 
-  t.GetTPCclusters(fTPCindex); 
-  t.GetTRDclusters(fTRDindex); 
-  const AliTrackPointArray *points=t.GetTrackPointArray();
-  if (points) fPoints=new AliTrackPointArray(*points);
+   delete fPoints;
+   delete fITStrack;
+   delete fTRDtrack;
 }
-
-AliESDfriendTrack::~AliESDfriendTrack() {delete fPoints;}
index 69ee70f..b86a455 100644 (file)
@@ -8,31 +8,47 @@
 //-------------------------------------------------------------------------
 
 #include <TObject.h>
-#include "AliESDtrack.h"
 
 class AliTrackPointArray;
+class AliKalmanTrack;
 
 //_____________________________________________________________________________
 class AliESDfriendTrack : public TObject {
 public:
+  enum {
+    kMaxITScluster=12,
+    kMaxTPCcluster=160,
+    kMaxTRDcluster=180
+  };
   AliESDfriendTrack();
   AliESDfriendTrack(const AliESDfriendTrack &);
-  AliESDfriendTrack(const AliESDtrack &);
   virtual ~AliESDfriendTrack();
 
-  Float_t Get1P() const {return f1P;}
-  const Int_t *GetITSindices() const {return fITSindex;}
-  const Int_t *GetTPCindices() const {return fTPCindex;}
-  const Int_t *GetTRDindices() const {return fTRDindex;}
+  void Set1P(Float_t p) {f1P=p;}
+  void SetTrackPointArray(AliTrackPointArray *points) {
+    fPoints=points;
+  }
+  Float_t Get1P() const  {return f1P;}
+  Int_t *GetITSindices() {return fITSindex;}
+  Int_t *GetTPCindices() {return fTPCindex;}
+  Int_t *GetTRDindices() {return fTRDindex;}
   const AliTrackPointArray *GetTrackPointArray() const {return fPoints;}
 
+  void SetITStrack(AliKalmanTrack *t) {fITStrack=t;}
+  void SetTRDtrack(AliKalmanTrack *t) {fTRDtrack=t;}
+  AliKalmanTrack *GetTRDtrack() {return fTRDtrack;}
+  AliKalmanTrack *GetITStrack() {return fITStrack;}
+
 protected:
-  Float_t f1P;                                  // 1/P (1/(GeV/c))
-  Int_t fITSindex[AliESDtrack::kMaxITScluster]; // indices of the ITS clusters 
-  Int_t fTPCindex[AliESDtrack::kMaxTPCcluster]; // indices of the TPC clusters
-  Int_t fTRDindex[AliESDtrack::kMaxTRDcluster]; // indices of the TRD clusters
+  Float_t f1P;                     // 1/P (1/(GeV/c))
+  Int_t fITSindex[kMaxITScluster]; // indices of the ITS clusters 
+  Int_t fTPCindex[kMaxTPCcluster]; // indices of the TPC clusters
+  Int_t fTRDindex[kMaxTRDcluster]; // indices of the TRD clusters
+  AliTrackPointArray *fPoints;//Array of track space points in the global frame
+
+  AliKalmanTrack *fITStrack; //! pointer to the ITS track (debug purposes) 
+  AliKalmanTrack *fTRDtrack; //! pointer to the TRD track (debug purposes) 
 
-  AliTrackPointArray *fPoints; // Array of track space points in the global frame
   ClassDef(AliESDfriendTrack,1) //ESD friend track
 };
 
index 49844a1..22b839b 100644 (file)
@@ -81,15 +81,6 @@ Int_t AliESDpid::MakePID(AliESD *event)
       for (j=0; j<ns; j++) p[j]*=d[j];
     }
 
-    //    if ((t->GetStatus()&AliESDtrack::kPHOSpid )!=0) {
-    //  Double_t d[10];
-    //  t->GetPHOSpid(d);
-    //  Int_t j, ok=0;
-    //  for (j=0; j<ns; j++) if (d[j]>keps) ok=1;
-    //  if (ok) 
-    //  for (j=0; j<ns; j++) p[j]*=d[j];
-    //}
-
     if ((t->GetStatus()&AliESDtrack::kRICHpid )!=0) {
       Double_t d[10];
       t->GetRICHpid(d);
index de2b6cc..339bf6f 100644 (file)
 
 #include "AliESDVertex.h"
 #include "AliESDtrack.h"
+#include "AliESDfriendTrack.h"
 #include "AliKalmanTrack.h"
-#include "AliTrackPointArray.h"
 #include "AliLog.h"
+#include "AliTrackPointArray.h"
 
 ClassImp(AliESDtrack)
 
@@ -76,7 +77,6 @@ AliESDtrack::AliESDtrack() :
   fITSsignal(0),
   fITSLabel(0),
   fITSFakeRatio(0),
-  fITStrack(0),
   fTPCchi2(0),
   fTPCncls(0),
   fTPCnclsF(0),
@@ -92,13 +92,11 @@ AliESDtrack::AliESDtrack() :
   fTRDLabel(0),
   fTRDQuality(0),
   fTRDBudget(0),
-  fTRDtrack(0),
   fTOFchi2(0),
   fTOFindex(0),
   fTOFCalChannel(-1),
   fTOFsignal(-1),
   fTOFsignalToT(0),
-  //  fPHOSsignal(-1),
   fRICHchi2(1e10),
   fRICHncls(0),
   fRICHindex(0),
@@ -109,7 +107,8 @@ AliESDtrack::AliESDtrack() :
   fRICHdy(-1),
   fRICHmipX(-1),
   fRICHmipY(-1),
-  fPoints(0)
+  fPoints(0),
+  fFriendTrack(new AliESDfriendTrack())
 {
   //
   // The default ESD constructor 
@@ -125,12 +124,8 @@ AliESDtrack::AliESDtrack() :
     fRICHr[i]=1.;
   }
   
-  for (i=0; i<kMaxITScluster; i++)  fITSchi2MIP[i]=1e10;
-  for (i=0; i<kMaxITScluster; i++)  { fITSindex[i]=-1; }
-  for (i=0; i<kMaxTPCcluster; i++) { fTPCindex[i]=-2; }
   for (i=0; i<3; i++)   { fKinkIndexes[i]=0;}
   for (i=0; i<3; i++)   { fV0Indexes[i]=-1;}
-  for (i=0; i<kMaxTRDcluster; i++) { fTRDindex[i]=-2; }
   for (i=0;i<kNPlane;i++) {fTRDsignals[i]=0.; fTRDTimBin[i]=-1;}
   for (i=0;i<4;i++) {fTPCPoints[i]=-1;}
   for (i=0;i<3;i++) {fTOFLabel[i]=-1;}
@@ -156,7 +151,6 @@ AliESDtrack::AliESDtrack(const AliESDtrack& track):
   fITSsignal(track.fITSsignal),
   fITSLabel(track.fITSLabel),
   fITSFakeRatio(track.fITSFakeRatio),
-  fITStrack(0),    //coping separatelly - in user code
   fTPCchi2(track.fTPCchi2),
   fTPCncls(track.fTPCncls),
   fTPCnclsF(track.fTPCnclsF),
@@ -172,13 +166,11 @@ AliESDtrack::AliESDtrack(const AliESDtrack& track):
   fTRDLabel(track.fTRDLabel),
   fTRDQuality(track.fTRDQuality),
   fTRDBudget(track.fTRDBudget),
-  fTRDtrack(0),
   fTOFchi2(track.fTOFchi2),
   fTOFindex(track.fTOFindex),
   fTOFCalChannel(track.fTOFCalChannel),
   fTOFsignal(track.fTOFsignal),
   fTOFsignalToT(track.fTOFsignalToT),
-  //fPHOSsignal(track.fPHOSsignal),
   fRICHchi2(track.fRICHchi2),
   fRICHncls(track.fRICHncls),
   fRICHindex(track.fRICHindex),
@@ -188,7 +180,9 @@ AliESDtrack::AliESDtrack(const AliESDtrack& track):
   fRICHdx(track.fRICHdx),
   fRICHdy(track.fRICHdy),
   fRICHmipX(track.fRICHmipX),
-  fRICHmipY(track.fRICHmipY)
+  fRICHmipY(track.fRICHmipY),
+  fPoints(0),
+  fFriendTrack(new AliESDfriendTrack(*(track.fFriendTrack)))
 {
   //
   //copy constructor
@@ -196,17 +190,13 @@ AliESDtrack::AliESDtrack(const AliESDtrack& track):
   for (Int_t i=0;i<AliPID::kSPECIES;i++) fTrackTime[i]=track.fTrackTime[i];
   for (Int_t i=0;i<AliPID::kSPECIES;i++)  fR[i]=track.fR[i];
   //
-  for (Int_t i=0;i<kMaxITScluster;i++) fITSchi2MIP[i]=track.fITSchi2MIP[i];
-  for (Int_t i=0;i<kMaxITScluster;i++) fITSindex[i]=track.fITSindex[i];    
   for (Int_t i=0;i<AliPID::kSPECIES;i++) fITSr[i]=track.fITSr[i]; 
   //
-  for (Int_t i=0;i<kMaxTPCcluster;i++) fTPCindex[i]=track.fTPCindex[i];  
   for (Int_t i=0;i<AliPID::kSPECIES;i++) fTPCr[i]=track.fTPCr[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<kMaxTRDcluster;i++) fTRDindex[i]=track.fTRDindex[i];   
   for (Int_t i=0;i<kNPlane;i++) {
       fTRDsignals[i]=track.fTRDsignals[i]; 
       fTRDTimBin[i]=track.fTRDTimBin[i];
@@ -220,11 +210,10 @@ AliESDtrack::AliESDtrack(const AliESDtrack& track):
   if (track.fCp) fCp=new AliExternalTrackParam(*track.fCp);
   if (track.fIp) fIp=new AliExternalTrackParam(*track.fIp);
   if (track.fOp) fOp=new AliExternalTrackParam(*track.fOp);
-  fPoints =0;
-  if (track.fPoints){
-    fPoints  = new AliTrackPointArray(*(track.fPoints));
-  }
+
+  if (track.fPoints) fPoints=new AliTrackPointArray(*(track.fPoints));
 }
+
 //_______________________________________________________________________
 AliESDtrack::~AliESDtrack(){ 
   //
@@ -234,8 +223,7 @@ AliESDtrack::~AliESDtrack(){
   delete fIp; 
   delete fOp;
   delete fCp; 
-  delete fITStrack;
-  delete fTRDtrack; 
+  delete fFriendTrack;
   delete fPoints;
 }
 
@@ -270,20 +258,16 @@ void AliESDtrack::MakeMiniESDtrack(){
 
   // Reset ITS track related information
   fITSchi2 = 0;
-  for (Int_t i=0;i<kMaxITScluster;i++) fITSchi2MIP[i]=0;
   fITSncls = 0;       
-  for (Int_t i=0;i<kMaxITScluster;i++) fITSindex[i]=-1;    
   fITSsignal = 0;     
   for (Int_t i=0;i<AliPID::kSPECIES;i++) fITSr[i]=0; 
   fITSLabel = 0;       
   fITSFakeRatio = 0;   
-  fITStrack =0;
 
   // Reset TPC related track information
   fTPCchi2 = 0;       
   fTPCncls = 0;       
   fTPCnclsF = 0;       
-  for (Int_t i=0;i<kMaxTPCcluster;i++) fTPCindex[i] = -2;  
   fTPCClusterMap = 0;  
   fTPCsignal= 0;      
   fTPCsignalS= 0;      
@@ -298,7 +282,6 @@ void AliESDtrack::MakeMiniESDtrack(){
   fTRDchi2 = 0;        
   fTRDncls = 0;       
   fTRDncls0 = 0;       
-  for (Int_t i=0;i<kMaxTRDcluster;i++) fTRDindex[i] = -2;   
   fTRDsignal = 0;      
   for (Int_t i=0;i<kNPlane;i++) {
       fTRDsignals[i] = 0; 
@@ -306,7 +289,6 @@ void AliESDtrack::MakeMiniESDtrack(){
   }
   for (Int_t i=0;i<AliPID::kSPECIES;i++) fTRDr[i] = 0; 
   fTRDLabel = 0;       
-  fTRDtrack = 0; 
   fTRDQuality  = 0;
   fTRDBudget  = 0;
 
@@ -320,11 +302,6 @@ void AliESDtrack::MakeMiniESDtrack(){
   for (Int_t i=0;i<3;i++) fTOFLabel[i] = 0;
   for (Int_t i=0;i<10;i++) fTOFInfo[i] = 0;
 
-  // Reset PHOS related track information
-  //for (Int_t i=0;i<3;i++) fPHOSpos[i] = 0; 
-  //fPHOSsignal = 0; 
-  //for (Int_t i=0;i<AliPID::kSPECIESN;i++) fPHOSr[i] = 0;
-  
   // Reset RICH related track information
   fRICHchi2 = 0;     
   fRICHncls = 0;     
@@ -336,7 +313,8 @@ void AliESDtrack::MakeMiniESDtrack(){
   fRICHdx = 0;     
   fRICHdy = 0;      
 
-  fPoints = 0;
+  delete fFriendTrack; fFriendTrack = 0;
+  delete fPoints; fPoints = 0;
 } 
 //_______________________________________________________________________
 Double_t AliESDtrack::GetMass() const {
@@ -367,6 +345,7 @@ Bool_t AliESDtrack::UpdateTrackParams(const AliKalmanTrack *t, ULong_t flags){
   //
   // This function updates track's running parameters 
   //
+  Int_t *index=0;
   Bool_t rc=kTRUE;
 
   SetStatus(flags);
@@ -383,9 +362,11 @@ Bool_t AliESDtrack::UpdateTrackParams(const AliKalmanTrack *t, ULong_t flags){
   switch (flags) {
     
   case kITSin: case kITSout: case kITSrefit:
+    index=fFriendTrack->GetITSindices(); 
+    for (Int_t i=0;i<AliESDfriendTrack::kMaxITScluster;i++) 
+         index[i]=t->GetClusterIndex(i);
     fITSncls=t->GetNumberOfClusters();
     fITSchi2=t->GetChi2();
-    for (Int_t i=0;i<kMaxITScluster;i++) fITSindex[i]=t->GetClusterIndex(i);
     fITSsignal=t->GetPIDsignal();
     fITSLabel = t->GetLabel();
     fITSFakeRatio = t->GetFakeRatio();
@@ -396,6 +377,7 @@ Bool_t AliESDtrack::UpdateTrackParams(const AliKalmanTrack *t, ULong_t flags){
     if (!fIp) fIp=new AliExternalTrackParam(*t);
     else fIp->Set(*t);
   case kTPCout:
+    index=fFriendTrack->GetTPCindices(); 
     if (flags & kTPCout){
       if (!fOp) fOp=new AliExternalTrackParam(*t);
       else fOp->Set(*t);
@@ -407,16 +389,16 @@ Bool_t AliESDtrack::UpdateTrackParams(const AliKalmanTrack *t, ULong_t flags){
       //"jump to case label crosses initialization of `Int_t prevrow'"
        Int_t prevrow = -1;
        //       for (Int_t i=0;i<fTPCncls;i++) 
-       for (Int_t i=0;i<kMaxTPCcluster;i++) 
+       for (Int_t i=0;i<AliESDfriendTrack::kMaxTPCcluster;i++) 
         {
-          fTPCindex[i]=t->GetClusterIndex(i);
+          index[i]=t->GetClusterIndex(i);
+          Int_t idx = index[i];
 
-         if (fTPCindex[i]<0) continue; 
+         if (idx<0) continue; 
 
           // Piotr's Cluster Map for HBT  
           // ### please change accordingly if cluster array is changing 
           // to "New TPC Tracking" style (with gaps in array) 
-          Int_t idx = fTPCindex[i];
           Int_t sect = (idx&0xff000000)>>24;
           Int_t row = (idx&0x00ff0000)>>16;
           if (sect > 18) row +=63; //if it is outer sector, add number of inner sectors
@@ -458,10 +440,11 @@ Bool_t AliESDtrack::UpdateTrackParams(const AliKalmanTrack *t, ULong_t flags){
     break;
 
   case kTRDout: case kTRDin: case kTRDrefit:
+    index=fFriendTrack->GetTRDindices();
     fTRDLabel = t->GetLabel(); 
     fTRDncls=t->GetNumberOfClusters();
     fTRDchi2=t->GetChi2();
-    for (Int_t i=0;i<fTRDncls;i++) fTRDindex[i]=t->GetClusterIndex(i);
+    for (Int_t i=0;i<fTRDncls;i++) index[i]=t->GetClusterIndex(i);
     fTRDsignal=t->GetPIDsignal();
     break;
   case kTRDbackup:
@@ -645,9 +628,6 @@ void AliESDtrack::SetITSpid(const Double_t *p) {
   SetStatus(AliESDtrack::kITSpid);
 }
 
-void AliESDtrack::SetITSChi2MIP(const Float_t *chi2mip){
-  for (Int_t i=0; i<kMaxITScluster; i++) fITSchi2MIP[i]=chi2mip[i];
-}
 //_______________________________________________________________________
 void AliESDtrack::GetITSpid(Double_t *p) const {
   // Gets the probability of each particle type (in ITS)
@@ -659,7 +639,10 @@ Int_t AliESDtrack::GetITSclusters(Int_t *idx) const {
   //---------------------------------------------------------------------
   // This function returns indices of the assgined ITS clusters 
   //---------------------------------------------------------------------
-  for (Int_t i=0; i<kMaxITScluster; i++) idx[i]=fITSindex[i];
+  if (idx!=0) {
+     Int_t *index=fFriendTrack->GetITSindices();
+     for (Int_t i=0; i<AliESDfriendTrack::kMaxITScluster; i++) idx[i]=index[i];
+  }
   return fITSncls;
 }
 
@@ -668,8 +651,10 @@ Int_t AliESDtrack::GetTPCclusters(Int_t *idx) const {
   //---------------------------------------------------------------------
   // This function returns indices of the assgined ITS clusters 
   //---------------------------------------------------------------------
-  if (idx!=0)
-    for (Int_t i=0; i<kMaxTPCcluster; i++) idx[i]=fTPCindex[i];  // MI I prefer some constant
+  if (idx!=0) {
+    Int_t *index=fFriendTrack->GetTPCindices();
+    for (Int_t i=0; i<AliESDfriendTrack::kMaxTPCcluster; i++) idx[i]=index[i];
+  }
   return fTPCncls;
 }
 
@@ -681,10 +666,11 @@ Float_t AliESDtrack::GetTPCdensity(Int_t row0, Int_t row1) const{
   Int_t good  = 0;
   Int_t found = 0;
   //  
+  Int_t *index=fFriendTrack->GetTPCindices();
   for (Int_t i=row0;i<=row1;i++){     
-    Int_t index = fTPCindex[i];
-    if (index!=-1)  good++;             // track outside of dead zone
-    if (index>0)    found++;
+    Int_t idx = index[i];
+    if (idx!=-1)  good++;             // track outside of dead zone
+    if (idx>0)    found++;
   }
   Float_t density=0.5;
   if (good>(row1-row0)*0.5) density = Float_t(found)/Float_t(good);
@@ -709,8 +695,10 @@ Int_t AliESDtrack::GetTRDclusters(Int_t *idx) const {
   //---------------------------------------------------------------------
   // This function returns indices of the assgined TRD clusters 
   //---------------------------------------------------------------------
-  if (idx!=0)
-    for (Int_t i=0; i<kMaxTRDcluster; i++) idx[i]=fTRDindex[i];  // MI I prefer some constant
+  if (idx!=0) {
+     Int_t *index=fFriendTrack->GetTRDindices();
+     for (Int_t i=0; i<AliESDfriendTrack::kMaxTRDcluster; i++) idx[i]=index[i];
+  }
   return fTRDncls;
 }
 
@@ -868,6 +856,15 @@ Bool_t AliESDtrack::RelateToVertex
   return kTRUE;
 }
 
+void AliESDtrack::SetTrackPointArray(AliTrackPointArray *points) { 
+    fPoints=points;
+    //fFriendTrack->SetTrackPointArray(points); 
+}
+const AliTrackPointArray *AliESDtrack::GetTrackPointArray() const { 
+    return fPoints;
+  //return fFriendTrack->GetTrackPointArray(); 
+}
+
 //_______________________________________________________________________
 void AliESDtrack::Print(Option_t *) const {
   // Prints info on the track
index c2b300e..c9204d3 100644 (file)
 #include <TBits.h>
 #include "AliExternalTrackParam.h"
 #include "AliPID.h"
+#include "AliESDfriendTrack.h"
+
 #include <TVector3.h>
 
 class AliESDVertex;
 class AliKalmanTrack;
+class AliESDfriendTrack;
 class AliTrackPointArray;
 
 class AliESDtrack : public AliExternalTrackParam {
@@ -36,6 +39,7 @@ public:
   AliESDtrack();
   AliESDtrack(const AliESDtrack& track);
   virtual ~AliESDtrack();
+  const AliESDfriendTrack *GetFriendTrack() const {return fFriendTrack;}
   void MakeMiniESDtrack();
   void SetID(Int_t id) { fID =id;}
   Int_t GetID(){ return fID;}
@@ -47,6 +51,7 @@ public:
   void SetESDpid(const Double_t *p);
   void GetESDpid(Double_t *p) const;
   
+  Bool_t IsOn(Int_t mask) const {return (fFlags&mask)>0;}
   ULong_t GetStatus() const {return fFlags;}
   Int_t GetLabel() const {return fLabel;}
   void SetLabel(Int_t label) {fLabel = label;}
@@ -105,59 +110,74 @@ public:
   Int_t GetNcls(Int_t idet) const;
   Int_t GetClusters(Int_t idet, Int_t *idx) const;
  
-  void SetITSpid(const Double_t *p);
-  void SetITSChi2MIP(const Float_t *chi2mip);
-  void SetITStrack(AliKalmanTrack * track){fITStrack=track;}
-  void GetITSpid(Double_t *p) const;
+  void    SetITSpid(const Double_t *p);
+  void    GetITSpid(Double_t *p) const;
   Float_t GetITSsignal() const {return fITSsignal;}
   Float_t GetITSchi2() const {return fITSchi2;}
-  Int_t GetITSclusters(Int_t *idx) const;
-  Int_t GetITSLabel() const {return fITSLabel;}
+  Int_t   GetITSclusters(Int_t *idx) const;
+  Int_t   GetITSLabel() const {return fITSLabel;}
   Float_t GetITSFakeRatio() const {return fITSFakeRatio;}
-  AliKalmanTrack * GetITStrack(){return fITStrack;}
 
-  void SetTPCpid(const Double_t *p);
-  void GetTPCpid(Double_t *p) const;
-  void SetTPCPoints(Float_t points[4]){for (Int_t i=0;i<4;i++) fTPCPoints[i]=points[i];}
-  void SetTPCPointsF(UChar_t  findable){fTPCnclsF = findable;}
+  void    SetITStrack(AliKalmanTrack * track){
+     fFriendTrack->SetITStrack(track);
+  }
+  AliKalmanTrack *GetITStrack(){
+     return fFriendTrack->GetITStrack();
+  }
+
+  void    SetTPCpid(const Double_t *p);
+  void    GetTPCpid(Double_t *p) const;
+  void    SetTPCPoints(Float_t points[4]){
+     for (Int_t i=0;i<4;i++) fTPCPoints[i]=points[i];
+  }
+  void    SetTPCPointsF(UChar_t  findable){fTPCnclsF = findable;}
   Float_t GetTPCPoints(Int_t i){return fTPCPoints[i];}
-  void SetKinkIndexes(Int_t points[3]) {for (Int_t i=0;i<3;i++) fKinkIndexes[i] = points[i];}
-  void SetV0Indexes(Int_t points[3]) {for (Int_t i=0;i<3;i++) fV0Indexes[i] = points[i];}
-  void SetTPCsignal(Float_t signal, Float_t sigma, UChar_t npoints){ fTPCsignal = signal; fTPCsignalS = sigma; fTPCsignalN = npoints;}
+  void    SetKinkIndexes(Int_t points[3]) {
+     for (Int_t i=0;i<3;i++) fKinkIndexes[i] = points[i];
+  }
+  void    SetV0Indexes(Int_t points[3]) {
+     for (Int_t i=0;i<3;i++) fV0Indexes[i] = points[i];
+  }
+  void    SetTPCsignal(Float_t signal, Float_t sigma, UChar_t npoints){ 
+     fTPCsignal = signal; fTPCsignalS = sigma; fTPCsignalN = npoints;
+  }
   Float_t GetTPCsignal() const {return fTPCsignal;}
   Float_t GetTPCchi2() const {return fTPCchi2;}
-  Int_t GetTPCclusters(Int_t *idx) const;
+  Int_t   GetTPCclusters(Int_t *idx) const;
   Float_t GetTPCdensity(Int_t row0, Int_t row1) const;
-  Int_t GetTPCLabel() const {return fTPCLabel;}
-  Int_t GetKinkIndex(Int_t i) const { return fKinkIndexes[i];}
-  Int_t GetV0Index(Int_t i) const { return fV0Indexes[i];}
+  Int_t   GetTPCLabel() const {return fTPCLabel;}
+  Int_t   GetKinkIndex(Int_t i) const { return fKinkIndexes[i];}
+  Int_t   GetV0Index(Int_t i) const { return fV0Indexes[i];}
   const TBits& GetTPCClusterMap() const {return fTPCClusterMap;}
   
-  void SetTRDpid(const Double_t *p);
-  void     SetTRDQuality(Float_t quality){fTRDQuality=quality;}
-  Float_t  GetTRDQuality()const {return fTRDQuality;}
-  void     SetTRDBudget(Float_t budget){fTRDBudget=budget;}
-  Float_t  GetTRDBudget()const {return fTRDBudget;}
-  void SetTRDtrack(AliKalmanTrack * track){fTRDtrack=track;}
-  void SetTRDsignals(Float_t dedx, Int_t i) {fTRDsignals[i]=dedx;}
-  void SetTRDTimBin(Int_t timbin, Int_t i) {fTRDTimBin[i]=timbin;}
-  void GetTRDpid(Double_t *p) const;
+  void    SetTRDpid(const Double_t *p);
+  void    SetTRDQuality(Float_t quality){fTRDQuality=quality;}
+  Float_t GetTRDQuality()const {return fTRDQuality;}
+  void    SetTRDBudget(Float_t budget){fTRDBudget=budget;}
+  Float_t GetTRDBudget()const {return fTRDBudget;}
+  void    SetTRDsignals(Float_t dedx, Int_t i) {fTRDsignals[i]=dedx;}
+  void    SetTRDTimBin(Int_t timbin, Int_t i) {fTRDTimBin[i]=timbin;}
+  void    GetTRDpid(Double_t *p) const;
   Float_t GetTRDsignal() const {return fTRDsignal;}
   Float_t GetTRDsignals(Int_t i) const {return fTRDsignals[i];}
-  Int_t GetTRDTimBin(Int_t i) const {return fTRDTimBin[i];}
+  Int_t   GetTRDTimBin(Int_t i) const {return fTRDTimBin[i];}
   Float_t GetTRDchi2() const {return fTRDchi2;}
-  Int_t GetTRDclusters(Int_t *idx) const;
-  Int_t GetTRDncls() const {return fTRDncls;}
+  Int_t   GetTRDclusters(Int_t *idx) const;
+  Int_t   GetTRDncls() const {return fTRDncls;}
   void    SetTRDpid(Int_t iSpecies, Float_t p);
   Float_t GetTRDpid(Int_t iSpecies) const;
-  Int_t GetTRDLabel() const {return fTRDLabel;}
+  Int_t   GetTRDLabel() const {return fTRDLabel;}
 
+  void    SetTRDtrack(AliKalmanTrack * track){
+     fFriendTrack->SetTRDtrack(track);
+  }
+  AliKalmanTrack *GetTRDtrack(){
+     return fFriendTrack->GetTRDtrack();
+  }
 
-  AliKalmanTrack * GetTRDtrack(){return fTRDtrack;}
-
-  void SetTOFsignal(Double_t tof) {fTOFsignal=tof;}
+  void    SetTOFsignal(Double_t tof) {fTOFsignal=tof;}
   Float_t GetTOFsignal() const {return fTOFsignal;}
-  void SetTOFsignalToT(Double_t ToT) {fTOFsignalToT=ToT;}
+  void    SetTOFsignalToT(Double_t ToT) {fTOFsignalToT=ToT;}
   Float_t GetTOFsignalToT() const {return fTOFsignalToT;}
   Float_t GetTOFchi2() const {return fTOFchi2;}
   void    SetTOFpid(const Double_t *p);
@@ -167,9 +187,9 @@ public:
   void    GetTOFInfo(Float_t *info) const;
   void    SetTOFInfo(Float_t *info);
   Int_t   GetTOFCalChannel() const {return fTOFCalChannel;}
-  Int_t  GetTOFcluster() const {return fTOFindex;}
-  void  SetTOFcluster(Int_t index) {fTOFindex=index;}
-  void  SetTOFCalChannel(Int_t index) {fTOFCalChannel=index;}
+  Int_t   GetTOFcluster() const {return fTOFindex;}
+  void    SetTOFcluster(Int_t index) {fTOFindex=index;}
+  void    SetTOFCalChannel(Int_t index) {fTOFCalChannel=index;}
   
   void    SetRICHsignal(Double_t beta) {fRICHsignal=beta;}
   Float_t GetRICHsignal() const {return fRICHsignal;}
@@ -178,25 +198,33 @@ public:
   void    SetRICHchi2(Double_t chi2) {fRICHchi2=chi2;}
   Float_t GetRICHchi2() const {return fRICHchi2;}
   void    SetRICHcluster(Int_t index) {fRICHindex=index;}
-  Int_t  GetRICHcluster() const {return fRICHindex;}
+  Int_t   GetRICHcluster() const {return fRICHindex;}
   void    SetRICHnclusters(Int_t n) {fRICHncls=n;}
   Int_t   GetRICHnclusters() const {return fRICHncls;}
-  void    SetRICHthetaPhi(Float_t  theta, Float_t  phi)      {fRICHtheta=theta; fRICHphi=phi;}
-  void    GetRICHthetaPhi(Float_t &theta, Float_t &phi)const {theta=fRICHtheta; phi=fRICHphi;}
-  void    SetRICHdxdy    (Float_t     dx, Float_t   dy)      {fRICHdx=dx;         fRICHdy=dy;}
-  void    GetRICHdxdy    (Float_t    &dx, Float_t  &dy)const {dx=fRICHdx;         dy=fRICHdy;}
-  void    SetRICHmipXY   (Float_t      x, Float_t    y)      {fRICHmipX=x;       fRICHmipY=y;} 
-  void    GetRICHmipXY   (Float_t     &x, Float_t   &y)const {x=fRICHmipX;       y=fRICHmipY;}
-  
-  Bool_t IsOn(Int_t mask) const {return (fFlags&mask)>0;}
+  void    SetRICHthetaPhi(Float_t theta, Float_t phi) {
+    fRICHtheta=theta; fRICHphi=phi;
+  }
+  void    GetRICHthetaPhi(Float_t &theta, Float_t &phi) const {
+    theta=fRICHtheta; phi=fRICHphi;
+  }
+  void    SetRICHdxdy(Float_t dx, Float_t dy) {
+    fRICHdx=dx;  fRICHdy=dy;
+  }
+  void    GetRICHdxdy(Float_t &dx, Float_t &dy) const {
+    dx=fRICHdx;  dy=fRICHdy;
+  }
+  void    SetRICHmipXY(Float_t x, Float_t y) {
+    fRICHmipX=x; fRICHmipY=y;
+  } 
+  void    GetRICHmipXY(Float_t &x, Float_t &y) const {
+    x=fRICHmipX; y=fRICHmipY;
+  }
   Bool_t IsRICH()  const {return fFlags&kRICHpid;}
-  Bool_t IsPHOS()  const {return fFlags&kPHOSpid;}
 
-  void   SetTrackPointArray(AliTrackPointArray *points) { fPoints = points; }
-  AliTrackPointArray *GetTrackPointArray() const { return fPoints; }
+  void   SetTrackPointArray(AliTrackPointArray *points);
+  const AliTrackPointArray *GetTrackPointArray() const; 
 
-  Bool_t 
-    RelateToVertex(const AliESDVertex *vtx, Double_t b, Double_t maxd);
+  Bool_t RelateToVertex(const AliESDVertex *vtx, Double_t b, Double_t maxd);
   void GetImpactParameters(Float_t &xy,Float_t &z) const {xy=fD; z=fZ;}
   void GetImpactParameters(Float_t p[2], Float_t cov[3]) const {
     p[0]=fD; p[1]=fZ; cov[0]=fCdd; cov[1]=fCdz; cov[2]=fCzz;
@@ -208,17 +236,14 @@ public:
     kTPCin=0x0010,kTPCout=0x0020,kTPCrefit=0x0040,kTPCpid=0x0080,
     kTRDin=0x0100,kTRDout=0x0200,kTRDrefit=0x0400,kTRDpid=0x0800,
     kTOFin=0x1000,kTOFout=0x2000,kTOFrefit=0x4000,kTOFpid=0x8000,
-    kPHOSpid=0x10000, kRICHpid=0x20000,
+    kRICHpid=0x20000,
     kTRDbackup=0x80000,
     kTRDStop=0x20000000,
     kESDpid=0x40000000,
     kTIME=0x80000000
   }; 
   enum {
-    kNPlane = 6,
-    kMaxITScluster=12,
-    kMaxTPCcluster=160,
-    kMaxTRDcluster=180
+    kNPlane = 6
   };
 protected:
   
@@ -248,53 +273,49 @@ protected:
 
   // ITS related track information
   Float_t fITSchi2;        // chi2 in the ITS
-  Float_t fITSchi2MIP[kMaxITScluster];     // chi2s in the ITS
   Int_t   fITSncls;        // number of clusters assigned in the ITS
-  Int_t   fITSindex[kMaxITScluster];   //! indices of the assigned ITS clusters
   Float_t fITSsignal;      // detector's PID signal
   Float_t fITSr[AliPID::kSPECIES]; // "detector response probabilities" (for the PID)
   Int_t   fITSLabel;       // label according TPC
   Float_t fITSFakeRatio;   // ration of fake tracks
-  AliKalmanTrack * fITStrack; //! OWNER: pointer to the ITS track -- currently for debug purpose
-  
+
+
   // TPC related track information
-  Float_t fTPCchi2;        // chi2 in the TPC
-  Int_t   fTPCncls;        // number of clusters assigned in the TPC
+  Float_t  fTPCchi2;       // chi2 in the TPC
+  Int_t    fTPCncls;       // number of clusters assigned in the TPC
   UShort_t fTPCnclsF;      // number of findable clusters in the TPC
-  Int_t  fTPCindex[kMaxTPCcluster];  //! indices of the assigned TPC clusters
-  TBits   fTPCClusterMap;  // Map of clusters, one bit per padrow; 1 if has a cluster on given padrow
-  Float_t fTPCsignal;      // detector's PID signal
-  UShort_t fTPCsignalN;      // number of points used for dEdx
+  TBits    fTPCClusterMap; // Map of clusters, one bit per padrow; 1 if has a cluster on given padrow
+  Float_t  fTPCsignal;     // detector's PID signal
+  UShort_t fTPCsignalN;    // number of points used for dEdx
   Float_t  fTPCsignalS;    // RMS of dEdx measurement
-  Float_t fTPCr[AliPID::kSPECIES]; // "detector response probabilities" (for the PID)
-  Int_t   fTPCLabel;       // label according TPC
-  Float_t fTPCPoints[4];   // TPC points -first, max. dens, last and max density
-  Int_t   fKinkIndexes[3]; // array of indexes of posible kink candidates 
-  Int_t   fV0Indexes[3]; // array of indexes of posible kink candidates 
+  Float_t  fTPCr[AliPID::kSPECIES]; // "detector response probabilities" (for the PID)
+  Int_t    fTPCLabel;      // label according TPC
+  Float_t  fTPCPoints[4];  // TPC points -first, max. dens, last and max density
+  Int_t    fKinkIndexes[3];// array of indexes of posible kink candidates 
+  Int_t    fV0Indexes[3];  // array of indexes of posible kink candidates 
 
   // TRD related track information
   Float_t fTRDchi2;        // chi2 in the TRD
   Int_t   fTRDncls;        // number of clusters assigned in the TRD
   Int_t   fTRDncls0;       // number of clusters assigned in the TRD before first material cross
-  Int_t  fTRDindex[kMaxTRDcluster];   //! indices of the assigned TRD clusters
   Float_t fTRDsignal;      // detector's PID signal
   Float_t fTRDsignals[kNPlane];  // TRD signals from all six planes
   Int_t   fTRDTimBin[kNPlane];   // Time bin of Max cluster from all six planes
   Float_t fTRDr[AliPID::kSPECIES]; // "detector response probabilities" (for the PID)
   Int_t   fTRDLabel;       // label according TRD
-  Float_t fTRDQuality;     //trd quality factor for TOF
-  Float_t fTRDBudget;     //trd material budget
-  AliKalmanTrack * fTRDtrack; //! OWNER: pointer to the TRD track -- currently for debug purpose
+  Float_t fTRDQuality;     // trd quality factor for TOF
+  Float_t fTRDBudget;      // trd material budget
+
 
   // TOF related track information
   Float_t fTOFchi2;        // chi2 in the TOF
   Int_t   fTOFindex;       // index of the assigned TOF cluster
-  Int_t   fTOFCalChannel; // Channel Index of the TOF Signal 
+  Int_t   fTOFCalChannel;  // Channel Index of the TOF Signal 
   Float_t fTOFsignal;      // detector's PID signal
   Float_t fTOFsignalToT;   // detector's ToT signal
   Float_t fTOFr[AliPID::kSPECIES]; // "detector response probabilities" (for the PID)
-  Int_t   fTOFLabel[3];       // TOF label 
-  Float_t fTOFInfo[10];       //! TOF informations
+  Int_t   fTOFLabel[3];    // TOF label 
+  Float_t fTOFInfo[10];    //! TOF informations
 
   // HMPID related track information
   Float_t fRICHchi2;       // chi2 in the RICH
@@ -309,9 +330,11 @@ protected:
   Float_t fRICHmipX;       // x of the MIP in LORS
   Float_t fRICHmipY;       // y of the MIP in LORS
 
-  AliTrackPointArray *fPoints; // Array which contains the track space points in the global frame
+  AliTrackPointArray *fPoints;//Array of track space points in the global frame
+
+  AliESDfriendTrack *fFriendTrack; //! All the complementary information
 
-  ClassDef(AliESDtrack,26)  //ESDtrack 
+  ClassDef(AliESDtrack,27)  //ESDtrack 
 };
 
 #endif 
index 285ec53..aac7a8e 100644 (file)
@@ -368,16 +368,6 @@ Bool_t CheckESD(const char* gAliceFileName = "galice.root",
       }
     }
 
-    // loop over calo tracks
-    for (Int_t iTrack = 0; iTrack < esd->GetNumberOfTracks(); iTrack++) {
-      AliESDtrack* track = esd->GetTrack(iTrack);
-      if (track->IsPHOS()) {
-       hEPHOS->Fill(track->GetPHOSsignal());
-      } else if (track->IsEMCAL()) {
-       hEEMCAL->Fill(track->GetEMCALsignal());
-      }
-    }
-
     // loop over muon tracks
     {
     for (Int_t iTrack = 0; iTrack < esd->GetNumberOfMuonTracks(); iTrack++) {