Use uniform ownership policy for data containers (clusters,
authorabercuci <abercuci@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 28 Jan 2013 08:47:53 +0000 (08:47 +0000)
committerabercuci <abercuci@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 28 Jan 2013 08:47:53 +0000 (08:47 +0000)
onl.tracklets, onl.tracks). TRD reconstructor is made the manager of
data containers.
Prepare onl.tracklets for usage in the tracking code (in view of TRD
upgrade)

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

index 0348b02..dc45ca9 100644 (file)
@@ -118,6 +118,10 @@ AliTRDReconstructor::~AliTRDReconstructor()
   // Destructor
   //
 
+  if(fClusterizer){
+    delete fClusterizer;
+    fClusterizer = NULL;
+  }
   if(fgClusters) {
     fgClusters->Delete();
     delete fgClusters;
@@ -137,10 +141,6 @@ AliTRDReconstructor::~AliTRDReconstructor()
     for(Int_t itask = 0; itask < AliTRDrecoParam::kTRDreconstructionTasks; itask++)
       if(fDebugStream[itask]) delete fDebugStream[itask];
   }
-  if(fClusterizer){
-    delete fClusterizer;
-    fClusterizer = NULL;
-  }
 }
 
 
@@ -155,6 +155,7 @@ void AliTRDReconstructor::Init(){
   if(!fClusterizer){
     fClusterizer = new AliTRDclusterizer(fgTaskNames[AliTRDrecoParam::kClusterizer], fgTaskNames[AliTRDrecoParam::kClusterizer]);
     fClusterizer->SetReconstructor(this);
+    AliInfo(Form("Build TRD clusterizer[%p]", (void*)fClusterizer));
   }
   
   // Make Debug Streams when Debug Streaming
@@ -176,27 +177,23 @@ void AliTRDReconstructor::ConvertDigits(AliRawReader *rawReader
   // Convert raw data digits into digit objects in a root tree
   //
 
-  //AliInfo("Convert raw data digits into digit objects [RawReader -> Digit TTree]");
+  AliDebug(1, "Convert raw data digits into digit objects [RawReader -> Digit TTree]");
+  AliDebug(2, Form("clusters[%p] tracklets[%p] tracks[%p]", (void*)fgClusters, (void*)fgTracklets, (void*)fgTracks));
 
-  AliTRDrawData rawData;
   rawReader->Reset();
   rawReader->Select("TRD");
+  ResetContainers();
+
+  AliTRDrawData rawData;
+  rawData.SetTracklets(GetTracklets("AliTRDtrackletMCM")); // link allocated online tracklets
+  rawData.SetTracks(GetTracks());                          // link allocated online tracks
+
   AliTRDdigitsManager *manager = rawData.Raw2Digits(rawReader);
   manager->MakeBranch(digitsTree);
   manager->WriteDigits();
   delete manager;
 
-  // take over ownership of online tracklets
-  fgTracklets = rawData.TrackletsArray();
-  rawData.SetTrackletsOwner(0x0);
-
-  // take over GTU tracks
-  fgTracks = rawData.TracksArray();
-  rawData.SetTracksOwner(0x0);
-
-  for (Int_t iSector = 0; iSector < 18; iSector++) {
-    fgTriggerFlags.SetFlags(iSector, rawData.GetTriggerFlags(iSector));
-  }
+  for (Int_t iSector = 0; iSector < 18; iSector++) fgTriggerFlags.SetFlags(iSector, rawData.GetTriggerFlags(iSector));
 }
 
 //_____________________________________________________________________________
@@ -207,43 +204,22 @@ void AliTRDReconstructor::Reconstruct(AliRawReader *rawReader
   // Reconstruct clusters
   //
 
-  //AliInfo("Reconstruct TRD clusters from RAW data [RawReader -> Cluster TTree]");
-
-
-  rawReader->Reset();
-  rawReader->Select("TRD");
-
+  AliDebug(1, "Reconstruct TRD clusters from RAW data [RawReader -> Cluster TTree]");
+  AliDebug(2, Form("clusters[%p] tracklets[%p] tracks[%p]", (void*)fgClusters, (void*)fgTracklets, (void*)fgTracks));
   if(!fClusterizer){
     AliFatal("Clusterizer not available!");
     return;
   }
-
-  fClusterizer->ResetRecPoints();
-
+  rawReader->Reset();
+  rawReader->Select("TRD");
+  ResetContainers();
   fClusterizer->OpenOutput(clusterTree);
   fClusterizer->SetUseLabels(kFALSE);
   fClusterizer->SetStoreRawSignals(kTRUE);
+  fClusterizer->ResetRecPoints();
   fClusterizer->Raw2ClustersChamber(rawReader);
-  
   fgNTimeBins = fClusterizer->GetNTimeBins();
-  
-  // take over ownership of online tracklets
-  fgTracklets = fClusterizer->TrackletsArray();
-  fClusterizer->SetTrackletsOwner(kFALSE);
-
-  // take over GTU tracks
-  fgTracks = fClusterizer->TracksArray();
-  fClusterizer->SetTracksOwner(kFALSE);
-
-  for (Int_t iSector = 0; iSector < 18; iSector++) {
-    fgTriggerFlags.SetFlags(iSector, fClusterizer->GetTriggerFlags(iSector));
-  }
-
-  if(IsWritingClusters()) return;
-
-  // take over ownership of clusters
-  fgClusters = fClusterizer->RecPoints();
-  fClusterizer->SetClustersOwner(kFALSE);
+  for (Int_t iSector = 0; iSector < 18; iSector++) fgTriggerFlags.SetFlags(iSector, fClusterizer->GetTriggerFlags(iSector));
 }
 
 //_____________________________________________________________________________
@@ -254,35 +230,25 @@ void AliTRDReconstructor::Reconstruct(TTree *digitsTree
   // Reconstruct clusters
   //
 
-  //AliInfo("Reconstruct TRD clusters from Digits [Digit TTree -> Cluster TTree]");
-  
-  AliTRDclusterizer clusterer(fgTaskNames[AliTRDrecoParam::kClusterizer], fgTaskNames[AliTRDrecoParam::kClusterizer]);
-  clusterer.SetReconstructor(this);
-  clusterer.SetUseLabels(kTRUE);
-  clusterer.SetStoreRawSignals(kTRUE);
-  clusterer.OpenOutput(clusterTree);
-  clusterer.ReadDigits(digitsTree);
-  clusterer.MakeClusters();
-
-  // read tracklets and tracks if not done during reading of raw data
-  if (!fgTracklets) {
-    clusterer.ReadTracklets();
-    fgTracklets = clusterer.TrackletsArray();
-    clusterer.SetTrackletsOwner(kFALSE);
-  }
-  if (!fgTracks) {
-    clusterer.ReadTracks();
-    fgTracks = clusterer.TracksArray();
-    clusterer.SetTracksOwner(kFALSE);
+  AliDebug(1, "Reconstruct TRD clusters from Digits [Digit TTree -> Cluster TTree]");
+  AliDebug(2, Form("Start :: clusters[%p] tracklets[%p] tracks[%p]", (void*)fgClusters, (void*)fgTracklets, (void*)fgTracks));
+  if(!fClusterizer){
+    AliFatal("Clusterizer not available!");
+    return;
   }
 
-  fgNTimeBins = clusterer.GetNTimeBins();
-
-  if(IsWritingClusters()) return;
-
-  // take over ownership of clusters
-  fgClusters = clusterer.RecPoints();
-  clusterer.SetClustersOwner(kFALSE);
+  if(fgClusters){
+    AliDebug(1, Form("Removing %5d clusters @ %p", fgClusters->GetEntriesFast(), (void*)fgClusters));
+    fgClusters->Clear();
+  }
+  AliTRDclusterizer clusterizer(fgTaskNames[AliTRDrecoParam::kClusterizer], fgTaskNames[AliTRDrecoParam::kClusterizer]);
+  clusterizer.SetReconstructor(this);
+  clusterizer.SetUseLabels(kTRUE);
+  clusterizer.SetStoreRawSignals(kTRUE);
+  clusterizer.OpenOutput(clusterTree);
+  clusterizer.ReadDigits(digitsTree);
+  clusterizer.MakeClusters();
+  fgNTimeBins = clusterizer.GetNTimeBins();
 }
 
 //_____________________________________________________________________________
@@ -295,6 +261,7 @@ AliTracker *AliTRDReconstructor::CreateTracker() const
   //return new AliTRDtracker(NULL);
   AliTRDtrackerV1 *tracker = new AliTRDtrackerV1();
   tracker->SetReconstructor(this);
+  AliInfo(Form("Build TRD tracker[%p]", (void*)tracker));
   return tracker;
 
 }
@@ -309,25 +276,19 @@ void AliTRDReconstructor::FillESD(TTree* /*digitsTree*/
   //
 
   // ----- filling tracklets -----
-  AliDebug(1, Form("Filling tracklets from %p (%i)",
-                  fgTracklets, fgTracklets ? fgTracklets->GetEntriesFast() : 0));
+  AliDebug(1, Form("Loading onl.tracklets(%i) to ESD", fgTracklets ? fgTracklets->GetEntriesFast() : 0));
   Int_t trackletIndex[1080] = { 0 };
   TList trklList;
   AliTRDrawStream::SortTracklets(fgTracklets, trklList, trackletIndex);
   TIter trackletIter(&trklList);
   while (AliTRDtrackletBase* tracklet = (AliTRDtrackletBase*) trackletIter()) {
     Int_t label = -2; // mark raw tracklets with label -2
-    if (AliTRDtrackletMCM *trklMCM = dynamic_cast<AliTRDtrackletMCM*> (tracklet))
-      label = trklMCM->GetLabel();
-
-    AliESDTrdTracklet *esdTracklet = new AliESDTrdTracklet(tracklet->GetTrackletWord(), tracklet->GetHCId(), label);
-
-    esd->AddTrdTracklet(esdTracklet);
+    if (AliTRDtrackletMCM *trklMCM = dynamic_cast<AliTRDtrackletMCM*> (tracklet)) label = trklMCM->GetLabel();
+    esd->AddTrdTracklet(new AliESDTrdTracklet(tracklet->GetTrackletWord(), tracklet->GetHCId(), label));
   }
 
   // ----- filling GTU tracks -----
-  AliDebug(1, Form("Now filling ESD with GTU tracks from %p (%i)",
-                  fgTracks, fgTracks ? fgTracks->GetEntriesFast() : 0));
+  AliDebug(1, Form("Loading gtu.tracks(%i) to ESD", fgTracks ? fgTracks->GetEntriesFast() : 0));
   if (fgTracks) {
     for (Int_t iTrack = 0; iTrack < fgTracks->GetEntriesFast(); iTrack++) {
       AliESDTrdTrack *trdTrack = (AliESDTrdTrack*) ((*fgTracks)[iTrack]);
@@ -338,29 +299,22 @@ void AliTRDReconstructor::FillESD(TTree* /*digitsTree*/
       AliTRDrawStream::AssignTracklets(trdTrack, trackletIndex, refIndex);
 
       for (Int_t iLayer = 0; iLayer < 6; ++iLayer) {
-       Int_t det = trdTrack->GetSector()*30 + stack*6 + iLayer;
-
-       AliESDTrdTracklet *trkl = refIndex[iLayer] > -1 ? esd->GetTrdTracklet(refIndex[iLayer]) : 0x0;
-       if (trkl) {
-         AliDebug(5, Form("adding tracklet with index %i: 0x%08x",
-                          refIndex[iLayer], trkl->GetTrackletWord()));
-         if (trkl->GetDetector() != det)
-           AliError(Form("inconsistent assignment of tracklet 0x%08x in det %i to track in %i",
-                         trkl->GetTrackletWord(), trkl->GetDetector(), det));
-         trdTrack->AddTrackletReference(trkl, iLayer);
-       }
+        Int_t det = trdTrack->GetSector()*30 + stack*6 + iLayer;
+        AliESDTrdTracklet *trkl = refIndex[iLayer] > -1 ? esd->GetTrdTracklet(refIndex[iLayer]) : 0x0;
+        if (trkl) {
+          AliDebug(5, Form("adding tracklet with index %i: 0x%08x",
+              refIndex[iLayer], trkl->GetTrackletWord()));
+          if (trkl->GetDetector() != det)
+            AliError(Form("inconsistent assignment of tracklet 0x%08x in det %i to track in %i",
+              trkl->GetTrackletWord(), trkl->GetDetector(), det));
+          trdTrack->AddTrackletReference(trkl, iLayer);
+        }
       }
-
       // only add the track when it's complete (including tracklet references)
       esd->AddTrdTrack(trdTrack);
     }
   }
-
   esd->SetTrdTrigger(&fgTriggerFlags);
-
-  // clearing variables for next event
-  fgTracklets = 0x0;
-  fgTracks = 0x0;
 }
 
 //_____________________________________________________________________________
@@ -401,6 +355,7 @@ void AliTRDReconstructor::SetOption(Option_t *opt)
 
     AliWarning(Form("Unknown option flag %s.", sopt.Data()));
   }
+  opar->Delete();
   delete opar;
 }
 
