Correct use of ROOT_INCLUDE_DIR
[u/mrichter/AliRoot.git] / MUON / MUONmapping / AliMpRowSegmentRSpecial.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: AliMpRowSegmentRSpecial.cxx,v 1.7 2006/05/24 13:58:46 ivana Exp $
18 // Category: sector
19
20 //-----------------------------------------------------------------------------
21 // Class AliMpRowSegmentRSpecial
22 // -----------------------------
23 // Class describing a special outer row segment composed of the 
24 // pad rows.
25 // Included in AliRoot: 2003/05/02
26 // Authors: David Guez, Ivana Hrivnacova; IPN Orsay
27 //-----------------------------------------------------------------------------
28
29 #include "AliMpRowSegmentRSpecial.h"
30 #include "AliMpRow.h"
31 #include "AliMpPadRow.h"
32 #include "AliMpVPadRowSegment.h"
33 #include "AliMpMotif.h"
34 #include "AliMpMotifType.h"
35 #include "AliMpMotifMap.h"
36 #include "AliMpMotifPosition.h"
37 #include "AliMpConstants.h"
38
39 #include "AliLog.h"
40
41 #include <Riostream.h>
42 #include <TMath.h>
43
44 using std::endl;
45 /// \cond CLASSIMP
46 ClassImp(AliMpRowSegmentRSpecial)
47 /// \endcond
48
49 //______________________________________________________________________________
50 AliMpRowSegmentRSpecial::AliMpRowSegmentRSpecial(AliMpRow* row, Double_t offsetX)
51   : AliMpVRowSegmentSpecial(row, offsetX)
52 {
53 /// Standard constructor 
54 }
55
56 //______________________________________________________________________________
57 AliMpRowSegmentRSpecial::AliMpRowSegmentRSpecial() 
58   : AliMpVRowSegmentSpecial()
59 {
60 /// Default constructor 
61 }
62
63 //______________________________________________________________________________
64 AliMpRowSegmentRSpecial::~AliMpRowSegmentRSpecial() 
65 {
66 /// Destructor  
67 }
68
69 //
70 // private methods  
71 //
72
73 //______________________________________________________________________________
74 AliMpVPadRowSegment*  
75 AliMpRowSegmentRSpecial::FindMostLeftPadRowSegment(Int_t motifPositionId) const
76 {
77 /// Find the most left pad row segment with this motifPositionId.
78
79   AliMpVPadRowSegment* found = 0;
80
81   for (Int_t i=0; i<GetNofPadRows(); i++) {
82     AliMpPadRow* padRow = GetPadRow(i);    
83
84     for (Int_t j=0; j<padRow->GetNofPadRowSegments(); j++) { 
85       AliMpVPadRowSegment* padRowSegment = padRow->GetPadRowSegment(j);
86
87       if ( padRowSegment->GetMotifPositionId() == motifPositionId &&
88            (!found || padRowSegment->LeftBorderX() < found->LeftBorderX()))
89            
90         found = padRowSegment;  
91     }
92   }
93
94   return found;         
95 }
96
97 //______________________________________________________________________________
98 void AliMpRowSegmentRSpecial::SetGlobalIndicesLow()
99 {
100 /// Set global low indices
101    
102   // Last normal row segment in the row
103   // (preceding this special row segment)
104   AliMpVRowSegment* rowSegment 
105     =  GetRow()->GetRowSegment(GetRow()->GetNofRowSegments()-2);
106     
107   // Set low indices limit to continue indices of the
108   // preceding row segment  
109   Int_t ix = rowSegment->GetHighLimitIx() + 1;
110   Int_t iy = rowSegment->GetLowLimitIy();
111   
112   SetLowIndicesLimit(ix, iy);
113 }
114
115 //
116 // protected methods  
117 //
118
119 //______________________________________________________________________________
120 void AliMpRowSegmentRSpecial::MotifCenterSlow(Int_t motifPositionId,
121                                               Double_t& x, Double_t& y) const
122 {
123 /// Fill the coordinates of the motif specified with
124 /// the given position identifier.                                           \n
125 /// !! Applicable only for motifs that have their most down pad in
126 /// this row segment.
127
128   // Find the first (left, down) pad row segment with this motifPositionId.
129   AliMpVPadRowSegment* downPadRowSegment 
130     = FindPadRowSegment(motifPositionId);
131   AliMpVPadRowSegment* leftPadRowSegment 
132     = FindMostLeftPadRowSegment(motifPositionId);
133   
134   // Check if the motifPositionId is present 
135   if (!downPadRowSegment || !leftPadRowSegment) {
136     AliErrorStream() << "Outside row segment region" << endl;
137     return;
138   }
139
140   // Check if both pad row segments have the same motif 
141   if (downPadRowSegment->GetMotif() != leftPadRowSegment->GetMotif()) {
142     AliFatal("Outside row segment region");
143     return;
144   }
145
146   // Get position of found row segment
147   x = leftPadRowSegment->LeftBorderX();       
148   y = GetRow()->LowBorderY()  ;   
149   
150   for (Int_t i=0; i<downPadRowSegment->GetPadRow()->GetID(); i++)
151     y += GetPadRow(i)->HalfSizeY()*2.;
152     
153   // Add motifs dimensions
154   x += downPadRowSegment->GetMotif()->DimensionX();
155   y += downPadRowSegment->GetMotif()->DimensionY();
156 }
157
158 //
159 // public methods  
160 //
161
162 //______________________________________________________________________________
163 Double_t  AliMpRowSegmentRSpecial::LeftBorderX() const
164 {
165 /// Return the x coordinate of the left row segment border
166 /// in the global coordinate system.
167
168   // The right edge of the last normal segment
169   Double_t sameBorder = GetOffsetX();
170
171   // Consistence check  
172   Double_t leftBorder = DBL_MAX;
173   for (Int_t i=0; i<GetNofPadRows(); i++) {
174     AliMpPadRow* padRow = GetPadRow(i);
175     Double_t border = padRow->GetPadRowSegment(0)->LeftBorderX();
176     if (border < leftBorder) leftBorder =  border;
177   }  
178
179   if (TMath::Abs(sameBorder - leftBorder) > 1.e-04)  {
180     AliErrorStream() << "WrongBorder" << endl;;
181     return sameBorder;
182   }  
183   
184   return leftBorder;
185
186 }
187
188 //______________________________________________________________________________
189 Double_t  AliMpRowSegmentRSpecial::RightBorderX() const
190 {
191 /// Return the x coordinate of the right row segment border
192 /// in the global coordinate system.
193
194   Double_t rightBorder = -DBL_MAX;
195   for (Int_t i=0; i<GetNofPadRows(); i++) {
196     AliMpPadRow* padRow = GetPadRow(i);
197     Double_t border 
198       = padRow->GetPadRowSegment(padRow->GetNofPadRowSegments()-1)
199         ->RightBorderX();
200       
201     if (border > rightBorder) rightBorder =  border;
202   }  
203   
204   return rightBorder;
205 }
206
207 //______________________________________________________________________________
208 Double_t AliMpRowSegmentRSpecial::GetPositionX() const
209 {
210 /// Return the x position of the row segment centre.
211 /// The centre is defined as the centre of the rectangular
212 /// row segment envelope.
213
214   // The right edge of the last normal segment
215   return GetOffsetX()  + GetDimensionX();
216 }
217
218 //______________________________________________________________________________
219 Double_t AliMpRowSegmentRSpecial::GetPositionY() const
220 {
221 /// Return the y position of the row segment centre.
222 /// The centre is defined as the centre of the rectangular
223 /// row segment envelope.
224
225   // The right edge of the last normal segment
226   return GetRow()->GetPositionY();  
227 }
228
229 //______________________________________________________________________________
230 Int_t AliMpRowSegmentRSpecial::SetIndicesToMotifPosition(Int_t i, MpPair_t indices)
231 {
232 /// Set global indices to i-th motif position and returns next index in x.
233
234   // Update low indices limit for this row segment
235   SetGlobalIndicesLow();
236
237   // Check for consistence
238   if ( GetLowLimitIx() != AliMp::PairFirst(indices) ) 
239     AliFatal("Inconsistent indices");
240
241   // Get motif position
242   AliMpMotifPosition* motifPosition
243     = GetRow()->GetMotifMap()->FindMotifPosition(GetMotifPositionId(i));
244     
245   // Set limits only once
246   if ( motifPosition->IsHighLimitValid() ) 
247     return AliMp::PairFirst(indices); 
248
249   // Low limit
250   //
251   Int_t ixl = GetLowLimitIx();
252   Int_t iyl = GetLowLimitIy();
253
254   // Find the most down pad row segment with this motifPositionId.
255   AliMpVPadRowSegment* padRowSegment = FindPadRowSegment(GetMotifPositionId(i));
256   Int_t padRowID = padRowSegment->GetPadRow()->GetID();
257   iyl += padRowID; 
258
259   // Add pads offset of this motif position in the row segment
260   for ( Int_t im=0; im<i; im++ ) {
261     AliMpVPadRowSegment* rs = GetPadRow(padRowID)->GetPadRowSegment(im);
262     if ( rs->GetMotifPositionId() == GetMotifPositionId(i) ) break; 
263     ixl += rs->GetNofPads();
264   }  
265   motifPosition->SetLowIndicesLimit(ixl, iyl);
266
267   // High limit 
268   //     
269   AliMpMotifType* motifType = motifPosition->GetMotif()->GetMotifType();  
270   MpPair_t high 
271     = motifPosition->GetLowIndicesLimit()
272       + AliMp::Pair(motifType->GetNofPadsX()-1, motifType->GetNofPadsY()-1);            
273   motifPosition->SetHighIndicesLimit(high);
274
275   // No increment index needed (this is always the last element)
276   return AliMp::PairFirst(indices);
277 }
278
279 //______________________________________________________________________________
280 void AliMpRowSegmentRSpecial::SetGlobalIndices(AliMpRow* rowBefore)
281 {
282 /// Set indices limits.
283 /// The limits are defined as the limits of the smallest rectangle which
284 /// includes all pads of this special row segment.
285
286   // Get first motif position
287   AliMpMotifPosition* firstMotifPosition
288     = GetRow()->GetMotifMap()->FindMotifPosition(GetMotifPositionId(0));
289     
290   // Low ix
291   Int_t ixl = firstMotifPosition->GetLowLimitIx();
292               // We have to take the motif position limit
293               // as it can overlap over more rows and the indices
294               // of the right border of the precedent normal segment
295               // differ from one row to another  
296
297   // High ix
298   Int_t ixh = ixl + MaxNofPadsInRow() - 1;
299
300   // Low iy
301   Int_t iyl = AliMpConstants::StartPadIndex();
302   if (rowBefore) {
303     //if (constPadSizeDirection == kY) {
304       iyl = rowBefore->GetHighLimitIy()+1;
305     //} 
306     /*
307     else {
308       AliMpVRowSegment* seg = rowBefore->FindRowSegment(ixl);   
309       AliMpMotifPosition* motPos =  rowBefore->FindMotifPosition(seg, ixl);
310       if (!motPos) 
311         Fatal("SetGlobalIndices", "Motif position in rowBefore not found.");
312       iyl = motPos->GetHighLimitIy()+1;
313     }
314     */
315   }  
316
317   // High iy
318   Int_t iyh = iyl + GetNofPadRows() - 1;
319   
320   SetLowIndicesLimit(ixl, iyl);
321   SetHighIndicesLimit(ixh, iyh);
322 }  
323
324