AliMUONDigitCalibrator
authorivana <ivana@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 27 May 2008 10:06:26 +0000 (10:06 +0000)
committerivana <ivana@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 27 May 2008 10:06:26 +0000 (10:06 +0000)
        Remove fNofChannelsPerDE member, which is now part of the
        AliMpDetElement class

mapping/AliMpExMap
        Replace usage of TExMapIter by the newly introduced
        AliMpExMapIterator class, and change the interface to remove
        the GetObject methods.

AliMUON1DMap
AliMUON2DMap
AliMUON2DMapIterator
AliMUON2DMapIteratorByI
AliMUONAlignment
AliMUONCheckItem
AliMUONCheckItemIterator
AliMUONClusterStoreV2Iterator
AliMUONESDInterface
AliMUONGeometryMisAligner
AliMUONGeometryModuleTransformer
AliMUONGeometryTransformer
AliMUONPainterHelper
AliMUONRawWriter
AliMUONRefitter
AliMUONRefitter
AliMUONRegionalTriggerConfig
AliMUONSimpleClusterServer
AliMUONTrackerData
AliMUONTriggerCrateStore
AliMUONTriggerElectronics
AliMUONTriggerIO
MUONRefit.C
mapping/AliMpDDLStore
mapping/AliMpDEIterator
mapping/AliMpDEStore
mapping/AliMpDetElement
mapping/AliMpManuIterator
mapping/AliMpMotifMap
mapping/AliMpMotifSpecial
mapping/AliMpMotifType
mapping/AliMpRegionalTrigger
mapping/AliMpSector
mapping/AliMpSegmentation
mapping/AliMpSlat
        Replace usage of TExMapIter by the newly introduced AliMpExMapIterator
        class, and changes due to the interface change in AliMpExMap.

AliMUONCalibrationData
        Added self check method

AliMUONTrackerIO
        When reading capacitance values, do not quit if serial number is already
        there, just skip it.

libMUONcore.pkg
MUONcoreLinkDef.h
        Adding new class AliMpExMapIterator

AliMUONClusterStoreV2.cxx
        Correct Clear method

AliMUONCDB
        Corrected WriteLocalTriggerMasks

AliMUONPadStatusMaker
AliMUONDigitStoreV1Iterator
        Removed unneeded include

mapping/AliMpManuUID
        Remove number of channels from here. Will be part of a forthcoming
        AliMpManu class...

mapping/AliMpConnection
mapping/AliMpMotifReader
        Adding SetLocalIndices method to AliMpConnection class.

checkDeps.py
        Some improvements in .pkg syntax parsing

(Laurent)

83 files changed:
MUON/AliMUON1DMap.cxx
MUON/AliMUON1DMap.h
MUON/AliMUON2DMap.cxx
MUON/AliMUON2DMap.h
MUON/AliMUON2DMapIterator.cxx
MUON/AliMUON2DMapIterator.h
MUON/AliMUON2DMapIteratorByI.cxx
MUON/AliMUON2DMapIteratorByI.h
MUON/AliMUONAlignment.cxx
MUON/AliMUONCDB.cxx
MUON/AliMUONCalibrationData.cxx
MUON/AliMUONCalibrationData.h
MUON/AliMUONCheckItem.cxx
MUON/AliMUONCheckItemIterator.cxx
MUON/AliMUONCheckItemIterator.h
MUON/AliMUONClusterStoreV2.cxx
MUON/AliMUONClusterStoreV2Iterator.cxx
MUON/AliMUONClusterStoreV2Iterator.h
MUON/AliMUONDigitCalibrator.cxx
MUON/AliMUONDigitCalibrator.h
MUON/AliMUONDigitStoreV1Iterator.cxx
MUON/AliMUONESDInterface.cxx
MUON/AliMUONESDInterface.h
MUON/AliMUONGeometryMisAligner.cxx
MUON/AliMUONGeometryModuleTransformer.cxx
MUON/AliMUONGeometryTransformer.cxx
MUON/AliMUONPadStatusMaker.cxx
MUON/AliMUONPainterHelper.cxx
MUON/AliMUONRawWriter.cxx
MUON/AliMUONRefitter.cxx
MUON/AliMUONRefitter.h
MUON/AliMUONRegionalTriggerConfig.cxx
MUON/AliMUONRegionalTriggerConfig.h
MUON/AliMUONSimpleClusterServer.cxx
MUON/AliMUONSt1GeometryBuilderV2.cxx
MUON/AliMUONSt1GeometryBuilderV2.h
MUON/AliMUONTrackerData.cxx
MUON/AliMUONTrackerIO.cxx
MUON/AliMUONTriggerCrateStore.cxx
MUON/AliMUONTriggerCrateStore.h
MUON/AliMUONTriggerElectronics.cxx
MUON/AliMUONTriggerIO.cxx
MUON/Calib/DDLStore/Run0_999999999_v0_s0.root
MUON/Calib/Mapping/Run0_999999999_v0_s0.root
MUON/MUONRefit.C
MUON/MUONcoreLinkDef.h
MUON/MUONmappingLinkDef.h
MUON/checkDeps.py
MUON/libMUONcore.pkg
MUON/mapping/AliMpConnection.cxx
MUON/mapping/AliMpConnection.h
MUON/mapping/AliMpDDLStore.cxx
MUON/mapping/AliMpDDLStore.h
MUON/mapping/AliMpDEIterator.cxx
MUON/mapping/AliMpDEIterator.h
MUON/mapping/AliMpDEStore.cxx
MUON/mapping/AliMpDEVisu.cxx
MUON/mapping/AliMpDetElement.cxx
MUON/mapping/AliMpDetElement.h
MUON/mapping/AliMpExMap.cxx
MUON/mapping/AliMpExMap.h
MUON/mapping/AliMpManuIterator.cxx
MUON/mapping/AliMpManuIterator.h
MUON/mapping/AliMpManuUID.cxx
MUON/mapping/AliMpManuUID.h
MUON/mapping/AliMpMotifMap.cxx
MUON/mapping/AliMpMotifMap.h
MUON/mapping/AliMpMotifReader.cxx
MUON/mapping/AliMpMotifSpecial.cxx
MUON/mapping/AliMpMotifSpecial.h
MUON/mapping/AliMpMotifType.cxx
MUON/mapping/AliMpMotifType.h
MUON/mapping/AliMpPCB.cxx
MUON/mapping/AliMpPCB.h
MUON/mapping/AliMpPCBPainter.cxx
MUON/mapping/AliMpRegionalTrigger.cxx
MUON/mapping/AliMpRegionalTrigger.h
MUON/mapping/AliMpSector.cxx
MUON/mapping/AliMpSegmentation.cxx
MUON/mapping/AliMpSlat.cxx
MUON/mapping/AliMpSlat.h
MUON/mapping/AliMpSlatPadIterator.cxx
MUON/mapping/AliMpSlatPainter.cxx

index 5178de6..87493db 100644 (file)
@@ -16,8 +16,8 @@
 // $Id$
 
 #include "AliMUON1DMap.h"
-#include "AliMUON1DMapIterator.h"
 #include "AliMpExMap.h"
+#include "AliMpExMapIterator.h"
 
 #include "AliLog.h"
 
@@ -35,17 +35,28 @@ ClassImp(AliMUON1DMap)
 /// \endcond
 
 //_____________________________________________________________________________
+AliMUON1DMap::AliMUON1DMap(TRootIOCtor*)
+: AliMUONVStore(),
+fMap(0x0)
+{
+  /// I/O ctor
+  
+}
+
+//_____________________________________________________________________________
 AliMUON1DMap::AliMUON1DMap(Int_t theSize)
 : AliMUONVStore(),
-  fMap(new AliMpExMap(kTRUE))
+  fMap(new AliMpExMap)
 {
 /// Default ctor
 
-  if ( theSize ) 
+    AliInfo("");
+    
+  if ( theSize > 0) 
   {
     fMap->SetSize(theSize);
   }
-    fMap->SetOwner(kTRUE);
+  fMap->SetOwner(kTRUE);
 }
 
 //_____________________________________________________________________________
@@ -122,7 +133,7 @@ AliMUON1DMap::CreateIterator() const
 {
   /// Create and return an iterator on this map
   /// Returned iterator must be deleted by user.
-  return new AliMUON1DMapIterator(*fMap);
+  return fMap->CreateIterator();
 }
 
 //_____________________________________________________________________________
