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