Commenting out StdoutToAliDebug which is, with the current AliLog
[u/mrichter/AliRoot.git] / MUON / mapping / AliMpSector.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: AliMpSector.cxx,v 1.14 2006/05/24 13:58:46 ivana Exp $
18 // Category: sector
19 //
20 // Class AliMpSector
21 // -----------------
22 // Class describing the sector of the MUON chamber of station 1.
23 // Included in AliRoot: 2003/05/02
24 // Authors: David Guez, Ivana Hrivnacova; IPN Orsay
25
26 #include "AliMpSector.h"
27 #include "AliMpSectorPadIterator.h"
28 #include "AliMpZone.h"
29 #include "AliMpRow.h"
30 #include "AliMpVRowSegment.h"
31 #include "AliMpVMotif.h"
32 #include "AliMpMotifMap.h"
33 #include "AliMpIntPair.h"
34 #include "AliMpConstants.h"
35
36 #include "AliLog.h"
37
38 #include <Riostream.h>
39
40 /// \cond CLASSIMP
41 ClassImp(AliMpSector)
42 /// \endcond
43
44 //_____________________________________________________________________________
45 AliMpSector::AliMpSector(const TString& id, Int_t nofZones, Int_t nofRows, 
46                          AliMp::Direction direction, const TVector2& offset) 
47   : TNamed("Sector", ""),
48     fID(id),
49     fOffset(offset),
50     fZones(),
51     fRows(),
52     fMotifMap(0),
53     fDirection(direction),
54     fMinPadDimensions(TVector2(1.e6, 1.e6)),
55     fMaxPadDimensions(),
56     fMaxPadIndices(AliMpIntPair::Invalid()),
57     fNofPads(0)
58 {
59 /// Standard constructor
60
61   AliDebugStream(1) << "this = " << this << endl;
62
63   fMotifMap = new AliMpMotifMap(true);
64   //fMotifMap = new AliMpMotifMap();
65
66 #ifdef WITH_STL
67   for (Int_t izone = 0; izone<nofZones; izone++) 
68     fZones.push_back(new AliMpZone(izone+1));
69     
70   for (Int_t irow = 0; irow<nofRows; irow++) 
71     fRows.push_back(new AliMpRow(irow, fMotifMap));
72 #endif
73
74 #ifdef WITH_ROOT
75   for (Int_t izone = 0; izone<nofZones; izone++) 
76     fZones.Add(new AliMpZone(izone+1));
77     
78   for (Int_t irow = 0; irow<nofRows; irow++) 
79     fRows.Add(new AliMpRow(irow, fMotifMap));
80 #endif
81 }
82
83 //_____________________________________________________________________________
84 AliMpSector::AliMpSector() 
85   : TNamed(),
86     fID(""),    
87     fOffset(TVector2(0., 0.)),
88     fZones(),
89     fRows(),
90     fMotifMap(0),
91     fDirection(AliMp::kX),
92     fMinPadDimensions(TVector2(0., 0.)),
93     fMaxPadDimensions(),
94     fMaxPadIndices(AliMpIntPair::Invalid()),
95     fNofPads(0)
96 {
97 /// Default constructor
98
99   AliDebugStream(1) << "this = " << this << endl;
100 }
101
102 //_____________________________________________________________________________
103 AliMpSector::~AliMpSector() 
104 {
105 /// Destructor 
106
107   AliDebugStream(1) << "this = " << this << endl;
108
109   // deletes 
110   for (Int_t izone = 0; izone<GetNofZones(); izone++) 
111     delete fZones[izone];
112     
113   for (Int_t irow = 0; irow<GetNofRows(); irow++) 
114     delete fRows[irow];
115
116   delete fMotifMap;
117 }
118
119 //
120 // private methods
121 //
122
123 //_____________________________________________________________________________
124 AliMpVPadIterator* AliMpSector::CreateIterator() const
125 {
126 /// Create sector pad iterator
127
128   return new AliMpSectorPadIterator(this);
129 }
130
131
132 //_____________________________________________________________________________
133 AliMpVRowSegment* AliMpSector::FindRowSegment(const TVector2& position) const
134 {
135 /// Find the row segment in the specified position.                         \n
136 /// Return if no motif is found.
137   
138   // Find row
139   AliMpRow* row = FindRow(position);
140   
141   if (!row) return 0;
142
143   // Find the row segment and return its motif
144   AliMpVRowSegment* rowSegment = row->FindRowSegment(position.X());
145   
146   return rowSegment;
147 }
148
149 //_____________________________________________________________________________
150 void  AliMpSector::SetRowOffsets()
151 {
152 /// For each row check consitency of the row segments
153 /// and calculate the row offset.
154
155   Double_t offset = fOffset.Y();
156   
157   for (Int_t irow=0; irow<GetNofRows(); irow++)
158     offset = GetRow(irow)->SetOffsetY(offset);    
159 }
160
161 //_____________________________________________________________________________
162 void  AliMpSector::SetMotifPositions()
163 {
164 /// Create motif positions objects and fills them in the motif map.
165
166   for (Int_t i=0; i<GetNofRows(); i++)
167     GetRow(i)->SetMotifPositions();
168 }
169
170 //_____________________________________________________________________________
171 void  AliMpSector::SetGlobalIndices()
172 {
173 /// Set the indices limits to all indexed elements
174 /// (row, row segment, motif positions).
175
176   AliMpIntPair indices(0,0); 
177   AliMpRow* rowBefore=0;
178   for (Int_t i=0; i<GetNofRows(); i++) {
179     GetRow(i)->SetGlobalIndices(fDirection, rowBefore);
180     rowBefore = GetRow(i);
181   }
182 }
183
184 //_____________________________________________________________________________
185 void  AliMpSector::SetMinMaxPadDimensions()
186 {
187 /// Set the minimal pad dimensions.
188
189   for (Int_t i=1; i<GetNofZones()+1; i++) {
190     TVector2 padDimensions = GetZone(i)->GetPadDimensions();
191     
192     if ( fDirection == AliMp::kX &&  
193          padDimensions.Y() > 0. && padDimensions.Y() < fMinPadDimensions.Y() ||
194          fDirection == AliMp::kY && 
195          padDimensions.X() > 0. && padDimensions.X() < fMinPadDimensions.X())
196       
197       fMinPadDimensions = padDimensions;
198
199     if ( fDirection == AliMp::kX &&  
200          padDimensions.Y() > 0. && padDimensions.Y() > fMaxPadDimensions.Y() ||
201          fDirection == AliMp::kY && 
202          padDimensions.X() > 0. && padDimensions.X() > fMinPadDimensions.X())
203       
204       fMaxPadDimensions = padDimensions;
205   }
206 }
207
208 //_____________________________________________________________________________
209 void  AliMpSector::SetMaxPadIndices()
210 {
211 /// Set maximum pad indices in x, y
212
213   if ( fMaxPadIndices != AliMpIntPair::Invalid() ) return;
214   
215   Int_t maxIndexInX = 0;
216   Int_t maxIndexInY = 0;
217   for (Int_t i=0; i<GetNofRows(); i++) {
218
219     Int_t ixh = GetRow(i)->GetHighIndicesLimit().GetFirst();
220     if ( ixh > maxIndexInX ) maxIndexInX = ixh;
221
222     Int_t iyh = GetRow(i)->GetHighIndicesLimit().GetSecond();
223     if ( iyh > maxIndexInY ) maxIndexInY = iyh;
224   }  
225   
226   fMaxPadIndices = AliMpIntPair(maxIndexInX, maxIndexInY);
227 }
228
229
230 //_____________________________________________________________________________
231 void  AliMpSector::SetNofPads()
232 {
233 /// Set the total number of pads
234
235   fNofPads = fMotifMap->CalculateNofPads();
236 }
237
238 //
239 // public methods
240 //
241
242 //_____________________________________________________________________________
243 void  AliMpSector::SetRowSegmentOffsets()
244 {
245 /// For all rows set the offset to all row segments.
246
247   for (Int_t irow=0; irow<GetNofRows(); irow++)
248     GetRow(irow)->SetRowSegmentOffsets(fOffset);    
249 }
250
251 //_____________________________________________________________________________
252 void AliMpSector::Initialize() 
253 {
254 /// Make needed settings after sector is read from
255 /// data files.
256
257   SetRowOffsets();
258   SetMotifPositions();
259   SetGlobalIndices();
260   SetMinMaxPadDimensions();
261   SetMaxPadIndices();
262   SetNofPads();
263 }  
264
265 //_____________________________________________________________________________
266 void AliMpSector::PrintGeometry()  const
267 {
268 /// Print the positions of rows, rows segments
269
270   for (Int_t i=0; i<GetNofRows(); i++) {
271     AliMpRow* row = GetRow(i);
272     
273     cout << "ROW " << row->GetID() 
274          << "  center Y " << row->Position().Y() << endl;
275
276     for (Int_t j=0; j<row->GetNofRowSegments(); j++) {
277        AliMpVRowSegment* rowSegment = row->GetRowSegment(j);
278         
279        cout << "   ROW Segment " << j 
280             << "  borders " 
281             << rowSegment->LeftBorderX() << "  "
282             << rowSegment->RightBorderX()
283             << "  x-size " 
284             << 2*rowSegment->Dimensions().X() << "  "
285             << endl;
286     }
287   }
288 }     
289              
290
291 //_____________________________________________________________________________
292 AliMpRow* AliMpSector::FindRow(const TVector2& position) const
293 {
294 /// Find the row for the specified y position.                              \n
295 /// If y is on border the lowest row is returned.
296   
297   Double_t y = position.Y();
298   
299 #ifdef WITH_STL
300   for (Int_t i=0; i<GetNofRows(); i++) {
301     if ( y >= fRows[i]->LowBorderY() && y <= fRows[i]->UpperBorderY())
302       return fRows[i];
303   }    
304 #endif
305
306 #ifdef WITH_ROOT
307   for (Int_t i=0; i<GetNofRows(); i++) {
308     if ( y >= ((AliMpRow*)fRows[i])->LowBorderY() && 
309          y <= ((AliMpRow*)fRows[i])->UpperBorderY())
310       return (AliMpRow*)fRows[i];
311   }    
312 #endif
313   
314   return 0;
315 }
316
317 //_____________________________________________________________________________
318 AliMpVMotif* AliMpSector::FindMotif(const TVector2& position) const
319 {
320 /// Find the motif in the specified position.                               \n
321 /// Return 0 if no motif is found.
322   
323   // Find the row segment
324   AliMpVRowSegment* rowSegment = FindRowSegment(position);
325   
326   if (!rowSegment) return 0;
327   
328   // Find motif
329   return rowSegment->FindMotif(position);  
330 }
331 //_____________________________________________________________________________
332 Int_t AliMpSector::FindMotifPositionId(const TVector2& position) const
333 {
334 /// Find the motif position ID in the specified position.                   \n
335 /// Return 0 if no motif is found.
336  
337   // Find the row segment
338   AliMpVRowSegment* rowSegment = FindRowSegment(position);
339   
340   if (!rowSegment) return 0;
341     
342   // Find motif position ID
343   return rowSegment->FindMotifPositionId(position);  
344 }
345
346 //_____________________________________________________________________________
347 AliMpRow* AliMpSector::FindRow(Int_t motifPositionId) const
348 {
349 /// Find the row with the the specified motif position.                     \n
350 /// Return 0 if no row is found.
351
352   AliMpVRowSegment* segment = FindRowSegment(motifPositionId);
353   
354   if (segment) return segment->GetRow();
355   
356   return 0;  
357 }
358
359 //_____________________________________________________________________________
360 AliMpVRowSegment* AliMpSector::FindRowSegment(Int_t motifPositionId) const
361 {
362 /// Find the row segment with the the specified motif position.            \n
363 /// Return 0 if no row segment is found.
364
365   for (Int_t irow=0; irow<GetNofRows(); irow++) {
366
367 #ifdef WITH_STL
368     AliMpRow* row = fRows[irow];
369 #endif
370 #ifdef WITH_ROOT
371     AliMpRow* row = (AliMpRow*)fRows[irow];
372 #endif
373    
374     for (Int_t iseg=0; iseg<row->GetNofRowSegments(); iseg++) {
375       AliMpVRowSegment* segment = row->GetRowSegment(iseg); 
376       if (segment->HasMotifPosition(motifPositionId)) return segment;
377     }
378   }
379   
380   return 0;    
381 }
382
383 //_____________________________________________________________________________
384 TVector2  AliMpSector::FindPosition(Int_t motifPositionId) const
385 {
386 /// Find the position of the motif specified by its position Id.            \n
387 /// Return 0 if no row segment is found.
388
389   AliMpVRowSegment* segment = FindRowSegment(motifPositionId);
390
391   if (!segment) {
392     AliWarningStream() << "Given motifPositionId not found." << endl;
393     return TVector2();
394   }   
395
396   return segment->MotifCenter(motifPositionId);
397 }
398    
399 //_____________________________________________________________________________
400 AliMpZone*  AliMpSector::FindZone(const TVector2& padDimensions) const
401 {
402 /// Find the zone with specified padDimensions.
403
404   for (Int_t i=0; i<GetNofZones(); i++) {
405     AliMpZone* zone = GetZone(i+1);
406     if (AliMpConstants::IsEqual(padDimensions, zone->GetPadDimensions())) 
407       return zone;
408   }
409   
410   // Return 0 if not found
411   return 0;      
412 }
413
414 //_____________________________________________________________________________
415 TVector2 AliMpSector::Position() const
416 {
417 /// Return the sector offset.
418
419   return fOffset;
420 }  
421
422
423 //_____________________________________________________________________________
424 TVector2 AliMpSector::Dimensions() const
425 {
426 /// Return the maximum halflengths in x, y.
427
428   Double_t x = 0.;
429   Double_t y = 0.;
430   for (Int_t i=0; i<GetNofRows(); i++) {
431
432 #ifdef WITH_STL
433     // take the largest x row dimension
434     if (fRows[i]->Dimensions().X() > x) 
435       x = fRows[i]->Dimensions().X();
436       
437     // add all rows y dimensions  
438     y += fRows[i]->Dimensions().Y();
439 #endif
440
441 #ifdef WITH_ROOT
442     // take the largest x row dimension
443     if ( ((AliMpRow*)fRows[i])->Dimensions().X() > x) 
444       x = ((AliMpRow*)fRows[i])->Dimensions().X();
445       
446     // add all rows y dimensions  
447     y += ((AliMpRow*)fRows[i])->Dimensions().Y();
448 #endif
449   }
450   
451   return TVector2(x, y);  
452 }  
453
454 //_____________________________________________________________________________
455 Int_t AliMpSector::GetNofZones() const
456 {    
457 /// Return the number of zones.
458
459 #ifdef WITH_STL
460   return fZones.size();
461 #endif
462
463 #ifdef WITH_ROOT
464   return fZones.GetEntriesFast();
465 #endif
466 }  
467
468 //_____________________________________________________________________________
469 AliMpZone* AliMpSector::GetZone(Int_t zoneID) const
470 {
471 /// Return zone with specified ID.
472
473   if (zoneID < 1 || zoneID > GetNofZones()) {
474     AliWarningStream() << "Index outside range" << endl;
475     return 0;
476   }
477   
478 #ifdef WITH_STL
479   return fZones[zoneID-1];
480 #endif
481
482 #ifdef WITH_ROOT
483   return (AliMpZone*)fZones[zoneID-1];
484 #endif
485 }  
486
487 //_____________________________________________________________________________
488 Int_t AliMpSector::GetNofRows() const
489 {
490 /// Return the number of rows.
491
492 #ifdef WITH_STL
493   return fRows.size();
494 #endif
495
496 #ifdef WITH_ROOT
497   return fRows.GetEntriesFast();
498 #endif
499 }  
500
501 //_____________________________________________________________________________
502 AliMpRow* AliMpSector::GetRow(Int_t rowID) const
503 {
504 /// Return row with specified ID.
505
506   if (rowID < 0 || rowID >= GetNofRows()) {
507     AliWarningStream() << "Index outside range" << endl;
508     return 0;
509   }
510   
511 #ifdef WITH_STL
512   return fRows[rowID];
513 #endif
514
515 #ifdef WITH_ROOT
516   return (AliMpRow*)fRows[rowID];
517 #endif
518 }
519
520 //_____________________________________________________________________________
521 AliMp::PlaneType
522 AliMpSector::GetPlaneType() const
523 {
524 /// Return the plane type
525
526   return GetDirection()==AliMp::kY ? AliMp::kBendingPlane : AliMp::kNonBendingPlane;
527 }
528
529 //_____________________________________________________________________________
530 void 
531 AliMpSector::GetAllMotifPositionsIDs(TArrayI& ecn) const
532 {
533 /// Return the array of all motif positions IDs
534
535   fMotifMap->GetAllMotifPositionsIDs(ecn);
536 }
537
538 //_____________________________________________________________________________
539 void
540 AliMpSector::Print(Option_t* opt) const
541 {
542 /// Print the map of motifs
543
544   cout << "Sector," << PlaneTypeName(GetPlaneType()) << endl;
545   fMotifMap->Print(opt);
546 }