index 23bae6f..f491eb0 100644 (file)
@@ -21,7 +21,8 @@ class AliMpExMap;
 class AliMUON1DMap : public AliMUONVStore
 {
 public:
-  AliMUON1DMap(Int_t theSize=0);
+  AliMUON1DMap(Int_t theSize);
+  AliMUON1DMap(TRootIOCtor* ioCtor);
   AliMUON1DMap(const AliMUON1DMap& other);
   AliMUON1DMap& operator=(const AliMUON1DMap& other);
   virtual ~AliMUON1DMap();
@@ -50,6 +51,8 @@ private:
   virtual Bool_t Set(Int_t i, TObject* object);
   
 private:  
+    /// Not implemented
+    AliMUON1DMap();
     
     AliMpExMap* fMap; ///< Internal array (map)
   
index 77f59e8..ff96bec 100644 (file)
@@ -21,6 +21,7 @@
 #include "AliMUON2DMapIterator.h"
 #include "AliMUON2DMapIteratorByI.h"
 #include "AliMpExMap.h"
+#include "AliMpExMapIterator.h"
 
 //-----------------------------------------------------------------------------
 /// \class AliMUON2DMap
@@ -37,31 +38,26 @@ ClassImp(AliMUON2DMap)
 
 const Int_t AliMUON2DMap::fgkOptimalSizeForDEManu = 228;
 
-namespace
+//_____________________________________________________________________________
+AliMUON2DMap::AliMUON2DMap(TRootIOCtor*)
+: AliMUONVStore(), 
+fMap(0x0),
+fOptimizeForDEManu(kFALSE)
 {
-  //___________________________________________________________________________
-  TObject* GetValue(TExMapIter& iter, Int_t& theKey) 
-  {
-    /// return the next value corresponding to theKey in iterator iter
-    theKey = -1;
-    Long_t key, value;
-    Bool_t ok = iter.Next(key,value);
-    if (!ok) return 0x0;
-    theKey = (Int_t)(key & 0xFFFF);
-    return reinterpret_cast<TObject*>(value);
-  }
+  /// Root I/O constructor.
 }
 
 //_____________________________________________________________________________
 AliMUON2DMap::AliMUON2DMap(Bool_t optimizeForDEManu) 
 : AliMUONVStore(), 
-  fMap(new AliMpExMap(kTRUE)),
+  fMap(new AliMpExMap),
   fOptimizeForDEManu(optimizeForDEManu)
 {
   /// Default constructor.
   // hard-coded constant in order not to depend on mapping
   // if this number ever change, it will not break the code, simply the
   // automatic resizing will give a warning...
+    
   if ( fOptimizeForDEManu ) fMap->SetSize(fgkOptimalSizeForDEManu); 
 }
 
@@ -163,13 +159,17 @@ Int_t
 AliMUON2DMap::GetSize() const
 {
   /// Return the number of objects we hold
-  TExMapIter iter(fMap->GetIterator());
-  Int_t i;
+  TIter next(fMap->CreateIterator());
   Int_t theSize(0);
+  AliMpExMap* m;
   
-  while ( GetValue(iter,i) ) 
+  while ( ( m = static_cast<AliMpExMap*>(next()) ) )
   {
-    theSize += GetSize(i);
+    TIter next2(m->CreateIterator());
+    while ( next2() ) 
+    {
+      ++theSize;
+    }
   }
   return theSize;
 }
@@ -195,7 +195,7 @@ AliMUON2DMap::Set(Int_t i, Int_t j, TObject* object, Bool_t replace)
   TObject* o = fMap->GetValue(i);
   if ( !o )
   {
-    AliMpExMap* m = new AliMpExMap(true);
+    AliMpExMap* m = new AliMpExMap;
     if ( fOptimizeForDEManu ) 
     {
       m->SetSize(451); // same remark as for the SetSize in ctor...
index 5ae8702..8dffdda 100644 (file)
@@ -20,7 +20,8 @@ class AliMpExMap;
 class AliMUON2DMap : public AliMUONVStore
 {
 public:
-  AliMUON2DMap(Bool_t optimizeForDEManu=kFALSE);  
+  AliMUON2DMap(TRootIOCtor* ioCtor);
+  AliMUON2DMap(Bool_t optimizeForDEManu);  
   AliMUON2DMap(const AliMUON2DMap& other);
   AliMUON2DMap&  operator = (const AliMUON2DMap& other);
   virtual ~AliMUON2DMap();
@@ -55,9 +56,11 @@ public:
   virtual Int_t GetSize(Int_t i) const;
 
 private:
+  /// Not implemented
+  AliMUON2DMap();
+
   Bool_t Set(Int_t i, Int_t j, TObject* object, Bool_t replace);
 
-private:
   static const Int_t fgkOptimalSizeForDEManu; ///< Optimal size for DEManu
 
   AliMpExMap* fMap; ///< Our internal map (an AliMpExMap of AliMpExMaps)
index f4f69ad..18ca049 100644 (file)
@@ -27,6 +27,8 @@
 //-----------------------------------------------------------------------------
 
 #include "AliMpExMap.h"
+#include "AliMpExMapIterator.h"
+#include "AliLog.h"
 
 /// \cond CLASSIMP
 ClassImp(AliMUON2DMapIterator)
@@ -36,41 +38,14 @@ ClassImp(AliMUON2DMapIterator)
 AliMUON2DMapIterator::AliMUON2DMapIterator(const AliMpExMap& theMap)
 : TIterator(),
 fkMap(&theMap),
-fCurrentMap(0x0),
-fI(-1),
-fJ(-1)
+fIter1(theMap.CreateIterator()),
+fIter2(NextIterator())
 {
   /// default ctor
   Reset();
 }
 
 //_____________________________________________________________________________
-AliMUON2DMapIterator::AliMUON2DMapIterator(const AliMUON2DMapIterator& rhs)
-: TIterator(rhs),
-fkMap(rhs.fkMap),
-fCurrentMap(rhs.fCurrentMap),
-fI(rhs.fI),
-fJ(rhs.fI)
-{
-  /// copy ctor
-}
-
-//_____________________________________________________________________________
-AliMUON2DMapIterator& 
-AliMUON2DMapIterator::operator=(const AliMUON2DMapIterator& rhs)
-{
-  /// assignment operator
-  if ( this != &rhs ) 
-  {
-    fkMap = rhs.fkMap;
-    fCurrentMap = rhs.fCurrentMap;
-    fI = rhs.fI;
-    fJ = rhs.fJ;
-  }
-  return *this;
-}
-
-//_____________________________________________________________________________
 TIterator& 
 AliMUON2DMapIterator::operator=(const TIterator& rhs)
 {
@@ -78,11 +53,8 @@ AliMUON2DMapIterator::operator=(const TIterator& rhs)
   
   if ( this != &rhs && rhs.IsA() == AliMUON2DMapIterator::Class() ) 
   {
-    const AliMUON2DMapIterator& rhs1 = static_cast<const AliMUON2DMapIterator&>(rhs);
-    fkMap = rhs1.fkMap;
-    fCurrentMap = rhs1.fCurrentMap;
-    fI = rhs1.fI;
-    fJ = rhs1.fJ;
+//    const AliMUON2DMapIterator& rhs1 = static_cast<const AliMUON2DMapIterator&>(rhs);
+    AliFatalGeneral("operator=(TIterator&)",""); // as in copy ctor
   }
   return *this;
 }
@@ -102,11 +74,16 @@ AliMUON2DMapIterator::GetCollection() const
 }
 
 //_____________________________________________________________________________
-AliMpExMap*
-AliMUON2DMapIterator::Map(Int_t i) const
+TIterator*
+AliMUON2DMapIterator::NextIterator()
 {
-  /// Get the map at a given index
-  return static_cast<AliMpExMap*>(fkMap->GetObjectFast(i));
+  /// Get next map (from fIter1) and create an iterator to it
+  
+  AliMpExMap* m = static_cast<AliMpExMap*>(fIter1->Next());
+
+  if (!m) return 0x0;
+  
+  return m->CreateIterator();
 }
 
 //_____________________________________________________________________________
@@ -115,25 +92,17 @@ AliMUON2DMapIterator::Next()
 {
   /// return next object
   
-  if (!fCurrentMap) return 0x0;
-  
-  ++fJ;
+  if (!fIter2) return 0x0;
+
+  TObject* o = fIter2->Next();
   
-  if ( fJ < fCurrentMap->GetSize() ) 
+  if (!o)
   {
-    return fCurrentMap->GetObjectFast(fJ);
-  }
-  else
-  {
-    ++fI;
-    if ( fI < fkMap->GetSize() )
-    {
-      fCurrentMap = Map(fI);
-      fJ = -1;
-      return Next();
-    }
-    return 0x0;
+    fIter2 = NextIterator();
+    return Next();
   }
+  
+  return o;
 }
 
 //_____________________________________________________________________________
@@ -141,15 +110,9 @@ void
 AliMUON2DMapIterator::Reset()
 {
   /// rewind the iterator
-  fI = -1;
-  fJ = -1;
-  fCurrentMap = 0x0;
   
-  if ( fkMap->GetSize() > 0 )
-  {
-    fI = 0;
-    fCurrentMap = Map(fI);
-    fJ = -1;
-  }
+  delete fIter2;
+  fIter1->Reset();
+  fIter2 = NextIterator();
 }
 
index 2c2d7d8..695f77b 100644 (file)
@@ -23,9 +23,6 @@ class AliMUON2DMapIterator : public TIterator
 {
 public:
   AliMUON2DMapIterator(const AliMpExMap& theMap);
-  AliMUON2DMapIterator(const AliMUON2DMapIterator& rhs);
-  AliMUON2DMapIterator& operator=(const AliMUON2DMapIterator& rhs);
-  TIterator& operator=(const TIterator& rhs);
   
   virtual ~AliMUON2DMapIterator();
   
@@ -37,16 +34,20 @@ public:
   virtual const TCollection* GetCollection() const;
   
 private:
-    
-  AliMpExMap* Map(Int_t i) const;
+  TIterator* NextIterator();
   
 private:
+  /// Not implemented
+  AliMUON2DMapIterator(const AliMUON2DMapIterator& rhs);
+  /// Not implemented
+  AliMUON2DMapIterator& operator=(const AliMUON2DMapIterator& rhs);
+  TIterator& operator=(const TIterator& rhs);
+
   const AliMpExMap* fkMap; ///< Top map we iterate upon
-  AliMpExMap* fCurrentMap; ///< Current map (inside top map) we are iterating upon
-  Int_t fI;                ///< Map(fI) is fCurrentMap  
-  Int_t fJ;                ///< Current position in fCurrentMap
+  TIterator* fIter1; ///< first iterator
+  TIterator* fIter2; ///< second iterator
   
-  ClassDef(AliMUON2DMapIterator,0) // VDataIterator for 2D maps
+  ClassDef(AliMUON2DMapIterator,0) // TIterator for AliMUON2D maps
 };
 
 
index b408407..37df45d 100644 (file)
 //-----------------------------------------------------------------------------
 
 #include "AliMUON2DMapIteratorByI.h"
-
+#include "AliMpExMapIterator.h"
 #include "AliMpExMap.h"
+#include "AliLog.h"
 
 /// \cond CLASSIMP
 ClassImp(AliMUON2DMapIteratorByI)
 /// \endcond
 
 //_____________________________________________________________________________
-AliMUON2DMapIteratorByI::AliMUON2DMapIteratorByI(const AliMpExMap& theMap,
-                                                 Int_t firstI,
-                                                 Int_t lastI)
+AliMUON2DMapIteratorByI::AliMUON2DMapIteratorByI(const AliMpExMap& theMap, Int_t firstI, Int_t lastI)
 : TIterator(),
 fkMap(&theMap),
+fIter1(theMap.CreateIterator()),
 fIter2(0x0),
-fCurrentI(-1),
-fCurrentJ(-1),
 fFirstI(firstI),
-fLastI(lastI)
+fLastI(lastI),
+fCurrentI(-1)
 {
   /// default ctor
   Reset();
 }
 
 //_____________________________________________________________________________
-AliMUON2DMapIteratorByI::AliMUON2DMapIteratorByI(const AliMUON2DMapIteratorByI& rhs)
-:TIterator(rhs),
-fkMap(rhs.fkMap),
-fIter2(0x0),
-fCurrentI(rhs.fCurrentI),
-fCurrentJ(rhs.fCurrentJ),
-fFirstI(rhs.fFirstI),
-fLastI(rhs.fLastI)
-{
-  /// copy ctor
-  if ( rhs.fIter2 ) fIter2 = new TExMapIter(*(rhs.fIter2));
-}
-
-//_____________________________________________________________________________
-AliMUON2DMapIteratorByI&
-AliMUON2DMapIteratorByI::operator=(const AliMUON2DMapIteratorByI& rhs)
-{
-  /// assignment operator
-  if ( this != &rhs ) 
-  {
-    fkMap = rhs.fkMap;
-    fIter2 = 0x0;
-    if ( rhs.fIter2 ) fIter2 = new TExMapIter(*(rhs.fIter2));
-    fCurrentI = rhs.fCurrentI;
-    fCurrentJ = rhs.fCurrentJ;
-    fFirstI = rhs.fFirstI;
-    fLastI = rhs.fLastI;
-  }
-  return *this;
-}
-
-//_____________________________________________________________________________
-TIterator&
+TIterator& 
 AliMUON2DMapIteratorByI::operator=(const TIterator& rhs)
 {
-  /// overriden assigment operator (imposed by Root's declaration of TIterator ?)
+  /// overriden operator= (imposed by Root's definition of TIterator::operator= ?)
+  
   if ( this != &rhs && rhs.IsA() == AliMUON2DMapIteratorByI::Class() ) 
   {
-    const AliMUON2DMapIteratorByI& rhs1 = static_cast<const AliMUON2DMapIteratorByI&>(rhs);
-    fkMap = rhs1.fkMap;
-    fIter2 = 0x0;
-    if ( rhs1.fIter2 ) fIter2 = new TExMapIter(*(rhs1.fIter2));
-    fCurrentI = rhs1.fCurrentI;
-    fCurrentJ = rhs1.fCurrentJ;
-    fFirstI = rhs1.fFirstI;
-    fLastI = rhs1.fLastI;
+    //    const AliMUON2DMapIteratorByI& rhs1 = static_cast<const AliMUON2DMapIteratorByI&>(rhs);
+    AliFatalGeneral("operator=(TIterator&)",""); // as in copy ctor
   }
   return *this;
 }
@@ -106,56 +68,46 @@ AliMUON2DMapIteratorByI::operator=(const TIterator& rhs)
 AliMUON2DMapIteratorByI::~AliMUON2DMapIteratorByI()
 {
   /// dtor
-  delete fIter2;
 }
 
 //_____________________________________________________________________________
 const TCollection* 
 AliMUON2DMapIteratorByI::GetCollection() const
 {
-  /// Not implemented
+  /// Return 0 as we're not really dealing with a Root TCollection...
   return 0x0;
 }
 
 //_____________________________________________________________________________
-TObject*
-AliMUON2DMapIteratorByI::GetValue(TExMapIter& iter, Int_t& theKey) const
+AliMpExMapIterator*
+AliMUON2DMapIteratorByI::NextIterator()
 {
-  /// return the value corresponding to theKey in iterator iter
-  theKey = -1;
-  Long_t key, value;
-  Bool_t ok = iter.Next(key,value);
-  if (!ok) return 0x0;
-  theKey = (Int_t)(key & 0xFFFF);
-  return reinterpret_cast<TObject*>(value);
+  /// Get next map (from fIter1) and create an iterator to it
+  
+  AliMpExMap* m = static_cast<AliMpExMap*>(fIter1->Next(fCurrentI));
+  
+  if (!m) return 0x0;
+  
+  if ( fCurrentI < fFirstI || fCurrentI > fLastI ) return NextIterator(); // try again
+
+  return m->CreateIterator();
 }
 
 //_____________________________________________________________________________
 TObject*
 AliMUON2DMapIteratorByI::Next()
 {
-  /// logic :
-  /// get TObject* from fIter2
-  /// if null, increment fIter2 by getting next map from fMap
-  
+  /// return next object
+
   if (!fIter2) return 0x0;
   
-  TObject* o = GetValue(*fIter2,fCurrentJ);
+  TObject* o = fIter2->Next();
+  
   if (!o)
   {
-    // fIter2 exhausted, try to get the next one
-    delete fIter2;
-    fIter2 = 0x0;
-    AliMpExMap* m(0x0);
-    while ( !m && fCurrentI < fLastI ) 
-    {
-      ++fCurrentI;
-      m = static_cast<AliMpExMap*>(fkMap->GetValue(fCurrentI));
-    }
-    if (!m) return 0x0; // we are done
-    fIter2 = new TExMapIter(m->GetIterator());
-    o = GetValue(*fIter2,fCurrentJ);
-  }
+    fIter2 = NextIterator();
+    return Next();
+  }  
   
   return o;
 }
@@ -165,19 +117,10 @@ void
 AliMUON2DMapIteratorByI::Reset()
 {
   /// rewind the iterator
-  delete fIter2;
-  fIter2 = 0x0;
-  fCurrentI = fFirstI;
-  AliMpExMap* m;
-  
-  while ( !(  m = static_cast<AliMpExMap*>(fkMap->GetValue(fCurrentI) ) ) && 
-          fCurrentI < fLastI )
-  {
-    ++fCurrentI;
-  }
   
-  if ( m ) 
-  {
-    fIter2 = new TExMapIter(m->GetIterator());
-  }
+  delete fIter2;
+  fIter1->Reset();
+  fIter2 = NextIterator();
+  fCurrentI = -1;
 }
+
index b85b60f..c906e1f 100644 (file)
 /// 
 //  Author Laurent Aphecetche
 
-#ifndef ROOT_TExMap
-#  include "TExMap.h"
-#endif
 #ifndef ROOT_TIterator
 #  include "TIterator.h"
 #endif
 
 class AliMpExMap;
+class AliMpExMapIterator;
 
 //_____________________________________________________________________________
 class AliMUON2DMapIteratorByI : public TIterator
@@ -27,9 +25,6 @@ class AliMUON2DMapIteratorByI : public TIterator
 public:
   AliMUON2DMapIteratorByI(const AliMpExMap& theMap, 
                           Int_t firstI, Int_t lastI);
-  AliMUON2DMapIteratorByI(const AliMUON2DMapIteratorByI& rhs);
-  TIterator& operator=(const TIterator& rhs);
-  AliMUON2DMapIteratorByI& operator=(const AliMUON2DMapIteratorByI& rhs);
   
   virtual ~AliMUON2DMapIteratorByI();
   
@@ -39,18 +34,23 @@ public:
   virtual void Reset(); 
 
   virtual const TCollection* GetCollection() const;
-  
+
 private:
-  
-  TObject* GetValue(TExMapIter& iter, Int_t& key) const;
+    AliMpExMapIterator* NextIterator();
   
 private:
-  const AliMpExMap* fkMap; //!< map to iterate upon
-  TExMapIter* fIter2; //!< second iterator
-  Int_t fCurrentI; //!< current index in direction i 
-  Int_t fCurrentJ; //!< current index in direction j
-  Int_t fFirstI; //!< first I to iterate upon
-  Int_t fLastI; //!< last I to iterate upon
+  /// Not implemented
+  AliMUON2DMapIteratorByI(const AliMUON2DMapIteratorByI& rhs);
+  /// Not implemented
+  AliMUON2DMapIteratorByI& operator=(const AliMUON2DMapIteratorByI& rhs);
+  TIterator& operator=(const TIterator& rhs);
+
+  const AliMpExMap* fkMap; ///< Top map we iterate upon
+  AliMpExMapIterator* fIter1; ///< first iterator
+  TIterator* fIter2; ///< second iterator
+  Int_t fFirstI; ///< start of range for I
+  Int_t fLastI; ///< end of range for I
+  Int_t fCurrentI; ///< current value of I 
   
   ClassDef(AliMUON2DMapIteratorByI,0) // VDataIterator for 2D maps
 };
index 4092759..645f81c 100644 (file)
@@ -39,6 +39,7 @@
 #include "AliMillepede.h"
 
 #include "AliMpExMap.h"
+#include "AliMpExMapIterator.h"
 
 #include "AliLog.h"
 
@@ -991,13 +992,12 @@ AliMUONAlignment::ReAlign(const AliMUONGeometryTransformer * transformer,
     if (verbose)
       AliInfo(Form("%i DEs in old GeometryStore  %i",detElements->GetSize(), iMt));
 
-    for (Int_t iDe = 0; iDe < detElements->GetSize(); iDe++) {
-      // detection elements.
-      AliMUONGeometryDetElement *detElement =
-       (AliMUONGeometryDetElement *) detElements->GetObject(iDe);
-      if (!detElement)
-       AliFatal("Detection element not found.");
-
+    TIter next(detElements->CreateIterator());
+    AliMUONGeometryDetElement* detElement;
+    Int_t iDe(-1);
+    while ( ( detElement = static_cast<AliMUONGeometryDetElement*>(next()) ) )
+    {
+      ++iDe;
       /// make a new detection element
       AliMUONGeometryDetElement *newDetElement =
        new AliMUONGeometryDetElement(detElement->GetId(),
index 6fcf7bb..2613779 100644 (file)
@@ -49,7 +49,6 @@
 #include "AliMpCDB.h"
 #include "AliMpConstants.h"
 #include "AliMpDDLStore.h"
-#include "AliMpDEIterator.h"
 #include "AliMpDEManager.h"
 #include "AliMpDetElement.h"
 #include "AliMpFiles.h"
@@ -632,7 +631,7 @@ AliMUONCDB::MakeLocalTriggerMaskStore(AliMUONVStore& localBoardMasks) const
   AliCodeTimerAuto("");
   
   Int_t ngenerated(0);
-  // Generate fake mask values for 234 localboards and put that into
+  // Generate fake mask values for all localboards and put that into
   // one single container (localBoardMasks)
   for ( Int_t i = 1; i <= AliMpConstants::TotalNofLocalBoards(); ++i )
   {
@@ -832,7 +831,7 @@ AliMUONCDB::WriteLocalTriggerMasks(Int_t startRun, Int_t endRun)
 {  
   /// Write local trigger masks to OCDB
   
-  AliMUONVStore* ltm = new AliMUON1DArray(235);
+  AliMUONVStore* ltm = new AliMUON1DArray(AliMpConstants::TotalNofLocalBoards()+1);
   Int_t ngenerated = MakeLocalTriggerMaskStore(*ltm);
   AliInfo(Form("Ngenerated = %d",ngenerated));
   if (ngenerated>0)
index fb0c086..68f305a 100644 (file)
@@ -447,5 +447,102 @@ AliMUONCalibrationData::Reset()
   fNeighbours = 0x0;
 }
 
+//_____________________________________________________________________________
+void
+AliMUONCalibrationData::Check(Int_t runNumber)
+{
+  /// Self-check to see if we can read all data for a given run 
+  /// from the current OCDB...
+  
+  if ( ! CreateCapacitances(runNumber) )
+  {
+    AliErrorClass("Could not read capacitances");
+  }
+  else
+  {
+    AliInfoClass("Capacitances read OK");
+  }
+
+  if ( ! CreateGains(runNumber) ) 
+  {
+    AliErrorClass("Could not read gains");
+  }
+  else
+  {
+    AliInfoClass("Gains read OK");
+  }
+
+  if ( ! CreateGlobalTriggerCrateConfig(runNumber) ) 
+  {
+    AliErrorClass("Could not read Trigger Crate Config");
+  }
+  else
+  {
+    AliInfoClass("TriggerBoardMasks read OK");
+  }
+
+  if ( !  CreateHV(runNumber) )
+  {
+    AliErrorClass("Could not read HV");
+  }
+  else
+  {
+    AliInfoClass("HV read OK");
+  }
+
+  if ( ! CreateNeighbours(runNumber) )
+  {
+    AliErrorClass("Could not read Neighbours");
+  }
+  else
+  {
+    AliInfoClass("Neighbours read OK");
+  }
+
+  if ( !  CreateLocalTriggerBoardMasks(runNumber) )
+  {
+    AliErrorClass("Could not read LocalTriggerBoardMasks");
+  }
+  else
+  {
+    AliInfoClass("LocalTriggerBoardMasks read OK");
+  }
+  
+  if ( ! CreatePedestals(runNumber) )
+  {
+    AliErrorClass("Could not read pedestals");
+  }
+  else
+  {
+    AliInfoClass("Pedestals read OK");
+  }
+  
+  if ( ! CreateRegionalTriggerConfig(runNumber) )
+  {
+    AliErrorClass("Could not read RegionalTriggerConfig");
+  }
+  else
+  {
+    AliInfoClass("RegionalTriggerBoardMasks read OK");
+  }
+  
+  if ( ! CreateTriggerLut(runNumber) )
+  {
+    AliErrorClass("Could not read TriggerLut");
+  }
+  else
+  {
+    AliInfoClass("TriggerLut read OK");
+  }
+
+  if ( ! CreateTriggerEfficiency(runNumber) )
+  {
+    AliErrorClass("Could not read TriggerEfficiency");
+  }
+  else    
+  {
+    AliInfoClass("TriggerEfficiency read OK");
+  }
+}
 
 
index 43013a9..1f1c4c9 100644 (file)
@@ -116,6 +116,8 @@ public:
 
   static TObject* CreateObject(Int_t runNumber, const char* path);
   
+  static void Check(Int_t runNumber);
+  
 protected:
   /// Not implemented
   AliMUONCalibrationData(const AliMUONCalibrationData& other);
index ccef521..e51ab12 100644 (file)
@@ -43,7 +43,7 @@ TNamed(name,name),
 fID(id),
 fDead(-1),
 fMaximum(maxNumber),
-fMissing(new AliMpExMap(kTRUE))
+fMissing(new AliMpExMap)
 {
   /// ctor. id is the number of that item, maxNumber is the maximum number
   /// of sub-item it can contains, and name is a label, e.g. de, chamber, manu.
index 57ee545..b393eef 100644 (file)
@@ -19,6 +19,7 @@
 #include "TExMap.h"
 #include "AliMpExMap.h"
 #include "AliMUONCheckItem.h"
+#include "AliLog.h"
 
 //-----------------------------------------------------------------------------
 /// \class AliMUONCheckItemIterator
@@ -45,8 +46,10 @@ AliMUONCheckItemIterator::AliMUONCheckItemIterator(const AliMUONCheckItem& item)
 fIter(0x0)
 {
   /// ctor
+  /// \todo To be reimplemented
   AliMpExMap* m = item.fMissing;
-  fIter = new TExMapIter(m->GetIterator());
+  AliFatal("Reimplement me w/o AliMpExMap::GetIterator()");
+//  fIter = new TExMapIter(m->GetIterator());
 }
 
 //_____________________________________________________________________________
index f734c69..f1daa86 100644 (file)
@@ -34,8 +34,7 @@ private:
   AliMUONCheckItemIterator(const AliMUONCheckItemIterator&);
   /// Not implemented
   AliMUONCheckItemIterator& operator=(const AliMUONCheckItemIterator&);
-  
-private:
+
   TExMapIter* fIter; //!< the actual iterator doing the job
   
   ClassDef(AliMUONCheckItemIterator,1) // Iterator for AliMUONCheckItem objects
index aa0b9f3..e8331b9 100644 (file)
@@ -90,7 +90,11 @@ void AliMUONClusterStoreV2::Clear(Option_t*)
   /// Clear the internal cluster array AND the index
   fClusters->Clear("C");
   if (fMap) {
-    fMap->Clear("C");
+    Int_t nChamber = AliMpConstants::NofTrackingChambers();
+    for (Int_t chamber=0; chamber<nChamber; chamber++) {
+      AliMpExMap *map = static_cast<AliMpExMap *>(fMap->UncheckedAt(chamber));
+      map->Clear("C");
+    }
     fMapped = kFALSE;
   }
 }
@@ -219,13 +223,13 @@ void AliMUONClusterStoreV2::ReMap()
     // Create one map per chamber
     AliMpExMap *map;
     for (Int_t chamber=0; chamber<nChamber; chamber++) {
-      map = new((*fMap)[chamber]) AliMpExMap(kTRUE);
+      map = new((*fMap)[chamber]) AliMpExMap;
       map->SetOwner(kFALSE);
     }
   }
   else {
     for (Int_t chamber=0; chamber<nChamber; chamber++) {
-      AliMpExMap *map = static_cast<AliMpExMap *>(fMap->At(chamber));
+      AliMpExMap *map = static_cast<AliMpExMap *>(fMap->UncheckedAt(chamber));
       map->Clear("C");
     }
   }  
index c6c2f8a..379b11c 100644 (file)
 //-----------------------------------------------------------------------------
 
 #include "AliMUONClusterStoreV2Iterator.h"
-
 #include "AliMUONClusterStoreV2.h"
 
+#include "AliMpExMapIterator.h"
 #include "AliMpExMap.h"
 
-#include <TExMap.h>
+#include "AliLog.h"
 
 /// \cond CLASSIMP
 ClassImp(AliMUONClusterStoreV2Iterator)
@@ -55,40 +55,15 @@ AliMUONClusterStoreV2Iterator::AliMUONClusterStoreV2Iterator(const AliMUONCluste
 }
 
 //_____________________________________________________________________________
-AliMUONClusterStoreV2Iterator::AliMUONClusterStoreV2Iterator(const AliMUONClusterStoreV2Iterator& iter)
-: TIterator(iter),
-  fStore(iter.fStore),
-  fFirstChamberId(iter.fFirstChamberId),
-  fLastChamberId(iter.fLastChamberId),
-  fCurrentChamberId(iter.fCurrentChamberId),
-  fChamberIterator(0x0)
-{
-  /// Copy constructor
-  if (iter.fChamberIterator) fChamberIterator = new TExMapIter(*(iter.fChamberIterator));
-}
-
-//_____________________________________________________________________________
-AliMUONClusterStoreV2Iterator& AliMUONClusterStoreV2Iterator::operator=(const AliMUONClusterStoreV2Iterator& iter)
-{
-  /// Assignment operator
-  if ( this != &iter ) {
-    fFirstChamberId = iter.fFirstChamberId;
-    fLastChamberId = iter.fLastChamberId;
-    fCurrentChamberId = iter.fCurrentChamberId;
-    delete fChamberIterator;
-    fChamberIterator = 0x0;
-    if (iter.fChamberIterator) fChamberIterator = new TExMapIter(*(iter.fChamberIterator));
-  }
-  return *this;
-}
-
-//_____________________________________________________________________________
-TIterator& AliMUONClusterStoreV2Iterator::operator=(const TIterator& iter)
+TIterator& AliMUONClusterStoreV2Iterator::operator=(const TIterator& /*iter*/)
 {
   /// Overriden operator= (imposed by Root's definition of TIterator::operator= ?)
+/*
   if ( this != &iter && iter.IsA() == AliMUONClusterStoreV2Iterator::Class() ) {
     (*this) = static_cast<const AliMUONClusterStoreV2Iterator&>(iter);
   }
+*/
+  AliFatalGeneral("AliMUONClusterStoreV2Iterator::operator=","reimplement me");
   return *this;
 }
 
@@ -103,9 +78,8 @@ AliMUONClusterStoreV2Iterator::~AliMUONClusterStoreV2Iterator()
 TObject* AliMUONClusterStoreV2Iterator::NextInCurrentChamber() const
 {
   /// Return the value corresponding to theKey in iterator iter
-  Long_t key, value;
-  if (fChamberIterator->Next(key,value)) return reinterpret_cast<TObject*>(value);
-  else return 0x0;
+  
+  return fChamberIterator->Next();
 }
 
 //_____________________________________________________________________________
@@ -120,7 +94,7 @@ TObject* AliMUONClusterStoreV2Iterator::Next()
     
     fCurrentChamberId++;
     delete fChamberIterator;
-    fChamberIterator = new TExMapIter(static_cast<AliMpExMap*>(fStore->fMap->UncheckedAt(fCurrentChamberId))->GetIterator());
+    fChamberIterator = static_cast<AliMpExMap*>(fStore->fMap->UncheckedAt(fCurrentChamberId))->CreateIterator();
     
     o = NextInCurrentChamber();
   }
@@ -134,5 +108,5 @@ void AliMUONClusterStoreV2Iterator::Reset()
   /// Reset the iterator
   fCurrentChamberId = fFirstChamberId;
   delete fChamberIterator;
-  fChamberIterator = new TExMapIter(static_cast<AliMpExMap*>(fStore->fMap->UncheckedAt(fCurrentChamberId))->GetIterator());
+  fChamberIterator = static_cast<AliMpExMap*>(fStore->fMap->UncheckedAt(fCurrentChamberId))->CreateIterator();
 }
index 821fa4e..1e6e8a5 100644 (file)
 #endif
 
 class AliMUONClusterStoreV2;
-class TExMapIter;
 
 class AliMUONClusterStoreV2Iterator : public TIterator
 {
 public:
   AliMUONClusterStoreV2Iterator(const AliMUONClusterStoreV2* store,
                                 Int_t firstChamberId, Int_t lastChamberId);
-  AliMUONClusterStoreV2Iterator(const AliMUONClusterStoreV2Iterator& rhs);
-  AliMUONClusterStoreV2Iterator& operator=(const AliMUONClusterStoreV2Iterator& rhs);
-  TIterator& operator=(const TIterator& rhs);
   
   virtual ~AliMUONClusterStoreV2Iterator();
   
@@ -41,11 +37,17 @@ private:
   TObject* NextInCurrentChamber() const;
   
 private:
+  /// Not implemented
+  AliMUONClusterStoreV2Iterator(const AliMUONClusterStoreV2Iterator& rhs);
+  /// Not implemented
+  AliMUONClusterStoreV2Iterator& operator=(const AliMUONClusterStoreV2Iterator& rhs);
+  TIterator& operator=(const TIterator& rhs);
+
   const AliMUONClusterStoreV2* fStore; ///< store to iterate upon
   Int_t fFirstChamberId; ///< first chamber
   Int_t fLastChamberId; ///< last chamber
   Int_t fCurrentChamberId; ///< current chamber
-  TExMapIter* fChamberIterator; ///< helper iterator
+  TIterator* fChamberIterator; ///< helper iterator
   
   ClassDef(AliMUONClusterStoreV2Iterator,0) // Implementation of TIterator
 };
index 06b52b3..1c5d4ac 100644 (file)
@@ -70,8 +70,7 @@ fStatusMapMaker(0x0),
 fPedestals(0x0),
 fGains(0x0),
 fApplyGains(0),
-fCapacitances(0x0),
-fNofChannelsPerDE(new TExMap)
+fCapacitances(0x0)
 {
   /// ctor
   
@@ -130,36 +129,6 @@ fNofChannelsPerDE(new TExMap)
   {
     fCapacitances = calib.Capacitances();
   }
-  
-  // FIXME: get the nof of channels per de directly within AliMpDetElement ?
-  // or use the AliMUONTrackerData class for that ?
-  
-  AliMpDEIterator it;
-  
-  it.First();
-  
-  while ( !it.IsDone() ) 
-  {
-    
-    AliMpDetElement* det = it.CurrentDE();
-    Int_t detElemId = det->GetId();
-    Int_t nchannels(0);
-    
-    for ( Int_t i = 0; i < det->GetNofBusPatches(); ++i ) 
-    {
-      Int_t busPatchId = det->GetBusPatchId(i);
-      AliMpBusPatch* bp = AliMpDDLStore::Instance()->GetBusPatch(busPatchId);
-      for ( Int_t j = 0; j < bp->GetNofManus(); ++j ) 
-      {
-        Int_t manuId = bp->GetManuId(j);
-        nchannels += det->NofChannelsInManu(manuId);
-      }        
-    }
-    
-    it.Next();
-    
-    fNofChannelsPerDE->Add((Long_t)detElemId,(Long_t)nchannels);
-  }
 }
 
 //_____________________________________________________________________________
@@ -173,7 +142,6 @@ AliMUONDigitCalibrator::~AliMUONDigitCalibrator()
   fLogger->Print();
 
   delete fLogger;
-  delete fNofChannelsPerDE;
 }
 
 //_____________________________________________________________________________
@@ -194,7 +162,8 @@ AliMUONDigitCalibrator::Calibrate(AliMUONVDigitStore& digitStore)
     {
       // Find out occupancy of that DE
       detElemId = digit->DetElemId();
-      Double_t nchannels = fNofChannelsPerDE->GetValue(detElemId);
+      AliMpDetElement* de = AliMpDDLStore::Instance()->GetDetElement(detElemId);
+      Double_t nchannels = de->NofChannels();
       Double_t occ = digitStore.GetSize(detElemId)/nchannels;
       if ( occ > 0.05 ) 
       {
index faa41e1..92010fa 100644 (file)
@@ -50,13 +50,12 @@ private:
     AliMUONVStore* fGains; //!< gain values
     Int_t fApplyGains; //!< whether we should apply gains or not, capa or not...
     AliMUONVStore* fCapacitances; //!< capa values
-    TExMap* fNofChannelsPerDE; //!< store nof channels within detection elements
     
     static const Int_t fgkNoGain; //!< do not apply gain calib at all
     static const Int_t fgkGainConstantCapa; //!< apply gain (from OCDB) with constant capa
     static const Int_t fgkGain; //!< apply gain and capa (from OCDB)
     
-  ClassDef(AliMUONDigitCalibrator,6) // Calibrate raw digit
+  ClassDef(AliMUONDigitCalibrator,7) // Calibrate raw digit
 };
 
 #endif
index 7664956..47c99f4 100644 (file)
@@ -28,6 +28,7 @@
 
 #include "AliMpDEManager.h"
 #include "AliMUONVDigit.h"
+#include "TObjArray.h"
 
 /// \cond CLASSIMP
 ClassImp(AliMUONDigitStoreV1Iterator)
index 9c4c3cc..589bf70 100644 (file)
 #include "AliMUONVClusterStore.h"
 #include "AliMUONVDigit.h"
 #include "AliMUONVDigitStore.h"
-#include "AliMUON1DMapIterator.h"
 #include "AliMUON2DMapIterator.h"
 #include "AliMUONTrackParam.h"
 #include "AliMUONTrackExtrap.h"
 #include "AliMUONConstants.h"
 
+#include "AliMpExMapIterator.h"
 #include "AliMpVSegmentation.h"
 #include "AliMpSegmentation.h"
 #include "AliMpIntPair.h"
@@ -72,7 +72,6 @@ AliMUONESDInterface::AliMUONESDInterface()
 : TObject(),
   fTracks(0x0),
   fDigits(0x0),
-  fTrackMap(0x0),
   fClusterMap(0x0),
   fDigitMap(0x0)
 {
@@ -85,7 +84,6 @@ AliMUONESDInterface::~AliMUONESDInterface()
   /// Destructor
   delete fTracks;
   delete fDigits;
-  delete fTrackMap;
   delete fClusterMap;
   delete fDigitMap;
 }
@@ -100,7 +98,6 @@ void AliMUONESDInterface::Clear(Option_t*)
   /// clear memory
   delete fTracks; fTracks = 0x0;
   delete fDigits; fDigits = 0x0;
-  delete fTrackMap; fTrackMap = 0x0;
   delete fClusterMap; fClusterMap = 0x0;
   delete fDigitMap; fDigitMap = 0x0;
 }
@@ -116,16 +113,13 @@ void AliMUONESDInterface::Reset()
   if (fDigits) fDigits->Clear("C");
   else fDigits = NewDigitStore();
   
-  if (fTrackMap) fTrackMap->Clear();
-  else fTrackMap = new AliMpExMap(kTRUE);
-  fTrackMap->SetOwner(kFALSE);
-  
   if (fClusterMap) fClusterMap->Clear();
-  else fClusterMap = new AliMpExMap(kTRUE);
+  else fClusterMap = new AliMpExMap;
   fClusterMap->SetOwner(kTRUE);
   
-  if (fDigitMap) fDigitMap->Clear("C");
-  else fDigitMap = new TClonesArray("AliMpExMap",10);
+  if (fDigitMap) fDigitMap->Clear();
+  else fDigitMap = new AliMpExMap;
+  fDigitMap->SetOwner(kTRUE);
 }
 
 //_____________________________________________________________________________
@@ -146,17 +140,15 @@ void AliMUONESDInterface::LoadEvent(AliESDEvent& esdEvent)
     // add it to track store
     AliMUONTrack* track = Add(*esdTrack, *fTracks);
     
-    // fill track map
-    fTrackMap->Add(iTrack, track);
-    
     // prepare cluster map
-    fClusterMap->Add(iTrack, new AliMpExMap(kTRUE));
-    AliMpExMap* cMap = (AliMpExMap*) fClusterMap->GetObjectFast(iTrack);
+    AliMpExMap* cMap = new AliMpExMap;
     cMap->SetOwner(kFALSE);
+    fClusterMap->Add(esdTrack->GetUniqueID(), cMap);
     
     // prepare digit maps
-    AliMpExMap* dMaps = new((*fDigitMap)[iTrack]) AliMpExMap(kTRUE);
+    AliMpExMap* dMaps = new AliMpExMap;
     dMaps->SetOwner(kTRUE);
+    fDigitMap->Add(esdTrack->GetUniqueID(), dMaps);
     
     // loop over ESD clusters
     Int_t nClusters = esdTrack->GetNClusters();
@@ -172,9 +164,9 @@ void AliMUONESDInterface::LoadEvent(AliESDEvent& esdEvent)
       cMap->Add(cluster->GetUniqueID(), cluster);
       
       // prepare digit map
-      dMaps->Add(esdCluster->GetUniqueID(), new AliMpExMap(kTRUE));
-      AliMpExMap* dMap = (AliMpExMap*) dMaps->GetObjectFast(iCluster);
+      AliMpExMap* dMap =new AliMpExMap;
       dMap->SetOwner(kFALSE);
+      dMaps->Add(esdCluster->GetUniqueID(), dMap);
       
       // loop over ESD pads
       Int_t nPads = esdCluster->GetNPads();
@@ -202,7 +194,7 @@ void AliMUONESDInterface::LoadEvent(AliESDEvent& esdEvent)
 Int_t AliMUONESDInterface::GetNTracks() const
 {
   /// return the number of tracks
-  return fTrackMap ? fTrackMap->GetSize() : 0;
+  return fTracks ? fTracks->GetSize() : 0;
 }
 
 //___________________________________________________________________________
@@ -210,16 +202,17 @@ Int_t AliMUONESDInterface::GetNClusters() const
 {
   /// return the number of clusters
   Int_t nClusters = 0;
-  Int_t nTracks = GetNTracks();
-  for (Int_t i = 0; i < nTracks; i++) nClusters += GetTrackFast(i)->GetNClusters();
+  AliMUONTrack *track;
+  TIter next(CreateTrackIterator());
+  while ((track = static_cast<AliMUONTrack*>(next()))) nClusters += track->GetNClusters();
   return nClusters;
 }
 
 //___________________________________________________________________________
-Int_t AliMUONESDInterface::GetNClusters(Int_t iTrack) const
+Int_t AliMUONESDInterface::GetNClusters(UInt_t trackId) const
 {
-  /// return the number of clusters in track "iTrack"
-  AliMUONTrack* track = GetTrack(iTrack);
+  /// return the number of clusters in track "trackId"
+  AliMUONTrack* track = FindTrack(trackId);
   return track ? track->GetNClusters() : 0;
 }
 
@@ -231,20 +224,21 @@ Int_t AliMUONESDInterface::GetNDigits() const
 }
 
 //___________________________________________________________________________
-Int_t AliMUONESDInterface::GetNDigits(Int_t iTrack) const
+Int_t AliMUONESDInterface::GetNDigits(UInt_t trackId) const
 {
-  /// return the number of digits in all clusters of track "iTrack"
+  /// return the number of digits in all clusters of track "trackId"
   Int_t nDigits = 0;
-  Int_t nClusters = GetNClusters(iTrack);
-  for (Int_t j = 0; j <  nClusters; j++) nDigits += GetClusterFast(iTrack,j)->GetNDigits();
+  AliMUONVCluster *cluster;
+  TIter next(CreateClusterIterator(trackId));
+  while ((cluster = static_cast<AliMUONVCluster*>(next()))) nDigits += cluster->GetNDigits();
   return nDigits;
 }
 
 //___________________________________________________________________________
-Int_t AliMUONESDInterface::GetNDigits(Int_t iTrack, Int_t iCluster) const
+Int_t AliMUONESDInterface::GetNDigits(UInt_t trackId, UInt_t clusterId) const
 {
   /// return the number of digits in cluster numbered "iCluster" of track "iTrack"
-  AliMUONVCluster* cluster = GetCluster(iTrack, iCluster);
+  AliMUONVCluster* cluster = FindCluster(trackId, clusterId);
   return cluster ? cluster->GetNDigits() : 0;
 }
 
@@ -257,50 +251,44 @@ Int_t AliMUONESDInterface::GetNDigitsInCluster(UInt_t clusterId) const
 }
 
 //___________________________________________________________________________
-AliMUONTrack* AliMUONESDInterface::GetTrack(Int_t iTrack) const
+AliMUONTrack* AliMUONESDInterface::FindTrack(UInt_t trackId) const
 {
-  /// return MUON track "iTrack" (0x0 if not found)
-  AliMUONTrack* track = fTrackMap ? (AliMUONTrack*) fTrackMap->GetObject(iTrack) : 0x0;
-  if (!track) AliWarning(Form("track %d does not exist",iTrack));
+  /// return track "trackId" (0x0 if not found)
+  AliMUONTrack *track = fTracks ? static_cast<AliMUONTrack*>(fTracks->FindObject(trackId)) : 0x0;
+  if (!track) AliWarning(Form("track %d does not exist",trackId));
   return track;
 }
 
 //___________________________________________________________________________
