implementation of option cw [writing of clusters]
authorabercuci <abercuci@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 18 Aug 2008 13:36:30 +0000 (13:36 +0000)
committerabercuci <abercuci@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 18 Aug 2008 13:36:30 +0000 (13:36 +0000)
HLT should run in the mode "no write clusters"
default in the offline reconstruction is write clusters

TRD/AliTRDReconstructor.cxx
TRD/AliTRDReconstructor.h
TRD/AliTRDclusterizer.cxx
TRD/AliTRDclusterizer.h
TRD/AliTRDtrackerV1.cxx
TRD/AliTRDtrackerV1.h

index 322f46c..9468547 100644 (file)
@@ -24,6 +24,7 @@
 #include <TFile.h>
 #include <TObjString.h>
 #include <TObjArray.h>
+#include <TClonesArray.h>
 
 #include "AliRunLoader.h"
 #include "AliRawReader.h"
@@ -43,7 +44,7 @@
 
 ClassImp(AliTRDReconstructor)
 
-
+TClonesArray *AliTRDReconstructor::fgClusters = 0x0;
 //_____________________________________________________________________________
 AliTRDReconstructor::AliTRDReconstructor()
   :AliReconstructor()
@@ -115,7 +116,7 @@ void AliTRDReconstructor::Reconstruct(AliRawReader *rawReader
   // Reconstruct clusters
   //
 
-  AliInfo("Reconstruct TRD clusters from RAW data [RawReader -> Cluster TTree]");
+  //AliInfo("Reconstruct TRD clusters from RAW data [RawReader -> Cluster TTree]");
 
 
   rawReader->Reset();
@@ -127,7 +128,12 @@ void AliTRDReconstructor::Reconstruct(AliRawReader *rawReader
   clusterer.OpenOutput(clusterTree);
   clusterer.SetAddLabels(kFALSE);
   clusterer.Raw2ClustersChamber(rawReader);
+  
+  if(IsWritingClusters()) return;
 
+  // take over ownership of clusters
+  fgClusters = clusterer.RecPoints();
+  clusterer.SetClustersOwner(kFALSE);
 }
 
 //_____________________________________________________________________________
@@ -138,7 +144,7 @@ void AliTRDReconstructor::Reconstruct(TTree *digitsTree
   // Reconstruct clusters
   //
 
-  AliInfo("Reconstruct TRD clusters from Digits [Digit TTree -> Cluster TTree]");
+  //AliInfo("Reconstruct TRD clusters from Digits [Digit TTree -> Cluster TTree]");
 
   AliTRDclusterizer clusterer("clusterer","TRD clusterizer");
   clusterer.SetReconstructor(this);
@@ -146,6 +152,11 @@ void AliTRDReconstructor::Reconstruct(TTree *digitsTree
   clusterer.ReadDigits(digitsTree);
   clusterer.MakeClusters();
 
+  if(IsWritingClusters()) return;
+
+  // take over ownership of clusters
+  fgClusters = clusterer.RecPoints();
+  clusterer.SetClustersOwner(kFALSE);
 }
 
 //_____________________________________________________________________________
index befeae8..d390eb0 100644 (file)
@@ -15,6 +15,7 @@
 #include "AliDetectorRecoParam.h"
 #include "AliTRDrecoParam.h"
 
+class TClonesArray;
 class AliRawReader;
 class AliTRDReconstructor: public AliReconstructor 
 {
@@ -52,6 +53,7 @@ public:
 
   virtual void        FillESD(AliRawReader *, TTree *clusterTree, AliESDEvent *esd) const { FillESD((TTree * )NULL, clusterTree, esd);                    }
   virtual void        FillESD(TTree *digitsTree, TTree *clusterTree, AliESDEvent *esd) const;
+  static TClonesArray* GetClusters() {return fgClusters;}
   Int_t               GetNdEdxSlices() const     { return GetPIDMethod() == kNNPID ? kNNslices : kLQslices;}
   AliTRDdriftGas      GetDriftGas() const        { return fSteerParam&kDriftGas ? kAr : kXe;}
   AliTRDpidMethod     GetPIDMethod() const       { return fSteerParam&kSteerPID ? kNNPID : kLQPID;}
@@ -66,6 +68,7 @@ public:
   virtual void        Reconstruct(AliRawReader *rawReader, TTree *clusterTree) const;
   virtual void        Reconstruct(TTree *digitsTree, TTree *clusterTree) const;
 
+  static void         SetClusters(TClonesArray *clusters) {fgClusters = clusters;}
   void               SetOption(Option_t *opt);
   inline void         SetTCParams(Double_t *par);
   void                SetStreamLevel(Int_t level, AliTRDReconstructorTask task= kTracker);
@@ -79,8 +82,9 @@ private:
   UInt_t        fSteerParam;          // steering flags
   Double_t      fTCParams[8];         // Tail Cancellation parameters for drift gases 
  
+  static TClonesArray *fgClusters;    // list of clusters for local reconstructor
 
-  ClassDef(AliTRDReconstructor, 1)         //  Class for the TRD reconstruction
+  ClassDef(AliTRDReconstructor, 1)    //  Class for the TRD reconstruction
 
 };
 
index 9fc2bfa..dcb7345 100644 (file)
@@ -25,6 +25,7 @@
 #include <TTree.h>
 #include <TH1.h>
 #include <TFile.h>
+#include <TClonesArray.h>
 #include <TObjArray.h>
 
 #include "AliRunLoader.h"
@@ -148,8 +149,8 @@ AliTRDclusterizer::AliTRDclusterizer(const AliTRDclusterizer &c)
   ,fClusterTree(NULL)
   ,fRecPoints(NULL)
   ,fTrackletTree(NULL)
-  ,fTrackletContainer(NULL)
   ,fDigitsManager(NULL)
+  ,fTrackletContainer(NULL)
   ,fAddLabels(kTRUE)
   ,fRawVersion(2)
   ,fIndexesOut(NULL)
@@ -173,48 +174,40 @@ AliTRDclusterizer::~AliTRDclusterizer()
   // AliTRDclusterizer destructor
   //
 
-  if (fRecPoints) 
-    {
-      fRecPoints->Delete();
-      delete fRecPoints;
-    }
-
-  if (fDigitsManager) 
-    {
-      delete fDigitsManager;
-      fDigitsManager = NULL;
-    }
+  if (fRecPoints && IsClustersOwner()){
+    fRecPoints->Delete();
+    delete fRecPoints;
+  }
 
-  if (fTrackletContainer)
-    {
-      delete fTrackletContainer;
-      fTrackletContainer = NULL;
-    }
+  if (fDigitsManager) {
+    delete fDigitsManager;
+    fDigitsManager = NULL;
+  }
 
-  if (fIndexesOut)
-    {
-      delete fIndexesOut;
-      fIndexesOut    = NULL;
-    }
+  if (fTrackletContainer){
+    delete fTrackletContainer;
+    fTrackletContainer = NULL;
+  }
 
-  if (fIndexesMaxima)
-    {
-      delete fIndexesMaxima;
-      fIndexesMaxima = NULL;
-    }
+  if (fIndexesOut){
+    delete fIndexesOut;
+    fIndexesOut    = NULL;
+  }
 
-  if (fTransform)
-    {
-      delete fTransform;
-      fTransform     = NULL;
-    }
+  if (fIndexesMaxima){
+    delete fIndexesMaxima;
+    fIndexesMaxima = NULL;
+  }
 
-  if (fLUT) 
-    {
-      delete [] fLUT;
-      fLUT           = NULL;
-    }
+  if (fTransform){
+    delete fTransform;
+    fTransform     = NULL;
+  }
 
+  if (fLUT) {
+    delete [] fLUT;
+    fLUT           = NULL;
+  }
 }
 
 //_____________________________________________________________________________
@@ -288,13 +281,15 @@ Bool_t AliTRDclusterizer::OpenOutput()
   // Open the output file
   //
 
-  TObjArray *ioArray = 0;
+  if (!fReconstructor->IsWritingClusters()) return kTRUE;
+
+  TObjArray *ioArray = 0x0; 
 
   AliLoader* loader = fRunLoader->GetLoader("TRDLoader");
   loader->MakeTree("R");
 
   fClusterTree = loader->TreeR();
-  fClusterTree->Branch("TRDcluster","TObjArray",&ioArray,32000,0);
+  fClusterTree->Branch("TRDcluster", "TObjArray", &ioArray, 32000, 0);
 
   return kTRUE;
 
@@ -307,11 +302,12 @@ Bool_t AliTRDclusterizer::OpenOutput(TTree *clusterTree)
   // Connect the output tree
   //
 
-  TObjArray *ioArray = 0;
-
-  fClusterTree = clusterTree;
-  fClusterTree->Branch("TRDcluster","TObjArray",&ioArray,32000,0);
-
+  // clusters writing
+  if (fReconstructor->IsWritingClusters()){
+    TObjArray *ioArray = 0x0;
+    fClusterTree = clusterTree;
+    fClusterTree->Branch("TRDcluster", "TObjArray", &ioArray, 32000, 0);
+  }
 
   // tracklet writing
   if (fReconstructor->IsWritingTracklets()){
@@ -378,67 +374,38 @@ Bool_t AliTRDclusterizer::WriteClusters(Int_t det)
     return kFALSE;
   }
  
+  TObjArray *ioArray = new TObjArray(400);
   TBranch *branch = fClusterTree->GetBranch("TRDcluster");
   if (!branch) {
-    TObjArray *ioArray = 0;
     branch = fClusterTree->Branch("TRDcluster","TObjArray",&ioArray,32000,0);
-  }
-
-  if ((det >=                      0) && 
-      (det <  AliTRDgeometry::Ndet())) {
-
-    Int_t nRecPoints = RecPoints()->GetEntriesFast();
-    TObjArray *detRecPoints = new TObjArray(400);
+  } else branch->SetAddress(&ioArray);
 
+  
+  Int_t nRecPoints = RecPoints()->GetEntriesFast();
+  if(det >= 0){
     for (Int_t i = 0; i < nRecPoints; i++) {
       AliTRDcluster *c = (AliTRDcluster *) RecPoints()->UncheckedAt(i);
-      if (det == c->GetDetector()) {
-        detRecPoints->AddLast(c);
-      }
-      else {
-        AliError(Form("Attempt to write a cluster with unexpected detector index: got=%d expected=%d\n"
-                     ,c->GetDetector()
-                     ,det));
-      }
+      if(det != c->GetDetector()) continue;
+      ioArray->AddLast(c);
     }
-
-    branch->SetAddress(&detRecPoints);
     fClusterTree->Fill();
+  } else {
+    //AliInfo(Form("Writing the cluster tree %s for event %d.", fClusterTree->GetName(), fRunLoader->GetEventNumber()));
 
-    delete detRecPoints;
-    
-    return kTRUE;
-
-  }
-
-  if (det == -1) {
-
-    AliInfo(Form("Writing the cluster tree %s for event %d."
-               ,fClusterTree->GetName(),fRunLoader->GetEventNumber()));
-
-    if (fRecPoints) {
-
-      branch->SetAddress(&fRecPoints);
-
-      AliLoader *loader = fRunLoader->GetLoader("TRDLoader");
-      loader->WriteRecPoints("OVERWRITE");
-  
-    }
-    else {
-
-      AliError("Cluster tree does not exist. Cannot write clusters.\n");
-      return kFALSE;
-
+    Int_t detOld = -1;
+    for (Int_t i = 0; i < nRecPoints; i++) {
+      AliTRDcluster *c = (AliTRDcluster *) RecPoints()->UncheckedAt(i);
+      if(c->GetDetector() != detOld){
+        fClusterTree->Fill();
+        ioArray->Clear();
+        detOld = c->GetDetector();
+      } 
+      ioArray->AddLast(c);
     }
-
-    return kTRUE;  
-
   }
+  delete ioArray;
 
-  AliError(Form("Unexpected detector index %d.\n",det));
-  return kFALSE;  
-  
+  return kTRUE;  
 }
 
 //_____________________________________________________________________________
@@ -583,59 +550,51 @@ Bool_t AliTRDclusterizer::MakeClusters()
   //
 
   // Propagate info from the digits manager
-  if (fAddLabels == kTRUE)
-    {
-      fAddLabels = fDigitsManager->UsesDictionaries();
-    }
-
+  if (fAddLabels == kTRUE){
+    fAddLabels = fDigitsManager->UsesDictionaries();
+  }
+  
   Bool_t fReturn = kTRUE;
-  for (Int_t i = 0; i < AliTRDgeometry::kNdet; i++)
-    {
-
-      AliTRDdataArrayDigits *digitsIn = (AliTRDdataArrayDigits*) fDigitsManager->GetDigits(i);      
-      // This is to take care of switched off super modules
-      if (!digitsIn->HasData()) 
-        {
-         continue;
+  for (Int_t i = 0; i < AliTRDgeometry::kNdet; i++){
+  
+    AliTRDdataArrayDigits *digitsIn = (AliTRDdataArrayDigits*) fDigitsManager->GetDigits(i);      
+    // This is to take care of switched off super modules
+    if (!digitsIn->HasData()) continue;
+    digitsIn->Expand();
+    AliTRDSignalIndex* indexes = fDigitsManager->GetIndexes(i);
+    if (indexes->IsAllocated() == kFALSE){
+      fDigitsManager->BuildIndexes(i);
+    }
+  
+    Bool_t fR = kFALSE;
+    if (indexes->HasEntry()){
+      if (fAddLabels){
+        for (Int_t iDict = 0; iDict < AliTRDdigitsManager::kNDict; iDict++){
+          AliTRDdataArrayI *tracksIn = 0;
+          tracksIn = (AliTRDdataArrayI *) fDigitsManager->GetDictionary(i,iDict);
+          tracksIn->Expand();
         }
-      digitsIn->Expand();
-      AliTRDSignalIndex* indexes = fDigitsManager->GetIndexes(i);
-      if (indexes->IsAllocated() == kFALSE)
-       {
-         fDigitsManager->BuildIndexes(i);
-       }
-
-      Bool_t fR = kFALSE;
-      if (indexes->HasEntry())
-       {
-         if (fAddLabels)
-           {
-             for (Int_t iDict = 0; iDict < AliTRDdigitsManager::kNDict; iDict++) 
-               {
-                 AliTRDdataArrayI *tracksIn = 0;
-                 tracksIn = (AliTRDdataArrayI *) fDigitsManager->GetDictionary(i,iDict);
-                 tracksIn->Expand();
-               }
-           }
-         fR = MakeClusters(i);
-         fReturn = fR && fReturn;
-       }
-
-      if (fR == kFALSE)
-       {
-         WriteClusters(i);
-         ResetRecPoints();
-       }
-
-      // No compress just remove
-      fDigitsManager->RemoveDigits(i);
-      fDigitsManager->RemoveDictionaries(i);      
-      fDigitsManager->ClearIndexes(i);
-
+      }
+      fR = MakeClusters(i);
+      fReturn = fR && fReturn;
     }
+  
+    //if (fR == kFALSE){
+    //  if(IsWritingClusters()) WriteClusters(i);
+    //  ResetRecPoints();
+    //}
+        
+    // No compress just remove
+    fDigitsManager->RemoveDigits(i);
+    fDigitsManager->RemoveDictionaries(i);      
+    fDigitsManager->ClearIndexes(i);  
+  }
+  
+  if(fReconstructor->IsWritingClusters()) WriteClusters(-1);
 
-  return fReturn;
+  AliInfo(Form("Number of found clusters : %d", RecPoints()->GetEntriesFast())); 
 
+  return fReturn;
 }
 
 //_____________________________________________________________________________
@@ -657,61 +616,39 @@ Bool_t AliTRDclusterizer::Raw2ClustersChamber(AliRawReader *rawReader)
   //
 
   // Create the digits manager
-  if (!fDigitsManager)
-    {
-      fDigitsManager = new AliTRDdigitsManager();
-      fDigitsManager->CreateArrays();
-    }
+  if (!fDigitsManager){
+    fDigitsManager = new AliTRDdigitsManager();
+    fDigitsManager->CreateArrays();
+  }
 
   fDigitsManager->SetUseDictionaries(fAddLabels);
 
-  // tracklet container for raw tracklet writing
-  if (!fTrackletContainer && fReconstructor->IsWritingTracklets()) 
-    {
-     fTrackletContainer = new UInt_t *[2];
-     for (Int_t i=0; i<2 ;i++){
-        fTrackletContainer[i] = new UInt_t[256]; // maximum tracklets for one HC
-     }
-    }
-
   AliTRDrawStreamBase *pinput = AliTRDrawStreamBase::GetRawStream(rawReader);
   AliTRDrawStreamBase &input = *pinput;
 
   AliInfo(Form("Stream version: %s", input.IsA()->GetName()));
   
   Int_t det    = 0;
-  while ((det = input.NextChamber(fDigitsManager,fTrackletContainer)) >= 0)
-    {
-      Bool_t iclusterBranch = kFALSE;
-      if (fDigitsManager->GetIndexes(det)->HasEntry())
-        {
-          iclusterBranch = MakeClusters(det);
-        }
-      if (iclusterBranch == kFALSE)
-        {
-          WriteClusters(det);
-          ResetRecPoints();
-        }
-      fDigitsManager->RemoveDigits(det);
-      fDigitsManager->RemoveDictionaries(det);
-      fDigitsManager->ClearIndexes(det);
-     
-      if (!fReconstructor->IsWritingTracklets()) continue;
-      if (*(fTrackletContainer[0]) > 0 || *(fTrackletContainer[1]) > 0) WriteTracklets(det); // if there is tracklet words in this det
+  while ((det = input.NextChamber(fDigitsManager)) >= 0){
+    Bool_t iclusterBranch = kFALSE;
+    if (fDigitsManager->GetIndexes(det)->HasEntry()){
+    iclusterBranch = MakeClusters(det);
     }
-  
-  if (fReconstructor->IsWritingTracklets()){
-    delete [] fTrackletContainer;
-    fTrackletContainer = NULL;
+
+    fDigitsManager->RemoveDigits(det);
+    fDigitsManager->RemoveDictionaries(det);      
+    fDigitsManager->ClearIndexes(det);
   }
+  if(fReconstructor->IsWritingClusters()) WriteClusters(-1);
 
   delete fDigitsManager;
   fDigitsManager = NULL;
 
   delete pinput;
   pinput = NULL;
-  return kTRUE;
 
+  AliInfo(Form("Number of found clusters : %d", RecPoints()->GetEntriesFast())); 
+  return kTRUE;
 }
 
 //_____________________________________________________________________________
@@ -1067,19 +1004,21 @@ Bool_t AliTRDclusterizer::MakeClusters(Int_t det)
         clusterSig[1] = clusterXYZ[5];
         Double_t clusterCharge  = clusterXYZ[3];
         Char_t   clusterTimeBin = ((Char_t) clusterRCT[2]);
-        AliTRDcluster *cluster = new AliTRDcluster(idet
-                                                  ,clusterCharge
-                                                  ,clusterPos
-                                                  ,clusterSig
-                                                  ,0x0
-                                                  ,((Char_t) nPadCount)
-                                                  ,signals
-                                                  ,((UChar_t) col)
-                                                  ,((UChar_t) row)
-                                                  ,((UChar_t) time)
-                                                  ,clusterTimeBin
-                                                  ,clusterPosCol
-                                                  ,volid);
+
+        Int_t n = RecPoints()->GetEntriesFast();
+        AliTRDcluster *cluster = new((*RecPoints())[n]) AliTRDcluster(idet
+                  ,clusterCharge
+                  ,clusterPos
+                  ,clusterSig
+                  ,0x0
+                  ,((Char_t) nPadCount)
+                  ,signals
+                  ,((UChar_t) col)
+                  ,((UChar_t) row)
+                  ,((UChar_t) time)
+                  ,clusterTimeBin
+                  ,clusterPosCol
+                  ,volid);
         cluster->SetInChamber(!out);
 
         UChar_t maskPosition = padStatus.GetDataUnchecked(row, col, time);
@@ -1102,7 +1041,7 @@ Bool_t AliTRDclusterizer::MakeClusters(Int_t det)
         cluster->SetLabel( col,1);
         cluster->SetLabel(time,2);
   
-        RecPoints()->Add(cluster);
+        //RecPoints()->Add(cluster);
 
         // Store the index of the first cluster in the current ROC
         if (firstClusterROC < 0) {
@@ -1121,8 +1060,8 @@ Bool_t AliTRDclusterizer::MakeClusters(Int_t det)
   if (fAddLabels) AddLabels(idet, firstClusterROC, nClusterROC);
 
   // Write the cluster and reset the array
-  WriteClusters(idet);
-  ResetRecPoints();
+  //WriteClusters(idet);
+  //ResetRecPoints();
 
   return kTRUE;
 
@@ -1427,18 +1366,16 @@ void AliTRDclusterizer::ResetRecPoints()
 }
 
 //_____________________________________________________________________________
-TObjArray *AliTRDclusterizer::RecPoints() 
+TClonesArray *AliTRDclusterizer::RecPoints() 
 {
   //
   // Returns the list of rec points
   //
 
   if (!fRecPoints) {
-    fRecPoints = new TObjArray(400);
+    fRecPoints = new TClonesArray("AliTRDcluster", 400);
   }
   return fRecPoints;
-
 }
 
 //_____________________________________________________________________________
index edef846..c432ac2 100644 (file)
@@ -15,7 +15,7 @@
 
 class TFile;
 class TTree;
-class TObjArray;
+class TClonesArray;
 
 class AliRunLoader;
 class AliRawReader;
@@ -33,6 +33,11 @@ class AliTRDReconstructor;
 class AliTRDclusterizer : public TNamed 
 {
 public:
+  // steering flags
+  enum{
+    kOwner = BIT(14)
+  };
+  
   AliTRDclusterizer(AliTRDReconstructor *rec = 0x0);
   AliTRDclusterizer(const Text_t* name, const Text_t* title, AliTRDReconstructor *rec = 0x0);
   AliTRDclusterizer(const AliTRDclusterizer &c);
@@ -52,7 +57,7 @@ public:
 
   virtual Bool_t   WriteClusters(Int_t det);
           void     ResetRecPoints();
-  TObjArray       *RecPoints();
+  TClonesArray       *RecPoints();
           Bool_t   WriteTracklets(Int_t det);
 
   virtual Bool_t   Raw2Clusters(AliRawReader *rawReader);
@@ -66,7 +71,10 @@ public:
             return fAddLabels;  } // should we assign labels to clusters
   virtual void     SetRawVersion(Int_t iver) { fRawVersion = iver; } // set the expected raw data version
   void             SetReconstructor(const AliTRDReconstructor *rec) {fReconstructor = rec;}
-  static UChar_t GetStatus(Short_t &signal);
+  static UChar_t   GetStatus(Short_t &signal);
+
+  Bool_t           IsClustersOwner() const {return TestBit(kOwner);}
+  void             SetClustersOwner(Bool_t own=kTRUE) {SetBit(kOwner, own); if(!own) fRecPoints = 0x0;}
 
 protected:
   void     DeConvExp(Double_t *source, Double_t *target
@@ -89,7 +97,7 @@ protected:
   const AliTRDReconstructor *fReconstructor;       //! reconstructor
   AliRunLoader        *fRunLoader;           //! Run Loader
   TTree               *fClusterTree;         //! Tree with the cluster
-  TObjArray           *fRecPoints;           //! Array of clusters
+  TClonesArray        *fRecPoints;           //! Array of clusters
 
   TTree               *fTrackletTree;         //! Tree for tracklets
 
index fe2dfff..418afdb 100644 (file)
@@ -1557,23 +1557,62 @@ Int_t AliTRDtrackerV1::ReadClusters(TClonesArray* &array, TTree *clusterTree) co
 Int_t AliTRDtrackerV1::LoadClusters(TTree *cTree)
 {
   //
-  // Fills clusters into TRD tracking_sectors 
-  // Note that the numbering scheme for the TRD tracking_sectors 
-  // differs from that of TRD sectors
+  // Fills clusters into TRD tracking sectors
   //
-
   
-  if (ReadClusters(fClusters, cTree)) {
-    AliError("Problem with reading the clusters !");
+  if(!(fClusters = AliTRDReconstructor::GetClusters())){
+    if (ReadClusters(fClusters, cTree)) {
+      AliError("Problem with reading the clusters !");
+      return 1;
+    }
+  }
+  SetClustersOwner();
+
+  if(!fClusters->GetEntriesFast()){ 
+    AliInfo("No TRD clusters");
     return 1;
   }
-  Int_t ncl  = fClusters->GetEntriesFast(), nin = 0;
-  if(!ncl){ 
-    AliInfo("Clusters 0");
+
+  //Int_t nin = 
+  BuildTrackingContainers();  
+
+  //Int_t ncl  = fClusters->GetEntriesFast();
+  //AliInfo(Form("Clusters %d [%6.2f %% in the active volume]", ncl, 100.*float(nin)/ncl));
+
+  return 0;
+}
+
+//_____________________________________________________________________________
+Int_t AliTRDtrackerV1::LoadClusters(TClonesArray *clusters)
+{
+  //
+  // Fills clusters into TRD tracking sectors
+  // Function for use in the HLT
+  
+  if(!clusters || !clusters->GetEntriesFast()){ 
+    AliInfo("No TRD clusters");
     return 1;
   }
 
-  Int_t icl = ncl;
+  fClusters = clusters;
+  SetClustersOwner();
+
+  //Int_t nin = 
+  BuildTrackingContainers();  
+
+  //Int_t ncl  = fClusters->GetEntriesFast();
+  //AliInfo(Form("Clusters %d [%6.2f %% in the active volume]", ncl, 100.*float(nin)/ncl));
+
+  return 0;
+}
+
+
+//____________________________________________________________________
+Int_t AliTRDtrackerV1::BuildTrackingContainers()
+{
+// Building tracking containers for clusters
+
+  Int_t nin =0, icl = fClusters->GetEntriesFast();
   while (icl--) {
     AliTRDcluster *c = (AliTRDcluster *) fClusters->UncheckedAt(icl);
     if(c->IsInChamber()) nin++;
@@ -1584,17 +1623,17 @@ Int_t AliTRDtrackerV1::LoadClusters(TTree *cTree)
     
     fTrSec[sector].GetChamber(stack, layer, kTRUE)->InsertCluster(c, icl);
   }
-  AliInfo(Form("Clusters %d in %6.2f %%", ncl, 100.*float(nin)/ncl));
   
   for(int isector =0; isector<AliTRDgeometry::kNsector; isector++){ 
     if(!fTrSec[isector].GetNChambers()) continue;
     fTrSec[isector].Init(fReconstructor);
   }
-  
-  return 0;
+
+  return nin;
 }
 
 
+
 //____________________________________________________________________
 void AliTRDtrackerV1::UnloadClusters() 
 { 
@@ -1604,7 +1643,7 @@ void AliTRDtrackerV1::UnloadClusters()
 
   if(fTracks) fTracks->Delete(); 
   if(fTracklets) fTracklets->Delete();
-  if(fClusters) fClusters->Delete();
+  if(fClusters && IsClustersOwner()) fClusters->Delete();
 
   for (int i = 0; i < AliTRDgeometry::kNsector; i++) fTrSec[i].Clear();
 
index b1f2a12..691e5aa 100644 (file)
@@ -51,6 +51,9 @@ class AliTRDtrackerV1 : public AliTracker
 {
 public:
   enum{
+    kOwner = BIT(14)
+  };
+  enum{
     kMaxLayersPerSector   = 1000
     , kMaxTimeBinIndex    = 216
     , kTrackingSectors    = 18
@@ -89,9 +92,13 @@ public:
        static Double_t FitLine(AliTRDtrackV1 *trk, AliTRDseedV1 *tracklets = 0x0, Bool_t err=0, Int_t np = 0, AliTrackPoint *points = 0x0);
        static Double_t FitKalman(AliTRDtrackV1 *trk, AliTRDseedV1 *tracklets = 0x0, Bool_t up=0, Int_t np = 0, AliTrackPoint *points = 0x0);
 
+  Bool_t          IsClustersOwner() const {return TestBit(kOwner);}
+  void            SetClustersOwner(Bool_t own=kTRUE) {SetBit(kOwner, own); if(!own) fClusters = 0x0;}
+
   Int_t           FollowBackProlongation(AliTRDtrackV1 &t);
   Int_t           FollowProlongation(AliTRDtrackV1 &t);
   Int_t           LoadClusters(TTree *cTree);
+  Int_t           LoadClusters(TClonesArray *clusters);
   Int_t           PropagateBack(AliESDEvent *event);
   Int_t           ReadClusters(TClonesArray* &array, TTree *in) const;
   Int_t           RefitInward(AliESDEvent *event);
@@ -124,6 +131,7 @@ public:
 protected:
   static Bool_t  AdjustSector(AliTRDtrackV1 *track); 
   Double_t       BuildSeedingConfigs(AliTRDtrackingChamber **stack, Int_t *configs);
+  Int_t          BuildTrackingContainers();
   static Float_t CalculateChi2Z(AliTRDseedV1 *tracklets, Double_t offset, Double_t slope, Double_t xref);
   Int_t          Clusters2TracksSM(Int_t sector, AliESDEvent *esd);
   Int_t          Clusters2TracksStack(AliTRDtrackingChamber **stack, TClonesArray *esdTrackList);