MUON/AliMUONPreClusterFinder.cxx

   1 /**************************************************************************
   2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3 *                                                                        *
   4 * Author: The ALICE Off-line Project.                                    *
   5 * Contributors are mentioned in the code where appropriate.              *
   6 *                                                                        *
   7 * Permission to use, copy, modify and distribute this software and its   *
   8 * documentation strictly for non-commercial purposes is hereby granted   *
   9 * without fee, provided that the above copyright notice appears in all   *
  10 * copies and that both the copyright notice and this permission notice   *
  11 * appear in the supporting documentation. The authors make no claims     *
  12 * about the suitability of this software for any purpose. It is          *
  13 * provided "as is" without express or implied warranty.                  *
  14 **************************************************************************/
  15
  16 // $Id$
  17
  18 #include "AliMUONPreClusterFinder.h"
  19
  20 #include "AliMUONCluster.h"
  21 #include "AliMUONPad.h"
  22 #include "AliMUONVDigit.h"
  23 #include "AliMUONVDigitStore.h"
  24
  25 #include "AliMpArea.h"
  26 #include "AliMpConstants.h"
  27 #include "AliMpVSegmentation.h"
  28
  29 #include "AliLog.h"
  30
  31 #include <Riostream.h>
  32 #include <TClonesArray.h>
  33 #include <TVector2.h>
  34
  35 //-----------------------------------------------------------------------------
  36 /// \class AliMUONPreClusterFinder
  37 ///
  38 /// Implementation of AliMUONVClusterFinder
  39 ///
  40 /// This class simply find adjacent pads to form clusters
  41 ///
  42 /// \author Laurent Aphecetche
  43 //-----------------------------------------------------------------------------
  44
  45 ClassImp(AliMUONPreClusterFinder)
  46
  47 //_____________________________________________________________________________
  48 AliMUONPreClusterFinder::AliMUONPreClusterFinder()
  49 : AliMUONVClusterFinder(),
  50   fClusters("AliMUONCluster"),
  51   fPads(0x0),
  52   fDetElemId(0),
  53   fArea(),
  54   fShouldAbort(kFALSE)
  55 {
  56   /// ctor
  57 }
  58
  59 //_____________________________________________________________________________
  60 AliMUONPreClusterFinder::~AliMUONPreClusterFinder()
  61 {
  62   /// dtor : note we're owner of the clusters, but not of the pads
  63 }
  64
  65 //_____________________________________________________________________________
  66 Bool_t
  67 AliMUONPreClusterFinder::UsePad(const AliMUONPad& pad)
  68 {
  69   /// Add a pad to the list of pads to be considered
  70   if ( pad.DetElemId() != fDetElemId )
  71   {
  72     AliError(Form("Cannot add pad from DE %d to this cluster finder which is "
  73                   "currently dealing with DE %d",pad.DetElemId(),fDetElemId));
  74     return kFALSE;
  75   }
  76
  77   new ((*fPads[pad.Cathode()])[fPads[pad.Cathode()]->GetLast()+1]) AliMUONPad(pad);
  78   // FIXME: should set the ClusterId of that new pad to be -1
  79   return kTRUE;
  80 }
  81
  82 //_____________________________________________________________________________
  83 Bool_t
  84 AliMUONPreClusterFinder::Prepare(Int_t detElemId,
  85                                  TClonesArray* pads[2],
  86                                  const AliMpArea& area)
  87 {
  88   /// Prepare for clustering, by giving access to segmentations and digit lists
  89
  90   fClusters.Clear("C");
  91
  92   fPads = pads;
  93   fDetElemId = detElemId;
  94   fArea = area;
  95
  96   fShouldAbort = kFALSE;
  97
  98   return kTRUE;
  99 }
 100
 101 //_____________________________________________________________________________
 102 void
 103 AliMUONPreClusterFinder::AddPad(AliMUONCluster& cluster, AliMUONPad* pad)
 104 {
 105   /// Add a pad to a cluster
 106
 107   if ( cluster.Multiplicity() > 500 )
 108   {
 109     fShouldAbort = kTRUE;
 110     return;
 111   }
 112
 113   cluster.AddPad(*pad);
 114
 115   Int_t cathode = pad->Cathode();
 116   TClonesArray& padArray = *fPads[cathode];
 117   // WARNING: this Remove method uses the AliMUONPad::IsEqual if that method is
 118   // present (otherwise just compares pointers) : so that one must be correct
 119   // if implemented !
 120   padArray.Remove(pad);
 121  // TObject* o = padArray.Remove(pad);
 122 //  if (!o)
 123 //  {
 124 //    AliFatal("Oups. Could not remove pad from pads to consider. Aborting as anyway "
 125 //             " we'll get an infinite loop. Please check the AliMUONPad::IsEqual method"
 126 //             " as the first suspect for failed remove");
 127 //  }
 128   TIter next(&padArray);
 129   AliMUONPad* testPad;
 130
 131   while ( ( testPad = static_cast<AliMUONPad*>(next())))
 132   {
 133     if ( AliMUONPad::AreNeighbours(*testPad,*pad) )
 134     {
 135       AddPad(cluster,testPad);
 136     }
 137   }
 138 }
 139
 140 //_____________________________________________________________________________
 141 Bool_t
 142 AreOverlapping(const AliMUONPad& pad, const AliMUONCluster& cluster)
 143 {
 144   /// Whether the pad overlaps with the cluster
 145
 146   static Double_t precision = 1E-4; // cm
 147   static TVector2 precisionAdjustment(precision,precision);//-precision,-precision);
 148   for ( Int_t i = 0; i < cluster.Multiplicity(); ++i )
 149   {
 150     AliMUONPad* testPad = cluster.Pad(i);
 151     // Note: we use negative precision numbers, meaning
 152     // the area of the pads will be *increased* by these small numbers
 153     // prior to check the overlap by the AreOverlapping method,
 154     // so pads touching only by the corners will be considered as
 155     // overlapping.
 156     if ( AliMUONPad::AreOverlapping(*testPad,pad,precisionAdjustment) )
 157     {
 158       return kTRUE;
 159     }
 160   }
 161   return kFALSE;
 162 }
 163
 164 //_____________________________________________________________________________
 165 AliMUONPad*
 166 AliMUONPreClusterFinder::GetNextPad(Int_t cathode) const
 167 {
 168 /// Return the next unused pad of given cathode, which is within fArea
 169
 170   TIter next(fPads[cathode]);
 171
 172   if ( !fArea.IsValid() )
 173   {
 174     return static_cast<AliMUONPad*>(next());
 175   }
 176   else
 177   {
 178     AliMUONPad* pad;
 179     while ( ( pad = static_cast<AliMUONPad*>(next())) )
 180     {
 181       AliMpArea padArea(pad->X(), pad->Y(), pad->DX(), pad->DY());
 182
 183       if (fArea.Overlap(padArea)) return pad;
 184
 185     }
 186     return 0x0;
 187   }
 188 }
 189
 190 //_____________________________________________________________________________
 191 AliMUONCluster*
 192 AliMUONPreClusterFinder::NextCluster()
 193 {
 194   /// Builds the next cluster, and returns it.
 195 //  AliCodeTimerAuto("pre-clustering",0)
 196
 197   // Start a new cluster
 198   Int_t id = fClusters.GetLast()+1;
 199   AliMUONCluster* cluster = new (fClusters[id]) AliMUONCluster;
 200   cluster->SetUniqueID(id);
 201
 202   AliMUONPad* pad = GetNextPad(0);
 203
 204   if (!pad) // protection against no pad in first cathode, which might happen
 205   {
 206     // try other cathode
 207     pad = GetNextPad(1);
 208     if (!pad)
 209     {
 210       // we are done.
 211       return 0x0;
 212     }
 213     // Builds (recursively) a cluster on second cathode only
 214     AddPad(*cluster,pad);
 215   }
 216   else
 217   {
 218     // Builds (recursively) a cluster on first cathode only
 219     AddPad(*cluster,pad);
 220
 221     if ( !ShouldAbort() )
 222     {
 223       // On the 2nd cathode, only add pads overlapping with the current cluster
 224       TClonesArray& padArray = *fPads[1];
 225       TIter next(&padArray);
 226       AliMUONPad* testPad;
 227
 228       while ( ( testPad = static_cast<AliMUONPad*>(next())) && !ShouldAbort() )
 229       {
 230         if (AreOverlapping(*testPad,*cluster) )
 231         {
 232           AddPad(*cluster,testPad);
 233         }
 234       }
 235     }
 236   }
 237
 238   if ( ShouldAbort() )
 239   {
 240     AliError(Form("Aborting clustering of DE %d because we've got too many pads",fDetElemId));
 241     fClusters.Remove(cluster);
 242     fClusters.Compress();
 243     return 0x0;
 244   }
 245
 246   if ( cluster->Multiplicity() <= 1 )
 247   {
 248     if ( cluster->Multiplicity() == 0 )
 249     {
 250       // no pad is suspicious
 251       AliWarning("Got an empty cluster...");
 252     }
 253     // else only 1 pad (not suspicious, but kind of useless, probably noise)
 254     // so we remove it from our list
 255     fClusters.Remove(cluster);
 256     fClusters.Compress();
 257     // then proceed further
 258     return NextCluster();
 259   }
 260
 261   return cluster;
 262 }