Adding comment lines to class description needed for Root documentation,
[u/mrichter/AliRoot.git] / MUON / mapping / AliMpSegmentation.cxx
index 3990140..fbd301c 100644 (file)
 // $MpId: AliMpSegmentation.cxx,v 1.7 2006/05/24 13:58:34 ivana Exp $
 // Category: management
 
-// -----------------------
+//-----------------------------------------------------------------------------
 // Class AliMpSegmentation
 // -----------------------
 // Singleton container class for mapping segmentations
 // Authors: Ivana Hrivnacova, IPN Orsay
 //          Laurent Aphecetche, SUBATECH
+//-----------------------------------------------------------------------------
 
 #include "AliMpSegmentation.h"
 
+#include "AliMpDetElement.h"
 #include "AliMpDEManager.h"
 #include "AliMpDEIterator.h"
 #include "AliMpExMap.h"
 #include "AliMpTrigger.h"
 #include "AliMpTriggerReader.h"
 #include "AliMpTriggerSegmentation.h"
+#include "AliMpCathodType.h"
 
 #include "AliLog.h"
+#include "AliCDBManager.h"
+#include "AliCDBEntry.h"
 
 #include <Riostream.h>
 #include <TMap.h>
 #include <TObjString.h>
 #include <TSystem.h>
+#include <TClass.h>
 
 /// \cond CLASSIMP
 ClassImp(AliMpSegmentation)
@@ -57,17 +63,35 @@ AliMpSegmentation* AliMpSegmentation::fgInstance = 0;
 //
 
 //______________________________________________________________________________
-AliMpSegmentation* AliMpSegmentation::Instance()
+AliMpSegmentation* AliMpSegmentation::Instance(Bool_t warn)
 {
-/// Create the sementation if it does not yet exist
-/// and return its instance
+/// Return its instance
 
-  if ( ! fgInstance )
-    fgInstance = new AliMpSegmentation();
+  if ( ! fgInstance && warn ) {
+    AliWarningClass("Segmentation has not been loaded");
+  }  
     
   return fgInstance;
 }    
 
+//______________________________________________________________________________
+AliMpSegmentation* AliMpSegmentation::ReadData(Bool_t warn)
+{
+/// Load the sementation from ASCII data files
+/// and return its instance
+
+  if ( fgInstance ) {
+    if ( warn )
+      AliWarningClass("Segmentation has been already loaded");
+    return fgInstance;
+  }  
+  
+  AliInfoClass("Reading segmentation from ASCII files.");
+
+  fgInstance = new AliMpSegmentation();
+  return fgInstance;
+}    
+
 //
 // ctors, dtor
 //
@@ -76,19 +100,19 @@ AliMpSegmentation* AliMpSegmentation::Instance()
 AliMpSegmentation::AliMpSegmentation()
 : TObject(),
   fMpSegmentations(true),
