include new ESDTOF classes in compilation, account for modifications in ESDEvent...
authorshahoian <ruben.shahoyan@cern.ch>
Wed, 12 Feb 2014 15:39:39 +0000 (16:39 +0100)
committershahoian <ruben.shahoyan@cern.ch>
Wed, 12 Feb 2014 15:45:48 +0000 (16:45 +0100)
14 files changed:
STEER/CMakelibESD.pkg
STEER/CMakelibSTEERBase.pkg
STEER/ESD/AliESDEvent.cxx
STEER/ESD/AliESDEvent.h
STEER/ESD/AliESDtrack.cxx
STEER/ESD/AliESDtrack.h
STEER/ESDLinkDef.h
STEER/STEERBase/AliVTOFcluster.cxx
STEER/STEERBase/AliVTOFcluster.h
STEER/STEERBaseLinkDef.h
TOF/AliTOFcluster.cxx
TOF/AliTOFcluster.h
TOF/AliTOFtracker.cxx
TOF/AliTOFtracker.h

index 2d1caea..07d9f15 100644 (file)
@@ -70,7 +70,9 @@ set ( SRCS
     ESD/AliESDCosmicTrack.cxx
     ESD/AliV0vertexer.cxx 
     ESD/AliCascadeVertexer.cxx 
-    ESD/AliESDTOFcluster.cxx
+    ESD/AliESDTOFHit.cxx
+    ESD/AliESDTOFMatch.cxx
+    ESD/AliESDTOFCluster.cxx
     )
 
 string( REPLACE ".cxx" ".h" HDRS "${SRCS}")
index b4610ed..8bcf4b5 100644 (file)
@@ -92,6 +92,8 @@ set ( SRCS
     STEERBase/AliVTrdTracklet.cxx
     STEERBase/AliGenEventHeaderTunedPbPb.cxx
     STEERBase/AliDummyHandler.cxx
+    STEERBase/AliVTOFHit.cxx
+    STEERBase/AliVTOFMatch.cxx
     STEERBase/AliVTOFcluster.cxx
   )
 
index b6c9e9d..f2480f2 100644 (file)
@@ -119,7 +119,11 @@ ClassImp(AliESDEvent)
                                                        "AliESDACORDE",
                                                        "AliESDAD",
                                                        "AliTOFHeader",
-                                                        "CosmicTracks"};
+                                                        "CosmicTracks",
+                                                       "AliESDTOFCluster",
+                                                       "AliESDTOFHit",
+                                                       "AliESDTOFMatch"};
+
 
 //______________________________________________________________________________
 AliESDEvent::AliESDEvent():
@@ -156,6 +160,9 @@ AliESDEvent::AliESDEvent():
   fCaloClusters(0),
   fEMCALCells(0), fPHOSCells(0),
   fCosmicTracks(0),
+  fESDTOFClusters(0),
+  fESDTOFHits(0),
+  fESDTOFMatchess(0),
   fErrorLogs(0),
   fOldMuonStructure(kFALSE),
   fESDOld(0),
@@ -168,9 +175,7 @@ AliESDEvent::AliESDEvent():
   fEventplane(0),
   fDetectorStatus(0xFFFFFFFF),
   fDAQDetectorPattern(0xFFFF),
-  fDAQAttributes(0xFFFF),
-  fNTOFclusters(0),
-  fTOFcluster(0)
+  fDAQAttributes(0xFFFF)
 {
 }
 //______________________________________________________________________________
@@ -209,6 +214,9 @@ AliESDEvent::AliESDEvent(const AliESDEvent& esd):
   fEMCALCells(new AliESDCaloCells(*esd.fEMCALCells)),
   fPHOSCells(new AliESDCaloCells(*esd.fPHOSCells)),
   fCosmicTracks(new TClonesArray(*esd.fCosmicTracks)),
+  fESDTOFClusters(esd.fESDTOFClusters ? new TClonesArray(*esd.fESDTOFClusters) : 0),
+  fESDTOFHits(esd.fESDTOFHits ? new TClonesArray(*esd.fESDTOFHits) : 0),
+  fESDTOFMatchess(esd.fESDTOFMatchess ? new TClonesArray(*esd.fESDTOFMatchess) : 0),
   fErrorLogs(new TClonesArray(*esd.fErrorLogs)),
   fOldMuonStructure(esd.fOldMuonStructure),
   fESDOld(esd.fESDOld ? new AliESD(*esd.fESDOld) : 0),
@@ -221,10 +229,7 @@ AliESDEvent::AliESDEvent(const AliESDEvent& esd):
   fEventplane(new AliEventplane(*esd.fEventplane)),
   fDetectorStatus(esd.fDetectorStatus),
   fDAQDetectorPattern(esd.fDAQDetectorPattern),
-  fDAQAttributes(esd.fDAQAttributes),
-  fNTOFclusters(esd.fNTOFclusters),
-  //  fTOFcluster(esd.fTOFcluster)
-  fTOFcluster(new TObjArray(*(esd.fTOFcluster)))
+  fDAQAttributes(esd.fDAQAttributes)
 {
   printf("copying ESD event...\n");   // AU
   // CKB init in the constructor list and only add here ...
@@ -256,6 +261,9 @@ AliESDEvent::AliESDEvent(const AliESDEvent& esd):
   AddObject(fEMCALCells);
   AddObject(fPHOSCells);
   AddObject(fCosmicTracks);
+  AddObject(fESDTOFClusters);
+  AddObject(fESDTOFHits);
+  AddObject(fESDTOFMatchess);
   AddObject(fErrorLogs);
   AddObject(fESDACORDE);
   AddObject(fESDAD);
@@ -364,10 +372,7 @@ AliESDEvent & AliESDEvent::operator=(const AliESDEvent& source) {
   fDetectorStatus = source.fDetectorStatus;
   fDAQDetectorPattern = source.fDAQDetectorPattern;
   fDAQAttributes = source.fDAQAttributes;
-  fNTOFclusters = source.fNTOFclusters;
 
-  *fTOFcluster = *source.fTOFcluster;
-  //  fTOFcluster = new TObjArray(*(source.fTOFcluster));
   fTracksConnected = kFALSE;
   ConnectTracks();
   return *this;
@@ -393,10 +398,6 @@ AliESDEvent::~AliESDEvent()
   if (fEventplane) delete fEventplane;
   
 
-  if(fTOFcluster){
-    fTOFcluster->Clear();
-    delete fTOFcluster;
-  }
 }
 
 void AliESDEvent::Copy(TObject &obj) const {
@@ -556,6 +557,9 @@ void AliESDEvent::ResetStdContent()
   if(fPHOSCells)fPHOSCells->DeleteContainer();
   if(fEMCALCells)fEMCALCells->DeleteContainer();
   if(fCosmicTracks)fCosmicTracks->Delete();
+  if(fESDTOFClusters)fESDTOFClusters->Clear();
+  if(fESDTOFHits)fESDTOFHits->Clear();
+  if(fESDTOFMatchess)fESDTOFMatchess->Clear();
   if(fErrorLogs) fErrorLogs->Delete();
 
   // don't reset fconnected fConnected and the list
@@ -840,12 +844,14 @@ Bool_t  AliESDEvent::RemoveTrack(Int_t rm) const
     }
   }
 
-
-
+  // from here on we remove the track
+  //
   //Replace the removed track with the last track 
   TClonesArray &a=*fTracks;
+  AliESDtrack* trm = GetTrack(rm);
+  trm->SuppressTOFMatches(); // remove reference to this track from stored TOF clusters
   delete a.RemoveAt(rm);
-
+  //
   if (rm==last) return kTRUE;
 
   AliESDtrack *t=GetTrack(last);
@@ -854,7 +860,6 @@ Bool_t  AliESDEvent::RemoveTrack(Int_t rm) const
   new (a[rm]) AliESDtrack(*t);
   delete a.RemoveAt(last);
 
-
   if (!used) return kTRUE;
   
 
@@ -1519,7 +1524,9 @@ void AliESDEvent::GetStdContent()
   fESDAD = (AliESDAD*)fESDObjects->FindObject(fgkESDListName[kESDAD]);
   fTOFHeader = (AliTOFHeader*)fESDObjects->FindObject(fgkESDListName[kTOFHeader]);
   fCosmicTracks = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kCosmicTracks]);