@@ -416,3 +371,65 @@ void AliTRDReconstructor::Options(UInt_t steer)
   }
 }
 
+
+//_____________________________________________________________________________
+TClonesArray* AliTRDReconstructor::GetClusters()
+{
+// Build/ Retrieve cluster array
+  if(!fgClusters){
+    fgClusters = new TClonesArray("AliTRDcluster", Int_t(GetRecoParam()->GetNClusters()));
+    fgClusters->SetOwner();
+    AliInfoGeneral("AliTRDReconstructor", Form("Allocate cluster array @ %p", (void*)fgClusters));
+  }
+  return fgClusters;
+}
+
+//_____________________________________________________________________________
+TClonesArray* AliTRDReconstructor::GetTracklets(const char *trkltype)
+{
+// Build/ Retrieve online tracklets array
+
+  if (trkltype != 0) {
+    if(fgTracklets && (TClass::GetClass(trkltype) != fgTracklets->GetClass())){
+      fgTracklets->Delete();
+      delete fgTracklets;
+    }
+    if (!fgTracklets) {
+      fgTracklets = new TClonesArray(trkltype, 200);
+      fgTracklets->SetOwner(kTRUE);
+      AliInfoGeneral("AliTRDReconstructor", Form("Allocate online tracklets[%s] array @ %p", trkltype, (void*)fgTracklets));
+    }
+  }
+  return fgTracklets;
+}
+
+//_____________________________________________________________________________
+TClonesArray* AliTRDReconstructor::GetTracks()
+{
+// Build/ Retrieve cluster array
+  if(!fgTracks){
+    fgTracks = new TClonesArray("AliESDTrdTrack", 100);
+    fgTracks->SetOwner();
+    AliInfoGeneral("AliTRDReconstructor", Form("Allocate online tracks array @ %p", (void*)fgTracks));
+  }
+  return fgTracks;
+}
+
+//_____________________________________________________________________________
+void AliTRDReconstructor::ResetContainers() const
+{
+// prepare data containers for a new event
+
+  if(fgClusters){
+    AliDebug(1, Form("Removing %5d clusters @ %p", fgClusters->GetEntriesFast(), (void*)fgClusters));
+    fgClusters->Clear();
+  }
+  if(fgTracklets){
+    AliDebug(1, Form("Removing %3d online tracklets @ %p", fgTracklets->GetEntriesFast(), (void*)fgTracklets));
+    fgTracklets->Clear();
+  }
+  if(fgTracks){
+    AliDebug(1, Form("Removing %3d online tracks @ %p", fgTracks->GetEntriesFast(), (void*)fgTracks));
+    fgTracks->Clear();
+  }
+}
index 729ebe9..a71d9b8 100644 (file)
@@ -49,9 +49,9 @@ 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;}
-  static TClonesArray* GetTracklets()            { return fgTracklets;}
-  static TClonesArray* GetTracks()               { return fgTracks;}
+  static TClonesArray* GetClusters();
+  static TClonesArray* GetTracklets(const char *trkltype = "AliTRDtrackletMCM");
+  static TClonesArray* GetTracks();
   static Int_t        GetNTimeBins()             { return fgNTimeBins;}
   Int_t               GetNdEdxSlices() const     { return (Int_t)AliTRDpidUtil::GetNdEdxSlices(GetPIDMethod());}
   AliTRDpidUtil::ETRDPIDMethod       GetPIDMethod() const       { return GetRecoParam()->IsPIDNeuralNetwork() ? AliTRDpidUtil::kNN : AliTRDpidUtil::kLQ;}