-AliMUONVCluster* AliMUONESDInterface::GetCluster(Int_t iTrack, Int_t iCluster) const
-{
-  /// return MUON cluster numbered "iCluster" in track "iTrack" (0x0 if not found)
-  AliMpExMap* cMap = fClusterMap ? (AliMpExMap*) fClusterMap->GetObject(iTrack) : 0x0;
-  AliMUONVCluster* cluster = cMap ? (AliMUONVCluster*) cMap->GetObject(iCluster) : 0x0;
-  if (!cluster) AliWarning(Form("cluster #%d in track %d does not exist",iCluster,iTrack));
-  return cluster;
-}
-
-//___________________________________________________________________________
-AliMUONVDigit* AliMUONESDInterface::GetDigit(Int_t iTrack, Int_t iCluster, Int_t iDigit) const
-{
-  /// return MUON digit numbered "iDigit" in cluster numbered "iCluster" of track "iTrack" (0x0 if not found)
-  AliMpExMap* dMaps = fDigitMap ? (AliMpExMap*) fDigitMap->At(iTrack) : 0x0;
-  AliMpExMap* dMap = dMaps ? (AliMpExMap*) dMaps->GetObject(iCluster) : 0x0;
-  AliMUONVDigit* digit = dMap ? (AliMUONVDigit*) dMap->GetObject(iDigit) : 0x0;
-  if (!digit) AliWarning(Form("digit #%d in cluster #%d of track %d does not exist",iDigit,iCluster,iTrack));
-  return digit;
-}
-
-//___________________________________________________________________________
 AliMUONVCluster* AliMUONESDInterface::FindCluster(UInt_t clusterId) const
 {
-  /// return cluster "clusterId" (0x0 if not found)
+  /// loop over tracks and return the first cluster "clusterId" found (0x0 if not found)
+  AliMpExMap *cMap;
   AliMUONVCluster* cluster = 0x0;
   
-  Int_t nTracks = GetNTracks();
-  for (Int_t i = 0; i < nTracks; i++) {
+  if (fClusterMap) {
     
-    cluster = (AliMUONVCluster*) ((AliMpExMap*) fClusterMap->GetObjectFast(i))->GetValue(clusterId);
-    if (cluster) break;
+    TIter next(fClusterMap->CreateIterator());
+    while ((cMap = static_cast<AliMpExMap*>(next()))) {
+      
+      cluster = static_cast<AliMUONVCluster*>(cMap->GetValue(clusterId));
+      if (cluster) return cluster;
+      
+    }
     
   }
   
   if (!cluster) AliWarning(Form("cluster %d does not exist",clusterId));
+  return 0x0;
+}
+
+//___________________________________________________________________________
+AliMUONVCluster* AliMUONESDInterface::FindCluster(UInt_t trackId, UInt_t clusterId) const
+{
+  /// return cluster "clusterId" in track "trackId" (0x0 if not found)
+  AliMpExMap *cMap = fClusterMap ? static_cast<AliMpExMap*>(fClusterMap->GetValue(trackId)) : 0x0;
+  AliMUONVCluster* cluster = cMap ? static_cast<AliMUONVCluster*>(cMap->GetValue(clusterId)) : 0x0;
+  if (!cluster) AliWarning(Form("cluster %d does not exist in track %d", clusterId, trackId));
   return cluster;
 }
 
@@ -328,11 +316,11 @@ TIterator* AliMUONESDInterface::CreateClusterIterator() const
 }
 
 //___________________________________________________________________________
-TIterator* AliMUONESDInterface::CreateClusterIterator(Int_t iTrack) const
+TIterator* AliMUONESDInterface::CreateClusterIterator(UInt_t trackId) const
 {
-  /// return iterator over clusters of track "iTrack"
-  AliMpExMap* cMap = fClusterMap ? (AliMpExMap*) fClusterMap->GetObject(iTrack) : 0x0;
-  return cMap ? new AliMUON1DMapIterator(*cMap) : 0x0;
+  /// return iterator over clusters of track "trackId"
+  AliMpExMap *cMap = fClusterMap ? static_cast<AliMpExMap*>(fClusterMap->GetValue(trackId)) : 0x0;
+  return cMap ? cMap->CreateIterator() : 0x0;
 }
 
 //___________________________________________________________________________
@@ -343,37 +331,42 @@ TIterator* AliMUONESDInterface::CreateDigitIterator() const
 }
 
 //___________________________________________________________________________
-TIterator* AliMUONESDInterface::CreateDigitIterator(Int_t iTrack) const
+TIterator* AliMUONESDInterface::CreateDigitIterator(UInt_t trackId) const
 {
-  /// return iterator over all digits of track "iTrack"
-  AliMpExMap* dMaps = fDigitMap ? (AliMpExMap*) fDigitMap->At(iTrack) : 0x0;
+  /// return iterator over all digits of track "trackId"
+  AliMpExMap* dMaps = fDigitMap ? static_cast<AliMpExMap*>(fDigitMap->GetValue(trackId)) : 0x0;
   return dMaps ? new AliMUON2DMapIterator(*dMaps) : 0x0;
 }
 
 //___________________________________________________________________________