-  fElCardsMap(true)
+  fElCardsMap(true),
+  fSlatMotifMap()
 {  
-/// Standard constructor
+/// Standard constructor - segmentation is loaded from ASCII data files
 
   AliDebug(1,"");
   fElCardsMap.SetOwner(true);
 
   // Create mapping segmentations for all detection elements
-  for ( Int_t cath = 0; cath < 2; cath ++ ) { 
+  for ( Int_t cath = AliMp::kCath0; cath <= AliMp::kCath1; cath ++ ) { 
     AliMpDEIterator it;
     for ( it.First(); ! it.IsDone(); it.Next() ) {
-      //if ( AliMpDEManager::GetChamberId(it.CurrentDE()) >= 4 ) break;
-      CreateMpSegmentation(it.CurrentDE(), cath);
+      CreateMpSegmentation(it.CurrentDEId(), AliMp::GetCathodType(cath));
     } 
   }  
 
@@ -96,9 +120,9 @@ AliMpSegmentation::AliMpSegmentation()
   // of tracking chambers
   AliMpDEIterator it;
   for ( it.First(); ! it.IsDone(); it.Next() ) { 
-    //if ( AliMpDEManager::GetChamberId(it.CurrentDE()) >= 4 ) break;
-    if ( AliMpDEManager::GetChamberId(it.CurrentDE()) >= 10 ) break;
-    FillElCardsMap(it.CurrentDE());
+    if ( AliMpDEManager::GetStationType(it.CurrentDEId()) != AliMp::kStationTrigger ) {
+      FillElCardsMap(it.CurrentDEId());
+    }
   }  
 }
 
@@ -106,10 +130,13 @@ AliMpSegmentation::AliMpSegmentation()
 AliMpSegmentation::AliMpSegmentation(TRootIOCtor* /*ioCtor*/)
 : TObject(),
   fMpSegmentations(),
-  fElCardsMap()
+  fElCardsMap(),
+  fSlatMotifMap()
 {  
 /// Constructor for IO
 
+  AliDebug(1,"");
+
   fgInstance = this;
 }
 
@@ -132,18 +159,19 @@ AliMpSegmentation::~AliMpSegmentation()
 
 //______________________________________________________________________________
 AliMpVSegmentation* 
-AliMpSegmentation::CreateMpSegmentation(Int_t detElemId, Int_t cath)
+AliMpSegmentation::CreateMpSegmentation(Int_t detElemId, AliMp::CathodType cath)
 {
 /// Create mapping segmentation for given detElemId and cath
 /// or return it if it was already built
 
   // Check detElemId & cath  
-  if ( ! AliMpDEManager::IsValid(detElemId, cath, true) ) return 0;
+  if ( ! AliMpDEManager::IsValidDetElemId(detElemId, true) ) return 0;
 
   // If segmentation is already built, just return it
   //
-  TString deName = AliMpDEManager::GetDEName(detElemId, cath);
-  TObject* object = fMpSegmentations.Get(deName);
+  AliMpDetElement* detElement = AliMpDEManager::GetDetElement(detElemId);
+  TString deSegName = detElement->GetSegName(cath);
+  TObject* object = fMpSegmentations.Get(deSegName);
   if ( object ) return (AliMpVSegmentation*)object;
 
   AliDebugStream(3)
@@ -152,29 +180,34 @@ AliMpSegmentation::CreateMpSegmentation(Int_t detElemId, Int_t cath)
   
   // Read mapping data and create segmentation
   //
-  AliMpStationType stationType = AliMpDEManager::GetStationType(detElemId);
-  AliMpPlaneType planeType = AliMpDEManager::GetPlaneType(detElemId, cath);
-  TString deTypeName = AliMpDEManager::GetDETypeName(detElemId, cath);
+  AliMp::StationType stationType = detElement->GetStationType();
+  AliMp::PlaneType planeType = detElement->GetPlaneType(cath);
+  TString deTypeName = detElement->GetSegType();
 
   AliMpVSegmentation* mpSegmentation = 0;
 
-  if ( stationType == kStation1 || stationType == kStation2 ) {
+  if ( stationType == AliMp::kStation1 || stationType == AliMp::kStation2 ) {
     AliMpSectorReader reader(stationType, planeType);
     AliMpSector* sector = reader.BuildSector();
     mpSegmentation = new AliMpSectorSegmentation(sector, true);
   }
-  else if ( stationType == kStation345 ) { 
-    AliMpSlat* slat = AliMpSt345Reader::ReadSlat(deTypeName, planeType);
+  else if ( stationType == AliMp::kStation345 ) { 
+    AliMpSt345Reader reader(fSlatMotifMap);
+    AliMpSlat* slat = reader.ReadSlat(deTypeName, planeType);
     mpSegmentation =  new AliMpSlatSegmentation(slat, true);
   }
-  else if ( stationType == kStationTrigger ) {
-    AliMpTrigger* trigger = AliMpTriggerReader::ReadSlat(deTypeName, planeType);
+  else if ( stationType == AliMp::kStationTrigger ) {
+    AliMpTriggerReader reader(fSlatMotifMap);
+    AliMpTrigger* trigger = reader.ReadSlat(deTypeName, planeType);
     mpSegmentation = new AliMpTriggerSegmentation(trigger, true);
   }
   else   
     AliErrorStream() << "Unknown station type" << endl;
 
-  fMpSegmentations.Add(deName, mpSegmentation); 
+  fMpSegmentations.Add(deSegName, mpSegmentation); 
+  
+//  StdoutToAliDebug(3, fSlatMotifMap.Print(););
+  
   return mpSegmentation;
 } 
 
@@ -197,15 +230,15 @@ AliMpSegmentation::FillElCardsMap(Int_t detElemId)
   // Do it in 2 steps to be able to set the AliMpExMap size once for all,
   // to avoid annoying warning message in case of dynamical resizing.
   // (not critical).
-  for ( Int_t cathode = 0; cathode < 2; ++cathode )
+  for ( Int_t cathode = AliMp::kCath0; cathode <= AliMp::kCath1; ++cathode )
   {
-    seg[cathode] = GetMpSegmentation(detElemId,cathode);
+    seg[cathode] = GetMpSegmentation(detElemId,AliMp::GetCathodType(cathode));
     seg[cathode]->GetAllElectronicCardIDs(ecn[cathode]);
   }
   
   mde->SetSize(ecn[0].GetSize()+ecn[1].GetSize());
   
-  for ( Int_t cathode = 0; cathode < 2; ++ cathode )
+  for ( Int_t cathode = AliMp::kCath0; cathode <= AliMp::kCath1; ++ cathode )
   {
     for ( Int_t i = 0; i < ecn[cathode].GetSize(); ++i )
     {
@@ -223,23 +256,25 @@ AliMpSegmentation::FillElCardsMap(Int_t detElemId)
 //______________________________________________________________________________
 const AliMpVSegmentation* 
 AliMpSegmentation::GetMpSegmentation(
-                      Int_t detElemId, Int_t cath, Bool_t warn) const
+                      Int_t detElemId, AliMp::CathodType cath, Bool_t warn) const
 {
 /// Return mapping segmentation for given detElemId and cath
 
   // Check detElemId & cath  
-  if ( ! AliMpDEManager::IsValid(detElemId, cath, false) ) {
+  if ( ! AliMpDEManager::IsValidDetElemId(detElemId, false) ) {
     
     if ( warn ) {
       AliWarningStream() 
-        << "Invalid detElemId/cathod (" 
-       << detElemId << ", " << cath << ")" << endl;
+        << "Invalid detElemId " << detElemId << endl;
     }  
     return 0;
   }  
 
-  TString deName = AliMpDEManager::GetDEName(detElemId, cath);
-  TObject* object = fMpSegmentations.Get(deName);
+  // If segmentation is already built, just return it
+  //
+  AliMpDetElement* detElement = AliMpDEManager::GetDetElement(detElemId);
+  TString deSegName = detElement->GetSegName(cath);
+  TObject* object = fMpSegmentations.Get(deSegName);
   if ( ! object ) {
     // Should never happen
     AliErrorStream()