@@ -77,14 +77,15 @@ public:
   virtual void        Reconstruct(AliRawReader *rawReader, TTree *clusterTree) const;
   virtual void        Reconstruct(TTree *digitsTree, TTree *clusterTree) const;
 
-  static void         SetClusters(TClonesArray *clusters)  { fgClusters = clusters;} 
-  static void         SetTracklets(TClonesArray *tracklets) { fgTracklets = tracklets;}
-  static void         SetTracks(TClonesArray *tracks) { fgTracks = tracks;}
+ static void         SetClusters(TClonesArray *clusters)  { fgClusters = clusters;}
+ static void         SetTracklets(TClonesArray *tracklets) { fgTracklets = tracklets;}
+ static void         SetTracks(TClonesArray *tracks) { fgTracks = tracks;}
   void               SetOption(Option_t *opt);
 
 private:
   AliTRDReconstructor(const AliTRDReconstructor &r); //Not implemented
   AliTRDReconstructor& operator = (const AliTRDReconstructor&); //Not implemented
+  void                ResetContainers() const;
 
   static Char_t const *fgSteerNames[kNsteer];//! steering names
   static Char_t const *fgSteerFlags[kNsteer];//! steering flags
index c984140..2c5525f 100644 (file)
@@ -232,21 +232,6 @@ AliTRDclusterizer::~AliTRDclusterizer()
   // AliTRDclusterizer destructor
   //
 
