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