Implemented a new version of cluster (with its store and iterator):
[u/mrichter/AliRoot.git] / MUON / AliMUONPreClusterFinder.cxx
index ce8cfca..7be9d56 100644 (file)
 #include "AliMpArea.h"
 #include "TVector2.h"
 #include "AliMUONPad.h"
-#include "AliMUONDigit.h"
+#include "AliMUONVDigit.h"
+#include "AliMUONVDigitStore.h"
+//#include "AliCodeTimer.h"
 
+//-----------------------------------------------------------------------------
 /// \class AliMUONPreClusterFinder
 ///
 /// Implementation of AliMUONVClusterFinder
@@ -33,6 +36,7 @@
 /// This class simply find adjacent pads to form clusters
 ///
 /// \author Laurent Aphecetche
+//-----------------------------------------------------------------------------
 
 ClassImp(AliMUONPreClusterFinder)
 
@@ -41,7 +45,6 @@ AliMUONPreClusterFinder::AliMUONPreClusterFinder()
 : AliMUONVClusterFinder(),
   fClusters(0x0),
   fSegmentations(0x0),
-  fDigits(0x0),
   fDetElemId(0)
 {
     /// ctor
@@ -83,13 +86,12 @@ AliMUONPreClusterFinder::UsePad(const AliMUONPad& pad)
 //_____________________________________________________________________________
 Bool_t
 AliMUONPreClusterFinder::Prepare(const AliMpVSegmentation* segmentations[2],
-                                 TClonesArray* digits[2]) 
+                                 const AliMUONVDigitStore& digitStore)
 // FIXME : add area on which to look for clusters here.
 {
   /// Prepare for clustering, by giving access to segmentations and digit lists
   
   fSegmentations = segmentations;
-  fDigits = digits;
   
   delete fClusters;
   fClusters = new TClonesArray("AliMUONCluster");
@@ -101,46 +103,43 @@ AliMUONPreClusterFinder::Prepare(const AliMpVSegmentation* segmentations[2],
   
   fDetElemId = -1;
   
-  // Converts digits into pads
-  for ( Int_t cathode = 0; cathode < 2; ++cathode )
+  TIter next(digitStore.CreateIterator());
+  AliMUONVDigit* d;
+  
+  while ( ( d = static_cast<AliMUONVDigit*>(next()) ) )
   {
-    if ( !digits[cathode] ) continue;
-
-    AliMUONDigit* d;
-    TIter next(digits[cathode]);
-    while ( ( d = static_cast<AliMUONDigit*>(next())))
+    Int_t ix = d->PadX();
+    Int_t iy = d->PadY();
+    Int_t cathode = d->Cathode();
+    AliMpPad pad = fSegmentations[cathode]->PadByIndices(AliMpIntPair(ix,iy));
+    TClonesArray& padArray = *(fPads[cathode]);
+    if ( fDetElemId == -1 ) 
     {
-      Int_t ix = d->PadX();
-      Int_t iy = d->PadY();
-      AliMpPad pad = fSegmentations[cathode]->PadByIndices(AliMpIntPair(ix,iy));
-      TClonesArray& padArray = *(fPads[cathode]);
-      if ( fDetElemId == -1 ) 
-      {
-        fDetElemId = d->DetElemId();
-      }
-      else
+      fDetElemId = d->DetElemId();
+    }
+    else
+    {
+      if ( d->DetElemId() != fDetElemId ) 
       {
-        if ( d->DetElemId() != fDetElemId ) 
-        {
-          AliError("Something is seriously wrong with DE. Aborting clustering");
-          return kFALSE;
-        }
+        AliError("Something is seriously wrong with DE. Aborting clustering");
+        return kFALSE;
       }
-      
-      AliMUONPad mpad(fDetElemId,cathode,
-                      ix,iy,pad.Position().X(),pad.Position().Y(),
-                      pad.Dimensions().X(),pad.Dimensions().Y(),
-                      d->Signal());
-      if ( d->IsSaturated() ) mpad.SetSaturated(kTRUE); 
-      new (padArray[padArray.GetLast()+1]) AliMUONPad(mpad);      
     }
+    
+    AliMUONPad mpad(fDetElemId,cathode,
+                    ix,iy,pad.Position().X(),pad.Position().Y(),
+                    pad.Dimensions().X(),pad.Dimensions().Y(),
+                    d->Charge());
+    if ( d->IsSaturated() ) mpad.SetSaturated(kTRUE);
+    mpad.SetUniqueID(d->GetUniqueID());
+    new (padArray[padArray.GetLast()+1]) AliMUONPad(mpad);      
   }
   if ( fPads[0]->GetLast() < 0 && fPads[1]->GetLast() < 0 )
   {
     // no pad at all, nothing to do...
     return kFALSE;
   }
-
+  
   return kTRUE;
 }
 
@@ -153,11 +152,20 @@ AliMUONPreClusterFinder::AddPad(AliMUONCluster& cluster, AliMUONPad* pad)
   
   Int_t cathode = pad->Cathode();
   TClonesArray& padArray = *fPads[cathode];
+  // WARNING: this Remove method uses the AliMUONPad::IsEqual if that method is
+  // present (otherwise just compares pointers) : so that one must be correct
+  // if implemented !
   padArray.Remove(pad);
-  padArray.Compress();
+ // TObject* o = padArray.Remove(pad); 
+//  if (!o)
+//  {
+//    AliFatal("Oups. Could not remove pad from pads to consider. Aborting as anyway "
+//             " we'll get an infinite loop. Please check the AliMUONPad::IsEqual method"
+//             " as the first suspect for failed remove");
+//  }  
   TIter next(&padArray);
   AliMUONPad* testPad;
-  
+
   while ( ( testPad = static_cast<AliMUONPad*>(next())))
   {
     if ( AliMUONPad::AreNeighbours(*testPad,*pad) )
@@ -196,18 +204,21 @@ AliMUONCluster*
 AliMUONPreClusterFinder::NextCluster()
 {
   /// Builds the next cluster, and returns it.
+//  AliCodeTimerAuto("pre-clustering")
   
   // Start a new cluster
   Int_t id = fClusters->GetLast()+1;
   AliMUONCluster* cluster = new ((*fClusters)[id]) AliMUONCluster;
   cluster->SetUniqueID(id);
   
-  AliMUONPad* pad = static_cast<AliMUONPad*>(fPads[0]->First());
+  TIter next(fPads[0]);
+  AliMUONPad* pad = static_cast<AliMUONPad*>(next());
   
   if (!pad) // protection against no pad in first cathode, which might happen
   {
     // try other cathode
-    pad = static_cast<AliMUONPad*>(fPads[1]->First());
+    TIter next(fPads[1]);
+    pad = static_cast<AliMUONPad*>(next());
     if (!pad) 
     {
       // we are done.