-  if (fRecPoints/* && IsClustersOwner()*/){
-    fRecPoints->Delete();
-    delete fRecPoints;
-  }
-
-  if (fTracklets){
-    fTracklets->Delete();
-    delete fTracklets;
-  }
-
-  if (fTracks){
-    fTracks->Delete();
-    delete fTracks;
-  }
-
   if (fDigitsManager) {
     delete fDigitsManager;
     fDigitsManager = NULL;
@@ -266,7 +251,6 @@ AliTRDclusterizer::~AliTRDclusterizer()
     delete fRawStream;
     fRawStream = NULL;
   }
-
 }
 
 //_____________________________________________________________________________
@@ -525,20 +509,20 @@ Bool_t AliTRDclusterizer::ReadTracklets()
   trackletLoader->Load();
   TTree *trackletTree = trackletLoader->Tree();
 
- if (trackletTree) {
-   TBranch *trklbranch = trackletTree->GetBranch("mcmtrklbranch");
-   TClonesArray *trklArray = TrackletsArray("AliTRDtrackletMCM");
-   if (trklbranch && trklArray) {
-     AliTRDtrackletMCM *trkl = 0x0;
-     trklbranch->SetAddress(&trkl);
-     for (Int_t iTracklet = 0; iTracklet < trklbranch->GetEntries(); iTracklet++) {
-       trklbranch->GetEntry(iTracklet);
-       new ((*trklArray)[trklArray->GetEntries()]) AliTRDtrackletMCM(*trkl);
-     }
-     return kTRUE;
-   }
- }
- return kFALSE;
+  if (trackletTree) {
+    TBranch *trklbranch = trackletTree->GetBranch("mcmtrklbranch");
+    TClonesArray *trklArray = TrackletsArray("AliTRDtrackletMCM");
+    if (trklbranch && trklArray) {
+      AliTRDtrackletMCM *trkl = 0x0;
+      trklbranch->SetAddress(&trkl);
+      for (Int_t iTracklet = 0; iTracklet < trklbranch->GetEntries(); iTracklet++) {
+        trklbranch->GetEntry(iTracklet);
+        new ((*trklArray)[trklArray->GetEntries()]) AliTRDtrackletMCM(*trkl);
+      }
+      return kTRUE;
+    }
+  }
+  return kFALSE;
 }
 
 Bool_t AliTRDclusterizer::ReadTracks()