-  fTOFcluster = new TObjArray(1);
+  fESDTOFClusters = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kTOFclusters]);
+  fESDTOFHits = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kTOFhit]);
+  fESDTOFMatchess = (TClonesArray*)fESDObjects->FindObject(fgkESDListName[kTOFmatch]);
 }
 
 //______________________________________________________________________________
@@ -1588,6 +1595,9 @@ void AliESDEvent::CreateStdContent()
   AddObject(new AliESDAD()); 
   AddObject(new AliTOFHeader());
   AddObject(new TClonesArray("AliESDCosmicTrack",0));
+  AddObject(new TClonesArray("AliESDTOFCluster",0));
+  AddObject(new TClonesArray("AliESDTOFHit",0));
+  AddObject(new TClonesArray("AliESDTOFMatch",0));
        
   // check the order of the indices against enum...
 
@@ -1705,8 +1715,6 @@ void AliESDEvent::WriteToTree(TTree* tree) const {
   tree->Branch("fDetectorStatus",(void*)&fDetectorStatus,"fDetectorStatus/l");
   tree->Branch("fDAQDetectorPattern",(void*)&fDAQDetectorPattern,"fDAQDetectorPattern/i");
   tree->Branch("fDAQAttributes",(void*)&fDAQAttributes,"fDAQAttributes/i");
-  tree->Branch("fNTOFclusters",(void *) &fNTOFclusters,"fNTOFclusters/i");
-  tree->Branch("fTOFcluster","TObjArray",(void *) &fTOFcluster);
 }
 
 //______________________________________________________________________________
