New macro to keep track of timing performances of the segmentation methods (Laurent)
[u/mrichter/AliRoot.git] / MUON / mapping / AliMpVSegmentation.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 // $MpId: AliMpVSegmentation.cxx,v 1.5 2006/05/24 13:58:29 ivana Exp $
18 // Category: basic
19
20 //-----------------------------------------------------------------------------
21 // Class AliMpVSegmentation
22 // ------------------------
23 // The abstract base class for the segmentation.
24 // Provides methods related to pads:
25 // conversion between pad indices, pad location, pad position;
26 // finding pad neighbour.
27 //
28 // Included in AliRoot: 2003/05/02
29 // Authors: David Guez, Ivana Hrivnacova; IPN Orsay
30 //         Laurent Aphecetche, SUBATECH
31 //-----------------------------------------------------------------------------
32
33
34 #include "AliMpVSegmentation.h"
35 #include "AliMpArea.h"
36 #include "AliMpConstants.h"
37
38 #include "AliLog.h"
39
40 #include "TVector2.h"
41 #include "TObjArray.h"
42
43 /// \cond CLASSIMP
44 ClassImp(AliMpVSegmentation)
45 /// \endcond
46
47 //_____________________________________________________________________________
48 AliMpVSegmentation::AliMpVSegmentation() 
49   : TObject()
50 {
51 /// Default constructor
52 }
53
54 //_____________________________________________________________________________
55 AliMpVSegmentation::~AliMpVSegmentation() 
56 {
57 /// Destructor 
58 }
59
60 //_____________________________________________________________________________
61 AliMpPadPair AliMpVSegmentation::FindPads(const TVector2& position1, 
62                                           const TVector2& position2) const
63 {
64 /// Return a pair of pads with specified position.
65 /// If both pads are identical, the second pad in pair is set to invalid.
66
67   AliMpPad pad1 = PadByPosition(position1, false);
68   AliMpPad pad2 = PadByPosition(position2, false);
69                                      
70   if (pad1 == pad2) pad2 = AliMpPad::Invalid();                              
71
72   return AliMpPadPair(pad1, pad2);
73 }  
74
75 //_____________________________________________________________________________
76 Int_t 
77 AliMpVSegmentation::GetNeighbours(const AliMpPad& pad, 
78                                   TObjArray& neighbours,
79                                   Bool_t includeSelf,
80                                   Bool_t includeVoid) const
81 {
82   /// Returns the list of neighbours of pad
83   static TVector2* testPositions(0x0);
84   static const Int_t kNofTestPositions(11);
85   static const Double_t kEpsilon(AliMpConstants::LengthTolerance()*2.0);
86   static Int_t centerIndex(-1);
87   
88   // testPositions are the positions (L,T,R,B) relative to pad's center (O)
89   // were we'll try to get a neighbouring pad, by getting a little
90   // bit outside the pad itself.
91   // Note that it's not symmetric as we assume that pad density
92   // can always decrease when going from left to right (or from bottom to top)
93   //
94   // L--T--R
95   // |     |
96   // L     |
97   // |  O  R
98   // L     |
99   // |     |
100   // L-B-B-R
101   //
102   // The order in which we actually test the positions has some importance,
103   // i.e. when using this information to compute status map later on. Here's
104   // the sequence :
105   //
106   // 4-- 5-- 6
107   // |       |
108   // 3       |
109   // |   0   7
110   // 2       |
111   // |       |
112   // 1-10- 9-8
113   
114   neighbours.Delete();
115   neighbours.SetOwner(kTRUE);
116   
117   if (!pad.IsValid()) return 0;
118   
119   if (!testPositions)
120   {
121     testPositions = new TVector2[kNofTestPositions];
122     Int_t n(0); 
123     // starting center
124     centerIndex = 0;
125     testPositions[n++] = TVector2(0,0); // O (pad center)
126     // then left column (L), starting from bottom
127     testPositions[n++] = TVector2(-1,-1); // 1
128     testPositions[n++] = TVector2(-1,-1/3.0); // 2 
129     testPositions[n++] = TVector2(-1,1/3.0); // 3
130     testPositions[n++] = TVector2(-1,1); // 4
131     // top (T)
132     testPositions[n++] = TVector2(0,1); // 5
133     // right column (R), starting from top
134     testPositions[n++] = TVector2(1,1); // 6
135     testPositions[n++] = TVector2(1,0); // 7
136     testPositions[n++] = TVector2(1,-1); // 8
137     // bottom (B), starting from right
138     testPositions[n++] = TVector2(1/3.0,-1); // 9 
139     testPositions[n++] = TVector2(-1/3.0,-1); // 10
140     // pad center
141     if ( n != kNofTestPositions ) {
142       AliError("Test on number of test positions failed.");
143     }  
144   }
145   
146   Int_t n(0);
147   
148   AliMpPad previous(AliMpPad::Invalid());
149   
150   for ( Int_t i = 0; i < kNofTestPositions; ++i ) 
151   {
152     if ( i == centerIndex && !includeSelf )
153     {
154       if ( includeVoid ) 
155       {
156         previous = AliMpPad::Invalid();
157         neighbours.Add(new AliMpPad(previous));
158         ++n;
159       }
160       continue;
161     }
162     
163     TVector2 shift = testPositions[i];
164     TVector2 pos = pad.Position();
165     pos += TVector2((pad.Dimensions().X()+kEpsilon)*shift.X(),
166                     (pad.Dimensions().Y()+kEpsilon)*shift.Y());
167
168     
169     AliMpPad p = PadByPosition(pos,kFALSE);
170     
171     if ( !p.IsValid() && !includeVoid ) continue;
172     
173     if ( p != previous || !previous.IsValid() ) 
174     {
175       previous = p;
176       neighbours.Add(new AliMpPad(p));
177       ++n;
178     }
179   }
180   return n;
181 }
182
183 //
184 // public methods
185 //
186
187 //_____________________________________________________________________________
188 AliMpPadPair AliMpVSegmentation::PadsUp(const AliMpPad& pad) const
189 {
190 /// Return a pair of pads neighbouring up to the specified pad.
191 /// If there is only one neighbouring pad,
192 /// the second pad in pair is invalid.
193
194   TVector2 position1 
195     = pad.Position()+ TVector2((-1.)*AliMpConstants::LengthStep(), 
196                                pad.Dimensions().Y()+ AliMpConstants::LengthStep());
197   TVector2 position2 
198     = pad.Position()+ TVector2(AliMpConstants::LengthStep(), 
199                                pad.Dimensions().Y()+ AliMpConstants::LengthStep());
200                                
201   return FindPads(position1, position2);
202 }
203
204 //_____________________________________________________________________________
205 AliMpPadPair AliMpVSegmentation::PadsDown(const AliMpPad& pad) const
206 {
207 /// Return a pair of pads neighbouring down to the specified pad.
208 /// If there is only one neighbouring pad,
209 /// the second pad in pair is invalid.
210
211   TVector2 position1 
212     = pad.Position()- TVector2(AliMpConstants::LengthStep(), 
213                                pad.Dimensions().Y()+ AliMpConstants::LengthStep());
214
215   TVector2 position2
216     = pad.Position()- TVector2((-1.)*AliMpConstants::LengthStep(), 
217                                pad.Dimensions().Y()+ AliMpConstants::LengthStep());
218                                      
219   return FindPads(position1, position2);
220 }
221
222 //_____________________________________________________________________________
223 AliMpPadPair AliMpVSegmentation::PadsLeft(const AliMpPad& pad) const
224 {
225 /// Return a pair of pads neighbouring left to the specified pad.
226 /// If there is only one neighbouring pad,
227 /// the second in pair is invalid.
228
229   TVector2 position1 
230     = pad.Position() - TVector2(pad.Dimensions().X() + AliMpConstants::LengthStep(),
231                                 AliMpConstants::LengthStep()); 
232   TVector2 position2
233     = pad.Position() - TVector2(pad.Dimensions().X() + AliMpConstants::LengthStep(),
234                                 (-1.)*AliMpConstants::LengthStep()); 
235
236   return FindPads(position1, position2);
237 }
238
239 //_____________________________________________________________________________
240 AliMpPadPair AliMpVSegmentation::PadsRight(const AliMpPad& pad) const
241 {
242 /// Return a pair of pads neighbouring right to the specified pad.
243 /// If there is only one neighbouring pad,
244 /// the second in pair is invalid.
245
246   TVector2 position1 
247     = pad.Position() + TVector2(pad.Dimensions().X() + AliMpConstants::LengthStep(),
248                                 (-1.)*AliMpConstants::LengthStep()); 
249   TVector2 position2
250     = pad.Position() + TVector2(pad.Dimensions().X() + AliMpConstants::LengthStep(),
251                                 AliMpConstants::LengthStep()); 
252                                      
253   return FindPads(position1, position2);
254 }
255
256 //_____________________________________________________________________________
257 Bool_t 
258 AliMpVSegmentation::HasPadByIndices(const AliMpIntPair& indices) const
259 {
260   /// Default implementation. Must be overwritten if can be made more
261   /// efficient in the child class
262   
263   return (PadByIndices(indices,kFALSE) != AliMpPad::Invalid());
264 }
265
266 //_____________________________________________________________________________
267 Bool_t 
268 AliMpVSegmentation::HasPadByLocation(const AliMpIntPair& location) const
269 {
270   /// Default implementation. Must be overwritten if can be made more
271   /// efficient in the child class
272   
273   return (PadByLocation(location,kFALSE) != AliMpPad::Invalid());
274 }
275
276 //_____________________________________________________________________________
277 Bool_t 
278 AliMpVSegmentation::HasMotifPosition(Int_t manuId) const
279 {
280   /// Default implementation to know if we hold a given manu
281   return ( MotifPosition(manuId) != 0x0 );
282 }
283
284