@@ -638,7 +622,10 @@ Bool_t AliTRDclusterizer::MakeClusters()
   
   if(fReconstructor->IsWritingClusters()) WriteClusters(-1);
 
-  AliInfo(Form("Number of found clusters : %d", RecPoints()->GetEntriesFast())); 
+  AliInfo(Form("Found :: clusters[%d] tracklets[%d] tracks[%d]",
+    RecPoints()?RecPoints()->GetEntriesFast():0,
+    TrackletsArray()?TrackletsArray()->GetEntriesFast():0,
+    TracksArray()?TracksArray()->GetEntriesFast():0));
 
   return fReturn;
 
@@ -732,7 +719,10 @@ Bool_t AliTRDclusterizer::Raw2ClustersChamber(AliRawReader *rawReader)
     fRawStream = NULL;
   }
 
-  AliInfo(Form("Number of found clusters : %d", fNoOfClusters)); 
+  AliInfo(Form("Found :: clusters[%d] tracklets[%d] tracks[%d]",
+    RecPoints()?RecPoints()->GetEntriesFast():0,
+    TrackletsArray()?TrackletsArray()->GetEntriesFast():0,
+    TracksArray()?TracksArray()->GetEntriesFast():0));
   return kTRUE;
 
 }
@@ -973,7 +963,7 @@ Bool_t AliTRDclusterizer::IsMaximum(const MaxStruct &Max, UChar_t &padStatus, Fl
   Float_t noiseMiddleThresh = fMinMaxCutSigma*fCalNoiseDetValue*fCalNoiseROC->GetValue(Max.col, Max.row);
   if (Signals[1] <= noiseMiddleThresh) return kFALSE;  
 
-  UChar_t status[3]={
+  Char_t status[3]={
     fCalPadStatusROC->GetStatus(Max.col-1, Max.row)
    ,fCalPadStatusROC->GetStatus(Max.col,   Max.row)
    ,fCalPadStatusROC->GetStatus(Max.col+1, Max.row)
@@ -1068,7 +1058,7 @@ Bool_t AliTRDclusterizer::FivePadCluster(MaxStruct &ThisMax, MaxStruct &Neighbou
 void AliTRDclusterizer::CreateCluster(const MaxStruct &Max)
 {
   //
-  // Creates a cluster at the given position and saves it in fRecPoints
+  // Creates a cluster at the given position and saves it in RecPoints
   //
 
   Int_t nPadCount = 1;
@@ -1463,22 +1453,6 @@ void AliTRDclusterizer::DeConvExp(Short_t *const arr, const Int_t nTime, const I
     for (int k = 0; k < 2; k++) {
       correction += reminder[k] = rates[k] * (reminder[k] + coefficients[k] * result);
     }
-
-  }
-
-}
-
-//_____________________________________________________________________________
-void AliTRDclusterizer::ResetRecPoints() 
-{
-  //
-  // Resets the list of rec points
-  //
-
-  if (fRecPoints) {
-    fRecPoints->Clear();
-    fNoOfClusters = 0;
-    //    delete fRecPoints;
   }
 }
 
@@ -1489,18 +1463,9 @@ TClonesArray *AliTRDclusterizer::RecPoints()
   // Returns the list of rec points
   //
 
-  if (!fRecPoints) {
-    if(!(fRecPoints = AliTRDReconstructor::GetClusters())){
-      // determine number of clusters which has to be allocated
-      Float_t nclusters = fReconstructor->GetRecoParam()->GetNClusters();
-
-      fRecPoints = new TClonesArray("AliTRDcluster", Int_t(nclusters));
-    }
-    //SetClustersOwner(kTRUE);
-    AliTRDReconstructor::SetClusters(0x0);
-  }
+  fRecPoints = AliTRDReconstructor::GetClusters();
+  if (!fRecPoints) AliError("Missing cluster array");
   return fRecPoints;
-
 }
 
 //_____________________________________________________________________________
@@ -1509,17 +1474,8 @@ TClonesArray *AliTRDclusterizer::TrackletsArray(const TString &trkltype)
   //
   // Returns the array of on-line tracklets
   //
-
-  if (trkltype.Length() != 0) {
-    if (!fTracklets) {
-      fTracklets = new TClonesArray(trkltype, 200);
-  }
-    else if (TClass::GetClass(trkltype.Data()) != fTracklets->GetClass()){
-      fTracklets->Delete();
-      delete fTracklets;
-      fTracklets = new TClonesArray(trkltype, 200);
-    }
-  }
+  fTracklets = AliTRDReconstructor::GetTracklets(trkltype.Data());
+  if (!fTracklets) AliError("Missing online tracklets array");
   return fTracklets;
 }
 
@@ -1528,8 +1484,7 @@ TClonesArray* AliTRDclusterizer::TracksArray()
 {
   // return array of GTU tracks (create TClonesArray if necessary)
 
-  if (!fTracks) {
-    fTracks = new TClonesArray("AliESDTrdTrack",100);
-  }
+  fTracks = AliTRDReconstructor::GetTracks();
+  if (!fTracks) AliError("Missing online tracks array");
   return fTracks;
 }
index fe590dd..efb9815 100644 (file)
@@ -91,9 +91,9 @@ class AliTRDclusterizer : public TNamed
   Bool_t   ReadTracks();
 
   Bool_t   WriteClusters(Int_t det);
-  void     ResetRecPoints();
+  void     ResetRecPoints()                { fNoOfClusters = 0;}
   virtual TClonesArray    *RecPoints();
-  virtual TClonesArray    *TrackletsArray(const TString &trkltype = "");
+  virtual TClonesArray    *TrackletsArray(const TString &trkltype = "AliTRDtrackletMCM");
   virtual TClonesArray    *TracksArray();
 
   Bool_t   Raw2Clusters(AliRawReader *rawReader);
index 81fcf7f..6a7e474 100644 (file)
@@ -109,16 +109,6 @@ AliTRDrawData::~AliTRDrawData()
   // Destructor
   //
 
-  if (fTracklets){
-    fTracklets->Delete();
-    delete fTracklets;
-  }
-
-  if (fTracks){
-    fTracks->Delete();
-    delete fTracks;
-  }
-
   delete fMcmSim;
 
 }
@@ -575,8 +565,8 @@ AliTRDdigitsManager *AliTRDrawData::Raw2Digits(AliRawReader *rawReader)
   if (!trklTreeLoader->Tree())
     trklTreeLoader->MakeTree();
 
-  input.SetTrackletArray(TrackletsArray());
-  input.SetTrackArray(TracksArray());
+  input.SetTrackletArray(fTracklets);
+  input.SetTrackArray(fTracks);
 
   // Loop through the digits
   Int_t det    = 0;
@@ -668,23 +658,3 @@ void AliTRDrawData::WriteIntermediateWords(UInt_t* buf, Int_t& nw, Int_t& of, co
     x = ((kNTBin)<<26) | (bcCtr<<10) | (ptCtr<<6) | (ptPhase<<2) | 1;
     if (nw < maxSize) buf[nw++] = x; else of++;
 }
-
-TClonesArray *AliTRDrawData::TrackletsArray()
-{
-  // Returns the array of on-line tracklets
-
-  if (!fTracklets) {
-    fTracklets = new TClonesArray("AliTRDtrackletWord", 200);
-  }
-  return fTracklets;
-}
-
-TClonesArray* AliTRDrawData::TracksArray()
-{
-  // return array of GTU tracks (create TClonesArray if necessary)
-
-  if (!fTracks) {
-    fTracks = new TClonesArray("AliESDTrdTrack",100);
-  }
-  return fTracks;
-}
index 4fa75f0..b0034a3 100644 (file)
@@ -41,10 +41,8 @@ class AliTRDrawData : public TObject {
 
   virtual AliTRDdigitsManager *Raw2Digits(AliRawReader *rawReader);
 
-  virtual TClonesArray    *TrackletsArray();
-  virtual TClonesArray    *TracksArray();
-  void                    SetTrackletsOwner(TClonesArray *trkl = 0x0) { fTracklets = trkl; } // set to own the given array
-  void                    SetTracksOwner(TClonesArray *trk = 0x0) { fTracks = trk; } // set to own the given array
+  void                    SetTracklets(TClonesArray *trkl = NULL) { fTracklets = trkl; } // link the given array
+  void                    SetTracks(TClonesArray *trk = NULL) { fTracks = trk; } // link the given array
 
   UInt_t  GetTriggerFlags(const Int_t sector) const { return fTrgFlags[sector]; }
 
index b6141a6..0cbc79c 100644 (file)
@@ -133,7 +133,7 @@ AliTRDtrackerV1::~AliTRDtrackerV1()
   //
   // Destructor
   //
-  
+
   if(fgRieman) delete fgRieman; fgRieman = NULL;
   if(fgTiltedRieman) delete fgTiltedRieman; fgTiltedRieman = NULL;
   if(fgTiltedRiemanConstrained) delete fgTiltedRiemanConstrained; fgTiltedRiemanConstrained = NULL;
@@ -141,7 +141,8 @@ AliTRDtrackerV1::~AliTRDtrackerV1()
   if(fTracksESD){ fTracksESD->Delete(); delete fTracksESD; }
   if(fTracks) {fTracks->Delete(); delete fTracks;}
   if(fTracklets) {fTracklets->Delete(); delete fTracklets;}
-  if(fClusters) {
+  if(IsClustersOwner() && fClusters) {
+    AliInfo(Form("tracker[%p] removing %d own clusters @ %p", (void*)this, fClusters->GetEntries(), (void*)fClusters));
     fClusters->Delete(); delete fClusters;
   }
   if(fGeom) delete fGeom;
@@ -1337,13 +1338,13 @@ Float_t AliTRDtrackerV1::FitTiltedRieman(AliTRDseedV1 *tracklets, Bool_t sigErro
   covarPolZ.Invert();
 
   // Update the tracklets
-  Double_t x1, dy, dz;
+  Double_t dy, dz;
   Double_t cov[15];
   memset(cov, 0, sizeof(Double_t) * 15);
   for(Int_t iLayer = 0; iLayer < AliTRDtrackerV1::kNPlanes; iLayer++) {
 
     x  = tracklets[iLayer].GetX0();
-    x1 = x - xref;
+//    x1 = x - xref;
     y  = 0;
     z  = 0;
     dy = 0;
@@ -1929,12 +1930,14 @@ Bool_t AliTRDtrackerV1::ReadClusters(TTree *clusterTree)
     return kFALSE;
   }
   branch->SetAddress(&clusterArray); 
-  
+
   if(!fClusters){ 
     Float_t nclusters =  fkRecoParam->GetNClusters();
     if(fkReconstructor->IsHLT()) nclusters /= AliTRDgeometry::kNsector;
     fClusters = new TClonesArray("AliTRDcluster", Int_t(nclusters));
     fClusters->SetOwner(kTRUE);
+    SetClustersOwner();
+    AliInfo(Form("Tracker owning clusters @ %p", (void*)fClusters));
   }
   
   // Loop through all entries in the tree
@@ -1968,27 +1971,26 @@ Int_t AliTRDtrackerV1::LoadClusters(TTree *cTree)
   
   fkRecoParam = fkReconstructor->GetRecoParam(); // load reco param for this event
 
-  if(!fkReconstructor->IsWritingClusters()){ 
-    fClusters = AliTRDReconstructor::GetClusters();
+//  if(!fkReconstructor->IsWritingClusters()) AliInfo(Form("IsWritingClusters[%c]", fkReconstructor->IsWritingClusters()?'y':'n'));
+  if(!(fClusters = AliTRDReconstructor::GetClusters())){
+    AliWarning("Clusters unavailable from TRD reconstructor. Trying reading from tree ...");
   } else {
     if(!ReadClusters(cTree)) {
-      AliError("Problem with reading the clusters !");
+      AliError("Reading clusters from tree failed.");
       return 1;
     }
   }
-  SetClustersOwner();
 
   if(!fClusters || !fClusters->GetEntriesFast()){ 
     AliInfo("No TRD clusters");
     return 1;
-  }
+  } else AliInfo(Form("Using :: clusters[%d] onl.tracklets[%d] onl.tracks[%d]",
+    fClusters?fClusters->GetEntriesFast():0,
+    AliTRDReconstructor::GetTracklets()?AliTRDReconstructor::GetTracklets()->GetEntriesFast():0,
+    AliTRDReconstructor::GetTracks()?AliTRDReconstructor::GetTracks()->GetEntriesFast():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;
 }
 
@@ -2002,17 +2004,14 @@ Int_t AliTRDtrackerV1::LoadClusters(TClonesArray * const clusters)
   if(!clusters || !clusters->GetEntriesFast()){ 
     AliInfo("No TRD clusters");
     return 1;
-  }
+  } else AliInfo(Form("Using :: external.clusters[%d]", clusters->GetEntriesFast()));
+
 
   fClusters = clusters;
-  SetClustersOwner();
 
   fkRecoParam = fkReconstructor->GetRecoParam(); // load reco param for this event
   BuildTrackingContainers();  
 
-  //Int_t ncl  = fClusters->GetEntriesFast();
-  //AliInfo(Form("Clusters %d [%6.2f %% in the active volume]", ncl, 100.*float(nin)/ncl));
-
   return 0;
 }
 
@@ -2061,14 +2060,15 @@ void AliTRDtrackerV1::UnloadClusters()
     fTracklets->Delete();
     if(HasRemoveContainers()){delete fTracklets; fTracklets = NULL;}
   }
-  if(fClusters){ 
-    if(IsClustersOwner()) fClusters->Delete();
-    
-    // save clusters array in the reconstructor for further use.
-    if(!fkReconstructor->IsWritingClusters()){
-      AliTRDReconstructor::SetClusters(fClusters);
-      SetClustersOwner(kFALSE);
-    } else AliTRDReconstructor::SetClusters(NULL);
+  if(fClusters && IsClustersOwner()){
+    AliInfo(Form("tracker[%p] clearing %d own clusters @ %p", (void*)this, fClusters->GetEntries(), (void*)fClusters));
+    fClusters->Delete();
+//     
+//     // save clusters array in the reconstructor for further use.
+//     if(!fkReconstructor->IsWritingClusters()){
+//       AliTRDReconstructor::SetClusters(fClusters);
+//       SetClustersOwner(kFALSE);
+//     } else AliTRDReconstructor::SetClusters(NULL);
   }
 
   for (int i = 0; i < AliTRDgeometry::kNsector; i++) fTrSec[i].Clear();
@@ -2644,7 +2644,7 @@ Int_t AliTRDtrackerV1::MakeSeeds(AliTRDtrackingChamber **stack, AliTRDseedV1 * c
   Double_t chi2[4];
 
   // this should be data member of AliTRDtrack TODO
-  Double_t seedQuality[kMaxTracksStack];
+//  Double_t seedQuality[kMaxTracksStack];
   
   // unpack control parameters
   Int_t config  = ipar[0];
@@ -2868,8 +2868,8 @@ Int_t AliTRDtrackerV1::MakeSeeds(AliTRDtrackingChamber **stack, AliTRDseedV1 * c
         }
         //AliInfo(Form("Passed likelihood %f[%e].", TMath::Log(1.E-9 + like), like));
       
-        // book preliminary results
-        seedQuality[ntracks] = like;
+        // book preliminry results
+        //seedQuality[ntracks] = like;
         fSeedLayer[ntracks]  = config;/*sLayer;*/
       
         // attach clusters to the extrapolation seeds