@@ -1809,8 +1817,6 @@ void AliESDEvent::ReadFromTree(TTree *tree, Option_t* opt){
       tree->SetBranchAddress("fDetectorStatus",&fDetectorStatus); //PH probably redundant
       tree->SetBranchAddress("fDAQDetectorPattern",&fDAQDetectorPattern);
       tree->SetBranchAddress("fDAQAttributes",&fDAQAttributes);
-      if(tree->GetBranch("fNTOFclusters")) tree->SetBranchAddress("fNTOFclusters",(UInt_t *) &fNTOFclusters);
-      if(tree->GetBranch("fTOFcluster")) tree->SetBranchAddress("fTOFcluster",&fTOFcluster);
       GetStdContent(); 
       fOldMuonStructure = fESDObjects->TestBit(BIT(23));
       fConnected = true;
@@ -1877,8 +1883,6 @@ void AliESDEvent::ReadFromTree(TTree *tree, Option_t* opt){
     tree->SetBranchAddress("fDetectorStatus",&fDetectorStatus);
     tree->SetBranchAddress("fDAQDetectorPattern",&fDAQDetectorPattern);
     tree->SetBranchAddress("fDAQAttributes",&fDAQAttributes);
-    if(tree->GetBranch("fNTOFclusters")) tree->SetBranchAddress("fNTOFclusters",(UInt_t *) &fNTOFclusters);
-    if(tree->GetBranch("fTOFcluster")) tree->SetBranchAddress("fTOFcluster",&fTOFcluster);
 
     GetStdContent();
     // when reading back we are not owner of the list 
@@ -1918,8 +1922,6 @@ void AliESDEvent::ReadFromTree(TTree *tree, Option_t* opt){
     tree->SetBranchAddress("fDetectorStatus",&fDetectorStatus);
     tree->SetBranchAddress("fDAQDetectorPattern",&fDAQDetectorPattern);
     tree->SetBranchAddress("fDAQAttributes",&fDAQAttributes);
-    if(tree->GetBranch("fNTOFclusters")) tree->SetBranchAddress("fNTOFclusters",(UInt_t *) &fNTOFclusters);
-    if(tree->GetBranch("fTOFcluster")) tree->SetBranchAddress("fTOFcluster",&fTOFcluster);
 
     GetStdContent();
     // when reading back we are not owner of the list 
@@ -2249,48 +2251,166 @@ Float_t AliESDEvent::GetVZEROEqMultiplicity(Int_t i) const
 }
 
 //______________________________________________________________________________
-void AliESDEvent::SetTOFcluster(Int_t ntofclusters,AliESDTOFcluster *cluster,Int_t *mapping){
-  fNTOFclusters = 0;
+void AliESDEvent::SetTOFcluster(Int_t ntofclusters,AliESDTOFCluster *cluster,Int_t *mapping)
+{
+  // Reset TClonesArray of TOF clusters
+  if (!fESDTOFClusters) {
+    AliError("fESDTOFClusters is not initialized");
+    return;
+  }
+  fESDTOFClusters->Clear();
+  
+  Int_t goodhit[20000];
+  if(mapping){
+    for(Int_t i=0;i < 20000;i++){
+      goodhit[i] = 0;
+    }
+  }
 
-  fTOFcluster->Clear();
-  fTOFcluster->Expand(1);      
-      
   for(Int_t i=0;i < ntofclusters;i++){
-
+    
     if(cluster[i].GetNMatchableTracks() || !mapping){
-      fTOFcluster->Expand(fNTOFclusters+1);      
-      fTOFcluster->AddAt(&cluster[i],fNTOFclusters);
       if(mapping)
-       mapping[i] = fNTOFclusters;
-      fNTOFclusters++;
+       mapping[i] = fESDTOFClusters->GetEntriesFast();
+      
+      // update TClonesArray
+      TClonesArray &ftr = *fESDTOFClusters;
+      AliESDTOFCluster *clusterTBW = new(ftr[fESDTOFClusters->GetEntriesFast()])AliESDTOFCluster(cluster[i]);
+
+      if(mapping){
+       // loop over hit in the cluster
+        for(Int_t k=0;k < clusterTBW->GetNTOFhits();k++){
+         Int_t ipos = clusterTBW->GetHitIndex(k);
+         goodhit[ipos] = 1; // hit should be kept
+       }
+      }
     }
   }
-  if(mapping)
-    printf("TOF cluster before of matching = %i , after = %i\n",ntofclusters,fNTOFclusters);
-   
+
+  if(mapping){
+    AliInfo(Form("TOF cluster before of matching = %i , after = %i\n",ntofclusters,fESDTOFClusters->GetEntriesFast()));
+    Int_t hitnewpos[20000];
+    Int_t nhitOriginal = fESDTOFHits->GetEntries();
+    for(Int_t i=0;i < fESDTOFHits->GetEntries();i++){
+      if(goodhit[i]){
+       hitnewpos[i] = i;
+      }
+      else{ // remove hit and decrease the hit array
+       TClonesArray &a=*fESDTOFHits;
+       Int_t lastpos = fESDTOFHits->GetEntries()-1;
+
+       if(i == lastpos)
+         delete a.RemoveAt(i);
+       else{
+         Int_t nhitBefore = fESDTOFHits->GetEntries();
+         for(Int_t k=nhitBefore-1;k>i;k--){ // find the last good track
+           if(!goodhit[k]){ // remove track
+             delete a.RemoveAt(k);
+             if(k-i==1) delete a.RemoveAt(i);
+           }
+           else{ // replace last one to the "i"
+             AliESDTOFHit *last = (AliESDTOFHit *) fESDTOFHits->At(k);
+             delete a.RemoveAt(i);
+             new (a[i]) AliESDTOFHit(*last);
+             delete a.RemoveAt(k);
+             hitnewpos[k] = i;
+             k = 0;
+           }
+         }
+       }
+      }
+    }
+
+    // remap cluster to hits
+    for(Int_t i=0;i < fESDTOFClusters->GetEntries();i++){
+      AliESDTOFCluster *cl = (AliESDTOFCluster *) fESDTOFClusters->At(i);
+      // loop over hit in the cluster
+      for(Int_t k=0;k < cl->GetNTOFhits();k++){
+       cl->SetHitIndex(k,hitnewpos[cl->GetHitIndex(k)]);
+      }
+    }
+    AliInfo(Form("TOF hit before of matching = %i , after = %i\n",nhitOriginal,fESDTOFHits->GetEntriesFast()));
+  } // end mapping
 
 }
 
 //______________________________________________________________________________
-void AliESDEvent::SetTOFcluster(Int_t ntofclusters,AliESDTOFcluster *cluster[],Int_t *mapping){
-  fNTOFclusters = 0;
-
-  fTOFcluster->Clear();
-  fTOFcluster->Expand(1);      
+void AliESDEvent::SetTOFcluster(Int_t ntofclusters,AliESDTOFCluster *cluster[],Int_t *mapping)
+{    
+  // Reset TClonesArray of TOF clusters
+  if(fESDTOFClusters)fESDTOFClusters->Delete();
+   
+  Int_t goodhit[20000];
+  if(mapping){
+    for(Int_t i=0;i < 20000;i++){
+      goodhit[i] = 0;
+    }
+  }
       
   for(Int_t i=0;i < ntofclusters;i++){
 
     if(cluster[i]->GetNMatchableTracks() || !mapping){
-      fTOFcluster->Expand(fNTOFclusters+1);      
-      fTOFcluster->AddAt(cluster[i],fNTOFclusters);
       if(mapping)
-       mapping[i] = fNTOFclusters;
-      fNTOFclusters++;
+       mapping[i] = fESDTOFClusters->GetEntriesFast();
+       
+      // update TClonesArray
+      TClonesArray &ftr = *fESDTOFClusters;
+      AliESDTOFCluster *clusterTBW = new(ftr[fESDTOFClusters->GetEntriesFast()])AliESDTOFCluster(*(cluster[i]));
+
+      if(mapping){
+       // loop over hit in the cluster
+        for(Int_t k=0;k < clusterTBW->GetNTOFhits();k++){
+         Int_t ipos = clusterTBW->GetHitIndex(k);
+         goodhit[ipos] = 1; // hit should be kept
+       }
+      }
     }
   }
-  if(mapping)
-    printf("TOF cluster before of matching = %i , after = %i\n",ntofclusters,fNTOFclusters);
-   
+
+  if(mapping){
+    AliInfo(Form("TOF cluster before of matching = %i , after = %i\n",ntofclusters,fESDTOFClusters->GetEntriesFast()));
+    Int_t hitnewpos[20000];
+    Int_t nhitOriginal = fESDTOFHits->GetEntries();
+    for(Int_t i=0;i < fESDTOFHits->GetEntries();i++){
+      if(goodhit[i]){
+       hitnewpos[i] = i;
+      }
+      else{ // remove hit and decrease the hit array
+       TClonesArray &a=*fESDTOFHits;
+       Int_t lastpos = fESDTOFHits->GetEntries()-1;
+
+       if(i == lastpos)
+         delete a.RemoveAt(i);
+       else{
+         Int_t nhitBefore = fESDTOFHits->GetEntries();
+         for(Int_t k=nhitBefore-1;k>i;k--){ // find the last good track
+           if(!goodhit[k]){ // remove track
+             delete a.RemoveAt(k);
+             if(k-i==1) delete a.RemoveAt(i);
+           }
+           else{ // replace last one to the "i"
+             AliESDTOFHit *last = (AliESDTOFHit *) fESDTOFHits->At(k);
+             delete a.RemoveAt(i);
+             new (a[i]) AliESDTOFHit(*last);
+             delete a.RemoveAt(k);
+             hitnewpos[k] = i;
+             k = 0;
+           }
+         }
+       }
+      }
+    }
+
+    // remap cluster to hits
+    for(Int_t i=0;i < fESDTOFClusters->GetEntries();i++){
+      AliESDTOFCluster *cl = (AliESDTOFCluster *) fESDTOFClusters->At(i);
+      // loop over hit in the cluster
+      for(Int_t k=0;k < cl->GetNTOFhits();k++){
+       cl->SetHitIndex(k,hitnewpos[cl->GetHitIndex(k)]);
+      }
+    }
+    AliInfo(Form("TOF hit before of matching = %i , after = %i\n",nhitOriginal,fESDTOFHits->GetEntriesFast()));
+  } // end mapping
 
 }
 
@@ -2301,5 +2421,13 @@ void AliESDEvent::ConnectTracks() {
   AliESDtrack *track;
   TIter next(fTracks);
   while ((track=(AliESDtrack*)next())) track->SetESDEvent(this);
+  //
+  // The same for TOF clusters
+  if (fESDTOFClusters) {
+    AliESDTOFCluster *clus;
+    TIter nextTOF(fESDTOFClusters);
+    while ((clus=(AliESDTOFCluster*)nextTOF())) clus->SetEvent((AliVEvent *) this);
+  }
   fTracksConnected = kTRUE;
+  //
 }
index 2c7e29b..56db016 100644 (file)
 
 #include "AliESDVZERO.h"
 #include "AliESDTrdTrack.h"
-#include "AliESDTOFcluster.h"
+#include "AliESDTOFCluster.h"
+#include "AliESDTOFHit.h"
+#include "AliESDTOFMatch.h"
+
 
 
 class AliESDfriend;
@@ -114,6 +117,9 @@ public:
                        kESDAD,
                       kTOFHeader,
                        kCosmicTracks,
+                      kTOFclusters,
+                      kTOFhit,
+                      kTOFmatch,
                       kESDListN
   };
 
@@ -295,10 +301,14 @@ public:
   AliTOFHeader *GetTOFHeader() const {return fTOFHeader;}
   Float_t GetEventTimeSpread() const {if (fTOFHeader) return fTOFHeader->GetT0spread(); else return 0.;}
   Float_t GetTOFTimeResolution() const {if (fTOFHeader) return fTOFHeader->GetTOFResolution(); else return 0.;}
-  TObjArray *GetTOFcluster() const {return fTOFcluster;}
-  void SetTOFcluster(Int_t ntofclusters,AliESDTOFcluster *cluster,Int_t *mapping=NULL);
-  void SetTOFcluster(Int_t ntofclusters,AliESDTOFcluster *cluster[],Int_t *mapping=NULL);
-  Int_t GetNTOFclusters() const {return fNTOFclusters;}
+
+  TClonesArray *GetESDTOFClusters() const {return fESDTOFClusters;}
+  TClonesArray *GetESDTOFHits() const {return fESDTOFHits;}
+  TClonesArray *GetESDTOFMatches() const {return fESDTOFMatchess;}
+
+  void SetTOFcluster(Int_t ntofclusters,AliESDTOFCluster *cluster,Int_t *mapping=NULL);
+  void SetTOFcluster(Int_t ntofclusters,AliESDTOFCluster *cluster[],Int_t *mapping=NULL);
+  Int_t GetNTOFclusters() const {return fESDTOFClusters ? fESDTOFClusters->GetEntriesFast() : 0;}
 
   void SetMultiplicity(const AliMultiplicity *mul);
 
@@ -559,6 +569,9 @@ protected:
   AliESDCaloCells *fEMCALCells;     //! EMCAL cell info
   AliESDCaloCells *fPHOSCells;     //! PHOS cell info
   TClonesArray *fCosmicTracks;     //! Tracks created by cosmics finder
+  TClonesArray *fESDTOFClusters;    //! TOF clusters
+  TClonesArray *fESDTOFHits;        //! TOF hits (used for clusters)
+  TClonesArray *fESDTOFMatchess;      //! TOF matching info (with the reference to tracks)
   TClonesArray *fErrorLogs;        //! Raw-data reading error messages
  
   Bool_t fOldMuonStructure;        //! Flag if reading ESD with old MUON structure
@@ -582,10 +595,7 @@ protected:
   UInt_t fDAQDetectorPattern; // Detector pattern from DAQ: bit 0 is SPD, bit 4 is TPC, etc. See event.h
   UInt_t fDAQAttributes; // Third word of attributes from DAQ: bit 7 corresponds to HLT decision 
 
-  Int_t fNTOFclusters;     //! N TOF clusters matchable
-  TObjArray *fTOFcluster; //! TOF clusters
-
-  ClassDef(AliESDEvent,21)  //ESDEvent class 
+  ClassDef(AliESDEvent,22)  //ESDEvent class 
 };
 #endif 
 
index 53b0dff..0fec7a0 100644 (file)
@@ -581,9 +581,6 @@ AliESDtrack::AliESDtrack(const AliVTrack *track) :
   for (i=0;i<10;i++) {fTOFInfo[i]=0;}
   for (i=0;i<12;i++) {fITSModule[i]=-1;}
 
-  // Set the ID
-  SetID(track->GetID());
-
   // Set ITS cluster map
   fITSClusterMap=track->GetITSClusterMap();
   fITSSharedMap=0;
@@ -650,6 +647,10 @@ AliESDtrack::AliESDtrack(const AliVTrack *track) :
   SetLabel(track->GetLabel());
   // Set the status
   SetStatus(track->GetStatus());
+  //
+  // Set the ID
+  SetID(track->GetID());
+  //
 }
 
 //_______________________________________________________________________
@@ -1844,8 +1845,8 @@ void AliESDtrack::GetIntegratedTimes(Double_t *times, Int_t nspec) const
   // get integrated time for requested N species
   if (nspec<1) return;
   if(fNtofClusters>0 && GetESDEvent()){
-    TObjArray *tofclArray = GetESDEvent()->GetTOFcluster();
-    AliESDTOFcluster *tofcl = (AliESDTOFcluster *) tofclArray->At(fTOFcluster[0]);
+    TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
+    AliESDTOFCluster *tofcl = (AliESDTOFCluster *) tofclArray->At(fTOFcluster[0]);
     //
     for(int i=tofcl->GetNMatchableTracks();i--;){
       if(tofcl->GetTrackIndex(i) == GetID()) {
@@ -1864,12 +1865,13 @@ void AliESDtrack::GetIntegratedTimes(Double_t *times, Int_t nspec) const
     for (int 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]);
+    TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
+    AliESDTOFCluster *tofcl = (AliESDTOFCluster *) tofclArray->At(fTOFcluster[0]);
 
     for(Int_t i=0;i < tofcl->GetNMatchableTracks();i++){
       if(tofcl->GetTrackIndex(i) == GetID()) index = i;
@@ -2373,8 +2375,8 @@ void AliESDtrack::GetTOFpid(Double_t *p) const {
 void AliESDtrack::GetTOFLabel(Int_t *p) const {
   // Gets (in TOF)
   if(fNtofClusters>0){
-    TObjArray *tofclArray = GetESDEvent()->GetTOFcluster();
-    AliESDTOFcluster *tofcl = (AliESDTOFcluster *) tofclArray->At(fTOFcluster[0]);
+    TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
+    AliESDTOFCluster *tofcl = (AliESDTOFCluster *) tofclArray->At(fTOFcluster[0]);
 
     for (Int_t i=0; i<3; i++) p[i]=tofcl->GetLabel(i);
   }
@@ -2966,6 +2968,7 @@ Double_t AliESDtrack::GetMassForTracking() const
   return (fPIDForTracking==AliPID::kHe3 || fPIDForTracking==AliPID::kAlpha) ? -m : m;
 }
 
+
 void    AliESDtrack::SetTOFclusterArray(Int_t ncluster,Int_t *TOFcluster){
   AliInfo("Method has to be implemented!");
 //   fNtofClusters=ncluster;
@@ -2984,7 +2987,69 @@ void    AliESDtrack::SetTOFclusterArray(Int_t ncluster,Int_t *TOFcluster){
 //     fTOFcluster = 0;
 }
 
-void    AliESDtrack::AddTOFcluster(Int_t icl){
+//____________________________________________
+void  AliESDtrack::SuppressTOFMatches()
+{
+  // remove reference to this track from TOF clusters
+  if (!fNtofClusters || !GetESDEvent()) return;
+  TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
+  for (;fNtofClusters--;) {
+    AliESDTOFCluster* clTOF = (AliESDTOFCluster*)tofclArray->At(fTOFcluster[fNtofClusters]);
+    clTOF->SuppressMatchedTrack(GetID());
+    if (!clTOF->GetNMatchableTracks()) { // remove this cluster
+      int last = tofclArray->GetEntriesFast()-1;
+      AliESDTOFCluster* clTOFL = (AliESDTOFCluster*)tofclArray->At(last);
+      if (last != fTOFcluster[fNtofClusters]) {
+       *clTOF = *clTOFL; // move last cluster to the place of eliminated one
+       // fix the references on this cluster
+       clTOF->FixSelfReferences(last,fTOFcluster[fNtofClusters]);
+      }
+      tofclArray->RemoveAt(last);
+    }
+  }
+}
+
+//____________________________________________
+void  AliESDtrack::ReplaceTOFTrackID(int oldID, int newID)
+{
+  // replace the ID in TOF clusters references to this track
+  if (!fNtofClusters || !GetESDEvent()) return;
+  TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
+  for (int it=fNtofClusters;it--;) {
+    AliESDTOFCluster* clTOF = (AliESDTOFCluster*)tofclArray->At(fTOFcluster[it]);
+    clTOF->ReplaceMatchedTrackID(oldID,newID);
+  }
+}
+
+//____________________________________________
+void  AliESDtrack::ReplaceTOFClusterID(int oldID, int newID)
+{
+  // replace the referenc on TOF cluster oldID by newID
+  if (!fNtofClusters || !GetESDEvent()) return;
+  for (int it=fNtofClusters;it--;) {
+    if (fTOFcluster[it] == oldID) {
+      fTOFcluster[it] = newID;
+      return;
+    }
+  }
+}
+
+//____________________________________________
+void  AliESDtrack::ReplaceTOFMatchID(int oldID, int newID)
+{
+  // replace in the ESDTOFCluster associated with this track the id of the corresponding
+  // ESDTOFMatch from oldID to newID
+  if (!fNtofClusters || !GetESDEvent()) return;
+  TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
+  for (int it=fNtofClusters;it--;) {
+    AliESDTOFCluster* clTOF = (AliESDTOFCluster*)tofclArray->At(fTOFcluster[it]);
+    clTOF->ReplaceMatchID(oldID,newID);
+  }
+}
+
+//____________________________________________
+void AliESDtrack::AddTOFcluster(Int_t icl)
+{
   fNtofClusters++;
   
   Int_t *old = fTOFcluster;
@@ -3000,10 +3065,12 @@ void    AliESDtrack::AddTOFcluster(Int_t icl){
  
 }
 
-Double_t AliESDtrack::GetTOFsignal() const {
+//____________________________________________
+Double_t AliESDtrack::GetTOFsignal() const 
+{
   if(fNtofClusters>0 && GetESDEvent()){
-    TObjArray *tofclArray = GetESDEvent()->GetTOFcluster();
-    AliESDTOFcluster *tofcl = (AliESDTOFcluster *) tofclArray->At(fTOFcluster[0]);
+    TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
+    AliESDTOFCluster *tofcl = (AliESDTOFCluster *) tofclArray->At(fTOFcluster[0]);
 
     return tofcl->GetTime();
   }
@@ -3012,11 +3079,12 @@ Double_t AliESDtrack::GetTOFsignal() const {
   return fTOFsignal;
 }
 
+//____________________________________________
 Double_t AliESDtrack::GetTOFsignalToT() const 
 {
   if(fNtofClusters>0 && GetESDEvent()){
-    TObjArray *tofclArray = GetESDEvent()->GetTOFcluster();
-    AliESDTOFcluster *tofcl = (AliESDTOFcluster *) tofclArray->At(fTOFcluster[0]);
+    TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
+    AliESDTOFCluster *tofcl = (AliESDTOFCluster *) tofclArray->At(fTOFcluster[0]);
 
     return tofcl->GetTOT();
   }
@@ -3025,11 +3093,12 @@ Double_t AliESDtrack::GetTOFsignalToT() const
   return fTOFsignalToT;
 }
 
+//____________________________________________
 Double_t AliESDtrack::GetTOFsignalRaw() const 
 {
   if(fNtofClusters>0 && GetESDEvent()){
-    TObjArray *tofclArray = GetESDEvent()->GetTOFcluster();
-    AliESDTOFcluster *tofcl = (AliESDTOFcluster *) tofclArray->At(fTOFcluster[0]);
+    TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
+    AliESDTOFCluster *tofcl = (AliESDTOFCluster *) tofclArray->At(fTOFcluster[0]);
 
     return tofcl->GetTimeRaw();
   }
@@ -3038,15 +3107,16 @@ Double_t AliESDtrack::GetTOFsignalRaw() const
   return fTOFsignalRaw;
 }
 
+//____________________________________________
 Double_t AliESDtrack::GetTOFsignalDz() const 
 {
 
-  AliESDTOFcluster *tofcl;
+  AliESDTOFCluster *tofcl;
 
   Int_t index = -1;
   if(fNtofClusters>0 && GetESDEvent()){
-    TObjArray *tofclArray = GetESDEvent()->GetTOFcluster();
-    tofcl = (AliESDTOFcluster *) tofclArray->At(fTOFcluster[0]);
+    TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
+    tofcl = (AliESDTOFCluster *) tofclArray->At(fTOFcluster[0]);
 
     for(Int_t i=0;i < tofcl->GetNMatchableTracks();i++){
       if(tofcl->GetTrackIndex(i) == GetID()) index = i;
@@ -3060,14 +3130,15 @@ Double_t AliESDtrack::GetTOFsignalDz() const
   return fTOFsignalDz;
 }
 
+//____________________________________________
 Double_t AliESDtrack::GetTOFsignalDx() const 
 {
-  AliESDTOFcluster *tofcl;
+  AliESDTOFCluster *tofcl;
 
   Int_t index = -1;
   if(fNtofClusters>0 && GetESDEvent()){
-    TObjArray *tofclArray = GetESDEvent()->GetTOFcluster();
-    tofcl = (AliESDTOFcluster *) tofclArray->At(fTOFcluster[0]);
+    TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
+    tofcl = (AliESDTOFCluster *) tofclArray->At(fTOFcluster[0]);
     for(Int_t i=0;i < tofcl->GetNMatchableTracks();i++){
       if(tofcl->GetTrackIndex(i) == GetID()) index = i;
     }
@@ -3079,11 +3150,12 @@ Double_t AliESDtrack::GetTOFsignalDx() const
   return fTOFsignalDx;
 }
 
+//____________________________________________
 Short_t  AliESDtrack::GetTOFDeltaBC() const 
 {
   if(fNtofClusters>0 && GetESDEvent()){
-    TObjArray *tofclArray = GetESDEvent()->GetTOFcluster();
-    AliESDTOFcluster *tofcl = (AliESDTOFcluster *) tofclArray->At(fTOFcluster[0]);
+    TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
+    AliESDTOFCluster *tofcl = (AliESDTOFCluster *) tofclArray->At(fTOFcluster[0]);
     return tofcl->GetDeltaBC();
   }
   else if(fNtofClusters>0) AliInfo("No AliESDEvent available here!\n");
@@ -3091,11 +3163,12 @@ Short_t  AliESDtrack::GetTOFDeltaBC() const
   return fTOFdeltaBC;
 }
 
+//____________________________________________
 Short_t  AliESDtrack::GetTOFL0L1() const 
 {
   if(fNtofClusters>0 && GetESDEvent()){
-    TObjArray *tofclArray = GetESDEvent()->GetTOFcluster();
-    AliESDTOFcluster *tofcl = (AliESDTOFcluster *) tofclArray->At(fTOFcluster[0]);
+    TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
+    AliESDTOFCluster *tofcl = (AliESDTOFCluster *) tofclArray->At(fTOFcluster[0]);
 
     return tofcl->GetL0L1Latency();
   }
@@ -3104,11 +3177,12 @@ Short_t  AliESDtrack::GetTOFL0L1() const
   return fTOFl0l1;
 }
 
+//____________________________________________
 Int_t   AliESDtrack::GetTOFCalChannel() const 
 {
   if(fNtofClusters>0 && GetESDEvent()){
-    TObjArray *tofclArray = GetESDEvent()->GetTOFcluster();
-    AliESDTOFcluster *tofcl = (AliESDTOFcluster *) tofclArray->At(fTOFcluster[0]);
+    TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
+    AliESDTOFCluster *tofcl = (AliESDTOFCluster *) tofclArray->At(fTOFcluster[0]);
 
     return tofcl->GetTOFchannel();
   }
@@ -3117,11 +3191,12 @@ Int_t   AliESDtrack::GetTOFCalChannel() const
   return fTOFCalChannel;
 }
 
+//____________________________________________
 Int_t   AliESDtrack::GetTOFcluster() const 
 {
   if(fNtofClusters>0 && GetESDEvent()){
-    TObjArray *tofclArray = GetESDEvent()->GetTOFcluster();
-    AliESDTOFcluster *tofcl = (AliESDTOFcluster *) tofclArray->At(fTOFcluster[0]);
+    TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
+    AliESDTOFCluster *tofcl = (AliESDTOFCluster *) tofclArray->At(fTOFcluster[0]);
 
     return tofcl->GetClusterIndex();
   }
@@ -3130,15 +3205,17 @@ Int_t   AliESDtrack::GetTOFcluster() const
   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]);
+    TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
+    AliESDTOFCluster *tofcl = (AliESDTOFCluster *) tofclArray->At(fTOFcluster[0]);
 
     if (tofcl->GetNMatchableTracks() > 1)
       return kTRUE;
@@ -3148,6 +3225,7 @@ Bool_t  AliESDtrack::IsTOFHitAlreadyMatched() const{
   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)
@@ -3157,12 +3235,13 @@ void AliESDtrack::ReMapTOFcluster(Int_t ncl,Int_t *mapping){
   }
 }
 
+//____________________________________________
 void AliESDtrack::SortTOFcluster(){
-  TObjArray *tofclArray = GetESDEvent()->GetTOFcluster();
+  TClonesArray *tofclArray = GetESDEvent()->GetESDTOFClusters();
 
   for(Int_t i=0;i<fNtofClusters-1;i++){
     for(Int_t j=i+1;j<fNtofClusters;j++){
-      AliESDTOFcluster *tofcl = (AliESDTOFcluster *) tofclArray->At(fTOFcluster[i]);
+      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;
@@ -3175,7 +3254,7 @@ void AliESDtrack::SortTOFcluster(){
       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]);
+      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;
@@ -3199,6 +3278,16 @@ void AliESDtrack::SortTOFcluster(){
   }
 }
 
+//____________________________________________
 const AliTOFHeader* AliESDtrack::GetTOFHeader() const {
   return fESDEvent->GetTOFHeader();
 }
+
+
+//___________________________________________
+void AliESDtrack::SetID(Short_t id) 
+{
+  // set track ID taking care about dependencies
+  if (fNtofClusters) ReplaceTOFTrackID(fID,id); 
+  fID=id;
+}
index 3eb3474..e588d9a 100644 (file)
@@ -30,7 +30,7 @@
 #include <TBits.h>
 #include "AliExternalTrackParam.h"
 #include "AliVTrack.h"
-#include "AliESDTOFcluster.h"
+#include "AliESDTOFCluster.h"
 #include "AliPID.h"
 #include "AliESDfriendTrack.h"
 #include "AliTPCdEdxInfo.h"
@@ -63,7 +63,7 @@ public:
   void AddCalibObject(TObject * object);     // add calib object to the list
   TObject *  GetCalibObject(Int_t index);    // return calib objct at given position
   void MakeMiniESDtrack();
-  void SetID(Short_t id) { fID =id;}
+  void SetID(Short_t id);
   Int_t GetID() const { return fID;}
   void SetVertexID(Char_t id) { fVertexID=id;}
   Char_t GetVertexID() const { return fVertexID;}
@@ -309,12 +309,17 @@ public:
     return fFriendTrack!=NULL?fFriendTrack->GetTRDtrack():NULL;
   }
 
+  // this are methods for manipulating with TOF clusters/matches
   void    SetTOFclusterArray(Int_t ncluster,Int_t *TOFcluster);
   Int_t   *GetTOFclusterArray() const {return fTOFcluster;}
   Int_t   GetNTOFclusters() const {return fNtofClusters;}
+  void    SuppressTOFMatches();
+  void    ReplaceTOFTrackID(int oldID, int newID);
+  void    ReplaceTOFClusterID(int oldID, int newID);
+  void    ReplaceTOFMatchID(int oldID, int newID);
   void    AddTOFcluster(Int_t icl);
-  void    SortTOFcluster();
-  void    ReMapTOFcluster(Int_t ncl,Int_t *mapping);
+  void    SortTOFcluster(); // RS? Not to be used?
+  void    ReMapTOFcluster(Int_t ncl,Int_t *mapping);  // RS? Not to be used?
 
   void    SetTOFsignal(Double_t tof) {fTOFsignal=tof;}
   Double_t GetTOFsignal() const;
index 3fc1deb..669e6cc 100644 (file)
@@ -152,7 +152,9 @@ code="{fTrackTime = new Double32_t[AliPID::kSPECIESC];for(Int_t isp=AliPID::kSPE
 #pragma link C++ class  AliV0vertexer+;
 #pragma link C++ class  AliCascadeVertexer+;
 
-#pragma link C++ class  AliESDTOFcluster+;
+#pragma link C++ class  AliESDTOFHit+;
+#pragma link C++ class  AliESDTOFMatch+;
+#pragma link C++ class  AliESDTOFCluster+;
 
 #pragma link C++ function AliESDUtils::GetCorrV0(const AliESDEvent*,Float_t &);
 #pragma link C++ function AliESDUtils::GetCorrSPD2(Float_t,Float_t);
index 333482c..341db67 100644 (file)
@@ -21,7 +21,8 @@
 #include "AliVTOFcluster.h"
 
 AliVTOFcluster::AliVTOFcluster(const AliVTOFcluster & source) :
-  TObject(source)
+  TObject(source),
+  fEvent(NULL)
 {
   // 
   // copy ctor for AliVTOFcluster object
@@ -35,6 +36,7 @@ AliVTOFcluster & AliVTOFcluster::operator=(const AliVTOFcluster & source)
   //
   if (this != &source) {
     TObject::operator=(source);
+    fEvent = source.fEvent;
   }
   return *this;
 }
index 8d353cc..d40d2cf 100644 (file)
 #include <TArrayI.h>
 #include <TArrayF.h>
 
+class AliVEvent;
+
 class AliVTOFcluster : public TObject {
 
  public:
+  enum {kMaxHits=4, kMaxMatches=7}; 
 
-  AliVTOFcluster() { }
+  AliVTOFcluster(): fEvent(0) { }
   virtual ~AliVTOFcluster() { }
   AliVTOFcluster(const AliVTOFcluster & source);
   AliVTOFcluster & operator=(const AliVTOFcluster & source);
 
-  virtual Int_t GetClusterIndex() const {return 0;} // cluster index
-  virtual Int_t GetTOFchannel() const {return 0;}; // TOF channel
-  virtual Float_t GetTime() const {return 0;}; // TOF time
-  virtual Float_t GetTimeRaw() const {return 0;}; // TOF raw time
-  virtual Float_t GetTOT() const {return 0;}; // TOF ToT
-  virtual Int_t GetLabel(Int_t ) const {return 0;};
-  virtual Int_t GetDeltaBC() const {return 0;};
-  virtual Int_t GetL0L1Latency() const {return 0;};
+  virtual Int_t GetClusterIndex(Int_t) const {return 0;} // cluster index
+  virtual Int_t GetTOFchannel(Int_t) const {return 0;}; // TOF channel
+  virtual Float_t GetTime(Int_t) const {return 0;}; // TOF time
+  virtual Float_t GetTimeRaw(Int_t) const {return 0;}; // TOF raw time
+  virtual Float_t GetTOT(Int_t) const {return 0;}; // TOF ToT
+  virtual Int_t GetLabel(Int_t, Int_t) const {return 0;};
+  virtual Int_t GetDeltaBC(Int_t) const {return 0;};
+  virtual Int_t GetL0L1Latency(Int_t) const {return 0;};
   virtual Bool_t GetStatus() const {return 0;};
   virtual Float_t GetZ() const {return 0;};
   virtual Float_t GetPhi() const {return 0;};
@@ -46,8 +49,14 @@ class AliVTOFcluster : public TObject {
   virtual Float_t GetDz(Int_t )  const {return 0;};
   virtual Float_t GetLength(Int_t ) const {return 0;};
   virtual Double_t GetIntegratedTime(Int_t ,Int_t ) const {return 0;};
+  virtual Int_t GetNTOFhits() const {return 0;};
+
+  virtual void SetEvent(const AliVEvent* ev) {fEvent = ev;}
+  virtual const AliVEvent* GetEvent() const {return fEvent;}
+
+  const AliVEvent* fEvent;            //! pointer to the event
 
-  ClassDef(AliVTOFcluster, 1) // TOF matchable cluster
+  ClassDef(AliVTOFcluster, 2) // TOF matchable cluster
 
 }; 
 
index baa945e..f519afd 100644 (file)
 #pragma link C++ class AliVTrdTracklet+;
 #pragma link C++ class AliGenEventHeaderTunedPbPb+;
 
+#pragma link C++ class  AliVTOFHit+;
+#pragma link C++ class  AliVTOFMatch+;
 #pragma link C++ class AliVTOFcluster+;
 
 #endif
index 490dea4..fee67b8 100644 (file)
@@ -50,7 +50,8 @@ AliTOFcluster::AliTOFcluster():
   fTdcRAW(0),
   fStatus(kTRUE),
   fDeltaBC(0),
-  fL0L1Latency(0)
+  fL0L1Latency(0),
+  fESDID(-1)
  {
   //
   // default ctor
@@ -80,7 +81,8 @@ AliTOFcluster::AliTOFcluster(UShort_t volId,
   fTdcRAW(par[4]),
   fStatus(status),
   fDeltaBC(par[5]),
-  fL0L1Latency(par[6])
+  fL0L1Latency(par[6]),
+  fESDID(-1)
  {
   //
   // constructor
@@ -109,7 +111,8 @@ AliTOFcluster::AliTOFcluster(const AliTOFcluster & cluster):
   fTdcRAW(cluster.fTdcRAW),
   fStatus(cluster.fStatus),
   fDeltaBC(cluster.fDeltaBC),
-  fL0L1Latency(cluster.fL0L1Latency)
+  fL0L1Latency(cluster.fL0L1Latency),
+  fESDID(-1)
  {
   //
   // copy ctor for AliTOFcluster object
@@ -139,6 +142,7 @@ AliTOFcluster & AliTOFcluster::operator = (const AliTOFcluster & cluster)
   fStatus=cluster.fStatus;
   fDeltaBC=cluster.fDeltaBC;
   fL0L1Latency=cluster.fL0L1Latency;
+  fESDID = -1;
   for (Int_t ii=0; ii<5; ii++)
     fdetIndex[ii] = cluster.fdetIndex[ii];
   return *this;
index 719b398..36aa6f3 100644 (file)
@@ -55,7 +55,10 @@ class AliTOFcluster : public AliCluster3D {
   void  SetTDCRAW(Int_t Tdc) {fTdcRAW = Tdc;} // Cluster ToF-raw setter
   void SetDeltaBC(Int_t value) {fDeltaBC = value;}; // deltaBC
   void SetL0L1Latency(Int_t value) {fL0L1Latency = value;}; // L0-L1 latency
-
+  //
+  void  SetESDID(Int_t id) {fESDID = id;}
+  Int_t GetESDID()  const  {return fESDID;}  
+  //
  private:
 
   Int_t fIdx;         // index of the digit related to this cluster
@@ -77,8 +80,10 @@ class AliTOFcluster : public AliCluster3D {
   Bool_t fStatus;     // cluster online status 
   Int_t fDeltaBC; // deltaBC
   Int_t fL0L1Latency; // L0L1 latency
+  //
+  Int_t fESDID;      //! id in ESD clusters list (if stored)
 
-  ClassDef(AliTOFcluster, 7) // TOF cluster
+  ClassDef(AliTOFcluster, 8) // TOF cluster
 };
 
 #endif
index c5a7100..aa801e5 100644 (file)
@@ -70,6 +70,7 @@ AliTOFtracker::AliTOFtracker():
   fnbadmatch(0),
   fnunmatch(0),
   fnmatch(0),
+  fESDEv(0),
   fTracks(new TClonesArray("AliTOFtrack")),
   fSeeds(new TObjArray(100)),
   fTOFtrackPoints(new TObjArray(10)),
@@ -98,11 +99,12 @@ AliTOFtracker::AliTOFtracker():
 
   // Getting the geometry
   fGeom = new AliTOFGeometry();
-
+  /* RS?
   for(Int_t i=0; i< 20000;i++){
     fClusterESD[i] = NULL;
+    fHit[i] = NULL;
   }
-
+  */
   InitCheckHists();
 
 }
@@ -148,13 +150,18 @@ AliTOFtracker::~AliTOFtracker() {
   for (Int_t ii=0; ii<kMaxCluster; ii++)
     if (fClusters[ii]) fClusters[ii]->Delete();
 
-  for(Int_t i=0; i< 20000;i++){
-    if(fClusterESD[i]){
-      delete fClusterESD[i];
-      fClusterESD[i] = NULL;
-    }
-  }
-
+  /* RS?
+     for(Int_t i=0; i< 20000;i++){
+     if(fClusterESD[i]){
+     delete fClusterESD[i];
+     fClusterESD[i] = NULL;
+     }
+     if(fHit[i]){
+     delete fHit[i];
+     fHit[i] = NULL;
+     }
+     }
+  */
 
 }
 //_____________________________________________________________________________
@@ -172,11 +179,9 @@ Int_t AliTOFtracker::PropagateBack(AliESDEvent * const event) {
   //
   // Gets seeds from ESD event and Match with TOF Clusters
   //
-
-  if(fNTOFmatched==0)
-    event->SetTOFcluster(1,fClusterESD);
-
-  if (fNTOFmatched==0) {
+  fESDEv = event;
+  //
+  if (fN==0) {
     AliInfo("No TOF recPoints to be matched with reconstructed tracks");
     return 0;
   }
@@ -193,6 +198,13 @@ Int_t AliTOFtracker::PropagateBack(AliESDEvent * const event) {
   //if(fkRecoParam->GetApplyPbPbCuts())fkRecoParam=fkRecoParam->GetPbPbparam();
   //fkRecoParam->PrintParameters();
 
+  /* RS?
+  // create clusters from hit
+  for(Int_t i=0;i < fNTOFmatched;i++){
+    fClusterESD[i] = new AliESDTOFCluster(fHit[i],event);
+    fClusterESD[i]->SetStatus(fClusters[i]->GetStatus());
+  }
+  */
   //Initialise some counters
 
   fNseeds=0;
@@ -209,14 +221,12 @@ Int_t AliTOFtracker::PropagateBack(AliESDEvent * const event) {
   //Load ESD tracks into a local Array of ESD Seeds
   for (Int_t i=0; i<fNseeds; i++){
     fSeeds->AddLast(event->GetTrack(i));
-    event->GetTrack(i)->SetESDEvent(event);
+    //    event->GetTrack(i)->SetESDEvent(event); // RS: Why this is needed? The event is already set
   }
-
   //Prepare ESD tracks candidates for TOF Matching
   CollectESD();
 
   if (fNseeds==0 || fNseedsTOF==0) {
-    event->SetTOFcluster(1,fClusterESD);
     AliInfo("No seeds to try TOF match");
     fSeeds->Clear();
     fTracks->Clear();
@@ -232,9 +242,9 @@ Int_t AliTOFtracker::PropagateBack(AliESDEvent * const event) {
   //Third Step without kTOFout flag (just to update clusters)
   MatchTracks(2);
 
-  event->SetTOFcluster(fNTOFmatched,fClusterESD); 
+  //RS?  event->SetTOFcluster(fNTOFmatched,fClusterESD); 
  
-  if (fNTOFmatched==0) {
+  if (fN==0) {
     AliInfo("No TOF recPoints to be matched with reconstructed tracks");
     fSeeds->Clear();
     fTracks->Clear();
@@ -246,9 +256,9 @@ Int_t AliTOFtracker::PropagateBack(AliESDEvent * const event) {
   //Update the matched ESD tracks
 
   for (Int_t i=0; i<ntrk; i++) {
+    // RS: This is a bogus code since t and seed are the same object
     AliESDtrack *t=event->GetTrack(i);
     AliESDtrack *seed =(AliESDtrack*)fSeeds->At(i);
-
     if ( (seed->GetStatus()&AliESDtrack::kTOFin)!=0 ) {
       t->SetStatus(AliESDtrack::kTOFin);
       //if(seed->GetTOFsignal()>0){
@@ -358,7 +368,7 @@ Int_t AliTOFtracker::PropagateBack(AliESDEvent * const event) {
       }
     }
   }
-
+  /* RS?
   if(fNTOFmatched){
     Int_t *matchmap = new Int_t[fNTOFmatched];
     event->SetTOFcluster(fNTOFmatched,fClusterESD,matchmap);
@@ -369,6 +379,7 @@ Int_t AliTOFtracker::PropagateBack(AliESDEvent * const event) {
 
     delete[] matchmap;
   }
+  */
 
   //Make TOF PID
   // Now done in AliESDpid
@@ -794,11 +805,11 @@ void AliTOFtracker::MatchTracks( Int_t mLastStep){
           nfound++;
 
          AliDebug(3,Form(" C - istep=%d ~ %d %d ~ nfound=%d",istep,trackInsideCluster,i,nfound));
-        
-
-         if(clind[i] < 20000 && mLastStep==2 && !isClusterMatchable[i]){ // add TOF clusters to the track
+         
+         // store the match in the ESD
+         if (mLastStep==2 && !isClusterMatchable[i]) { // add TOF clusters to the track
+           //
            isClusterMatchable[i] = kTRUE;
-
            //Tracking info
            Double_t mom=t->GetP();
            AliDebug(3,Form(" Momentum for track %d -> %f", iseed,mom));
@@ -811,9 +822,10 @@ void AliTOFtracker::MatchTracks( Int_t mLastStep){
              time[isp]+=(trackPos[3][istep]-trackPos[3][0])/kSpeedOfLight*TMath::Sqrt(momz*momz+mass*mass)/momz;
              //time[isp]+=(trackPos[3][istep]-trackPos[3][0])/kSpeedOfLight*TMath::Sqrt(mom*mom+mass*mass)/mom;
            }
-
-           if(!fClusterESD[clind[i]]->Update(t->GetID(),dist3d[1],dist3d[0],dist3d[2],trackPos[3][istep],time))//x,y,z -> tracking RF
-             t->AddTOFcluster(clind[i]);
+           //
+           AliESDTOFCluster* esdTOFCl = GetESDTOFCluster(clind[i]); 
+           if(!esdTOFCl->Update(t->GetID(),dist3d[1],dist3d[0],dist3d[2],trackPos[3][istep],time))//x,y,z -> tracking RF
+             t->AddTOFcluster(esdTOFCl->GetESDID());
          }
 
           // ***** NEW *****
@@ -1033,7 +1045,11 @@ void AliTOFtracker::MatchTracks( Int_t mLastStep){
 //       t->SetIntegratedTimes(time);
 //       t->SetTOFLabel(tlab);
  
-    // add tof cluster to the track also for step 2
+      // add tof cluster to the track also for step 2
+      AliESDTOFCluster* esdTOFCl = GetESDTOFCluster(idclus); 
+      esdTOFCl->Update(t->GetID(),mindistY,mindist,mindistZ,recL,time);
+      t->AddTOFcluster(esdTOFCl->GetESDID());
+      /* RS?
       if(idclus < 20000){
        fClusterESD[idclus]->Update(t->GetID(),mindistY,mindist,mindistZ,recL,time);//x,y,z -> tracking RF
        
@@ -1042,7 +1058,7 @@ void AliTOFtracker::MatchTracks( Int_t mLastStep){
       else{
        AliInfo("Too many TOF clusters matched with tracks (> 20000)");
       }
-      
+      */
     }
     // Fill Reco-QA histos for Reconstruction
     fHRecNClus->Fill(nc);
@@ -1108,18 +1124,12 @@ Int_t AliTOFtracker::LoadClusters(TTree *cTree) {
 
   fN = 0;
   fNTOFmatched = 0;
-  for(Int_t i=0; i< 20000;i++){
-    if(fClusterESD[i]){
-      delete fClusterESD[i];
-      fClusterESD[i] = NULL;
-    }
-  }
 
   for (Int_t i=0; i<nc; i++) {
     AliTOFcluster *c=(AliTOFcluster*)clusters->UncheckedAt(i);
 //PH    fClusters[i]=new AliTOFcluster(*c); fN++;
     fClusters[i]=c; fN++;
-
+    c->SetESDID(-1);
   // Fill Digits QA histos
  
     Int_t isector = c->GetDetInd(0);
@@ -1131,16 +1141,16 @@ Int_t AliTOFtracker::LoadClusters(TTree *cTree) {
     Float_t time =(AliTOFGeometry::TdcBinWidth()*c->GetTDC())*1E-3; // in ns
     Float_t tot = (AliTOFGeometry::TdcBinWidth()*c->GetToT())*1E-3;//in ns
 
+    /* RS?
     Int_t ind[5];
     ind[0]=isector;
     ind[1]=iplate;
     ind[2]=istrip;
     ind[3]=ipadZ;
     ind[4]=ipadX;
-
     Int_t calindex = AliTOFGeometry::GetIndex(ind);
     Int_t tofLabels[3]={c->GetLabel(0),c->GetLabel(1),c->GetLabel(2)};
+    */
     Int_t stripOffset = 0;
     switch (iplate) {
     case 0:
@@ -1168,23 +1178,19 @@ Int_t AliTOFtracker::LoadClusters(TTree *cTree) {
     fHDigClusTime->Fill(time);
     fHDigClusToT->Fill(tot);
 
+    fNTOFmatched++; // RS: Actually number of clusters
+    /* RS?
     if(fNTOFmatched < 20000){
-      fClusterESD[fNTOFmatched] = new AliESDTOFcluster(i,calindex,
-                               AliTOFGeometry::TdcBinWidth()*c->GetTDC()/*ps*/,
-                               AliTOFGeometry::TdcBinWidth()*c->GetTDCRAW()/*ps*/,
-                               AliTOFGeometry::ToTBinWidth()*c->GetToT()*1E-3/*ns*/,
-                               tofLabels,
-                               c->GetDeltaBC(),c->GetL0L1Latency(),
-                               c->GetStatus(),c->GetZ(),c->GetPhi(),c->GetR());
+      fHit[fNTOFmatched] = new AliESDTOFHit(AliTOFGeometry::TdcBinWidth()*c->GetTDC(),
+                                           AliTOFGeometry::TdcBinWidth()*c->GetTDCRAW(),
+                                           AliTOFGeometry::ToTBinWidth()*c->GetToT()*1E-3,
+                                           calindex,tofLabels,c->GetL0L1Latency(),
+                                           c->GetDeltaBC(),i,c->GetZ(),c->GetR(),c->GetPhi());
       fNTOFmatched++;
     }
-
+    */
   }
 
-
-  if(fNTOFmatched == 0)
-    fClusterESD[0] = new AliESDTOFcluster();
-
   return 0;
 }
 //_________________________________________________________________________
@@ -1196,7 +1202,20 @@ void AliTOFtracker::UnloadClusters() {
 //PH    delete fClusters[i];
     fClusters[i] = 0x0;
   }
+  /* RS
+  for(Int_t i=0; i< 20000;i++){
+    if(fClusterESD[i]){
+      delete fClusterESD[i];
+      fClusterESD[i] = NULL;
+    }
+    if(fHit[i]){
+      delete fHit[i];
+      fHit[i] = NULL;
+    }
+  }
+  */
   fN=0;
+  fNTOFmatched = 0;
 }
 
 //_________________________________________________________________________
@@ -1399,5 +1418,43 @@ void AliTOFtracker::FillClusterArray(TObjArray* arr) const
     for (Int_t i=0; i<fN; ++i) arr->Add(fClusters[i]);
 
 }
-//_________________________________________________________________________
 
+//_________________________________________________________________________
+AliESDTOFCluster* AliTOFtracker::GetESDTOFCluster(int clID)
+{
+  // get ESDTOFcluster corresponding to fClusters[clID]. If the original cluster
+  // was not stored yet in the ESD, first do this
+  AliTOFcluster *c = fClusters[clID];
+  AliESDTOFCluster *clESD = 0;
+  int esdID = c->GetESDID(); // was this cluster already stored in the ESD clusters?
+  TClonesArray* esdTOFClArr = fESDEv->GetESDTOFClusters();
+  if (esdID<0) { // cluster was not stored yet, do this
+    esdID = esdTOFClArr->GetEntriesFast();
+    c->SetESDID(esdID);
+    // first store the hits of the cluster
+    TClonesArray* esdTOFHitArr = fESDEv->GetESDTOFHits();
+    int nh = esdTOFHitArr->GetEntriesFast();
+    Int_t tofLabels[3]={c->GetLabel(0),c->GetLabel(1),c->GetLabel(2)};
+    Int_t ind[5] = {c->GetDetInd(0), c->GetDetInd(1), c->GetDetInd(2), c->GetDetInd(3), c->GetDetInd(4) };
+    Int_t calindex = AliTOFGeometry::GetIndex(ind);
+    /*AliESDTOFHit* esdHit = */ 
+    new ( (*esdTOFHitArr)[nh] ) 
+      AliESDTOFHit( AliTOFGeometry::TdcBinWidth()*c->GetTDC(),
+                   AliTOFGeometry::TdcBinWidth()*c->GetTDCRAW(),
+                   AliTOFGeometry::ToTBinWidth()*c->GetToT()*1E-3,
+                   calindex,tofLabels,c->GetL0L1Latency(),
+                   c->GetDeltaBC(),esdID,c->GetZ(),c->GetR(),c->GetPhi());
+    //
+    clESD =  new( (*esdTOFClArr)[esdID] ) AliESDTOFCluster( clID );
+    clESD->SetEvent(fESDEv);
+    clESD->SetStatus( c->GetStatus() );
+    clESD->SetESDID(esdID);
+    // 
+    // register hits in the cluster
+    clESD->AddESDTOFHitIndex(nh);
+  }
+  else clESD =  (AliESDTOFCluster*)esdTOFClArr->At(esdID); // cluster is aready stored in the ESD
+  //
+  return clESD;
+  //
+}
index 75832ac..437d74d 100644 (file)
@@ -21,7 +21,8 @@
 #include "AliTracker.h"
 
 #include "TObject.h"
-#include "AliESDTOFcluster.h"
+#include "AliESDTOFCluster.h"
+#include "AliESDTOFHit.h"
 
 class TClonesArray;
 class TObjArray;
@@ -107,8 +108,11 @@ class AliTOFtracker : public AliTracker {
  void InitCheckHists();
  void SaveCheckHists();
  void FillClusterArray(TObjArray* arr) const;
+ protected:
+ AliESDTOFCluster* GetESDTOFCluster(int clID);
 
-private:
+ private:
 
  enum {kMaxCluster=77777}; //maximal number of the TOF clusters
 
@@ -131,6 +135,8 @@ private:
  Int_t fnbadmatch;      // Wrongly matched tracks
  Int_t fnunmatch;       // Unmatched tracks
  Int_t fnmatch;         // Total matched tracks
+
+ AliESDEvent*  fESDEv;  //! pointer on the esd event
  
  TClonesArray* fTracks; //! pointer to the TClonesArray with TOF tracks
  TObjArray* fSeeds;  //! pointer to the TObjArray with ESD tracks
@@ -159,9 +165,10 @@ private:
  Float_t fExpTimePr; // exp time, Protons
 
  Int_t fNTOFmatched;                   // number of matched TOF cluster
- AliESDTOFcluster *fClusterESD[20000]; // pointers to the TOF clusters for ESD
+ // AliESDTOFCluster *fClusterESD[20000]; // pointers to the TOF clusters for ESD
+ // AliESDTOFHit *fHit[20000];            // pointers to the TOF hits for ESD
 
- ClassDef(AliTOFtracker, 7) // TOF tracker 
+ ClassDef(AliTOFtracker, 9) // TOF tracker 
 };
 
 #endif