Replacement of AliMpIntPair object with algoritmic
[u/mrichter/AliRoot.git] / MUON / mapping / AliMpSegmentation.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: AliMpSegmentation.cxx,v 1.7 2006/05/24 13:58:34 ivana Exp $
18 // Category: management
19
20 //-----------------------------------------------------------------------------
21 // Class AliMpSegmentation
22 // -----------------------
23 // Singleton container class for mapping segmentations
24 // Authors: Ivana Hrivnacova, IPN Orsay
25 //          Laurent Aphecetche, SUBATECH
26 //-----------------------------------------------------------------------------
27
28 #include "AliMpSegmentation.h"
29
30 #include "AliMpDataStreams.h"
31 #include "AliMpDetElement.h"
32 #include "AliMpDEStore.h"
33 #include "AliMpDEManager.h"
34 #include "AliMpDEIterator.h"
35 #include "AliMpExMap.h"
36 #include "AliMpFastSegmentation.h"
37 #include "AliMpSector.h"
38 #include "AliMpSectorReader.h"
39 #include "AliMpSectorSegmentation.h"
40 #include "AliMpSlat.h"
41 #include "AliMpSlatSegmentation.h"
42 #include "AliMpSt345Reader.h"
43 #include "AliMpTrigger.h"
44 #include "AliMpTriggerReader.h"
45 #include "AliMpTriggerSegmentation.h"
46 #include "AliMpCathodType.h"
47 #include "AliMpSlatMotifMap.h"
48
49
50 #include "AliLog.h"
51
52 #include <Riostream.h>
53 #include <TMap.h>
54 #include <TObjString.h>
55 #include <TSystem.h>
56 #include <TClass.h>
57
58 #include <cassert>
59
60 /// \cond CLASSIMP
61 ClassImp(AliMpSegmentation)
62 /// \endcond
63
64 AliMpSegmentation* AliMpSegmentation::fgInstance = 0;
65
66 //
67 // static methods
68 //
69
70 //______________________________________________________________________________
71 AliMpSegmentation* AliMpSegmentation::Instance(Bool_t warn)
72 {
73 /// Return its instance
74
75   if ( ! fgInstance && warn ) {
76     AliWarningClass("Segmentation has not been loaded");
77   }  
78     
79   return fgInstance;
80 }    
81
82 //______________________________________________________________________________
83 AliMpSegmentation* AliMpSegmentation::ReadData(const AliMpDataStreams& dataStreams,
84                                                Bool_t warn)
85 {
86 /// Load the sementation from ASCII data files
87 /// and return its instance
88
89   if ( fgInstance ) {
90     if ( warn )
91       AliWarningClass("Segmentation has been already loaded");
92     return fgInstance;
93   }  
94   
95   if ( dataStreams.GetReadFromFiles() )
96     AliInfoClass("Reading segmentation from ASCII files.");
97
98   fgInstance = new AliMpSegmentation(dataStreams);
99   return fgInstance;
100 }    
101
102 //
103 // ctors, dtor
104 //
105
106 //______________________________________________________________________________
107 AliMpSegmentation::AliMpSegmentation(const AliMpDataStreams& dataStreams)
108 : TObject(),
109   fkDataStreams(dataStreams),
110   fDetElements(0),
111   fMpSegmentations(true),
112   fElCardsMap(),
113   fSlatMotifMap(new AliMpSlatMotifMap)
114 {  
115 /// Standard constructor - segmentation is loaded from ASCII data files
116
117   AliDebug(1,"");
118   
119   fElCardsMap.SetOwner(kTRUE);
120   
121   // Load DE data
122   if ( ! AliMpDEStore::Instance(false) )  
123     AliMpDEStore::ReadData(dataStreams);
124   fDetElements = AliMpDEStore::Instance();  
125
126   // Create mapping segmentations for all detection elements
127   AliMpDEIterator it;
128   for ( it.First(); ! it.IsDone(); it.Next() ) 
129   {
130     Int_t n(0);
131     
132     for ( Int_t cath = AliMp::kCath0; cath <= AliMp::kCath1; ++cath ) 
133     { 
134       if ( CreateMpSegmentation(it.CurrentDEId(), AliMp::GetCathodType(cath)) ) ++n;
135     }
136      
137     if ( n == 2 &&  // should always be the case except when we play with the CreateMpSegmentation method...
138         AliMpDEManager::GetStationType(it.CurrentDEId()) != AliMp::kStationTrigger ) // only for tracker
139     {
140         // Fill el cards map for all detection elements
141         // of tracking chambers
142         FillElCardsMap(it.CurrentDEId());
143     }      
144   } 
145 }
146
147 //______________________________________________________________________________
148 AliMpSegmentation::AliMpSegmentation(TRootIOCtor* ioCtor)
149 : TObject(),
150   fkDataStreams(ioCtor),
151   fDetElements(0),
152   fMpSegmentations(),
153   fElCardsMap(ioCtor),
154   fSlatMotifMap(0)
155 {  
156 /// Constructor for IO
157
158   AliDebug(1,"");
159
160   fgInstance = this;
161 }
162
163 //______________________________________________________________________________
164 AliMpSegmentation::~AliMpSegmentation()
165 {
166 /// Destructor
167
168   AliDebug(1,"");
169
170   delete fDetElements;
171
172   // Segmentations are deleted with fMpSegmentations 
173   // El cards arrays are deleted with fElCardsMap
174   
175   delete fSlatMotifMap;
176   
177   fgInstance = 0;
178 }
179
180 //
181 // private methods
182 //
183
184 //______________________________________________________________________________
185 AliMpVSegmentation* 
186 AliMpSegmentation::CreateMpSegmentation(Int_t detElemId, AliMp::CathodType cath)
187 {
188 /// Create mapping segmentation for given detElemId and cath
189 /// or return it if it was already built
190
191   // Check detElemId & cath  
192   if ( ! AliMpDEManager::IsValidDetElemId(detElemId, true) ) return 0;
193
194   // If segmentation is already built, just return it
195   //
196   AliMpDetElement* detElement = AliMpDEManager::GetDetElement(detElemId);
197   TString deSegName = detElement->GetSegName(cath);
198   TObject* object = fMpSegmentations.Get(deSegName);
199   if ( object ) return (AliMpVSegmentation*)object;
200
201   AliDebugStream(3)
202     << "Creating segmentation for detElemId=" << detElemId 
203     << " cath=" << cath << endl;
204   
205   // Read mapping data and create segmentation
206   //
207   AliMp::StationType stationType = detElement->GetStationType();
208   AliMp::PlaneType planeType = detElement->GetPlaneType(cath);
209   TString deTypeName = detElement->GetSegType();
210
211   AliMpVSegmentation* mpSegmentation = 0;
212
213   if ( stationType == AliMp::kStation12 ) {
214     AliMq::Station12Type station12Type = detElement->GetStation12Type();
215     AliMpSectorReader reader(fkDataStreams, station12Type, planeType);
216     AliMpSector* sector = reader.BuildSector();
217     mpSegmentation = new AliMpFastSegmentation(new AliMpSectorSegmentation(sector, true));
218   }
219   else if ( stationType == AliMp::kStation345 ) { 
220     AliMpSt345Reader reader(fkDataStreams,fSlatMotifMap);
221     AliMpSlat* slat = reader.ReadSlat(deTypeName, planeType);
222     mpSegmentation = new AliMpFastSegmentation(new AliMpSlatSegmentation(slat, true));
223   }
224   else if ( stationType == AliMp::kStationTrigger ) {
225     AliMpTriggerReader reader(fkDataStreams,fSlatMotifMap);
226     AliMpTrigger* trigger = reader.ReadSlat(deTypeName, planeType);
227     mpSegmentation = new AliMpTriggerSegmentation(trigger, true);
228   }
229   else   
230     AliErrorStream() << "Unknown station type" << endl;
231
232   if ( mpSegmentation ) fMpSegmentations.Add(deSegName, mpSegmentation); 
233   
234 //  StdoutToAliDebug(3, fSlatMotifMap.Print(););
235   
236   return mpSegmentation;
237
238
239 //_____________________________________________________________________________
240 AliMpExMap*
241 AliMpSegmentation::FillElCardsMap(Int_t detElemId)
242 {
243 /// Fill the map of electronic cards IDs to segmentations for
244 /// given detElemId
245
246   AliDebugStream(2) << "detElemId=" << detElemId << endl;;
247   
248   AliMpExMap* mde = new AliMpExMap;
249   mde->SetOwner(kFALSE);
250   fElCardsMap.Add(detElemId,mde);
251
252   const AliMpVSegmentation* seg[2];
253   TArrayI ecn[2];
254   
255   for ( Int_t cathode = AliMp::kCath0; cathode <= AliMp::kCath1; ++cathode )
256   {
257     seg[cathode] = GetMpSegmentation(detElemId,AliMp::GetCathodType(cathode));
258     seg[cathode]->GetAllElectronicCardIDs(ecn[cathode]);
259     for ( Int_t i = 0; i < ecn[cathode].GetSize(); ++i )
260     {
261       mde->Add(ecn[cathode][i],const_cast<AliMpVSegmentation*>(seg[cathode]));
262     }
263   }
264   
265   assert( mde->GetSize() > 0 );
266   
267   return mde;
268   
269 }
270
271 //
272 // public methods
273 //
274
275 //______________________________________________________________________________
276 const AliMpVSegmentation* 
277 AliMpSegmentation::GetMpSegmentation(
278                       Int_t detElemId, AliMp::CathodType cath, Bool_t warn) const
279 {
280 /// Return mapping segmentation for given detElemId and cath
281
282   // Check detElemId & cath  
283   if ( ! AliMpDEManager::IsValidDetElemId(detElemId, false) ) {
284     
285     if ( warn ) {
286       AliWarningStream() 
287         << "Invalid detElemId " << detElemId << endl;
288     }   
289     return 0;
290   }  
291
292   // If segmentation is already built, just return it
293   //
294   AliMpDetElement* detElement = AliMpDEManager::GetDetElement(detElemId);
295   TString deSegName = detElement->GetSegName(cath);
296   TObject* object = fMpSegmentations.Get(deSegName);
297   if ( ! object ) {
298     // Should never happen
299     AliErrorStream() 
300       << "Segmentation for detElemId/cathod " 
301         << detElemId << ", " << cath << " not defined" << endl;
302     return 0;
303   }  
304   
305   return static_cast<AliMpVSegmentation*>(object);
306
307
308 //_____________________________________________________________________________
309 const AliMpVSegmentation* 
310 AliMpSegmentation::GetMpSegmentationByElectronics(
311                       Int_t detElemId, Int_t ecId, Bool_t warn) const
312 {
313 /// Return mapping segmentation for given detElemId and electronic card Id
314 /// (motif position Id)
315
316   AliMpExMap* m = static_cast<AliMpExMap*>(fElCardsMap.GetValue(detElemId));
317   
318   if (!m) {
319     // Should never happen
320     AliErrorStream() 
321       << "Cannot find the el cards map for detElemId " << detElemId << endl;
322     return 0;
323   }  
324
325   TObject* object = m->GetValue(ecId);
326   if ( ! object ) {
327     if ( warn ) {
328       AliErrorStream() 
329         << "Segmentation for electronic card " 
330         << ecId << " not found" << endl;
331     }   
332     return 0;
333   }  
334    
335   return static_cast<AliMpVSegmentation*>(object);
336 }
337
338 //_____________________________________________________________________________
339 const AliMpSector*  
340 AliMpSegmentation::GetSector(const AliMpVSegmentation* kSegmentation, 
341                              Bool_t warn) const
342 {
343 /// Return sector for given mapping segmentation.
344 /// If segmentation is not of sector type, zero is returned 
345 /// and an Error is issued if warn is set true (default). 
346
347   if ( ! kSegmentation ) return 0;
348
349   if ( kSegmentation->StationType() != AliMp::kStation12 ) {
350     if ( warn ) {
351       AliErrorStream() 
352         << "Segmentation is not of sector type" << endl;
353      }   
354      return 0;
355   }
356     
357   // If fast segmentation
358   const AliMpFastSegmentation* fseg 
359     = dynamic_cast<const AliMpFastSegmentation*>(kSegmentation);
360   if ( fseg ) {   
361     return 
362       static_cast<const AliMpSectorSegmentation*>(fseg->GetHelper())->GetSector();
363   }
364   
365   // If sector segmentation
366   const AliMpSectorSegmentation* sseg 
367     = dynamic_cast<const AliMpSectorSegmentation*>(kSegmentation);
368   if ( sseg ) {   
369     return sseg->GetSector();
370   }
371   
372   // Should not get to this line
373   AliErrorStream() << "Segemntation type not identified." << endl;
374   return 0;         
375 }
376                              
377 //_____________________________________________________________________________
378 const AliMpSector*  
379 AliMpSegmentation::GetSector(Int_t detElemId, AliMp::CathodType cath, 
380                              Bool_t warn) const
381 {
382 /// Return sector for given detElemId and cath.
383 /// If segmentation is not of sector type, zero is returned 
384 /// and an Error is issued if warn is set true (default). 
385
386   return GetSector(GetMpSegmentation(detElemId, cath, warn), warn);
387 }    
388       
389 //_____________________________________________________________________________
390 const AliMpSector*  
391 AliMpSegmentation::GetSectorByElectronics(Int_t detElemId, Int_t elCardID, 
392                              Bool_t warn) const
393 {
394 /// Return sector for given detElemId and elCardID.
395 /// If segmentation is not of sector type, zero is returned 
396 /// and an Error is issued if warn is set true (default). 
397
398   return GetSector(GetMpSegmentationByElectronics(detElemId, elCardID, warn), warn);
399 }    
400       
401 //_____________________________________________________________________________
402 const AliMpSlat*    
403 AliMpSegmentation::GetSlat(const AliMpVSegmentation* kSegmentation, 
404                            Bool_t warn) const
405 {                           
406 /// Return slat for given mapping segmentation.
407 /// If segmentation is not of slat type, zero is returned 
408 /// and an Error is issued if warn is set true (default). 
409
410   if ( ! kSegmentation ) return 0;
411  
412   if ( kSegmentation->StationType() != AliMp::kStation345 ) {
413      if ( warn ) {
414        AliErrorStream() 
415          << "Segmentation is not of slat type" << endl;
416      }    
417      return 0;
418   }
419   
420   // If fast segmentation
421   const AliMpFastSegmentation* fseg 
422     = dynamic_cast<const AliMpFastSegmentation*>(kSegmentation);
423   if ( fseg ) {   
424     return 
425       static_cast<const AliMpSlatSegmentation*>(fseg->GetHelper())->Slat();
426   }
427   
428   // If slat segmentation
429   const AliMpSlatSegmentation* sseg 
430     = dynamic_cast<const AliMpSlatSegmentation*>(kSegmentation);
431     
432   if ( sseg ) {   
433     return sseg->Slat();
434   }
435   
436   // Should not get to this line
437   AliErrorStream() << "Segemntation type not identified." << endl;
438   return 0;         
439 }    
440                            
441 //_____________________________________________________________________________
442 const AliMpSlat*  
443 AliMpSegmentation::GetSlat(Int_t detElemId, AliMp::CathodType cath, 
444                            Bool_t warn) const
445 {
446 /// Return slat for given detElemId and cath.
447 /// If segmentation is not of slat type, zero is returned 
448 /// and an Error is issued if warn is set true (default). 
449
450   return GetSlat(GetMpSegmentation(detElemId, cath, warn), warn);
451 }    
452
453 //_____________________________________________________________________________
454 const AliMpSlat*  
455 AliMpSegmentation::GetSlatByElectronics(Int_t detElemId, Int_t elCardID, 
456                            Bool_t warn) const
457 {
458 /// Return slat for given detElemId and elCardID.
459 /// If segmentation is not of slat type, zero is returned 
460 /// and an Error is issued if warn is set true (default). 
461
462   return GetSlat(GetMpSegmentationByElectronics(detElemId, elCardID, warn), warn);
463 }    
464
465 //_____________________________________________________________________________
466 const AliMpTrigger* 
467 AliMpSegmentation::GetTrigger(const AliMpVSegmentation* kSegmentation, 
468                               Bool_t warn) const
469 {                               
470 /// Return trigger for given mapping segmentation.
471 /// If segmentation is not of trigger type, zero is returned 
472 /// and an Error is issued if warn is set true (default). 
473
474   if ( ! kSegmentation ) return 0;
475  
476   if ( kSegmentation->StationType() != AliMp::kStationTrigger ) {
477      if ( warn ) {
478        AliErrorStream() 
479          << "Segmentation is not of trigger type" << endl;
480      }    
481      return 0;
482   }
483   
484   // If slat segmentation
485   const AliMpTriggerSegmentation* tseg 
486     = dynamic_cast<const AliMpTriggerSegmentation*>(kSegmentation);
487   if ( tseg ) {   
488     return tseg->Slat();
489   }
490   
491   // If fast segmentation
492   const AliMpFastSegmentation* fseg 
493     = dynamic_cast<const AliMpFastSegmentation*>(kSegmentation);
494     
495   if ( fseg ) {   
496     return 
497       static_cast<const AliMpTriggerSegmentation*>(fseg->GetHelper())->Slat();
498   }
499   
500   // Should not get to this line
501   AliErrorStream() << "Segemntation type not identified." << endl;
502   return 0;         
503 }    
504
505 //_____________________________________________________________________________
506 const AliMpTrigger*  
507 AliMpSegmentation::GetTrigger(Int_t detElemId, AliMp::CathodType cath, 
508                               Bool_t warn) const
509 {
510 /// Return trigger for given detElemId and cath.
511 /// If segmentation is not of trigger type, zero is returned 
512 /// and an Error is issued if warn is set true (default). 
513
514   return GetTrigger(GetMpSegmentation(detElemId, cath, warn), warn);
515 }    
516
517 //_____________________________________________________________________________
518 const AliMpTrigger*  
519 AliMpSegmentation::GetTriggerByElectronics(Int_t detElemId, Int_t elCardID, 
520                               Bool_t warn) const
521 {
522 /// Return trigger for given detElemId and elCardID.
523 /// If segmentation is not of trigger type, zero is returned 
524 /// and an Error is issued if warn is set true (default). 
525
526   return GetTrigger(GetMpSegmentationByElectronics(detElemId, elCardID, warn), warn);
527 }