Redefinition of macro to avoid warnings
[u/mrichter/AliRoot.git] / 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",)
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 }