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