-TIterator* AliMUONESDInterface::CreateDigitIterator(Int_t iTrack, Int_t iCluster) const
+TIterator* AliMUONESDInterface::CreateDigitIterator(UInt_t trackId, UInt_t clusterId) const
 {
-  /// return iterator over digits of cluster numbered "iCluster" in track "iTrack"
-  AliMpExMap* dMaps = fDigitMap ? (AliMpExMap*) fDigitMap->At(iTrack) : 0x0;
-  AliMpExMap* dMap = dMaps ? (AliMpExMap*) dMaps->GetObject(iCluster) : 0x0;
-  return dMap ? new AliMUON1DMapIterator(*dMap) : 0x0;
+  /// return iterator over digits of cluster "clusterId" in track "trackId"
+  AliMpExMap* dMaps = fDigitMap ? static_cast<AliMpExMap*>(fDigitMap->GetValue(trackId)) : 0x0;
+  AliMpExMap* dMap = dMaps ? static_cast<AliMpExMap*>(dMaps->GetValue(clusterId)) : 0x0;
+  return dMap ? dMap->CreateIterator() : 0x0;
 }
 
 //___________________________________________________________________________
 TIterator* AliMUONESDInterface::CreateDigitIteratorInCluster(UInt_t clusterId) const
 {
-  /// return iterator over digits of cluster "clusterId"
+  /// return iterator over digits of the first cluster "clusterId" found by looping over all tracks
+  AliMpExMap *dMaps;
   AliMpExMap* dMap = 0x0;
   
-  Int_t nTracks = GetNTracks();
-  for (Int_t i = 0; i < nTracks; i++) {
+  if (fDigitMap) {
     
-    dMap = (AliMpExMap*) ((AliMpExMap*) fDigitMap->UncheckedAt(i))->GetValue(clusterId);
-    if (dMap) break;
+    TIter next(fDigitMap->CreateIterator());
+    while ((dMaps = static_cast<AliMpExMap*>(next()))) {
+      
+      dMap = static_cast<AliMpExMap*>(dMaps->GetValue(clusterId));
+      if (dMap) return dMap->CreateIterator();
+      
+    }
     
   }
   
-  return dMap ? new AliMUON1DMapIterator(*dMap) : 0x0;
+  return 0x0;
 }
 
 //___________________________________________________________________________
@@ -742,11 +735,11 @@ void AliMUONESDInterface::MUONToESD(const AliMUONVCluster& cluster, AliESDMuonCl
   esdCluster.SetUniqueID(cluster.GetUniqueID());
   esdCluster.SetXYZ(cluster.GetX(), cluster.GetY(), cluster.GetZ());
   esdCluster.SetErrXY(cluster.GetErrX(), cluster.GetErrY());
+  esdCluster.SetCharge(cluster.GetCharge());
+  esdCluster.SetChi2(cluster.GetChi2());
   
-  if (digits) { // transfert all data...
+  if (digits) { // transfert all data if required
     
-    esdCluster.SetCharge(cluster.GetCharge());
-    esdCluster.SetChi2(cluster.GetChi2());
     AliESDMuonPad esdPad;
     for (Int_t i=0; i<cluster.GetNDigits(); i++) {
       AliMUONVDigit* digit = digits->FindObject(cluster.GetDigitId(i));
@@ -758,11 +751,6 @@ void AliMUONESDInterface::MUONToESD(const AliMUONVCluster& cluster, AliESDMuonCl
       esdCluster.AddPad(esdPad);
     }
     
-  } else { // ...or not
-    
-    esdCluster.SetCharge(0.);
-    esdCluster.SetChi2(0.);
-    
   }
   
 }
index 3933900..9858ea9 100644 (file)
@@ -14,8 +14,8 @@
 
 #include <AliMpExMap.h>
 #include <TObject.h>
-#include <TClonesArray.h>
 #include <TString.h>
+#include "AliLog.h"
 
 class AliMUONTrack;
 class AliMUONVTrackStore;
@@ -49,35 +49,25 @@ public: // methods to play with internal objects
   // Return numbers of tracks/clusters/digits
   Int_t GetNTracks() const;
   Int_t GetNClusters() const;
-  Int_t GetNClusters(Int_t iTrack) const;
+  Int_t GetNClusters(UInt_t trackId) const;
   Int_t GetNDigits() const;
-  Int_t GetNDigits(Int_t iTrack) const;
-  Int_t GetNDigits(Int_t iTrack, Int_t iCluster) const;
+  Int_t GetNDigits(UInt_t trackId) const;
+  Int_t GetNDigits(UInt_t trackId, UInt_t clusterId) const;
   Int_t GetNDigitsInCluster(UInt_t clusterId) const;
   
-  // Return internal MUON objects (faster than finders)
-  // ordering of the MUON objects is the same as in ESD
-  AliMUONTrack*    GetTrack(Int_t iTrack) const;
-  AliMUONVCluster* GetCluster(Int_t iTrack, Int_t iCluster) const;
-  AliMUONVDigit*   GetDigit(Int_t iTrack, Int_t iCluster, Int_t iDigit) const;
-  
-  // Quickly return internal MUON objects (indices unchecked)
-  // ordering of the MUON objects is the same as in ESD
-  AliMUONTrack*    GetTrackFast(Int_t iTrack) const;
-  AliMUONVCluster* GetClusterFast(Int_t iTrack, Int_t iCluster) const;
-  AliMUONVDigit*   GetDigitFast(Int_t iTrack, Int_t iCluster, Int_t iDigit) const;
-  
-  // Find internal MUON objects (slower than getters)
+  // Find internal MUON objects
+  AliMUONTrack*    FindTrack(UInt_t trackId) const;
   AliMUONVCluster* FindCluster(UInt_t clusterId) const;
+  AliMUONVCluster* FindCluster(UInt_t trackId, UInt_t clusterId) const;
   AliMUONVDigit*   FindDigit(UInt_t digitId) const;
   
   // iterate over internal MUON objects
   TIterator* CreateTrackIterator() const;
   TIterator* CreateClusterIterator() const;
-  TIterator* CreateClusterIterator(Int_t iTrack) const;
+  TIterator* CreateClusterIterator(UInt_t trackId) const;
   TIterator* CreateDigitIterator() const;
-  TIterator* CreateDigitIterator(Int_t iTrack) const;
-  TIterator* CreateDigitIterator(Int_t iTrack, Int_t iCluster) const;
+  TIterator* CreateDigitIterator(UInt_t trackId) const;
+  TIterator* CreateDigitIterator(UInt_t trackId, UInt_t clusterId) const;
   TIterator* CreateDigitIteratorInCluster(UInt_t clusterId) const;
   
   
@@ -147,36 +137,12 @@ private:
   AliMUONVDigitStore* fDigits; ///< digit container
   
   // maps (to speed up data retrieval)
-  AliMpExMap*   fTrackMap;   ///< map of tracks
-  AliMpExMap*   fClusterMap; ///< map of clusters
-  TClonesArray* fDigitMap;   ///< map of digits
+  AliMpExMap* fClusterMap; ///< map of clusters
+  AliMpExMap* fDigitMap;   ///< map of digits
     
     
   ClassDef(AliMUONESDInterface,0)
 };
 
-
-//___________________________________________________________________________
-inline AliMUONTrack* AliMUONESDInterface::GetTrackFast(Int_t iTrack) const
-{
-  /// return MUON track "iTrack" without any check
-  return (AliMUONTrack*) fTrackMap->GetObjectFast(iTrack);
-}
-
-//___________________________________________________________________________
-inline AliMUONVCluster* AliMUONESDInterface::GetClusterFast(Int_t iTrack, Int_t iCluster) const
-{
-  /// return MUON cluster numbered "iCluster" in track "iTrack" without any check
-  return (AliMUONVCluster*) ((AliMpExMap*) fClusterMap->GetObjectFast(iTrack))->GetObjectFast(iCluster);
-}
-
-//___________________________________________________________________________
-inline AliMUONVDigit* AliMUONESDInterface::GetDigitFast(Int_t iTrack, Int_t iCluster, Int_t iDigit) const
-{
-  /// return MUON digit numbered "iDigit" in cluster numbered "iCluster" of track "iTrack" without any check
-  return (AliMUONVDigit*) ((AliMpExMap*) ((AliMpExMap*) fDigitMap->UncheckedAt(iTrack))->GetObjectFast(iCluster))->GetObjectFast(iDigit);
-}
-
-
 #endif
 
index 581fe66..0018974 100644 (file)
@@ -51,6 +51,7 @@
 #include "AliMUONGeometryBuilder.h"
 
 #include "AliMpExMap.h"
+#include "AliMpExMapIterator.h"
 
 #include "AliLog.h"
 
@@ -375,14 +376,11 @@ AliMUONGeometryMisAligner::MisAlign(const AliMUONGeometryTransformer *
       if (verbose)
        AliInfo(Form("%i DEs in old GeometryStore  %i",detElements->GetSize(), iMt));
 
-      for (Int_t iDe = 0; iDe < detElements->GetSize(); iDe++)
-       {                       // detection elements.
-         AliMUONGeometryDetElement *detElement =
-           (AliMUONGeometryDetElement *) detElements->GetObject(iDe);
-
-         if (!detElement)
-           AliFatal("Detection element not found.");
-
+      TIter next(detElements->CreateIterator());
+      AliMUONGeometryDetElement *detElement;
+      
+      while ( ( detElement = static_cast<AliMUONGeometryDetElement*>(next()) ) )
+      {
          /// make a new detection element
          AliMUONGeometryDetElement *newDetElement =
            new AliMUONGeometryDetElement(detElement->GetId(),
index 3db0cf6..95aec65 100644 (file)
@@ -66,7 +66,7 @@ AliMUONGeometryModuleTransformer::AliMUONGeometryModuleTransformer(Int_t moduleI
   fTransformation = new TGeoHMatrix("");
 
   // Det elements transformation stores
-  fDetElements = new AliMpExMap(true);
+  fDetElements = new AliMpExMap;
 }
 
 
index 2b1bd8b..19c0564 100644 (file)
@@ -39,7 +39,7 @@
 #include <TVector2.h>
 #include "AliMpVSegmentation.h"
 #include "AliMpSegmentation.h"
-
+#include "AliMpExMapIterator.h"
 #include "AliLog.h"
 #include "AliAlignObjMatrix.h"
 #include "AliAlignObj.h"
@@ -120,7 +120,7 @@ AliMUONGeometryTransformer::CreateDEAreas() const
 {
   /// Create DE areas
   
-  fDEAreas = new AliMpExMap(true);
+  fDEAreas = new AliMpExMap;
   
   AliMpDEIterator it;
 
@@ -455,11 +455,11 @@ AliMUONGeometryTransformer::LoadTransformations()
     
     // Loop over detection elements
     AliMpExMap* detElements = moduleTransformer->GetDetElementStore();    
-   
-    for (Int_t j=0; j<detElements->GetSize(); j++) {
-      AliMUONGeometryDetElement* detElement
-        = (AliMUONGeometryDetElement*)detElements->GetObject(j);
-
+    TIter next(detElements->CreateIterator());    
+    AliMUONGeometryDetElement* detElement;
+    
+    while ( ( detElement = static_cast<AliMUONGeometryDetElement*>(next()) ) )
+    {
       // Det element  symbolic name
       TString symnameDE = GetDESymName(detElement->GetId());
     
@@ -538,10 +538,10 @@ void AliMUONGeometryTransformer::WriteDetElemTransforms(ofstream& out) const
     AliMUONGeometryModuleTransformer* moduleTransformer 
       = (AliMUONGeometryModuleTransformer*)fModuleTransformers->At(i);
     AliMpExMap* detElements = moduleTransformer->GetDetElementStore();    
-
-    for (Int_t j=0; j<detElements->GetSize(); j++) {
-      AliMUONGeometryDetElement* detElement
-        = (AliMUONGeometryDetElement*)detElements->GetObject(j);
+    TIter next(detElements->CreateIterator());
+    AliMUONGeometryDetElement* detElement;
+    while ( ( detElement = static_cast<AliMUONGeometryDetElement*>(next()) ) )
+    {
       const TGeoMatrix* transform 
         = detElement->GetLocalTransformation(); 
        
@@ -822,11 +822,11 @@ void AliMUONGeometryTransformer::AddAlignableVolumes() const
 
     // Detection elements
     AliMpExMap* detElements = module->GetDetElementStore();    
-
-    for (Int_t j=0; j<detElements->GetSize(); j++) {
-      AliMUONGeometryDetElement* detElement
-        = (AliMUONGeometryDetElement*)detElements->GetObject(j);
-       
+    TIter next(detElements->CreateIterator());    
+    AliMUONGeometryDetElement* detElement;
+    
+    while ( ( detElement = static_cast<AliMUONGeometryDetElement*>(next()) ) )
+    {
       // Set detection element symbolic name
       TGeoPNEntry* pnEntryDE
         = gGeoManager->SetAlignableEntry(GetDESymName(detElement->GetId()), 
@@ -878,12 +878,13 @@ TClonesArray* AliMUONGeometryTransformer::CreateZeroAlignmentData() const
   for (Int_t i=0; i<fModuleTransformers->GetEntriesFast(); i++) {
     AliMUONGeometryModuleTransformer* moduleTransformer 
       = (AliMUONGeometryModuleTransformer*)fModuleTransformers->At(i);
-    AliMpExMap* detElements = moduleTransformer->GetDetElementStore();    
 
-    for (Int_t j=0; j<detElements->GetSize(); j++) {
-      AliMUONGeometryDetElement* detElement
-        = (AliMUONGeometryDetElement*)detElements->GetObject(j);
-       
+    AliMpExMap* detElements = moduleTransformer->GetDetElementStore();    
+    TIter next(detElements->CreateIterator());    
+    AliMUONGeometryDetElement* detElement;
+    
+    while ( ( detElement = static_cast<AliMUONGeometryDetElement*>(next()) ) )
+    {
       Int_t detElemId = detElement->GetId();
   
       // Align object ID
index d3db3e2..c13bb14 100644 (file)
@@ -37,7 +37,6 @@
 #include "AliMpArrayI.h"
 #include "AliMpConstants.h"
 #include "AliMpDDLStore.h"
-#include "AliMpDEIterator.h"
 #include "AliMpDEManager.h"
 #include "AliMpDetElement.h"
 #include "AliMpHVNamer.h"
index d09f934..1d44d68 100644 (file)
@@ -216,8 +216,8 @@ AliMUONPainterHelper::GenerateGeometry()
   AliMUONGeometryTransformer transformer;
   transformer.LoadGeometryData("transform.dat");
 //  transformer.LoadGeometryData("geometry.root"); //FIXME: add a protection if geometry.root file does not exist
-  fExplodedGlobalTransformations = new AliMpExMap(true);
-  fRealGlobalTransformations = new AliMpExMap(true);
+  fExplodedGlobalTransformations = new AliMpExMap;
+  fRealGlobalTransformations = new AliMpExMap;
   AliMpDEIterator deIt;
   deIt.First();
   while ( !deIt.IsDone() )
index 532b63b..630df04 100644 (file)
@@ -164,7 +164,7 @@ Int_t AliMUONRawWriter::Digits2Raw(AliMUONVDigitStore* digitStore,
   {
     AliCodeTimerAuto("for Tracker")
 
-    AliMpExMap busPatchMap(true);
+    AliMpExMap busPatchMap;
 
     Int_t nDDLs = AliDAQ::NumberOfDdls("MUONTRK");
     
@@ -235,8 +235,11 @@ AliMUONRawWriter::Digits2BusPatchMap(const AliMUONVDigitStore& digitStore,
   UChar_t channelId = 0;
   UShort_t charge = 0;
   Int_t busPatchId = 0;
+  Int_t currentBusPatchId = -1;
   UInt_t word;
   
+  AliMUONBusStruct* busStruct(0x0);
+  
   TIter next(digitStore.CreateTrackerIterator());
   AliMUONVDigit* digit;
   
@@ -281,9 +284,13 @@ AliMUONRawWriter::Digits2BusPatchMap(const AliMUONVDigitStore& digitStore,
       parity ^=  ((word >> i) & 0x1);
     }
     AliBitPacking::PackWord((UInt_t)parity,word,31,31);
-    
-    AliMUONBusStruct* busStruct = 
-      static_cast<AliMUONBusStruct*>(busPatchMap.GetValue(busPatchId));
+
+    if ( currentBusPatchId != busPatchId ) 
+    {
+      busStruct = 
+        static_cast<AliMUONBusStruct*>(busPatchMap.GetValue(busPatchId));
+      currentBusPatchId = busPatchId;
+    }
     
     if (!busStruct)
     {
index 9e038b0..76fb3d8 100644 (file)
@@ -101,11 +101,12 @@ AliMUONVTrackStore* AliMUONRefitter::ReconstructFromDigits()
   if (!newTrackStore) return 0x0;
   
   // loop over tracks and refit them (create new tracks)
-  Int_t nTracks = fESDInterface->GetNTracks();
-  for (Int_t iTrack = 0; iTrack < nTracks; iTrack++) {
-    AliMUONTrack *track = RetrackFromDigits(iTrack);
-    newTrackStore->Add(track);
-    delete track;
+  AliMUONTrack *track;
+  TIter next(fESDInterface->CreateTrackIterator());
+  while ((track = static_cast<AliMUONTrack*>(next()))) {
+    AliMUONTrack *newTrack = RetrackFromDigits(*track);
+    newTrackStore->Add(newTrack);
+    delete newTrack;
   }
   
   return newTrackStore;
@@ -138,12 +139,9 @@ AliMUONVTrackStore* AliMUONRefitter::ReconstructFromClusters()
 }
 
 //_____________________________________________________________________________
-AliMUONTrack* AliMUONRefitter::RetrackFromDigits(Int_t iTrack)
+AliMUONTrack* AliMUONRefitter::RetrackFromDigits(UInt_t trackId)
 {
-  /// refit track "iTrack" from the digits (i.e. re-clusterized the attached clusters):
-  /// several new clusters may be reconstructed per initial ESD cluster:
-  /// -> all the combinations of clusters are considered to build the new tracks
-  /// -> return the best track (largest number of clusters or best chi2 in case of equality)
+  /// refit track "trackId" from the digits (i.e. re-clusterized the attached clusters)
   /// it is the responsability of the user to delete the returned track
   
   if (!fESDInterface) {
@@ -152,92 +150,15 @@ AliMUONTrack* AliMUONRefitter::RetrackFromDigits(Int_t iTrack)
   }
   
   // get the track to refit
-  AliMUONTrack* track = fESDInterface->GetTrack(iTrack);
-  if (!track) return 0x0;
-  
-  // check if digits exist
-  if (fESDInterface->GetNDigits(iTrack) == 0) {
-    AliError(Form("no digit attached to track #%d",iTrack));
-    return 0x0;
-  }
-  
-  // prepare new track(s)
-  AliMUONVTrackStore* newTrackStore = AliMUONESDInterface::NewTrackStore();
-  if (!newTrackStore) return 0x0;
-  newTrackStore->Add(*track)->Clear("C");
-  
-  // prepare new cluster store
-  AliMUONVClusterStore* newClusterStore = AliMUONESDInterface::NewClusterStore();
-  if (!newClusterStore) {
-    delete newTrackStore;
-    return 0x0;
-  }
+  AliMUONTrack* track = fESDInterface->FindTrack(trackId);
   
-  // loop over clusters, re-clusterize and build new tracks
-  Int_t nClusters = track->GetNClusters();
-  for (Int_t iCluster = 0; iCluster < nClusters; iCluster++) {
-    
-    // reset the new cluster store
-    newClusterStore->Clear();
-    
-    // get the current cluster
-    AliMUONVCluster* cluster = fESDInterface->GetClusterFast(iTrack,iCluster);
-    
-    // re-clusterize current cluster
-    TIter next(fESDInterface->CreateDigitIterator(iTrack, iCluster));
-    fClusterServer->UseDigits(next);
-    Int_t nNewClusters = fClusterServer->Clusterize(cluster->GetChamberId(),*newClusterStore,AliMpArea());
-    
-    // check that re-clusterizing succeeded
-    if (nNewClusters == 0) {
-      AliWarning(Form("refit gave no cluster (chamber %d)",cluster->GetChamberId()));
-      AliInfo("initial ESD cluster:");
-      cluster->Print("FULL");
-      continue;
-    }
-    
-    // add the new cluster(s) to the tracks
-    AddClusterToTracks(*newClusterStore, *newTrackStore);
-    
-  }
-  
-  // refit the tracks and pick up the best one
-  AliMUONTrack *currentTrack, *bestTrack = 0x0;
-  Double_t currentChi2, bestChi2 = 1.e10;
-  Int_t currentNCluster, bestNClusters = 0;
-  TIter next(newTrackStore->CreateIterator());
-  while ((currentTrack = static_cast<AliMUONTrack*>(next()))) {
-    
-    // set the track parameters at first cluster if any (used as seed in original tracking)
-    AliMUONTrackParam* param = (AliMUONTrackParam*) currentTrack->GetTrackParamAtCluster()->First();
-    if (param) *param = *((AliMUONTrackParam*) track->GetTrackParamAtCluster()->First());
-    
-    // refit the track
-    if (!fTracker->RefitTrack(*currentTrack)) break;
-    
-    // find best track (the one with the higher number of cluster or the best chi2 in case of equality)
-    currentNCluster = currentTrack->GetNClusters();
-    currentChi2 = currentTrack->GetGlobalChi2();
-    if (currentNCluster > bestNClusters || (currentNCluster == bestNClusters && currentChi2 < bestChi2)) {
-      bestTrack = currentTrack;
-      bestNClusters = currentNCluster;
-      bestChi2 = currentChi2;
-    }
-    
-  }
-  
-  // copy best track and free memory
-  AliMUONTrack* newTrack = bestTrack ? new AliMUONTrack(*bestTrack) : 0x0;
-  delete newClusterStore;
-  delete newTrackStore;
-  
-  return newTrack;
+  return track ? RetrackFromDigits(*track) : 0x0;
 }
 
 //_____________________________________________________________________________
-AliMUONTrack* AliMUONRefitter::RetrackFromClusters(Int_t iTrack)
+AliMUONTrack* AliMUONRefitter::RetrackFromClusters(UInt_t trackId)
 {
-  /// refit track "iTrack" form the clusters (i.e. do not re-clusterize)
+  /// refit track "trackId" form the clusters (i.e. do not re-clusterize)
   /// it is the responsability of the user to delete the returned track
   
   if (!fESDInterface) {
@@ -246,7 +167,7 @@ AliMUONTrack* AliMUONRefitter::RetrackFromClusters(Int_t iTrack)
   }
   
   // get the track to refit
-  AliMUONTrack* track = fESDInterface->GetTrack(iTrack);
+  AliMUONTrack* track = fESDInterface->FindTrack(trackId);
   if (!track) return 0x0;
   
   // refit the track (create a new one)
@@ -260,9 +181,9 @@ AliMUONTrack* AliMUONRefitter::RetrackFromClusters(Int_t iTrack)
 }
 
 //_____________________________________________________________________________
-AliMUONVClusterStore* AliMUONRefitter::ReClusterize(Int_t iTrack, Int_t iCluster)
+AliMUONVClusterStore* AliMUONRefitter::ReClusterize(UInt_t trackId, UInt_t clusterId)
 {
-  /// re-clusterize cluster numbered "iCluster" in track "iTrack"
+  /// re-clusterize cluster numbered "clusterId" in track "trackId"
   /// several new clusters may be reconstructed
   /// it is the responsability of the user to delete the returned store
   
@@ -272,12 +193,12 @@ AliMUONVClusterStore* AliMUONRefitter::ReClusterize(Int_t iTrack, Int_t iCluster
   }
   
   // get the cluster to re-clusterize
-  AliMUONVCluster* cluster = fESDInterface->GetCluster(iTrack,iCluster);
+  AliMUONVCluster* cluster = fESDInterface->FindCluster(trackId,clusterId);
   if (!cluster) return 0x0;
   
   // check if digits exist
   if (cluster->GetNDigits() == 0) {
-    AliError(Form("no digit attached to cluster #%d in track %d",iCluster,iTrack));
+    AliError(Form("no digit attached to cluster #%d in track %d",clusterId,trackId));
     return 0x0;
   }
   
@@ -286,7 +207,7 @@ AliMUONVClusterStore* AliMUONRefitter::ReClusterize(Int_t iTrack, Int_t iCluster
   if (!clusterStore) return 0x0;
   
   // re-clusterize
-  TIter next(fESDInterface->CreateDigitIterator(iTrack, iCluster));
+  TIter next(fESDInterface->CreateDigitIterator(trackId, clusterId));
   fClusterServer->UseDigits(next);
   fClusterServer->Clusterize(cluster->GetChamberId(),*clusterStore,AliMpArea());
   
@@ -345,6 +266,92 @@ void AliMUONRefitter::CreateClusterServer(AliMUONGeometryTransformer& transforme
 }
 
 //_____________________________________________________________________________
+AliMUONTrack* AliMUONRefitter::RetrackFromDigits(const AliMUONTrack& track)
+{
+  /// refit the given track from the digits (i.e. re-clusterized the attached clusters):
+  /// several new clusters may be reconstructed per initial ESD cluster:
+  /// -> all the combinations of clusters are considered to build the new tracks
+  /// -> return the best track (largest number of clusters or best chi2 in case of equality)
+  
+  // check if digits exist
+  UInt_t trackId = track.GetUniqueID();
+  if (fESDInterface->GetNDigits(trackId) == 0) {
+    AliError(Form("no digit attached to track #%d",trackId));
+    return 0x0;
+  }
+  
+  // prepare new track(s)
+  AliMUONVTrackStore* newTrackStore = AliMUONESDInterface::NewTrackStore();
+  if (!newTrackStore) return 0x0;
+  newTrackStore->Add(track)->Clear("C");
+  
+  // prepare new cluster store
+  AliMUONVClusterStore* newClusterStore = AliMUONESDInterface::NewClusterStore();
+  if (!newClusterStore) {
+    delete newTrackStore;
+    return 0x0;
+  }
+  
+  // loop over clusters, re-clusterize and build new tracks
+  AliMUONVCluster* cluster;
+  TIter nextCluster(fESDInterface->CreateClusterIterator(trackId));
+  while ((cluster = static_cast<AliMUONVCluster*>(nextCluster()))) {
+    
+    // reset the new cluster store
+    newClusterStore->Clear();
+    
+    // re-clusterize current cluster
+    TIter nextDigit(fESDInterface->CreateDigitIterator(trackId, cluster->GetUniqueID()));
+    fClusterServer->UseDigits(nextDigit);
+    Int_t nNewClusters = fClusterServer->Clusterize(cluster->GetChamberId(),*newClusterStore,AliMpArea());
+    
+    // check that re-clusterizing succeeded
+    if (nNewClusters == 0) {
+      AliWarning(Form("refit gave no cluster (chamber %d)",cluster->GetChamberId()));
+      AliInfo("initial ESD cluster:");
+      cluster->Print("FULL");
+      continue;
+    }
+    
+    // add the new cluster(s) to the tracks
+    AddClusterToTracks(*newClusterStore, *newTrackStore);
+    
+  }
+  
+  // refit the tracks and pick up the best one
+  AliMUONTrack *currentTrack, *bestTrack = 0x0;
+  Double_t currentChi2, bestChi2 = 1.e10;
+  Int_t currentNCluster, bestNClusters = 0;
+  TIter next(newTrackStore->CreateIterator());
+  while ((currentTrack = static_cast<AliMUONTrack*>(next()))) {
+    
+    // set the track parameters at first cluster if any (used as seed in original tracking)
+    AliMUONTrackParam* param = (AliMUONTrackParam*) currentTrack->GetTrackParamAtCluster()->First();
+    if (param) *param = *((AliMUONTrackParam*) track.GetTrackParamAtCluster()->First());
+    
+    // refit the track
+    if (!fTracker->RefitTrack(*currentTrack)) break;
+    
+    // find best track (the one with the higher number of cluster or the best chi2 in case of equality)
+    currentNCluster = currentTrack->GetNClusters();
+    currentChi2 = currentTrack->GetGlobalChi2();
+    if (currentNCluster > bestNClusters || (currentNCluster == bestNClusters && currentChi2 < bestChi2)) {
+      bestTrack = currentTrack;
+      bestNClusters = currentNCluster;
+      bestChi2 = currentChi2;
+    }
+    
+  }
+  
+  // copy best track and free memory
+  AliMUONTrack* newTrack = bestTrack ? new AliMUONTrack(*bestTrack) : 0x0;
+  delete newClusterStore;
+  delete newTrackStore;
+  
+  return newTrack;
+}
+
+//_____________________________________________________________________________
 void AliMUONRefitter::AddClusterToTracks(const AliMUONVClusterStore &clusterStore, AliMUONVTrackStore &trackStore)
 {
   /// add clusters to each of the given tracks
index df700ff..7b043f4 100644 (file)
@@ -38,11 +38,11 @@ public:
   AliMUONVTrackStore* ReconstructFromClusters();
   
   // refit a particular track in the ESD event
-  AliMUONTrack* RetrackFromDigits(Int_t iTrack);
-  AliMUONTrack* RetrackFromClusters(Int_t iTrack);
+  AliMUONTrack* RetrackFromDigits(UInt_t trackId);
+  AliMUONTrack* RetrackFromClusters(UInt_t trackId);
   
   // re-clusterize a particular cluster in the ESD event
-  AliMUONVClusterStore* ReClusterize(Int_t iTrack, Int_t iCluster);
+  AliMUONVClusterStore* ReClusterize(UInt_t trackId, UInt_t clusterId);
   AliMUONVClusterStore* ReClusterize(UInt_t clusterId);
   
   
@@ -54,8 +54,10 @@ protected:
   
 private:
   
-  void                   CreateGeometryTransformer();
-  void                   CreateClusterServer(AliMUONGeometryTransformer& transformer);
+  void CreateGeometryTransformer();
+  void CreateClusterServer(AliMUONGeometryTransformer& transformer);
+  
+  AliMUONTrack* RetrackFromDigits(const AliMUONTrack& track);
   
   void AddClusterToTracks(const AliMUONVClusterStore &localClusterStore, AliMUONVTrackStore &trackStore);
   
index f745d72..1741bbe 100644 (file)
@@ -28,7 +28,7 @@
 #include "AliMpConstants.h"
 #include "AliMpFiles.h"
 #include "AliMpHelper.h"
-
+#include "AliMpExMapIterator.h"
 #include "AliLog.h"
 
 #include <TArrayI.h>
@@ -45,7 +45,7 @@ ClassImp(AliMUONRegionalTriggerConfig)
 //______________________________________________________________________________
 AliMUONRegionalTriggerConfig::AliMUONRegionalTriggerConfig()
   : TObject(),
-    fTriggerCrates(true)
+    fTriggerCrates()
 {
 /// Standard constructor
   
@@ -192,20 +192,11 @@ Int_t AliMUONRegionalTriggerConfig::GetNofTriggerCrates() const
 }
 
 //______________________________________________________________________________
-AliMUONTriggerCrateConfig* AliMUONRegionalTriggerConfig::GetTriggerCrate(Int_t index) const
+TIterator* 
+AliMUONRegionalTriggerConfig::CreateCrateIterator() const 
 { 
-    /// Return the trigger crates with given index;
-
-    return static_cast<AliMUONTriggerCrateConfig*>(fTriggerCrates.GetObject(index)); 
-}
-
-//______________________________________________________________________________
-AliMUONTriggerCrateConfig* AliMUONRegionalTriggerConfig::GetTriggerCrateFast(Int_t index) const
-{ 
-    /// Return the trigger crates with given index;
-    /// the index is not checked as we use the fast method in AliMpExMap.
-
-    return static_cast<AliMUONTriggerCrateConfig*>(fTriggerCrates.GetObjectFast(index)); 
+  /// Return trigger crates iterator
+  return fTriggerCrates.CreateIterator(); 
 }
 
 
index 9691fb8..81d288f 100644 (file)
@@ -16,8 +16,6 @@
 
 #include "AliMpExMap.h"
 
-#include <TObjArray.h>
-
 class AliMUONTriggerCrateConfig;
 class AliMUONLocalBoardConfig;
 
@@ -39,10 +37,8 @@ class AliMUONRegionalTriggerConfig : public  TObject{
     // method for looping
     
     Int_t GetNofTriggerCrates() const;
-    AliMUONTriggerCrateConfig* GetTriggerCrate(Int_t index) const;
-    AliMUONTriggerCrateConfig* GetTriggerCrateFast(Int_t index) const;
-    TExMapIter GetTriggerCrateItr() const;
-
+    
+    TIterator* CreateCrateIterator() const;
   
   private:
     // data members  
@@ -51,10 +47,6 @@ class AliMUONRegionalTriggerConfig : public  TObject{
   ClassDef(AliMUONRegionalTriggerConfig,1) // Regional trigger crate config
 };
 
-/// Return trigger crates iterator
-inline TExMapIter AliMUONRegionalTriggerConfig::GetTriggerCrateItr() const { 
-  return fTriggerCrates.GetIterator(); 
-}
 #endif 
 
 
index 401b57e..4086104 100644 (file)
@@ -76,8 +76,8 @@ AliMUONSimpleClusterServer::AliMUONSimpleClusterServer(AliMUONVClusterFinder* cl
     /// Ctor
     /// Note that we take ownership of the clusterFinder
     
-    fPads[0] = new AliMpExMap(true);
-    fPads[1] = new AliMpExMap(true);
+    fPads[0] = new AliMpExMap;
+    fPads[1] = new AliMpExMap;
     
 }
 
index 2ed8def..8efc3cb 100644 (file)
@@ -2460,7 +2460,6 @@ void AliMUONSt1GeometryBuilderV2::PlaceSector(const AliMpSector* sector,
           if (find(alreadyDone.begin(),alreadyDone.end(),motifPosId)
               != alreadyDone.end()) continue; // don't treat the same motif twice
 
-          AliMUONSt1SpecialMotif spMot = specialMap[motifPosId];
 #endif
 #ifdef WITH_ROOT
           Bool_t isDone = false;
@@ -2470,9 +2469,9 @@ void AliMUONSt1GeometryBuilderV2::PlaceSector(const AliMpSector* sector,
            i++;
          }  
          if (isDone) continue; // don't treat the same motif twice
+#endif
 
           AliMUONSt1SpecialMotif spMot = *((AliMUONSt1SpecialMotif*)specialMap.GetValue(motifPosId));
-#endif
          AliDebugStream(2) << chamber << " processing special motif: " << motifPosId << endl;  
 
           AliMpMotifPosition* motifPos = sector->GetMotifMap()->FindMotifPosition(motifPosId);
index 23e4a14..ba9cde3 100644 (file)
@@ -18,9 +18,7 @@
 
 #include "AliMpContainers.h"
 
-#ifdef WITH_ROOT
-  #include "TExMap.h"
-#endif
+#include <TExMap.h>
 
 #ifdef WITH_STL
   #include <map>
index 99d97e4..518970d 100644 (file)
@@ -128,9 +128,8 @@ AliMUONTrackerData::Add(const AliMUONVStore& store)
     // get number of bus patches and number of detection element
     // to initialize fBusPatchValues and fDEValues below
     
-    TExMapIter it(AliMpDDLStore::Instance()->GetBusPatchesIterator());
-    Long_t key,value;
-    while ( it.Next(key,value) ) ++numberOfBusPatches;
+    TIter next(AliMpDDLStore::Instance()->CreateBusPatchIterator());
+    while ( next() ) ++numberOfBusPatches;
     AliMpDEIterator deIt;
     deIt.First();
     while (!deIt.IsDone())
index 208f0fa..ffdc05b 100644 (file)
@@ -261,8 +261,7 @@ AliMUONTrackerIO::ReadCapacitances(const char* file, AliMUONVStore& capaStore)
       if (param)
       {
         AliErrorClass(Form("serialNumber %d appears several times !",serialNumber));
-        capaStore.Clear();
-        break;
+        continue;
       }
       param = new AliMUONCalibParamNF(2,AliMpConstants::ManuNofChannels(),serialNumber,0,1.0);
       Bool_t ok = capaStore.Add(param);
index 2a2f715..23239b6 100644 (file)
@@ -16,7 +16,7 @@
 // $Id$
 
 #include "AliMUONTriggerCrateStore.h"
-
+#include "AliMpExMapIterator.h"
 #include "AliMUONTriggerCrate.h"
 #include "AliMUONLocalTriggerBoard.h"
 #include "AliMUONRegionalTriggerBoard.h"
@@ -36,7 +36,6 @@
 #include <TSystem.h>
 #include <Riostream.h>
 
-
 //-----------------------------------------------------------------------------
 /// \class AliMUONTriggerCrateStore
 /// 
@@ -54,11 +53,7 @@ ClassImp(AliMUONTriggerCrateStore)
 AliMUONTriggerCrateStore::AliMUONTriggerCrateStore()
 : TObject(),
 fCrates(0x0),
-fLocalBoards(0x0),
-fCrateIterator(0x0),
-fLBIterator(0x0),
-fCurrentCrate(0x0),
-fCurrentLocalBoard(-1)
+fLocalBoards(0x0)
 {
 /// Default constructor
 }
@@ -67,8 +62,6 @@ fCurrentLocalBoard(-1)
 AliMUONTriggerCrateStore::~AliMUONTriggerCrateStore()
 {
 /// Destructor
-  delete fCrateIterator;
-  delete fLBIterator;
   delete fCrates;
   delete fLocalBoards;
 }
@@ -112,6 +105,24 @@ AliMUONTriggerCrateStore::LocalBoard(Int_t boardNumber) const
 }
 
 //_____________________________________________________________________________
+TIterator*
+AliMUONTriggerCrateStore::CreateCrateIterator() const
+{
+  /// Create iterator over crates
+
+  return fCrates ? fCrates->CreateIterator() : 0x0;
+}
+
+//_____________________________________________________________________________
+TIterator*
+AliMUONTriggerCrateStore::CreateLocalBoardIterator() const
+{
+  /// Create iterator over local boards
+
+  return fLocalBoards ? fLocalBoards->CreateIterator() : 0x0;
+}
+
+//_____________________________________________________________________________
 AliMUONTriggerCrate* 
 AliMUONTriggerCrateStore::Crate(const char *name) const
 {
@@ -170,100 +181,6 @@ TString AliMUONTriggerCrateStore::GetCrateName(Int_t ddl, Int_t reg) const
   return TString(name);
 }
 //_____________________________________________________________________________
-void
-AliMUONTriggerCrateStore::FirstCrate()
-{
-  /// initialize iteration
-  if ( !fCrates )
-  {
-    AliError("Object not properly initialized");
-    return;
-  }
-  if (!fCrateIterator)
-  {
-    fCrateIterator = new TExMapIter(fCrates->GetIterator());
-  }
-  fCrateIterator->Reset();
-}
-
-//_____________________________________________________________________________
-void
-AliMUONTriggerCrateStore::FirstLocalBoard()
-{
-  /// Initialize iterator on local boards.
-  /// Please note that we're not using directly the FirstCrate() and
-  /// NextCrate() methods here to avoid mix and match between crate iterator
-  /// and local board iterator
-  fCurrentCrate = 0x0;
-  fCurrentLocalBoard = 0;
-
-  if ( !fLBIterator ) 
-  {
-    fLBIterator = new TExMapIter(fCrates->GetIterator());
-  }
-  fLBIterator->Reset();
-  Long_t key, value;
-  Bool_t ok = fLBIterator->Next(key,value);
-  if ( ok )
-  {
-    fCurrentCrate = reinterpret_cast<AliMUONTriggerCrate*>(value);
-    fCurrentLocalBoard = 1;
-  }
-}
-
-//_____________________________________________________________________________
-AliMUONTriggerCrate*
-AliMUONTriggerCrateStore::NextCrate()
-{
-  /// Return the next crate in iteration, or 0 if iteration is ended.
-  if (!fCrateIterator) return 0x0;
-  
-  Long_t key, value;
-  Bool_t ok = fCrateIterator->Next(key,value);
-  if (ok)
-  {
-    return reinterpret_cast<AliMUONTriggerCrate*>(value);
-  }
-  else
-  {
-    return 0x0;
-  }
-}
-
-//_____________________________________________________________________________
-AliMUONLocalTriggerBoard*
-AliMUONTriggerCrateStore::NextLocalBoard()
-{  
-  /// Return the next local board in iteration, or 0 if iteration is ended.
-  if ( !fLBIterator ) return 0x0;
-
-  if ( fCurrentLocalBoard >= fCurrentCrate->Boards()->GetLast() +1)
-//  if ( fCurrentLocalBoard >= fCurrentCrate->Boards()->GetLast() )
-  {
-    // try to go to next crate, if some are left
-    Long_t key, value;
-    Bool_t ok = fLBIterator->Next(key,value);
-    if ( ok )
-    {
-      fCurrentCrate = reinterpret_cast<AliMUONTriggerCrate*>(value);
-      fCurrentLocalBoard = 1;
-    }
-    else
-    {
-      fCurrentLocalBoard = 0;
-      return 0x0;
-    }
-  }
-
-  AliMUONLocalTriggerBoard* lb = static_cast<AliMUONLocalTriggerBoard*>
-    (fCurrentCrate->Boards()->At(fCurrentLocalBoard));
-  
-  ++fCurrentLocalBoard;
-  
-  return lb;
-}
-
-//_____________________________________________________________________________
 Int_t
 AliMUONTriggerCrateStore::NumberOfCrates() const
 {
@@ -286,9 +203,9 @@ void
 AliMUONTriggerCrateStore::ReadFromFile(AliMUONCalibrationData* calibData) 
 {
   /// create crate and local board objects from mapping & calib (Ch.F)
-    fCrates = new AliMpExMap(kTRUE);
+    fCrates = new AliMpExMap;
     fCrates->SetOwner(kTRUE);
-    fLocalBoards = new AliMpExMap(kTRUE);
+    fLocalBoards = new AliMpExMap;
     fLocalBoards->SetOwner(kFALSE);
   
   
@@ -301,13 +218,11 @@ AliMUONTriggerCrateStore::ReadFromFile(AliMUONCalibrationData* calibData)
   if (!regionalConfig)
      AliWarning("No valid regional trigger configuration in CDB");
   
-    TExMapIter itr = AliMpDDLStore::Instance()->GetTriggerCrateItr();
-  
-    Long_t key, value;
+  TIter next(AliMpDDLStore::Instance()->GetRegionalTrigger()->CreateCrateIterator());
+  AliMpTriggerCrate* crateMapping;
   
-    while(itr.Next(key, value))
+  while ( ( crateMapping = static_cast<AliMpTriggerCrate*>(next()) ) )
     {
-      AliMpTriggerCrate* crateMapping =  reinterpret_cast<AliMpTriggerCrate*>(value);
     
       TString crateName = crateMapping->GetName();
       AliMUONTriggerCrate *crate = Crate(crateName.Data());
index 6a5e81d..ce497d1 100644 (file)
@@ -21,7 +21,7 @@
 class AliMUONLocalTriggerBoard;
 class AliMUONTriggerCrate;
 class AliMpExMap;
-class TExMapIter;
+class TIterator;
 class AliMUONCalibrationData;
 
 class AliMUONTriggerCrateStore : public TObject
@@ -31,17 +31,18 @@ public:
   virtual ~AliMUONTriggerCrateStore();
   
   Int_t NumberOfCrates() const;
-  void FirstCrate();
-  AliMUONTriggerCrate* NextCrate();
+
   AliMUONTriggerCrate* Crate(const char* crateName) const;
   AliMUONTriggerCrate* Crate(Int_t ddl, Int_t reg) const;
 
   Int_t NumberOfLocalBoards() const;
-  void FirstLocalBoard();
-  AliMUONLocalTriggerBoard* NextLocalBoard();
+
   AliMUONLocalTriggerBoard* LocalBoard(Int_t boardNumber) const;
   
   void ReadFromFile(AliMUONCalibrationData* calibData);
+  TIterator* CreateCrateIterator() const;
+  
+  TIterator* CreateLocalBoardIterator() const;
 
 protected:
   /// Not implemented
@@ -55,14 +56,10 @@ private:
 private:
   AliMpExMap* fCrates; ///< list of crates
   AliMpExMap* fLocalBoards; ///< local boards (indexed by their number)
-  TExMapIter* fCrateIterator; //!< iterator for the crate map above
-  TExMapIter* fLBIterator; //!< iterator for boards (through crates)
-  AliMUONTriggerCrate* fCurrentCrate; //!< used for iterating on local board
-  Int_t fCurrentLocalBoard; //!< used for iterating on local board
 
   TString GetCrateName(Int_t ddl, Int_t reg) const;
 
-  ClassDef(AliMUONTriggerCrateStore,1) // Reader for CRATE.TXT file
+  ClassDef(AliMUONTriggerCrateStore,2) // Reader for CRATE.TXT file
 };
 
 #endif
index eff5ec4..b2e8b9b 100644 (file)
@@ -275,10 +275,9 @@ void AliMUONTriggerElectronics::Feed(const AliMUONVDigitStore& digitStore)
   
   // FILL UP/DOWN OF CURRENT BOARD (DONE VIA J3 BUS IN REAL LIFE)
   AliMUONTriggerCrate* cr;
+  TIter next2(fCrates->CreateCrateIterator());
   
-  fCrates->FirstCrate();
-  
-  while ( ( cr = fCrates->NextCrate() ) )
+  while ( ( cr = static_cast<AliMUONTriggerCrate*>(next2()) ) )
   {            
     TObjArray *boards = cr->Boards();
     
@@ -318,10 +317,9 @@ void AliMUONTriggerElectronics::Feed(UShort_t pattern[2][4])
   /// FILL INPUTS
   ///
   AliMUONTriggerCrate* cr;
+  TIter next(fCrates->CreateCrateIterator());
    
-   fCrates->FirstCrate();
-   
-   while ( ( cr = fCrates->NextCrate() ) )
+   while ( ( cr = static_cast<AliMUONTriggerCrate*>(next()) ) )
    {                 
      TObjArray *boards = cr->Boards();
      
@@ -358,10 +356,9 @@ void AliMUONTriggerElectronics::Scan(Option_t *option)
   ///
 
   AliMUONTriggerCrate* cr;
+  TIter next(fCrates->CreateCrateIterator());  
   
-  fCrates->FirstCrate();
-  
-  while ( ( cr = fCrates->NextCrate() ) )
+  while ( ( cr = static_cast<AliMUONTriggerCrate*>(next()) ) )
   {                
     TObjArray *boards = cr->Boards();
     
@@ -393,10 +390,8 @@ void AliMUONTriggerElectronics::Reset()
   ///
   
    AliMUONTriggerCrate* cr;
-   
-   fCrates->FirstCrate();
-   
-   while ( ( cr = fCrates->NextCrate() ) )
+  TIter next(fCrates->CreateCrateIterator());
+   while ( ( cr = static_cast<AliMUONTriggerCrate*>(next()) ) )
    {            
       TObjArray *boards = cr->Boards();
             
@@ -423,12 +418,11 @@ void AliMUONTriggerElectronics::LoadMasks(AliMUONCalibrationData* calibData)
 
   
   AliMUONTriggerCrate* cr;
-  
-  fCrates->FirstCrate();
+  TIter next(fCrates->CreateCrateIterator());
   
   Int_t irb(0);
   
-  while ( ( cr = fCrates->NextCrate() ) )
+  while ( ( cr = static_cast<AliMUONTriggerCrate*>(next()) ) )
   {            
     TObjArray *boards = cr->Boards();
     
@@ -483,10 +477,9 @@ void AliMUONTriggerElectronics::LocalResponse()
 /// Compute the response for local cards
        
   AliMUONTriggerCrate* cr;
+  TIter next(fCrates->CreateCrateIterator());
   
-  fCrates->FirstCrate();
-  
-  while ( ( cr = fCrates->NextCrate() ) )
+  while ( ( cr = static_cast<AliMUONTriggerCrate*>(next()) ) )
   {            
     
     TObjArray *boards = cr->Boards();
@@ -532,10 +525,9 @@ void AliMUONTriggerElectronics::RegionalResponse()
 {
   /// Compute the response for all regional cards.
   AliMUONTriggerCrate* cr;
+  TIter next(fCrates->CreateCrateIterator());
   
-  fCrates->FirstCrate();
-  
-  while ( ( cr = fCrates->NextCrate() ) )
+  while ( ( cr = static_cast<AliMUONTriggerCrate*>(next()) ) )
   {            
       TObjArray *boards = cr->Boards();
 
@@ -556,8 +548,6 @@ void AliMUONTriggerElectronics::GlobalResponse()
   UShort_t regional[16];
   
   AliMUONTriggerCrate* cr;
-  
-  fCrates->FirstCrate();
   Int_t irb(0);
   
   if ( !fCrates->NumberOfCrates() >= 16 ) 
@@ -565,8 +555,10 @@ void AliMUONTriggerElectronics::GlobalResponse()
     AliFatal(Form("Something is wrong : too many crates %d",
                   fCrates->NumberOfCrates()));
   }
-  
-  while ( ( cr = fCrates->NextCrate() ) )
+
+  TIter next(fCrates->CreateCrateIterator());
+
+  while ( ( cr = static_cast<AliMUONTriggerCrate*>(next())))
   {            
     AliMUONTriggerBoard* rb = 
       static_cast<AliMUONTriggerBoard*>(cr->Boards()->At(0));
index 343b1c5..4cfd068 100644 (file)
@@ -212,10 +212,10 @@ AliMUONTriggerIO::ReadLocalMasks(const char* localFile, AliMUONVStore& localMask
   UShort_t maskBuffer[8];
   
   Int_t nLocalBoards(0);
-  
+    
   while ( fread ( maskBuffer, 2, 8, fp ) )
   {
-    Int_t localBoardId = LocalBoardId(nLocalBoards);
+    Int_t localBoardId = fRegionalTrigger.LocalBoardId(nLocalBoards);
     AliDebug(1,Form("LB %03d X1 %4x X2 %4x X3 %4x X4 %4x "
                     "Y1 %4x Y2 %4x Y3 %4x Y4 %4x",
                     localBoardId,
@@ -370,7 +370,7 @@ AliMUONTriggerIO::ReadLUT(const char* lutFileToRead, AliMUONTriggerLut& lut)
   
   for ( Int_t i = 0; i < NofLocalBoards(); ++i ) 
   {
-    ReadLocalLUT(lut,LocalBoardId(i),flut);
+    ReadLocalLUT(lut,fRegionalTrigger.LocalBoardId(i),flut);
   }
   
   fclose(flut);
@@ -467,7 +467,7 @@ AliMUONTriggerIO::WriteLUT(const AliMUONTriggerLut& lut,
   
   for ( Int_t i = 0; i < NofLocalBoards(); ++i ) 
   {
-    WriteLocalLUT(lut,LocalBoardId(i),flut);
+    WriteLocalLUT(lut,fRegionalTrigger.LocalBoardId(i),flut);
   }
   
   fclose(flut);
@@ -595,12 +595,11 @@ AliMUONTriggerIO::WriteRegionalConfig(const char* regionalFile, AliMUONRegionalT
       AliError("Could not write regional no configuration in memory");
       return kFALSE;
     }
-
-      
-   for (Int_t iCrate = 0; iCrate < nCrate; ++iCrate) 
-      {
-      AliMpTriggerCrate* crate = fRegionalTrigger.GetTriggerCrateFast(iCrate);
-      
+    
+    TIter next(fRegionalTrigger.CreateCrateIterator());
+    AliMpTriggerCrate* crate;
+    while ( ( crate = static_cast<AliMpTriggerCrate*>(next()) ) )
+    {
       AliMUONTriggerCrateConfig* crateConfig = regionalConfig->FindTriggerCrate(crate->GetName());
       if (!crateConfig) 
       {
@@ -661,10 +660,11 @@ AliMUONTriggerIO::WriteLocalMasks(const char* localFile, AliMUONVStore& localMas
 
     UShort_t maskBuffer[8];
 
-    for (Int_t iCrate = 0; iCrate < regionalConfig->GetNofTriggerCrates(); ++iCrate) 
-    {
-      AliMUONTriggerCrateConfig* crate = regionalConfig->GetTriggerCrateFast(iCrate);
-      
+    TIter next(regionalConfig->CreateCrateIterator());
+    AliMUONTriggerCrateConfig* crate;
+    
+    while ( ( crate = static_cast<AliMUONTriggerCrateConfig*>(next()) ) )
+    {      
       UShort_t mask = crate->GetMask(); // getting mask from current config
 
       for (Int_t iLocal = 0; iLocal < crate->GetNofLocalBoards(); ++iLocal) 
@@ -789,9 +789,5 @@ AliMUONTriggerIO::LocalBoardId(Int_t index) const
 {  
   /// Return the i-th localBoardId, or -1 if index is out of bounds
 
-  AliMpLocalBoard* board = fRegionalTrigger.GetLocalBoard(index);
-  if ( ! board ) return -1;
-  
-  return board->GetId(); 
+  return fRegionalTrigger.LocalBoardId(index);
 }
-
index 7e07091..8c3b8df 100644 (file)
Binary files a/MUON/Calib/DDLStore/Run0_999999999_v0_s0.root and b/MUON/Calib/DDLStore/Run0_999999999_v0_s0.root differ
index 08c9b7d..930b26b 100644 (file)
Binary files a/MUON/Calib/Mapping/Run0_999999999_v0_s0.root and b/MUON/Calib/Mapping/Run0_999999999_v0_s0.root differ
index f3503bf..7066759 100644 (file)
@@ -128,7 +128,7 @@ void MUONRefit(Int_t nevents = -1, const char* esdFileNameIn = "AliESDs.root", c
       // get the ESD track
       AliESDMuonTrack* esdTrack = (AliESDMuonTrack*) esdTracks->UncheckedAt(iTrack);
       // get the corresponding MUON track
-      AliMUONTrack* track = esdInterface.GetTrackFast(iTrack);
+      AliMUONTrack* track = esdInterface.FindTrack(esdTrack->GetUniqueID());
       // Find the corresponding re-fitted MUON track
       AliMUONTrack* newTrack = (AliMUONTrack*) newTrackStore->FindObject(esdTrack->GetUniqueID());
       
@@ -215,7 +215,7 @@ void Prepare()
   
   // set reconstruction parameters
   AliMUONRecoParam *muonRecoParam = AliMUONRecoParam::GetLowFluxParam();
-  muonRecoParam->ImproveTracks(kFALSE);
+  muonRecoParam->CombineClusterTrackReco(kFALSE);
   muonRecoParam->Print("FULL");
   AliRecoParam::Instance()->RegisterRecoParam(muonRecoParam);
   
index 5853b73..0b748b4 100644 (file)
@@ -13,6 +13,7 @@
 
 #pragma link C++ class  AliMpIntPair+;
 #pragma link C++ class  AliMpExMap-;
+#pragma link C++ class  AliMpExMapIterator+;
 #pragma link C++ class  AliMpArrayI+;
 #pragma link C++ class  AliMpStringObjMap+;
 
 #pragma link C++ class AliMUON2DMapIteratorByI+;
 #pragma link C++ class AliMUON1DArray+;
 #pragma link C++ class AliMUON1DMap+;
-#pragma link C++ class AliMUON1DMapIterator+;
 #pragma link C++ class AliMUONCheckItem+;
 #pragma link C++ class AliMUONCheckItemIterator+;
 #pragma link C++ class AliMUONVStore+;
 #pragma link C++ class AliMUONTreeManager+;
 #pragma link C++ class AliMUONLogger+;
 
+#pragma link C++ function operator-(const AliMpIntPair& ,const AliMpIntPair& );
+#pragma link C++ function operator+(const AliMpIntPair& ,const AliMpIntPair& );
+#pragma link C++ function operator<<(ostream& ,const AliMpIntPair& );
+
 #endif
 
 
index 8d1fa0b..d305e49 100644 (file)
@@ -26,9 +26,6 @@
 #pragma link C++ enum   AliMp::StationType;
 #pragma link C++ enum   AliMp::CathodType;
 
-#pragma link C++ function operator-(const AliMpIntPair& ,const AliMpIntPair& );
-#pragma link C++ function operator+(const AliMpIntPair& ,const AliMpIntPair& );
-#pragma link C++ function operator<<(ostream& ,const AliMpIntPair& );
 #pragma link C++ function operator<<(ostream& ,const AliMpPad& );
 #pragma link C++ function operator<<(ostream& ,const AliMpArea& );
 #pragma link C++ function operator<(const AliMpPad& ,const AliMpPad& );
 #pragma link C++ class  AliMpPCBPainter+;
 #pragma link C++ class  AliMpDEVisu+;
 #pragma link C++ class  AliMpIteratorPainter+;
+
+#ifdef WITH_STL
+#pragma link C++ class  std::pair<Int_t, TVector2>+;
+#pragma link C++ class  std::pair<Int_t, AliMpMotifPosition*>+;
+#pragma link C++ class  std::pair<TString, AliMpVMotif*>+;
+#pragma link C++ class  std::pair<TString, AliMpMotifType*>+;
+#pragma link C++ class  std::pair<AliMpIntPair, AliMpConnection*>+;
+#pragma link C++ class  std::pair<AliMpIntPair, AliMpMotifPosition*>+;
+#endif
index eaaa1e8..74eb9a9 100755 (executable)
@@ -30,6 +30,176 @@ def append(list,a):
   if not a in list:
     list.append(a)
     
+#_______________________________________________________________________________
+def isempty(line):
+
+  return len(line) < 2
+  
+#_______________________________________________________________________________
+def iscomment(line):
+
+  return re.search("^#",line)
+
+#_______________________________________________________________________________
+def iscontinuation(line):
+
+  return line.find('\\') > 0
+
+#_______________________________________________________________________________
+def compactLines(ilines):
+  """ Given an array of lines, remove empty lines, comment lines
+  and concatenate lines that should be one (i.e. removing the \ continuation
+  marks...
+  """
+  
+  continuation = False
+
+  olines = []
+  
+  currentline = ""
+  
+  i = 0
+  
+  for line in ilines:
+    
+    i = i + 1
+    
+    if line.find('\\') > 0:
+      line = re.sub("\t|\n|\r|\\\\","",line)
+      continuation = True
+    else:
+      continuation = False
+      if isempty(currentline):
+        currentline = line
+      else:
+        l = re.sub("\t","",line)
+        currentline = currentline + re.sub(" {1,}"," ",l)
+      if not iscomment(currentline) and not isempty(currentline):
+        olines.append(re.sub(" {1,}"," ",currentline))
+      currentline = ""
+          
+    if continuation:
+      currentline = currentline + line
+      
+  return olines
+
+#_______________________________________________________________________________
+def tokenizeLines(lines):
+  """
+  Return a dict of keys -> value items.
+  keys are the left part of lines supposed to be of the form :
+  KEY:=VALUE
+  or
+  KEY+=VALUE
+  or
+  KEY=VALUE
+  """
+  
+  tokens = {}
+  
+  define = ":="
+  plus = "+="
+  equal = "="
+  
+  separators = [ define, plus, equal ]
+  
+  for l in lines:
+    sep = False
+    for s in separators:
+      if s in l:        
+        a = l.split(s,1)
+        key = a[0].strip()
+        value = re.sub("\n|\t|\n","",a[1])
+        if len(a) > 2:
+          print "Something fishy here !"
+        sep = True
+        break
+    if not sep:
+      continue
+    if not key in tokens.keys():
+      tokens[key] = ""
+    if s == plus:
+      tokens[key] += value
+    else:
+      tokens[key] = value
+      
+  return tokens
+
+#_______________________________________________________________________________
+def variableSubstitution(tokenname,alltokens):
+  """
+  """
+
+  value = alltokens.get(tokenname,"")
+      
+  for k in alltokens.keys():
+    if re.search("\$\(%s\)"%k,value):
+      # found something like $(VARIABLE), so expand that variable, 
+      # by calling us again
+      rep = value.replace("$(%s)"%k,variableSubstitution(k,alltokens))
+      return rep
+    if re.search("\$\(%s\:"%k,value):
+      # found something like $(VARIABLE: 
+      # we suppose it's then something like $(VARIABLE:.x=.y)
+      # i.e. we replace x by y in VARIABLE's expansion
+      t = variableSubstitution(k,alltokens)
+      i1 = value.index(":")
+      i2 = value.index(")")
+      change = value[i1+1:i2].split("=")
+      return t.replace(change[0],change[1])
+
+  return value
+
+#_______________________________________________________________________________
+def patternSubstitution(value):
+
+  if re.search("\$\(patsubst",value):
+    rv = []
+    # found the Makefile function $(patsubst %.x, %.y, list)
+    i1 = value.index("(")
+    i2 = value.rindex(")")
+    a = value[i1+1:i2].split(",")
+    source = a[0].replace("patsubst ","")
+    destination = a[1].replace("%","")
+    if source != "%":      
+      print "Houston, we have a problem : ",value
+      sys.exit(1)
+    for l in a[2].split():
+      rv.append(destination + l)
+    return rv
+    
+  return value.split()
+
+#_______________________________________________________________________________
+def getSourceFiles2(lib,rootsys,alice_root):
+  """Extract the list of files from a libXXX.pkg file
+    Return a pair of list (sourceFiles,einclude), where einclude
+    is the list of directories needed to be included compile the files.
+  """
+  
+  try:
+    f = open(lib)
+  except:
+    print "Cannot open file ", file
+    sys.exit(1)
+
+  filelines = f.readlines()
+  
+  f.close()
+  
+  lines = compactLines(filelines)
+  
+  tokens = tokenizeLines(lines)
+
+  sourcesfiles = patternSubstitution(variableSubstitution("SRCS",tokens))
+  eincludes = patternSubstitution(variableSubstitution("EINCLUDE",tokens))
+  
+  pkg = getLibPackage(lib)
+  dir = os.path.join(alice_root,pkg)
+  
+  sourcesfiles = [ os.path.join(dir,x) for x in sourcesfiles ]
+  
+  return sourcesfiles,eincludes
 
 #_______________________________________________________________________________
 def getSourceFiles(lib,rootsys,alice_root):
@@ -311,7 +481,8 @@ def main():
 
   dirs.append(dir)
     
-  requestedPackages = [ "MUON", "STEER", "RAW", "ITS", "TRD", "VZERO", "TPC", "PHOS", "TOF", "ZDC", "EMCAL", "HMPID", "SHUTTLE", "ACORDE" ];
+#  requestedPackages = [ "MUON", "STEER", "RAW", "ITS", "TRD", "VZERO", "TPC", "PHOS", "TOF", "ZDC", "EMCAL", "HMPID", "SHUTTLE", "ACORDE", "HLT", "EVE" ];
+  requestedPackages = [ "RAW", "STEER", "MUON", "HLT","EVE" ]
   
   # find the libraries defined in this directory (looking for libXXXX.pkg files)  
   libraries = []
@@ -375,7 +546,7 @@ def main():
 
       if not re.search("da.pkg",lib):
         # handle the special case of DAs which are not part of libs, really
-        lib2src[lib], eincludes[lib] = getSourceFiles(lib,rootsys,alice_root)
+        lib2src[lib], eincludes[lib] = getSourceFiles2(lib,rootsys,alice_root)        
       else:
         l = lib
         l = re.sub("lib","",l)
index b7474e8..1c35530 100644 (file)
@@ -3,6 +3,7 @@
 
 SRCS:=  mapping/AliMpIntPair.cxx  \
         mapping/AliMpExMap.cxx  \
+        mapping/AliMpExMapIterator.cxx  \
         mapping/AliMpArrayI.cxx  \
         mapping/AliMpStringObjMap.cxx  \
         AliMUONObjectPair.cxx \
@@ -12,7 +13,6 @@ SRCS:=  mapping/AliMpIntPair.cxx  \
         AliMUON2DMapIteratorByI.cxx \
         AliMUON1DArray.cxx \
         AliMUON1DMap.cxx \
-        AliMUON1DMapIterator.cxx \
         AliMUONCheckItem.cxx \
         AliMUONCheckItemIterator.cxx \
         AliMUONVStore.cxx \
index f8f91d5..80d7c08 100755 (executable)
@@ -34,7 +34,7 @@ ClassImp(AliMpConnection)
 
 //_____________________________________________________________________________
 AliMpConnection::AliMpConnection(Int_t padNum, Int_t bergNum,Int_t kaptonNum,
-                                Int_t gassiNum) 
+                                Int_t gassiNum, const AliMpIntPair& localIndices) 
   : TObject(),
     fPadNum(padNum),
     fBergNum(bergNum),
@@ -43,8 +43,12 @@ AliMpConnection::AliMpConnection(Int_t padNum, Int_t bergNum,Int_t kaptonNum,
     fOwner(0)
 {
 /// Standard constructor
+
+      SetUniqueID(localIndices.GetFirst() | ( localIndices.GetSecond() << 16 ));
+
       AliDebug(1,Form("this=%p padNum=%d bergNum=%d kaptonNum=%d gassiNum=%d",
                       this,padNum,bergNum,kaptonNum,gassiNum));
+
 }
 
 //_____________________________________________________________________________
@@ -66,3 +70,23 @@ AliMpConnection::~AliMpConnection()
 /// Destructor  
   AliDebug(1,Form("this=%p"));
 }
+
+/*
+//_____________________________________________________________________________
+void
+AliMpConnection::SetLocalIndices(const AliMpIntPair& pair)
+{
+  SetUniqueID(pair.GetFirst() | ( pair.GetSecond() << 16 ));
+}
+*/
+
+//_____________________________________________________________________________
+AliMpIntPair AliMpConnection::LocalIndices() const
+{
+/// Return local indices 
+
+  Int_t f = GetUniqueID() & 0xFFFF;
+  Int_t s = ( ( GetUniqueID() & 0xFFFF0000 ) >> 16);
+  return AliMpIntPair(f,s);
+}
+
index f71109e..4bb74b1 100755 (executable)
@@ -24,7 +24,8 @@ class AliMpConnection : public TObject
 {
   public:
     AliMpConnection();
-    AliMpConnection(Int_t padNum,Int_t bergNum,Int_t kaptonNum,Int_t gassiNum);
+    AliMpConnection(Int_t padNum,Int_t bergNum,Int_t kaptonNum,Int_t gassiNum,
+                    const AliMpIntPair& localIndices);
     virtual ~AliMpConnection();
 
     // methods
@@ -55,6 +56,8 @@ class AliMpConnection : public TObject
           /// Set the motif type which contains this connection
     void SetOwner(AliMpMotifType *owner) {fOwner=owner;}
 
+    // void SetLocalIndices(const AliMpIntPair& pair);
+    
   private:
     /// Not implemented
     AliMpConnection(const AliMpConnection& right);
@@ -77,8 +80,8 @@ class AliMpConnection : public TObject
 inline TString AliMpConnection::PadName() const 
 { return fOwner->PadName(fPadNum); }
 
-          /// Return the local indices of this pad in the motif
-inline AliMpIntPair AliMpConnection::LocalIndices() const
-{ return fOwner->FindLocalIndicesByConnection(this);}
+//          /// Return the local indices of this pad in the motif
+//inline AliMpIntPair AliMpConnection::LocalIndices() const
+//{ return fOwner->FindLocalIndicesByConnection(this);}
 
 #endif //ALI_MP_CONNECTION_H
index 4b84bed..05c5aef 100644 (file)
@@ -29,6 +29,7 @@
 
 #include <cstdlib>
 #include "AliMpDDLStore.h"
+#include "AliMpExMapIterator.h"
 #include "AliMpConstants.h"
 #include "AliMpDEStore.h"
 #include "AliMpDDL.h"
@@ -105,7 +106,7 @@ AliMpDDLStore* AliMpDDLStore::ReadData(Bool_t warn)
 AliMpDDLStore::AliMpDDLStore()
         : TObject(),
         fDDLs(fgkNofDDLs+fgkNofTriggerDDLs), // FIXEME
-        fBusPatches(true),
+        fBusPatches(),
         fManuList12(),
         fManuBridge2(),
         fRegionalTrigger()
@@ -135,7 +136,7 @@ AliMpDDLStore::AliMpDDLStore()
 AliMpDDLStore::AliMpDDLStore(TRootIOCtor* ioCtor)
         : TObject(),
         fDDLs(),
-        fBusPatches(),
+        fBusPatches(ioCtor),
         fRegionalTrigger(ioCtor)
 {
     /// Constructor for I0
@@ -300,17 +301,17 @@ Bool_t  AliMpDDLStore::ReadTrigger()
 }
 
 //______________________________________________________________________________
-Bool_t  AliMpDDLStore::SetTriggerDDLs() 
+Bool_t  
+AliMpDDLStore::SetTriggerDDLs() 
 {
-/// Create trigger DDLs and set DDL Ids in the regional trigger
-  
+  /// Create trigger DDLs and set DDL Ids in the regional trigger
 
   Int_t iDDL = -1;
-
-  for ( Int_t i=0; i<fRegionalTrigger.GetNofTriggerCrates(); ++i ) {
+  TIter next(fRegionalTrigger.CreateCrateIterator());
+  AliMpTriggerCrate* crate;
   
-    AliMpTriggerCrate* crate = fRegionalTrigger.GetTriggerCrateFast(i);
-
+  while ( ( crate = static_cast<AliMpTriggerCrate*>(next()) ) )
+  {
     TString crateName = crate->GetName();
 
     // determine ddl number vs crate side
@@ -628,12 +629,11 @@ Bool_t AliMpDDLStore::SetBusPatchLength() {
 Int_t AliMpDDLStore::GetLocalBoardId(TString name) const {
     /// return the first board with a given side and line
 
-
-    TExMapIter i = fRegionalTrigger.GetLocalBoardItr();
-    Long_t key, value;
-    while ( i.Next(key, value) ) {
-        AliMpLocalBoard* local = (AliMpLocalBoard*)value;
-
+  TIter next(fRegionalTrigger.CreateLocalBoardIterator());
+  AliMpLocalBoard* local;
+  
+  while ( ( local = static_cast<AliMpLocalBoard*>(next()) ) )
+  {
         TString tmp(&local->GetName()[4], 2);
         if (name.Contains(tmp))
             if (name[0] == local->GetName()[0])
@@ -641,7 +641,6 @@ Int_t AliMpDDLStore::GetLocalBoardId(TString name) const {
     }
 
     return 0;
-
 }
 
 //
@@ -893,3 +892,13 @@ void AliMpDDLStore::SetRegionalTrigger(const AliMpRegionalTrigger& regionalTrigg
   // Set new trigger DDLs from new regional trigger
   SetTriggerDDLs();
 }  
+
+
+//______________________________________________________________________________
+TIterator* 
+AliMpDDLStore::CreateBusPatchIterator() const
+{
+/// Create the iterator over bus patches
+
+  return fBusPatches.CreateIterator();
+}
index 92156ba..a594751 100644 (file)
@@ -62,24 +62,16 @@ class AliMpDDLStore : public  TObject {
     Int_t  GetDDLfromBus(Int_t busPatchId) const;
     Int_t  GetBusPatchId(Int_t detElemId, Int_t manuId) const;
     
-    /// Return trigger crates iterator
-    TExMapIter GetTriggerCrateItr() const { return fRegionalTrigger.GetTriggerCrateItr(); }
-
-    /// Return trigger local board iterator
-    TExMapIter GetLocalBoardItr() const { return fRegionalTrigger.GetLocalBoardItr(); }
-
-    /// Get an iterator to loop over bus patches
-    TExMapIter GetBusPatchesIterator() const { return fBusPatches.GetIterator(); }
-    
     /// Get detection elt and Manu number from serial number
     AliMpIntPair  GetDetElemIdManu(Int_t manuSerial) const;
 
-    /// print info of all manus
+    /// Print info of all manus
     void PrintAllManu() const;
     
     // Set methods
     void SetRegionalTrigger(const AliMpRegionalTrigger& regionalTrigger);
 
+    TIterator* CreateBusPatchIterator() const; 
     
   private:
     AliMpDDLStore();
index e112517..bf2aa0d 100644 (file)
@@ -25,6 +25,8 @@
 //-----------------------------------------------------------------------------
 
 #include "AliMpDEIterator.h"
+
+#include "AliMpExMapIterator.h"
 #include "AliMpDEStore.h"
 #include "AliMpDetElement.h"
 #include "AliMpDEManager.h"
@@ -41,59 +43,21 @@ ClassImp(AliMpDEIterator)
 
 //______________________________________________________________________________
 AliMpDEIterator::AliMpDEIterator()
-    : TObject(),
-      fDEStore(AliMpDEStore::Instance()),
-      fIndex(-1),
-      fChamberId(-1)
+: TObject(),
+  fCurrentDE(0x0),
+  fIterator(AliMpDEStore::Instance()->fDetElements.CreateIterator()),
+  fChamberId(-1)
 {  
 /// Standard and default constructor
 }
 
 //______________________________________________________________________________
-AliMpDEIterator::AliMpDEIterator(const AliMpDEIterator& rhs)
- : TObject(rhs),
-   fDEStore(rhs.fDEStore),
-   fIndex(rhs.fIndex),
-   fChamberId(rhs.fChamberId)
-{
-/// Copy constructor
-}
-
-//______________________________________________________________________________
 
 AliMpDEIterator::~AliMpDEIterator()
 {
 /// Destructor
-}
-
-//______________________________________________________________________________
-AliMpDEIterator&  AliMpDEIterator::operator=(const AliMpDEIterator& rhs)
-{
-/// Assignement operator
 
-  // check assignment to self
-  if (this == &rhs) return *this;
-
-  // base class assignment
-  TObject::operator=(rhs);
-
-  fDEStore = rhs.fDEStore;
-  fIndex = rhs.fIndex;
-  fChamberId = rhs.fChamberId;
-
-  return *this;
-} 
-
-//
-// private methods
-//
-
-//______________________________________________________________________________
-AliMpDetElement*  AliMpDEIterator::GetDetElement(Int_t index) const
-{
-/// Return the detection element from the map via index
-
-  return static_cast<AliMpDetElement*>(fDEStore->fDetElements.GetObject(index));
+  delete fIterator;
 }
 
 //
@@ -105,7 +69,8 @@ void AliMpDEIterator::First()
 {
 /// Set iterator to the first DE Id defined 
 
-  fIndex = 0;
+  fIterator->Reset();
+  fCurrentDE = static_cast<AliMpDetElement*>(fIterator->Next());
   fChamberId = -1;
 }  
 
@@ -114,29 +79,22 @@ void AliMpDEIterator::First(Int_t chamberId)
 {
 /// Reset the iterator, so that it points to the first DE
  
-  fChamberId = -1;
-  fIndex = -1;  
   if ( ! AliMpDEManager::IsValidChamberId(chamberId) ) {
     AliErrorStream() << "Invalid chamber Id " << chamberId << endl;
+    fIterator->Reset();
+    fChamberId = -1;    
+    fCurrentDE = 0x0;
     return;
   }    
 
-  Int_t i=0;
-  while ( i < fDEStore->fDetElements.GetSize() && fChamberId < 0 ) {
-    Int_t detElemId = GetDetElement(i)->GetId();
-    if ( AliMpDEManager::GetChamberId(detElemId) == chamberId ) {
-      fChamberId = chamberId;
-      fIndex = i;
-    } 
-    i++; 
+  fIterator->Reset();
+  fChamberId = -1;
+  while ( fChamberId != chamberId ) 
+  {
+    fCurrentDE = static_cast<AliMpDetElement*>(fIterator->Next());
+    if (!fCurrentDE) return;
+    fChamberId = AliMpDEManager::GetChamberId(CurrentDEId());
   }
-
-  if ( fChamberId < 0 ) {
-    AliErrorStream() 
-      << "No DEs of Chamber Id " << chamberId << " found" << endl;
-    return;
-  }    
-
 }
 
 //______________________________________________________________________________
@@ -144,14 +102,20 @@ void AliMpDEIterator::Next()
 {
 /// Increment iterator to next DE
 
-  fIndex++;
-
-  // Invalidate if at the end
-  if ( ( fIndex == fDEStore->fDetElements.GetSize() ) ||
-       ( fChamberId >= 0 &&    
-         AliMpDEManager::GetChamberId(CurrentDEId()) != fChamberId ) ) {
-    fIndex = -1;
-  }   
+  if ( fChamberId < 0 ) 
+  {
+    fCurrentDE = static_cast<AliMpDetElement*>(fIterator->Next());
+  }
+  else
+  {
+    fCurrentDE = static_cast<AliMpDetElement*>(fIterator->Next());
+    
+    while ( fCurrentDE && (AliMpDEManager::GetChamberId(fCurrentDE->GetId()) != fChamberId) )
+    {
+      fCurrentDE = static_cast<AliMpDetElement*>(fIterator->Next());
+      if (!fCurrentDE) return;
+    }
+  }
 }
 
 //______________________________________________________________________________
@@ -159,7 +123,7 @@ Bool_t AliMpDEIterator::IsDone() const
 {
 /// Is the iterator in the end?
 
-  return ( fIndex < 0 );
+  return ( fCurrentDE == 0x0 );
 }   
 
 //______________________________________________________________________________
@@ -167,22 +131,19 @@ AliMpDetElement* AliMpDEIterator::CurrentDE() const
 {
 /// Current DE Id
 
-  if ( ! IsDone() )
-    return GetDetElement(fIndex);
-  else {   
-    AliErrorStream()
-      << "Not in valid position - returning invalid DE." << endl;
-    return 0;
-  }  
+  return fCurrentDE;
 }
     
 //______________________________________________________________________________
-Int_t AliMpDEIterator::CurrentDEId() const
+Int_t 
+AliMpDEIterator::CurrentDEId() const
 {
 /// Current DE Id
 
-  if ( ! IsDone() )
-    return GetDetElement(fIndex)->GetId();
+  if ( fCurrentDE )
+  {
+    return fCurrentDE->GetId();
+  }
   else {   
     AliErrorStream()
       << "Not in valid position - returning invalid DE." << endl;
index 34aee92..77f49d4 100644 (file)
 
 #include <TArrayI.h>
 
-class AliMpDEStore;
 class AliMpDetElement;
-
+class TIterator;
 class TString;
 
-
 class AliMpDEIterator : public  TObject {
 
   public:
     AliMpDEIterator();
-    AliMpDEIterator(const AliMpDEIterator& rhs);
+    //AliMpDEIterator(const AliMpDEIterator& rhs);
     virtual ~AliMpDEIterator();
 
     // Operators
-    AliMpDEIterator& operator=(const AliMpDEIterator& rhs);
+    //AliMpDEIterator& operator=(const AliMpDEIterator& rhs);
     
     // Methods for iterating over DE elements
     // 
@@ -49,13 +47,15 @@ class AliMpDEIterator : public  TObject {
     Int_t CurrentDEId() const;
 
   private:
-    // methods
-    AliMpDetElement*  GetDetElement(Int_t index) const;
+    /// Not implemented
+    AliMpDEIterator(const AliMpDEIterator& rhs);
+    /// Not implemented
+    AliMpDEIterator& operator=(const AliMpDEIterator& rhs);
 
     // data members    
-    AliMpDEStore*  fDEStore;   ///< DE store 
-    Int_t          fIndex;     ///< Current DE index
-    Int_t          fChamberId; ///< The iterated chamber 
+    AliMpDetElement* fCurrentDE; ///< current element in iteration
+    TIterator*       fIterator;  ///< iterator
+    Int_t            fChamberId; ///< The iterated chamber 
 
   ClassDef(AliMpDEIterator,0)  // The iterator over valid detection element IDs
 };
index 9f639ee..aaa3838 100644 (file)
@@ -34,6 +34,7 @@
 #include "AliMpHelper.h"
 #include "AliMpIntPair.h"
 #include "AliMpConstants.h"
+#include "AliMpExMapIterator.h"
 
 #include "AliLog.h"
 
@@ -93,7 +94,7 @@ AliMpDEStore* AliMpDEStore::ReadData(Bool_t warn)
 //______________________________________________________________________________
 AliMpDEStore::AliMpDEStore()
 : TObject(),
-  fDetElements(true)
+  fDetElements()
 {  
 /// Standard constructor
 
@@ -105,9 +106,9 @@ AliMpDEStore::AliMpDEStore()
 }
 
 //______________________________________________________________________________
-AliMpDEStore::AliMpDEStore(TRootIOCtor* /*ioCtor*/)
+AliMpDEStore::AliMpDEStore(TRootIOCtor* ioCtor)
 : TObject(),
-  fDetElements()
+  fDetElements(ioCtor)
 {  
 /// Constructor for IO
 
@@ -325,8 +326,8 @@ AliMpDEStore::ReadDENames(AliMp::StationType station)
                       " of DetElemId %d",detElemId));
       }
       
-      AliMpDetElement* detElement 
-        = new AliMpDetElement(detElemId, name, name0, planeForCathode[0]);
+      AliMpDetElement* detElement = new AliMpDetElement(detElemId, name, name0, planeForCathode[0]);
+      
       if ( ! fDetElements.GetValue(detElemId) ) 
       {
         AliDebugClassStream(3)  
@@ -393,11 +394,12 @@ AliMpDetElement* AliMpDEStore::GetDetElement(const TString& deName, Bool_t warn)
 {
 /// Return det element for given deName
 
-  for ( Int_t i = 0; i < fDetElements.GetSize(); i++ ) {
-    
-    AliMpDetElement* detElement 
-      = (AliMpDetElement*)fDetElements.GetObject(i);
-      
+  TIter next(fDetElements.CreateIterator());
+  AliMpDetElement* detElement;
+  
+  while ( ( detElement = static_cast<AliMpDetElement*>(next()) ) )
+  {
+             
     if (deName.CompareTo(detElement->GetDEName()) == 0) 
 
       return detElement;
@@ -416,11 +418,11 @@ AliMpIntPair  AliMpDEStore::GetDetElemIdManu(Int_t manuSerial) const
 {
 /// Return the detElemId and manuId for given serial manu number
 
-  for ( Int_t i = 0; i < fDetElements.GetSize(); i++ ) {
-    
-    AliMpDetElement* detElement 
-      = (AliMpDetElement*)fDetElements.GetObject(i);
-      
+  TIter next(fDetElements.CreateIterator());
+  AliMpDetElement* detElement;
+  
+  while ( ( detElement = static_cast<AliMpDetElement*>(next()) ) )
+  {
     Int_t manuId = detElement->GetManuIdFromSerial(manuSerial);
     if ( manuId ) return AliMpIntPair(detElement->GetId(), manuId);
   }    
index db3c018..ec8f4ea 100644 (file)
@@ -788,11 +788,11 @@ void AliMpDEVisu::PopUpManuMotif(AliMpSlat* slat)
   AliMpMotifPosition* motifPos = 0x0;
   Int_t manuId = 0;
 
-  for ( AliMpSlat::Size_t i = 0; i < slat->GetSize(); ++i ) {
+  for ( Int_t i = 0; i < slat->GetSize(); ++i ) {
     
     AliMpPCB* pcb = slat->GetPCB(i);
     
-    for ( AliMpPCB::Size_t j = 0; j < slat->GetPCB(i)->GetSize(); ++j ) {
+    for ( Int_t j = 0; j < slat->GetPCB(i)->GetSize(); ++j ) {
       
       motifPos = pcb->GetMotifPosition(j);
       
index f3aaa4e..1948c9f 100644 (file)
@@ -58,17 +58,18 @@ AliMpDetElement::AliMpDetElement(Int_t id, const TString& name,
     fSegType(segType),
     fPlaneType(planeType),
     fBusPatchIds(false),
-    fManuToSerialNbs(1700),
-    fSerialNbToManus(1700),
-    fManuList(1700),
-    fTrackerChannels(1700*AliMpConstants::ManuNofChannels()),
-    fHVmanus(true)
+    fManuToSerialNbs(),
+    fSerialNbToManus(),
+    fManuList(),
+    fTrackerChannels(),
+    fHVmanus(),
+    fNofChannels(0)
 {
 /// Standard constructor
 }
 
 //______________________________________________________________________________
-AliMpDetElement::AliMpDetElement(TRootIOCtor* /*ioCtor*/)
+AliMpDetElement::AliMpDetElement(TRootIOCtor* ioCtor)
   : TObject(),
     fId(0),
     fDdlId(-1),
@@ -78,9 +79,10 @@ AliMpDetElement::AliMpDetElement(TRootIOCtor* /*ioCtor*/)
     fBusPatchIds(),
     fManuToSerialNbs(),
     fSerialNbToManus(),
-    fManuList(true),
-    fTrackerChannels(true),
-    fHVmanus(true)
+    fManuList(),
+    fTrackerChannels(),
+    fHVmanus(ioCtor),
+    fNofChannels()
 {
 /// Root IO constructor
 }
@@ -331,6 +333,8 @@ AliMpDetElement::AddManu(Int_t manuId)
   }
   
   fManuList.Add(AliMpManuUID::BuildUniqueID(fId,manuId),(Long_t)n);
+
+  fNofChannels += n;
   
   AliMpHVNamer hvNamer;
   
index 29c9b59..6df7be3 100644 (file)
@@ -74,6 +74,9 @@ class AliMpDetElement : public  TObject {
     
     const AliMpArrayI* ManusForHV(Int_t hvIndex) const;
     
+           /// Return the number of channels in this detection element    
+    Int_t NofChannels() const { return fNofChannels; }
+    
   private:
     /// Not implemented
     AliMpDetElement();
@@ -101,7 +104,9 @@ class AliMpDetElement : public  TObject {
     
     AliMpExMap fHVmanus; ///< map of HV->manu
     
-  ClassDef(AliMpDetElement,2)  // The manager class for definition of detection element types
+    Int_t fNofChannels; ///< number of channels in this detection element
+    
+  ClassDef(AliMpDetElement,3)  // The manager class for definition of detection element types
 };
 
 // inline function
index 4320c59..32e1941 100644 (file)
@@ -26,6 +26,7 @@
 
 #include "AliMpExMap.h"
 #include "AliMpIntPair.h"
+#include "AliMpExMapIterator.h"
 
 #include "AliLog.h"
 
@@ -61,12 +62,20 @@ Long_t  AliMpExMap::GetIndex(const AliMpIntPair& pair)
 {
 /// Convert the pair of integers to integer.
 
-  if (pair.GetFirst() >= fgkSeparator1 || pair.GetSecond() >= fgkSeparator1) {
-    AliFatalClass("Index out of limit.");
-    exit(1); 
-  }  
-      
-  return pair.GetFirst()*fgkSeparator1 + pair.GetSecond() + 1;
+  if ( pair.GetFirst() >= 0xFFFF || pair.GetSecond() >= 0xFFFF ) 
+  {
+    AliFatalClass("Index out of limit");
+    return 0;
+  }
+  
+  return 1 + ( pair.GetFirst() | ( pair.GetSecond() << 16 ) );
+           
+//  if (pair.GetFirst() >= fgkSeparator1 || pair.GetSecond() >= fgkSeparator1) {
+//    AliFatalClass("Index out of limit.");
+//    exit(1); 
+//  }  
+//      
+//  return pair.GetFirst()*fgkSeparator1 + pair.GetSecond() + 1;
 }  
 
 //_____________________________________________________________________________
@@ -89,9 +98,12 @@ Long_t  AliMpExMap::GetIndex(const TString& s)
 //______________________________________________________________________________
 AliMpIntPair  AliMpExMap::GetPair(Long_t index)
 {
-/// Convert the integer index to the pair of integers.
+// Convert the integer index to the pair of integers.
 
-  return AliMpIntPair((index-1)/fgkSeparator1,(index-1)%fgkSeparator1);
+//  return AliMpIntPair((index-1)/fgkSeparator1,(index-1)%fgkSeparator1);
+  return AliMpIntPair( 
+                       ( (index-1) & 0xFFFF ) ,
+                       ( (index-1) & 0xFFFF0000 ) >> 16 );
 }  
 
 //_____________________________________________________________________________
@@ -113,25 +125,25 @@ TString  AliMpExMap::GetString(Long_t index)
 //
 
 //_____________________________________________________________________________
-AliMpExMap::AliMpExMap(Bool_t /*standardConstructor*/) 
+AliMpExMap::AliMpExMap() 
   : TObject(),
     fMap(fgkDefaultSize),
     fObjects(fgkDefaultSize),
     fKeys(fgkDefaultSize)
 {
-/// Standard constructor
+      /// Default constructor
 
   fObjects.SetOwner(fgkDefaultOwnership);
 }
 
 //_____________________________________________________________________________
-AliMpExMap::AliMpExMap() 
+AliMpExMap::AliMpExMap(TRootIOCtor*) 
   : TObject(),
     fMap(),
     fObjects(),
     fKeys()
 {
-/// Default constructor
+      /// "Root - I/O" constructor
 }
 
 
@@ -161,35 +173,6 @@ AliMpExMap::operator=(const AliMpExMap& rhs)
 }
 
 //_____________________________________________________________________________
-void
-AliMpExMap::Copy(TObject& dest) const
-{
-  /// Copy this to dest
-  /// Copy implies that dest will become owner of its objects, whatever
-  /// the ownership of (*this) is.
-  
-  AliDebug(1,"");
-  
-  TObject::Copy(dest);
-  AliMpExMap& m = static_cast<AliMpExMap&>(dest);
-  m.fKeys = fKeys;
-  m.fMap.Delete();
-  m.fObjects.Clear();
-  
-  for ( Int_t i = 0; i <= fObjects.GetLast(); ++i ) 
-  {
-    TObject* o = fObjects.At(i)->Clone();
-    if (!o)
-    {
-      AliError("Object was not cloned properly ! Please investigate...");
-    }
-    m.fObjects.AddLast(o);
-  }
-  m.FillMap();
-  m.fObjects.SetOwner(kTRUE);
-}
-
-//_____________________________________________________________________________
 AliMpExMap::~AliMpExMap() 
 {
 /// Destructor 
@@ -216,12 +199,41 @@ void AliMpExMap::AddKey(Long_t key)
   // Resize array if needed
   if (fObjects.GetEntriesFast() == fKeys.GetSize()) {
    fKeys.Set(2*fKeys.GetSize());
-   AliWarningStream() << "AliMpExMap::AddKey: resized Key array " << endl;
+   AliDebugStream(1) << "AliMpExMap::AddKey: resized Key array " << endl;
   } 
    
   fKeys.AddAt(key, fObjects.GetEntriesFast());      
 }
 
+//_____________________________________________________________________________
+void
+AliMpExMap::Copy(TObject& dest) const
+{
+  /// Copy this to dest
+  /// Copy implies that dest will become owner of its objects, whatever
+  /// the ownership of (*this) is.
+  
+  AliDebug(1,"");
+  
+  TObject::Copy(dest);
+  AliMpExMap& m = static_cast<AliMpExMap&>(dest);
+  m.fKeys = fKeys;
+  m.fMap.Delete();
+  m.fObjects.Clear();
+  
+  for ( Int_t i = 0; i <= fObjects.GetLast(); ++i ) 
+  {
+    TObject* o = fObjects.At(i)->Clone();
+    if (!o)
+    {
+      AliError("Object was not cloned properly ! Please investigate...");
+    }
+    m.fObjects.AddLast(o);
+  }
+  m.FillMap();
+  m.fObjects.SetOwner(kTRUE);
+}
+
 //
 // public methods
 //
@@ -237,6 +249,29 @@ void AliMpExMap::Clear(Option_t* option)
 }
 
 //_____________________________________________________________________________
+void AliMpExMap::Print(Option_t* opt) const
+{
+/// Print out
+
+  cout << Form("fMap size/capacity %d/%d",fMap.GetSize(),fMap.Capacity()) 
+       << Form(" fObjects.GetSize/Entries %d/%d",fObjects.GetSize(),fObjects.GetEntries()) 
+       << Form(" fKeys.GetSize %d",fKeys.GetSize()) << endl;
+  
+  TString sopt(opt);
+  sopt.ToUpper();
+  
+  if ( sopt.Contains("FULL") ) 
+  {
+    TIter next(CreateIterator());
+    TObject* o;
+    while ( ( o = next() ) )
+    {
+      o->Print();
+    }
+  }
+}
+
+//_____________________________________________________________________________
 void AliMpExMap::Add(const AliMpIntPair& key, TObject* object)
 {
 /// Add object with its key to the map and arrays
@@ -293,36 +328,21 @@ Int_t AliMpExMap::GetSize() const
 }
 
 //_____________________________________________________________________________
-TExMapIter AliMpExMap::GetIterator() const
+Int_t AliMpExMap::GetCapacity() const
 {
-/// Return TExMap iterator set to the beginning of the map
-
-  return TExMapIter(&fMap);
+  /// Return the map capacity
+  
+  return fObjects.GetSize();
 }
 
 //_____________________________________________________________________________
-TObject* AliMpExMap::GetObject(Int_t index) const
+AliMpExMapIterator*
+AliMpExMap::CreateIterator() const
 {
-/// Return the object via its index in the array
-/// (This function makes possible looping over map as over an array)
+/// Return iterator set to the beginning of the map
 
-  if ( index < 0 || index >= fObjects.GetEntriesFast() ) {
-    AliErrorStream() << "Index outside limits" << endl;
-    return 0;
-  }
-  
-  return fObjects.UncheckedAt(index);
-}      
-
-//_____________________________________________________________________________
-TObject* AliMpExMap::GetObjectFast(Int_t index) const
-{
-  /// Return the object via its index in the array
-  /// (This function makes possible looping over map as over an array)
-  /// without bound checking.
-  
-  return fObjects.UncheckedAt(index);
-}      
+  return new AliMpExMapIterator(*this);
+}
 
 //_____________________________________________________________________________
 TObject* AliMpExMap::GetValue(const AliMpIntPair& key) const
@@ -365,25 +385,3 @@ void AliMpExMap::Streamer(TBuffer &R__b)
     AliMpExMap::Class()->WriteBuffer(R__b, this);
   }
 }
-
-//_____________________________________________________________________________
-void AliMpExMap::Print(Option_t* opt) const
-{
-  /// print out
-  cout << Form("fMap size/capacity %d/%d",fMap.GetSize(),fMap.Capacity()) 
-    << Form(" fObjects.GetSize/Entries %d/%d",fObjects.GetSize(),fObjects.GetEntries()) 
-  << Form(" fKeys.GetSize %d",fKeys.GetSize()) << endl;
-  
-  TString sopt(opt);
-  sopt.ToUpper();
-  
-  if ( sopt.Contains("FULL") ) 
-  {
-    TIter next(&fObjects);
-    TObject* o;
-    while ( ( o = next() ) )
-    {
-      o->Print();
-    }
-  }
-}
index bf5a046..3ffc3e8 100644 (file)
 #include <TExMap.h>
 
 class AliMpIntPair;
+class AliMpExMapIterator;
 
 class TString;
 
 class AliMpExMap : public TObject
 {
   public:
+  
+    friend class AliMpExMapIterator;
+  
     AliMpExMap();
-    AliMpExMap(Bool_t standardConstructor);
+    AliMpExMap(TRootIOCtor* /*ioCtor*/);
     AliMpExMap(const AliMpExMap& rhs);
     AliMpExMap& operator=(const AliMpExMap& rhs);
     virtual ~AliMpExMap();
@@ -40,11 +44,13 @@ class AliMpExMap : public TObject
     //
     static Long_t  GetIndex(const AliMpIntPair& pair);
     static Long_t  GetIndex(const TString& s);
+
     static AliMpIntPair  GetPair(Long_t index);
     static TString       GetString(Long_t index);
 
     // methods from base class
     virtual void Clear(Option_t* opt="");
+    virtual void Print(Option_t* opt="") const;
 
     // set methods
     void Add(const AliMpIntPair& key, TObject* object);
@@ -55,23 +61,20 @@ class AliMpExMap : public TObject
     void SetOwner(Bool_t owner);
     
     // get methods
-    Int_t       GetSize() const;
-    TExMapIter  GetIterator() const;
-    TObject*    GetObject(Int_t index) const;
-    TObject*    GetObjectFast(Int_t index) const;
-
+    Int_t GetSize() const;
+    Int_t GetCapacity() const;
+    
     TObject*    GetValue(const AliMpIntPair& key) const;
     TObject*    GetValue(const TString& key) const;
     TObject*    GetValue(Int_t key) const;
 
-    void Copy(TObject& dest) const;
+    AliMpExMapIterator* CreateIterator() const;
     
-  virtual void Print(Option_t* opt="") const;
-
   private:  
     // methods
     void FillMap();
     void AddKey(Long_t key);
+    void Copy(TObject& dest) const;
     
     // static data members
     static const Int_t    fgkDefaultSize;      ///< Default initial size
index 9009b74..10478c9 100644 (file)
@@ -20,6 +20,7 @@
 #include "AliMpBusPatch.h"
 #include "AliMpDDLStore.h"
 #include "TExMap.h"
+#include "AliLog.h"
 
 /// \class AliMpManuIterator
 ///
@@ -34,7 +35,7 @@ ClassImp(AliMpManuIterator)
 //_____________________________________________________________________________
 AliMpManuIterator::AliMpManuIterator()
 : TObject(), 
-fIterator(new TExMapIter(AliMpDDLStore::Instance()->GetBusPatchesIterator())),
+fIterator(AliMpDDLStore::Instance()->CreateBusPatchIterator()),
 fCurrentBusPatch(0x0),
 fCurrentManuIndex(-1)
 {
@@ -65,7 +66,7 @@ AliMpManuIterator::Next(Int_t& detElemId, Int_t& manuId)
   }
   else
   {
-    fCurrentBusPatch = NextBusPatch();
+    fCurrentBusPatch = static_cast<AliMpBusPatch*>(fIterator->Next());
     if (!fCurrentBusPatch ) 
     {
       return kFALSE;
@@ -76,30 +77,13 @@ AliMpManuIterator::Next(Int_t& detElemId, Int_t& manuId)
 }
 
 //_____________________________________________________________________________
-AliMpBusPatch* 
-AliMpManuIterator::NextBusPatch() const
-{
-  /// Return next bus patch
-  
-  Long_t key, value;
-  
-  Bool_t ok = fIterator->Next(key,value);
-
-  if (ok)
-  {
-    return reinterpret_cast<AliMpBusPatch*>(value);
-  }
-  return 0x0;
-}
-
-//_____________________________________________________________________________
 void
 AliMpManuIterator::Reset()
 {
   /// Rewind the iterator
   fIterator->Reset();
   
-  fCurrentBusPatch = NextBusPatch();
+  fCurrentBusPatch = static_cast<AliMpBusPatch*>(fIterator->Next());
   
   fCurrentManuIndex = -1;
 }
index bd215a4..f1ce2ae 100644 (file)
@@ -17,7 +17,7 @@
 #endif
 
 class AliMpBusPatch;
-class TExMapIter;
+class TIterator;
 
 class AliMpManuIterator : public TObject
 {
@@ -31,21 +31,18 @@ public:
   void Reset();
   
 private:
+   /// not implemented
+   AliMpManuIterator(const AliMpManuIterator& rhs);
+   /// not implemented
+   AliMpManuIterator& operator=(const AliMpManuIterator& rhs);
 
-    /// not implemented
-    AliMpManuIterator(const AliMpManuIterator& rhs);
-  /// not implemented
-  AliMpManuIterator& operator=(const AliMpManuIterator& rhs);
-
-    AliMpBusPatch* NextBusPatch() const;
-    
 private:
 
-    TExMapIter* fIterator; ///< internal iterator
+    TIterator* fIterator; ///< internal iterator
     AliMpBusPatch* fCurrentBusPatch; ///< current bus patch
     Int_t fCurrentManuIndex; ///< current manu index in current bus patch
     
-  ClassDef(AliMpManuIterator,1) // Iterator on MUON tracker manus
+  ClassDef(AliMpManuIterator,2) // Iterator on MUON tracker manus
 };
 
 #endif
index 41a86ed..fe8017f 100644 (file)
@@ -29,14 +29,14 @@ ClassImp(AliMpManuUID)
 
 //_____________________________________________________________________________
 AliMpManuUID::AliMpManuUID()
-  : TObject(), fNofChannels(0)
+  : TObject()
 {
     /// default ctor
 }
 
 //_____________________________________________________________________________
-AliMpManuUID::AliMpManuUID(Int_t detElemId, Int_t manuId, Int_t nofChannels)
-: TObject(), fNofChannels(nofChannels)
+AliMpManuUID::AliMpManuUID(Int_t detElemId, Int_t manuId)
+: TObject()
 {
   /// normal ctor
   SetUniqueID(BuildUniqueID(detElemId,manuId));                            
index 9b21bf5..3142f86 100644 (file)
@@ -20,7 +20,7 @@ class AliMpManuUID : public TObject
 {
 public:
   AliMpManuUID();
-  AliMpManuUID(Int_t detElemId, Int_t manuId, Int_t nofChannels=0);
+  AliMpManuUID(Int_t detElemId, Int_t manuId);
   virtual ~AliMpManuUID();
   
   /// Get detection element
@@ -28,9 +28,6 @@ public:
 
   /// Get manu identifier
   Int_t ManuId() const { return AliMpManuUID::ManuId(GetUniqueID()); }
-
-  /// Get number of channels in this manu
-  Int_t NofChannels() const { return fNofChannels; }
   
   static UInt_t BuildUniqueID(Int_t detElemId, Int_t manuId);
   
@@ -38,10 +35,7 @@ public:
   
   static Int_t ManuId(UInt_t uniqueID);
   
-private:
-    Int_t fNofChannels; ///< number of channels in this manu (<=64)
-  
-  ClassDef(AliMpManuUID,1) // Unique ID for MUON tracker manus
+  ClassDef(AliMpManuUID,2) // Unique ID for MUON tracker manus
 };
 
 #endif
index a3d42df..c5a1d40 100755 (executable)
@@ -27,6 +27,9 @@
 //-----------------------------------------------------------------------------
 
 #include "AliMpMotifMap.h"
+
+#include "AliCodeTimer.h"
+#include "AliMpExMapIterator.h"
 #include "AliMpVMotif.h"
 #include "AliMpMotif.h"
 #include "AliMpMotifSpecial.h"
@@ -44,29 +47,41 @@ ClassImp(AliMpMotifMap)
 /// \endcond
 
 //_____________________________________________________________________________
-AliMpMotifMap::AliMpMotifMap(Bool_t /*standardConstructor*/) 
-  : TObject()
-#ifdef WITH_ROOT
-    ,fMotifs(true),
-     fMotifTypes(true),
-     fMotifPositions(true),
-     fMotifPositions2(true)
-#endif 
+AliMpMotifMap::AliMpMotifMap()
+  : TObject(),
+    fMotifs(),
+    fMotifTypes(),
+    fMotifPositions(),
+    fMotifPositions2()
 {
 /// Standard constructor
   
-  //fMotifPositions2.SetOwner(false);
+#ifdef WITH_ROOT
+  fMotifPositions2.SetOwner(false);
+#endif
 }
 
 //_____________________________________________________________________________
-AliMpMotifMap::AliMpMotifMap() 
+AliMpMotifMap::AliMpMotifMap(TRootIOCtor* ioCtor) 
   : TObject(),
+#ifdef WITH_STL
     fMotifs(),
     fMotifTypes(),
     fMotifPositions(),
     fMotifPositions2()
+#endif
+#ifdef WITH_ROOT
+    fMotifs(ioCtor),
+    fMotifTypes(ioCtor),
+    fMotifPositions(ioCtor),
+    fMotifPositions2(ioCtor)
+#endif
 {
-/// Default constructor
+/// Root IO constructor
+
+#ifdef WITH_ROOT
+   fMotifPositions2.SetOwner(false);
+#endif
 }
 
 //_____________________________________________________________________________
@@ -91,6 +106,7 @@ AliMpMotifMap::~AliMpMotifMap()
     delete ip->second;
   }  
 #endif  
+  
 }
 
 // 
@@ -169,11 +185,13 @@ void  AliMpMotifMap::PrintMotifs() const
   if (fMotifs.GetSize()) {
     cout << "Dump of Motif Map - " << fMotifs.GetSize() << " entries:" << endl;
     Int_t counter = 0;        
-    TExMapIter i = fMotifs.GetIterator();
-    Long_t key, value;
-    while ( i.Next(key, value) ) {
-      TString id  = fMotifs.AliMpExMap::GetString(key);
-      AliMpVMotif* motif = (AliMpVMotif*)value;
+    AliMpExMapIterator* it = fMotifs.CreateIterator();
+    Int_t key;
+    AliMpVMotif* motif;
+    
+    while ( ( motif = static_cast<AliMpVMotif*>(it->Next(key)) ) )
+    {
+         TString id  = fMotifs.AliMpExMap::GetString(key);
       cout << "Map element " 
            << setw(3) << counter++ << "   " 
            << id.Data() << "   " ;
@@ -181,6 +199,7 @@ void  AliMpMotifMap::PrintMotifs() const
       cout << endl;
     }
     cout << endl;
+    delete it;
   }
 #endif  
 }
@@ -210,12 +229,14 @@ void  AliMpMotifMap::PrintMotifTypes() const
 #ifdef WITH_ROOT
   if (fMotifTypes.GetSize()) {
     cout << "Dump of Motif Type Map - " << fMotifTypes.GetSize() << " entries:" << endl;
-    Int_t counter = 0;        
-    TExMapIter i = fMotifTypes.GetIterator();
-    Long_t key, value;
-    while ( i.Next(key, value) ) {
+    Int_t counter = 0;
+    AliMpExMapIterator* it = fMotifTypes.CreateIterator();
+    Int_t key;
+    AliMpMotifType* motifType;
+    
+    while ( ( motifType = static_cast<AliMpMotifType*>(it->Next(key)) ) )
+    {
       TString id  = AliMpExMap::GetString(key);
-      AliMpMotifType* motifType = (AliMpMotifType*)value;
       cout << "Map element " 
            << setw(3) << counter++ << "   " 
            << id.Data() << "   " ;
@@ -223,6 +244,7 @@ void  AliMpMotifMap::PrintMotifTypes() const
       cout << endl;
     }
     cout << endl;
+    delete it;
   }
 #endif  
 }
@@ -246,17 +268,14 @@ AliMpMotifMap::GetAllMotifPositionsIDs(TArrayI& ecn) const
   
 #ifdef WITH_ROOT  
   ecn.Set(fMotifPositions.GetSize());
-  TExMapIter it = fMotifPositions.GetIterator();
-  Long_t key, value;
+  TIter next(fMotifPositions.CreateIterator());
+  AliMpMotifPosition* motifPosition;
   Int_t i(0);
-  
-  while ( it.Next(key, value) ) 
+  while ( ( motifPosition = static_cast<AliMpMotifPosition*>(next()) ) )
   {
-    AliMpMotifPosition* motifPosition = reinterpret_cast<AliMpMotifPosition*>(value);
     ecn[i] = motifPosition->GetID();
     ++i;
   }
-  
 #endif  
 }
 
@@ -279,6 +298,8 @@ AliMpMotifPosition* AliMpMotifMap::GetMotifPosition(UInt_t index) const
 {
 /// Return the motif position which is in the map on the index-th position
 
+  AliCodeTimerAuto("");
+  
   if ( index >= GetNofMotifPositions() ) {
     AliErrorStream() << "Index " << index << " outside limits." << endl;
     return 0;
@@ -291,7 +312,9 @@ AliMpMotifPosition* AliMpMotifMap::GetMotifPosition(UInt_t index) const
 #endif
   
 #ifdef WITH_ROOT  
-  return (AliMpMotifPosition*)fMotifPositions.GetObject(index);
+  TIter next(fMotifPositions.CreateIterator());
+  while (index-- > 0) next();
+  return static_cast<AliMpMotifPosition*>(next());
 #endif 
 }
 
@@ -311,11 +334,10 @@ Int_t AliMpMotifMap::CalculateNofPads() const
 #endif
   
 #ifdef WITH_ROOT  
-  TExMapIter it = fMotifPositions.GetIterator();
-  Long_t key, value;
-  
-  while ( it.Next(key, value) ) {
-    AliMpMotifPosition* motifPosition = reinterpret_cast<AliMpMotifPosition*>(value);
+  TIter next(fMotifPositions.CreateIterator());
+  AliMpMotifPosition* motifPosition;
+  while ( ( motifPosition = static_cast<AliMpMotifPosition*>(next()) ) )
+  {
     nofPads += motifPosition->GetMotif()->GetMotifType()->GetNofPads();
   }
 #endif  
@@ -348,10 +370,11 @@ void  AliMpMotifMap::PrintMotifPositions() const
   if (fMotifPositions.GetSize()) {
     cout << "Dump of Motif Position Map - " << fMotifPositions.GetSize() << " entries:" << endl;
     Int_t counter = 0;        
-    TExMapIter i = fMotifPositions.GetIterator();
-    Long_t key, value;
-    while ( i.Next(key, value) ) {
-      AliMpMotifPosition* motifPosition = (AliMpMotifPosition*)value;
+    TIter next(fMotifPositions.CreateIterator());
+    AliMpMotifPosition* motifPosition;
+    
+    while ( ( motifPosition = static_cast<AliMpMotifPosition*>(next()) ) )
+    {
       cout << "Map element " 
            << setw(3) << counter++ << "   "; 
       PrintMotifPosition(motifPosition);          
@@ -385,15 +408,17 @@ void  AliMpMotifMap::PrintMotifPositions2() const
 #endif  
 
 #ifdef WITH_ROOT
-  if (fMotifPositions2.GetSize()) {
+  
+  if (fMotifPositions2.GetSize()) 
+  {
     cout << "Dump of Motif Position Map 2 - " << fMotifPositions2.GetSize() << " entries:" << endl;
+    TIter next(fMotifPositions2.CreateIterator());
+    AliMpMotifPosition* motifPosition(0x0);
     Int_t counter = 0;        
-    TExMapIter i = fMotifPositions2.GetIterator();
-    Long_t key, value;
-    while ( i.Next(key, value) ) {
-      AliMpMotifPosition* motifPosition = (AliMpMotifPosition*)value;
-      cout << "Map element " 
-           << setw(3) << counter++ << "   "; 
+    
+    while ( ( motifPosition = static_cast<AliMpMotifPosition*>(next()) ) )
+    {
+      cout << "Map element " << setw(3) << counter++ << "   "; 
       PrintMotifPosition2(motifPosition);         
       cout << endl;
     }
@@ -497,7 +522,7 @@ Bool_t AliMpMotifMap::AddMotifPosition(AliMpMotifPosition* motifPosition, Bool_t
 #endif
 
 #ifdef WITH_ROOT
-  fMotifPositions.Add(motifPosition->GetID(), motifPosition);
+  fMotifPositions.Add(motifPosition->GetID() << 16, motifPosition);
 #endif
 
   return true;
@@ -527,10 +552,10 @@ void AliMpMotifMap::FillMotifPositionMap2()
     return;
   }  
 
-  TExMapIter i = fMotifPositions.GetIterator();
-  Long_t key, value;
-  while ( i.Next(key, value) ) {
-    AliMpMotifPosition* motifPosition = (AliMpMotifPosition*)value;
+  TIter next(fMotifPositions.CreateIterator());
+  AliMpMotifPosition* motifPosition(0x0);
+  while ( ( motifPosition = static_cast<AliMpMotifPosition*>(next()) ) )
+  {
     fMotifPositions2.Add(motifPosition->GetLowIndicesLimit(), motifPosition);
   }
 #endif
@@ -576,10 +601,10 @@ void  AliMpMotifMap::PrintGlobalIndices(const char* fileName) const
 
 #ifdef WITH_ROOT
   if (fMotifPositions.GetSize()) {
-    TExMapIter i = fMotifPositions.GetIterator();
-    Long_t key, value;
-    while ( i.Next(key, value) ) {
-      AliMpMotifPosition* motifPosition = (AliMpMotifPosition*)value;
+    TIter next(fMotifPositions.CreateIterator());
+    AliMpMotifPosition* motifPosition;
+    while ( ( motifPosition = static_cast<AliMpMotifPosition*>(next()) ) )
+    {
       out << setw(5) << motifPosition->GetID() << "     "
          << setw(3) << motifPosition->GetLowIndicesLimit().GetFirst()  << " " 
          << setw(3) << motifPosition->GetLowIndicesLimit().GetSecond() 
@@ -638,6 +663,8 @@ AliMpVMotif* AliMpMotifMap::FindMotif(const TString& motifID) const
 {
 /// Find the motif with the specified ID.
   
+  //AliCodeTimerAuto("");
+
 #ifdef WITH_STL
   MotifMapIterator i = fMotifs.find(motifID);
   if (i != fMotifs.end()) 
@@ -661,11 +688,12 @@ AliMpVMotif* AliMpMotifMap::FindMotif(const TString& motifID,
 /// with the given motifTypeID and motifDimensions.
 /// Disagreement causes fatal error.
  
+  //AliCodeTimerAuto("");
+
   AliMpVMotif* motif = FindMotif(motifID);
 
   if (motif && motif->GetMotifType()->GetID() != motifTypeID) {
-      Fatal("FindMotif", 
-            "Motif has been already defined with a different type.");
+      AliFatal("Motif has been already defined with a different type.");
       return 0;            
   }
 
@@ -675,8 +703,7 @@ AliMpVMotif* AliMpMotifMap::FindMotif(const TString& motifID,
       ( motif->GetPadDimensions(0).X() != padDimensions.X() ||
         motif->GetPadDimensions(0).Y() != padDimensions.Y())) { 
       
-      Fatal("FindMotifType", 
-            "Motif type has been already defined with different dimensions.");
+      AliFatal("Motif type has been already defined with different dimensions.");
       return 0;
 
   } 
@@ -686,8 +713,7 @@ AliMpVMotif* AliMpMotifMap::FindMotif(const TString& motifID,
       (padDimensions.X() == 0. && padDimensions.Y() == 0.) &&
       !dynamic_cast<AliMpMotifSpecial*>(motif)) {
 
-      Fatal("FindMotifType", 
-            "Motif type has been already defined with different dimensions.");
+      AliFatal("Motif type has been already defined with different dimensions.");
       return 0;
 
   } 
@@ -700,6 +726,8 @@ AliMpMotifType* AliMpMotifMap::FindMotifType(const TString& motifTypeID) const
 {
 /// Find the motif type with the specified motif type ID.
   
+  //AliCodeTimerAuto("");
+
 #ifdef WITH_STL
   MotifTypeMapIterator i = fMotifTypes.find(motifTypeID);
   if (i != fMotifTypes.end()) 
@@ -719,6 +747,8 @@ AliMpMotifMap::FindMotifPosition(Int_t motifPositionID) const
 {
 /// Find the motif position with the specified motif position ID.
   
+  //AliCodeTimerAuto("");
+
 #ifdef WITH_STL
   MotifPositionMapIterator i = fMotifPositions.find(motifPositionID);
   if (i != fMotifPositions.end()) 
@@ -728,7 +758,7 @@ AliMpMotifMap::FindMotifPosition(Int_t motifPositionID) const
 #endif
 
 #ifdef WITH_ROOT
-  return (AliMpMotifPosition*)fMotifPositions.GetValue(motifPositionID);
+  return (AliMpMotifPosition*)fMotifPositions.GetValue(motifPositionID << 16);
 #endif
 }
 
index 4934d7f..56cf91a 100755 (executable)
@@ -78,8 +78,8 @@ class AliMpMotifMap : public TObject
 #endif    
 
   public:
-    AliMpMotifMap(Bool_t /*standardConstructor*/);
     AliMpMotifMap();
+    AliMpMotifMap(TRootIOCtor* ioCtor);
     virtual ~AliMpMotifMap();
     
     // methods
index d3954a1..5290549 100644 (file)
@@ -234,11 +234,14 @@ AliMpMotifType* AliMpMotifReader::BuildMotifType(const TString& motifTypeId)
 
     ix = AliMpExMap::GetPair(value).GetFirst();
     iy = AliMpExMap::GetPair(value).GetSecond();
+    
 #endif
 
-    motifType->AddConnection(AliMpIntPair(ix,iy),
-                  new AliMpConnection(padNum,numBerg,numKapton,gassiNum));
-
+    AliMpConnection* connection 
+      = new AliMpConnection(padNum,numBerg,numKapton,gassiNum, AliMpIntPair(ix,iy));
+    
+    motifType->AddConnection(AliMpIntPair(ix,iy),connection);
+                  
     if (ix>=nofPadsX) nofPadsX=ix+1;
     if (iy>=nofPadsY) nofPadsY=iy+1;
 
index 04ebc20..902e46c 100755 (executable)
@@ -41,27 +41,11 @@ ClassImp(AliMpMotifSpecial)
 
 
 //______________________________________________________________________________
-AliMpMotifSpecial::AliMpMotifSpecial():
-  AliMpVMotif(),
-  fDimensions(),
-  fPadDimensionsVector(),
-  fPadDimensionsVector2()
-{
-  /// Default constructor
-}
-
-
-//______________________________________________________________________________
 AliMpMotifSpecial::AliMpMotifSpecial(const TString &id, 
                                      AliMpMotifType *motifType)
   : AliMpVMotif(id,motifType),
     fDimensions(),
-#ifdef WITH_STL
     fPadDimensionsVector(),
-#endif    
-#ifdef WITH_ROOT
-    fPadDimensionsVector(true),
-#endif    
     fPadDimensionsVector2()
   
 {
@@ -73,6 +57,22 @@ AliMpMotifSpecial::AliMpMotifSpecial(const TString &id,
 }
 
 //______________________________________________________________________________
+AliMpMotifSpecial::AliMpMotifSpecial(TRootIOCtor* ioCtor):
+  AliMpVMotif(),
+  fDimensions(),
+#ifdef WITH_STL
+  fPadDimensionsVector(),
+#endif    
+#ifdef WITH_ROOT
+  fPadDimensionsVector(ioCtor),
+#endif    
+  fPadDimensionsVector2()
+{
+  /// Root IO constructor
+}
+
+
+//______________________________________________________________________________
 AliMpMotifSpecial::~AliMpMotifSpecial()
 {
   /// Destructor
index b41dba1..d9d8f98 100755 (executable)
@@ -49,7 +49,7 @@ class AliMpMotifSpecial : public AliMpVMotif
 
  public:
   AliMpMotifSpecial(const TString &id, AliMpMotifType *motifType);
-  AliMpMotifSpecial();
+  AliMpMotifSpecial(TRootIOCtor* ioCtor);
   virtual ~AliMpMotifSpecial();
 
   // Access methods
@@ -70,6 +70,8 @@ class AliMpMotifSpecial : public AliMpVMotif
   virtual AliMpIntPair PadIndicesLocal(const TVector2& localPos) const;
 
  private:
+  /// Not implemented
+  AliMpMotifSpecial();
   // methods
   Int_t VectorIndex(const AliMpIntPair& indices) const;
 
index 1425cd8..7d72904 100755 (executable)
@@ -27,6 +27,8 @@
 
 #include <cstdlib>
 #include "AliMpMotifType.h"
+
+#include "AliMpExMapIterator.h"
 #include "AliMpMotifTypePadIterator.h"
 #include "AliMpConnection.h"
 
@@ -48,12 +50,7 @@ AliMpMotifType::AliMpMotifType(const TString &id)
     fID(id),
     fNofPadsX(0),   
     fNofPadsY(0),
-#ifdef WITH_STL
     fConnections()
-#endif
-#ifdef WITH_ROOT
-    fConnections(true)
-#endif
 {
   /// Standard constructor                                                   \n
   /// Please note that id should be of the form %s for station 1,2,
@@ -63,12 +60,17 @@ AliMpMotifType::AliMpMotifType(const TString &id)
 }
 
 //______________________________________________________________________________
-AliMpMotifType::AliMpMotifType() 
+AliMpMotifType::AliMpMotifType(TRootIOCtor* ioCtor) 
   : TObject(),
     fID(""),
     fNofPadsX(0),   
     fNofPadsY(0),
+#ifdef WITH_STL
     fConnections()
+#endif
+#ifdef WITH_ROOT
+    fConnections(ioCtor)
+#endif
 {
   /// Default constructor
       AliDebug(1,Form("this=%p",this));
@@ -208,13 +210,14 @@ AliMpConnection *AliMpMotifType::FindConnectionByPadNum(Int_t padNum) const
 #endif
 
 #ifdef WITH_ROOT
-  TExMapIter i = fConnections.GetIterator();
-  Long_t key, value;
-  while ( i.Next(key, value) ) {
-    AliMpConnection* connection = (AliMpConnection*)value;
-    if (connection->GetPadNum()==padNum) return connection;
-  }  
- return 0;
+ TIter next(fConnections.CreateIterator());
+ AliMpConnection* connection;
+ while ( ( connection = static_cast<AliMpConnection*>(next()) ) )
+ {
+   if (connection->GetPadNum()==padNum) return connection;
+ }
+ return 0x0;
 #endif
 }
 
@@ -251,13 +254,14 @@ AliMpConnection *AliMpMotifType::FindConnectionByGassiNum(Int_t gassiNum) const
 #endif
 
 #ifdef WITH_ROOT
-  TExMapIter i = fConnections.GetIterator();
-  Long_t key, value;
-  while ( i.Next(key, value) ) {
-    AliMpConnection* connection = (AliMpConnection*)value;
-    if (connection->GetGassiNum()==gassiNum) return connection;
-  }  
- return 0;
+ TIter next(fConnections.CreateIterator());
+ AliMpConnection* connection;
+ while ( ( connection = static_cast<AliMpConnection*>(next()) ) )
+ {
+   if (connection->GetGassiNum()==gassiNum) return connection;
+ }
+ return 0x0;
 #endif
 }
 
@@ -274,13 +278,14 @@ AliMpConnection *AliMpMotifType::FindConnectionByKaptonNum(Int_t kaptonNum) cons
 #endif
 
 #ifdef WITH_ROOT
-  TExMapIter i = fConnections.GetIterator();
-  Long_t key, value;
-  while ( i.Next(key, value) ) {
-    AliMpConnection* connection = (AliMpConnection*)value;
-    if (connection->GetKaptonNum()==kaptonNum) return connection;
-  }  
- return 0;
+ TIter next(fConnections.CreateIterator());
+ AliMpConnection* connection;
+ while ( ( connection = static_cast<AliMpConnection*>(next()) ) )
+ {
+   if (connection->GetKaptonNum()==kaptonNum) return connection;
+ }
+ return 0x0;
 #endif
 }
 //______________________________________________________________________________
@@ -296,41 +301,24 @@ AliMpConnection *AliMpMotifType::FindConnectionByBergNum(Int_t bergNum) const
 #endif
 
 #ifdef WITH_ROOT
-  TExMapIter i = fConnections.GetIterator();
-  Long_t key, value;
-  while ( i.Next(key, value) ) {
-    AliMpConnection* connection = (AliMpConnection*)value;
-    if (connection->GetBergNum()==bergNum) return connection;
-  }  
-  return 0;
+ TIter next(fConnections.CreateIterator());
+ AliMpConnection* connection;
+ while ( ( connection = static_cast<AliMpConnection*>(next()) ) )
+ {
+   if (connection->GetBergNum()==bergNum) return connection;
+ }
+ return 0x0;
 #endif
 }
 
 
 //______________________________________________________________________________
-AliMpIntPair AliMpMotifType::FindLocalIndicesByConnection(
-                                 const AliMpConnection* connection) const
+AliMpIntPair AliMpMotifType::FindLocalIndicesByConnection(const AliMpConnection* connection) const
 {
-  /// Retrieve the pad position from the connection pointer.
-  /// Not to be used widely, since it use a search in the
-  /// connection list...
-
-#ifdef WITH_STL
- for(ConnectionMapCIterator i = fConnections.begin();
-  i!=fConnections.end();++i)
-   if (i->second==connection) return i->first;
-#endif
-
-#ifdef WITH_ROOT
-  TExMapIter i = fConnections.GetIterator();
-  Long_t key, value;
-  while ( i.Next(key, value) ) {
-    AliMpConnection* aConnection = (AliMpConnection*)value;
-    if (aConnection == connection) return AliMpExMap::GetPair(key);
-  }  
-#endif
+  /// Reurn the pad position from the connection pointer.
 
-  return AliMpIntPair::Invalid();
+  return connection->LocalIndices();
 }
 
 //______________________________________________________________________________
@@ -345,12 +333,13 @@ AliMpIntPair AliMpMotifType::FindLocalIndicesByPadNum(Int_t padNum) const
 #endif
    
 #ifdef WITH_ROOT
-  TExMapIter i = fConnections.GetIterator();
-  Long_t key, value;
-  while ( i.Next(key, value) ) {
-    AliMpConnection* connection = (AliMpConnection*)value;
-    if (connection->GetPadNum() == padNum) return AliMpExMap::GetPair(key);
-  }  
+  TIter next(fConnections.CreateIterator());
+  AliMpConnection* connection;
+  
+  while ( ( connection = static_cast<AliMpConnection*>(next()) ) )
+  {
+    if (connection->GetPadNum()==padNum) return connection->LocalIndices();
+  }
 #endif
  return AliMpIntPair::Invalid();
 }
@@ -367,12 +356,13 @@ AliMpIntPair AliMpMotifType::FindLocalIndicesByGassiNum(Int_t gassiNum) const
 #endif
    
 #ifdef WITH_ROOT
-  TExMapIter i = fConnections.GetIterator();
-  Long_t key, value;
-  while ( i.Next(key, value) ) {
-    AliMpConnection* connection = (AliMpConnection*)value;
-    if (connection->GetGassiNum()==gassiNum) return AliMpExMap::GetPair(key);
-  }  
+  TIter next(fConnections.CreateIterator());
+  AliMpConnection* connection;
+  
+  while ( ( connection = static_cast<AliMpConnection*>(next()) ) )
+  {
+    if (connection->GetGassiNum()==gassiNum) return connection->LocalIndices();
+  }
 #endif
    
  return AliMpIntPair::Invalid();
@@ -390,12 +380,13 @@ AliMpIntPair AliMpMotifType::FindLocalIndicesByKaptonNum(Int_t kaptonNum) const
 #endif
    
 #ifdef WITH_ROOT
-  TExMapIter i = fConnections.GetIterator();
-  Long_t key, value;
-  while ( i.Next(key, value) ) {
-    AliMpConnection* connection = (AliMpConnection*)value;
-    if (connection->GetKaptonNum()==kaptonNum) return AliMpExMap::GetPair(key);
-  }  
+  TIter next(fConnections.CreateIterator());
+  AliMpConnection* connection;
+  
+  while ( ( connection = static_cast<AliMpConnection*>(next()) ) )
+  {
+    if (connection->GetKaptonNum()==kaptonNum) return connection->LocalIndices();
+  }
 #endif
    
  return AliMpIntPair::Invalid();
@@ -413,12 +404,13 @@ AliMpIntPair AliMpMotifType::FindLocalIndicesByBergNum(Int_t bergNum) const
 #endif
    
 #ifdef WITH_ROOT
-  TExMapIter i = fConnections.GetIterator();
-  Long_t key, value;
-  while ( i.Next(key, value) ) {
-    AliMpConnection* connection = (AliMpConnection*)value;
-    if (connection->GetBergNum()==bergNum) return AliMpExMap::GetPair(key);
-  }  
+  TIter next(fConnections.CreateIterator());
+  AliMpConnection* connection;
+  
+  while ( ( connection = static_cast<AliMpConnection*>(next()) ) )
+  {
+    if (connection->GetBergNum()==bergNum) return connection->LocalIndices();
+  }
 #endif
    
  return AliMpIntPair::Invalid();
index 9b636fa..7ab08e4 100755 (executable)
@@ -49,7 +49,7 @@ class AliMpMotifType : public TObject
     AliMpMotifType(const TString &id);
     AliMpMotifType(const AliMpMotifType& rhs);
     AliMpMotifType& operator=(const AliMpMotifType& rhs);
-    AliMpMotifType();
+    AliMpMotifType(TRootIOCtor* ioCtor);
     virtual ~AliMpMotifType();
 
     TObject* Clone(const char* newname="") const;
@@ -99,6 +99,8 @@ class AliMpMotifType : public TObject
       void Copy(TObject& o) const;
     
   private:
+    /// Not implemented
+    AliMpMotifType();
     // static data members
     static const Int_t  fgkPadNumForA; ///< the pad number for the pad "A"
   
index ba4efc7..c1c9568 100644 (file)
@@ -207,7 +207,7 @@ AliMpPCB::~AliMpPCB()
   ///
   AliDebug(1,Form("this=%p",this));
 #ifndef WITH_ROOT
-  for ( size_t i = 0; i < fMotifPositions.size(); ++i )
+  for ( UInt_t i = 0; i < fMotifPositions.size(); ++i )
   {
     delete fMotifPositions[i];
   }
@@ -378,7 +378,7 @@ AliMpPCB::Clone(const TArrayI& manuids, Int_t ixOffset, Double_t xOffset) const
 
   // Then change the internal MotifPositions wrt manu id
   // and position (offset in x).
-  for ( Size_t i = 0; i < pcb->GetSize(); ++i )
+  for ( Int_t i = 0; i < pcb->GetSize(); ++i )
     {
       AliMpMotifPosition* mp = pcb->GetMotifPosition(i);
       mp->SetID(manuids[i]);
@@ -434,16 +434,16 @@ AliMpPCB::Copy(TObject& o) const
   pcb.fMotifPositions.Delete();
   AliDebug(1,"Deleting pcb.fMotifPositions : done");
 #else
-  for ( Size_t i = 0; i < pcb.fMotifPositions.size(); ++i )
+  for ( UInt_t i = 0; i < pcb.fMotifPositions.size(); ++i )
   {
     delete pcb.fMotifPositions[i];
   }
 #endif
 
 #ifdef WITH_ROOT
-  for ( Size_t i = 0; i < fMotifPositions.GetEntriesFast(); ++i )
+  for ( Int_t i = 0; i < fMotifPositions.GetEntriesFast(); ++i )
 #else
-  for ( Size_t i = 0; i < fMotifPositions.size(); ++i )
+  for ( UInt_t i = 0; i < fMotifPositions.size(); ++i )
 #endif  
     {
       AliMpMotifPosition* pos = (AliMpMotifPosition*)fMotifPositions[i];
@@ -528,9 +528,9 @@ AliMpPCB::FindMotifPosition(Int_t ix, Int_t iy) const
   ///
   
 #ifdef WITH_ROOT
-  for (Size_t i = 0; i < fMotifPositions.GetEntriesFast(); ++i )
+  for (Int_t i = 0; i < fMotifPositions.GetEntriesFast(); ++i )
 #else  
-  for (Size_t i = 0; i < fMotifPositions.size(); ++i )
+  for (UInt_t i = 0; i < fMotifPositions.size(); ++i )
 #endif
     {
       AliMpMotifPosition* mp = (AliMpMotifPosition*)fMotifPositions[i];
@@ -551,9 +551,9 @@ AliMpPCB::FindMotifPosition(Double_t x, Double_t y) const
   ///
   
 #ifdef WITH_ROOT
-  for (Size_t i = 0; i < fMotifPositions.GetEntriesFast(); ++i )
+  for (Int_t i = 0; i < fMotifPositions.GetEntriesFast(); ++i )
 #else  
-  for (Size_t i = 0; i < fMotifPositions.size(); ++i )
+  for (UInt_t i = 0; i < fMotifPositions.size(); ++i )
 #endif   
   {
     AliMpMotifPosition* mp = (AliMpMotifPosition*)fMotifPositions[i];
@@ -583,7 +583,7 @@ AliMpPCB::GetID() const
 
 //_____________________________________________________________________________
 AliMpMotifPosition*
-AliMpPCB::GetMotifPosition(AliMpPCB::Size_t i) const
+AliMpPCB::GetMotifPosition(Int_t i) const
 {
   ///
   /// Get the i-th motifPosition stored in this PCB's internal array.
@@ -592,7 +592,7 @@ AliMpPCB::GetMotifPosition(AliMpPCB::Size_t i) const
 #ifdef WITH_ROOT
   if ( i >= fMotifPositions.GetEntriesFast() ) return 0;
 #else
-  if ( i >= fMotifPositions.size() ) return 0;
+  if ( i >= Int_t(fMotifPositions.size()) ) return 0;
 #endif  
   return (AliMpMotifPosition*)fMotifPositions[i];
 }
@@ -620,7 +620,7 @@ AliMpPCB::GetNofPadsY() const
 }
 
 //_____________________________________________________________________________
-AliMpPCB::Size_t
+Int_t
 AliMpPCB::GetSize() const
 {
   ///
@@ -649,7 +649,10 @@ AliMpPCB::HasMotifPositionID(Int_t manuId) const
   }
   return kFALSE;
 #else
-  AliFatal("Not implemented");
+  for ( UInt_t i=0; i<fMotifPositions.size(); ++i ) {
+    if ( fMotifPositions[i]->GetID() == manuId ) return kTRUE;
+  }  
+  return kFALSE;
 #endif
 }
 
@@ -739,9 +742,9 @@ AliMpPCB::Print(Option_t* option) const
   if ( option && option[0] == 'M' )
   {
 #ifdef WITH_ROOT
-    for ( Size_t i = 0; i < fMotifPositions.GetEntriesFast(); ++i )
+    for ( Int_t i = 0; i < fMotifPositions.GetEntriesFast(); ++i )
 #else  
-    for ( Size_t i = 0; i < fMotifPositions.size(); ++i )
+    for ( UInt_t i = 0; i < fMotifPositions.size(); ++i )
 #endif    
     {
       if (option)
@@ -769,9 +772,9 @@ AliMpPCB::Save() const
   lines.SetOwner(kTRUE);
   
 #ifdef WITH_ROOT
-  for ( Size_t i = 0; i < fMotifPositions.GetEntriesFast(); ++i )
+  for ( Int_t i = 0; i < fMotifPositions.GetEntriesFast(); ++i )
 #else  
-  for ( Size_t i = 0; i < fMotifPositions.size(); ++i )
+  for ( UInt_t i = 0; i < fMotifPositions.size(); ++i )
 #endif    
   {
     AliMpMotifPosition* pos = GetMotifPosition(i);
index 8361274..df82620 100644 (file)
@@ -52,14 +52,6 @@ class AliMpPCB : public TObject
 {
  public:
 
-#ifdef WITH_ROOT
-  /// Type def for the array size
-  typedef Int_t  Size_t;
-#else  
-  /// Type def for the array size
-  typedef UInt_t Size_t;
-#endif
-  
   AliMpPCB();
   /** Ctor. The sizes are given in mm.
       See full doc for the meaning of enveloppe parameters.
@@ -125,7 +117,7 @@ class AliMpPCB : public TObject
   /** Returns the i-th motifPosition of this PCB.
       i : [0..GetSize()-1]
   */
-  AliMpMotifPosition* GetMotifPosition(Size_t i) const;
+  AliMpMotifPosition* GetMotifPosition(Int_t i) const;
 
   /// Returns the motifPosition which contains the pad at (ix,iy).
   AliMpMotifPosition* FindMotifPosition(Int_t ix, Int_t iy) const;
@@ -134,7 +126,7 @@ class AliMpPCB : public TObject
   AliMpMotifPosition* FindMotifPosition(Double_t x, Double_t y) const;
 
   /// The number of motifs, aka manus.
-  Size_t GetSize() const;
+  Int_t GetSize() const;
 
   Int_t GetNofPadsX() const;
   Int_t GetNofPadsY() const;
index dde8924..7796bb2 100644 (file)
@@ -95,7 +95,7 @@ AliMpPCBPainter::Draw(Option_t* option)
   switch (option[0])
   {
     case 'M':
-      for ( AliMpPCB::Size_t i = 0; i < fPCB->GetSize(); ++i )
+      for ( Int_t i = 0; i < fPCB->GetSize(); ++i )
       {
         AliMpMotifPosition* pos = fPCB->GetMotifPosition(i);
         
index d26d6b1..441352a 100644 (file)
@@ -24,6 +24,7 @@
 //-----------------------------------------------------------------------------
 
 #include "AliMpRegionalTrigger.h"
+#include "AliMpExMapIterator.h"
 #include "AliMpTriggerCrate.h"
 #include "AliMpLocalBoard.h"
 #include "AliMpConstants.h"
@@ -46,32 +47,32 @@ ClassImp(AliMpRegionalTrigger)
 //______________________________________________________________________________
 AliMpRegionalTrigger::AliMpRegionalTrigger()
   : TObject(),
-    fTriggerCrates(true),
-    fLocalBoards(true)
+    fTriggerCrates(),
+    fLocalBoardMap(),
+    fLocalBoardArray(AliMpConstants::TotalNofLocalBoards()+1) // included non-notified boards
 {
-/// Standard constructor
+      /// Standard constructor
   
     fTriggerCrates.SetOwner(true);
     fTriggerCrates.SetSize(AliMpConstants::LocalBoardNofChannels());
-
-    fLocalBoards.SetOwner(true);
-    fLocalBoards.SetSize(AliMpConstants::TotalNofLocalBoards()); // included non-notified boards
 }
 
 //______________________________________________________________________________
 AliMpRegionalTrigger::AliMpRegionalTrigger(const AliMpRegionalTrigger& rhs)
   : TObject(rhs),
     fTriggerCrates(rhs.fTriggerCrates),
-    fLocalBoards(rhs.fLocalBoards)
+    fLocalBoardMap(rhs.fLocalBoardMap),
+    fLocalBoardArray(rhs.fLocalBoardArray)
 {
 /// Copy constructor
 }  
 
 //______________________________________________________________________________
-AliMpRegionalTrigger::AliMpRegionalTrigger(TRootIOCtor* /*ioCtor*/)
+AliMpRegionalTrigger::AliMpRegionalTrigger(TRootIOCtor* ioCtor)
   : TObject(),
-    fTriggerCrates(),
-    fLocalBoards()
+    fTriggerCrates(ioCtor),
+    fLocalBoardMap(ioCtor),
+    fLocalBoardArray()
 {
 /// Constructor for I0
 }
@@ -89,7 +90,7 @@ AliMpRegionalTrigger& AliMpRegionalTrigger::operator=(const AliMpRegionalTrigger
 
   // assignment operator
   fTriggerCrates = rhs.fTriggerCrates;
-  fLocalBoards = rhs.fLocalBoards;
+  fLocalBoardArray = rhs.fLocalBoardArray;
   
   return *this;
 }  
@@ -203,8 +204,9 @@ Bool_t AliMpRegionalTrigger::ReadData(const TString& fileName)
           
           board->SetTC(list[4]);
           
-          // add local board into map
-          fLocalBoards.Add(board->GetId(), board);
+          // add local board into array
+          fLocalBoardArray.AddAt(board,board->GetId());
+          fLocalBoardMap.Add(board->GetId(),board);
         }
       }
     }
@@ -214,15 +216,15 @@ Bool_t AliMpRegionalTrigger::ReadData(const TString& fileName)
 //______________________________________________________________________________
 AliMpLocalBoard* AliMpRegionalTrigger::FindLocalBoard(Int_t localBoardId, 
                                                       Bool_t warn) const {
-    /// Return bus patch with given Id
+    /// Return local board with given Id
 
     AliMpLocalBoard* localBoard
-      = (AliMpLocalBoard*) fLocalBoards.GetValue(localBoardId);
-
+      = static_cast<AliMpLocalBoard*>(fLocalBoardMap.GetValue(localBoardId));
+    
     if ( ! localBoard && warn ) {
         AliErrorStream()
-        << "Local board with Id = " << localBoardId << " not defined." << endl;
-    }
+        << "Loacl board with localBoardId = " << localBoardId << " not found." << endl;
+    }      
 
     return localBoard;
 }
@@ -252,47 +254,44 @@ Int_t AliMpRegionalTrigger::GetNofTriggerCrates() const
 }
 
 //______________________________________________________________________________
-AliMpTriggerCrate* AliMpRegionalTrigger::GetTriggerCrate(Int_t index) const
+Int_t AliMpRegionalTrigger::GetNofLocalBoards() const
 { 
-    /// Return the trigger crates with given index;
-
-    return static_cast<AliMpTriggerCrate*>(fTriggerCrates.GetObject(index)); 
+    /// Return number of local boards
+    
+    return fLocalBoardArray.GetSize(); 
 }
 
 //______________________________________________________________________________
-AliMpTriggerCrate* AliMpRegionalTrigger::GetTriggerCrateFast(Int_t index) const
-{ 
-    /// Return the trigger crates with given index;
-    /// the index is not checked as we use the fast method in AliMpExMap.
+TIterator* 
+AliMpRegionalTrigger::CreateCrateIterator() const
+{
+  /// Create iterator over crates
 
-    return static_cast<AliMpTriggerCrate*>(fTriggerCrates.GetObjectFast(index)); 
+  return fTriggerCrates.CreateIterator();
 }
 
 //______________________________________________________________________________
-Int_t AliMpRegionalTrigger::GetNofLocalBoards() const
-{ 
-    /// Return number of local boards
-    
-    return fLocalBoards.GetSize(); 
-}
+TIterator* 
+AliMpRegionalTrigger::CreateLocalBoardIterator() const
+{
+  /// Create iterator over local boards
 
-//______________________________________________________________________________
-AliMpLocalBoard* AliMpRegionalTrigger::GetLocalBoard(Int_t index) const
-{ 
-    /// Return local board with given index;
-    
-    return static_cast<AliMpLocalBoard*>(fLocalBoards.GetObject(index)); 
+  return fLocalBoardArray.MakeIterator();
 }
 
 //______________________________________________________________________________
-AliMpLocalBoard* AliMpRegionalTrigger::GetLocalBoardFast(Int_t index) const
-{ 
-    /// Return local board with given index;
-    /// the index is not checked as we use the fast method in AliMpExMap.
-    
-    return static_cast<AliMpLocalBoard*>(fLocalBoards.GetObjectFast(index)); 
+Int_t 
+AliMpRegionalTrigger::LocalBoardId(Int_t index) const
+{
+  /// Return local board Id for the local boards with a given index
+
+  AliMpLocalBoard* lb = static_cast<AliMpLocalBoard*>(fLocalBoardArray.At(index));
+  if (lb)
+  {
+    return lb->GetId();
+  }
+  AliError(Form("Could not get local board at index %d",index));
+  return -1;
 }
 
 
-
-
index c9fe1bc..9c83dd8 100644 (file)
 
 class AliMpTriggerCrate;
 class AliMpLocalBoard;
+class TIterator;
 
 class AliMpRegionalTrigger : public  TObject{
 
   public:
     AliMpRegionalTrigger();
     AliMpRegionalTrigger(const AliMpRegionalTrigger& rhs);
-    AliMpRegionalTrigger(TRootIOCtor* /*ioCtor*/);
+    AliMpRegionalTrigger(TRootIOCtor* ioCtor);
     virtual ~AliMpRegionalTrigger();
     
     // operators
@@ -39,35 +40,26 @@ class AliMpRegionalTrigger : public  TObject{
     AliMpLocalBoard*   FindLocalBoard(Int_t localBoardId, Bool_t warn = true) const;
 
     // method for looping
+
+    TIterator* CreateCrateIterator() const;
+    
+    TIterator* CreateLocalBoardIterator() const;
+    
+    Int_t LocalBoardId(Int_t index) const;
     
     Int_t GetNofTriggerCrates() const;
-    AliMpTriggerCrate* GetTriggerCrate(Int_t index) const;
-    AliMpTriggerCrate* GetTriggerCrateFast(Int_t index) const;
-    TExMapIter GetTriggerCrateItr() const;
 
     Int_t GetNofLocalBoards() const;
-    AliMpLocalBoard* GetLocalBoard(Int_t index) const;
-    AliMpLocalBoard* GetLocalBoardFast(Int_t index) const;
-    TExMapIter GetLocalBoardItr() const;
 
   private:
     // data members  
     AliMpExMap  fTriggerCrates; ///< map for trigger crates
-    AliMpExMap  fLocalBoards;   ///< map for local boards
+    AliMpExMap fLocalBoardMap; ///< map of local boards (owner of boards)
+    TObjArray  fLocalBoardArray; ///< array of local boards (not owner of boards, the map is the owner)
  
-  ClassDef(AliMpRegionalTrigger,1) // Regional trigger crate
+  ClassDef(AliMpRegionalTrigger,2) // Regional trigger crate
 };
 
-/// Return trigger crates iterator
-inline TExMapIter AliMpRegionalTrigger::GetTriggerCrateItr() const { 
-  return fTriggerCrates.GetIterator(); 
-}
-
-/// Return trigger local board iterator
-inline TExMapIter AliMpRegionalTrigger::GetLocalBoardItr() const { 
-  return fLocalBoards.GetIterator(); 
-}
 
 #endif //ALI_MP_REGIONAL__CRATE_H
 
index e395e6f..38eb299 100755 (executable)
@@ -62,8 +62,7 @@ AliMpSector::AliMpSector(const TString& id, Int_t nofZones, Int_t nofRows,
 
   AliDebugStream(1) << "this = " << this << endl;
 
-  fMotifMap = new AliMpMotifMap(true);
-  //fMotifMap = new AliMpMotifMap();
+  fMotifMap = new AliMpMotifMap;
 
 #ifdef WITH_STL
   for (Int_t izone = 0; izone<nofZones; izone++) 
index eea4467..8a592ea 100644 (file)
@@ -53,6 +53,8 @@
 #include <TSystem.h>
 #include <TClass.h>
 
+#include <cassert>
+
 /// \cond CLASSIMP
 ClassImp(AliMpSegmentation)
 /// \endcond
@@ -101,14 +103,13 @@ AliMpSegmentation* AliMpSegmentation::ReadData(Bool_t warn)
 AliMpSegmentation::AliMpSegmentation()
 : TObject(),
   fDetElements(0),
-  fMpSegmentations(true),
-  fElCardsMap(true),
+  fMpSegmentations(),
+  fElCardsMap(),
   fSlatMotifMap(AliMpSlatMotifMap::Instance())
 {  
 /// Standard constructor - segmentation is loaded from ASCII data files
 
   AliDebug(1,"");
-  fElCardsMap.SetOwner(true);
   
   // Load DE data
   if ( ! AliMpDEStore::Instance(false) )  
@@ -116,29 +117,32 @@ AliMpSegmentation::AliMpSegmentation()
   fDetElements = AliMpDEStore::Instance();  
 
   // Create mapping segmentations for all detection elements
-  for ( Int_t cath = AliMp::kCath0; cath <= AliMp::kCath1; cath ++ ) { 
-    AliMpDEIterator it;
-    for ( it.First(); ! it.IsDone(); it.Next() ) {
-      CreateMpSegmentation(it.CurrentDEId(), AliMp::GetCathodType(cath));
-    } 
-  }  
-
-  // Fill el cards map for all detection elements
-  // of tracking chambers
   AliMpDEIterator it;
-  for ( it.First(); ! it.IsDone(); it.Next() ) { 
-    if ( AliMpDEManager::GetStationType(it.CurrentDEId()) != AliMp::kStationTrigger ) {
-      FillElCardsMap(it.CurrentDEId());
+  for ( it.First(); ! it.IsDone(); it.Next() ) 
+  {
+    Int_t n(0);
+    
+    for ( Int_t cath = AliMp::kCath0; cath <= AliMp::kCath1; ++cath ) 
+    { 
+      if ( CreateMpSegmentation(it.CurrentDEId(), AliMp::GetCathodType(cath)) ) ++n;
     }
-  }  
+     
+    if ( n == 2 &&  // should always be the case except when we play with the CreateMpSegmentation method...
+        AliMpDEManager::GetStationType(it.CurrentDEId()) != AliMp::kStationTrigger ) // only for tracker
+    {
+        // Fill el cards map for all detection elements
+        // of tracking chambers
+        FillElCardsMap(it.CurrentDEId());
+    }      
+  } 
 }
 
 //______________________________________________________________________________
-AliMpSegmentation::AliMpSegmentation(TRootIOCtor* /*ioCtor*/)
+AliMpSegmentation::AliMpSegmentation(TRootIOCtor* ioCtor)
 : TObject(),
   fDetElements(0),
   fMpSegmentations(),
-  fElCardsMap(),
+  fElCardsMap(ioCtor),
   fSlatMotifMap(0)
 {  
 /// Constructor for IO
@@ -214,7 +218,7 @@ AliMpSegmentation::CreateMpSegmentation(Int_t detElemId, AliMp::CathodType cath)
   else   
     AliErrorStream() << "Unknown station type" << endl;
 
-  fMpSegmentations.Add(deSegName, mpSegmentation); 
+  if ( mpSegmentation ) fMpSegmentations.Add(deSegName, mpSegmentation); 
   
 //  StdoutToAliDebug(3, fSlatMotifMap.Print(););
   
@@ -230,33 +234,27 @@ AliMpSegmentation::FillElCardsMap(Int_t detElemId)
 
   AliDebugStream(2) << "detElemId=" << detElemId << endl;;
   
-  AliMpExMap* mde = new AliMpExMap(true);
+  AliMpExMap* mde = new AliMpExMap;
   mde->SetOwner(kFALSE);
   fElCardsMap.Add(detElemId,mde);
 
   const AliMpVSegmentation* seg[2];
   TArrayI ecn[2];
   
-  // 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 = AliMp::kCath0; cathode <= AliMp::kCath1; ++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 = AliMp::kCath0; cathode <= AliMp::kCath1; ++ cathode )
-  {
     for ( Int_t i = 0; i < ecn[cathode].GetSize(); ++i )
     {
       mde->Add(ecn[cathode][i],const_cast<AliMpVSegmentation*>(seg[cathode]));
     }
   }
   
+  assert( mde->GetSize() > 0 );
+  
   return mde;
+  
 }
 
 //
index 10846dc..23f7e99 100644 (file)
@@ -18,6 +18,7 @@
 
 #include "AliMpSlat.h"
 
+#include "AliMpExMapIterator.h"
 #include "AliLog.h"
 #include "AliMpMotifPosition.h"
 #include "AliMpPCB.h"
@@ -26,6 +27,8 @@
 
 #include "TArrayI.h"
 
+#include <cassert>
+
 //-----------------------------------------------------------------------------
 /// Representation of a slat cathode (bending or non-bending).
 ///
@@ -44,7 +47,7 @@ ClassImp(AliMpSlat)
 /// \endcond
 
 //_____________________________________________________________________________
-AliMpSlat::AliMpSlat() 
+AliMpSlat::AliMpSlat(TRootIOCtor* ioCtor) 
 : TObject(), 
   fId(""), 
   fPlaneType(AliMp::kNonBendingPlane),
@@ -52,7 +55,7 @@ AliMpSlat::AliMpSlat()
   fDY(0),
   fNofPadsX(0), 
   fMaxNofPadsY(0),
-  fManuMap(),
+  fManuMap(ioCtor),
   fPCBs(),
   fPosition(),
   fNofPads(0)
@@ -76,7 +79,7 @@ AliMpSlat::AliMpSlat(const char* id, AliMp::PlaneType bendingOrNonBending)
   fDY(0),
   fNofPadsX(0), 
   fMaxNofPadsY(0),
-  fManuMap(kTRUE),
+  fManuMap(),
   fPCBs(),
   fPosition(),
   fNofPads(0)
@@ -101,7 +104,7 @@ AliMpSlat::~AliMpSlat()
 #ifdef WITH_ROOT    
   fPCBs.Delete();
 #else
-  for ( size_t i = 0; i < fPCBs.size(); ++i )
+  for ( UInt_t i = 0; i < fPCBs.size(); ++i )
   {
     delete fPCBs[i];
   }
@@ -138,7 +141,8 @@ AliMpSlat::Add(const AliMpPCB& pcbType, const TArrayI& manuList)
   fDX += pcb->DX();
   fNofPadsX += pcb->GetNofPadsX();
   fMaxNofPadsY = TMath::Max(fMaxNofPadsY,pcb->GetNofPadsY());
-  for ( AliMpPCB::Size_t i = 0; i < pcb->GetSize(); ++i )
+  Int_t n(0);
+  for ( Int_t i = 0; i < pcb->GetSize(); ++i )
        {
                AliMpMotifPosition* mp = pcb->GetMotifPosition(i);
                Int_t manuID = mp->GetID();
@@ -147,6 +151,8 @@ AliMpSlat::Add(const AliMpPCB& pcbType, const TArrayI& manuList)
     TObject* there = fManuMap.GetValue(manuID);
     if ( there == 0 )
     {
+      ++n;
+      AliDebug(1,Form("Adding %d-th manuId=%d (%d) to ManuMap (size=%d)",n,manuID,mp->GetID(),fManuMap.GetSize()));
       fManuMap.Add(manuID,(TObject*)mp);
     }
     else
@@ -257,7 +263,7 @@ AliMpSlat::FindPCB(Int_t ix) const
   ///
   /// Returns the PCB containing x-integer-position ix
   ///
-  for ( Size_t i = 0; i < GetSize(); ++i ) 
+  for ( Int_t i = 0; i < GetSize(); ++i ) 
        {
                AliMpPCB* pcb = GetPCB(i);
                if ( ix >= pcb->Ixmin() && ix <= pcb->Ixmax() )
@@ -275,7 +281,7 @@ AliMpSlat::FindPCBIndex(Int_t ix) const
   ///
   /// Returns the index of the PCB containing x-integer-position ix.
   ///
-  for ( Size_t i = 0; i < GetSize(); ++i ) 
+  for ( Int_t i = 0; i < GetSize(); ++i ) 
        {
                AliMpPCB* pcb = GetPCB(i);
                if ( ix >= pcb->Ixmin() && ix <= pcb->Ixmax() )
@@ -293,7 +299,7 @@ AliMpSlat::FindPCB(Double_t x, Double_t y) const
   ///
   /// Returns the PCB containing position (x,y)
   ///
-  for ( Size_t i = 0; i < GetSize(); ++i ) 
+  for ( Int_t i = 0; i < GetSize(); ++i ) 
        {
                AliMpPCB* pcb = GetPCB(i);
 //             if ( x >= pcb->Xmin() && x < pcb->Xmax() &&
@@ -318,7 +324,7 @@ AliMpSlat::FindPCBIndex(Double_t x, Double_t y) const
   ///
   /// Returns the index of the PCB containing position (x,y)
   ///
-  for ( Size_t i = 0; i < GetSize(); ++i ) 
+  for ( Int_t i = 0; i < GetSize(); ++i ) 
        {
                AliMpPCB* pcb = GetPCB(i);
                if ( x >= pcb->Xmin() && x < pcb->Xmax() &&
@@ -335,7 +341,7 @@ Int_t
 AliMpSlat::FindPCBIndexByMotifPositionID(Int_t manuId) const
 {
   /// Find the index of the PCB containing a given manu
-  for ( Size_t i = 0; i< GetSize(); ++i )
+  for ( Int_t i = 0; i< GetSize(); ++i )
   {
     AliMpPCB* pcb = GetPCB(i);
     if ( pcb->HasMotifPositionID(manuId) ) return i;
@@ -363,17 +369,19 @@ AliMpSlat::GetAllMotifPositionsIDs(TArrayI& ecn) const
   ///
   /// Return all the manuIds (=MotifPositionIDs) of this slat
   ///
-  ecn.Set(GetNofElectronicCards());
+  Int_t N(GetNofElectronicCards());
+  assert(N>0);
+  ecn.Set(N);
 //#ifdef WITH_ROOT
-  TExMapIter it(fManuMap.GetIterator());
-  Long_t key;
-  Long_t value;
+  TIter next(fManuMap.CreateIterator());
+  AliMpMotifPosition* mp;
   Int_t n(0);
-  while ( it.Next(key,value) == kTRUE )
+  while ( ( mp = static_cast<AliMpMotifPosition*>(next()) ) )
   {
-    ecn.AddAt((Int_t)(key),n);
+    ecn.AddAt(mp->GetID(),n);
     ++n;
   }
+  assert(n==N);
 //#else
   // missing here
 //#endif      
@@ -460,7 +468,7 @@ AliMpSlat::GetNofPadsX() const
 
 //_____________________________________________________________________________
 AliMpPCB*
-AliMpSlat::GetPCB(AliMpSlat::Size_t i) const
+AliMpSlat::GetPCB(Int_t i) const
 {
   ///
   /// Returns the i-th PCB of this slat.
@@ -469,13 +477,13 @@ AliMpSlat::GetPCB(AliMpSlat::Size_t i) const
   if ( i >= fPCBs.GetEntriesFast() ) return 0;
   return (AliMpPCB*)fPCBs[i];
 #else
-  if ( i >= fPCBs.size() ) return 0;
+  if ( i >= Int_t(fPCBs.size()) ) return 0;
   return fPCBs[i];
 #endif  
 }
 
 //_____________________________________________________________________________
-AliMpSlat::Size_t
+Int_t
 AliMpSlat::GetSize() const
 {
   ///
@@ -505,7 +513,7 @@ AliMpSlat::Print(Option_t* option) const
   
   if ( soption.Contains("P") )
        {
-    for ( Size_t i = 0; i < GetSize() ; ++i )
+    for ( Int_t i = 0; i < GetSize() ; ++i )
                {
       cout << "    ";
                        if ( option )
@@ -523,12 +531,11 @@ AliMpSlat::Print(Option_t* option) const
   {
     cout << fManuMap.GetSize() << " ";
     cout << "Electronic card (manu or local board) Ids : ";
-    
-    TExMapIter iter(fManuMap.GetIterator());
-    Long_t key, value;
-    while ( iter.Next(key,value) )
+    TIter next(fManuMap.CreateIterator());
+    AliMpMotifPosition* mp;
+    while ( ( mp = static_cast<AliMpMotifPosition*>(next())) )
     {
-      cout << key << " ";
+      cout << mp->GetID() << " ";
     }
     cout << endl;
   }
index 60ea0f3..1242b06 100644 (file)
@@ -51,15 +51,7 @@ class AliMpSlat : public TObject
 {
  public:
 
-#ifdef WITH_ROOT
-  /// Type def for the array size
-  typedef Int_t Size_t;
-#else
-  /// Type def for the array size
-  typedef UInt_t Size_t;
-#endif  
-  
-  AliMpSlat();
+  AliMpSlat(TRootIOCtor* ioCtor);
   AliMpSlat(const char* id, AliMp::PlaneType bendingOrNonBending);
   virtual ~AliMpSlat();
 
@@ -93,7 +85,7 @@ class AliMpSlat : public TObject
   Int_t FindPCBIndex(Double_t x, Double_t y) const;
 
   /// Returns the i-th PCB of this slat.
-  AliMpPCB* GetPCB(Size_t i) const;
+  AliMpPCB* GetPCB(Int_t i) const;
 
   /// Returns the MotifPosition containing location (x,y).
   AliMpMotifPosition* FindMotifPosition(Double_t x, Double_t y) const;
@@ -125,7 +117,7 @@ class AliMpSlat : public TObject
   Int_t GetNofPadsX() const;
  
   /// Returns the number of PCBs of this slat.
-  Size_t GetSize() const;
+  Int_t GetSize() const;
     
   void Print(Option_t* option="") const;
 
@@ -142,6 +134,8 @@ class AliMpSlat : public TObject
  
  private:
   /// Not implemented
+  AliMpSlat();
+  /// Not implemented
   AliMpSlat(const AliMpSlat& rhs);
   /// Not implemented
   AliMpSlat& operator=(const AliMpSlat& rhs);
index 921caf4..47b8be4 100644 (file)
@@ -119,7 +119,7 @@ AliMpSlatPadIterator::Prepare(const AliMpArea& area)
   /// Split area into smaller area intersecting pcbs,
   /// and allocate the corresponding delegate iterators.
        
-  for ( AliMpSlat::Size_t i = 0; i < fkSlat->GetSize(); ++i )
+  for ( Int_t i = 0; i < fkSlat->GetSize(); ++i )
        {
                const AliMpPCB* pcb = fkSlat->GetPCB(i);
                AliMpArea pcbArea(pcb->Area());
index b2f1bd9..8122df9 100644 (file)
@@ -108,7 +108,7 @@ AliMpSlatPainter::Draw(Option_t* option)
   switch (option[0])
     {
     case 'P':
-      for ( AliMpSlat::Size_t i = 0; i < fkSlat->GetSize(); ++i )
+      for ( Int_t i = 0; i < fkSlat->GetSize(); ++i )
        {
          AliMpPCB* pcb = fkSlat->GetPCB(i);