- Adapted comments for Doxygen
authorivana <ivana@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 19 Jun 2006 09:56:43 +0000 (09:56 +0000)
committerivana <ivana@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 19 Jun 2006 09:56:43 +0000 (09:56 +0000)
- Removed implementation of protected copy constructor &
  assignment operator
- Implementation of destructor moved in .cxx
- Cleanup Effective C++ warnings

90 files changed:
MUON/AliMUON.cxx
MUON/AliMUON1DArray.cxx
MUON/AliMUON1DArray.h
MUON/AliMUON2DMap.cxx
MUON/AliMUON2DMap.h
MUON/AliMUONCalibParam1I.cxx
MUON/AliMUONCalibParam1I.h
MUON/AliMUONCalibParam2F.cxx
MUON/AliMUONCalibParam2F.h
MUON/AliMUONCalibrationData.cxx
MUON/AliMUONCalibrationData.h
MUON/AliMUONChamber.cxx
MUON/AliMUONChamber.h
MUON/AliMUONChamberTrigger.cxx
MUON/AliMUONChamberTrigger.h
MUON/AliMUONCheck.cxx
MUON/AliMUONCheck.h
MUON/AliMUONCommonGeometryBuilder.cxx
MUON/AliMUONCommonGeometryBuilder.h
MUON/AliMUONConstants.cxx
MUON/AliMUONConstants.h
MUON/AliMUONData.cxx
MUON/AliMUONData.h
MUON/AliMUONDataDigitIterator.cxx
MUON/AliMUONDataDigitIterator.h
MUON/AliMUONDataInterface.cxx
MUON/AliMUONDataIterator.cxx
MUON/AliMUONDigit.cxx
MUON/AliMUONDigit.h
MUON/AliMUONDisplay.cxx
MUON/AliMUONDisplay.h
MUON/AliMUONGlobalTrigger.cxx
MUON/AliMUONGlobalTrigger.h
MUON/AliMUONHit.cxx
MUON/AliMUONHit.h
MUON/AliMUONLoader.cxx
MUON/AliMUONLocalTrigger.cxx
MUON/AliMUONLocalTrigger.h
MUON/AliMUONMathieson.cxx
MUON/AliMUONMathieson.h
MUON/AliMUONPoints.cxx
MUON/AliMUONPoints.h
MUON/AliMUONRawCluster.cxx
MUON/AliMUONRecoCheck.cxx
MUON/AliMUONRecoCheck.h
MUON/AliMUONSegFactory.cxx
MUON/AliMUONSegFactory.h
MUON/AliMUONSlatGeometryBuilder.cxx
MUON/AliMUONSlatGeometryBuilder.h
MUON/AliMUONSt12QuadrantSegmentation.cxx
MUON/AliMUONSt12QuadrantSegmentation.h
MUON/AliMUONSt1GeometryBuilder.cxx
MUON/AliMUONSt1GeometryBuilder.h
MUON/AliMUONSt1GeometryBuilderV2.cxx
MUON/AliMUONSt1GeometryBuilderV2.h
MUON/AliMUONSt1SpecialMotif.cxx
MUON/AliMUONSt1SpecialMotif.h
MUON/AliMUONSt2GeometryBuilder.cxx
MUON/AliMUONSt2GeometryBuilder.h
MUON/AliMUONSt2GeometryBuilderV2.cxx
MUON/AliMUONSt2GeometryBuilderV2.h
MUON/AliMUONSt345SlatSegmentation.cxx
MUON/AliMUONSt345SlatSegmentation.h
MUON/AliMUONSt345SlatSegmentationV2.cxx
MUON/AliMUONSt345SlatSegmentationV2.h
MUON/AliMUONTransientDigit.cxx
MUON/AliMUONTransientDigit.h
MUON/AliMUONTriggerCircuit.cxx
MUON/AliMUONTriggerCircuit.h
MUON/AliMUONTriggerCircuitNew.cxx
MUON/AliMUONTriggerCircuitNew.h
MUON/AliMUONTriggerConstants.cxx
MUON/AliMUONTriggerCrateStore.cxx
MUON/AliMUONTriggerCrateStore.h
MUON/AliMUONTriggerEfficiencyCells.cxx
MUON/AliMUONTriggerEfficiencyCells.h
MUON/AliMUONTriggerGeometryBuilder.cxx
MUON/AliMUONTriggerGeometryBuilder.h
MUON/AliMUONTriggerLut.cxx
MUON/AliMUONTriggerSegmentation.cxx
MUON/AliMUONTriggerSegmentation.h
MUON/AliMUONTriggerSegmentationV2.cxx
MUON/AliMUONTriggerSegmentationV2.h
MUON/AliMUONV1DStore.cxx
MUON/AliMUONV1DStore.h
MUON/AliMUONV2DStore.cxx
MUON/AliMUONV2DStore.h
MUON/AliMUONVCalibParam.cxx
MUON/AliMUONv1.cxx
MUON/AliMUONv1.h

index 22b1cfb..a5fbe28 100644 (file)
@@ -215,15 +215,6 @@ AliMUON::AliMUON(const char *name, const char *title,
 }
 
 //____________________________________________________________________
-AliMUON::AliMUON(const AliMUON& rMUON)
- : AliDetector(rMUON)
-{
-/// Protected copy constructor
-
-  AliFatal("Not implemented.");
-}
-
-//____________________________________________________________________
 AliMUON::~AliMUON()
 {
 /// Destructor
@@ -250,18 +241,6 @@ AliMUON::~AliMUON()
   delete fRawWriter;
 }
 
-//________________________________________________________________________
-AliMUON& AliMUON::operator = (const AliMUON& rhs)
-{
-/// Protected assignement operator
-
-  if (this == &rhs) return *this;
-
-  AliFatal("Not implemented.");
-    
-  return *this;  
-}
-
 //_____________________________________________________________________________
 void AliMUON::AddGeometryBuilder(AliMUONVGeometryBuilder* geomBuilder)
 {
index b852543..a5b2ee4 100644 (file)
 #include "TObjArray.h"
 
 ///
+/// \class AliMUON1DArray
 /// This class is simply a wrapper to a TObjArray, offering in addition a
 /// control over the replacement policy when you add
 /// something to it.
 ///
+/// \author Laurent Aphecetche
 
+/// \cond CLASSIMP
 ClassImp(AliMUON1DArray)
+/// \endcond
 
 //_____________________________________________________________________________
 AliMUON1DArray::AliMUON1DArray(Int_t theSize)
 : AliMUONV1DStore(),
   fArray(0x0)
 {
-  // 
-  // Default ctor
-  //
+/// Default ctor
+
   if ( theSize ) 
   {
     fArray = new TObjArray(theSize);
@@ -47,6 +50,8 @@ AliMUON1DArray::AliMUON1DArray(const AliMUON1DArray& other)
 : AliMUONV1DStore(),
   fArray(0x0)
 {
+/// Copy constructor
+
   other.CopyTo(*this);
 }
 
@@ -54,6 +59,8 @@ AliMUON1DArray::AliMUON1DArray(const AliMUON1DArray& other)
 AliMUON1DArray&
 AliMUON1DArray::operator=(const AliMUON1DArray& other)
 {
+/// Assignment operator
+
   other.CopyTo(*this);
   return *this;
 }
@@ -61,9 +68,8 @@ AliMUON1DArray::operator=(const AliMUON1DArray& other)
 //_____________________________________________________________________________
 AliMUON1DArray::~AliMUON1DArray()
 {
-  //
-  // dtor, we're the owner of our internal array.
-  //
+/// dtor, we're the owner of our internal array.
+
   delete fArray;
 }
 
@@ -71,9 +77,8 @@ AliMUON1DArray::~AliMUON1DArray()
 void
 AliMUON1DArray::CopyTo(AliMUON1DArray& dest) const
 {
-  //
-  // Make a deep copy
-  //
+/// Make a deep copy
+
   delete dest.fArray;
   dest.fArray = new TObjArray;
   dest.fArray->SetOwner(kTRUE);
@@ -87,9 +92,8 @@ AliMUON1DArray::CopyTo(AliMUON1DArray& dest) const
 TObject* 
 AliMUON1DArray::Get(Int_t i) const
 {
-  //
-  // Get the object located at index i, if it exists, and if i is correct.
-  //
+/// Get the object located at index i, if it exists, and if i is correct.
+
   if ( i >= 0 && i < fArray->GetSize() )
   {
     return fArray->At(i);
@@ -102,11 +106,10 @@ AliMUON1DArray::Get(Int_t i) const
 Bool_t 
 AliMUON1DArray::Set(Int_t i, TObject* object, Bool_t replace)
 {
-  //
-  // Set the object located at i
-  // If replace=kFALSE and there's already an object at location i,
-  // this method fails and returns kFALSE, otherwise it returns kTRUE
-  //
+/// Set the object located at i
+/// If replace=kFALSE and there's already an object at location i,
+/// this method fails and returns kFALSE, otherwise it returns kTRUE
+
   if ( i >= 0 && i < fArray->GetSize() )
   {
     TObject* o = Get(i);
index 9c4e28c..3002eb7 100644 (file)
@@ -7,7 +7,7 @@
 /// \class AliMUON1DArray
 /// \brief Implementation of AliMUONV1DStore
 /// 
-/// \author Laurent Aphecetche
+//  Author Laurent Aphecetche
 
 #ifndef ALIMUON1DARRAY_H
 #define ALIMUON1DARRAY_H
index 97af9b3..8287d75 100644 (file)
 #include "AliLog.h"
 #include "AliMpExMap.h"
 
-/// 
-/// Basic implementation of AliMUONV2DStore container using
+/// \class AliMUON2DMap
+/// \brief Basic implementation of AliMUONV2DStore container using
 /// AliMpExMap internally.
 /// What we store is a "double" map : an AliMpExMap of AliMpExMaps
 ///
+/// \author Laurent Aphecetche
 
+/// \cond CLASSIMP
 ClassImp(AliMUON2DMap)
+/// \endcond
 
 //_____________________________________________________________________________
 AliMUON2DMap::AliMUON2DMap() : AliMUONV2DStore(), fMap(new AliMpExMap(true))
 {
-  //
-  // ctor.
-  //
+/// Default constructor.
 }
 
 //_____________________________________________________________________________
@@ -41,13 +42,17 @@ AliMUON2DMap::AliMUON2DMap(const AliMUON2DMap& other)
 : AliMUONV2DStore(),
 fMap(0x0)
 {
-  other.CopyTo(*this);
+ /// Copy constructor.
+
+ other.CopyTo(*this);
 }
 
 //_____________________________________________________________________________
 AliMUON2DMap&
 AliMUON2DMap::operator=(const AliMUON2DMap& other)
 {
+/// Assignment operator
+
   other.CopyTo(*this);
   return *this;
 }
@@ -55,9 +60,9 @@ AliMUON2DMap::operator=(const AliMUON2DMap& other)
 //_____________________________________________________________________________
 AliMUON2DMap::~AliMUON2DMap()
 {
-  //
-  // dtor. we delete the map, which will delete the objects, as we're owner.
-  //
+/// Destructor. 
+/// We delete the map, which will delete the objects, as we're owner.
+
   delete fMap;
 }
 
@@ -65,9 +70,8 @@ AliMUON2DMap::~AliMUON2DMap()
 void
 AliMUON2DMap::CopyTo(AliMUON2DMap&) const
 {
-  // 
-  // Copy this into dest.
-  //
+/// Copy this into dest.
+
   AliFatal("Implement me if needed");
 }
 
@@ -75,9 +79,8 @@ AliMUON2DMap::CopyTo(AliMUON2DMap&) const
 TObject* 
 AliMUON2DMap::Get(Int_t i, Int_t j) const
 {
-  //
-  // Return the value at position (i,j).
-  //
+/// Return the value at position (i,j).
+
   TObject* o = fMap->GetValue(i);
   if ( o )
   {
@@ -92,20 +95,17 @@ AliMUON2DMap::Get(Int_t i, Int_t j) const
 void
 AliMUON2DMap::Print(Option_t*) const
 {
-  //
-  // Not implemented (yet?)
-  //
+/// Not implemented (yet?)
 }
 
 //_____________________________________________________________________________
 Bool_t 
 AliMUON2DMap::Set(Int_t i, Int_t j, TObject* object, Bool_t replace)
 {
-  //
-  // Set the object at position (i,j).
-  // If replace==kTRUE, we don't care if there's an object there already,
-  // otherwise we might refuse to set if the (i,j) location is already
-  // filled (in which case we return kFALSE).
+/// Set the object at position (i,j).
+/// If replace==kTRUE, we don't care if there's an object there already,
+/// otherwise we might refuse to set if the (i,j) location is already
+/// filled (in which case we return kFALSE).
   
   TObject* o = fMap->GetValue(i);
   if ( !o )
index db23555..b333516 100644 (file)
@@ -8,7 +8,7 @@
 /// \brief Basic implementation of AliMUONV2DStore container using
 /// AliMpExMap internally.
 ///
-/// \author Laurent Aphecetche
+//  Author Laurent Aphecetche
 
 #ifndef AliMUON2DMAP_H
 #define AliMUON2DMAP_H
@@ -25,7 +25,8 @@ public:
 
   virtual TObject* Get(Int_t i, Int_t j) const;
   virtual Bool_t Set(Int_t i, Int_t j, TObject* object, Bool_t replace);
-  virtual Bool_t IsOwner() const { return kTRUE; }
+  /// Whether or not this container is the owner of its contents.
+  virtual Bool_t IsOwner() const { return kTRUE; } 
 
   virtual void Print(Option_t* opt="") const;
 
index 9456cf5..6832e7b 100644 (file)
@@ -22,6 +22,8 @@
 #include "TMath.h"
 #include "TString.h"
 
+/// \class AliMUONCalibParam1I
+///
 /// This class is implementing the AliMUONVCalibParam interface.
 /// 
 /// It stores a given number of integers.
 /// 
 /// You might consider just as it is, namely a C++ wrapper to 
 /// a plain int[] array.
+///
+/// \author Laurent Aphecetche
 
+/// \cond CLASSIMP
 ClassImp(AliMUONCalibParam1I)
+/// \endcond
 
 //_____________________________________________________________________________
 AliMUONCalibParam1I::AliMUONCalibParam1I() 
@@ -40,9 +46,7 @@ AliMUONCalibParam1I::AliMUONCalibParam1I()
   fSize(0),
   fValues(0x0)
 {
-    //
-    // Default ctor.
-    // 
+/// Default constructor.
 }
 
 //_____________________________________________________________________________
@@ -50,11 +54,10 @@ AliMUONCalibParam1I::AliMUONCalibParam1I(Int_t theSize, Int_t fillWithValue)
 : AliMUONVCalibParam(),
   fSize(theSize)
 {
-  //
-  // Normal ctor, where theSize specifies the number of channels handled
-  // by this object, and fillWithValue the default value assigned to each
-  // channel.
-  //
+/// Normal constructor, where theSize specifies the number of channels handled
+/// by this object, and fillWithValue the default value assigned to each
+/// channel.
+
   if ( fSize > 0 )
   {
     fValues = new Int_t[fSize];
@@ -68,9 +71,8 @@ AliMUONCalibParam1I::AliMUONCalibParam1I(const AliMUONCalibParam1I& other)
 fSize(0),
 fValues(0x0)
 {
-  //
-  // Copy ctor
-  //
+/// Copy constructor
+
   other.CopyTo(*this);
 }
 
@@ -78,9 +80,8 @@ fValues(0x0)
 AliMUONCalibParam1I&
 AliMUONCalibParam1I::operator=(const AliMUONCalibParam1I& other) 
 {
-  //
-  // Assignment operator
-  //
+/// Assignment operator
+
   AliMUONVCalibParam::operator=(other);
   other.CopyTo(*this);
   return *this;
@@ -89,9 +90,8 @@ AliMUONCalibParam1I::operator=(const AliMUONCalibParam1I& other)
 //_____________________________________________________________________________
 AliMUONCalibParam1I::~AliMUONCalibParam1I()
 {
-  //
-  // dtor.
-  //
+/// Destructor.
+
   delete[] fValues;
 }
 
@@ -99,9 +99,8 @@ AliMUONCalibParam1I::~AliMUONCalibParam1I()
 void
 AliMUONCalibParam1I::CopyTo(AliMUONCalibParam1I& destination) const
 {
-  //
-  // Copy this into destination.
-  //
+/// Copy this into destination.
+
   delete[] destination.fValues;
   destination.fSize = fSize;
   if ( fSize > 0 )
@@ -118,11 +117,10 @@ AliMUONCalibParam1I::CopyTo(AliMUONCalibParam1I& destination) const
 void
 AliMUONCalibParam1I::Print(Option_t* opt) const
 {
-  //
-  // Output this object to stdout.
-  // If opt=="full", then all channels are printed, otherwise
-  // only the general characteristics are printed.
-  //
+/// Output this object to stdout.
+/// If opt=="full", then all channels are printed, otherwise
+/// only the general characteristics are printed.
+
   TString sopt(opt);
   sopt.ToUpper();
   cout << "AliMUONCalibParam1I - Size=" << Size()
@@ -141,9 +139,8 @@ AliMUONCalibParam1I::Print(Option_t* opt) const
 void
 AliMUONCalibParam1I::SetValueAsFloat(Int_t i, Int_t j, Float_t value)
 {
-  //
-  // Set the value as a float, which is casted to an int prior to storage.
-  //
+/// Set the value as a float, which is casted to an int prior to storage.
+
   SetValueAsInt(i,j,TMath::Nint(value));
 }
 
@@ -151,10 +148,9 @@ AliMUONCalibParam1I::SetValueAsFloat(Int_t i, Int_t j, Float_t value)
 void
 AliMUONCalibParam1I::SetValueAsInt(Int_t i, Int_t j, Int_t value)
 {
-  //
-  // Set the value for a given channel.
-  // (i,j) are checked for correctness before use.
-  //
+/// Set the value for a given channel.
+/// (i,j) are checked for correctness before use.
+
   if ( j != 0 || i >= fSize || i < 0 )
   {
     AliError(Form("Invalid (i,j)=(%d,%d) max allowed is (%d,%d)",
@@ -170,9 +166,8 @@ AliMUONCalibParam1I::SetValueAsInt(Int_t i, Int_t j, Int_t value)
 Float_t
 AliMUONCalibParam1I::ValueAsFloat(Int_t i, Int_t j) const
 {
-  //
-  // Return one value as a float.
-  //
+/// Return one value as a float.
+
   return 1.0*ValueAsInt(i,j);
 }
 
@@ -180,10 +175,9 @@ AliMUONCalibParam1I::ValueAsFloat(Int_t i, Int_t j) const
 Int_t
 AliMUONCalibParam1I::ValueAsInt(Int_t i, Int_t j) const
 {
-  //
-  // Return one value as an integer, after checking that (i,j)
-  // are valid indices.
-  //
+/// Return one value as an integer, after checking that (i,j)
+/// are valid indices.
+
   if ( j != 0 || i >= fSize || i < 0 )
   {
     AliError(Form("Invalid (i,j)=(%d,%d) max allowed is (%d,%d)",
index e1a9b13..0f4342f 100644 (file)
@@ -5,11 +5,10 @@
 
 /// \ingroup base
 /// \class AliMUONCalibParam1I
-/// \brief Implementation of AliMUONVCalibParam.
-/// 
-/// Handle the case of 1 integer parameter per channel.
+/// \brief Implementation of AliMUONVCalibParam,
+/// handle the case of 1 integer parameter per channel.
 ///
-/// \author Laurent Aphecetche
+// Author Laurent Aphecetche
 
 #ifndef ALIMUONCALIBPARAM1I_H
 #define ALIMUONCALIBPARAM1I_H
index 4f4f8f7..c2f081a 100644 (file)
 #include "TString.h"
 
 ///
-/// Implementation of AliMUONVCalibParam for pair of floats.
+/// \class AliMUONCalibParam2F
+/// \brief Implementation of AliMUONVCalibParam for pair of floats.
 ///
+/// Handle the case of 2 floating point parameters per channel.
 /// Conceptually, this class is the equivalent of a vector or float pairs,
 /// but it is implemented using bare Float_t[] array.
 ///
+/// \author Laurent Aphecetche
 
+/// \cond CLASSIMP
 ClassImp(AliMUONCalibParam2F)
+/// \endcond
 
 //_____________________________________________________________________________
 AliMUONCalibParam2F::AliMUONCalibParam2F() 
@@ -38,9 +43,7 @@ AliMUONCalibParam2F::AliMUONCalibParam2F()
   fN(0),
   fValues(0x0)
 {
-  //
-  // Default ctor.
-  // 
+/// Default constructor.
 }
 
 //_____________________________________________________________________________
@@ -49,11 +52,10 @@ AliMUONCalibParam2F::AliMUONCalibParam2F(Int_t theSize, Int_t fillWithValue)
   fSize(theSize),
   fN(fSize*Dimension())
 {
-  //
-  // Normal ctor, where theSize specifies the number of channels handled
-  // by this object, and fillWithValue the default value assigned to each
-  // channel.
-  //
+/// Normal constructor, where theSize specifies the number of channels handled
+/// by this object, and fillWithValue the default value assigned to each
+/// channel.
+
   if ( fN > 0 )
   {
     fValues = new Float_t[fN];
@@ -69,6 +71,8 @@ fSize(0),
 fN(0),
 fValues(0x0)
 {
+/// Copy constructor.
+
   other.CopyTo(*this);
 }
 
@@ -76,6 +80,8 @@ fValues(0x0)
 AliMUONCalibParam2F&
 AliMUONCalibParam2F::operator=(const AliMUONCalibParam2F& other) 
 {
+/// Assignment operator
+
   other.CopyTo(*this);
   return *this;
 }
@@ -83,9 +89,8 @@ AliMUONCalibParam2F::operator=(const AliMUONCalibParam2F& other)
 //_____________________________________________________________________________
 AliMUONCalibParam2F::~AliMUONCalibParam2F()
 {
-  //
-  // dtor
-  //
+/// Destructor
+
   delete[] fValues;
 }
 
@@ -93,9 +98,8 @@ AliMUONCalibParam2F::~AliMUONCalibParam2F()
 void
 AliMUONCalibParam2F::CopyTo(AliMUONCalibParam2F& destination) const
 {
-  //
-  // Copy *this to destination
-  //
+/// Copy *this to destination
+
   delete[] destination.fValues;
   destination.fN = fN;
   destination.fSize = fSize;
@@ -114,10 +118,9 @@ AliMUONCalibParam2F::CopyTo(AliMUONCalibParam2F& destination) const
 Int_t
 AliMUONCalibParam2F::Index(Int_t i, Int_t j) const
 {
-  //
-  // Compute the 1D index of the internal storage from the pair (i,j)
-  // Returns -1 if the (i,j) pair is invalid
-  //
+/// Compute the 1D index of the internal storage from the pair (i,j)
+/// Returns -1 if the (i,j) pair is invalid
+
   if ( i >= 0 && i < Size() && j >= 0 && j < Dimension() )
   {
     return i + Size()*j;
@@ -129,11 +132,10 @@ AliMUONCalibParam2F::Index(Int_t i, Int_t j) const
 void
 AliMUONCalibParam2F::Print(Option_t* opt) const
 {
-  //
-  // Output this object to stdout.
-  // If opt=="full", then all channels are printed, otherwise
-  // only the general characteristics are printed.
-  //
+/// Output this object to stdout.
+/// If opt=="full", then all channels are printed, otherwise
+/// only the general characteristics are printed.
+
   TString sopt(opt);
   sopt.ToUpper();
   cout << "AliMUONCalibParam2F - Size=" << Size()
@@ -152,9 +154,8 @@ AliMUONCalibParam2F::Print(Option_t* opt) const
 void
 AliMUONCalibParam2F::SetValueAsFloat(Int_t i, Int_t j, Float_t value)
 {
-  //
-  // Set one value as a float, after checking that the indices are correct.
-  //
+/// Set one value as a float, after checking that the indices are correct.
+
   Int_t ix = Index(i,j);
   
   if ( ix < 0 )
@@ -172,9 +173,8 @@ AliMUONCalibParam2F::SetValueAsFloat(Int_t i, Int_t j, Float_t value)
 void
 AliMUONCalibParam2F::SetValueAsInt(Int_t i, Int_t j, Int_t value)
 {
-  //
-  // Set one value as an int.
-  //
+/// Set one value as an int.
+
   SetValueAsFloat(i,j,static_cast<Float_t>(value));
 }
 
@@ -182,9 +182,8 @@ AliMUONCalibParam2F::SetValueAsInt(Int_t i, Int_t j, Int_t value)
 Float_t
 AliMUONCalibParam2F::ValueAsFloat(Int_t i, Int_t j) const
 {
-  //
-  // Return the value as a float (which it is), after checking indices.
-  //
+/// Return the value as a float (which it is), after checking indices.
+
   Int_t ix = Index(i,j);
   
   if ( ix < 0 )
@@ -203,9 +202,8 @@ AliMUONCalibParam2F::ValueAsFloat(Int_t i, Int_t j) const
 Int_t
 AliMUONCalibParam2F::ValueAsInt(Int_t i, Int_t j) const
 {
-  //
-  // Return the value as an int, by rounding the internal float value.
-  //
+/// Return the value as an int, by rounding the internal float value.
+
   Float_t v = ValueAsFloat(i,j);
   return TMath::Nint(v);
 }
index 80efdab..e608005 100644 (file)
@@ -5,12 +5,9 @@
 
 /// \ingroup base
 /// \class AliMUONCalibParam2F
-/// \brief Implementation of AliMUONVCalibParam.
+/// \brief Implementation of AliMUONVCalibParam for pair of floats
 /// 
-/// Handle the case of 2 floating point parameters per channel.
-///
-/// 
-/// \author Laurent Aphecetche
+//  Author Laurent Aphecetche
 
 #ifndef ALIMUONCALIBPARAM2F_H
 #define ALIMUONCALIBPARAM2F_H
@@ -29,14 +26,16 @@ public:
   
   virtual ~AliMUONCalibParam2F();
 
-  virtual Int_t Dimension() const { return 2; }
+  /// Return dimension (here 2)
+  virtual Int_t Dimension() const { return 2; } 
   
   virtual void Print(Option_t* opt="") const;
   
   virtual void SetValueAsFloat(Int_t i, Int_t j, Float_t value);
   virtual void SetValueAsInt(Int_t i, Int_t j, Int_t value);
   
-  virtual Int_t Size() const { return fSize; }
+  /// Return size - the number of float pair we hold
+  virtual Int_t Size() const { return fSize; } 
 
   virtual Float_t ValueAsFloat(Int_t i, Int_t j=0) const;
   virtual Int_t ValueAsInt(Int_t i, Int_t j=0) const;
index f34b42c..70c1a5c 100644 (file)
 #include "AliMUONVCalibParam.h"
 #include "Riostream.h"
 
+/// \class AliMUONCalibrationData
+///
+/// For the moment, this class stores pedestals, gains and deadchannels
+/// that are fetched from the CDB.
 ///
 /// This class is to be considered as a convenience class.
 /// Its aim is to ease retrieval of calibration data from the 
 /// It acts as a "facade" to a bunch of underlying 
 /// containers/calibration classes.
 ///
+/// \author Laurent Aphecetche
 
+/// \cond CLASSIMP
 ClassImp(AliMUONCalibrationData)
+/// \endcond
 
 //_____________________________________________________________________________
 AliMUONCalibrationData::AliMUONCalibrationData(Int_t runNumber, 
@@ -53,14 +60,14 @@ fGlobalTriggerBoardMasks(0x0),
 fTriggerLut(0x0),
 fTriggerEfficiency(0x0)
 {
-  //
-  // Default ctor.
+/// Default ctor.
+
   // If deferredInitialization is false, we read *all* calibrations
   // at once.
   // So when using this class to access only one kind of calibrations (e.g.
   // only pedestals), you should put deferredInitialization to kTRUE, which
   // will instruct this object to fetch the data only when neeeded.
-  //
+
   if ( deferredInitialization == kFALSE )
   {
     OnDemandGains();
@@ -75,26 +82,10 @@ fTriggerEfficiency(0x0)
 }
 
 //_____________________________________________________________________________
-AliMUONCalibrationData::AliMUONCalibrationData(const AliMUONCalibrationData&)
-: TObject()
-{
-  AliFatal("Implement me if needed");
-}
-
-//_____________________________________________________________________________
-AliMUONCalibrationData&
-AliMUONCalibrationData::operator=(const AliMUONCalibrationData&)
-{
-  AliFatal("Implement me if needed");
-  return *this;
-}
-
-//_____________________________________________________________________________
 AliMUONCalibrationData::~AliMUONCalibrationData()
 {
-  //
-  // dtor. Note that we're the owner of our pointers.
-  //
+/// Destructor. Note that we're the owner of our pointers.
+
   delete fPedestals;
   delete fGains;
   delete fDeadChannels;
@@ -109,11 +100,10 @@ AliMUONCalibrationData::~AliMUONCalibrationData()
 AliMUONVCalibParam*
 AliMUONCalibrationData::DeadChannels(Int_t detElemId, Int_t manuId) const
 {
-  //
-  // Return the calibration for a given (detElemId, manuId) pair
-  // Note that for DeadChannel, it's "legal" to return 0x0 (e.g. if a manu
-  // is perfect, we might simply forget it in the store).
-  //
+/// Return the calibration for a given (detElemId, manuId) pair
+/// Note that for DeadChannel, it's "legal" to return 0x0 (e.g. if a manu
+/// is perfect, we might simply forget it in the store).
+
   return
   static_cast<AliMUONVCalibParam*>(OnDemandDeadChannels()->Get(detElemId,manuId));
 }
@@ -122,9 +112,8 @@ AliMUONCalibrationData::DeadChannels(Int_t detElemId, Int_t manuId) const
 AliMUONV2DStore*
 AliMUONCalibrationData::OnDemandDeadChannels() const
 {
-  //
-  // Create (if needed) and return the internal store for DeadChannels.
-  //
+/// Create (if needed) and return the internal store for DeadChannels.
+
   if (!fDeadChannels)
   {
     AliCDBEntry* entry = GetEntry("MUON/Calib/DeadChannels");
@@ -148,10 +137,9 @@ AliMUONCalibrationData::OnDemandDeadChannels() const
 AliCDBEntry*
 AliMUONCalibrationData::GetEntry(const char* path) const
 {
-  //
-  // Access the CDB for a given path (e.g. MUON/Calib/Pedestals),
-  // and return the corresponding CDBEntry.
-  //
+/// Access the CDB for a given path (e.g. MUON/Calib/Pedestals),
+/// and return the corresponding CDBEntry.
+
   return AliCDBManager::Instance()->Get(path,fRunNumber);
 }
 
@@ -159,11 +147,10 @@ AliMUONCalibrationData::GetEntry(const char* path) const
 AliMUONVCalibParam*
 AliMUONCalibrationData::Gains(Int_t detElemId, Int_t manuId) const
 {
-  //
-  // Return the gains for a given (detElemId, manuId) pair
-  // Note that, unlike the DeadChannel case, if the result is 0x0, that's an
-  // error (meaning that we should get gains for all channels).
-  //
+/// Return the gains for a given (detElemId, manuId) pair
+/// Note that, unlike the DeadChannel case, if the result is 0x0, that's an
+/// error (meaning that we should get gains for all channels).
+
   AliMUONVCalibParam* gain = 
     static_cast<AliMUONVCalibParam*>(OnDemandGains()->Get(detElemId,manuId));
   if (!gain)
@@ -178,9 +165,8 @@ AliMUONCalibrationData::Gains(Int_t detElemId, Int_t manuId) const
 AliMUONV2DStore*
 AliMUONCalibrationData::OnDemandGains() const
 {
-  //
-  // Create (if needed) and return the internal store for gains.
-  //
+/// Create (if needed) and return the internal store for gains.
+
   if (!fGains)
   {
     AliCDBEntry* entry = GetEntry("MUON/Calib/Gains");
@@ -204,9 +190,8 @@ AliMUONCalibrationData::OnDemandGains() const
 AliMUONVCalibParam* 
 AliMUONCalibrationData::GlobalTriggerBoardMasks() const
 {
-  //
-  // Return the masks for the global trigger board.
-  //
+/// Return the masks for the global trigger board.
+
   return OnDemandGlobalTriggerBoardMasks();
 }
 
@@ -214,9 +199,8 @@ AliMUONCalibrationData::GlobalTriggerBoardMasks() const
 AliMUONVCalibParam*
 AliMUONCalibrationData::OnDemandGlobalTriggerBoardMasks() const
 {
-  //
-  // Create (if needed) and return the internal store for GlobalTriggerBoardMasks.
-  //
+/// Create (if needed) and return the internal store for GlobalTriggerBoardMasks.
+
   if (!fGlobalTriggerBoardMasks)
   {
     AliCDBEntry* entry = GetEntry("MUON/Calib/GlobalTriggerBoardMasks");
@@ -240,9 +224,8 @@ AliMUONCalibrationData::OnDemandGlobalTriggerBoardMasks() const
 AliMUONVCalibParam* 
 AliMUONCalibrationData::LocalTriggerBoardMasks(Int_t localBoardNumber) const
 {
-  //
-  // Return the masks for a given trigger local board.
-  //
+/// Return the masks for a given trigger local board.
+
   AliMUONVCalibParam* ltbm = 
   static_cast<AliMUONVCalibParam*>(OnDemandLocalTriggerBoardMasks()->Get(localBoardNumber));
   if (!ltbm)
@@ -256,9 +239,8 @@ AliMUONCalibrationData::LocalTriggerBoardMasks(Int_t localBoardNumber) const
 AliMUONV1DStore*
 AliMUONCalibrationData::OnDemandLocalTriggerBoardMasks() const
 {
-  //
-  // Create (if needed) and return the internal store for LocalTriggerBoardMasks.
-  //
+/// Create (if needed) and return the internal store for LocalTriggerBoardMasks.
+
   if (!fLocalTriggerBoardMasks)
   {
     AliCDBEntry* entry = GetEntry("MUON/Calib/LocalTriggerBoardMasks");
@@ -282,9 +264,8 @@ AliMUONCalibrationData::OnDemandLocalTriggerBoardMasks() const
 AliMUONV2DStore*
 AliMUONCalibrationData::OnDemandPedestals() const
 {
-  //
-  // Create (if needed) and return the internal storage for pedestals.
-  //
+/// Create (if needed) and return the internal storage for pedestals.
+
   if (!fPedestals)
   {
     AliCDBEntry* entry = GetEntry("MUON/Calib/Pedestals");
@@ -308,9 +289,8 @@ AliMUONCalibrationData::OnDemandPedestals() const
 void
 AliMUONCalibrationData::Print(Option_t*) const
 {
-  //
-  // A very basic dump of our guts.
-  //  
+/// A very basic dump of our guts.
+
   cout << "RunNumber " << RunNumber()
   << " fGains=" << fGains
   << " fPedestals=" << fPedestals
@@ -327,11 +307,10 @@ AliMUONCalibrationData::Print(Option_t*) const
 AliMUONVCalibParam*
 AliMUONCalibrationData::Pedestals(Int_t detElemId, Int_t manuId) const
 {
-  //
-  // Return the pedestals for a given (detElemId, manuId) pair.
-  // A return value of 0x0 is considered an error, meaning we should get
-  // pedestals for all channels.
-  //
+/// Return the pedestals for a given (detElemId, manuId) pair.
+/// A return value of 0x0 is considered an error, meaning we should get
+/// pedestals for all channels.
+
   AliMUONVCalibParam* ped = 
     static_cast<AliMUONVCalibParam*>(OnDemandPedestals()->Get(detElemId,manuId));
   if (!ped)
@@ -346,9 +325,8 @@ AliMUONCalibrationData::Pedestals(Int_t detElemId, Int_t manuId) const
 AliMUONVCalibParam* 
 AliMUONCalibrationData::RegionalTriggerBoardMasks(Int_t index) const
 {
-  //
-  // Return the masks for a given trigger regional board.
-  //
+/// Return the masks for a given trigger regional board.
+
   AliMUONVCalibParam* rtbm = 
   static_cast<AliMUONVCalibParam*>(OnDemandRegionalTriggerBoardMasks()->Get(index));
   if (!rtbm)
@@ -362,9 +340,8 @@ AliMUONCalibrationData::RegionalTriggerBoardMasks(Int_t index) const
 AliMUONV1DStore*
 AliMUONCalibrationData::OnDemandRegionalTriggerBoardMasks() const
 {
-  //
-  // Create (if needed) and return the internal store for RegionalTriggerBoardMasks.
-  //
+/// Create (if needed) and return the internal store for RegionalTriggerBoardMasks.
+
   if (!fRegionalTriggerBoardMasks)
   {
     AliCDBEntry* entry = GetEntry("MUON/Calib/RegionalTriggerBoardMasks");
@@ -388,9 +365,8 @@ AliMUONCalibrationData::OnDemandRegionalTriggerBoardMasks() const
 AliMUONTriggerEfficiencyCells*
 AliMUONCalibrationData::TriggerEfficiency() const
 {
-  //
-  // Return the trigger efficiency.
-  //
+/// Return the trigger efficiency.
+
   return OnDemandTriggerEfficiency();
 }
 
@@ -398,9 +374,8 @@ AliMUONCalibrationData::TriggerEfficiency() const
 AliMUONTriggerEfficiencyCells* 
 AliMUONCalibrationData::OnDemandTriggerEfficiency() const
 {
-  //
-  //
-  //
+/// \todo: add comment
+
   if (!fTriggerEfficiency)
   {
     AliCDBEntry* entry = GetEntry("MUON/Calib/TriggerEfficiency");
@@ -424,9 +399,8 @@ AliMUONCalibrationData::OnDemandTriggerEfficiency() const
 AliMUONTriggerLut*
 AliMUONCalibrationData::TriggerLut() const
 {
-  //
-  // Return the trigger look up table.
-  //
+/// Return the trigger look up table.
+
   return OnDemandTriggerLut();
 }
 
@@ -434,9 +408,8 @@ AliMUONCalibrationData::TriggerLut() const
 AliMUONTriggerLut* 
 AliMUONCalibrationData::OnDemandTriggerLut() const
 {
-  //
-  //
-  //
+/// \todo: add comment
+
   if (!fTriggerLut)
   {
     AliCDBEntry* entry = GetEntry("MUON/Calib/TriggerLut");
index b3c903b..9030ee0 100644 (file)
@@ -6,11 +6,8 @@
 /// \ingroup base
 /// \class AliMUONCalibrationData
 /// \brief Single entry point to access MUON calibration data.
-///
-/// For the moment, this class stores pedestals, gains and deadchannels
-/// that are fetched from the CDB.
 /// 
-/// \author Laurent Aphecetche
+//  Author Laurent Aphecetche
 
 #ifndef ALIMUONCALIBRATIONDATA_H
 #define ALIMUONCALIBRATIONDATA_H
index aadb147..c3f94d4 100644 (file)
 #include "AliMUONHit.h"
 #include "AliLog.h"
 
+/// \cond CLASSIMP
 ClassImp(AliMUONChamber)       
+/// \endcond
 
+//_______________________________________________________
 AliMUONChamber::AliMUONChamber()
   : TObject(), 
     fId(0),
@@ -69,16 +72,6 @@ AliMUONChamber::AliMUONChamber(Int_t id)
 }
 
 //_______________________________________________________
-AliMUONChamber::AliMUONChamber(const AliMUONChamber& rChamber)
-  : TObject(rChamber)
-{
-/// Protected copy constructor
-
-  AliFatal("Not implemented.");
-  // Dummy copy constructor
-}
-
-//_______________________________________________________
 AliMUONChamber::~AliMUONChamber() 
 {
 /// Destructor
@@ -86,18 +79,6 @@ AliMUONChamber::~AliMUONChamber()
   AliDebug(1, Form("dtor this = %p", this));
 }
 
-//_______________________________________________________
-AliMUONChamber & AliMUONChamber::operator =(const AliMUONChamber& rhs)
-{
-/// Protected assignement operator
-
-  if (this == &rhs) return *this;
-
-  AliFatal("Not implemented.");
-    
-  return *this;  
-}
-
 //_____________________________________________________
 void AliMUONChamber::ChargeCorrelationInit() 
 {
index 51a5e9e..5472bb4 100644 (file)
@@ -28,22 +28,20 @@ class AliMUONChamber : public TObject
     AliMUONChamber(Int_t id);
     virtual ~AliMUONChamber();
     
-//
-// Get chamber Id
+/// Get chamber Id
   virtual Int_t   GetId() const {return fId;}
-//
 
-//  
-// Set response model
+  
+/// Set response model
   virtual void    SetResponseModel(AliMUONResponse* thisResponse) {fResponse=thisResponse;}
-//  
-//  Get pointer to response model
+  
+///  Get pointer to response model
   virtual AliMUONResponse* &ResponseModel(){return fResponse;}
 
 //
 // Member function forwarding to the segmentation and response models
 //
-// Calculate pulse height from energy loss  
+/// Calculate pulse height from energy loss  
   virtual Float_t IntPH(Float_t eloss) {return fResponse->IntPH(eloss);}
 
 // Initialisation of charge fluctuation for given hit
@@ -51,21 +49,21 @@ class AliMUONChamber : public TObject
 
 // Configuration forwarding
 //
-// Define signal distribution region
-// by number of sigmas of the distribution function
+/// Define signal distribution region
+/// by number of sigmas of the distribution function
   virtual void   SetSigmaIntegration(Float_t p1)
       {fResponse->SetSigmaIntegration(p1);}
-// Set the single electron pulse-height (ADCchan/e)  
+/// Set the single electron pulse-height (ADCchan/e)  
   virtual void   SetChargeSlope(Float_t p1)              {fResponse->SetChargeSlope(p1);}
-// Set width of charge distribution function  
+/// Set width of charge distribution function  
   virtual void   SetChargeSpread(Float_t p1, Float_t p2) {fResponse->SetChargeSpread(p1,p2);}
-// Set maximum ADC count value
+/// Set maximum ADC count value
   virtual void   SetMaxAdc(Int_t p1)                   {fResponse->SetMaxAdc(p1);}
 //  
 // Cluster formation method (charge disintegration)
   virtual void   DisIntegration(AliMUONHit* hit,
                                Int_t& x, Float_t newclust[6][500]);
-//
+/// Set charge correlation
   virtual void SetChargeCorrel(Float_t correl) {fResponse->SetChargeCorrel(correl);}
 
  protected:
index 2320862..dd394f1 100644 (file)
@@ -42,17 +42,14 @@ AliMUONChamberTrigger::AliMUONChamberTrigger()
   : AliMUONChamber(),
     fkGeomTransformer(0)
 {
-// Default constructor
+/// Default constructor
 }
 
 //-------------------------------------------
 
-AliMUONChamberTrigger::AliMUONChamberTrigger(const AliMUONChamberTrigger& right) 
-  : AliMUONChamber(right) 
-{  
-/// Protected copy constructor (not implemented)
-
-  AliFatal("Copy constructor not provided.");
+AliMUONChamberTrigger:: ~AliMUONChamberTrigger()
+{
+/// Destructor
 }
 
 //-------------------------------------------
@@ -62,31 +59,16 @@ AliMUONChamberTrigger::AliMUONChamberTrigger(Int_t id,
   : AliMUONChamber(id),
     fkGeomTransformer(kGeometryTransformer)
 {
-// Constructor using chamber id
+/// Constructor using chamber id
 }
 
 //-------------------------------------------
-AliMUONChamberTrigger& 
-AliMUONChamberTrigger::operator=(const AliMUONChamberTrigger& right)
-{
-/// Protected assignement operator (not implemented)
-
-  // check assignement to self
-  if (this == &right) return *this;
-
-  AliFatal("Assignement operator not provided.");
-    
-  return *this;  
-}    
-
-//-------------------------------------------
 void AliMUONChamberTrigger::DisIntegration(AliMUONHit* hit,
                                           Int_t& nnew,
                                           Float_t newclust[6][500]) 
 {
-//    
-//  Generates pad hits (simulated cluster) 
-//  using the segmentation and the response model
+///  Generates pad hits (simulated cluster) 
+///  using the segmentation and the response model
 
 
   Float_t   tof = hit->Age();
index c9c46d3..7182063 100644 (file)
@@ -25,7 +25,7 @@ class AliMUONChamberTrigger : public AliMUONChamber
   public:
     AliMUONChamberTrigger();
     AliMUONChamberTrigger(Int_t id, const AliMUONGeometryTransformer* kGeometry);
-    virtual ~AliMUONChamberTrigger(){}
+    virtual ~AliMUONChamberTrigger();
     
     // Cluster formation method (charge disintegration)
     
index 7e106fa..81ad57a 100644 (file)
 #include "AliMUONDataIterator.h"
 #include "AliMUONDigit.h"
 
-/// A helper class to dump data from AliRoot-generated root files.
+/// \class AliMUONCheck
+/// \brief A helper class to dump data from AliRoot-generated root files.
 /// 
 /// Only implemented for digits so far, it is meant as a replacement
 /// of the MUONCheck.C macro, or to be used by this macro to simplify it.
 ///
+/// \author Laurent Aphecetche
 
+/// \cond CLASSIMP
 ClassImp(AliMUONCheck)
+/// \endcond
 
 //_____________________________________________________________________________
 AliMUONCheck::AliMUONCheck(const char* galiceFile, 
@@ -42,7 +46,7 @@ fLastEvent(lastEvent),
 fRunLoader(0x0),
 fData(0x0)
 {
-  // ctor
+/// Standard constructor
   
   fRunLoader = AliRunLoader::Open(fFileName.Data(),"MUONFolder","READ");
   if (!fRunLoader) 
@@ -64,25 +68,10 @@ fData(0x0)
 }
 
 //_____________________________________________________________________________
-AliMUONCheck::AliMUONCheck(const AliMUONCheck& rhs) : TObject(rhs)
-{
-  // copy ctor
-  AliFatal("Implement me if needed");
-}
-
-//_____________________________________________________________________________
-AliMUONCheck& 
-AliMUONCheck::operator=(const AliMUONCheck&)
-{
-  // assignement operator
-  AliFatal("Implement me if needed")
-  return *this;
-}
-
-//_____________________________________________________________________________
 AliMUONCheck::~AliMUONCheck()
 {
-  // dtor
+/// Destructor
+
   delete fData;
 }
 
@@ -90,7 +79,8 @@ AliMUONCheck::~AliMUONCheck()
 void
 AliMUONCheck::DumpDigits(Option_t* opt) const
 {
-  // Dump the digits to screen
+/// Dump the digits to screen
+
   if ( !IsValid() ) return;
   
   Int_t nevents = fRunLoader->GetNumberOfEvents();
index 4323474..04162ec 100644 (file)
 /// \class AliMUONCheck
 /// \brief A helper class to dump data from AliRoot-generated root files.
 /// 
-/// Only implemented for digits so far, it is meant as a replacement
-/// of the MUONCheck.C macro, or to be used by this macro to simplify it.
-///
-/// \author Laurent Aphecetche
+//  Author Laurent Aphecetche
 
 #ifndef ROOT_TObject
 #  include "TObject.h"
@@ -31,6 +28,7 @@ public:
   AliMUONCheck(const char* galiceFile, Int_t firstEvent=0, Int_t lastEvent=-1);
   virtual ~AliMUONCheck();
   
+  /// Return true if contains valid data
   Bool_t IsValid() const { return (fData!=0); }
   
   void DumpDigits(Option_t* opt="") const;
index 21a6728..e019872 100644 (file)
 #include "AliRun.h"
 #include "AliLog.h"
 
+/// \cond CLASSIMP
 ClassImp(AliMUONCommonGeometryBuilder)
+/// \endcond
  
 //______________________________________________________________________________//___________________________________________
 AliMUONCommonGeometryBuilder::AliMUONCommonGeometryBuilder(AliMUON* muon)
   : AliMUONVGeometryBuilder(-1),
     fMUON(muon)
 {
-/// Standars constructor
+/// Standard constructor
 }
 
 //______________________________________________________________________________//___________________________________________
@@ -53,7 +55,7 @@ AliMUONCommonGeometryBuilder::AliMUONCommonGeometryBuilder(
                                  const AliMUONCommonGeometryBuilder& right) 
   : AliMUONVGeometryBuilder(right) 
 {  
-  /// copy constructor (not implemented)
+/// Copy constructor (not implemented)
 
   AliFatal("Copy constructor not provided.");
 }
@@ -68,7 +70,7 @@ AliMUONCommonGeometryBuilder::~AliMUONCommonGeometryBuilder()
 AliMUONCommonGeometryBuilder& 
 AliMUONCommonGeometryBuilder::operator=(const AliMUONCommonGeometryBuilder& right)
 {
-  /// assignement operator (not implemented)
+/// Assignement operator (not implemented)
 
   // check assignement to self
   if (this == &right) return *this;
index 8433104..5735efd 100644 (file)
@@ -3,7 +3,7 @@
 
 // $Id$
 
-/// \ingroup base
+/// \ingroup sim
 /// \class AliMUONCommonGeometryBuilder
 /// \brief Class to build common materials
 ///
@@ -26,9 +26,9 @@ class AliMUONCommonGeometryBuilder : public AliMUONVGeometryBuilder
     virtual  ~AliMUONCommonGeometryBuilder();
 
     virtual void  CreateMaterials();
-    virtual void  CreateGeometry()      {}
-    virtual void  SetSensitiveVolumes() {}
-    virtual void  SetTransformations()  {}
+    virtual void  CreateGeometry()      {}  ///< No geometry is created
+    virtual void  SetSensitiveVolumes() {}  ///< No sensitive volumes are set
+    virtual void  SetTransformations()  {}  ///< No transformations are set
 
   protected:
     AliMUONCommonGeometryBuilder(const AliMUONCommonGeometryBuilder& right);
@@ -37,9 +37,9 @@ class AliMUONCommonGeometryBuilder : public AliMUONVGeometryBuilder
  
   private:
     // data members
-    AliMUON*  fMUON; ///< Class to build common materials 
+    AliMUON*  fMUON; ///< the MUON detector class 
 
-  ClassDef(AliMUONCommonGeometryBuilder,1)  // Common MUON geometry definitions
+  ClassDef(AliMUONCommonGeometryBuilder,1)  // Class to build common materials 
 };
 
 #endif //ALI_MUON_COMMON_GEOMETRY_BUILDER_H
index 9e7dec9..3c42a81 100644 (file)
 /// by the way).
 ///
 
+/// \cond CLASSIMP
+ClassImp(AliMUONConstants)
+/// \endcond
+
 Int_t   AliMUONConstants::fgNCh = 14;
 Int_t   AliMUONConstants::fgNTrackingCh = 10;
 Int_t   AliMUONConstants::fgNTriggerCh = 4;
@@ -75,8 +79,6 @@ Float_t  AliMUONConstants::fgDmax[7]  = {  176.6, 229.0, 308.84, 418.2,  522.0,
  
 Int_t    AliMUONConstants::fgMaxZoom = 20;
 
-ClassImp(AliMUONConstants)
-
 //______________________________________________________________________________
 Int_t AliMUONConstants::ChamberNumber(Float_t z) 
 {
index 4bf684f..4a974cd 100644 (file)
@@ -66,7 +66,9 @@ class AliMUONConstants : public TObject {
     static Float_t PitchSt1() {return fgPitchSt1;}
 
  protected:
+    /// Default constructor
     AliMUONConstants() : TObject() {}
+    /// Destructor
     virtual ~AliMUONConstants(){}
 
  private:
index e79bec4..3ef1e05 100644 (file)
@@ -38,7 +38,9 @@
 #include "TArrayI.h"
 #include "TString.h"
 
+/// \cond CLASSIMP
 ClassImp(AliMUONData)
+/// \endcond
  
 //_____________________________________________________________________________
   AliMUONData::AliMUONData():
@@ -88,21 +90,13 @@ AliMUONData::AliMUONData(AliLoader * loader, const char* name, const char* title
     fSplitLevel(0),
     fCurrentEvent(-1)
 {
-  // Constructor for AliMUONData
-}
-
-//_____________________________________________________________________________
-AliMUONData::AliMUONData(const AliMUONData& rMUONData):TNamed(rMUONData)
-{
-// Protected copy constructor
-
-  AliFatal("Not implemented.");
+/// Standard constructor
 }
 
 //_____________________________________________________________________________
 AliMUONData::~AliMUONData()
 {
-  // Destructor for AliMUONData
+/// Destructor for AliMUONData
   if (fHits) {
     fHits->Delete();
     delete fHits;
@@ -139,51 +133,34 @@ AliMUONData::~AliMUONData()
 }
 
 //_____________________________________________________________________________
-AliMUONData& AliMUONData::operator=(const AliMUONData& rhs)
-{
-// Protected assignement operator
-
-  if (this == &rhs) return *this;
-
-  AliFatal("Not implemented.");
-    
-  return *this;  
-}    
-          
-
-//_____________________________________________________________________________
 void AliMUONData::AddDigit(Int_t id, Int_t *tracks, Int_t *charges, Int_t *digits)
 {
-  //
-  // Add a MUON digit to the list of Digits of the detection plane id
-  //
+/// Add a MUON digit to the list of Digits of the detection plane id
   TClonesArray &ldigits = * Digits(id) ; 
   new(ldigits[fNdigits[id]++]) AliMUONDigit(tracks,charges,digits);
 }
 //_____________________________________________________________________________
 void AliMUONData::AddDigit(Int_t id, const AliMUONDigit& digit)
 {
-  //
-  // Add a MUON digit to the list of Digits of the detection plane id
-  //
+/// Add a MUON digit to the list of Digits of the detection plane id
+
   TClonesArray &ldigits = * Digits(id) ; 
   new(ldigits[fNdigits[id]++]) AliMUONDigit(digit);
 }
 //_____________________________________________________________________________
 void AliMUONData::AddSDigit(Int_t id, Int_t *tracks, Int_t *charges, Int_t *sdigits)
 {
-  //
-  // Add a MUON Sdigit to the list of SDigits of the detection plane id
-  //
+/// Add a MUON Sdigit to the list of SDigits of the detection plane id
+
   TClonesArray &lSdigits = * SDigits(id) ; 
   new(lSdigits[fNSdigits[id]++]) AliMUONDigit(tracks,charges,sdigits);
 }
 //_____________________________________________________________________________
 void AliMUONData::AddSDigit(Int_t id, const AliMUONDigit& Sdigit)
 {
-  //
-  // Add a MUON Sdigit to the list of SDigits of the detection plane id
-  //
+/// Add a MUON Sdigit to the list of SDigits of the detection plane id
+
   TClonesArray &lSdigits = * SDigits(id) ; 
   new(lSdigits[fNSdigits[id]++]) AliMUONDigit(Sdigit);
 }
@@ -191,7 +168,8 @@ void AliMUONData::AddSDigit(Int_t id, const AliMUONDigit& Sdigit)
 //_____________________________________________________________________________
 void AliMUONData::AddGlobalTrigger(const AliMUONGlobalTrigger& trigger )
 {
-  // add a MUON Global Trigger to the list (only one GlobalTrigger per event !);
+/// Add a MUON Global Trigger to the list (only one GlobalTrigger per event !);
+
   TClonesArray &globalTrigger = *fGlobalTrigger;
   new(globalTrigger[fNglobaltrigger++]) AliMUONGlobalTrigger(trigger);
 }
@@ -202,7 +180,8 @@ void AliMUONData::AddHit(Int_t fIshunt, Int_t track, Int_t iChamber,
                         Float_t phi, Float_t length, Float_t destep,
                         Float_t Xref,Float_t Yref,Float_t Zref)
 {
- // Add new hit to the hit list
+/// Add new hit to the hit list
+
   TClonesArray &lhits = *fHits;
   new(lhits[fNhits++]) AliMUONHit(fIshunt, track, iChamber, 
                                  idpart, X, Y, Z, 
@@ -218,6 +197,7 @@ void AliMUONData::AddHit2(Int_t fIshunt, Int_t track, Int_t detElemId,
                         Float_t Xref,Float_t Yref,Float_t Zref)
 {
  // Add new hit to the hit list
+
   TClonesArray &lhits = *fHits;
   new(lhits[fNhits++]) AliMUONHit(fIshunt, track, detElemId, 
                                  idpart, X, Y, Z, 
@@ -228,41 +208,40 @@ void AliMUONData::AddHit2(Int_t fIshunt, Int_t track, Int_t detElemId,
 //____________________________________________________________________________
 void AliMUONData::AddLocalTrigger(const  AliMUONLocalTrigger& trigger)
 {
-  // add a MUON Local Trigger to the list
+/// add a MUON Local Trigger to the list
+
   TClonesArray &localTrigger = *fLocalTrigger;
   new(localTrigger[fNlocaltrigger++]) AliMUONLocalTrigger(trigger);
 }
 //_____________________________________________________________________________
 void AliMUONData::AddRawCluster(Int_t id, const AliMUONRawCluster& c)
 {
-  //
-  // Add a MUON rawcluster to the list in the detection plane id
-  //
+/// Add a MUON rawcluster to the list in the detection plane id
+
   TClonesArray &lrawcl = *((TClonesArray*) fRawClusters->At(id));
   new(lrawcl[fNrawclusters[id]++]) AliMUONRawCluster(c);
 }
 //_____________________________________________________________________________
 void AliMUONData::AddRecTrack(const AliMUONTrack& track)
 {
-  //
-  // Add a MUON rectrack
-  //
+/// Add a MUON rectrack
+
   TClonesArray &lrectracks = *fRecTracks;
   new(lrectracks[fNrectracks++]) AliMUONTrack(track);
 }
 //_____________________________________________________________________________
 void AliMUONData::AddRecTriggerTrack(const AliMUONTriggerTrack& triggertrack)
 {
-  //
-  // Add a MUON triggerrectrack
-  //
+/// Add a MUON triggerrectrack
+
   TClonesArray &lrectriggertracks = *fRecTriggerTracks;  
   new(lrectriggertracks[fNrectriggertracks++]) AliMUONTriggerTrack(triggertrack);
 }
 //____________________________________________________________________________
 TClonesArray*  AliMUONData::Digits(Int_t DetectionPlane) const
 {
-  //Getting List of Digits
+/// Getting List of Digits
+
   if (fDigits)
     return ( (TClonesArray*) fDigits->At(DetectionPlane) );
   else
@@ -271,7 +250,8 @@ TClonesArray*  AliMUONData::Digits(Int_t DetectionPlane) const
 //____________________________________________________________________________
 TClonesArray*  AliMUONData::SDigits(Int_t DetectionPlane) const
 {
-  //Getting List of SDigits
+/// Getting List of SDigits
+
   if (fSDigits)
     return ( (TClonesArray*) fSDigits->At(DetectionPlane) );
   else
@@ -280,7 +260,8 @@ TClonesArray*  AliMUONData::SDigits(Int_t DetectionPlane) const
 //____________________________________________________________________________
 Bool_t   AliMUONData::IsRawClusterBranchesInTree()
 {
-  // Checking if there are RawCluster Branches In TreeR
+/// Checking if there are RawCluster Branches In TreeR
+
   if (TreeR()==0x0) {
     AliError("No treeR in memory");
     return kFALSE;
@@ -297,7 +278,8 @@ Bool_t   AliMUONData::IsRawClusterBranchesInTree()
 //____________________________________________________________________________
 Bool_t   AliMUONData::IsDigitsBranchesInTree()
 {
-  // Checking if there are RawCluster Branches In TreeR
+/// Checking if there are RawCluster Branches In TreeR
+
   if (TreeD()==0x0) {
     AliError("No treeD in memory");
     return kFALSE;
@@ -314,7 +296,7 @@ Bool_t   AliMUONData::IsDigitsBranchesInTree()
 //____________________________________________________________________________
 Bool_t   AliMUONData::IsTriggerBranchesInTree()
 {
-  // Checking if there are Trigger Branches In TreeR
+/// Checking if there are Trigger Branches In TreeR
  if (TreeR()==0x0) {
     AliError("No treeR in memory");
     return kFALSE;
@@ -331,7 +313,7 @@ Bool_t   AliMUONData::IsTriggerBranchesInTree()
 //____________________________________________________________________________
 Bool_t   AliMUONData::IsTriggerBranchesInTreeD()
 {
-  // Checking if there are Trigger Branches In TreeR
+/// Checking if there are Trigger Branches In TreeR
  if (TreeD()==0x0) {
     AliError("No treeD in memory");
     return kFALSE;
@@ -349,7 +331,7 @@ Bool_t   AliMUONData::IsTriggerBranchesInTreeD()
 //____________________________________________________________________________
 Bool_t   AliMUONData::IsTrackBranchesInTree()
 {
-  // Checking if there are Track Branches In TreeT
+/// Checking if there are Track Branches In TreeT
   if (TreeT()==0x0) {
     AliError("No treeT in memory");
     return kFALSE;
@@ -366,7 +348,7 @@ Bool_t   AliMUONData::IsTrackBranchesInTree()
 //____________________________________________________________________________
 Bool_t   AliMUONData::IsTriggerTrackBranchesInTree()
 {
-  // Checking if there are TriggerTrack Branches In TreeT
+/// Checking if there are TriggerTrack Branches In TreeT
   if (TreeT()==0x0) {
     AliError("No treeT in memory");
     return kFALSE;
@@ -383,7 +365,7 @@ Bool_t   AliMUONData::IsTriggerTrackBranchesInTree()
 //____________________________________________________________________________
 void AliMUONData::Fill(Option_t* option)
 {
-  // Method to fill the trees
+/// Method to fill the trees
   const char *cH   = strstr(option,"H");
   const char *cD   = strstr(option,"D");   // Digits branches in TreeD
   const char *cS   = strstr(option,"S");   // SDigits branches in TreeS
@@ -540,9 +522,8 @@ void AliMUONData::Fill(Option_t* option)
 //_____________________________________________________________________________
 void AliMUONData::MakeBranch(Option_t* option)
 {
-  //
-  // Create Tree branches for the MUON.
-  //
+/// Create Tree branches for the MUON.
+
   const Int_t kBufferSize = 4000;
   char branchname[30];
   
@@ -792,7 +773,8 @@ void AliMUONData::MakeBranch(Option_t* option)
 //____________________________________________________________________________
 TClonesArray*  AliMUONData::RawClusters(Int_t DetectionPlane)
 {
-  // Getting Raw Clusters
+/// Getting Raw Clusters
+
   if (fRawClusters) 
     return ( (TClonesArray*) fRawClusters->At(DetectionPlane) );
   else
@@ -803,6 +785,8 @@ TClonesArray*  AliMUONData::RawClusters(Int_t DetectionPlane)
 TClonesArray*  
 AliMUONData::LocalTrigger() const
 {
+/// Getting local trigger
+
   return fLocalTrigger;
 }
 
@@ -810,7 +794,8 @@ AliMUONData::LocalTrigger() const
 void
 AliMUONData::GetDigits() const 
 {
-  // Load the digits from TreeD for the current event.
+/// Load the digits from TreeD for the current event.
+
   Int_t event = fLoader->GetRunLoader()->GetEventNumber();
   if ( fCurrentEvent != event )
   {
@@ -823,16 +808,16 @@ AliMUONData::GetDigits() const
 TClonesArray*  
 AliMUONData::GlobalTrigger() const
 {
-  // Return the global trigger 
+/// Return the global trigger 
+
   return fGlobalTrigger;
 }
 
 //____________________________________________________________________________
 void AliMUONData::ResetDigits()
 {
-    //
-    // Reset number of digits and the digits array for this detector
-    //
+/// Reset number of digits and the digits array for this detector
+
     if (fDigits == 0x0) return;
     for ( int i=0;i<AliMUONConstants::NCh();i++ ) {
       if ((*fDigits)[i])    ((TClonesArray*)fDigits->At(i))->Clear("C");
@@ -842,9 +827,8 @@ void AliMUONData::ResetDigits()
 //____________________________________________________________________________
 void AliMUONData::ResetSDigits()
 {
-    //
-    // Reset number of Sdigits and the Sdigits array for this detector
-    //
+/// Reset number of Sdigits and the Sdigits array for this detector
+
     if (fSDigits == 0x0) return;
     for ( int i=0;i<AliMUONConstants::NCh();i++ ) {
       if ((*fSDigits)[i])    ((TClonesArray*)fSDigits->At(i))->Clear();
@@ -854,15 +838,16 @@ void AliMUONData::ResetSDigits()
 //______________________________________________________________________________
 void AliMUONData::ResetHits()
 {
-  // Reset number of clusters and the cluster array for this detector
+/// Reset number of clusters and the cluster array for this detector
+
   fNhits   = 0;
   if (fHits) fHits->Clear();
 }
 //_______________________________________________________________________________
 void AliMUONData::ResetRawClusters()
 {
-    // Reset number of raw clusters and the raw clust array for this detector
-    //
+/// Reset number of raw clusters and the raw clust array for this detector
+
   for ( int i=0;i<AliMUONConstants::NTrackingCh();i++ ) {
     if ((*fRawClusters)[i])    ((TClonesArray*)fRawClusters->At(i))->Clear();
     if (fNrawclusters)  fNrawclusters[i]=0;
@@ -871,7 +856,8 @@ void AliMUONData::ResetRawClusters()
 //_______________________________________________________________________________
 void AliMUONData::ResetTrigger()
 {
-  //  Reset Local and Global Trigger 
+/// Reset Local and Global Trigger 
+
   fNglobaltrigger = 0;
   if (fGlobalTrigger) fGlobalTrigger->Clear();
   fNlocaltrigger = 0;
@@ -880,21 +866,24 @@ void AliMUONData::ResetTrigger()
 //____________________________________________________________________________
 void AliMUONData::ResetRecTracks()
 {
-  // Reset tracks information
+/// Reset tracks information
+
   fNrectracks = 0;
   if (fRecTracks) fRecTracks->Delete(); // necessary to delete in case of memory allocation
 }
 //____________________________________________________________________________
 void AliMUONData::ResetRecTriggerTracks()
 {
-  // Reset tracks information
+/// Reset tracks information
+
   fNrectriggertracks = 0;
   if (fRecTriggerTracks) fRecTriggerTracks->Delete(); // necessary to delete in case of memory allocation
 }
 //_____________________________________________________________________________
 void AliMUONData::SetTreeAddress(Option_t* option)
 {
-  //Setting Addresses to the events trees
+/// Setting Addresses to the events trees
+
   const char *cH   = strstr(option,"H");
   const char *cD   = strstr(option,"D");   // Digits branches in TreeD
   const char *cS   = strstr(option,"S");   // SDigits branches in TreeS
@@ -1090,7 +1079,8 @@ void AliMUONData::SetTreeAddress(Option_t* option)
 void
 AliMUONData::Print(Option_t* opt) const
 {
-  // Dump object on screen
+/// Dump object on screen
+
   TString options(opt);
   options.ToUpper();
   
index 7e5709d..a912f04 100644 (file)
@@ -79,24 +79,36 @@ class AliMUONData : public TNamed
     virtual void   AddRecTrack(const AliMUONTrack& track);
     virtual void   AddRecTriggerTrack(const AliMUONTriggerTrack& triggertrack);
 
-    TClonesArray*  Hits() {return fHits;}
+    TClonesArray*  Hits() {return fHits;} ///< Return hits
     TClonesArray*  Digits(Int_t DetectionPlane) const;
     TClonesArray*  SDigits(Int_t DetectionPlane) const;
     TClonesArray*  LocalTrigger() const;
     TClonesArray*  GlobalTrigger() const;    
     TClonesArray*  RawClusters(Int_t DetectionPlane);
-    TClonesArray*  RecTracks() {return fRecTracks;}
+    
+                    /// Return reconstructed tracks
+    TClonesArray*  RecTracks() {return fRecTracks;} 
+                   /// Return reconstructed trigger tracks
     TClonesArray*  RecTriggerTracks() {return fRecTriggerTracks;}
 
+                    /// Load hits for \a i th entry in hits three
     void           GetTrack(Int_t it) const  {fLoader->TreeH()->GetEvent(it);}
+                   /// Get number of entries in hits three
     Int_t          GetNtracks() const      {return (Int_t) fLoader->TreeH()->GetEntries();}
     void           GetDigits() const;
+                   /// Load sdigits tree
     void           GetSDigits() const {fLoader->TreeS()->GetEvent(0);}
+                   /// Load raw clusters tree
     void           GetRawClusters() const {fLoader->TreeR()->GetEvent(0);}
+                   /// Load trigger tree
     void           GetTrigger() const {fLoader->TreeR()->GetEvent(0);}
+                   /// Load trigger D tree
     void           GetTriggerD() const {fLoader->TreeD()->GetEvent(0);}
+                   /// Return split level
     Int_t          GetSplitLevel() const {return fSplitLevel;}
+                   /// Return reconstructed tracks
     void           GetRecTracks() const {fLoader->TreeT()->GetEvent(0);}
+                   /// Return reconstructed trigger tracks
     void           GetRecTriggerTracks() const {fLoader->TreeT()->GetEvent(0);}
 
     Bool_t        IsRawClusterBranchesInTree();
@@ -106,13 +118,16 @@ class AliMUONData : public TNamed
     Bool_t        IsTrackBranchesInTree();
     Bool_t        IsTriggerTrackBranchesInTree();
 
+                       /// Get loader
     virtual AliLoader* GetLoader() const { return fLoader; }
+                       /// Set loader
     virtual void       SetLoader(AliLoader * loader) {fLoader=loader;}    
     
     virtual void   Fill(Option_t* opt=" ");
     virtual void   MakeBranch(Option_t *opt=" ");
     virtual void   SetTreeAddress(Option_t *opt=" ");
     
+                   /// Set split level
     void           SetSplitLevel(Int_t SplitLevel) {fSplitLevel=SplitLevel;}
     
     virtual void Print(Option_t* opt="") const;
@@ -125,11 +140,17 @@ class AliMUONData : public TNamed
     virtual void   ResetRecTracks();
     virtual void   ResetRecTriggerTracks();
   
+                   /// Return tree with hits
     TTree*         TreeH() {return fLoader->TreeH(); }
+                   /// Return tree with digits
     TTree*         TreeD() {return fLoader->TreeD(); }
+                   /// Return tree with summable digits
     TTree*         TreeS() {return fLoader->TreeS(); }
+                   /// Return tree with raw clusters
     TTree*         TreeR() {return fLoader->TreeR(); }
+                   /// Return tree with tracks
     TTree*         TreeT() {return fLoader->TreeT(); }
+                   /// Return tree with particles
     TTree*         TreeP() {return fLoader->TreeP(); }
 
     //    TIterator* CreateDigitIterator(AliMUONData::EChamberIteration type);
index 961330a..6014654 100644 (file)
 /// \author L. Aphecetche
 ///
 
+/// \cond CLASSIMP
+ClassImp(AliMUONDataDigitIterator)
+/// \endcond
+
 //_____________________________________________________________________________
 AliMUONDataDigitIterator::AliMUONDataDigitIterator(const AliMUONData* data,
                                                    Int_t firstChamber, 
@@ -41,9 +45,7 @@ fData(data),
 fFirstChamber(firstChamber),
 fLastChamber(lastChamber)
 {
-  // 
-  // Ctor
-  // 
+  /// Standard constructor
   Reset();
 }
 
@@ -52,13 +54,23 @@ AliMUONDataDigitIterator::AliMUONDataDigitIterator(const AliMUONDataDigitIterato
 : 
 AliMUONVDataIterator()
 {
+  /// Copy constructor
+
   rhs.CopyTo(*this);
 }
 
 //_____________________________________________________________________________
+AliMUONDataDigitIterator::~AliMUONDataDigitIterator()
+{
+  /// Destructor
+}
+
+//_____________________________________________________________________________
 AliMUONDataDigitIterator&
 AliMUONDataDigitIterator::operator=(const AliMUONDataDigitIterator& rhs)
 {
+  /// Assignment operator
+
   rhs.CopyTo(*this);
   return *this;
 }
@@ -67,7 +79,7 @@ AliMUONDataDigitIterator::operator=(const AliMUONDataDigitIterator& rhs)
 void
 AliMUONDataDigitIterator::CopyTo(AliMUONDataDigitIterator& destination) const
 {
-  // Copy *this to destination
+  /// Copy *this to destination
   destination.fData=fData;
   destination.fFirstChamber=fFirstChamber;
   destination.fLastChamber=fLastChamber;
@@ -80,7 +92,7 @@ AliMUONDataDigitIterator::CopyTo(AliMUONDataDigitIterator& destination) const
 TObject*
 AliMUONDataDigitIterator::Next()
 {
-  // Return current element and self-position to the next one.
+  /// Return current element and self-position to the next one.
   
   TObject* rv(0x0);
   
@@ -115,7 +127,7 @@ AliMUONDataDigitIterator::Next()
 Bool_t
 AliMUONDataDigitIterator::Remove()
 {
-  // Remove current element.
+  /// Remove current element.
   
   if ( fDigits ) 
   {
@@ -131,7 +143,7 @@ AliMUONDataDigitIterator::Remove()
 void
 AliMUONDataDigitIterator::Reset()
 {
-  // Resets the iterator
+  /// Reset the iterator
   fData->GetDigits();
   fCurrentDigit = 0;
   fCurrentChamber = fFirstChamber;
index 38a3c75..bf3cfb3 100644 (file)
@@ -25,7 +25,7 @@ public:
   AliMUONDataDigitIterator(const AliMUONData* data, Int_t firstChamber, Int_t lastChamber);
   AliMUONDataDigitIterator(const AliMUONDataDigitIterator& rhs);
   AliMUONDataDigitIterator& operator=(const AliMUONDataDigitIterator& rhs);
-  virtual ~AliMUONDataDigitIterator() {}
+  virtual ~AliMUONDataDigitIterator();
     
   TObject* Next();
   
index cdcbf9c..0ac2213 100644 (file)
@@ -69,47 +69,26 @@ ClassImp(AliMUONDataInterface)
 AliMUONDataInterface::AliMUONDataInterface()
        : TObject(), fData(NULL, "MUON", "MUON")
 {
-// Set all internal pointers to NULL and indices to -1.
+/// Set all internal pointers to NULL and indices to -1.
 
        Reset();
 }
 
-AliMUONDataInterface::AliMUONDataInterface(const AliMUONDataInterface& rhs)
-  : TObject(rhs)
-{
-// Protected copy constructor
-
-  AliFatal("Not implemented.");
-}
-
 AliMUONDataInterface::~AliMUONDataInterface()
 {
-// Delete the runloader if we created it.
-// If the runloader is not to be deleted then call Reset just before 
-// the destructor is called.
+/// Delete the runloader if we created it.
+/// If the runloader is not to be deleted then call Reset just before 
+/// the destructor is called.
 
        if (fRunloader != NULL && fCreatedRunLoader)
                delete fRunloader;
 }
 
-AliMUONDataInterface&  
-AliMUONDataInterface::operator=(const AliMUONDataInterface& rhs)
-{
-// Protected assignement operator
-
-  if (this == &rhs) return *this;
-
-  AliFatal("Not implemented.");
-    
-  return *this;  
-}    
-          
-
 void AliMUONDataInterface::Reset()
 {
-// Sets all internal pointers to NULL and indices to -1.
-// Note: No resources are released!
-// Specificaly AliRunLoader is not deleted.
+/// Sets all internal pointers to NULL and indices to -1.
+/// Note: No resources are released!
+/// Specificaly AliRunLoader is not deleted.
 
        fCreatedRunLoader = kFALSE;
        fRunloader = NULL;
@@ -129,8 +108,8 @@ void AliMUONDataInterface::Reset()
 
 Bool_t AliMUONDataInterface::UseCurrentRunLoader()
 {
-// Tries to fetch the current runloader with AliRunLoader::GetRunLoader. If nothing is
-// currently loaded then kFALSE is returned and AliMUONDataInterface is reset.
+/// Tries to fetch the current runloader with AliRunLoader::GetRunLoader. If nothing is
+/// currently loaded then kFALSE is returned and AliMUONDataInterface is reset.
 
        Reset();
        fRunloader = AliRunLoader::GetRunLoader();
@@ -152,7 +131,7 @@ Bool_t AliMUONDataInterface::UseCurrentRunLoader()
 
 Bool_t AliMUONDataInterface::FetchMuonLoader(TString filename, TString foldername)
 {
-  // fetches the muon loader for the given filename/foldername
+/// Fetches the muon loader for the given filename/foldername
 
        fMuonloader = fRunloader->GetLoader("MUONLoader");
        if (fMuonloader == NULL)
@@ -171,8 +150,8 @@ Bool_t AliMUONDataInterface::FetchMuonLoader(TString filename, TString foldernam
 
 Bool_t AliMUONDataInterface::LoadLoaders(TString filename, TString foldername)
 {
-// Load the run and muon loaders from the specified file and folder.
-// kTRUE is returned on success and kFALSE on failure.
+/// Load the run and muon loaders from the specified file and folder.
+/// kTRUE is returned on success and kFALSE on failure.
 
        fRunloader = AliRunLoader::Open(filename, foldername, "READ");
        if (fRunloader == NULL)
@@ -197,11 +176,11 @@ Bool_t AliMUONDataInterface::LoadLoaders(TString filename, TString foldername)
 
 Bool_t AliMUONDataInterface::FetchLoaders(TString filename, TString foldername)
 {
-// Fetch the run loader and muon loader objects from memory if they already exist,
-// or from memory if they do not. 
-// If the currently loaded run loader (if any) is not refering to the file and folder
-// we are interested in then it is deleted and reopened with the required file and
-// folder names.
+/// Fetch the run loader and muon loader objects from memory if they already exist,
+/// or from memory if they do not. 
+/// If the currently loaded run loader (if any) is not refering to the file and folder
+/// we are interested in then it is deleted and reopened with the required file and
+/// folder names.
 
        if (fRunloader == NULL)
        {
@@ -238,10 +217,10 @@ Bool_t AliMUONDataInterface::FetchLoaders(TString filename, TString foldername)
 
 Bool_t AliMUONDataInterface::FetchEvent(Int_t event)
 {
-// Fetch the specified event from the runloader and reset all the track, cathode
-// and address flags to force them to be reloaded.
-// If a negative event number is specified then the current runloader event
-// number is used.
+/// Fetch the specified event from the runloader and reset all the track, cathode
+/// and address flags to force them to be reloaded.
+/// If a negative event number is specified then the current runloader event
+/// number is used.
 
        if (fEventnumber < 0)
        {
@@ -276,7 +255,7 @@ Bool_t AliMUONDataInterface::FetchEvent(Int_t event)
 
 Bool_t AliMUONDataInterface::FetchTreeK()
 {
-// Fetch the Kine tree from the current run loader.
+/// Fetch the Kine tree from the current run loader.
 
        if (fRunloader->TreeK() == NULL)
        {
@@ -293,8 +272,8 @@ Bool_t AliMUONDataInterface::FetchTreeK()
 
 Bool_t AliMUONDataInterface::FetchTreeH()
 {
-// Fetch the Hits tree from the current muon loader.
-// Set all the required addresses etc...
+/// Fetch the Hits tree from the current muon loader.
+/// Set all the required addresses etc...
 
        if (fMuonloader->TreeH() == NULL)
        {
@@ -318,8 +297,8 @@ Bool_t AliMUONDataInterface::FetchTreeH()
 
 Bool_t AliMUONDataInterface::FetchTreeS()
 {
-// Fetch the S-Digits tree from the current muon loader.
-// Set all the required addresses etc...
+/// Fetch the S-Digits tree from the current muon loader.
+/// Set all the required addresses etc...
 
        if (fMuonloader->TreeS() == NULL)
        {
@@ -343,8 +322,8 @@ Bool_t AliMUONDataInterface::FetchTreeS()
 
 Bool_t AliMUONDataInterface::FetchTreeD()
 {
-// Fetch the digits tree from the current muon loader.
-// Set all the required addresses etc...
+/// Fetch the digits tree from the current muon loader.
+/// Set all the required addresses etc...
 
        if (fMuonloader->TreeD() == NULL)
        {
@@ -368,8 +347,8 @@ Bool_t AliMUONDataInterface::FetchTreeD()
 
 Bool_t AliMUONDataInterface::FetchTreeR()
 {
-  // Fetch the reconstructed objects tree from the current muon loader.
-  // Note: The addresses must still be set. 
+/// Fetch the reconstructed objects tree from the current muon loader.
+/// Note: The addresses must still be set. 
   
   if (fMuonloader->TreeR() == NULL)
     {
@@ -390,8 +369,8 @@ Bool_t AliMUONDataInterface::FetchTreeR()
 
 Bool_t AliMUONDataInterface::FetchTreeT()
 {
-  // fetch the reconstructed tracks tree from the current muon loader
-  // note : the addresses must still be set.
+/// fetch the reconstructed tracks tree from the current muon loader
+/// note : the addresses must still be set.
   if (fMuonloader->TreeT() == NULL)
     {
       fMuonloader->LoadTracks("READ");
@@ -410,7 +389,7 @@ Bool_t AliMUONDataInterface::FetchTreeT()
   
 Int_t AliMUONDataInterface::NumberOfEvents(TString filename, TString foldername)
 {
-// Returns the number of events in the specified file/folder, and -1 on error.
+/// Returns the number of events in the specified file/folder, and -1 on error.
 
        if ( ! FetchLoaders(filename, foldername) ) return -1;
        return fRunloader->GetNumberOfEvents();
@@ -419,7 +398,7 @@ Int_t AliMUONDataInterface::NumberOfEvents(TString filename, TString foldername)
 
 Int_t AliMUONDataInterface::NumberOfParticles(TString filename, TString foldername, Int_t event)
 {
-// Returns the number of events in the specified file/folder, and -1 on error.
+/// Returns the number of events in the specified file/folder, and -1 on error.
 
        if ( ! FetchLoaders(filename, foldername) ) return -1;
        if ( ! FetchEvent(event) ) return -1;
@@ -432,8 +411,8 @@ TParticle* AliMUONDataInterface::Particle(
                TString filename, TString foldername, Int_t event, Int_t particle
        )
 {
-// Returns the specified particle in the given file, folder and event.
-// NULL is returned on error.
+/// Returns the specified particle in the given file, folder and event.
+/// NULL is returned on error.
 
        if ( ! FetchLoaders(filename, foldername) ) return NULL;
        if ( ! FetchEvent(event) ) return NULL;
@@ -449,8 +428,8 @@ TParticle* AliMUONDataInterface::Particle(
 
 Int_t AliMUONDataInterface::NumberOfTracks(TString filename, TString foldername, Int_t event)
 {
-// Returns the number of tracks in the specified file/folder and event.
-// -1 is returned on error.
+/// Returns the number of tracks in the specified file/folder and event.
+/// -1 is returned on error.
 
        if ( ! FetchLoaders(filename, foldername) ) return -1;
        if ( ! FetchEvent(event) ) return -1;
@@ -463,8 +442,8 @@ Int_t AliMUONDataInterface::NumberOfHits(
                TString filename, TString foldername, Int_t event, Int_t track
        )
 {
-// Returns the number of hits in the specified file/folder, event and track.
-// -1 is returned on error.
+/// Returns the number of hits in the specified file/folder, event and track.
+/// -1 is returned on error.
 
        if ( ! FetchLoaders(filename, foldername) ) return -1;
        if ( ! FetchEvent(event) ) return -1;
@@ -485,8 +464,8 @@ AliMUONHit* AliMUONDataInterface::Hit(
                Int_t track, Int_t hit
        )
 {
-// Returns the specified hit in the given file, folder, event and track.
-// NULL is returned on error.
+/// Returns the specified hit in the given file, folder, event and track.
+/// NULL is returned on error.
 
        if ( ! FetchLoaders(filename, foldername) ) return NULL;
        if ( ! FetchEvent(event) ) return NULL;
@@ -507,8 +486,8 @@ Int_t AliMUONDataInterface::NumberOfSDigits(
                Int_t chamber, Int_t cathode
        )
 {
-// Returns the number of s-digits in the given file, folder, event,
-// chamber and cathode. -1 is returned on error.
+/// Returns the number of s-digits in the given file, folder, event,
+/// chamber and cathode. -1 is returned on error.
 
        Assert( 0 <= chamber && chamber <= 13 );
        Assert( 0 <= cathode && cathode <= 1 );
@@ -532,8 +511,8 @@ AliMUONDigit* AliMUONDataInterface::SDigit(
                Int_t chamber, Int_t cathode, Int_t sdigit
        )
 {
-// Returns the specified s-digit in the given file, folder, event,
-// chamber and cathode. NULL is returned on error.
+/// Returns the specified s-digit in the given file, folder, event,
+/// chamber and cathode. NULL is returned on error.
 
        Assert( 0 <= chamber && chamber <= 13 );
        Assert( 0 <= cathode && cathode <= 1 );
@@ -557,8 +536,8 @@ Int_t AliMUONDataInterface::NumberOfDigits(
                Int_t chamber, Int_t cathode
        )
 {
-// Returns the number of digits in the given file, folder, event,
-// chamber and cathode. -1 is returned on error.
+/// Returns the number of digits in the given file, folder, event,
+/// chamber and cathode. -1 is returned on error.
        Assert( 0 <= chamber && chamber <= 13 );
        Assert( 0 <= cathode && cathode <= 1 );
        
@@ -581,8 +560,8 @@ AliMUONDigit* AliMUONDataInterface::Digit(
                Int_t chamber, Int_t cathode, Int_t digit
        )
 {
-// Returns the specified digit in the given file, folder, event,
-// chamber and cathode. NULL is returned on error.
+/// Returns the specified digit in the given file, folder, event,
+/// chamber and cathode. NULL is returned on error.
 
        Assert( 0 <= chamber && chamber <= 13 );
        Assert( 0 <= cathode && cathode <= 1 );
@@ -605,8 +584,8 @@ Int_t AliMUONDataInterface::NumberOfRawClusters(
                TString filename, TString foldername, Int_t event, Int_t chamber
        )
 {
-// Returns the number of raw clusters in the specified file, folder, event and chamber.
-// -1 is returned or error.
+/// Returns the number of raw clusters in the specified file, folder, event and chamber.
+/// -1 is returned or error.
 
        Assert( 0 <= chamber && chamber <= 13 );
        if ( ! FetchLoaders(filename, foldername) ) return -1;
@@ -629,8 +608,8 @@ AliMUONRawCluster* AliMUONDataInterface::RawCluster(
                Int_t chamber, Int_t cluster
        )
 {
-// Fetch the specified raw cluster from the given file, folder, event and chamber number.
-// NULL is returned on error.
+/// Fetch the specified raw cluster from the given file, folder, event and chamber number.
+/// NULL is returned on error.
 
        Assert( 0 <= chamber && chamber <= 13 );
        if ( ! FetchLoaders(filename, foldername) ) return NULL;
@@ -650,8 +629,8 @@ AliMUONRawCluster* AliMUONDataInterface::RawCluster(
 
 Int_t AliMUONDataInterface::NumberOfLocalTriggers(TString filename, TString foldername, Int_t event)
 {
-// Return the number of local trigger objects in the specified file, folder and
-// event number. -1 is returned on error.
+/// Return the number of local trigger objects in the specified file, folder and
+/// event number. -1 is returned on error.
 
        if ( ! FetchLoaders(filename, foldername) ) return -1;
        if ( ! FetchEvent(event) ) return -1;
@@ -672,8 +651,8 @@ AliMUONLocalTrigger* AliMUONDataInterface::LocalTrigger(
                TString filename, TString foldername, Int_t event, Int_t trigger
        )
 {
-// Fetch the specified local trigger object from the given file, folder and event number.
-// NULL is returned on error.
+/// Fetch the specified local trigger object from the given file, folder and event number.
+/// NULL is returned on error.
 
        if ( ! FetchLoaders(filename, foldername) ) return NULL;
        if ( ! FetchEvent(event) ) return NULL;
@@ -691,8 +670,8 @@ AliMUONLocalTrigger* AliMUONDataInterface::LocalTrigger(
 
 Bool_t AliMUONDataInterface::SetFile(TString filename, TString foldername)
 {
-// Set the current file and folder from which to fetch data.
-// kTRUE is returned if the run and muon loaders were found, else kFALSE. 
+/// Set the current file and folder from which to fetch data.
+/// kTRUE is returned if the run and muon loaders were found, else kFALSE. 
 
        return FetchLoaders(filename, foldername);
 }
@@ -700,8 +679,8 @@ Bool_t AliMUONDataInterface::SetFile(TString filename, TString foldername)
 
 Bool_t AliMUONDataInterface::GetEvent(Int_t event)
 {
-// Select the current event from which to fetch data.
-// kTRUE is returned if the event was found, else kFALSE is returned.
+/// Select the current event from which to fetch data.
+/// kTRUE is returned if the event was found, else kFALSE is returned.
 
        if (fRunloader == NULL)
        {
@@ -715,8 +694,8 @@ Bool_t AliMUONDataInterface::GetEvent(Int_t event)
 
 Int_t AliMUONDataInterface::NumberOfEvents()
 {
-// Get the number of events in the currently selected file.
-// -1 is returned on error.
+/// Get the number of events in the currently selected file.
+/// -1 is returned on error.
 
        if (fRunloader == NULL)
        {
@@ -729,8 +708,8 @@ Int_t AliMUONDataInterface::NumberOfEvents()
 
 Int_t AliMUONDataInterface::NumberOfParticles()
 {
-// Get the number of particles in the current event.
-// -1 is returned on error.
+/// Get the number of particles in the current event.
+/// -1 is returned on error.
 
        if (fRunloader == NULL)
        {
@@ -744,8 +723,8 @@ Int_t AliMUONDataInterface::NumberOfParticles()
 
 TParticle* AliMUONDataInterface::Particle(Int_t particle)
 {
-// Fetch the specified particle from the current event.
-// NULL is returned on error.
+/// Fetch the specified particle from the current event.
+/// NULL is returned on error.
 
        if (fRunloader == NULL)
        {
@@ -768,8 +747,8 @@ TParticle* AliMUONDataInterface::Particle(Int_t particle)
 
 Int_t AliMUONDataInterface::NumberOfTracks()
 {
-// Get the number of tracks in the current event.
-// -1 is returned on error.
+/// Get the number of tracks in the current event.
+/// -1 is returned on error.
 
        if (fRunloader == NULL)
        {
@@ -788,8 +767,8 @@ Int_t AliMUONDataInterface::NumberOfTracks()
 
 Int_t AliMUONDataInterface::NumberOfHits(Int_t track)
 {
-// Get the number of hits for the given track in the current event.
-// -1 is returned on error.
+/// Get the number of hits for the given track in the current event.
+/// -1 is returned on error.
 
        if (fRunloader == NULL)
        {
@@ -814,8 +793,8 @@ Int_t AliMUONDataInterface::NumberOfHits(Int_t track)
 
 AliMUONHit* AliMUONDataInterface::Hit(Int_t track, Int_t hit)
 {
-// Fetch the specified hit from the current event.
-// NULL is returned on error.
+/// Fetch the specified hit from the current event.
+/// NULL is returned on error.
 
        if (fRunloader == NULL)
        {
@@ -840,8 +819,8 @@ AliMUONHit* AliMUONDataInterface::Hit(Int_t track, Int_t hit)
 
 Int_t AliMUONDataInterface::NumberOfSDigits(Int_t chamber, Int_t cathode)
 {
-// Get the number of s-digits on the chamber, cathode in the current event.
-// -1 is returned on error.
+/// Get the number of s-digits on the chamber, cathode in the current event.
+/// -1 is returned on error.
 
        Assert( 0 <= chamber && chamber <= 13 );
        Assert( 0 <= cathode && cathode <= 1 );
@@ -870,8 +849,8 @@ Int_t AliMUONDataInterface::NumberOfSDigits(Int_t chamber, Int_t cathode)
 
 AliMUONDigit* AliMUONDataInterface::SDigit(Int_t chamber, Int_t cathode, Int_t sdigit)
 {
-// Fetch the specified s-digits on the chamber, cathode from the current event.
-// NULL is returned on error.
+/// Fetch the specified s-digits on the chamber, cathode from the current event.
+/// NULL is returned on error.
 
        Assert( 0 <= chamber && chamber <= 13 );
        Assert( 0 <= cathode && cathode <= 1 );
@@ -900,8 +879,8 @@ AliMUONDigit* AliMUONDataInterface::SDigit(Int_t chamber, Int_t cathode, Int_t s
 
 Int_t AliMUONDataInterface::NumberOfDigits(Int_t chamber, Int_t cathode)
 {
-// Get the number of digits on the chamber, cathode in the current event.
-// -1 is returned on error.
+/// Get the number of digits on the chamber, cathode in the current event.
+/// -1 is returned on error.
 
        Assert( 0 <= chamber && chamber <= 13 );
        Assert( 0 <= cathode && cathode <= 1 );
@@ -930,8 +909,8 @@ Int_t AliMUONDataInterface::NumberOfDigits(Int_t chamber, Int_t cathode)
 
 AliMUONDigit* AliMUONDataInterface::Digit(Int_t chamber, Int_t cathode, Int_t digit)
 {
-// Fetch the specified digits on the chamber, cathode from the current event.
-// NULL is returned on error.
+/// Fetch the specified digits on the chamber, cathode from the current event.
+/// NULL is returned on error.
 
        Assert( 0 <= chamber && chamber <= 13 );
        Assert( 0 <= cathode && cathode <= 1 );
@@ -960,8 +939,8 @@ AliMUONDigit* AliMUONDataInterface::Digit(Int_t chamber, Int_t cathode, Int_t di
 
 Int_t AliMUONDataInterface::NumberOfRawClusters(Int_t chamber)
 {
-// Get the number of raw clusters on the given chamber in the current event.
-// -1 is returned on error.
+/// Get the number of raw clusters on the given chamber in the current event.
+/// -1 is returned on error.
 
        Assert( 0 <= chamber && chamber <= 13 );
 
@@ -990,8 +969,8 @@ Int_t AliMUONDataInterface::NumberOfRawClusters(Int_t chamber)
 
 AliMUONRawCluster* AliMUONDataInterface::RawCluster(Int_t chamber, Int_t cluster)
 {
-// Fetch the specified raw cluster on the given chamber from the current event.
-// NULL is returned on error.
+/// Fetch the specified raw cluster on the given chamber from the current event.
+/// NULL is returned on error.
 
        Assert( 0 <= chamber && chamber <= 13 );
 
@@ -1020,8 +999,8 @@ AliMUONRawCluster* AliMUONDataInterface::RawCluster(Int_t chamber, Int_t cluster
 
 Int_t AliMUONDataInterface::NumberOfLocalTriggers()
 {
-// Get the number of local trigger objects in the current event.
-// -1 is returned on error.
+/// Get the number of local trigger objects in the current event.
+/// -1 is returned on error.
 
        if (fRunloader == NULL)
        {
@@ -1048,8 +1027,8 @@ Int_t AliMUONDataInterface::NumberOfLocalTriggers()
 
 AliMUONLocalTrigger* AliMUONDataInterface::LocalTrigger(Int_t trigger)
 {
-// Fetch the specified local trigger object from the current event.
-// NULL is returned on error.
+/// Fetch the specified local trigger object from the current event.
+/// NULL is returned on error.
 
        if (fRunloader == NULL)
        {
@@ -1075,9 +1054,8 @@ AliMUONLocalTrigger* AliMUONDataInterface::LocalTrigger(Int_t trigger)
 
 Int_t AliMUONDataInterface::NumberOfGlobalTriggers()
 {
-  
-  // Get the number of local trigger objects in the current event.
-  // -1 is returned on error.
+/// Get the number of local trigger objects in the current event.
+/// -1 is returned on error.
   
   if (fRunloader == NULL)
     {
@@ -1103,8 +1081,8 @@ Int_t AliMUONDataInterface::NumberOfGlobalTriggers()
 
 AliMUONGlobalTrigger* AliMUONDataInterface::GlobalTrigger(Int_t trigger)
 {
-  // Fetch the specified local trigger object from the current event.
-  // NULL is returned on error.
+/// Fetch the specified local trigger object from the current event.
+/// NULL is returned on error.
   
   if (fRunloader == NULL)
     {
@@ -1130,8 +1108,8 @@ AliMUONGlobalTrigger* AliMUONDataInterface::GlobalTrigger(Int_t trigger)
 
 Int_t AliMUONDataInterface::NumberOfRecTracks()
 {
-  // Fetch the number of reconstructed tracks from the current event.
-  // NULL is returned on error.
+/// Fetch the number of reconstructed tracks from the current event.
+/// NULL is returned on error.
   
   if (fRunloader == NULL)
     {
@@ -1157,8 +1135,8 @@ Int_t AliMUONDataInterface::NumberOfRecTracks()
 
 AliMUONTrack* AliMUONDataInterface::RecTrack(Int_t rectrack)
 {
-  // Fetch the specified reconstructed track object from the current event.
-  // NULL is returned on error.
+/// Fetch the specified reconstructed track object from the current event.
+/// NULL is returned on error.
   
   if (fRunloader == NULL)
     {
index 135d261..c35b4b3 100644 (file)
 // Currently only implemented for digits, as a proof-of-principle.
 //
 
+/// \cond CLASSIMP
+ClassImp(AliMUONDataIterator)
+/// \endcond
+
 namespace
 {
   void GetChamberNumbers(AliMUONDataIterator::EIterationStyle type, 
@@ -56,8 +60,6 @@ namespace
 }
 }
 
-ClassImp(AliMUONDataIterator)
-
 //_____________________________________________________________________________
 AliMUONDataIterator::AliMUONDataIterator() 
 : 
index b6e2c53..5bb8f12 100644 (file)
@@ -20,7 +20,7 @@
 #include "Riostream.h"
 #include "TString.h"
 
-///
+/// \class AliMUONDigit
 /// A class representing a digit in the MUON spectrometer
 /// either in tracking or trigger chambers.
 ///
 /// with no electronic noise whatsoever) or digits (either real digits or
 /// simulated ones but including electronic noise and de-calibration, to 
 /// closely ressemble real ones).
-///
 
+/// \cond CLASSIMP
 ClassImp(AliMUONDigit)
+/// \endcond
 
 //_____________________________________________________________________________
 AliMUONDigit::AliMUONDigit()
@@ -54,9 +55,7 @@ fTracks(0x0),
 fPhysics(0),
 fHit(0)
 {
-  //
-  // Default constructor
-  //
+  /// Default constructor
 }
 
 //_____________________________________________________________________________
@@ -77,9 +76,8 @@ fTracks(0x0),
 fPhysics(0),
 fHit(0)
 {
-  //
-  // copy constructor
-  //
+  /// Copy constructor
+
    (static_cast<const AliMUONDigit&>(digit)).Copy(*this);
 }
 
@@ -103,10 +101,9 @@ fPhysics(0),
 fHit(0)
 
 {
-  //
-  // Creates a MUON digit object to be updated
-  // \deprecated
-  //
+  /// Creates a MUON digit object to be updated
+  /// \deprecated
+
     fPadX        = digits[0];
     fPadY        = digits[1];
     fCathode     = digits[2];
@@ -138,10 +135,9 @@ fTracks(0x0),
 fPhysics(0),
 fHit(0)
 {
-  //
-  // Creates a MUON digit object
-  //
-  // \deprecated
+  /// Creates a MUON digit object
+  /// \deprecated
+
     fPadX        = digits[0];
     fPadY        = digits[1];
     fCathode     = digits[2];
@@ -169,9 +165,8 @@ fHit(0)
 //_____________________________________________________________________________
 AliMUONDigit::~AliMUONDigit()
 {
-  //
-  // Destructor 
-  //
+  /// Destructor 
+
   delete[] fTcharges;
   delete[] fTracks;
 }
@@ -180,10 +175,8 @@ AliMUONDigit::~AliMUONDigit()
 void
 AliMUONDigit::AddTrack(Int_t trackNumber, Int_t trackCharge)
 {
-  //
-  // Add 1 track information to the track list we keep.
-  // The implementation below is dumb, you've been warned !
-  //
+  /// Add 1 track information to the track list we keep.
+  /// The implementation below is dumb, you've been warned !
   
   // First check if track is already there, in which
   // case we simply increment its charge.
@@ -223,9 +216,8 @@ AliMUONDigit::AddTrack(Int_t trackNumber, Int_t trackCharge)
 void 
 AliMUONDigit::Clear(Option_t*)
 {
-  //
-  // Reset this digit, in particular the internal arrays are deleted.
-  //
+  /// Reset this digit, in particular the internal arrays are deleted.
+
   delete[] fTracks;
   delete[] fTcharges;
   fTracks=0x0;
@@ -236,10 +228,8 @@ AliMUONDigit::Clear(Option_t*)
 //_____________________________________________________________________________
 Int_t AliMUONDigit::Compare(const TObject *obj) const
 {
-  // 
-  // The order defined below is first by DE, then Signal, then 
-  // manuId, and then manuChannel, i.e. it should be a total ordering...
-  //
+  /// The order defined below is first by DE, then Signal, then 
+  /// manuId, and then manuChannel, i.e. it should be a total ordering...
 
   const AliMUONDigit* d = static_cast<const AliMUONDigit*>(obj);
   
@@ -283,9 +273,8 @@ Int_t AliMUONDigit::Compare(const TObject *obj) const
 void 
 AliMUONDigit::Copy(TObject& obj) const
 {
-  //
-  // Copy this line to line.
-  //
+  /// Copy this line to line.
+
   TObject::Copy(obj);
   AliMUONDigit& digit = static_cast<AliMUONDigit&>(obj);
   
@@ -325,7 +314,8 @@ AliMUONDigit::Copy(TObject& obj) const
 Bool_t
 AliMUONDigit::IsNoiseOnly() const
 {
-  // Whether this (simulated only) digit is only due to noise.
+  /// Whether this (simulated only) digit is only due to noise.
+
   return (fFlags & fgkNoiseOnlyMask );
 }
 
@@ -333,7 +323,8 @@ AliMUONDigit::IsNoiseOnly() const
 Bool_t
 AliMUONDigit::IsSaturated() const
 {
-  // Whether this digit is saturated or not.
+  /// Whether this digit is saturated or not.
+
   return (fFlags & fgkSaturatedMask );
 }
 
@@ -341,9 +332,8 @@ AliMUONDigit::IsSaturated() const
 void
 AliMUONDigit::NoiseOnly(Bool_t value)
 {
-  //
-  // Set the NoiseOnly status of this digit.
-  //
+  /// Set the NoiseOnly status of this digit.
+
   if ( value )
   {
     fFlags |= fgkNoiseOnlyMask;
@@ -358,9 +348,8 @@ AliMUONDigit::NoiseOnly(Bool_t value)
 AliMUONDigit& 
 AliMUONDigit::operator=(const AliMUONDigit& digit)
 {
-  //
-  // Assignement operator.
-  //
+  /// Assignement operator.
+
   AliMUONDigit a(digit);
   a.Copy(*this);
   return *this;
@@ -370,9 +359,8 @@ AliMUONDigit::operator=(const AliMUONDigit& digit)
 void
 AliMUONDigit::PatchTracks(Int_t mask)
 {
-  //
-  // Add mask to each track number.
-  //
+  /// Add mask to each track number.
+
   for ( Int_t i = 0; i < Ntracks(); ++i )
   {
     fTracks[i] += mask;
@@ -383,10 +371,9 @@ AliMUONDigit::PatchTracks(Int_t mask)
 void
 AliMUONDigit::Print(Option_t* opt) const
 {
-  //
-  // Dump to screen.
-  // If opt=="tracks", info on tracks are printed too.
-  //
+  /// Dump to screen.
+  /// If opt=="tracks", info on tracks are printed too.
+
   cout << "<AliMUONDigit>: DetEle " << setw(5) << DetElemId()
   << " Cath " << setw(2) << Cathode()
   << " (Ix,Iy)=(" << setw(3) << PadX() << "," << setw(3) << PadY()
@@ -433,9 +420,8 @@ AliMUONDigit::Print(Option_t* opt) const
 void
 AliMUONDigit::Saturated(Bool_t value)
 {
-  //
-  // Set the saturation status of this digit.
-  //
+  /// Set the saturation status of this digit.
+
   if ( value )
   {
     fFlags |= fgkSaturatedMask;
@@ -461,9 +447,8 @@ AliMUONDigit::SetElectronics(Int_t manuId, Int_t manuChannel)
 Int_t
 AliMUONDigit::Track(Int_t i) const
 {
-  //
-  // Return the i-th track number (if i is >=0 and < Ntracks()) or -1.
-  //
+  /// Return the i-th track number (if i is >=0 and < Ntracks()) or -1.
+
   if ( i >= 0 && i < fNtracks ) 
   {
     return fTracks[i];
@@ -476,9 +461,8 @@ AliMUONDigit::Track(Int_t i) const
 Int_t
 AliMUONDigit::TrackCharge(Int_t i) const
 {
-  //
-  // Return the i-th track charge (if i is >=0 and < Ntracjs()) or -1.
-  //
+  /// Return the i-th track charge (if i is >=0 and < Ntracjs()) or -1.
+
   if ( i >= 0 && i < fNtracks ) 
   {
     return fTcharges[i];
index 21d2b29..685abe2 100644 (file)
@@ -17,36 +17,36 @@ class AliMUONDigit : public TObject
  public:
     AliMUONDigit();
     AliMUONDigit(const AliMUONDigit& rhs);
-    /// \deprecated
+    // deprecated
     AliMUONDigit(Int_t *digits);
-    /// \deprecated
+    // deprecated
     AliMUONDigit(Int_t *tracks, Int_t *charges, Int_t *digits);
     virtual ~AliMUONDigit();
 
     AliMUONDigit& operator=(const AliMUONDigit& rhs);
     
-    virtual Bool_t IsSortable() const {return kTRUE;}
+    virtual Bool_t IsSortable() const {return kTRUE;}        ///< Return true if sortable
     virtual int Compare(const TObject *obj) const;
 
-    virtual Int_t DetElemId()const     {return fDetElemId;}    
-    virtual Int_t PadX() const         {return fPadX;}
-    virtual Int_t PadY() const         {return fPadY;}
-    virtual Int_t Cathode() const      {return fCathode;}
+    virtual Int_t DetElemId()const     {return fDetElemId;}  ///< Return detection element ID  
+    virtual Int_t PadX() const         {return fPadX;}       ///< Return pad number along x
+    virtual Int_t PadY() const         {return fPadY;}       ///< Return pad number along y
+    virtual Int_t Cathode() const      {return fCathode;}    ///< Return cathode number
     
-    virtual Int_t Signal() const       {return fSignal;}
+    virtual Int_t Signal() const       {return fSignal;}     ///< Return signal amplitude
     
-    virtual Int_t Physics() const      {return fPhysics;}
+    virtual Int_t Physics() const      {return fPhysics;}    ///< Return MC physics contribution to signal
     
-    virtual Int_t Hit() const          {return fHit;}  
+    virtual Int_t Hit() const          {return fHit;}        ///< Return MC hit number
     
-    virtual Int_t Ntracks() const { return fNtracks; }
+    virtual Int_t Ntracks() const { return fNtracks; }       ///< Return MC tracks making to this digit
     virtual void AddTrack(Int_t trackNumber, Int_t trackCharge);
     virtual Int_t Track(Int_t i) const;
     virtual Int_t TrackCharge(Int_t i) const;
     
-    virtual Int_t ADC() const { return fADC; }
-    virtual Int_t ManuId() const { return fManuId; }
-    virtual Int_t ManuChannel() const { return fManuChannel; }
+    virtual Int_t ADC() const { return fADC; }                 ///< Return ADC value
+    virtual Int_t ManuId() const { return fManuId; }           ///< Return Id of the MANU chip
+    virtual Int_t ManuChannel() const { return fManuChannel; } ///< Return Channel within the MANU chip
     virtual Bool_t IsSaturated() const;
     virtual Bool_t IsNoiseOnly() const;
     
@@ -54,15 +54,15 @@ class AliMUONDigit : public TObject
     virtual void Saturated(Bool_t saturated=kTRUE);
     virtual void SetElectronics(Int_t manuId, Int_t manuChannel);
     virtual void SetADC(Int_t adc) { fADC=adc; }
-    virtual void SetDetElemId(Int_t id)    {fDetElemId = id;}
-    virtual void SetPadX(Int_t pad)        {fPadX = pad;}
-    virtual void SetPadY(Int_t pad)        {fPadY = pad;}
-    virtual void SetSignal(Int_t q)        {fSignal = q;}
-    virtual void AddSignal(Int_t q)        {fSignal += q;}
-    virtual void AddPhysicsSignal(Int_t q) {fPhysics += q;}
-    virtual void SetHit(Int_t n)           {fHit = n;}    
-    virtual void SetCathode(Int_t c)       {fCathode = c;}
-    virtual void SetPhysicsSignal(Int_t q) {fPhysics = q; }
+    virtual void SetDetElemId(Int_t id)    {fDetElemId = id;}  ///< Set detection element ID
+    virtual void SetPadX(Int_t pad)        {fPadX = pad;}      ///< Set pad number along x
+    virtual void SetPadY(Int_t pad)        {fPadY = pad;}      ///< Set pad number along y
+    virtual void SetSignal(Int_t q)        {fSignal = q;}      ///< Set signal amplitude
+    virtual void AddSignal(Int_t q)        {fSignal += q;}     ///< Add signal amplitude
+    virtual void AddPhysicsSignal(Int_t q) {fPhysics += q;}    ///< Add MC physics contribution to signal
+    virtual void SetHit(Int_t n)           {fHit = n;}         ///< Set MC hit number
+    virtual void SetCathode(Int_t c)       {fCathode = c;}     ///< Set cathode number
+    virtual void SetPhysicsSignal(Int_t q) {fPhysics = q; }    ///< Set MC physics contribution to signal
     
     virtual void Print(Option_t* opt="") const;
     
@@ -74,7 +74,7 @@ class AliMUONDigit : public TObject
       */
     virtual void Clear(Option_t*);
     
-    /// Add mask to the track numbers.
+    // Add mask to the track numbers.
     virtual void PatchTracks(Int_t mask);
     
 private:
index 60b4338..cb0d9f2 100644 (file)
 
 /* $Id$ */
 
-//////////////////////////////////////////////////////////////////////////
-//                                                                      //
-// AliDisplay                                                           //
-//                                                                      //
-// Utility class to display ALICE outline, tracks, hits,..              //
-//                                                                      //
-//////////////////////////////////////////////////////////////////////////
+/// \class AliMUONDisplay
+/// Create an event display object.
+/// A canvas named "edisplay" is created with a vertical size in pixels  \n
+///
+///    A QUICK Overview of the Event Display functions                   \n
+///    ===============================================                   \n
+///
+/// The event display can ve invoked by executing the macro "display.C"  \n
+/// A canvas like in the picture below will appear.
+///
+///  On the left side of the canvas, the following buttons appear:
+///  - *Next*       to move to the next event
+///  - *Previous*   to move to the previous event
+///  - *Pick*       Select this option to be able to point on a track with the
+///                 mouse. Once on the track, use the right button to select
+///                 an action. For example, select SetMarkerAttributes to
+///                 change the marker type/color/size for the track.
+///  - *Zoom*       Select this option (default) if you want to zoom.
+///                 To zoom, simply select the selected area with the left button.
+///  - *UnZoom*     To revert to the previous picture size.
+///
+///  - slider R     On the left side, the vertical slider can be used to
+///                 set the default picture size.
+///
+///  When you are in Zoom mode, you can click on the black part of the canvas
+///  to select special options with the right mouse button.
+///
+/// When you are in pick mode, you can "Inspect" the object pointed by the mouse.
+/// When you are on a track, select the menu item "InspectParticle"
+/// to display the current particle attributes.
+///
+/// You can activate the Root browser by selecting the Inspect menu
+/// in the canvas tool bar menu. Then select "Start Browser"
+/// This will open a new canvas with the browser. At this point, you may want
+/// to display some histograms (from the Trees). Go to the "File" menu
+/// of the browser and click on "New canvas".
+/// In the browser, click on item "ROOT files" in the left pane.
+/// Click on galice.root.
+/// Click on TH
+/// Click on TPC for example
+/// Click on any variable (eg TPC.fX) to histogram the variable.
+///
+/// If you are lost, you can click on HELP in any Root canvas or browser.
+
+//Begin_Html
+/*
+<img src="gif/AliMUONDisplay.gif">
+*/
+//End_Html
 
 #include "AliMUONDisplay.h"
 #include "AliMUON.h"
 #include <TPolyLine3D.h>
 #include <TBox.h>
 
-
-
+/// \cond CLASSIMP
 ClassImp(AliMUONDisplay)
-
+/// \endcond
 
 //_____________________________________________________________________________
 AliMUONDisplay::AliMUONDisplay()
-  : AliDisplay()
+  : AliDisplay(),
+    fEvent(0),
+    fChamber(0),
+    fCathode(0),
+    fDrawClusters(kTRUE),
+    fDrawCoG(kTRUE),
+    fDrawTracks(kFALSE),
+    fClustersCuts(0),
+    fColPad(0),
+    fPoints(0),
+    fPhits(0),
+    fRpoints(0),
+    fNextCathode(0),
+    fLoader(0), 
+    fMUONData(0)
 {
-// Constructor
-    fPoints = 0;
-    fPhits = 0;
-    fRpoints = 0;
-    fCanvas = 0;
-    fNextCathode = kFALSE; 
-    fColPad = 0;
+/// Default constructor
 }
 
 //_____________________________________________________________________________
 AliMUONDisplay::AliMUONDisplay(Int_t size, AliLoader * loader)
-  : AliDisplay()
+  : AliDisplay(),
+    fEvent(0),
+    fChamber(1),
+    fCathode(1),
+    fDrawClusters(kTRUE),
+    fDrawCoG(kTRUE),
+    fDrawTracks(kFALSE),
+    fClustersCuts(0),
+    fColPad(0),
+    fPoints(0),
+    fPhits(0),
+    fRpoints(0),
+    fNextCathode(kFALSE),
+    fLoader(loader), 
+    fMUONData(0)
+  
 {
-// Create an event display object.
-// A canvas named "edisplay" is created with a vertical size in pixels
-//
-//    A QUICK Overview of the Event Display functions
-//    ===============================================
-//
-//  The event display can ve invoked by executing the macro "display.C"
-// A canvas like in the picture below will appear.
-//
-//  On the left side of the canvas, the following buttons appear:
-//   *Next*       to move to the next event
-//   *Previous*   to move to the previous event
-
-//   *Pick*       Select this option to be able to point on a track with the
-//                mouse. Once on the track, use the right button to select
-//                an action. For example, select SetMarkerAttributes to
-//                change the marker type/color/size for the track.
-//   *Zoom*       Select this option (default) if you want to zoom.
-//                To zoom, simply select the selected area with the left button.
-//   *UnZoom*     To revert to the previous picture size.
-//
-//   slider R     On the left side, the vertical slider can be used to
-//                set the default picture size.
-//
-//    When you are in Zoom mode, you can click on the black part of the canvas
-//  to select special options with the right mouse button.
-
-//
-//  When you are in pick mode, you can "Inspect" the object pointed by the mouse.
-//  When you are on a track, select the menu item "InspectParticle"
-//  to display the current particle attributes.
-//
-//  You can activate the Root browser by selecting the Inspect menu
-//  in the canvas tool bar menu. Then select "Start Browser"
-//  This will open a new canvas with the browser. At this point, you may want
-//  to display some histograms (from the Trees). Go to the "File" menu
-//  of the browser and click on "New canvas".
-//  In the browser, click on item "ROOT files" in the left pane.
-//  Click on galice.root.
-//  Click on TH
-//  Click on TPC for example
-//  Click on any variable (eg TPC.fX) to histogram the variable.
-//
-//   If you are lost, you can click on HELP in any Root canvas or browser.
-//Begin_Html
-/*
-<img src="gif/AliMUONDisplay.gif">
-*/
-//End_Html
-
+/// Standard constructor to create an event display object.
 
     fPad = 0;
     
@@ -152,22 +167,14 @@ AliMUONDisplay::AliMUONDisplay(Int_t size, AliLoader * loader)
    
    // Initialize display default parameters
     SetRange(200,2000);
+
    // Set front view by default
     fTheta =   0;
     fPhi   = -90;
     fPsi   =   0;
-    fChamber = 1;
-    fCathode = 1;
-    //   fRzone   = 1.e10;
-    fDrawClusters  = kTRUE;
-    fDrawCoG       = kTRUE;
-    fDrawTracks    = kFALSE;
     fZoomMode      = 1;
     fZooms         = 0;
-    fClustersCuts  = 0;
-    fPoints        = 0;
-    fPhits         = 0;
-    fRpoints       = 0;
+
     // Create colors
     CreateColors();
     // Create display canvas
@@ -231,8 +238,7 @@ AliMUONDisplay::AliMUONDisplay(Int_t size, AliLoader * loader)
     fTrigPad->SetEditable(kFALSE);
     fButtons->SetEditable(kFALSE);
     fCanvas->Update();
-    fNextCathode = kFALSE; 
-    fLoader = loader;
     // initialize container
     if(fLoader) 
       fMUONData = new AliMUONData(fLoader,"MUON","MUON");
@@ -240,19 +246,11 @@ AliMUONDisplay::AliMUONDisplay(Int_t size, AliLoader * loader)
       fMUONData =0x0;
 }
 
-AliMUONDisplay::AliMUONDisplay(const AliMUONDisplay & display)
-  : AliDisplay(display)
-{
-// Protected copy constructor
-
-  AliFatal("Not implemented.");
-}
-
-
-
 //_____________________________________________________________________________
 AliMUONDisplay::~AliMUONDisplay()
 {
+/// Destructor
+
   // Delete space point structure
     if (fPoints) fPoints->Delete();
     delete fPoints;
@@ -270,13 +268,13 @@ AliMUONDisplay::~AliMUONDisplay()
 //_____________________________________________________________________________
 void AliMUONDisplay::Clear(Option_t *)
 {
-//    Delete graphics temporary objects
+/// Delete graphics temporary objects
 }
 
 //_____________________________________________________________________________
 void AliMUONDisplay::DisplayButtons()
 {
-//    Create the user interface buttons
+/// Create the user interface buttons
 
 
     fButtons = new TPad("buttons", "newpad",0,0.45,0.15,1);
@@ -357,7 +355,7 @@ void AliMUONDisplay::DisplayButtons()
 //_____________________________________________________________________________
 void AliMUONDisplay::CreateColors() const
 {
-//    Create the colors palette used to display clusters
+/// Create the colors palette used to display clusters
 
     Int_t k,i;
     Int_t color;
@@ -422,7 +420,8 @@ void AliMUONDisplay::CreateColors() const
 //_____________________________________________________________________________
 void AliMUONDisplay::DisplayColorScale()
 {
-// Display pulse height color scale
+/// Display pulse height color scale
+
     Int_t i;
     Int_t color;
     Float_t xlow, ylow, xup, yup, hs;
@@ -463,7 +462,7 @@ void AliMUONDisplay::DisplayColorScale()
 //______________________________________________________________________________
 Int_t AliMUONDisplay::DistancetoPrimitive(Int_t px, Int_t)
 {
-// Compute distance from point px,py to objects in event
+/// Compute distance from point px,py to objects in event
 
     gPad->SetCursor(kCross);
     
@@ -484,7 +483,7 @@ Int_t AliMUONDisplay::DistancetoPrimitive(Int_t px, Int_t)
 //_____________________________________________________________________________
 void AliMUONDisplay::Draw(Option_t *)
 {
-//    Display current event
+/// Display current event
 
     if (!fDrawTracks) 
       DrawChamber();   
@@ -495,6 +494,7 @@ void AliMUONDisplay::Draw(Option_t *)
 //_____________________________________________________________________________
 void AliMUONDisplay::DrawChamber()
 {
+/// Display current event
 
   fDrawTracks = kFALSE;
   fPad->cd();
@@ -507,7 +507,7 @@ void AliMUONDisplay::DrawChamber()
 //_____________________________________________________________________________
 void AliMUONDisplay::DrawReco(Option_t *)
 {
-//    Display current event
+/// Display current event
 
   fDrawTracks = kTRUE;
   // print kinematics of generated particles
@@ -524,6 +524,8 @@ void AliMUONDisplay::DrawReco(Option_t *)
 //_____________________________________________________________________________
 void AliMUONDisplay::PrintKinematics()
 {
+/// Print kinematic tree
+
   AliRunLoader * runLoader;
   TParticle *particle = new TParticle();
   Int_t nPart;
@@ -555,11 +557,12 @@ void AliMUONDisplay::PrintKinematics()
   delete particle;    
 }
 
+//_____________________________________________________________________________
 void AliMUONDisplay::DrawSegmentation()
 {
-  // to be re-written for new seg
-// Draw graphical representation of segmenatation
-// Attention: still experimental code
+/// \todo to be re-written for new seg
+/// Draw graphical representation of segmenatation
+/// Attention: still experimental code
 //     Int_t icat=1;
     
 //     AliMUON *pMUON  = (AliMUON*)gAlice->GetModule("MUON");
@@ -621,7 +624,7 @@ void AliMUONDisplay::DrawSegmentation()
 //_____________________________________________________________________________
 void AliMUONDisplay::DrawClusters()
 {
-//    Draw clusters for MUON chambers
+/// Draw clusters for MUON chambers
 
     Int_t ndigits, digit;
     TObjArray *points;
@@ -650,7 +653,7 @@ void AliMUONDisplay::DrawClusters()
 //_____________________________________________________________________________
 void AliMUONDisplay::DrawHits()
 {
-//    Draw hits for MUON chambers
+/// Draw hits for MUON chambers
 
     LoadHits(fChamber);
 
@@ -674,7 +677,8 @@ void AliMUONDisplay::DrawHits()
 //_____________________________________________________________________________
 void AliMUONDisplay::DrawCoG()
 {
-//    Draw hits for MUON chambers
+/// Draw hits for MUON chambers
+
     if (!fDrawCoG) return;
     if (fChamber > 10) return;
     LoadCoG(fChamber,fCathode);
@@ -695,7 +699,8 @@ void AliMUONDisplay::DrawCoG()
 //_____________________________________________________________________________
 void AliMUONDisplay::DrawTracks()
 {
-//    Draw tracks
+/// Draw tracks
+
     if (!fDrawTracks) return;
     LoadTracks();
     
@@ -716,7 +721,7 @@ void AliMUONDisplay::DrawTracks()
 
 void AliMUONDisplay::DrawTitle(Option_t *option)
 {
-//    Draw the event title
+/// Draw the event title
 
     Float_t xmin = gPad->GetX1();
     Float_t xmax = gPad->GetX2();
@@ -761,7 +766,8 @@ void AliMUONDisplay::DrawTitle(Option_t *option)
 //_____________________________________________________________________________
 void AliMUONDisplay::DrawView(Float_t theta, Float_t phi, Float_t psi)
 {
-  //    Draw a view of MUON clusters
+/// Draw a view of MUON clusters
+
   AliInfo(" Draw View");
   
   gPad->SetCursor(kWatch);
@@ -921,7 +927,7 @@ void AliMUONDisplay::DrawView(Float_t theta, Float_t phi, Float_t psi)
 //_____________________________________________________________________________
 void AliMUONDisplay::DrawGlobalView(Float_t theta, Float_t phi, Float_t psi)
 {
-//    Draw a view of muons chambers with tracks
+/// Draw a view of muons chambers with tracks
     
     gPad->SetCursor(kWatch);
     // gPad->SetFillColor(39);
@@ -971,7 +977,7 @@ void AliMUONDisplay::DrawGlobalView(Float_t theta, Float_t phi, Float_t psi)
 //______________________________________________________________________________
 void AliMUONDisplay::ExecuteEvent(Int_t event, Int_t px, Int_t py)
 {
-//  Execute action corresponding to the mouse event
+/// Execute action corresponding to the mouse event
 
     static Float_t x0, y0, x1, y1;
     
@@ -1039,8 +1045,8 @@ void AliMUONDisplay::ExecuteEvent(Int_t event, Int_t px, Int_t py)
 //___________________________________________
 void AliMUONDisplay::LoadDigits(Int_t chamber, Int_t cathode)
 {
-// Read digits info and store x,y,z info in arrays fPoints
-// Loop on all detectors
+/// Read digits info and store x,y,z info in arrays fPoints.
+/// Loop on all detectors
 
     if (chamber > 14) return;
     fChamber = chamber;
@@ -1242,8 +1248,8 @@ void AliMUONDisplay::LoadDigits(Int_t chamber, Int_t cathode)
 //___________________________________________
 void AliMUONDisplay::LoadCoG(Int_t chamber, Int_t /*cathode*/)
 {
-// Read raw clusters info and store x,y,z info in arrays fRpoints
-// Loop on all detectors
+/// Read raw clusters info and store x,y,z info in arrays fRpoints.
+/// Loop on all detectors
 
     if (chamber > 10) return;
     
@@ -1288,7 +1294,8 @@ void AliMUONDisplay::LoadCoG(Int_t chamber, Int_t /*cathode*/)
 //___________________________________________
 void AliMUONDisplay::LoadTracks()
 {
-// Load tracks
+/// Load tracks
+
   AliMUONTrack* recTrack = 0;
   AliMUONTrackParam* trackParam = 0;
   TClonesArray *  trackParamAtHit = 0;   
@@ -1347,8 +1354,11 @@ void AliMUONDisplay::LoadTracks()
 
 }
 
+//___________________________________________
 void AliMUONDisplay::PrintTrack(Int_t iRecTracks, AliMUONTrack *recTrack)
 {
+/// Print reconstructed track
+
   AliMUONTrackParam *trackParam;
   Float_t vertex[3], momentum[3];
   Float_t pYZ, bendingSlope, nonBendingSlope, chi2dof;
@@ -1379,8 +1389,8 @@ void AliMUONDisplay::PrintTrack(Int_t iRecTracks, AliMUONTrack *recTrack)
 //___________________________________________
 void AliMUONDisplay::LoadHits(Int_t chamber)
 {
-  // Read hits info and store x,y,z info in arrays fPhits
-  // Loop on all detectors
+/// Read hits info and store x,y,z info in arrays fPhits.
+/// Loop on all detectors
 
     if (chamber > 14) return;
     Int_t track;
@@ -1441,14 +1451,14 @@ void AliMUONDisplay::LoadHits(Int_t chamber)
 //_____________________________________________________________________________
 void AliMUONDisplay::Paint(Option_t *)
 {
-//    Paint miscellaneous items
+/// Paint miscellaneous items
 }
 
 //_____________________________________________________________________________
 void AliMUONDisplay::SetPickMode()
 {
-// Set parameters for pick mode.
-// 
+/// Set parameters for pick mode.
     fZoomMode = 0;
 
     fArcButton->SetY1(fPickButton->GetYlowNDC()+0.5*fPickButton->GetHNDC());
@@ -1458,7 +1468,8 @@ void AliMUONDisplay::SetPickMode()
 //_____________________________________________________________________________
 void AliMUONDisplay::SetZoomMode()
 {
-//  Set parameters for zoom mode
+/// Set parameters for zoom mode
+
     fZoomMode = 1;
     
     fArcButton->SetY1(fZoomButton->GetYlowNDC()+0.5*fZoomButton->GetHNDC());
@@ -1468,8 +1479,8 @@ void AliMUONDisplay::SetZoomMode()
 //_____________________________________________________________________________
 void AliMUONDisplay::NextChamber(Int_t delta)
 {
-  // to go from chamber to next chamber if delta = 1
-  // or previous chamber otherwise
+/// To go from chamber to next chamber if delta = 1
+/// or previous chamber otherwise
     if (delta == 1) {
        if (fChamber < AliMUONConstants::NCh()) fChamber++;
     } else {
@@ -1484,7 +1495,8 @@ void AliMUONDisplay::NextChamber(Int_t delta)
 //_____________________________________________________________________________
 void AliMUONDisplay::NextCathode()
 {
-    // to switch to other cathode plane
+/// To switch to other cathode plane
+
     if (!fPad) return;
     fPad->Clear();
     if (fCathode == 1) {
@@ -1506,6 +1518,7 @@ void AliMUONDisplay::NextCathode()
 //_____________________________________________________________________________
 void AliMUONDisplay::Trigger()
 {
+/// Print global trigger output
 
   AliMUONGlobalTrigger* globalTrig;
 
@@ -1528,7 +1541,8 @@ void AliMUONDisplay::Trigger()
 //_____________________________________________________________________________
 void AliMUONDisplay::SetChamberAndCathode(Int_t chamber, Int_t cathode)
 {
-// Set chamber and cathode number
+/// Set chamber and cathode number
+
    fChamber = chamber;
    fCathode = cathode;
 
@@ -1538,9 +1552,11 @@ void AliMUONDisplay::SetChamberAndCathode(Int_t chamber, Int_t cathode)
    DrawChamber();
 }
 
+//_____________________________________________________________________________
 void AliMUONDisplay::SetEvent(Int_t newevent)
 {
-// Chose event 
+/// Chose event 
+
     gAlice->GetEvent(newevent);
     fEvent=newevent;
     if (!gAlice->TreeD()) return; 
@@ -1553,7 +1569,8 @@ void AliMUONDisplay::SetEvent(Int_t newevent)
 //_____________________________________________________________________________
 void AliMUONDisplay::SetRange(Float_t rrange, Float_t zrange)
 {
-// Set view range along R and Z
+/// Set view range along R and Z
+
     fRrange = rrange;
     fZrange = zrange;
 
@@ -1565,7 +1582,7 @@ void AliMUONDisplay::SetRange(Float_t rrange, Float_t zrange)
 //_____________________________________________________________________________
 void AliMUONDisplay::SetView(Float_t theta, Float_t phi, Float_t psi)
 {
-//  change viewing angles for current event
+/// Change viewing angles for current event
 
     fPad->cd();
     fPhi   = phi;
@@ -1582,15 +1599,16 @@ void AliMUONDisplay::SetView(Float_t theta, Float_t phi, Float_t psi)
 //_____________________________________________________________________________
 void AliMUONDisplay::ShowNextEvent(Int_t delta)
 {
+/// Display (current event_number + delta)
+///  -  delta =  1  shown next event
+///  -  delta = -1 show previous event
+
   AliRunLoader * runLoader;
   if (fLoader)
     runLoader = fLoader->GetRunLoader();
   else
     runLoader = 0x0;
     
-//  Display (current event_number + delta)
-//    delta =  1  shown next event
-//    delta = -1 show previous event
     if (delta) {
       //runLoader->CleanDetectors();
       //runLoader->CleanKinematics();
@@ -1607,7 +1625,8 @@ void AliMUONDisplay::ShowNextEvent(Int_t delta)
 //______________________________________________________________________________
 void AliMUONDisplay::UnZoom()
 {
-// Unzoom 
+/// Unzoom 
+
     if (fZooms <= 0) return;
     fZooms--;
     TPad *pad = (TPad*)gPad->GetPadSave();
@@ -1618,9 +1637,8 @@ void AliMUONDisplay::UnZoom()
 //_____________________________________________________________________________
 void AliMUONDisplay::ResetPoints()
 {
-    //
-    // Reset array of points
-    //
+/// Reset array of points
+
     if (fPoints) {
        fPoints->Delete();
        delete fPoints;
@@ -1630,9 +1648,8 @@ void AliMUONDisplay::ResetPoints()
 //_____________________________________________________________________________
 void AliMUONDisplay::ResetPhits()
 {
-    //
-    // Reset array of points
-    //
+/// Reset array of points
+
     if (fPhits) {
        fPhits->Delete();
        delete fPhits;
@@ -1642,32 +1659,11 @@ void AliMUONDisplay::ResetPhits()
 //_____________________________________________________________________________
 void AliMUONDisplay::ResetRpoints()
 {
-  //
-  // Reset array of points
-  //
+/// Reset array of points
+
     if (fRpoints) {
        fRpoints->Clear();
        //      delete fRpoints;
        fRpoints = 0;
     }
 }
-
-AliMUONDisplay & AliMUONDisplay::operator = (const AliMUONDisplay & rhs)
-{
-// Protected assignement operator
-
-  if (this == &rhs) return *this;
-
-  AliFatal("Not implemented.");
-    
-  return *this;  
-}
-
-
-
-
-
-
-
-
-
index efdb63d..009e424 100644 (file)
 /// \class AliMUONDisplay
 /// \brief Utility class to display MUON events
 
-//////////////////////////////////////////////////////////////////////////
-//                                                                      //
-// AliDisplay                                                           //
-//                                                                      //
-// Utility class to display ALice outline, tracks, hits,..              //
-//                                                                      //
-//////////////////////////////////////////////////////////////////////////
-
 #include "AliDisplay.h"
 
 class AliLoader;
@@ -56,23 +48,24 @@ public:
    virtual void      DrawTitle(Option_t *option="");
    virtual void      DrawView(Float_t theta, Float_t phi, Float_t psi=0);
    virtual void      DrawGlobalView(Float_t theta, Float_t phi, Float_t psi=0);
+                     /// Not implemented function
    virtual void      DrawP(Float_t,Float_t,Float_t,Float_t,Float_t,Int_t){}
    virtual void      ExecuteEvent(Int_t event, Int_t px, Int_t py);
-   Int_t             GetZoomMode() const {return fZoomMode;}
-   Int_t             GetChamber() const {return fChamber;}
-   Int_t             GetCathode() const {return fCathode;}
+   Int_t             GetZoomMode() const {return fZoomMode;}  ///< Return zoom mode
+   Int_t             GetChamber() const {return fChamber;}    ///< Return current chamber
+   Int_t             GetCathode() const {return fCathode;}    ///< Return current cathode
 
-   AliMUONData*      GetMUONData() {return fMUONData;}
-   AliLoader*        GetLoader()  {return fLoader;}
+   AliMUONData*      GetMUONData() {return fMUONData;}        ///< Return MUON data
+   AliLoader*        GetLoader()  {return fLoader;}           ///< Return loader
 
    virtual void      LoadDigits(Int_t chamber, Int_t cathode);
    virtual void      LoadHits(Int_t chamber);
    virtual void      LoadCoG(Int_t chamber, Int_t cathode);
    virtual void      LoadTracks();
-   TPad             *Pad() {return fPad;}
-   TObjArray        *Points() {return fPoints;}
-   TObjArray        *Phits() {return fPhits;}
-   TObjArray        *Rpoints() {return fRpoints;}
+   TPad             *Pad() {return fPad;}         ///< Return pad
+   TObjArray        *Points() {return fPoints;}   ///< Return points for each cathode
+   TObjArray        *Phits() {return fPhits;}     ///< Return hit points for each chamber
+   TObjArray        *Rpoints() {return fRpoints;} ///< Return cog points for each cathode
    virtual void      Paint(Option_t *option="");
    virtual void      SetDrawClusters(Bool_t draw=kTRUE) {fDrawClusters=draw;}   // *MENU*
    virtual void      SetChamberAndCathode(Int_t chamber=1, Int_t cathode=1);    // *MENU*
index abdb270..133834a 100644 (file)
 #include "AliLog.h"
 #include "AliMUONLocalStruct.h"
 
+/// \class AliMUONGlobalTrigger
+/// Global Trigger algorithm data output.
+/// Built from Local and Regional algorithms.                          \n 
+/// Update for copy & assigment operator,
+/// add SetGlobalPattern and GetGlobalPattern method for rawdata 
+/// (Ch. Finck)
+/// \author Ph. Crochet
+
+/// \cond CLASSIMP
 ClassImp(AliMUONGlobalTrigger)
-
-/// ------------------
-/// Class AliMUONGlobalTrigger
-/// ------------------
-// Global Trigger algorithm data output
-// built from Local and Regional algorithms 
-/// Ph. Crochet
-///
-/// update for copy & assigment operator
-/// add SetGlobalPattern and GetGlobalPattern method for rawdata
-/// Ch. Finck
-
+/// \endcond
 
 //----------------------------------------------------------------------
 AliMUONGlobalTrigger::AliMUONGlobalTrigger()
@@ -59,44 +57,47 @@ AliMUONGlobalTrigger::AliMUONGlobalTrigger()
     fPairLikeHpt(0),
     fPairLikeApt(0)
 { 
-  //
-  // constructor 
-  //
+  /// Default constructor 
 }
+
 //----------------------------------------------------------------------
 AliMUONGlobalTrigger::AliMUONGlobalTrigger(const AliMUONGlobalTrigger& theMUONGlobalTrig)
-  : TObject(theMUONGlobalTrig)
-{
-  //
-  // copy constructor
-  //
-  fSinglePlusLpt  = theMUONGlobalTrig.fSinglePlusLpt;
-  fSinglePlusHpt  = theMUONGlobalTrig.fSinglePlusHpt;
-  fSinglePlusApt  = theMUONGlobalTrig.fSinglePlusApt;
-  
-  fSingleMinusLpt = theMUONGlobalTrig.fSingleMinusLpt;
-  fSingleMinusHpt = theMUONGlobalTrig.fSingleMinusHpt;
-  fSingleMinusApt = theMUONGlobalTrig.fSingleMinusApt;
-  
-  fSingleUndefLpt = theMUONGlobalTrig.fSingleUndefLpt;
-  fSingleUndefHpt = theMUONGlobalTrig.fSingleUndefHpt;
-  fSingleUndefApt = theMUONGlobalTrig.fSingleUndefApt;
-  
-  fPairUnlikeLpt  = theMUONGlobalTrig.fPairUnlikeLpt;
-  fPairUnlikeHpt  = theMUONGlobalTrig.fPairUnlikeHpt;
-  fPairUnlikeApt  = theMUONGlobalTrig.fPairUnlikeApt;
+  : TObject(theMUONGlobalTrig),
   
-  fPairLikeLpt    = theMUONGlobalTrig.fPairLikeLpt;
-  fPairLikeHpt    = theMUONGlobalTrig.fPairLikeHpt;
-  fPairLikeApt    = theMUONGlobalTrig.fPairLikeApt;
+    fSinglePlusLpt(theMUONGlobalTrig.fSinglePlusLpt),
+    fSinglePlusHpt(theMUONGlobalTrig.fSinglePlusHpt),
+    fSinglePlusApt(theMUONGlobalTrig.fSinglePlusApt),
+    
+    fSingleMinusLpt(theMUONGlobalTrig.fSingleMinusLpt),
+    fSingleMinusHpt(theMUONGlobalTrig.fSingleMinusHpt),
+    fSingleMinusApt(theMUONGlobalTrig.fSingleMinusApt),
+    
+    fSingleUndefLpt(theMUONGlobalTrig.fSingleUndefLpt),
+    fSingleUndefHpt(theMUONGlobalTrig.fSingleUndefHpt),
+    fSingleUndefApt(theMUONGlobalTrig.fSingleUndefApt),
+    
+    fPairUnlikeLpt(theMUONGlobalTrig.fPairUnlikeLpt),
+    fPairUnlikeHpt(theMUONGlobalTrig.fPairUnlikeHpt),
+    fPairUnlikeApt(theMUONGlobalTrig.fPairUnlikeApt),
+    
+    fPairLikeLpt(theMUONGlobalTrig.fPairLikeLpt),
+    fPairLikeHpt(theMUONGlobalTrig.fPairLikeHpt),
+    fPairLikeApt(theMUONGlobalTrig.fPairLikeApt)
+{
+  /// Copy constructor
+}
+
+//----------------------------------------------------------------------
+AliMUONGlobalTrigger::~AliMUONGlobalTrigger()
+{
+  /// Destructor
 }
 
 //----------------------------------------------------------------------
 AliMUONGlobalTrigger& AliMUONGlobalTrigger::operator=(const AliMUONGlobalTrigger& theMUONGlobalTrig)
 {
-  // assignement operator
-  //
-  // equal operator (useful for non-pointer member in TClonesArray)
+  /// Assignement operator;
+  /// equal operator (useful for non-pointer member in TClonesArray)
 
   if (this == &theMUONGlobalTrig)
     return *this;
@@ -132,38 +133,38 @@ AliMUONGlobalTrigger::AliMUONGlobalTrigger(Int_t *singlePlus,
                                           Int_t *singleMinus,
                                           Int_t *singleUndef,
                                           Int_t *pairUnlike, Int_t *pairLike)
-{
-  //
-  // Set the Global Trigger object
-  //
-  fSinglePlusLpt = singlePlus[0];
-  fSinglePlusHpt = singlePlus[1];
-  fSinglePlusApt = singlePlus[2];
+  : TObject(),
+  
+    fSinglePlusLpt(singlePlus[0]),
+    fSinglePlusHpt(singlePlus[1]),
+    fSinglePlusApt(singlePlus[2]),
 
-  fSingleMinusLpt = singleMinus[0];
-  fSingleMinusHpt = singleMinus[1];
-  fSingleMinusApt = singleMinus[2];
+    fSingleMinusLpt(singleMinus[0]),
+    fSingleMinusHpt(singleMinus[1]),
+    fSingleMinusApt(singleMinus[2]),
 
-  fSingleUndefLpt = singleUndef[0];
-  fSingleUndefHpt = singleUndef[1];
-  fSingleUndefApt = singleUndef[2];
+    fSingleUndefLpt(singleUndef[0]),
+    fSingleUndefHpt(singleUndef[1]),
+    fSingleUndefApt(singleUndef[2]),
 
-  fPairUnlikeLpt = pairUnlike[0];
-  fPairUnlikeHpt = pairUnlike[1];
-  fPairUnlikeApt = pairUnlike[2];
+    fPairUnlikeLpt(pairUnlike[0]),
+    fPairUnlikeHpt(pairUnlike[1]),
+    fPairUnlikeApt(pairUnlike[2]),
 
-  fPairLikeLpt   = pairLike[0];  
-  fPairLikeHpt   = pairLike[1];  
-  fPairLikeApt   = pairLike[2];  
+    fPairLikeLpt(pairLike[0]),    
+    fPairLikeHpt(pairLike[1]),  
+    fPairLikeApt(pairLike[2])
+  
+{
+  /// Set the Global Trigger object
 }
 
 //-----------------------------------------------------------
 void AliMUONGlobalTrigger:: SetGlobalPattern(Int_t gloTrigPat)
 {
-  //
-  // set class member from global pattern
-  // coming from rawdata
-  //
+  /// Set class member from global pattern
+  /// coming from rawdata
+
   fSinglePlusLpt = (gloTrigPat     ) & 0x1;
   fSinglePlusHpt = (gloTrigPat >> 1) & 0x1; 
   fSinglePlusApt = (gloTrigPat >> 2) & 0x1;
@@ -189,11 +190,9 @@ void AliMUONGlobalTrigger:: SetGlobalPattern(Int_t gloTrigPat)
 //-----------------------------------------------------------
 Int_t AliMUONGlobalTrigger::GetGlobalPattern() const
 {
+  /// Global trigger pattern calculation
+  /// from class member values
 
-  //
-  // global trigger pattern calculation
-  // from class member values
-  //
   Int_t gloTrigPat = 0;
 
   if (SinglePlusLpt())  gloTrigPat|= 0x1;
index 851abd5..82ed920 100644 (file)
@@ -9,8 +9,8 @@
 
 /// \ingroup base
 /// \class AliMUONGlobalTrigger
-/// \brief global trigger object
-/// \author Ph. Crochet
+/// \brief Global trigger object
+//  Author Ph. Crochet
 
 #include <TObject.h>
 
@@ -20,23 +20,38 @@ class AliMUONGlobalTrigger : public TObject {
   AliMUONGlobalTrigger(const AliMUONGlobalTrigger& rhs); // copy constructor
   AliMUONGlobalTrigger(Int_t *singlePlus, Int_t *singleMinus,
                       Int_t *singleUndef, Int_t *pairUnlike, Int_t *pairLike);
-  virtual ~AliMUONGlobalTrigger(){;}
+  virtual ~AliMUONGlobalTrigger();
   AliMUONGlobalTrigger& operator=(const  AliMUONGlobalTrigger& rhs);
-  
+        
+       /// Return number of Single Plus Low pt
   Int_t SinglePlusLpt()  const {return fSinglePlusLpt;} 
+       /// Return number of Single Plus High pt
   Int_t SinglePlusHpt()  const {return fSinglePlusHpt ;}    
+       /// Return number of Single Plus All pt
   Int_t SinglePlusApt()  const {return fSinglePlusApt ;}     
+       /// Return number of Single Minus Low pt
   Int_t SingleMinusLpt() const {return fSingleMinusLpt ;}  
+       /// Return number of Single Minus High pt
   Int_t SingleMinusHpt() const {return fSingleMinusHpt;}  
+       /// Return number of Single Minus All pt
   Int_t SingleMinusApt() const {return fSingleMinusApt;}  
+       /// Return number of Single Undefined Low pt
   Int_t SingleUndefLpt() const {return fSingleUndefLpt ;}  
+       /// Return number of Single Undefined High pt
   Int_t SingleUndefHpt() const {return fSingleUndefHpt ;}   
+       /// Return number of Single Undefined All pt
   Int_t SingleUndefApt() const {return fSingleUndefApt ;}  
+       /// Return number of Unlike sign pair Low pt
   Int_t PairUnlikeLpt()  const {return fPairUnlikeLpt ;}   
+       /// Return number of Unlike sign pair High pt
   Int_t PairUnlikeHpt()  const {return fPairUnlikeHpt ;}   
+       /// Return number of Unlike sign pair All pt
   Int_t PairUnlikeApt()  const {return fPairUnlikeApt ;}   
+       /// Return number of Like sign pair Low pt
   Int_t PairLikeLpt()    const {return fPairLikeLpt ;}     
+       /// Return number of Like sign pair High pt
   Int_t PairLikeHpt()    const {return fPairLikeHpt ;}     
+       /// Return number of Like sign pair All pt
   Int_t PairLikeApt()    const {return fPairLikeApt ;}     
   
   void  SetGlobalPattern(Int_t globalPattern);
index 8ba3819..e1050cd 100644 (file)
@@ -15,7 +15,7 @@
 
 /* $Id$ */
 
-// MUON classe for MonteCarlo Hits, inherited from AliHit for the 
+// MUON class for MonteCarlo Hits, inherited from AliHit for the 
 // In addition to the ALiHit data member fX, fY, fZ and fTrack, AliMUONHit contains some info about the particle crossing the chamber:
 // Impulsion: fPtot, fPx, fPy and fPz
 // Reference position at the center of the chamber (wire plane) fXref, fYref and fZref
 #include "AliMUONGeometryStore.h"
 
 
+/// \cond CLASSIMP
 ClassImp(AliMUONHit)
+/// \endcond
  
 //___________________________________________
 AliMUONHit::AliMUONHit()
-  : AliHit() 
+  : AliHit(), 
+    fIsDetElemId(kTRUE),
+    fDetElemId(0),
+    fParticle(0),
+    fTheta(0),
+    fPhi(0),
+    fTlength(0),
+    fEloss(0),
+    fAge(0),
+    fPHfirst(0),
+    fPHlast(0),
+    fPTot(0),
+    fPx(0),
+    fPy(0),
+    fPz(0),
+    fXref(0),
+    fYref(0),
+    fZref(0)
 {
-// Default constructor
+/// Default constructor
 }
 
 //___________________________________________
-AliMUONHit::AliMUONHit(Int_t shunt, Int_t track, Int_t *vol, Float_t *hits):
-       AliHit(shunt, track)
+AliMUONHit::AliMUONHit(Int_t shunt, Int_t track, Int_t *vol, Float_t *hits)
+  : AliHit(shunt, track),
+    fIsDetElemId(kFALSE),
+    fDetElemId(vol[0]),
+    fParticle(hits[0]),
+    fTheta(hits[4]),
+    fPhi(hits[5]),
+    fTlength(hits[6]),
+    fEloss(hits[7]),
+    fAge(hits[14]),
+    fPHfirst((Int_t)hits[8]),
+    fPHlast((Int_t)hits[9]),
+    fPTot(hits[10]),
+    fPx(hits[11]),
+    fPy(hits[12]),
+    fPz(hits[13]),
+    fXref(0),
+    fYref(0),
+    fZref(0)
 {
-// Constructor
-// TBR
-   
-    fIsDetElemId = kFALSE;
-    fDetElemId = vol[0];
-    fParticle  = hits[0];
+/// Constructor
+/// \deprecated TBR
+
     fX         = hits[1];
     fY         = hits[2];
     fZ         = hits[3];
-    fTheta     = hits[4];
-    fPhi       = hits[5];
-    fTlength   = hits[6];
-    fEloss     = hits[7];
-    fPHfirst   = (Int_t) hits[8];
-    fPHlast    = (Int_t) hits[9];
-    fPTot      = hits[10];
-    fPx        = hits[11];
-    fPy        = hits[12];
-    fPz        = hits[13];
-    fAge       = hits[14];
-    fXref      = 0.;
-    fYref      = 0.;
-    fZref      = 0.;
 }
 
 //___________________________________________
 AliMUONHit::AliMUONHit(Int_t shunt, Int_t track, Int_t *vol, Float_t *hits, 
-                       Bool_t /*isDetElemId*/) :
-       AliHit(shunt, track)
+                       Bool_t /*isDetElemId*/)
+  : AliHit(shunt, track),
+    fIsDetElemId(kTRUE),
+    fDetElemId(vol[0]),
+    fParticle(hits[0]),
+    fTheta(hits[4]),
+    fPhi(hits[5]),
+    fTlength(hits[6]),
+    fEloss(hits[7]),
+    fAge(hits[14]),
+    fPHfirst((Int_t)hits[8]),
+    fPHlast((Int_t)hits[9]),
+    fPTot(hits[10]),
+    fPx(hits[11]),
+    fPy(hits[12]),
+    fPz(hits[13]),
+    fXref(0),
+    fYref(0),
+    fZref(0)
 {
-// Constructor
+/// Constructor
    
-    fIsDetElemId = kTRUE;
-    fDetElemId = vol[0];
-    fParticle  = hits[0];
     fX         = hits[1];
     fY         = hits[2];
     fZ         = hits[3];
-    fTheta     = hits[4];
-    fPhi       = hits[5];
-    fTlength   = hits[6];
-    fEloss     = hits[7];
-    fPHfirst   = (Int_t) hits[8];
-    fPHlast    = (Int_t) hits[9];
-    fPTot      = hits[10];
-    fPx        = hits[11];
-    fPy        = hits[12];
-    fPz        = hits[13];
-    fAge       = hits[14];
-    fXref      = 0.;
-    fYref      = 0.;
-    fZref      = 0.;
 }
 
 //___________________________________________
 AliMUONHit::AliMUONHit(Int_t shunt, Int_t track, Int_t iChamber, Int_t idpart, 
                       Float_t X, Float_t Y, Float_t Z, Float_t tof, Float_t momentum, 
-                      Float_t theta, Float_t phi, Float_t length, Float_t destep):
-       AliHit(shunt, track)
+                      Float_t theta, Float_t phi, Float_t length, Float_t destep)
+  : AliHit(shunt, track),
+    fIsDetElemId(kFALSE),
+    fDetElemId(iChamber),
+    fParticle(idpart),
+    fTheta(theta),
+    fPhi(phi),
+    fTlength(length),
+    fEloss(destep),
+    fAge(tof),
+    fPHfirst(0),
+    fPHlast(0),
+    fPTot(momentum),
+    fPx(momentum * TMath::Sin(theta) * TMath::Cos(phi)),
+    fPy(momentum * TMath::Sin(theta) * TMath::Sin(phi)),
+    fPz(momentum * TMath::Cos(theta)),
+    fXref(0),
+    fYref(0),
+    fZref(0)
 {
-// Constructor
-// TBR
+/// Constructor
+/// \deprecated TBR
 
-    fIsDetElemId = kFALSE;
-    fDetElemId = iChamber;
-    fParticle  = idpart;
     fX         = X;
     fY         = Y;
     fZ         = Z;
-    fTheta     = theta;
-    fPhi       = phi;
-    fTlength   = length;
-    fEloss     = destep;
-    fPHfirst   = 0;
-    fPHlast    = 0;
-    fPTot      = momentum;
-    fPx        = momentum * TMath::Sin(theta) * TMath::Cos(phi);
-    fPy        = momentum * TMath::Sin(theta) * TMath::Sin(phi);
-    fPz        = momentum * TMath::Cos(theta) ;
-    fAge       = tof;
-    fXref      = 0.;
-    fYref      = 0.;
-    fZref      = 0.;
 }
 
 //___________________________________________
 AliMUONHit::AliMUONHit(Int_t shunt, Int_t track, Int_t detElemId, Int_t idpart, 
                       Float_t X, Float_t Y, Float_t Z, Float_t tof, Float_t momentum, 
                       Float_t theta, Float_t phi, Float_t length, Float_t destep,
-                      Bool_t /*isDetElemId*/):
-       AliHit(shunt, track)
+                      Bool_t /*isDetElemId*/)
+  : AliHit(shunt, track),
+    fIsDetElemId(kTRUE),
+    fDetElemId(detElemId),
+    fParticle(idpart),
+    fTheta(theta),
+    fPhi(phi),
+    fTlength(length),
+    fEloss(destep),
+    fAge(tof),
+    fPHfirst(0),
+    fPHlast(0),
+    fPTot(momentum),
+    fPx(momentum * TMath::Sin(theta) * TMath::Cos(phi)),
+    fPy(momentum * TMath::Sin(theta) * TMath::Sin(phi)),
+    fPz(momentum * TMath::Cos(theta)),
+    fXref(0),
+    fYref(0),
+    fZref(0)
 {
-// Constructor
-    fIsDetElemId = kTRUE;
-    fDetElemId = detElemId;
-    fParticle  = idpart;
+/// Constructor
     fX         = X;
     fY         = Y;
     fZ         = Z;
-    fTheta     = theta;
-    fPhi       = phi;
-    fTlength   = length;
-    fEloss     = destep;
-    fPHfirst   = 0;
-    fPHlast    = 0;
-    fPTot      = momentum;
-    fPx        = momentum * TMath::Sin(theta) * TMath::Cos(phi);
-    fPy        = momentum * TMath::Sin(theta) * TMath::Sin(phi);
-    fPz        = momentum * TMath::Cos(theta) ;
-    fAge       = tof;
-    fXref      = 0.;
-    fYref      = 0.;
-    fZref      = 0.;
 }
 
 //-----------------------------------------------------------------------------------------------
 AliMUONHit::AliMUONHit(Int_t shunt, Int_t track, Int_t iChamber, Int_t idpart, 
                       Float_t X, Float_t Y, Float_t Z, Float_t tof, Float_t momentum, 
                       Float_t theta, Float_t phi, Float_t length, Float_t destep,
-                      Float_t Xref,Float_t Yref,Float_t Zref):
-       AliHit(shunt, track)
+                      Float_t Xref,Float_t Yref,Float_t Zref)
+  : AliHit(shunt, track),
+    fIsDetElemId(kFALSE),
+    fDetElemId(iChamber),
+    fParticle(idpart),
+    fTheta(theta),
+    fPhi(phi),
+    fTlength(length),
+    fEloss(destep),
+    fAge(tof),
+    fPHfirst(0),
+    fPHlast(0),
+    fPTot(momentum),
+    fPx(momentum * TMath::Sin(theta) * TMath::Cos(phi)),
+    fPy(momentum * TMath::Sin(theta) * TMath::Sin(phi)),
+    fPz(momentum * TMath::Cos(theta)),
+    fXref(Xref),
+    fYref(Yref),
+    fZref(Zref)
 {
-// Constructor
-// TBR
+/// Constructor
+/// \deprecated TBR
 
-    fIsDetElemId = kFALSE;
-    fDetElemId = iChamber;
-    fParticle  = idpart;
     fX         = X;
     fY         = Y;
     fZ         = Z;
-    fTheta     = theta;
-    fPhi       = phi;
-    fTlength   = length;
-    fEloss     = destep;
-    fPHfirst   = 0;
-    fPHlast    = 0;
-    fPTot      = momentum;
-    fPx        = momentum * TMath::Sin(theta) * TMath::Cos(phi);
-    fPy        = momentum * TMath::Sin(theta) * TMath::Sin(phi);
-    fPz        = momentum * TMath::Cos(theta) ;
-    fAge       = tof;
-    fXref      = Xref;
-    fYref      = Yref;
-    fZref      = Zref;
 }
 //-----------------------------------------------------------------------------------------------
 AliMUONHit::AliMUONHit(Int_t shunt, Int_t track, Int_t detElemId, Int_t idpart, 
                       Float_t X, Float_t Y, Float_t Z, Float_t tof, Float_t momentum, 
                       Float_t theta, Float_t phi, Float_t length, Float_t destep,
                       Float_t Xref,Float_t Yref,Float_t Zref,
-                      Bool_t /*isDetElemId*/):
-       AliHit(shunt, track)
+                      Bool_t /*isDetElemId*/)
+  : AliHit(shunt, track),
+    fIsDetElemId(kTRUE),
+    fDetElemId(detElemId),
+    fParticle(idpart),
+    fTheta(theta),
+    fPhi(phi),
+    fTlength(length),
+    fEloss(destep),
+    fAge(tof),
+    fPHfirst(0),
+    fPHlast(0),
+    fPTot(momentum),
+    fPx(momentum * TMath::Sin(theta) * TMath::Cos(phi)),
+    fPy(momentum * TMath::Sin(theta) * TMath::Sin(phi)),
+    fPz(momentum * TMath::Cos(theta)),
+    fXref(Xref),
+    fYref(Yref),
+    fZref(Zref)
 {
-// Constructor
-    fIsDetElemId = kTRUE;
-    fDetElemId = detElemId;
-    fParticle  = idpart;
+/// Constructor
+
     fX         = X;
     fY         = Y;
     fZ         = Z;
-    fTheta     = theta;
-    fPhi       = phi;
-    fTlength   = length;
-    fEloss     = destep;
-    fPHfirst   = 0;
-    fPHlast    = 0;
-    fPTot      = momentum;
-    fPx        = momentum * TMath::Sin(theta) * TMath::Cos(phi);
-    fPy        = momentum * TMath::Sin(theta) * TMath::Sin(phi);
-    fPz        = momentum * TMath::Cos(theta) ;
-    fAge       = tof;
-    fXref      = Xref;
-    fYref      = Yref;
-    fZref      = Zref;
+}
+
+//-----------------------------------------------------------------------------------------------
+AliMUONHit::~AliMUONHit()
+{
+/// Dectructor
 }
 
 //-----------------------------------------------------------------------------------------------
 Int_t AliMUONHit::DetElemId()const
 {
-// Return detection element ID
+/// Return detection element ID
 
   if (!fIsDetElemId) {
     AliWarning("Detection element Id is not defined.");
     return 0;
   }  
-  // end of TBR
   
   return fDetElemId;
 }
@@ -240,7 +265,7 @@ Int_t AliMUONHit::DetElemId()const
 //-----------------------------------------------------------------------------------------------
 Int_t  AliMUONHit::Chamber()  const
 {  
-// Return chamber ID
+/// Return chamber ID
 
   if (!fIsDetElemId) 
     return fDetElemId;
index 446b083..a1d403d 100644 (file)
@@ -10,7 +10,7 @@
 /// \class AliMUONHit
 /// \brief MonteCarlo hit
 ///
-/// MUON classe for MonteCarlo Hits, inherited from AliHit for the 
+/// MUON class for MonteCarlo Hits, inherited from AliHit for the 
 /// In addition to the ALiHit data member fX, fY, fZ and fTrack, AliMUONHit contains some info about the particle crossing the chamber:
 /// Impulsion: fPtot, fPx, fPy and fPz
 /// Reference position at the center of the chamber (wire plane) fXref, fYref and fZref
@@ -48,33 +48,33 @@ class AliMUONHit : public AliHit {
                Float_t X, Float_t Y, Float_t Z, Float_t tof, Float_t momentum, 
                Float_t theta, Float_t phi, Float_t length, Float_t destep,
                Float_t Xref, Float_t Yref, Float_t Zref, Bool_t isNew);
-    virtual ~AliMUONHit() {}
+    virtual ~AliMUONHit();
 
     Int_t   DetElemId()const;
     Int_t   Chamber()  const;
-    virtual void Print(Option_t* opt="") const;
-
-    Float_t Particle() const {return fParticle;}    
-    Float_t Theta()    const {return fTheta;}
-    Float_t Phi()      const {return fPhi;}
-    Float_t Tlength()  const {return fTlength;}
-    Float_t Eloss()    const {return fEloss;}
-    Float_t Age()      const {return fAge;}
-    Int_t   PHfirst()  const {return fPHfirst;}
-    Int_t   PHlast()   const {return fPHlast;}
 
-    Float_t Momentum() const {return fPTot;}
-    Float_t Px()       const {return fPx;}
-    Float_t Py()       const {return fPy;}
-    Float_t Pz()       const {return fPz;}
-    Float_t Cx()       const {return fPx/fPTot;} 
-    Float_t Cy()       const {return fPy/fPTot;}
-    Float_t Cz()       const {return fPz/fPTot;}
-
-    Float_t Xref()     const {return fXref;}
-    Float_t Yref()     const {return fYref;}
-    Float_t Zref()     const {return fZref;}
+    virtual void Print(Option_t* opt="") const;
 
+    Float_t Particle() const {return fParticle;}  ///< Return particle id   
+    Float_t Theta()    const {return fTheta;}     ///< Return incident theta angle in degrees
+    Float_t Phi()      const {return fPhi;}       ///< Return incident phi angle in degrees
+    Float_t Tlength()  const {return fTlength;}   ///< Return track length inside the chamber
+    Float_t Eloss()    const {return fEloss;}     ///< Return Ionisation energy loss in gas
+    Float_t Age()      const {return fAge;}       ///< Return Particle Age
+    Int_t   PHfirst()  const {return fPHfirst;}   ///< Return First padhit
+    Int_t   PHlast()   const {return fPHlast;}    ///< Return Last padhit
+
+    Float_t Momentum() const {return fPTot;}      ///< Return local momentum P of the entering track
+    Float_t Px()       const {return fPx;}        ///< Return Px
+    Float_t Py()       const {return fPy;}        ///< Return Py
+    Float_t Pz()       const {return fPz;}        ///< Return Pz
+    Float_t Cx()       const {return fPx/fPTot;}  ///< Return Px/PTot 
+    Float_t Cy()       const {return fPy/fPTot;}  ///< Return Py/PTot 
+    Float_t Cz()       const {return fPz/fPTot;}  ///< Return Pz/PTot 
+
+    Float_t Xref()     const {return fXref;}      ///< Return X position of hit in the center of the chamber (without angle effect)
+    Float_t Yref()     const {return fYref;}      ///< Return Y position of hit in the center of the chamber (without angle effect)
+    Float_t Zref()     const {return fZref;}      ///< Return Z position of hit in the center of the chamber (without angle effect)
 
  private:  
     Bool_t    fIsDetElemId;   ///< False if fDetElemId contains Chamber Id (old code) 
@@ -83,7 +83,7 @@ class AliMUONHit : public AliHit {
     Float_t   fTheta ;        ///< Incident theta angle in degrees      
     Float_t   fPhi   ;        ///< Incident phi angle in degrees
     Float_t   fTlength;       ///< Track length inside the chamber
-    Float_t   fEloss;         ///< ionisation energy loss in gas
+    Float_t   fEloss;         ///< Ionisation energy loss in gas
     Float_t   fAge;           ///< Particle Age
     Int_t     fPHfirst;       ///< First padhit
     Int_t     fPHlast;        ///< Last padhit
index 166ea06..cac512e 100644 (file)
 #include "AliMUONConstants.h"
 #include "AliLog.h"
 
+/// \cond CLASSIMP
 ClassImp(AliMUONLoader)
+/// \endcond
+
 //___________________________________________________________________
 AliMUONLoader::AliMUONLoader()
   : AliLoader(),
@@ -38,41 +41,22 @@ AliMUONLoader::AliMUONLoader(const Char_t* detname,const Char_t* eventfoldername
   : AliLoader(detname,eventfoldername),
     fMUONData(0)
 {
+/// Standard contructor with name of the top folder of the tree
 }
 //_______________________________________________________________________________
 AliMUONLoader::AliMUONLoader(const Char_t * detname,TFolder* eventfolder)
   : AliLoader(detname,eventfolder),
-  fMUONData(0)
+    fMUONData(0)
 {
 /// Constructor
 }
-//___________________________________________
-AliMUONLoader::AliMUONLoader(const AliMUONLoader& rhs)
-  : AliLoader(rhs)
-{
-/// Protected copy constructor
-
-  AliFatal("Not implemented.");
-}
 
 //_______________________________________________________________________________
 AliMUONLoader::~AliMUONLoader()
 {
 /// Destructor 
 }
-//-------------------------------------------------------------------
-AliMUONLoader&  
-AliMUONLoader::operator=(const AliMUONLoader& rhs)
-{
-/// Protected assignement operator
-
-  if (this == &rhs) return *this;
 
-  AliFatal("Not implemented.");
-    
-  return *this;  
-}    
-          
 //_______________________________________________________________________________
 void AliMUONLoader::SetMUONData(AliMUONData * MUONData)
 {
index b47b8e7..6d5d88b 100644 (file)
 #include "AliLog.h"
 #include "AliMUONLocalStruct.h"
 
-ClassImp(AliMUONLocalTrigger)
-
-/// ------------------
-/// Class AliMUONLocalTrigger
-/// ------------------
+/// \class AliMUONLocalTrigger
 /// Local Trigger algorithm data outputs
-/// (contains local trigger decision and bit patterns)
-/// Ph. Crochet
-///
-/// add SetLocalStruct method for rawdata
-/// Ch. Finck
+/// (contains local trigger decision and bit patterns)                \n
+/// Add SetLocalStruct method for rawdata  (Ch. Finck)
+/// \author Ph. Crochet
+
+/// \cond CLASSIMP
+ClassImp(AliMUONLocalTrigger)
+/// \endcond
 
 //----------------------------------------------------------------------
 AliMUONLocalTrigger::AliMUONLocalTrigger()
@@ -57,17 +55,14 @@ AliMUONLocalTrigger::AliMUONLocalTrigger()
     fLoDecision(0),
     fDigits(0)
 {
-  //
-  // constructor
-  //
+/// Default constructor
 }
 //----------------------------------------------------------------------
 AliMUONLocalTrigger::AliMUONLocalTrigger(const AliMUONLocalTrigger& theMUONLocalTrig)
   : TObject(theMUONLocalTrig)
 {
-  //
-  // copy constructor (useful for TClonesArray)
-  //
+/// Copy constructor (useful for TClonesArray)
+
   fLoCircuit = theMUONLocalTrig.fLoCircuit;
   fLoStripX  = theMUONLocalTrig.fLoStripX;         
   fLoDev     = theMUONLocalTrig.fLoDev;           
@@ -93,9 +88,8 @@ AliMUONLocalTrigger::AliMUONLocalTrigger(const AliMUONLocalTrigger& theMUONLocal
 //----------------------------------------------------------------------
 AliMUONLocalTrigger& AliMUONLocalTrigger::operator=(const AliMUONLocalTrigger& theMUONLocalTrig)
 {
-  // assigment operator
-  //
-  // equal operator (useful for non-pointer member in TClonesArray)
+/// Assigment operator;
+/// equal operator (useful for non-pointer member in TClonesArray)
 
   if (this == &theMUONLocalTrig)
     return *this;
@@ -131,9 +125,8 @@ AliMUONLocalTrigger& AliMUONLocalTrigger::operator=(const AliMUONLocalTrigger& t
 //----------------------------------------------------------------------
 AliMUONLocalTrigger::AliMUONLocalTrigger(const Int_t* localtr, const TArrayI& digits)
 {
-  //
-  // add a local trigger object 
-  //
+/// Add a local trigger object 
+
   fLoCircuit = localtr[0];
   fLoStripX  = localtr[1];         
   fLoDev     = localtr[2];           
@@ -158,9 +151,9 @@ AliMUONLocalTrigger::AliMUONLocalTrigger(const Int_t* localtr, const TArrayI& di
 //----------------------------------------------------------------------
 Char_t AliMUONLocalTrigger::GetLoDecision()
 {
-  // get local decision 
-  // from H(L)pt
-  // returns local trigger decision
+/// Get local decision 
+/// from H(L)pt;
+/// returns local trigger decision
 
   fLoDecision  = (fLoLpt & 0x3);
   fLoDecision |= (fLoHpt << 2) & 0xC;
@@ -172,9 +165,9 @@ Char_t AliMUONLocalTrigger::GetLoDecision()
 void AliMUONLocalTrigger::GetDigit(
                Int_t i, Int_t& chamber, Int_t& cathode, Int_t& digit) const
 {
-// Returns the i'th digit that fired this circuit.
-// The number of digits can be found with NumberOfDigits(), that is 
-// i is valid in the range [ 0 , NumberOfDigits() - 1 ]
+/// Returns the i'th digit that fired this circuit.
+/// The number of digits can be found with NumberOfDigits(), that is 
+/// i is valid in the range [ 0 , NumberOfDigits() - 1 ]
 
        Int_t digitnumber = fDigits[i];
        DecodeDigitNumber(digitnumber, chamber, cathode, digit);
@@ -184,9 +177,9 @@ void AliMUONLocalTrigger::GetDigit(
 Int_t AliMUONLocalTrigger::EncodeDigitNumber(Int_t chamber, Int_t cathode, 
                                             Int_t digit)
 {
-// Encodes a 32-bit digit number from digit information to be stored
-// in internal integer arrays. Note that the value of the digit parameter
-// can not be larger than 0x07FFFFFF.
+/// Encodes a 32-bit digit number from digit information to be stored
+/// in internal integer arrays. Note that the value of the digit parameter
+/// can not be larger than 0x07FFFFFF.
 
        assert( 0 <= cathode && cathode <= 1 );
        assert( 0 <= chamber && chamber <= 13 );
@@ -207,9 +200,9 @@ Int_t AliMUONLocalTrigger::EncodeDigitNumber(Int_t chamber, Int_t cathode,
 void AliMUONLocalTrigger::DecodeDigitNumber(Int_t digitnumber, Int_t& chamber, 
                                            Int_t& cathode, Int_t& digit)
 {
-// Decodes a digit number into information about the digit.
-// One can subsequently fetch the digit with
-// AliMUONDataInterface::Digit(chamber, cathode, digit)
+/// Decodes a digit number into information about the digit.
+/// One can subsequently fetch the digit with
+/// AliMUONDataInterface::Digit(chamber, cathode, digit)
 
        cathode = (digitnumber >> 31) & 0x1;
        chamber = (digitnumber >> 27) & 0xF;
@@ -219,9 +212,7 @@ void AliMUONLocalTrigger::DecodeDigitNumber(Int_t digitnumber, Int_t& chamber,
 //----------------------------------------------------------------------
 void AliMUONLocalTrigger::SetLocalStruct(Int_t loCircuit, AliMUONLocalStruct& localStruct)
 {
-  //
-  // Set local trigger info from rawdata localStruct
-  //
+/// Set local trigger info from rawdata localStruct
 
   // set id'
   SetLoCircuit(loCircuit);
index a4073d0..973d6ee 100644 (file)
@@ -10,7 +10,7 @@
 /// \ingroup base
 /// \class AliMUONLocalTrigger
 /// \brief Reconstructed Local Trigger object
-/// \author Ph. Crochet
+//  Author Ph. Crochet
 
 #include <TObject.h>
 #include <TArrayI.h>
@@ -26,50 +26,84 @@ class AliMUONLocalTrigger : public TObject {
   AliMUONLocalTrigger& operator=(const AliMUONLocalTrigger& rhs); 
 
   // getter methods
+  //
+        /// Return Circuit number
   Int_t LoCircuit() const {return fLoCircuit;}
+        /// Return X strip in MT11
   Int_t LoStripX() const {return fLoStripX;}   
+        /// Return Deviation
   Int_t LoDev() const {return fLoDev;}
+        /// Return Y strip in MT11
   Int_t LoStripY() const {return fLoStripY;}
+        /// Return Low pt
   Int_t LoLpt() const {return fLoLpt;}
+        /// Return High p
   Int_t LoHpt() const {return fLoHpt;}
+        /// Return All pt
   Int_t LoApt() const {return fLoApt;}
 
-   
+           /// Return X strip pattern for chamber 11
   UShort_t GetX1Pattern() const {return fX1Pattern;}
+           /// Return X strip pattern for chamber 12  
   UShort_t GetX2Pattern() const {return fX2Pattern;}
+           /// Return X strip pattern for chamber 21 
   UShort_t GetX3Pattern() const {return fX3Pattern;}
+           /// Return X strip pattern for chamber 22
   UShort_t GetX4Pattern() const {return fX4Pattern;}
 
+           /// Return Y strip pattern for chamber 11 
   UShort_t GetY1Pattern() const {return fY1Pattern;}
+           /// Return Y strip pattern for chamber 12
   UShort_t GetY2Pattern() const {return fY2Pattern;}
+           /// Return Y strip pattern for chamber 21
   UShort_t GetY3Pattern() const {return fY3Pattern;}
+           /// Return Y strip pattern for chamber 22
   UShort_t GetY4Pattern() const {return fY4Pattern;}
 
   Char_t GetLoDecision();
 
   // setter methods
+  //
+           /// Set Circuit number
   void SetLoCircuit(Int_t loCir) {fLoCircuit = loCir;}
+           /// Set X strip in MT11
   void SetLoStripX(Int_t loStrX) {fLoStripX = loStrX;}   
+           /// Set Deviation
   void SetLoDev(Int_t loDev)     {fLoDev = loDev;}
+           /// Set Y strip in MT11
   void SetLoStripY(Int_t loStrY) {fLoStripY = loStrY;}
+           /// Set Low pt
   void SetLoLpt(Int_t loLpt)     {fLoLpt = loLpt;}
+           /// Set High pt
   void SetLoHpt(Int_t loHpt)     {fLoHpt = loHpt;}
+           /// Set All pt
   void SetLoApt(Int_t loApt)     {fLoApt = loApt;}
 
+           /// Set X strip pattern for chamber 11
   void SetX1Pattern(UShort_t pat) {fX1Pattern = pat;}
+           /// Set X strip pattern for chamber 12
   void SetX2Pattern(UShort_t pat) {fX2Pattern = pat;}
+           /// Set X strip pattern for chamber 21
   void SetX3Pattern(UShort_t pat) {fX3Pattern = pat;}
+           /// Set X strip pattern for chamber 22
   void SetX4Pattern(UShort_t pat) {fX4Pattern = pat;}
 
+           /// Set Y strip pattern for chamber 11
   void SetY1Pattern(UShort_t pat) {fY1Pattern = pat;}
+           /// Set Y strip pattern for chamber 12
   void SetY2Pattern(UShort_t pat) {fY2Pattern = pat;}
+           /// Set Y strip pattern for chamber 21
   void SetY3Pattern(UShort_t pat) {fY3Pattern = pat;}
+           /// Set Y strip pattern for chamber 22
   void SetY4Pattern(UShort_t pat) {fY4Pattern = pat;}
 
   void SetLocalStruct(Int_t loCircuit, AliMUONLocalStruct& localStruct);
 
   // data link
+  //
+           /// Return number of digits in the list
   Int_t NumberOfDigits() const { return fDigits.GetSize(); }
+           /// Return \a i th digit number in the list
   Int_t GetDigitNumber(Int_t i) const { return fDigits[i]; }
   void  GetDigit(Int_t i, Int_t& chamber, Int_t& cathode, Int_t& digit) const;
 
index e0a6b7b..13abd14 100644 (file)
 #include <TMath.h>
 #include <TRandom.h>
 
+/// \cond CLASSIMP
 ClassImp(AliMUONMathieson)
+/// \endcond
        
 //__________________________________________________________________________
-  AliMUONMathieson::AliMUONMathieson() :
+AliMUONMathieson::AliMUONMathieson() :
     fSqrtKx3(0.),
     fKx2(0.),
     fKx4(0.),
@@ -48,6 +50,12 @@ ClassImp(AliMUONMathieson)
 
 }
 
+//__________________________________________________________________________
+AliMUONMathieson::~AliMUONMathieson()
+{
+/// Destructor
+}
+
   //__________________________________________________________________________
 void AliMUONMathieson::SetSqrtKx3AndDeriveKx2Kx4(Float_t SqrtKx3)
 {
index bd09f05..c580916 100644 (file)
@@ -20,33 +20,44 @@ class AliMUONMathieson : public TObject
 {
  public:
     AliMUONMathieson();
-    virtual ~AliMUONMathieson(){}
+    virtual ~AliMUONMathieson();
  
-    // Get anode cathode Pitch
+    /// Get anode cathode Pitch
     Float_t Pitch() const        {return fPitch;}
     // Set anode cathode Pitch
     void    SetPitch(Float_t p1);
 
     // Set Mathieson parameters
-    // Mathieson \sqrt{Kx3} and derived Kx2 and Kx4
-    void SetSqrtKx3AndDeriveKx2Kx4(Float_t SqrtKx3);
-    // Mathieson \sqrt{Kx3}
+    //
+    
+    /// Mathieson \a sqrt{Kx3} and derived \a Kx2 and \a Kx4
+    void    SetSqrtKx3AndDeriveKx2Kx4(Float_t SqrtKx3);
+    
+    /// Mathieson \a sqrt{Kx3}
     void    SetSqrtKx3(Float_t p1) {fSqrtKx3 = p1;};
-    // Mathieson Kx2
+    
+    /// Mathieson \a Kx2
     void    SetKx2(Float_t p1)      {fKx2 = p1;};
-    // Mathieson Kx4
+    
+    /// Mathieson \a Kx4
     void    SetKx4(Float_t p1)      {fKx4 = p1;};
-    // Mathieson \sqrt{Ky3} and derived Ky2 and Ky4
+    
+    /// Mathieson \a sqrt{Ky3} and derived \a Ky2 and \a Ky4
     void SetSqrtKy3AndDeriveKy2Ky4(Float_t SqrtKy3);
-    // Mathieson \sqrt{Ky3}
+    
+    /// Mathieson \a sqrt{Ky3}
     void    SetSqrtKy3(Float_t p1)   {fSqrtKy3 = p1;};
-    // Mathieson Ky2
+    
+    /// Mathieson \a Ky2
     void    SetKy2(Float_t p1) {fKy2 = p1;};
-    // Mathieson Ky4
+    
+    /// Mathieson \a Ky4
     void    SetKy4(Float_t p1) {fKy4 = p1;};
+    
     /// \deprecated To be removed when old (s)digitizers go off.
     Float_t  IntXY(Int_t id, AliMUONGeometrySegmentation* segmentation) const;
-    /// Charge integration on region (x1,y1,x2,y2).
+    
+    /// Charge integration on region \a (x1,y1,x2,y2).
     Float_t IntXY(Float_t xi1, Float_t yi1, Float_t xi2, Float_t yi2) const;
     
  private:
@@ -59,7 +70,8 @@ class AliMUONMathieson : public TObject
     Float_t fKy4;                      ///< Mathieson Ky4 = Ky1/Ky2/Sqrt(Ky3)
     Float_t fPitch;                    ///< anode-cathode pitch
     Float_t fInversePitch;             ///< 1/Pitch
-    ClassDef(AliMUONMathieson,3) // Implementation of Mathieson response
+
+  ClassDef(AliMUONMathieson,3) // Implementation of Mathieson response
 };
 #endif
 
index 328675d..653ec78 100644 (file)
 #include "AliMUONDigit.h"
 #include "AliLog.h"
 
+/// \cond CLASSIMP
 ClassImp(AliMUONPoints)
+/// \endcond
 
 //_____________________________________________________________________________
 AliMUONPoints::AliMUONPoints()
-  : AliPoints()
+  : AliPoints(),
+    fHitIndex(0),
+    fTrackIndex(0),
+    fDigitIndex(0),
+    fMatrix(0)
+
 {
-  //
-  // Default constructor
-  //
-  fHitIndex = 0;
-  fTrackIndex = 0;
-  fDigitIndex = 0;
+  /// Default constructor
+
   fMarker[0] = fMarker[1] = fMarker[2]=0;
-  fMatrix = 0;
 }
 
 //_____________________________________________________________________________
 AliMUONPoints::AliMUONPoints(Int_t npoints)
-  :AliPoints(npoints)
+  : AliPoints(npoints),
+    fHitIndex(0),
+    fTrackIndex(0),
+    fDigitIndex(0),
+    fMatrix(0)
 {
-  //
-  // Standard constructor
-  //
-  fHitIndex = 0;
-  fTrackIndex = 0;
-  fDigitIndex = 0;
+  /// Standard constructor
+
   fMarker[0] = fMarker[1] = fMarker[2]=0;
-  fMatrix = 0;
 }
 
 //_____________________________________________________________________________
-AliMUONPoints::AliMUONPoints(const AliMUONPoints& points)
-  : AliPoints(points)
-{
-// Protected copy constructor
-
-  AliFatal("Not implemented.");
-}
-        
-//_____________________________________________________________________________
 AliMUONPoints::~AliMUONPoints()
 {
-  //
-  // Default destructor
-  //
+  /// Destructor
+
   fHitIndex = 0;
   fTrackIndex = 0;
   fDigitIndex = 0;
@@ -99,9 +90,8 @@ AliMUONPoints::~AliMUONPoints()
 //_____________________________________________________________________________
 void AliMUONPoints::DumpHit() const
 {
-  //
-  //   Dump hit corresponding to this point
-  //
+  /// Dump hit corresponding to this point
   AliMUONHit *hit = GetHit();
   if (hit) hit->Dump();
 }
@@ -109,9 +99,8 @@ void AliMUONPoints::DumpHit() const
 //_____________________________________________________________________________
 void AliMUONPoints::DumpDigit() const
 {
-  //
-  //   Dump digit corresponding to this point
-  //
+  /// Dump digit corresponding to this point
+
   AliMUONDigit *digit = GetDigit();
   if (digit) digit->Dump();
 }
@@ -119,9 +108,7 @@ void AliMUONPoints::DumpDigit() const
 //_____________________________________________________________________________
 void AliMUONPoints::InspectHit()
 {
-  //
-  //   Inspect hit corresponding to this point
-  //
+  /// Inspect hit corresponding to this point
 
   if (fHitIndex < 0 ) return;
   TVirtualPad *padsav = gPad;
@@ -151,9 +138,8 @@ void AliMUONPoints::InspectHit()
 //_____________________________________________________________________________
 void AliMUONPoints::InspectDigit()
 {
-  //
-  //   Inspect digit corresponding to this point
-  //
+  /// Inspect digit corresponding to this point
+
   if (fDigitIndex < 0) return;
   TVirtualPad *padsav = gPad;
   AliMUONDigit *digit = GetDigit();
@@ -188,9 +174,7 @@ void AliMUONPoints::InspectDigit()
 //_____________________________________________________________________________
 Int_t AliMUONPoints::GetTrackIndex() const
 {
-  //
-  //   Dump digit corresponding to this point
-  //
+  /// Dump digit corresponding to this point
 
   Inspect();
   /*
@@ -207,9 +191,8 @@ Int_t AliMUONPoints::GetTrackIndex() const
 //_____________________________________________________________________________
 AliMUONHit *AliMUONPoints::GetHit() const
 {
-  //
-  //   Returns pointer to hit index in AliRun::fParticles
-  //
+  /// Returns pointer to hit index in AliRun::fParticles
+
   AliMUON *pMUON  = (AliMUON*)gAlice->GetModule("MUON");
   
   pMUON->TreeH()->GetEvent(fTrackIndex);
@@ -222,9 +205,7 @@ AliMUONHit *AliMUONPoints::GetHit() const
 //_____________________________________________________________________________
 AliMUONDigit *AliMUONPoints::GetDigit() const
 {
-  //
-  //   Returns pointer to digit index in AliRun::fParticles
-  //
+  /// Returns pointer to digit index in AliRun::fParticles
 
   AliMUONDisplay *display=(AliMUONDisplay*)gAlice->Display();
   Int_t chamber=display->GetChamber();
@@ -237,15 +218,3 @@ AliMUONDigit *AliMUONPoints::GetDigit() const
   if (fDigitIndex < 0 || fDigitIndex >= ndigits) return 0;
   return (AliMUONDigit*)muonDigits->UncheckedAt(fDigitIndex);
 }
-//_____________________________________________________________________________
-
-AliMUONPoints& AliMUONPoints::operator= (const AliMUONPoints& rhs)
-{
-// Protected assignement operator
-
-  if (this == &rhs) return *this;
-
-  AliFatal("Not implemented.");
-    
-  return *this;  
-}
index 3438491..5d022d2 100644 (file)
@@ -24,10 +24,13 @@ public:
   AliMUONPoints();
   AliMUONPoints(Int_t npoints);
   virtual ~AliMUONPoints();
-
+                        
+                       /// Return hit index
   Int_t                 GetHitIndex() const {return fHitIndex;}
   Int_t                 GetTrackIndex() const; // *MENU*
+                       /// Return digit index
   Int_t                 GetDigitIndex() const {return fDigitIndex;}
+                       /// Return associated 3D-marker
   TMarker3DBox         *GetMarker(Int_t i) const {return fMarker[i];}
   AliMUONHit           *GetHit() const;
   AliMUONDigit         *GetDigit() const;
@@ -35,10 +38,15 @@ public:
   virtual void          DumpHit() const; // *MENU*
   virtual void          InspectDigit(); // *MENU*
   virtual void          DumpDigit() const; // *MENU*
+                        /// Set hit index
   virtual void          SetHitIndex(Int_t hitindex) {fHitIndex = hitindex;}
+                        /// Set track index
   virtual void          SetTrackIndex(Int_t trackindex) {fTrackIndex = trackindex;}
+                        /// Set digit index
   virtual void          SetDigitIndex(Int_t digitindex) {fDigitIndex = digitindex;}
+                        /// Set associated 3D-marker
   virtual void          Set3DMarker(Int_t i,TMarker3DBox *marker) {fMarker[i] = marker;}
+                        /// Set matrix
   virtual void          SetMatrix(TMatrixF *matrix) {fMatrix = matrix;}
   
 protected:
index ab0d2be..2b885a0 100644 (file)
 
 #include "AliMUONRawCluster.h"
 
+/// \cond CLASSIMP
 ClassImp(AliMUONRawCluster)
-
+/// \endcond
 
 AliMUONRawCluster::AliMUONRawCluster() 
-  : TObject()
+  : TObject(),
+    fClusterType(0),
+    fGhost(0),
+    fDetElemId(0)   
 {
 /// Constructor
     fTracks[0]=fTracks[1]=fTracks[2]=-1; 
@@ -54,8 +58,6 @@ AliMUONRawCluster::AliMUONRawCluster()
        }
     }
     fNcluster[0]=fNcluster[1]=-1;
-    fGhost=0;
-    fDetElemId = 0;
     fErrXY[0] = 0.144;
     fErrXY[1] = 0.01;
 }
index 12b0361..5231e76 100644 (file)
 
 /* $Id$ */
 
-// -----------------------
-// Class AliMUONRecoCheck
-// -----------------------
-// Utility class to check the muon reconstruction. Reconstructed tracks are compared
-// to reference tracks. The reference tracks are built from AliTrackReference for the
-// hit in chamber (0..9) and from kinematics for the vertex parameters.     
+/// \class AliMUONRecoCheck
+/// \brief Utility class to check reconstruction
+/// Reconstructed tracks are compared to reference tracks. 
+/// The reference tracks are built from AliTrackReference for the
+/// hit in chamber (0..9) and from kinematics for the vertex parameters.     
 
 #include "AliMUON.h"
 #include "AliMUONRecoCheck.h"
 
 #include <TParticle.h>
 
+/// \cond CLASSIMP
 ClassImp(AliMUONRecoCheck)
+/// \endcond
 
 //_____________________________________________________________________________
 AliMUONRecoCheck::AliMUONRecoCheck(Char_t *chLoader)
 {
 /// Constructor
+
   fMuonTrackRef = new TClonesArray("AliMUONTrack", 10);
 
   // open the run loader
@@ -69,15 +71,6 @@ AliMUONRecoCheck::AliMUONRecoCheck(Char_t *chLoader)
   fRecoTracks = 0;
 }
 
-//____________________________________________________________________
-AliMUONRecoCheck::AliMUONRecoCheck(const AliMUONRecoCheck& rhs)
- : TObject(rhs)
-{
-/// Protected copy constructor
-
-  AliFatal("Not implemented.");
-}
-
 //_____________________________________________________________________________
 AliMUONRecoCheck::~AliMUONRecoCheck()
 {
@@ -91,18 +84,6 @@ AliMUONRecoCheck::~AliMUONRecoCheck()
   delete fMUONData;
 }
 
-//________________________________________________________________________
-AliMUONRecoCheck& AliMUONRecoCheck::operator = (const AliMUONRecoCheck& rhs)
-{
-/// Protected assignement operator
-
-  if (this == &rhs) return *this;
-
-  AliFatal("Not implemented.");
-    
-  return *this;  
-}
-
 //_____________________________________________________________________________
 void AliMUONRecoCheck::MakeTrackRef()
 {
index 098844e..38be774 100644 (file)
@@ -24,18 +24,25 @@ public:
   AliMUONRecoCheck(Char_t *chLoader);
   virtual          ~AliMUONRecoCheck();
 
+                /// Return MUON data 
   AliMUONData*  GetMUONData() {return fMUONData;}
   void MakeTrackRef();
+                /// Add track reference
   void AddMuonTrackReference(const AliMUONTrack *muonTrack) 
     {new ((*fMuonTrackRef)[fMuonTrackRef->GetEntriesFast()]) AliMUONTrack(*muonTrack);}
+
   void PrintEvent() const;
   void ResetTracks() const;
+                /// Return run loader
   AliRunLoader* GetRunLoader() {return fRunLoader;}
   void CleanMuonTrackRef();
   void ReconstructibleTracks();
+                /// Return number of reconstructible tracks
   Int_t GetNumberOfReconstuctibleTracks() {return fReconstructibleTracks;}
+                /// Return number of reconstructed tracks
   Int_t GetNumberOfRecoTracks() {return fRecoTracks;}
   TClonesArray *GetTrackReco();
+                /// Return reference muon tracks
   TClonesArray *GetMuonTrackRef() {return fMuonTrackRef;}
 
 protected:
index 02962cf..e269ed8 100644 (file)
@@ -49,7 +49,9 @@
 #include <TObjString.h>
 #include <TMap.h>
 
+/// \cond CLASSIMP
 ClassImp(AliMUONSegFactory)
+/// \endcond
 
 //______________________________________________________________________________
 AliMUONSegFactory::AliMUONSegFactory(const AliMUONGeometryTransformer* geometry)
@@ -92,15 +94,6 @@ AliMUONSegFactory::AliMUONSegFactory(const TString& volPathsFileName,
 }
 
 //______________________________________________________________________________
-AliMUONSegFactory::AliMUONSegFactory(const AliMUONSegFactory& rhs)
- : TObject(rhs)
-{
-/// Protected copy constructor
-
-  AliFatal("Not implemented.");
-}
-
-//______________________________________________________________________________
 
 AliMUONSegFactory::~AliMUONSegFactory()
 {
@@ -110,18 +103,6 @@ AliMUONSegFactory::~AliMUONSegFactory()
         // The segmentation is supposed to be deleted in the client code
 }
 
-//______________________________________________________________________________
-AliMUONSegFactory&  AliMUONSegFactory::operator=(const AliMUONSegFactory& rhs)
-{
-  // Protected assignement operator
-
-  if (this == &rhs) return *this;
-
-  AliFatal("Not implemented.");
-    
-  return *this;  
-}    
-          
 //
 // Private methods
 //
@@ -129,8 +110,8 @@ AliMUONSegFactory&  AliMUONSegFactory::operator=(const AliMUONSegFactory& rhs)
 //______________________________________________________________________________
 Bool_t AliMUONSegFactory::IsGeometryDefined(Int_t ichamber)
 {
-// Return true, if det elements for the chamber with the given ichamber Id
-// are defined in geometry (the geometry builder for this chamber was activated)
+/// Return true, if det elements for the chamber with the given ichamber Id
+/// are defined in geometry (the geometry builder for this chamber was activated)
 
   if ( ! fkTransformer ||
        ! fkTransformer->GetModuleTransformer(ichamber, false) )
@@ -174,7 +155,7 @@ AliMUONSegFactory::CreateMpSegmentation(Int_t detElemId, Int_t cath)
 AliMUONVGeometryDESegmentation*  
 AliMUONSegFactory::CreateDESegmentation(Int_t detElemId, Int_t cath)
 { 
-// Create DE segmentation, operating in local DE reference frame
+/// Create DE segmentation, operating in local DE reference frame
 
   // Check detElemId & cath  
   if ( ! AliMpDEManager::IsValid(detElemId, cath, true) ) return 0;
@@ -271,8 +252,8 @@ AliMUONSegFactory::CreateDESegmentation(Int_t detElemId, Int_t cath)
 AliMUONGeometrySegmentation*  
 AliMUONSegFactory::CreateModuleSegmentation(Int_t moduleId, Int_t cath)
 { 
-// Create module segmentation, operating in global reference frame
-// Detection elements are defined via DE names map.
+/// Create module segmentation, operating in global reference frame
+/// Detection elements are defined via DE names map.
 
   // Check cathod & module Id 
   if ( ! AliMpDEManager::IsValidCathod(cath, true) || 
@@ -343,9 +324,7 @@ AliMUONSegFactory::CreateSegmentation(const TString& option)
 //__________________________________________________________________________
 void AliMUONSegFactory::BuildStation3() 
 {
-  //--------------------------------------------------------
-  // Configuration for Chamber TC5/6  (Station 3) ----------          
-  //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+/// Configuration for Chamber TC5/6  (Station 3) ----------          
 
   AliMUONGeometrySegmentation* segmentation[2];
 
@@ -476,10 +455,7 @@ void AliMUONSegFactory::BuildStation3()
 //__________________________________________________________________________
 void AliMUONSegFactory::BuildStation4() 
 {
-  //--------------------------------------------------------
-  // Configuration for Chamber TC7/8  (Station 4) ----------           
-  //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
+/// Configuration for Chamber TC7/8  (Station 4) ----------           
 
   AliMUONGeometrySegmentation* segmentation[2];
 
@@ -682,9 +658,7 @@ void AliMUONSegFactory::BuildStation4()
 //__________________________________________________________________________
 void AliMUONSegFactory::BuildStation5() 
 {       
-  //--------------------------------------------------------
-  // Configuration for Chamber TC9/10  (Station 5) ---------           
-  //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+/// Configuration for Chamber TC9/10  (Station 5) ---------           
 
   AliMUONGeometrySegmentation* segmentation[2];
 
@@ -868,9 +842,7 @@ void AliMUONSegFactory::BuildStation5()
 //__________________________________________________________________________
 void AliMUONSegFactory::BuildStation6() 
 { 
-  //--------------------------------------------------------
-  // Configuration for Trigger stations
-  //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+/// Configuration for Trigger stations
 
  
     AliMUONGeometrySegmentation *chamberSeg[2];
index 595190f..73e2b1c 100644 (file)
@@ -3,7 +3,7 @@
 
 /* $Id$ */
 
-/// \ingroup sim
+/// \ingroup base
 /// \class AliMUONSegFactory
 /// \brief New factory for building segmentations at all levels
 ///
@@ -106,6 +106,7 @@ class AliMUONSegFactory : public  TObject {
   ClassDef(AliMUONSegFactory,0)  // MUON Factory for Chambers and Segmentation
 };
 
+/// Return segmentation
 inline AliMUONSegmentation* AliMUONSegFactory::GetSegmentation() const
 { return fSegmentation; }
 
index 7c99524..6b3830c 100644 (file)
@@ -46,8 +46,9 @@
 #include "AliMUONGeometryEnvelopeStore.h"
 #include "AliMUONConstants.h"
 
+/// \cond CLASSIMP
 ClassImp(AliMUONSlatGeometryBuilder)
-
+/// \endcond
 
 //______________________________________________________________________________
 AliMUONSlatGeometryBuilder::AliMUONSlatGeometryBuilder(AliMUON* muon)
index bd06d6a..192089f 100644 (file)
@@ -4,7 +4,7 @@
 // $Id$
 // Revision of includes 07/05/2004
 //
-/// \ingroup base
+/// \ingroup sim
 /// \class AliMUONSlatGeometryBuilder
 /// \brief MUON Station3 geometry construction class
 ///
index c98b702..7507176 100644 (file)
@@ -42,7 +42,9 @@
 #include "AliMUONSt12QuadrantSegmentation.h"
 #include "AliMUONConstants.h"
 
+/// \cond CLASSIMP
 ClassImp(AliMUONSt12QuadrantSegmentation)
+/// \endcond
 
 //______________________________________________________________________________
 AliMUONSt12QuadrantSegmentation::AliMUONSt12QuadrantSegmentation(
@@ -75,7 +77,7 @@ AliMUONSt12QuadrantSegmentation::AliMUONSt12QuadrantSegmentation(
   fYt(0.),
   fCorrA(0)
 {
-// Normal constructor
+/// Standard constructor
 
   fSectorSegmentation = dynamic_cast<AliMpSectorSegmentation*>(segmentation);
   if (fSectorSegmentation)
@@ -125,23 +127,17 @@ AliMUONSt12QuadrantSegmentation::AliMUONSt12QuadrantSegmentation()
   fIwt(0),
   fXt(0.),
   fYt(0.),
-  fCorrA(0) {
-// Default Constructor
+  fCorrA(0) 
+{
+/// Default Constructor
 
   AliDebug(1, Form("default (empty) ctor this = %p", this));
 }
 
 //______________________________________________________________________________
-AliMUONSt12QuadrantSegmentation::AliMUONSt12QuadrantSegmentation(const AliMUONSt12QuadrantSegmentation& rhs) 
-  : AliMUONVGeometryDESegmentation(rhs)
+AliMUONSt12QuadrantSegmentation::~AliMUONSt12QuadrantSegmentation() 
 {
-// Copy constructor
-  AliFatal("Copy constructor is not implemented.");
-}
-
-//______________________________________________________________________________
-AliMUONSt12QuadrantSegmentation::~AliMUONSt12QuadrantSegmentation() {
-// Destructor
+/// Destructor
 
   AliDebug(1, Form("dtor this = %p", this));
 
@@ -151,32 +147,13 @@ AliMUONSt12QuadrantSegmentation::~AliMUONSt12QuadrantSegmentation() {
 } 
 
 //
-// operators
-//
-
-//______________________________________________________________________________
-AliMUONSt12QuadrantSegmentation& 
-AliMUONSt12QuadrantSegmentation::operator=(const AliMUONSt12QuadrantSegmentation& rhs)
-{
-// Copy operator 
-
-  // check assignement to self
-  if (this == &rhs) return *this;
-
-  AliFatal("Assignment operator is not implemented.");
-    
-  return *this;  
-}
-
-//
 // private methods
 //
 
 //______________________________________________________________________________
 void AliMUONSt12QuadrantSegmentation::UpdateCurrentPadValues(const AliMpPad& pad)
 {
-// Updates current pad values.
-// ---
+/// Updates current pad values.
 
   fIx = pad.GetIndices().GetFirst();
   fIy = pad.GetIndices().GetSecond();
@@ -193,8 +170,7 @@ void AliMUONSt12QuadrantSegmentation::UpdateCurrentPadValues(const AliMpPad& pad
 //______________________________________________________________________________
 void AliMUONSt12QuadrantSegmentation::SetPadSize(Float_t /*p1*/, Float_t /*p2*/)
 {
-// Set pad size Dx*Dy 
-// ---
+/// Set pad size Dx*Dy 
 
   AliFatal("Not uniform pad size.");
 }
@@ -202,8 +178,7 @@ void AliMUONSt12QuadrantSegmentation::SetPadSize(Float_t /*p1*/, Float_t /*p2*/)
 //______________________________________________________________________________
 void AliMUONSt12QuadrantSegmentation::SetDAnod(Float_t d)
 {
-// Set anod pitch
-// ---
+/// Set anod pitch
 
   fWireD = d;
 }
@@ -212,7 +187,7 @@ void AliMUONSt12QuadrantSegmentation::SetDAnod(Float_t d)
 //______________________________________________________________________________
 Bool_t  AliMUONSt12QuadrantSegmentation::HasPad(Float_t x, Float_t y, Float_t /*z*/)
 { 
-// Returns true if a pad exists in the given position
+/// Returns true if a pad exists in the given position
 
   // fSector->GetMotifMap()->Print();
 
@@ -226,7 +201,7 @@ Bool_t  AliMUONSt12QuadrantSegmentation::HasPad(Float_t x, Float_t y, Float_t /*
 //______________________________________________________________________________
 Bool_t  AliMUONSt12QuadrantSegmentation::HasPad(Int_t ix, Int_t iy)
 {
-// Returns true if a pad with given indices exists
+/// Returns true if a pad with given indices exists
 
   AliMpPad pad = fSectorSegmentation->PadByIndices(AliMpIntPair(ix,iy), false);
 
@@ -237,8 +212,8 @@ Bool_t  AliMUONSt12QuadrantSegmentation::HasPad(Int_t ix, Int_t iy)
 //______________________________________________________________________________
 AliMUONGeometryDirection  AliMUONSt12QuadrantSegmentation::GetDirection()
 {
-// Returns the direction with a constant pad size  
-// (Direction or coordinate where the resolution is the best)
+/// Returns the direction with a constant pad size  
+/// (Direction or coordinate where the resolution is the best)
 
   switch ( fSector->GetDirection() ) {
     case kX: return kDirX;
@@ -251,8 +226,8 @@ AliMUONGeometryDirection  AliMUONSt12QuadrantSegmentation::GetDirection()
 const AliMpVSegmentation*  
 AliMUONSt12QuadrantSegmentation::GetMpSegmentation() const
 {
-// Returns the mapping segmentation
-// (provides access to electronics info)
+/// Returns the mapping segmentation
+/// (provides access to electronics info)
 
   return fSectorSegmentation;
 }  
@@ -260,10 +235,9 @@ AliMUONSt12QuadrantSegmentation::GetMpSegmentation() const
 //______________________________________________________________________________
 Float_t AliMUONSt12QuadrantSegmentation::GetAnod(Float_t xhit) const
 {
-// Anod wire coordinate closest to xhit
-// Returns for a hit position xhit the position of the nearest anode wire    
-// From AliMUONSegmentationV01.
-// ---
+/// Anod wire coordinate closest to xhit
+/// Returns for a hit position xhit the position of the nearest anode wire    
+/// From AliMUONSegmentationV01.
 
   Float_t wire= (xhit>0) ? Int_t(xhit/fWireD) + 0.5
                          : Int_t(xhit/fWireD) - 0.5;
@@ -275,8 +249,7 @@ Float_t AliMUONSt12QuadrantSegmentation::GetAnod(Float_t xhit) const
 void  AliMUONSt12QuadrantSegmentation::GetPadI(Float_t x, Float_t y, Float_t /*z*/, 
                                       Int_t& ix, Int_t& iy)
 {                                      
-//  Returns pad coordinates (ix,iy) for given real coordinates (x,y)
-// ---
+///  Returns pad coordinates (ix,iy) for given real coordinates (x,y)
 
   GetPadI(x, y, ix, iy);
 }
@@ -285,9 +258,8 @@ void  AliMUONSt12QuadrantSegmentation::GetPadI(Float_t x, Float_t y, Float_t /*z
 void  AliMUONSt12QuadrantSegmentation::GetPadI(Float_t x, Float_t y,
                                       Int_t& ix, Int_t& iy)
 {                                      
-// Returns pad coordinates (ix,iy) for given real coordinates (x,y)
-// If there is no pad, ix = 0, iy = 0 are returned.
-// ---
+/// Returns pad coordinates (ix,iy) for given real coordinates (x,y)
+/// If there is no pad, ix = 0, iy = 0 are returned.
 
   AliMpPad pad = fSectorSegmentation->PadByPosition(TVector2(x,y), true);
 
@@ -299,8 +271,7 @@ void  AliMUONSt12QuadrantSegmentation::GetPadI(Float_t x, Float_t y,
 void  AliMUONSt12QuadrantSegmentation::GetPadC(Int_t ix, Int_t iy, 
                                       Float_t& x, Float_t& y, Float_t& z)
 {                                      
-// Transform from pad to real coordinates
-// ---
+/// Transform from pad to real coordinates
 
   z = fZ;
   GetPadC(ix, iy, x , y);
@@ -310,9 +281,8 @@ void  AliMUONSt12QuadrantSegmentation::GetPadC(Int_t ix, Int_t iy,
 void  AliMUONSt12QuadrantSegmentation::GetPadC(Int_t ix, Int_t iy, 
                                       Float_t& x, Float_t& y)
 {                                      
-// Transform from pad to real coordinates
-// If there is no pad, x = 0., y = 0. are returned.
-// ---
+/// Transform from pad to real coordinates
+/// If there is no pad, x = 0., y = 0. are returned.
 
   AliMpPad pad = fSectorSegmentation->PadByIndices(AliMpIntPair(ix,iy), true);
 
@@ -324,8 +294,7 @@ void  AliMUONSt12QuadrantSegmentation::GetPadC(Int_t ix, Int_t iy,
 //______________________________________________________________________________
 void AliMUONSt12QuadrantSegmentation::Init(Int_t chamber)
 {
-// Initialize segmentation
-// ---
+/// Initialize segmentation
 
  // find Npx, Npy and save this info
   
@@ -339,8 +308,7 @@ void AliMUONSt12QuadrantSegmentation::Init(Int_t chamber)
 //______________________________________________________________________________
 Float_t AliMUONSt12QuadrantSegmentation::Dpx() const
 {
-// Get pad size in x
-// ---
+/// Get pad size in x
 
   AliFatal( "Not uniform pad size.");
   return 0.;
@@ -349,8 +317,7 @@ Float_t AliMUONSt12QuadrantSegmentation::Dpx() const
 //______________________________________________________________________________
 Float_t AliMUONSt12QuadrantSegmentation::Dpy() const
 {
-// Get pad size in y
-// ---
+/// Get pad size in y
 
   AliFatal("Not uniform pad size.");
   return 0.;
@@ -359,8 +326,7 @@ Float_t AliMUONSt12QuadrantSegmentation::Dpy() const
 //______________________________________________________________________________
 Float_t AliMUONSt12QuadrantSegmentation::Dpx(Int_t isector) const
 {
-// Pad size in x by sector
-// ---
+/// Pad size in x by sector
 
   return fSectorSegmentation->PadDimensions(isector).X()*2.0;
 } 
@@ -368,8 +334,7 @@ Float_t AliMUONSt12QuadrantSegmentation::Dpx(Int_t isector) const
 //______________________________________________________________________________
 Float_t AliMUONSt12QuadrantSegmentation::Dpy(Int_t isector) const
 {
-// Pad size in x, y by Sector 
-// ---
+/// Pad size in x, y by Sector 
 
   return fSectorSegmentation->PadDimensions(isector).Y()*2.0;
 }
@@ -377,9 +342,8 @@ Float_t AliMUONSt12QuadrantSegmentation::Dpy(Int_t isector) const
 //______________________________________________________________________________
 Int_t AliMUONSt12QuadrantSegmentation::Npx() const
 {
-// Maximum number of Pads in x
-// hard coded for the time being
-// ---
+/// Maximum number of Pads in x
+/// hard coded for the time being
 
   return fSectorSegmentation->MaxPadIndexX();
 }
@@ -387,9 +351,8 @@ Int_t AliMUONSt12QuadrantSegmentation::Npx() const
 //______________________________________________________________________________
 Int_t AliMUONSt12QuadrantSegmentation::Npy() const
 {
-// Maximum number of Pads in y
-// hard coded for the time being
-// ---
+/// Maximum number of Pads in y
+/// hard coded for the time being
 
   return fSectorSegmentation->MaxPadIndexY();
 }
@@ -397,11 +360,10 @@ Int_t AliMUONSt12QuadrantSegmentation::Npy() const
 //______________________________________________________________________________
 void  AliMUONSt12QuadrantSegmentation::SetPad(Int_t ix, Int_t iy)
 {
-// Set pad position.
-// Sets virtual pad coordinates, needed for evaluating pad response 
-// outside the tracking program.
-// From AliMUONSegmentationV01.
-// ---
+/// Set pad position.
+/// Sets virtual pad coordinates, needed for evaluating pad response 
+/// outside the tracking program.
+/// From AliMUONSegmentationV01.
 
   GetPadC(ix, iy, fX, fY);
   fZone = Sector(ix, iy);
@@ -410,10 +372,10 @@ void  AliMUONSt12QuadrantSegmentation::SetPad(Int_t ix, Int_t iy)
 //______________________________________________________________________________
 void  AliMUONSt12QuadrantSegmentation::SetHit(Float_t xhit, Float_t yhit, Float_t /*zhit*/)
 {
-// Set hit position
-// Sets virtual hit position, needed for evaluating pad response 
-// outside the tracking program 
-// From AliMUONSegmentationV01.
+/// Set hit position
+/// Sets virtual hit position, needed for evaluating pad response 
+/// outside the tracking program 
+/// From AliMUONSegmentationV01.
 
   fXhit = xhit;
   fYhit = yhit;
@@ -423,8 +385,7 @@ void  AliMUONSt12QuadrantSegmentation::SetHit(Float_t xhit, Float_t yhit, Float_
 void  AliMUONSt12QuadrantSegmentation::FirstPad(Float_t xhit, Float_t yhit, Float_t /*zhit*/, 
                                        Float_t dx, Float_t dy) 
 {                                       
-// Iterate over pads - initialiser
-// ---
+/// Iterate over pads - initialiser
 
   // Sets the current pad to that located in the hit position
  
@@ -453,8 +414,7 @@ void  AliMUONSt12QuadrantSegmentation::FirstPad(Float_t xhit, Float_t yhit, Floa
 //______________________________________________________________________________
 void  AliMUONSt12QuadrantSegmentation::NextPad()
 {
-// Iterate over pads - stepper
-// ---
+/// Iterate over pads - stepper
 
   fSectorIterator->Next();                             
 
@@ -465,8 +425,7 @@ void  AliMUONSt12QuadrantSegmentation::NextPad()
 //______________________________________________________________________________
 Int_t AliMUONSt12QuadrantSegmentation::MorePads()
 {
-// Iterate over pads - condition
-// ---
+/// Iterate over pads - condition
 
   if (fSectorIterator->IsDone())
     return 0;
@@ -478,9 +437,8 @@ Int_t AliMUONSt12QuadrantSegmentation::MorePads()
 Float_t AliMUONSt12QuadrantSegmentation::Distance2AndOffset(Int_t iX, Int_t iY, 
                                                   Float_t x, Float_t y, Int_t* /*dummy*/)
 {                                         
-// Returns the square of the distance between 1 pad
-// labelled by its channel numbers and a coordinate
-// ---
+/// Returns the square of the distance between 1 pad
+/// labelled by its channel numbers and a coordinate
 
   AliMpPad pad = fSectorSegmentation->PadByIndices(AliMpIntPair(iX, iY));
   
@@ -494,9 +452,8 @@ Float_t AliMUONSt12QuadrantSegmentation::Distance2AndOffset(Int_t iX, Int_t iY,
 void AliMUONSt12QuadrantSegmentation::GetNParallelAndOffset(Int_t /*iX*/, Int_t /*iY*/,
                                                   Int_t* /*Nparallel*/, Int_t* /*Offset*/)
 {                                         
-// Number of pads read in parallel and offset to add to x 
-// (specific to LYON, but mandatory for display)
-// ---
+/// Number of pads read in parallel and offset to add to x 
+/// (specific to LYON, but mandatory for display)
 
   AliFatal( "Not yet implemented.");
 }
@@ -507,8 +464,7 @@ void AliMUONSt12QuadrantSegmentation::Neighbours(Int_t iX, Int_t iY,
                                         Int_t* Nlist, 
                                        Int_t Xlist[10], Int_t Ylist[10])
 {                                        
-// Get next neighbours 
-// ---
+/// Get next neighbours 
 
   AliMpPad pad = fSectorSegmentation->PadByIndices(AliMpIntPair(iX,iY));
   Int_t &i = *Nlist;
@@ -525,9 +481,8 @@ void AliMUONSt12QuadrantSegmentation::Neighbours(Int_t iX, Int_t iY,
 //______________________________________________________________________________
 Int_t  AliMUONSt12QuadrantSegmentation::Ix()
 {
-// Current pad cursor during disintegration
-// x, y-coordinate
-// ---
+/// Current pad cursor during disintegration
+/// x, y-coordinate
 
   return fSectorIterator->CurrentItem().GetIndices().GetFirst();
 }
@@ -535,9 +490,8 @@ Int_t  AliMUONSt12QuadrantSegmentation::Ix()
 //______________________________________________________________________________
 Int_t  AliMUONSt12QuadrantSegmentation::Iy()
 {
-// Current pad cursor during disintegration
-// x, y-coordinate
-// ---
+/// Current pad cursor during disintegration
+/// x, y-coordinate
 
   return fSectorIterator->CurrentItem().GetIndices().GetSecond();
 }
@@ -545,8 +499,7 @@ Int_t  AliMUONSt12QuadrantSegmentation::Iy()
 //______________________________________________________________________________
 Int_t  AliMUONSt12QuadrantSegmentation::ISector()
 {
-// Current sector
-// ---
+/// Current sector
 
   return fZone;
 }
@@ -554,8 +507,7 @@ Int_t  AliMUONSt12QuadrantSegmentation::ISector()
 //______________________________________________________________________________
 Int_t AliMUONSt12QuadrantSegmentation::Sector(Int_t ix, Int_t iy)
 {
-// Calculate sector from pad coordinates
-// ---
+/// Calculate sector from pad coordinates
 
   return fSectorSegmentation
            ->Zone(fSectorSegmentation->PadByIndices(AliMpIntPair(ix, iy)));
@@ -564,8 +516,7 @@ Int_t AliMUONSt12QuadrantSegmentation::Sector(Int_t ix, Int_t iy)
 //______________________________________________________________________________
 Int_t AliMUONSt12QuadrantSegmentation::Sector(Float_t x, Float_t y)
 {
-// Calculate sector from pad coordinates
-// ---
+/// Calculate sector from pad coordinates
 
   return fSectorSegmentation
            ->Zone(fSectorSegmentation
@@ -576,8 +527,7 @@ Int_t AliMUONSt12QuadrantSegmentation::Sector(Float_t x, Float_t y)
 void  AliMUONSt12QuadrantSegmentation::IntegrationLimits(Float_t& x1, Float_t& x2,
                                                 Float_t& y1, Float_t& y2)
 {                                                
-// Current integration limits 
-// ---
+/// Current integration limits 
  
   x1 = fXhit - fX - Dpx(fZone)/2.;
   x2 = x1 + Dpx(fZone);
@@ -589,21 +539,21 @@ void  AliMUONSt12QuadrantSegmentation::IntegrationLimits(Float_t& x1, Float_t& x
 //______________________________________________________________________________
 Int_t AliMUONSt12QuadrantSegmentation::SigGenCond(Float_t x, Float_t y, Float_t /*z*/)
 {
-// Signal Generation Condition during Stepping
-//  0: don't generate signal
-//  1: generate signal 
-//  Comments: 
-//
-//  Crossing of pad boundary and mid plane between neighbouring wires is checked.
-//  To correctly simulate the dependence of the spatial resolution on the angle 
-//  of incidence signal must be generated for constant steps on 
-//  the projection of the trajectory along the anode wire.
-//
-//  Signal will be generated if particle crosses pad boundary or
-//  boundary between two wires. 
-//
-// From AliMUONSegmentationV01
-// ---
+/// Signal Generation Condition during Stepping
+/// -  0: don't generate signal
+/// -  1: generate signal 
+///
+///  Comments:                                                                  \n 
+///
+///  Crossing of pad boundary and mid plane between neighbouring wires is checked.
+///  To correctly simulate the dependence of the spatial resolution on the angle 
+///  of incidence signal must be generated for constant steps on 
+///  the projection of the trajectory along the anode wire.
+///
+///  Signal will be generated if particle crosses pad boundary or
+///  boundary between two wires. 
+///
+/// From AliMUONSegmentationV01
 
   Int_t ixt, iyt;
   GetPadI(x, y, ixt, iyt);
@@ -620,10 +570,9 @@ Int_t AliMUONSt12QuadrantSegmentation::SigGenCond(Float_t x, Float_t y, Float_t
 //______________________________________________________________________________
 void  AliMUONSt12QuadrantSegmentation::SigGenInit(Float_t x, Float_t y, Float_t /*z*/)
 {
-// Initialise signal generation at coord (x,y,z)
-// Initialises pad and wire position during stepping.
-// From AliMUONSegmentationV01
-// ---
+/// Initialise signal generation at coord (x,y,z)
+/// Initialises pad and wire position during stepping.
+/// From AliMUONSegmentationV01
 
   fXt = x;
   fYt = y;
@@ -634,11 +583,10 @@ void  AliMUONSt12QuadrantSegmentation::SigGenInit(Float_t x, Float_t y, Float_t
 //______________________________________________________________________________
 void AliMUONSt12QuadrantSegmentation::GiveTestPoints(Int_t& n, Float_t* x, Float_t* y) const
 {                                            
-// Test points for auto calibration
-// Returns test point on the pad plane.
-// Used during determination of the segmoid correction of the COG-method
-// From AliMUONSegmentationV01
-// ---
+/// Test points for auto calibration
+/// Returns test point on the pad plane.
+/// Used during determination of the segmoid correction of the COG-method
+/// From AliMUONSegmentationV01
 
   n=1;
   x[0] = (fRmax+fRmin)/2/TMath::Sqrt(2.);
@@ -648,9 +596,8 @@ void AliMUONSt12QuadrantSegmentation::GiveTestPoints(Int_t& n, Float_t* x, Float
 //______________________________________________________________________________
 void AliMUONSt12QuadrantSegmentation::Draw(const char * /*opt*/)
 {
-// Draw the segmentation zones.
-// (Called from AliMUON::BuildGeometry)
-// ---
+/// Draw the segmentation zones.
+/// (Called from AliMUON::BuildGeometry)
 
   AliWarning("Not yet implemented.");
 }
@@ -658,9 +605,8 @@ void AliMUONSt12QuadrantSegmentation::Draw(const char * /*opt*/)
 //______________________________________________________________________________
 void AliMUONSt12QuadrantSegmentation::SetCorrFunc(Int_t isec, TF1* func)
 {
-// Set the correction function.
-// From AliMUONSegmentationV01
-// ---
+/// Set the correction function.
+/// From AliMUONSegmentationV01
 
   fCorrA->AddAt(func, isec);
 }
@@ -668,9 +614,8 @@ void AliMUONSt12QuadrantSegmentation::SetCorrFunc(Int_t isec, TF1* func)
 //______________________________________________________________________________
 TF1* AliMUONSt12QuadrantSegmentation::CorrFunc(Int_t isec) const
 {
-// Get the correction Function.
-// From AliMUONSegmentationV01
-// ---
+/// Get the correction Function.
+/// From AliMUONSegmentationV01
 
   return (TF1*) fCorrA->At(isec);
 } 
index 4c7b05e..4526b04 100644 (file)
@@ -9,14 +9,10 @@
 
 /// \ingroup base
 /// \class AliMUONSt12QuadrantSegmentation
-/// \brief Segmentation for MUON quadrants of stations 1 and 2
-
-// Class AliMUONSt12QuadrantSegmentation
-// -------------------------------------
-// Segmentation for MUON quadrants of stations 1 and 2 using 
-// the mapping package
-//
-// Author: Ivana Hrivnacova, IPN Orsay
+/// \brief Segmentation for MUON quadrants of stations 1 and 2 using 
+/// the mapping package
+///
+/// \author Ivana Hrivnacova, IPN Orsay
 
 #include "AliMpStationType.h"
 #include "AliMpPlaneType.h"
index edc2c61..8286242 100644 (file)
 #include "AliMUONGeometryModule.h"
 #include "AliMUONGeometryEnvelopeStore.h"
 
+/// \cond CLASSIMP
 ClassImp(AliMUONSt1GeometryBuilder)
+/// \endcond
 
 //______________________________________________________________________________
 AliMUONSt1GeometryBuilder::AliMUONSt1GeometryBuilder(AliMUON* muon)
  : AliMUONVGeometryBuilder(0, 1),
    fMUON(muon)
 {
-// Standard constructor
+/// Standard constructor
 
 }
 
@@ -49,7 +51,7 @@ AliMUONSt1GeometryBuilder::AliMUONSt1GeometryBuilder()
  : AliMUONVGeometryBuilder(),
    fMUON(0)
 {
-// Default constructor
+/// Default constructor
 }
 
 
@@ -57,21 +59,22 @@ AliMUONSt1GeometryBuilder::AliMUONSt1GeometryBuilder()
 AliMUONSt1GeometryBuilder::AliMUONSt1GeometryBuilder(const AliMUONSt1GeometryBuilder& rhs)
   : AliMUONVGeometryBuilder(rhs)
 {
-// Protected copy constructor
+/// Protected copy constructor
 
   AliFatal("Copy constructor is not implemented.");
 }
 
 //______________________________________________________________________________
-AliMUONSt1GeometryBuilder::~AliMUONSt1GeometryBuilder() {
-//
+AliMUONSt1GeometryBuilder::~AliMUONSt1GeometryBuilder() 
+{
+/// Destructor
 }
 
 //______________________________________________________________________________
 AliMUONSt1GeometryBuilder& 
 AliMUONSt1GeometryBuilder::operator = (const AliMUONSt1GeometryBuilder& rhs) 
 {
-// Protected assignement operator
+/// Protected assignement operator
 
   // check assignement to self
   if (this == &rhs) return *this;
@@ -88,8 +91,7 @@ AliMUONSt1GeometryBuilder::operator = (const AliMUONSt1GeometryBuilder& rhs)
 //______________________________________________________________________________
 void AliMUONSt1GeometryBuilder::CreateGeometry()
 {
-// From AliMUONv1::CreateGeometry()
-// ---
+/// From AliMUONv1::CreateGeometry()
 
 //********************************************************************
 //                            Station 1                             **
@@ -291,8 +293,7 @@ void AliMUONSt1GeometryBuilder::CreateGeometry()
 //______________________________________________________________________________
 void AliMUONSt1GeometryBuilder::SetTransformations()
 {
-// Defines the transformations for the station2 chambers.
-// ---
+/// Define the transformations for the station2 chambers.
 
   Double_t zpos1= - AliMUONConstants::DefaultChamberZ(0); 
   SetTranslation(0, TGeoTranslation(0., 0., zpos1));
@@ -304,8 +305,7 @@ void AliMUONSt1GeometryBuilder::SetTransformations()
 //______________________________________________________________________________
 void AliMUONSt1GeometryBuilder::SetSensitiveVolumes()
 {
-// Defines the sensitive volumes for station1 chambers.
-// ---
+/// Define the sensitive volumes for station1 chambers.
 
   GetGeometry(0)->SetSensitiveVolume("S01G");
   GetGeometry(1)->SetSensitiveVolume("S02G");
index da93d04..b2d666a 100644 (file)
@@ -4,7 +4,7 @@
 // $Id$
 // Revision of includes 07/05/2004
 
-/// \ingroup base
+/// \ingroup sim
 /// \class AliMUONSt1GeometryBuilder
 /// \brief MUON Station1 coarse geometry construction class
 ///
index eed1e39..31d0d6d 100644 (file)
   #include "TArrayI.h"
 #endif
 
+/// \cond CLASSIMP
+ClassImp(AliMUONSt1GeometryBuilderV2)
+/// \endcond
+
 // Thickness Constants
 const GReal_t AliMUONSt1GeometryBuilderV2::fgkHzPadPlane=0.0148/2.;     //Pad plane
 const GReal_t AliMUONSt1GeometryBuilderV2::fgkHzFoam = 2.503/2.;        //Foam of mechanicalplane
@@ -124,13 +128,13 @@ const Int_t AliMUONSt1GeometryBuilderV2::fgkFoamBoxNameOffset=200;
 const Int_t AliMUONSt1GeometryBuilderV2::fgkFR4BoxNameOffset=400; 
 const Int_t AliMUONSt1GeometryBuilderV2::fgkDaughterCopyNoOffset=1000;
 
-ClassImp(AliMUONSt1GeometryBuilderV2)
-
 //______________________________________________________________________________
 AliMUONSt1GeometryBuilderV2::AliMUONSt1GeometryBuilderV2(AliMUON* muon)
   : AliMUONVGeometryBuilder(0, 1),
     fMUON(muon)
 {
+/// Standard constructor
+
    // set path to mapping data files
    if (! gSystem->Getenv("MINSTALL")) {    
      TString dirPath = gSystem->Getenv("ALICE_ROOT");
@@ -148,15 +152,14 @@ AliMUONSt1GeometryBuilderV2::AliMUONSt1GeometryBuilderV2()
   : AliMUONVGeometryBuilder(),
     fMUON(0)
 {
-// Default Constructor
-// --
+/// Default Constructor
 }
  
 //______________________________________________________________________________
 AliMUONSt1GeometryBuilderV2::AliMUONSt1GeometryBuilderV2(const AliMUONSt1GeometryBuilderV2& rhs)
   : AliMUONVGeometryBuilder(rhs)
 {
-// Dummy copy constructor
+/// Dummy copy constructor
 
  AliFatal("Copy constructor is not implemented.");
 }
@@ -164,7 +167,7 @@ AliMUONSt1GeometryBuilderV2::AliMUONSt1GeometryBuilderV2(const AliMUONSt1Geometr
 //______________________________________________________________________________
 AliMUONSt1GeometryBuilderV2::~AliMUONSt1GeometryBuilderV2()
 {
-// Destructor
+/// Destructor
 }
 
 
@@ -172,6 +175,8 @@ AliMUONSt1GeometryBuilderV2::~AliMUONSt1GeometryBuilderV2()
 AliMUONSt1GeometryBuilderV2& 
 AliMUONSt1GeometryBuilderV2::operator = (const AliMUONSt1GeometryBuilderV2& rhs) 
 {
+/// Assignment operator
+
   // check assignement to self
   if (this == &rhs) return *this;
 
@@ -188,8 +193,7 @@ AliMUONSt1GeometryBuilderV2::operator = (const AliMUONSt1GeometryBuilderV2& rhs)
 TString 
 AliMUONSt1GeometryBuilderV2::QuadrantEnvelopeName(Int_t chamber, Int_t quadrant) const
 { 
-// Generate unique envelope name from chamber Id and quadrant number
-// ---
+/// Generate unique envelope name from chamber Id and quadrant number
 
   return Form("%s%d", Form("%s%d",fgkQuadrantEnvelopeName,chamber), quadrant); 
 }
@@ -197,8 +201,8 @@ AliMUONSt1GeometryBuilderV2::QuadrantEnvelopeName(Int_t chamber, Int_t quadrant)
 //______________________________________________________________________________
 void AliMUONSt1GeometryBuilderV2::CreateHole()
 {
-// Create all the elements found inside a foam hole
-// --
+/// Create all the elements found inside a foam hole
+
   Int_t* idtmed = fMUON->GetIdtmed()->GetArray()-1099;
   Int_t idAir  = idtmed[1100];      // medium 1
   //Int_t idCopper  = idtmed[1109]; // medium 10 = copper 
@@ -234,8 +238,8 @@ void AliMUONSt1GeometryBuilderV2::CreateHole()
 //______________________________________________________________________________
 void AliMUONSt1GeometryBuilderV2::CreateDaughterBoard()
 {
-// Create all the elements in a daughter board
-// --
+/// Create all the elements in a daughter board
+
   Int_t* idtmed = fMUON->GetIdtmed()->GetArray()-1099;
   Int_t idAir  = idtmed[1100]; // medium 1
   //Int_t idCopper  = idtmed[1109]; // medium 10 = copper
@@ -282,9 +286,8 @@ void AliMUONSt1GeometryBuilderV2::CreateDaughterBoard()
 //______________________________________________________________________________
 void AliMUONSt1GeometryBuilderV2::CreateInnerLayers()
 {
-// Create the layer of sensitive volumes with gas
-// and the copper layer.
-// --
+/// Create the layer of sensitive volumes with gas
+/// and the copper layer.
 
 // Gas Medium
   Int_t* idtmed = fMUON->GetIdtmed()->GetArray()-1099; 
@@ -500,9 +503,8 @@ void AliMUONSt1GeometryBuilderV2::CreateInnerLayers()
 //______________________________________________________________________________
 void AliMUONSt1GeometryBuilderV2::CreateQuadrant(Int_t chamber)
 {
-// create the quadrant (bending and non-bending planes)
-// for the given chamber
-// --
+/// Create the quadrant (bending and non-bending planes)
+/// for the given chamber
 
   CreateFrame(chamber);
 
@@ -579,8 +581,7 @@ void AliMUONSt1GeometryBuilderV2::CreateFoamBox(
                                         Int_t segNumber,
                                         const  TVector2& dimensions)
 {
-// create all the elements in the copper plane
-// --
+/// Create all the elements in the copper plane
 
   Int_t* idtmed = fMUON->GetIdtmed()->GetArray()-1099;
   Int_t idAir  = idtmed[1100]; // medium 1
@@ -625,10 +626,9 @@ void AliMUONSt1GeometryBuilderV2::CreatePlaneSegment(Int_t segNumber,
                                     const  TVector2& dimensions,
                                    Int_t nofHoles)
 {
-// Create a segment of a plane (this includes a foam layer, 
-// holes in the foam to feed the kaptons through, kapton connectors
-// and the mother board.)
-// --
+/// Create a segment of a plane (this includes a foam layer, 
+/// holes in the foam to feed the kaptons through, kapton connectors
+/// and the mother board.)
   
   CreateFoamBox(segNumber,dimensions);
 
@@ -645,34 +645,32 @@ void AliMUONSt1GeometryBuilderV2::CreatePlaneSegment(Int_t segNumber,
 //______________________________________________________________________________
 void AliMUONSt1GeometryBuilderV2::CreateFrame(Int_t chamber)
 {
-// Create the non-sensitive elements of the frame for the  <chamber>
-//
-// 
-// Model and notation:
-//
-// The Quadrant volume name starts with SQ
-// The volume segments are numbered 00 to XX.
-//
-//                              OutTopFrame
-//                               (SQ02-16) 
-//                              ------------  
-//             OutEdgeFrame   /              |
-//             (SQ17-24)     /               |  InVFrame (SQ00-01) 
-//                          /                |
-//                          |                |   
-//               OutVFrame  |            _- - 
-//               (SQ25-39)  |           |   InArcFrame (SQ42-45)
-//                          |           |
-//                          -------------
-//                        InHFrame (SQ40-41)
-//                          
-//
-// 06 February 2003 - Overlapping volumes resolved.
-// One quarter chamber is comprised of three TUBS volumes: SQMx, SQNx, and SQFx,
-// where SQMx is the Quadrant Middle layer for chamber <x> ( posZ in [-3.25,3.25]),
-// SQNx is the Quadrant Near side layer for chamber <x> ( posZ in [-6.25,3-.25) ), and
-// SQFx is the Quadrant Far side layer for chamber <x> ( posZ in (3.25,6.25] ).
-//---
+/// Create the non-sensitive elements of the frame for the \a chamber
+///
+/// Model and notation:                                                     \n
+///                                                                         \n
+/// The Quadrant volume name starts with SQ                                 \n
+/// The volume segments are numbered 00 to XX                               \n
+///                                                                         \n
+///                              OutTopFrame                                \n
+///                               (SQ02-16)                                 \n 
+///                              ------------                               \n
+///             OutEdgeFrame   /              |                             \n
+///             (SQ17-24)     /               |  InVFrame (SQ00-01)         \n 
+///                          /                |                             \n
+///                          |                |                             \n 
+///               OutVFrame  |            _- -                              \n
+///               (SQ25-39)  |           |   InArcFrame (SQ42-45)           \n
+///                          |           |                                  \n 
+///                          -------------                                  \n 
+///                        InHFrame (SQ40-41)                               \n 
+///                                                                         \n                         
+///                                                                         \n
+/// 06 February 2003 - Overlapping volumes resolved.                        \n
+/// One quarter chamber is comprised of three TUBS volumes: SQMx, SQNx, and SQFx,
+/// where SQMx is the Quadrant Middle layer for chamber \a chamber ( posZ in [-3.25,3.25]),
+/// SQNx is the Quadrant Near side layer for chamber \a chamber ( posZ in [-6.25,3-.25) ), and
+/// SQFx is the Quadrant Far side layer for chamber \a chamber ( posZ in (3.25,6.25] ).
 
   const Float_t kNearFarLHC=2.4;    // Near and Far TUBS Origin wrt LHC Origin
 
@@ -2064,8 +2062,7 @@ void AliMUONSt1GeometryBuilderV2::CreateFrame(Int_t chamber)
 //______________________________________________________________________________
 void AliMUONSt1GeometryBuilderV2::PlaceInnerLayers(Int_t chamber)
 {
-// Place the gas and copper layers for the specified chamber.
-// --
+/// Place the gas and copper layers for the specified chamber.
 
 // Rotation Matrices 
   Int_t rot1, rot2, rot3, rot4;   
@@ -2164,9 +2161,10 @@ void AliMUONSt1GeometryBuilderV2::PlaceInnerLayers(Int_t chamber)
 void AliMUONSt1GeometryBuilderV2::PlaceSector(AliMpSector* sector,SpecialMap specialMap, 
                             const TVector3& where, Bool_t reflectZ, Int_t chamber)
 {
-// Place all the segments in the mother volume, at the position defined
-// by the sector's data.
-// --
+/// Place all the segments in the mother volume, at the position defined
+/// by the sector's data.
+
+/// \cond SKIP
 
   static Int_t segNum=1;
   Int_t sgn;
@@ -2303,13 +2301,13 @@ void AliMUONSt1GeometryBuilderV2::PlaceSector(AliMpSector* sector,SpecialMap spe
       }// end of special motif case
     }
   }
+/// \endcond
 } 
 
 //______________________________________________________________________________
 TString AliMUONSt1GeometryBuilderV2::GasVolumeName(const TString& name, Int_t chamber) const
 {
-// Inserts the chamber number into the name.
-// ---
+/// Insert the chamber number into the name.
 
   TString newString(name);
  
@@ -2321,43 +2319,6 @@ TString AliMUONSt1GeometryBuilderV2::GasVolumeName(const TString& name, Int_t ch
   return newString;
 }
 
-/*
-//______________________________________________________________________________
-Bool_t AliMUONSt1GeometryBuilderV2::IsInChamber(Int_t ich, Int_t volGid) const
-{
-// True if volume <volGid> is part of the sensitive 
-// volumes of chamber <ich> 
-// ---
-  for (Int_t i = 0; i < fChamberV2[ich]->GetSize(); i++) {
-      if (fChamberV2[ich]->At(i) == volGid) return kTRUE;
-  }
-  return kFALSE;
-}
-*/
-
-//
-// protected methods
-//
-
-/*
-//______________________________________________________________________________
-Int_t  AliMUONSt1GeometryBuilderV2::GetChamberId(Int_t volId) const
-{
-// Check if the volume with specified  volId is a sensitive volume (gas) 
-// of some chamber and returns the chamber number;
-// if not sensitive volume - return 0.
-// ---
-
-  for (Int_t i = 1; i <=2; i++) 
-     if (IsInChamber(i-1,volId)) return i;
-  
-  for (Int_t i = 3; i <= AliMUONConstants::NCh(); i++)
-    if (volId==((AliMUONChamber*)(*fChambers)[i-1])->GetGid()) return i;
-
-  return 0;
-}
-*/
-
 //
 // public methods
 //
@@ -2365,6 +2326,8 @@ Int_t  AliMUONSt1GeometryBuilderV2::GetChamberId(Int_t volId) const
 //______________________________________________________________________________
 void AliMUONSt1GeometryBuilderV2::CreateMaterials()
 {
+/// Define materials specific to station 1
+
 // Materials and medias defined in MUONv1:
 //
 //  AliMaterial( 9, "ALUMINIUM$", 26.98, 13., 2.7, 8.9, 37.2);
@@ -2504,8 +2467,8 @@ void AliMUONSt1GeometryBuilderV2::CreateMaterials()
 //______________________________________________________________________________
 void AliMUONSt1GeometryBuilderV2::CreateGeometry()
 {
-// Create the detailed GEANT geometry for the dimuon arm station1
-// --
+/// Create the detailed GEANT geometry for the dimuon arm station1
+
   AliDebug(1,"Called");
 
   // Define chamber volumes as virtual
@@ -2623,8 +2586,7 @@ void AliMUONSt1GeometryBuilderV2::CreateGeometry()
 //______________________________________________________________________________
 void AliMUONSt1GeometryBuilderV2::SetTransformations() 
 {
-// Defines the transformations for the station2 chambers.
-// ---
+/// Define the transformations for the station2 chambers.
 
   if (gAlice->GetModule("SHIL")) {
     SetMotherVolume(0, "YOUT1");
@@ -2644,8 +2606,7 @@ void AliMUONSt1GeometryBuilderV2::SetTransformations()
 //______________________________________________________________________________
 void AliMUONSt1GeometryBuilderV2::SetSensitiveVolumes()
 {
-// Defines the sensitive volumes for station2 chambers.
-// ---
+/// Define the sensitive volumes for station2 chambers.
 
   GetGeometry(0)->SetSensitiveVolume("SA1G");
   GetGeometry(0)->SetSensitiveVolume("SB1G");
index 93c5a47..8d3d017 100644 (file)
@@ -4,7 +4,7 @@
 // $Id$
 // Revision of includes 07/05/2004
 //
-/// \ingroup base
+/// \ingroup sim
 /// \class AliMUONSt1GeometryBuilderV2
 /// \brief MUON Station1 detailed geometry construction class
 ///
@@ -145,12 +145,9 @@ class AliMUONSt1GeometryBuilderV2 : public AliMUONVGeometryBuilder
     TString FR4BoxName(Int_t segNumber) const;
     TString GasVolumeName(const TString& name, Int_t chamber) const;
 
-    void   AddChamberGid(Int_t id,Int_t volName,Int_t idx);
-    //Bool_t IsInChamber(Int_t ich, Int_t volGid) const;   
-
-    GReal_t TotalHzPlane() const ;         // Total mechanical plane half Size
-    GReal_t TotalHzDaughter() const ;      // Total daughter plane half Size
-    GReal_t TotalHz() const ;              // Total plane half Size
+    GReal_t TotalHzPlane() const ; 
+    GReal_t TotalHzDaughter() const ;
+    GReal_t TotalHz() const ;
        
     // Data members
     //
@@ -164,31 +161,40 @@ class AliMUONSt1GeometryBuilderV2 : public AliMUONVGeometryBuilder
 
 // inline functions
 
+/// Return total mechanical plane half Size
 inline GReal_t AliMUONSt1GeometryBuilderV2::TotalHzPlane() const 
 //{ return fgkHzPadPlane + fgkHzFoam + fgkHzFR4; }
 { return fgkHzFoam + fgkHzFR4; }
 
+/// Return total daughter plane half Size
 inline GReal_t AliMUONSt1GeometryBuilderV2::TotalHzDaughter() const 
 { return fgkHzBergPlastic + fgkHzDaughter; }
 
+/// Return total plane half Size
 inline GReal_t AliMUONSt1GeometryBuilderV2::TotalHz() const 
 { return TotalHzPlane() + TotalHzDaughter(); }
 
+/// Return middle quadrant layer name for chamber \a chamber
 inline TString AliMUONSt1GeometryBuilderV2::QuadrantMLayerName(Int_t chamber) const
 { return Form("%s%d",fgkQuadrantMLayerName,chamber); }
 
+/// Return nearer quadrant layer name for chamber \a chamber
 inline TString AliMUONSt1GeometryBuilderV2::QuadrantNLayerName(Int_t chamber) const
 { return Form("%s%d",fgkQuadrantNLayerName,chamber); }
 
+/// Return farther quadrant layer name for chamber \a chamber
 inline TString AliMUONSt1GeometryBuilderV2::QuadrantFLayerName(Int_t chamber) const
 { return Form("%s%d",fgkQuadrantFLayerName,chamber); }
 
+/// Return plane segment name for segment \a segNumber
 inline TString AliMUONSt1GeometryBuilderV2::PlaneSegmentName(Int_t segNumber) const
 { return Form("S%.3d", segNumber); }
 
+/// Return foam box name for segment \a segNumber
 inline TString AliMUONSt1GeometryBuilderV2::FoamBoxName(Int_t segNumber) const
 { return Form("S%.3d", segNumber + fgkFoamBoxNameOffset); }
 
+/// Return FR4 box name for segment \a segNumber
 inline TString AliMUONSt1GeometryBuilderV2::FR4BoxName(Int_t segNumber) const
 { return Form("S%.3d", segNumber + fgkFR4BoxNameOffset); }
 
index 78f8912..c4e7834 100644 (file)
@@ -32,7 +32,7 @@ AliMUONSt1SpecialMotif::AliMUONSt1SpecialMotif(const TVector2& delta,
   :fDelta(delta),
    fRotAngle(rotAngle)
 {
-// normal constructor
+/// Standard constructor
 }
 
 //__________________________________________________________________________
@@ -40,7 +40,7 @@ AliMUONSt1SpecialMotif::AliMUONSt1SpecialMotif()
   :fDelta(TVector2(0.,0.)),
    fRotAngle(0.)
 {
-// default constructor
+/// Default constructor
 }
 
 //__________________________________________________________________________
@@ -49,12 +49,12 @@ AliMUONSt1SpecialMotif::AliMUONSt1SpecialMotif(const AliMUONSt1SpecialMotif& src
    fRotAngle(src.fRotAngle)
   
 {
-// copy constructor
+/// Copy constructor
 }
 
 //__________________________________________________________________________
 AliMUONSt1SpecialMotif::~AliMUONSt1SpecialMotif()
 {
-// destructor
+/// Destructor
 }
 
index 83c32c9..d16f5d3 100644 (file)
@@ -25,8 +25,11 @@ class AliMUONSt1SpecialMotif
     AliMUONSt1SpecialMotif(const TVector2& delta,Double_t rotAngle=0.);
     AliMUONSt1SpecialMotif(const AliMUONSt1SpecialMotif& src);
     virtual ~AliMUONSt1SpecialMotif();
-    
+             
+            /// Return offset
     TVector2 GetDelta()    const {return fDelta;}
+    
+             /// Return rotation angle in degrees (0 = vertical) 
     Double_t GetRotAngle() const {return fRotAngle;}
 
   private:
index 1074a06..81c1926 100644 (file)
@@ -32,7 +32,9 @@
 #include "AliMUONGeometryModule.h"
 #include "AliMUONGeometryEnvelopeStore.h"
 
+/// \cond CLASSIMP
 ClassImp(AliMUONSt2GeometryBuilder)
+/// \endcond
 
 //______________________________________________________________________________
 AliMUONSt2GeometryBuilder::AliMUONSt2GeometryBuilder(AliMUON* muon)
index e360e0b..b462281 100644 (file)
@@ -4,7 +4,7 @@
 // $Id$
 // Revision of includes 07/05/2004
 //
-/// \ingroup base
+/// \ingroup sim
 /// \class AliMUONSt2GeometryBuilder
 /// \brief MUON Station2 coarse geometry construction class
 ///
index bcf50ec..059944c 100644 (file)
 #include "AliMUONConstants.h"
 
 #define PI 3.14159
+
+/// \cond CLASSIMP
 ClassImp(AliMUONSt2GeometryBuilderV2)
+/// \endcond
 
 //______________________________________________________________________________
 AliMUONSt2GeometryBuilderV2::AliMUONSt2GeometryBuilderV2(AliMUON* muon)
index 7764879..4b6600b 100644 (file)
@@ -4,7 +4,7 @@
 // $Id$
 // Revision of includes 07/05/2004
 //
-/// \ingroup base
+/// \ingroup sim
 /// \class AliMUONSt2GeometryBuilderV2
 /// \brief MUON Station2 detailed geometry construction class
 ///
index ff892e8..86be37b 100644 (file)
 
 /* $Id$ */
 
-//*********************************************************
-//  Segmentation classes for slat modules          
-//  This class works with local coordinates
-//  of the slats via the class AliMUONGeometrySegmentation
-//  This class contains the size of the slats and the
-//  and the differents PCB densities. 
-//  (from old AliMUONSegmentationSlatModule)
-//  Gines, Subatech, Nov04
-//  Add electronics mapping
-//  Christian, Subatech, Mai 05
-//*********************************************************
+/// \class AliMUONSt345SlatSegmentation
+/// \brief Segmentation classes for slat modules          
+///
+/// This class works with local coordinates
+/// of the slats via the class AliMUONGeometrySegmentation
+/// This class contains the size of the slats and the
+/// and the differents PCB densities. 
+/// (from old AliMUONSegmentationSlatModule)
+///
+/// Add electronics mapping - Christian, Subatech, Mai 05
+///
+/// \author Gines Martinez, Subatech, Nov04
 
 #include <TArrayI.h>
 #include <TArrayF.h>
 #include "AliMUONSt345SlatSegmentation.h"
 #include "AliLog.h"
 
+/// \cond CLASSIMP
 ClassImp(AliMUONSt345SlatSegmentation)
-
+/// \endcond
 
 AliMUONSt345SlatSegmentation::AliMUONSt345SlatSegmentation() 
   :     AliMUONVGeometryDESegmentation(),
@@ -60,7 +62,7 @@ AliMUONSt345SlatSegmentation::AliMUONSt345SlatSegmentation()
         fIymax(0),
        fInitDone(kFALSE)
 {
-  // default constructor
+/// Default constructor
        AliDebug(1,Form("this=%p default (empty) ctor",this));
 }
 
@@ -91,7 +93,8 @@ AliMUONSt345SlatSegmentation::AliMUONSt345SlatSegmentation(Bool_t bending)
        fInitDone(kFALSE)
 
 {
-  // Non default constructor
+/// Standard constructor
+
   fNsec = 4;  // 4 sector densities at most per slat 
   fNDiv = new TArrayI(fNsec);      
   fDpxD = new TArrayF(fNsec);      
@@ -103,33 +106,9 @@ AliMUONSt345SlatSegmentation::AliMUONSt345SlatSegmentation(Bool_t bending)
 
 }
 //----------------------------------------------------------------------
-AliMUONSt345SlatSegmentation::AliMUONSt345SlatSegmentation(const AliMUONSt345SlatSegmentation& rhs) 
-:       AliMUONVGeometryDESegmentation(rhs),
-       fBending(0),
-       fId(0),
-       fDpx(0),
-       fDpy(0),
-       fNpx(999999),
-       fNpy(999999),
-       fWireD(0.25),
-       fXhit(0.),
-       fYhit(0.),
-       fIx(0),
-       fIy(0),
-       fX(0.),
-       fY(0.),
-       fIxmin(0),
-       fIxmax(0),
-       fIymin(0),
-       fIymax(0)
-{
-// Copy constructor
-               AliFatal("Not implemented");
-}
-//----------------------------------------------------------------------
 AliMUONSt345SlatSegmentation::~AliMUONSt345SlatSegmentation() 
 {
-  // Destructor
+/// Destructor
 
   AliDebug(1, Form("dtor this = %p", this));
 
@@ -137,21 +116,13 @@ AliMUONSt345SlatSegmentation::~AliMUONSt345SlatSegmentation()
   delete fDpxD;
   delete fDpyD;
 }
-//----------------------------------------------------------------------
-AliMUONSt345SlatSegmentation& AliMUONSt345SlatSegmentation::operator=(const AliMUONSt345SlatSegmentation& rhs)
-{
-  // Protected assignement operator
-  if (this == &rhs) return *this;
-  AliFatal("Not implemented.");
-  return *this;  
-}
-
 
 //------------------------------------------------------------------------
 Float_t AliMUONSt345SlatSegmentation::Distance2AndOffset(Int_t iX, Int_t iY, Float_t X, Float_t Y, Int_t * /*dummy*/)
 {
-  // Returns the square of the distance between 1 pad
-  // labelled by its Channel numbers and a coordinate
+/// Returns the square of the distance between 1 pad
+/// labelled by its Channel numbers and a coordinate
+
   Float_t x,y;
   GetPadC(iX,iY,x,y);
   return (x-X)*(x-X) + (y-Y)*(y-Y);
@@ -159,20 +130,23 @@ Float_t AliMUONSt345SlatSegmentation::Distance2AndOffset(Int_t iX, Int_t iY, Flo
 //____________________________________________________________________________
 Float_t AliMUONSt345SlatSegmentation::Dpx(Int_t isec) const
 {
-  // Return x-strip width
+/// Return x-strip width
+
   return (*fDpxD)[isec];
 } 
 
 //____________________________________________________________________________
 Float_t AliMUONSt345SlatSegmentation::Dpy(Int_t  isec) const
 {
-  // Return y-strip width
+/// Return y-strip width
+
   return (*fDpyD)[isec];
 }
 //_____________________________________________________________________________
 Float_t AliMUONSt345SlatSegmentation::GetAnod(Float_t xhit) const
 {
-  // Returns for a hit position xhit the position of the nearest anode wire    
+/// Returns for a hit position xhit the position of the nearest anode wire    
+
   Float_t wire= (xhit>0)? Int_t(xhit/fWireD)+0.5:Int_t(xhit/fWireD)-0.5;
   return fWireD*wire;
 }
@@ -180,7 +154,7 @@ Float_t AliMUONSt345SlatSegmentation::GetAnod(Float_t xhit) const
 //_____________________________________________________________________________
 Bool_t AliMUONSt345SlatSegmentation::HasPad(Int_t ix, Int_t iy)
 {
-// Return true if pas with given indices exists
+/// Return true if pas with given indices exists
 
        if ( ix < 1 || ix > Npx() || iy < 1 || iy > Npy() )
        {
@@ -201,7 +175,7 @@ Bool_t AliMUONSt345SlatSegmentation::HasPad(Int_t ix, Int_t iy)
 //--------------------------------------------------------------------------------
 void AliMUONSt345SlatSegmentation::GetPadC(Int_t ix, Int_t iy, Float_t &x, Float_t &y) 
 {
-    //  Returns real coordinates (x,y) for given pad coordinates (ix,iy)
+/// Returns real coordinates (x,y) for given pad coordinates (ix,iy)
 
   if (ix < 1 || ix > Npx() || iy < 1 || iy > Npy() ){
     AliWarning(Form("ix %d or iy %d out of boundaries: Npx=%d and Npy=%d",ix, iy, Npx(), Npy()));
@@ -230,7 +204,7 @@ void AliMUONSt345SlatSegmentation::GetPadC(Int_t ix, Int_t iy, Float_t &x, Float
 //_____________________________________________________________________________
 void AliMUONSt345SlatSegmentation::GetPadI(Float_t x, Float_t y, Int_t &ix, Int_t &iy) 
 {
-//  Returns pad coordinates (ix,iy) for given real coordinates (x,y)
+///  Returns pad coordinates (ix,iy) for given real coordinates (x,y)
 
   //  Find sector isec    
   Int_t isec=-1;
@@ -257,7 +231,7 @@ void AliMUONSt345SlatSegmentation::GetPadI(Float_t x, Float_t y, Int_t &ix, Int_
 //-------------------------------------------------------------------------
 void AliMUONSt345SlatSegmentation::GetPadI(Float_t x, Float_t y , Float_t /*z*/, Int_t &ix, Int_t &iy)
 {
-//  Returns pad coordinates (ix,iy) for given real coordinates (x,y)
+/// Returns pad coordinates (ix,iy) for given real coordinates (x,y)
 
   GetPadI(x, y, ix, iy);
 }
@@ -266,10 +240,10 @@ void AliMUONSt345SlatSegmentation::GetPadI(Float_t x, Float_t y , Float_t /*z*/,
 //_______________________________________________________________
 void AliMUONSt345SlatSegmentation::SetPadDivision(Int_t ndiv[4])
 {
-  // Defines the pad size perp. to the anode wire (y) for different sectors. 
-  // Pad sizes are defined as integral fractions ndiv of a basis pad size
-  // fDpx
-  // 
+/// Defines the pad size perp. to the anode wire (y) for different sectors. 
+/// Pad sizes are defined as integral fractions ndiv of a basis pad size
+/// fDpx
   for (Int_t i=0; i<4; i++) {
     (*fNDiv)[i]=ndiv[i];
   }
@@ -278,17 +252,17 @@ void AliMUONSt345SlatSegmentation::SetPadDivision(Int_t ndiv[4])
 //____________________________________________________________________________
 void AliMUONSt345SlatSegmentation::SetPadSize(Float_t p1, Float_t p2)
 {
-  //  Sets the padsize 
+/// Sets the padsize 
+
   fDpx=p1;
   fDpy=p2;
 }
 //_______________________________________________________________          
 void AliMUONSt345SlatSegmentation::SetPcbBoards(Int_t n[4])
 {
-  //
-  // Set PcbBoard segmentation zones for each density
-  // n[0] slat type parameter
-  // n[1] PcbBoards for highest density sector fNDiv[1] etc ...
+/// Set PcbBoard segmentation zones for each density
+/// n[0] slat type parameter
+/// n[1] PcbBoards for highest density sector fNDiv[1] etc ...
 
   fRtype = n[0];
   n[0] = 0;
@@ -298,17 +272,17 @@ void AliMUONSt345SlatSegmentation::SetPcbBoards(Int_t n[4])
 //-------------------------------------------------------------------------
 void AliMUONSt345SlatSegmentation::SetPad(Int_t ix, Int_t iy)
 {
-  //
-  // Sets virtual pad coordinates, needed for evaluating pad response 
-  // outside the tracking program 
+/// Sets virtual pad coordinates, needed for evaluating pad response 
+/// outside the tracking program 
+
   GetPadC(ix,iy,fX,fY);
   fSector=Sector(ix,iy);
 }
 //---------------------------------------------------------------------------
 void AliMUONSt345SlatSegmentation::SetHit(Float_t x, Float_t y)
 {
-  // Set current hit 
-  //
+/// Set current hit 
+
   fXhit = x;
   fYhit = y;
     
@@ -322,7 +296,7 @@ void AliMUONSt345SlatSegmentation::SetHit(Float_t x, Float_t y)
 //----------------------------------------------------------------------------
 void AliMUONSt345SlatSegmentation::SetHit(Float_t xhit, Float_t yhit, Float_t /*zhit*/)
 {
-  // Set current hit 
+/// Set current hit 
 
   SetHit(xhit, yhit);
 }
@@ -330,8 +304,8 @@ void AliMUONSt345SlatSegmentation::SetHit(Float_t xhit, Float_t yhit, Float_t /*
 //----------------------------------------------------------
 void AliMUONSt345SlatSegmentation::FirstPad(Float_t xhit, Float_t yhit, Float_t dx, Float_t dy)
 {
-// Initialises iteration over pads for charge distribution algorithm
-//
+/// Initialises iteration over pads for charge distribution algorithm
+
     //
     // Find the wire position (center of charge distribution)
     Float_t x0a = GetAnod(xhit);
@@ -395,15 +369,15 @@ void AliMUONSt345SlatSegmentation::FirstPad(Float_t xhit, Float_t yhit, Float_t
 //----------------------------------------------------------------------
 void AliMUONSt345SlatSegmentation::FirstPad(Float_t xhit, Float_t yhit, Float_t /*zhit*/, Float_t dx, Float_t dy)
 {
-// Initialises iteration over pads for charge distribution algorithm
+/// Initialises iteration over pads for charge distribution algorithm
 
   FirstPad(xhit, yhit, dx, dy);
 }
 //----------------------------------------------------------------------
 void AliMUONSt345SlatSegmentation::NextPad()
 {
-  // Stepper for the iteration over pads
-  //
+/// Stepper for the iteration over pads
+
   // Step to next pad in the integration region
   //  step from left to right    
   if (fIx != fIxmax) {
@@ -424,8 +398,8 @@ void AliMUONSt345SlatSegmentation::NextPad()
 //-------------------------------------------------------------------------
 Int_t AliMUONSt345SlatSegmentation::MorePads()
 {
-  // Stopping condition for the iterator over pads
-  //
+/// Stopping condition for the iterator over pads
+
   // Are there more pads in the integration region
     
   return  (fIx != -999  || fIy != -999);
@@ -433,9 +407,8 @@ Int_t AliMUONSt345SlatSegmentation::MorePads()
 //--------------------------------------------------------------------------
 Int_t AliMUONSt345SlatSegmentation::Sector(Int_t ix, Int_t iy) 
 {
-  //
-  // Determine segmentation zone from pad coordinates
-  //
+/// Determine segmentation zone from pad coordinates
+
   Int_t isec = -1;
   for (Int_t i = 0; i < fNsec; i++) {
     if (ix <= fNpxS[i]) {
@@ -453,8 +426,8 @@ Int_t AliMUONSt345SlatSegmentation::Sector(Int_t ix, Int_t iy)
 void AliMUONSt345SlatSegmentation::
 IntegrationLimits(Float_t& x1,Float_t& x2,Float_t& y1, Float_t& y2) 
 {
-  //  Returns integration limits for current pad
-  //
+///  Returns integration limits for current pad
+
   x1=fXhit-fX-Dpx(fSector)/2.;
   x2=x1+Dpx(fSector);
   y1=fYhit-fY-Dpy(fSector)/2.;
@@ -467,7 +440,8 @@ IntegrationLimits(Float_t& x1,Float_t& x2,Float_t& y1, Float_t& y2)
 void AliMUONSt345SlatSegmentation::
 Neighbours(Int_t iX, Int_t iY, Int_t* Nlist, Int_t Xlist[10], Int_t Ylist[10]) 
 {
-  // Returns list of next neighbours for given Pad (iX, iY)
+/// Returns list of next neighbours for given Pad (iX, iY)
+
   Int_t i=0;
   //  step right
   if (iX+1 <= fNpx) {
@@ -496,14 +470,13 @@ Neighbours(Int_t iX, Int_t iY, Int_t* Nlist, Int_t Xlist[10], Int_t Ylist[10])
 //--------------------------------------------------------------------------
 void AliMUONSt345SlatSegmentation::Init(Int_t detectionElementId)
 {
-  //
-  //  Fill the arrays fCx (x-contour) and fNpxS (ix-contour) for each sector
-  //  These arrays help in converting from real to pad co-ordinates and
-  //  vice versa
-  //   
-  //  Segmentation is defined by rectangular modules approximating
-  //  concentric circles as shown below
-  //
+///  Fill the arrays fCx (x-contour) and fNpxS (ix-contour) for each sector
+///  These arrays help in converting from real to pad co-ordinates and
+///  vice versa
+///   
+///  Segmentation is defined by rectangular modules approximating
+///  concentric circles as shown below
+
   //  PCB module size in cm
   //  printf("\n Initialise Segmentation SlatModule \n");
 
index 7e73b0e..a465101 100644 (file)
@@ -8,14 +8,6 @@
 /// \ingroup base
 /// \class AliMUONSt345SlatSegmentation
 /// \brief Segmentation for slat modules
-///
-///*********************************************************
-///  Segmentation classes for slat modules          
-///  This class works with local coordinates
-///  of the slats via the class AliMUONGeometrySegmentation
-///  This class contains the size of the slats and the
-///  and the differents PCB densities. 
-///*********************************************************
 
 #include  "AliMUONVGeometryDESegmentation.h"
 
@@ -31,55 +23,56 @@ class AliMUONSt345SlatSegmentation : public AliMUONVGeometryDESegmentation
     virtual ~AliMUONSt345SlatSegmentation();
       
     virtual Float_t  Distance2AndOffset(Int_t iX, Int_t iY, Float_t X, Float_t Y, Int_t * dummy);  // Distance between 1 pad and a position
-    virtual Float_t  Dpx() const {return fDpx;}  // Pad size in x   
-    virtual Float_t  Dpy() const {return fDpy;}  // Pad size in y   
+    virtual Float_t  Dpx() const {return fDpx;}  ///< Pad size in x   
+    virtual Float_t  Dpy() const {return fDpy;}  ///< Pad size in y   
     virtual Float_t  Dpx(Int_t isec) const;       // Pad size in x by Sector
     virtual Float_t  Dpy(Int_t isec) const;       // Pad size in y by Sector
-    virtual void     Draw(const char */*opt*/ = "") {}  // Not implemented
+    virtual void     Draw(const char */*opt*/ = "") {}  ///< Not implemented
     virtual void     FirstPad(Float_t xhit, Float_t yhit, Float_t dx, Float_t dy);  // Initialisation for pad iteration
     virtual void     FirstPad(Float_t xhit, Float_t yhit, Float_t zhit, Float_t dx, Float_t dy);
 
-    virtual Bool_t   HasPad(Float_t /*x*/, Float_t /*y*/, Float_t /*z*/) { return true; }
+    virtual Bool_t   HasPad(Float_t /*x*/, Float_t /*y*/, Float_t /*z*/) { return true; }  ///< Not implemented
     virtual Bool_t   HasPad(Int_t ix, Int_t iy);
-    virtual AliMUONGeometryDirection  GetDirection() { return kDirUndefined; } 
-    virtual const AliMpVSegmentation* GetMpSegmentation() const { return 0; }                 
+    virtual AliMUONGeometryDirection  GetDirection() { return kDirUndefined; } ///< Not implemented
+    virtual const AliMpVSegmentation* GetMpSegmentation() const { return 0; }  ///< Not implemented                   
 
     virtual Float_t  GetAnod(Float_t xhit) const;  // Anod wire coordinate closest to xhit
     virtual void     GetPadI(Float_t x ,Float_t y ,Int_t   &ix,Int_t &iy);  // Transform from pad to real coordinates
     virtual void     GetPadI(Float_t x, Float_t y , Float_t z, Int_t &ix, Int_t &iy);
     virtual void     GetPadC(Int_t ix, Int_t iy, Float_t &x, Float_t &y);
+                     /// Returns real coordinates (x,y,z) for given pad coordinates (ix,iy)
     virtual void     GetPadC(Int_t ix, Int_t iy, Float_t &x, Float_t &y, Float_t &z) {z=0; GetPadC(ix, iy, x , y);}
 
     virtual void     IntegrationLimits(Float_t& x1, Float_t& x2, Float_t& y1, Float_t& y2); //Current integration limits
-    virtual Int_t    ISector()  {return fSector;} // Current Pad during Integration (current sector)
-    virtual Int_t    Ix() {return fIx;} // x-coordinate
-    virtual Int_t    Iy() {return fIy;} // y-coordinate
+    virtual Int_t    ISector()  {return fSector;} ///< Current Pad during Integration (current sector)
+    virtual Int_t    Ix() {return fIx;} ///< x-coordinate
+    virtual Int_t    Iy() {return fIy;} ///< y-coordinate
   
     virtual Int_t    MorePads();  // Condition
  
     virtual void     Neighbours(Int_t iX, Int_t iY, Int_t* Nlist, Int_t Xlist[10], Int_t Ylist[10]);  // Get next neighbours
     virtual void     NextPad(); // Stepper
-    virtual Int_t    Npx() const {return fNpx;} // Maximum number of Pads in x
-    virtual Int_t    Npy() const {return fNpy;} // Maximum number of Pads in y
+    virtual Int_t    Npx() const {return fNpx;} ///< Maximum number of Pads in x
+    virtual Int_t    Npy() const {return fNpy;} ///< Maximum number of Pads in y
 
-    virtual void     SetDAnod(Float_t D) {fWireD = D;};  // Anod pitch
-    virtual Int_t    Sector(Int_t ix, Int_t iy);         // Calculate sector from pad coordinates
-    virtual void     SetHit(Float_t xhit, Float_t yhit); // Set hit position
+    virtual void     SetDAnod(Float_t D) {fWireD = D;};  ///< Anod pitch
+    virtual Int_t    Sector(Int_t ix, Int_t iy);         //   Calculate sector from pad coordinates
+    virtual void     SetHit(Float_t xhit, Float_t yhit); //   Set hit position
     virtual void     SetHit(Float_t xhit, Float_t yhit, Float_t zhit);
-    virtual void     SetId(Int_t id) {fId=id;}  // Setting detection element
+    virtual void     SetId(Int_t id) {fId=id;}  ///< Setting detection element
     virtual void     SetPad(Int_t ix, Int_t iy);         // Set pad position
     virtual void     SetPadDivision(Int_t ndiv[4]);      // Set Slat Segmentation Parameters
     virtual void     SetPadSize(Float_t p1, Float_t p2); // Pad size Dx*Dy 
     virtual void     SetPcbBoards(Int_t n[4]);           // Set Segmentation Zones (PCB Boards)
  
     // The following function could be obsolet for this class, but they are pure virtual in AliSegmentation
-    virtual void     GetNParallelAndOffset(Int_t /*iX*/, Int_t /*iY*/, Int_t */*Nparallel*/, Int_t */*Offset*/) {};
-    virtual Int_t    SigGenCond(Float_t /*x*/, Float_t /*y*/, Float_t /*z*/){return 0;} ;  // Signal Generation Condition during Stepping
-    virtual void     SigGenInit(Float_t /*x*/, Float_t /*y*/, Float_t /*z*/){};  // Initialise signal gneration at coord (x,y,z)
-    virtual void     GiveTestPoints(Int_t &/*n*/, Float_t * /*x*/, Float_t */*y*/) const{};   // Test points for auto calibration
-    virtual void     SetCorrFunc(Int_t /*dum*/, TF1* /*func*/){}; // Function for systematic corrections, Set the correction function
-    virtual TF1*     CorrFunc(Int_t) const {return 0x0;} // Get the correction Function
-    virtual Int_t    Sector(Float_t /*x*/, Float_t /*y*/) {return 1;}
+    virtual void     GetNParallelAndOffset(Int_t /*iX*/, Int_t /*iY*/, Int_t */*Nparallel*/, Int_t */*Offset*/) {}; ///< Not implemented
+    virtual Int_t    SigGenCond(Float_t /*x*/, Float_t /*y*/, Float_t /*z*/){return 0;} ;  ///< Signal Generation Condition during Stepping
+    virtual void     SigGenInit(Float_t /*x*/, Float_t /*y*/, Float_t /*z*/){};  ///< Initialise signal gneration at coord (x,y,z)
+    virtual void     GiveTestPoints(Int_t &/*n*/, Float_t * /*x*/, Float_t */*y*/) const{};   ///< Test points for auto calibration
+    virtual void     SetCorrFunc(Int_t /*dum*/, TF1* /*func*/){}; ///< Function for systematic corrections, Set the correction function
+    virtual TF1*     CorrFunc(Int_t) const {return 0x0;} ///< Get the correction Function
+    virtual Int_t    Sector(Float_t /*x*/, Float_t /*y*/) {return 1;} ///< Current sector
 
     virtual void     Init(Int_t detectionElementId); // Initialisation
     // Current integration limits
index a537273..1c0a67a 100644 (file)
@@ -37,7 +37,9 @@
 
 #include "Riostream.h"
 
+/// \cond CLASSIMP
 ClassImp(AliMUONSt345SlatSegmentationV2)
+/// \endcond
 
 namespace
 {
@@ -55,7 +57,7 @@ fPadIterator(0),
 fXhit(FMAX),
 fYhit(FMAX)
 {
-// Default ctor
+/// Default ctor
 
        AliDebug(1,Form("this=%p default (empty) ctor",this));
 }
@@ -73,9 +75,7 @@ fPadIterator(0),
 fXhit(FMAX),
 fYhit(FMAX)
 { 
-  //
-  // Normal ctor.
-  //
+/// Normal ctor.
 
   fSlatSegmentation = dynamic_cast<AliMpSlatSegmentation*>(segmentation);
   if (fSlatSegmentation)
@@ -88,44 +88,20 @@ fYhit(FMAX)
                                                                        fSlatSegmentation));
 }
 
-//______________________________________________________________________________
-AliMUONSt345SlatSegmentationV2::AliMUONSt345SlatSegmentationV2(
-                                   const AliMUONSt345SlatSegmentationV2& right) 
-  : AliMUONVGeometryDESegmentation(right) 
-{  
-/// Protected copy constructor (not implemented)
-
-  AliFatal("Copy constructor not provided.");
-}
-
 //_____________________________________________________________________________
 AliMUONSt345SlatSegmentationV2::~AliMUONSt345SlatSegmentationV2()
 {
-// Destructor
+/// Destructor
 
        AliDebug(1,Form("dtor this=%p",this));
   delete fPadIterator;
 }
 
-//______________________________________________________________________________
-AliMUONSt345SlatSegmentationV2& 
-AliMUONSt345SlatSegmentationV2::operator=(const AliMUONSt345SlatSegmentationV2& right)
-{
-/// Protected assignement operator (not implemented)
-
-  // check assignement to self
-  if (this == &right) return *this;
-
-  AliFatal("Assignement operator not provided.");
-    
-  return *this;  
-}    
-
 //_____________________________________________________________________________
 TF1*
 AliMUONSt345SlatSegmentationV2::CorrFunc(Int_t /*isec*/) const
 {
-// Not implemented
+/// Not implemented
 
   AliFatal("Not Implemented");
   return 0x0;
@@ -135,7 +111,7 @@ AliMUONSt345SlatSegmentationV2::CorrFunc(Int_t /*isec*/) const
 Float_t 
 AliMUONSt345SlatSegmentationV2::Distance2AndOffset(Int_t /*iX*/, Int_t /*iY*/, 
                                  Float_t /*x*/, Float_t /*y*/, Int_t* /*dummy*/){
-// Not implemented
+/// Not implemented
 
   AliFatal("Not Implemented");
   return 0.0;
@@ -145,7 +121,7 @@ AliMUONSt345SlatSegmentationV2::Distance2AndOffset(Int_t /*iX*/, Int_t /*iY*/,
 void
 AliMUONSt345SlatSegmentationV2::Draw(Option_t* /*opt*/)
 {
-// Not implemented
+/// Not implemented
 
   AliFatal("Not Implemented");
 }
@@ -154,7 +130,7 @@ AliMUONSt345SlatSegmentationV2::Draw(Option_t* /*opt*/)
 Float_t
 AliMUONSt345SlatSegmentationV2::Dpx() const
 {
-// Not implemented
+/// Not implemented
 
   AliFatal("Not Implemented");
   return 0.0;
@@ -164,7 +140,7 @@ AliMUONSt345SlatSegmentationV2::Dpx() const
 Float_t
 AliMUONSt345SlatSegmentationV2::Dpy() const
 {
-// Not implemented
+/// Not implemented
 
   AliFatal("Not Implemented");
   return 0.0;
@@ -174,7 +150,7 @@ AliMUONSt345SlatSegmentationV2::Dpy() const
 Float_t
 AliMUONSt345SlatSegmentationV2::Dpx(int ipcb) const
 {
-// Get pad size in x
+/// Get pad size in x
 
        AliMpPCB* pcb = fSlat->GetPCB(ipcb);
        if (!pcb) 
@@ -188,7 +164,7 @@ AliMUONSt345SlatSegmentationV2::Dpx(int ipcb) const
 Float_t
 AliMUONSt345SlatSegmentationV2::Dpy(int ipcb) const
 {
-// Get pad size in y
+/// Get pad size in y
 
        AliMpPCB* pcb = fSlat->GetPCB(ipcb);
        if (!pcb) 
@@ -203,16 +179,15 @@ void
 AliMUONSt345SlatSegmentationV2::FirstPad(Float_t xhit, Float_t yhit,Float_t /*zhit*/,
                                          Float_t dx, Float_t dy)
 {
-  // OK. We will do it in 2 steps. First get the area over which to
-  // iterate, based on hit coordinates and (dx,dy). This first step
-  // has nothing to do with segmentation in the first place, but with
-  // how we simulate the fact that at some point the charge is shared
-  // amongst several pads.
-  // The second step is the actual pad iteration and is handled by 
-  // a specific class (which has to do only with iteration...)
-  //
-  // FIXME: this method should not be here in the first place, IMHO.
-  //
+/// OK. We will do it in 2 steps. First get the area over which to
+/// iterate, based on hit coordinates and (dx,dy). This first step
+/// has nothing to do with segmentation in the first place, but with
+/// how we simulate the fact that at some point the charge is shared
+/// amongst several pads.
+/// The second step is the actual pad iteration and is handled by 
+/// a specific class (which has to do only with iteration...)
+///
+/// \todo FIXME: this method should not be here in the first place, IMHO.
        
   // Find the wire position (center of charge distribution)
   Float_t xwire = GetAnod(xhit);
@@ -261,7 +236,7 @@ AliMUONSt345SlatSegmentationV2::FirstPad(Float_t xhit, Float_t yhit,Float_t /*zh
 Float_t
 AliMUONSt345SlatSegmentationV2::GetAnod(Float_t xhit) const
 {
-  // Gets the x-coordinate of the wire which is the closest to xhit.
+/// Gets the x-coordinate of the wire which is the closest to xhit.
        
   Int_t n = Int_t(xhit/AliMUONConstants::Pitch());
   Float_t wire = (xhit>0) ? n+0.5 : n-0.5;
@@ -272,7 +247,7 @@ AliMUONSt345SlatSegmentationV2::GetAnod(Float_t xhit) const
 AliMUONGeometryDirection
 AliMUONSt345SlatSegmentationV2::GetDirection()
 {
-// Not implemented
+/// Not implemented
 
   //AliWarning("Not Implemented");
   return kDirUndefined;
@@ -282,8 +257,8 @@ AliMUONSt345SlatSegmentationV2::GetDirection()
 const AliMpVSegmentation*  
 AliMUONSt345SlatSegmentationV2::GetMpSegmentation() const
 {
-// Returns the mapping segmentation
-// (provides access to electronics info)
+/// Returns the mapping segmentation
+/// (provides access to electronics info)
 
   return fSlatSegmentation;
 }  
@@ -294,7 +269,7 @@ void
 AliMUONSt345SlatSegmentationV2::GetNParallelAndOffset(Int_t /*iX*/, Int_t /*iY*/,
                                         Int_t* /*Nparallel*/, Int_t* /*Offset*/)
 {
-// Not implemented
+/// Not implemented
 
   AliFatal("Not Implemented");
 }
@@ -304,7 +279,7 @@ void
 AliMUONSt345SlatSegmentationV2::GetPadC(Int_t ix, Int_t iy, 
                                         Float_t& x, Float_t& y, Float_t& z)
 {                                       
-// Transform from pad to real coordinates
+/// Transform from pad to real coordinates
 
   z = 0;
   GetPadC(ix,iy,x,y);
@@ -315,7 +290,7 @@ void
 AliMUONSt345SlatSegmentationV2::GetPadC(Int_t ix, Int_t iy, 
                                         Float_t& x, Float_t& y)
 {
-// Transform from pad to real coordinates
+/// Transform from pad to real coordinates
 
   AliMpPad pad = 
   fSlatSegmentation->PadByIndices(AliMpIntPair(ix,iy),kTRUE);
@@ -329,7 +304,7 @@ void
 AliMUONSt345SlatSegmentationV2::GetPadI(Float_t x, Float_t y, Float_t /*z*/,
 Int_t& ix, Int_t& iy)
 {
-//  Returns pad coordinates (ix,iy) for given real coordinates (x,y)
+///  Returns pad coordinates (ix,iy) for given real coordinates (x,y)
 
   GetPadI(x,y,ix,iy);
 }
@@ -339,7 +314,7 @@ void
 AliMUONSt345SlatSegmentationV2::GetPadI(Float_t x, Float_t y,
                                         Int_t& ix, Int_t& iy)
 {
-//  Returns pad coordinates (ix,iy) for given real coordinates (x,y)
+///  Returns pad coordinates (ix,iy) for given real coordinates (x,y)
 
   AliMpPad pad = fSlatSegmentation->PadByPosition(TVector2(x,y), kTRUE);
        
@@ -359,7 +334,7 @@ void
 AliMUONSt345SlatSegmentationV2::GiveTestPoints(Int_t& /*n*/, 
                                     Float_t* /*x*/, Float_t* /*y*/) const
 {
-// Not implemented
+/// Not implemented
 
   AliFatal("Not Implemented");
 }
@@ -368,7 +343,7 @@ AliMUONSt345SlatSegmentationV2::GiveTestPoints(Int_t& /*n*/,
 Bool_t
 AliMUONSt345SlatSegmentationV2::HasPad(Float_t x, Float_t y, Float_t z)
 {
-// Returns true if a pad exists in the given position
+/// Returns true if a pad exists in the given position
 
   Int_t ix, iy;
   GetPadI(x,y,z,ix,iy);
@@ -379,7 +354,7 @@ AliMUONSt345SlatSegmentationV2::HasPad(Float_t x, Float_t y, Float_t z)
 Bool_t
 AliMUONSt345SlatSegmentationV2::HasPad(Int_t ix, Int_t iy)
 {
-// Returns true if a pad with given indices exists
+/// Returns true if a pad with given indices exists
 
   return fSlatSegmentation->HasPad(AliMpIntPair(ix,iy));
 }
@@ -389,9 +364,7 @@ void
 AliMUONSt345SlatSegmentationV2::IntegrationLimits(Float_t& x1, Float_t& x2,
                                                   Float_t& y1, Float_t& y2)
 {
-  //
-  //  Returns integration limits for current pad
-  //
+///  Returns integration limits for current pad
        
        //   x1 = fXhit - fX - Dpx(fSector)/2.;
        //   x2 = x1 + Dpx(fSector);
@@ -416,7 +389,8 @@ AliMUONSt345SlatSegmentationV2::IntegrationLimits(Float_t& x1, Float_t& x2,
 Int_t
 AliMUONSt345SlatSegmentationV2::ISector()
 {
-  // FIXME: remove the usage of ISector from all the code.
+/// \todo FIXME: remove the usage of ISector from all the code.
+
   return -10;
 }
 
@@ -424,8 +398,8 @@ AliMUONSt345SlatSegmentationV2::ISector()
 Int_t
 AliMUONSt345SlatSegmentationV2::Ix()
 {
-// Current pad cursor during disintegration
-// x, y-coordinate
+/// Current pad cursor during disintegration
+/// x, y-coordinate
 
   if ( fPadIterator )
        {
@@ -441,8 +415,8 @@ AliMUONSt345SlatSegmentationV2::Ix()
 Int_t
 AliMUONSt345SlatSegmentationV2::Iy()
 {
-// Current pad cursor during disintegration
-// x, y-coordinate
+/// Current pad cursor during disintegration
+/// x, y-coordinate
 
   if ( fPadIterator ) 
        {
@@ -458,6 +432,8 @@ AliMUONSt345SlatSegmentationV2::Iy()
 Int_t
 AliMUONSt345SlatSegmentationV2::MorePads()
 {
+/// Iterate over pads - condition
+
   return (fPadIterator && !fPadIterator->IsDone());
 }
 
@@ -466,7 +442,8 @@ void
 AliMUONSt345SlatSegmentationV2::Neighbours(Int_t iX, Int_t iY, Int_t* Nlist,
                                            Int_t Xlist[10], Int_t Ylist[10])
 {
-  // Find pad at (ix,iy) for which we'll search neighbours.
+/// Find pad at (ix,iy) for which we'll search neighbours.
+
   AliMpPad pad = 
        fSlatSegmentation->PadByIndices(AliMpIntPair(iX,iY),kTRUE);
        
@@ -497,7 +474,7 @@ AliMUONSt345SlatSegmentationV2::Neighbours(Int_t iX, Int_t iY, Int_t* Nlist,
 void
 AliMUONSt345SlatSegmentationV2::NextPad()
 {
-// Iterate over pads - stepper
+/// Iterate over pads - stepper
 
   if ( fPadIterator )
        {
@@ -514,7 +491,7 @@ AliMUONSt345SlatSegmentationV2::NextPad()
 Int_t
 AliMUONSt345SlatSegmentationV2::Npx() const
 {
-// Maximum number of Pads in x
+/// Maximum number of Pads in x
 
   return fSlatSegmentation->MaxPadIndexX()+1;
 }
@@ -523,7 +500,7 @@ AliMUONSt345SlatSegmentationV2::Npx() const
 Int_t
 AliMUONSt345SlatSegmentationV2::Npy() const
 {
-// Maximum number of Pads in y
+/// Maximum number of Pads in y
 
   return fSlatSegmentation->MaxPadIndexY()+1;
 }
@@ -532,7 +509,7 @@ AliMUONSt345SlatSegmentationV2::Npy() const
 void
 AliMUONSt345SlatSegmentationV2::Print(Option_t* /*opt*/) const
 {
-// Printing
+/// Printing
 
   cout << "DetElemId=" << fDetElemId << " PlaneType=" 
   << fPlaneType << " Npx,Npy=" << Npx() << "," << Npy() << " fSlat=" << fSlat 
@@ -544,7 +521,7 @@ AliMUONSt345SlatSegmentationV2::Print(Option_t* /*opt*/) const
 Int_t
 AliMUONSt345SlatSegmentationV2::Sector(Int_t ix, Int_t /*iy*/)
 {
-// Calculate sector from pad coordinates
+/// Calculate sector from pad coordinates
 
   return fSlat->FindPCBIndex(ix);
 }
@@ -553,7 +530,7 @@ AliMUONSt345SlatSegmentationV2::Sector(Int_t ix, Int_t /*iy*/)
 Int_t
 AliMUONSt345SlatSegmentationV2::Sector(Float_t x, Float_t y)
 {
-// Calculate sector from pad coordinates
+/// Calculate sector from pad coordinates
 
   return fSlat->FindPCBIndex(x,y);
 }
@@ -562,7 +539,7 @@ AliMUONSt345SlatSegmentationV2::Sector(Float_t x, Float_t y)
 void
 AliMUONSt345SlatSegmentationV2::SetCorrFunc(Int_t /*isec*/,TF1* /*func*/)
 {
-// Not implemented
+/// Not implemented
 
   AliFatal("Not Implemented");
 }
@@ -571,7 +548,7 @@ AliMUONSt345SlatSegmentationV2::SetCorrFunc(Int_t /*isec*/,TF1* /*func*/)
 void
 AliMUONSt345SlatSegmentationV2::SetDAnod(float /*d*/)
 {
-// Not implemented
+/// Not implemented
 
   AliFatal("Not Implemented");
 }
@@ -580,9 +557,9 @@ AliMUONSt345SlatSegmentationV2::SetDAnod(float /*d*/)
 void
 AliMUONSt345SlatSegmentationV2::SetHit(Float_t x, Float_t y, Float_t)
 {
-// Set hit position
-// Sets virtual hit position, needed for evaluating pad response 
-// outside the tracking program 
+/// Set hit position
+/// Sets virtual hit position, needed for evaluating pad response 
+/// outside the tracking program 
 
   fXhit = x;
   fYhit = y;
@@ -612,9 +589,9 @@ AliMUONSt345SlatSegmentationV2::SetHit(Float_t x, Float_t y, Float_t)
 void
 AliMUONSt345SlatSegmentationV2::SetPad(Int_t ix, Int_t iy)
 {
-// Set pad position.
-// Sets virtual pad coordinates, needed for evaluating pad response 
-// outside the tracking program.
+/// Set pad position.
+/// Sets virtual pad coordinates, needed for evaluating pad response 
+/// outside the tracking program.
 
   fCurrentPad = 
        fSlatSegmentation->PadByIndices(AliMpIntPair(ix,iy),kTRUE);
@@ -628,7 +605,7 @@ AliMUONSt345SlatSegmentationV2::SetPad(Int_t ix, Int_t iy)
 void
 AliMUONSt345SlatSegmentationV2::SetPadSize(float /*p1*/,float /*p2*/)
 {
-// Not implemented
+/// Not implemented
 
   AliFatal("Not Implemented");
 }
@@ -637,7 +614,7 @@ AliMUONSt345SlatSegmentationV2::SetPadSize(float /*p1*/,float /*p2*/)
 Int_t 
 AliMUONSt345SlatSegmentationV2::SigGenCond(Float_t /*x*/, Float_t /*y*/, Float_t /*z*/)
 {
-// Not implemented
+/// Not implemented
 
   AliFatal("Not Implemented");
   return 0;
@@ -647,7 +624,7 @@ AliMUONSt345SlatSegmentationV2::SigGenCond(Float_t /*x*/, Float_t /*y*/, Float_t
 void 
 AliMUONSt345SlatSegmentationV2::SigGenInit(Float_t,Float_t,Float_t)
 {
-// Not implemented
+/// Not implemented
 
   AliFatal("Not Implemented");
 }
index b81d0b6..8409a42 100644 (file)
@@ -76,7 +76,7 @@ class AliMUONSt345SlatSegmentationV2 : public AliMUONVGeometryDESegmentation
 
   void SetDAnod(float d);
 
-  void Init(int /*chamber*/) {}
+  void Init(int /*chamber*/) {}  ///< Not implemented
   void Draw(Option_t* opt = "");
 
   Float_t Dpx() const;
@@ -100,7 +100,7 @@ class AliMUONSt345SlatSegmentationV2 : public AliMUONVGeometryDESegmentation
 
   const AliMpVSegmentation* GetMpSegmentation() const;
 
-  /// to be deprecated. Use the one below w/o z instead.
+  /// \deprecated. Use the one below w/o z instead.
   void GetPadC(Int_t ix, Int_t iy, Float_t& x, Float_t& y, Float_t& z);
 
   /// From pad indices to coordinates (cm).
index a6f78c6..cc1d9d6 100644 (file)
@@ -27,7 +27,9 @@
 #include "AliMUONTransientDigit.h"
 #include "AliLog.h"
 
+/// \cond CLASSIMP
 ClassImp(AliMUONTransientDigit)
+/// \endcond
 
 //____________________________________________________________________________
 AliMUONTransientDigit::AliMUONTransientDigit() :
@@ -38,16 +40,6 @@ AliMUONTransientDigit::AliMUONTransientDigit() :
 /// Default constructor
 }
  
-//____________________________________________________________________________
-AliMUONTransientDigit::AliMUONTransientDigit(const AliMUONTransientDigit& digit) :
-  AliMUONDigit(digit)
-{
-/// Protected copy constructor
-
-  AliFatal( "Not implemented.");
-}
-
-
 AliMUONTransientDigit::AliMUONTransientDigit(Int_t ich, Int_t *digits) : 
   AliMUONDigit(digits),
   fChamber(ich),
@@ -67,21 +59,10 @@ AliMUONTransientDigit::~AliMUONTransientDigit()
 }
 
 ////////////////////////////////////////////////////////////////////////
-AliMUONTransientDigit& 
-AliMUONTransientDigit::operator =(const AliMUONTransientDigit& rhs)
-{
-/// Protected assignement operator
-
-  if (this == &rhs) return *this;
-
-  AliFatal("Not implemented.");
-    
-  return *this;  
-}
-
-////////////////////////////////////////////////////////////////////////
 void AliMUONTransientDigit::AddToTrackList(Int_t track, Int_t charge)
 {
+/// Add track to the track list
+
   TVector *pTrInfo = new TVector(3);
   TVector &trInfo = *pTrInfo;
   trInfo(0) = track;
@@ -92,6 +73,9 @@ void AliMUONTransientDigit::AddToTrackList(Int_t track, Int_t charge)
 ////////////////////////////////////////////////////////////////////////
 void AliMUONTransientDigit::UpdateTrackList(Int_t track, Int_t charge)
 {
+/// Update track charge if track already in the track list,
+/// or add the track to the list
+
   Int_t lastEntry = fTrackList->GetLast();
   TVector *pVect = static_cast<TVector*>(fTrackList->At(lastEntry));
   if ( static_cast<Int_t>((*pVect)(0)) == track) {
@@ -104,6 +88,8 @@ void AliMUONTransientDigit::UpdateTrackList(Int_t track, Int_t charge)
 ////////////////////////////////////////////////////////////////////////
 Int_t AliMUONTransientDigit::GetTrack(Int_t i) const
 {
+/// Return \a i th track from the list
+
   if (i > fTrackList->GetEntriesFast()) return 0;
   TVector *pVect = static_cast<TVector*>(fTrackList->At(i));
   return static_cast<Int_t>((*pVect)(0));
@@ -113,6 +99,8 @@ Int_t AliMUONTransientDigit::GetTrack(Int_t i) const
 ////////////////////////////////////////////////////////////////////////
 Int_t AliMUONTransientDigit::GetCharge(Int_t i) const
 {
+/// Return the charge of \a i th track in the list
+
   if (i > fTrackList->GetEntriesFast()) return 0;
   TVector *pVect = static_cast<TVector*>(fTrackList->At(i));
   return static_cast<Int_t>((*pVect)(1));
index f475587..6cec0d0 100644 (file)
@@ -10,6 +10,8 @@
 /// \ingroup base
 /// \class AliMUONTransientDigit
 /// \brief MUON transient digit
+///
+/// Extends AliMUONDigit with a list of contributing tracks
 
 #include "AliMUONDigit.h"
 
@@ -22,7 +24,9 @@ class AliMUONTransientDigit : public AliMUONDigit
     AliMUONTransientDigit(Int_t rpad, Int_t *digits);
     virtual ~AliMUONTransientDigit();
 
+          /// Return chamber number
     Int_t Chamber() const {return fChamber;}
+          /// Return number of tracks in the list
     Int_t GetNTracks() const {return fTrackList->GetEntriesFast();}
     Int_t GetTrack(Int_t i) const;
     Int_t GetCharge(Int_t i) const;
index 15cd8ef..9c23929 100644 (file)
@@ -33,7 +33,9 @@
 #include "AliMUONConstants.h"
 #include "AliLog.h"
 
+/// \cond CLASSIMP
 ClassImp(AliMUONTriggerCircuit)
+/// \endcond
 
 //----------------------------------------------------------------------
 AliMUONTriggerCircuit::AliMUONTriggerCircuit()
@@ -42,7 +44,7 @@ AliMUONTriggerCircuit::AliMUONTriggerCircuit()
     fX2m(0),
     fX2ud(0)
 {
-// Constructor
+/// Constructor
 
   fOrMud[0]=fOrMud[1]=0;
   Int_t i;  
@@ -58,30 +60,14 @@ AliMUONTriggerCircuit::AliMUONTriggerCircuit()
 }
 
 //----------------------------------------------------------------------
-AliMUONTriggerCircuit::AliMUONTriggerCircuit(const AliMUONTriggerCircuit& theMUONTriggerCircuit)
-  : TObject(theMUONTriggerCircuit)
+AliMUONTriggerCircuit::~AliMUONTriggerCircuit()
 {
-// Protected copy constructor
-
-  AliFatal("Not implemented.");
-}
-
-//----------------------------------------------------------------------
-AliMUONTriggerCircuit & 
-AliMUONTriggerCircuit::operator=(const AliMUONTriggerCircuit& rhs)
-{
-// Protected assignement operator
-
-  if (this == &rhs) return *this;
-
-  AliFatal("Not implemented.");
-    
-  return *this;  
-}
+/// Destructor
+} 
 
 //----------------------------------------------------------------------
 void AliMUONTriggerCircuit::Init(Int_t iCircuit) {
-// initialize circuit characteristics
+/// initialize circuit characteristics
   fIdCircuit=AliMUONTriggerConstants::CircuitId(iCircuit);
 
   LoadX2();
@@ -95,7 +81,7 @@ void AliMUONTriggerCircuit::Init(Int_t iCircuit) {
 
 //----------------------------------------------------------------------
 Int_t AliMUONTriggerCircuit::CircuitNumber(Int_t idCircuit) const {
-// returns circuit number iCircuit (0-234) corresponding to circuit idCircuit
+/// returns circuit number iCircuit (0-234) corresponding to circuit idCircuit
   Int_t iCircuit=0;
   for (Int_t i=0; i<234; i++) {
     if (AliMUONTriggerConstants::CircuitId(i)==idCircuit) {
@@ -107,7 +93,7 @@ Int_t AliMUONTriggerCircuit::CircuitNumber(Int_t idCircuit) const {
 }
 //----------------------------------------------------------------------
 Int_t AliMUONTriggerCircuit::ModuleNumber(Int_t idModule) const {
-// returns module number imod (from 0 to 63) corresponding to module idmodule
+/// returns module number imod (from 0 to 63) corresponding to module idmodule
   Int_t absidModule=TMath::Abs(idModule);
   Int_t iModule=0;
   for (Int_t i=0; i<63; i++) {
@@ -121,18 +107,18 @@ Int_t AliMUONTriggerCircuit::ModuleNumber(Int_t idModule) const {
 
 //----------------------------------------------------------------------
 Int_t AliMUONTriggerCircuit::Module(Int_t idCircuit) const {
-// returns ModuleId where Circuit idCircuit is sitting
+/// returns ModuleId where Circuit idCircuit is sitting
   return Int_t(idCircuit/10);
 }
 //----------------------------------------------------------------------
 Int_t AliMUONTriggerCircuit::Position(Int_t idCircuit) const {
-// returns position of idCircuit in correcponding Module
+/// returns position of idCircuit in correcponding Module
   return TMath::Abs(idCircuit)-TMath::Abs(Module(idCircuit))*10;
 }
 
 //----------------------------------------------------------------------
 void AliMUONTriggerCircuit::LoadX2() {
-// initialize fX2m, fX2ud and fOrMud
+/// initialize fX2m, fX2ud and fOrMud
   
   Int_t idModule=Module(fIdCircuit);        // corresponding module Id.
 // and its number of X strips
@@ -181,8 +167,8 @@ void AliMUONTriggerCircuit::LoadX2() {
 
 //----------------------------------------------------------------------
 void AliMUONTriggerCircuit::LoadXCode(){
-// assign a Id. number to each X strip of current circuit 
-// Id.=(corresponding module Id.)*100+(Id. strip of module)
+/// assign a Id. number to each X strip of current circuit 
+/// Id.=(corresponding module Id.)*100+(Id. strip of module)
 
 // first part : fill XMC11 XMC12 and strips 8 to 24 (middle) XMC21 XMC22
   Int_t iStripCircMT1=0, iStripCircMT2=8;
@@ -271,10 +257,10 @@ void AliMUONTriggerCircuit::LoadXCode(){
 
 //----------------------------------------------------------------------
 void AliMUONTriggerCircuit::LoadYCode(){
-// assign a Id. number to each Y strip of current circuit 
-// Id.=(corresponding module Id.)*100+(Id. strip of module)
-// note : for Y plane fill only "central part" of circuit
-// (upper and lower parts are filled in PreHandlingY of AliMUONTriggerDecision)
+/// assign a Id. number to each Y strip of current circuit 
+/// Id.=(corresponding module Id.)*100+(Id. strip of module)
+/// note : for Y plane fill only "central part" of circuit
+/// (upper and lower parts are filled in PreHandlingY of AliMUONTriggerDecision)
     
   Int_t idModule=Module(fIdCircuit);        // corresponding module Id.
 // and its number of Y strips
@@ -291,8 +277,8 @@ void AliMUONTriggerCircuit::LoadYCode(){
 
 //----------------------------------------------------------------------
 Float_t AliMUONTriggerCircuit::PtCal(Int_t istripX, Int_t idev, Int_t istripY){
-// returns calculated pt for circuit/istripX/idev/istripY according 
-// to the formula of the TRD. Note : idev (input) is in [0+30]
+/// returns calculated pt for circuit/istripX/idev/istripY according 
+/// to the formula of the TRD. Note : idev (input) is in [0+30]
 
   //  Int_t jdev = idev - 15;        // jdev in [-15+15]
   Int_t istripX2=istripX+idev+1; // find istripX2 using istripX and idev
@@ -315,7 +301,7 @@ Float_t AliMUONTriggerCircuit::PtCal(Int_t istripX, Int_t idev, Int_t istripY){
 
 //---------------------------------------------------------------------
 void AliMUONTriggerCircuit::LoadYPos2(){
-// fill fYpos11 and fYpos21 -> y position of X declusterized strips
+/// fill fYpos11 and fYpos21 -> y position of X declusterized strips
 
   Int_t chamber, cathode;
   Int_t code, idModule, idStrip, idSector;
@@ -376,10 +362,10 @@ void AliMUONTriggerCircuit::LoadYPos2(){
 
 //----------------------------------------------------------------------
 void AliMUONTriggerCircuit::LoadXPos2(){
-// fill fXpos11 -> x position of Y strips for the first plane only
-// fXpos11 contains the x position of Y strip for the current circuit
-// taking into account whether or nor not part(s) of the circuit
-// (middle, up or down) has(have) 16 strips
+/// fill fXpos11 -> x position of Y strips for the first plane only
+/// fXpos11 contains the x position of Y strip for the current circuit
+/// taking into account whether or nor not part(s) of the circuit
+/// (middle, up or down) has(have) 16 strips
   
   Float_t x, y, z;
   Int_t istrip, idDE;  
@@ -427,39 +413,39 @@ void AliMUONTriggerCircuit::LoadXPos2(){
 //--- methods which return member data related info
 //----------------------------------------------------------------------
 Int_t AliMUONTriggerCircuit::GetIdCircuit() const { 
-// returns circuit Id
+/// returns circuit Id
   return fIdCircuit;
 }
 //----------------------------------------------------------------------
 Int_t AliMUONTriggerCircuit::GetIdModule() const { 
-// returns module Id
+/// returns module Id
   return Module(fIdCircuit);
 }
 //----------------------------------------------------------------------
 Int_t AliMUONTriggerCircuit::GetNstripX() const { 
-// returns the number of X strips in the module where the circuit is sitting
+/// returns the number of X strips in the module where the circuit is sitting
   return AliMUONTriggerConstants::NstripX(ModuleNumber(Module(fIdCircuit)));
 }
 //----------------------------------------------------------------------
 Int_t AliMUONTriggerCircuit::GetNstripY() const { 
-// returns the number of Y strips in the module where the circuit is sitting
+/// returns the number of Y strips in the module where the circuit is sitting
   return AliMUONTriggerConstants::NstripY(ModuleNumber(Module(fIdCircuit)));
 }
 //----------------------------------------------------------------------
 Int_t AliMUONTriggerCircuit::GetPosCircuit() const { 
-// returns the position of the circuit in its module
+/// returns the position of the circuit in its module
   return Position(fIdCircuit);
 }
 //----------------------------------------------------------------------
 Int_t AliMUONTriggerCircuit::GetIdCircuitD() const {
-// returns the Id of the circuit down 
+/// returns the Id of the circuit down 
   Int_t idModule=Module(fIdCircuit);
   Int_t idModuleD=(TMath::Abs(idModule)+10)*(TMath::Abs(idModule)/idModule); 
   return (TMath::Abs(idModuleD)*10+1)*(TMath::Abs(idModule)/idModule);
 }
 //----------------------------------------------------------------------
 Int_t AliMUONTriggerCircuit::GetICircuitD() const {
-// returns the number of the circuit down 
+/// returns the number of the circuit down 
   Int_t idModule=Module(fIdCircuit);
   Int_t idModuleD=(TMath::Abs(idModule)+10)*(TMath::Abs(idModule)/idModule); 
   Int_t idCircuitD=
@@ -468,14 +454,14 @@ Int_t AliMUONTriggerCircuit::GetICircuitD() const {
 }
 //----------------------------------------------------------------------
 Int_t AliMUONTriggerCircuit::GetIdCircuitU() const {
-// returns the Id of the circuit up 
+/// returns the Id of the circuit up 
   Int_t idModule=Module(fIdCircuit);
   Int_t idModuleU=(TMath::Abs(idModule)-10)*(TMath::Abs(idModule)/idModule); 
   return (TMath::Abs(idModuleU)*10+1)*(TMath::Abs(idModule)/idModule);
 }
 //----------------------------------------------------------------------
 Int_t AliMUONTriggerCircuit::GetICircuitU() const {
-// returns the number of the circuit up 
+/// returns the number of the circuit up 
   Int_t idModule=Module(fIdCircuit);
   Int_t idModuleU=(TMath::Abs(idModule)-10)*(TMath::Abs(idModule)/idModule); 
   Int_t idCircuitU=
@@ -484,38 +470,38 @@ Int_t AliMUONTriggerCircuit::GetICircuitU() const {
 }
 //----------------------------------------------------------------------
 Int_t AliMUONTriggerCircuit::GetX2m() const { 
-// returns fX2m
+/// returns fX2m
   return fX2m;
 }
 //----------------------------------------------------------------------
 Int_t AliMUONTriggerCircuit::GetX2ud() const { 
-// returns fX2ud
+/// returns fX2ud
   return fX2ud;
 }
 //----------------------------------------------------------------------
 void AliMUONTriggerCircuit::GetOrMud(Int_t orMud[2]) const {
-// returns fOrMud 
+/// returns fOrMud 
   orMud[0]=fOrMud[0];
   orMud[1]=fOrMud[1];
 }
 //----------------------------------------------------------------------
 Int_t AliMUONTriggerCircuit::GetXcode(Int_t chamber, Int_t istrip) const {
-// returns X code of circuit/chamber/istrip (warning : chamber in [0,3])
+/// returns X code of circuit/chamber/istrip (warning : chamber in [0,3])
   return fXcode[chamber][istrip];
 }
 //----------------------------------------------------------------------
 Int_t AliMUONTriggerCircuit::GetYcode(Int_t chamber, Int_t istrip) const {
-// returns Y code of circuit/chamber/istrip (warning : chamber in [0,3])
+/// returns Y code of circuit/chamber/istrip (warning : chamber in [0,3])
   return fYcode[chamber][istrip];
 }
 //----------------------------------------------------------------------
 Float_t AliMUONTriggerCircuit::GetY11Pos(Int_t istrip) const {
-// returns Y position of X strip istrip in MC11
+/// returns Y position of X strip istrip in MC11
   return fYpos11[istrip];
 }
 //----------------------------------------------------------------------
 Float_t AliMUONTriggerCircuit::GetY21Pos(Int_t istrip) const {
-// returns Y position of X strip istrip in MC21
+/// returns Y position of X strip istrip in MC21
   return fYpos21[istrip];
 }
 //----------------------------------------------------------------------
@@ -551,7 +537,7 @@ void dump(const char* what, const Int_t* array, Int_t size)
 void
 AliMUONTriggerCircuit::Print(Option_t* ) const
 {
-// prints-out data member
+/// prints-out data member
   cout << "IdCircuit " << fIdCircuit << " X2m,X2ud=" << fX2m << ","
   << fX2ud;
   for ( Int_t i = 0; i < 2; ++i )
@@ -570,7 +556,7 @@ AliMUONTriggerCircuit::Print(Option_t* ) const
     sprintf(s,"Ycode[%d]",i);
     dump(s,fYcode[i],32);
   }
- // Int_t fIdCircuit;            // circuit Id number
+//  Int_t fIdCircuit;            // circuit Id number
 //  Int_t fX2m;                  // internal info needed by TriggerDecision
 //  Int_t fX2ud;                 // internal info needed by TriggerDecision
 //  Int_t fOrMud[2];             // internal info needed by TriggerDecision
@@ -584,9 +570,9 @@ AliMUONTriggerCircuit::Print(Option_t* ) const
 
 Int_t AliMUONTriggerCircuit::DetElemId(Int_t ichamber, Int_t idModule)
 {
-// adpated to official numbering (09/20/05)
-// returns the detection element Id for given chamber and module
-// ichamber (from 11 to 14), idModule (from -97 to 97)
+/// adpated to official numbering (09/20/05)
+/// returns the detection element Id for given chamber and module
+/// ichamber (from 11 to 14), idModule (from -97 to 97)
 //    
     Int_t itmp=0;    
     Int_t linenumber=Int_t(idModule/10);    
index a580b1c..4cd6f20 100644 (file)
@@ -21,7 +21,7 @@ class AliMUONTriggerCircuit : public TObject
 {
  public: 
   AliMUONTriggerCircuit();  
-  virtual ~AliMUONTriggerCircuit(){;} 
+  virtual ~AliMUONTriggerCircuit();
 
   // initializations
   void Init(Int_t iCircuit);    
index 800b4bb..73ac243 100644 (file)
 #include "AliMpVSegmentation.h"
 #include "AliMUONGeometryTransformer.h"
 
+/// \cond CLASSIMP
 ClassImp(AliMUONTriggerCircuitNew)
+/// \endcond
 
 //----------------------------------------------------------------------
 AliMUONTriggerCircuitNew::AliMUONTriggerCircuitNew()
 : TObject(),
 fILocalBoard(0)
 {
-  // Constructor
+/// Constructor
   
   Int_t i;  
   for (i=0; i<16; i++) { fXpos11[i]=0.; }
@@ -58,31 +60,15 @@ fILocalBoard(0)
 }
 
 //----------------------------------------------------------------------
-AliMUONTriggerCircuitNew::AliMUONTriggerCircuitNew(const AliMUONTriggerCircuitNew& theMUONTriggerCircuit)
-: TObject(theMUONTriggerCircuit)
+AliMUONTriggerCircuitNew::~AliMUONTriggerCircuitNew()
 {
-  // Protected copy constructor
-  
-  AliFatal("Not implemented.");
-}
-
-//----------------------------------------------------------------------
-AliMUONTriggerCircuitNew & 
-AliMUONTriggerCircuitNew::operator=(const AliMUONTriggerCircuitNew& rhs)
-{
-  // Protected assignement operator
-  
-  if (this == &rhs) return *this;
-  
-  AliFatal("Not implemented.");
-  
-  return *this;  
-}
+/// Destructor
+} 
 
 //----------------------------------------------------------------------
 void AliMUONTriggerCircuitNew::Init(Int_t iCircuit, const AliMUONTriggerCrateStore& crates) 
 {
-  // initialize circuit characteristics
+/// initialize circuit characteristics
   fILocalBoard=iCircuit+1;//AliMUONTriggerConstants::CircuitId(iCircuit);
   
   LoadXPos(crates);
@@ -93,7 +79,7 @@ void AliMUONTriggerCircuitNew::Init(Int_t iCircuit, const AliMUONTriggerCrateSto
 //---------------------------------------------------------------------
 void AliMUONTriggerCircuitNew::LoadYPos(const AliMUONTriggerCrateStore& crates)
 {
-  // fill fYpos11 and fYpos21 -> y position of X declusterized strips
+/// fill fYpos11 and fYpos21 -> y position of X declusterized strips
   
   const AliMUONLocalTriggerBoard* localBoard = crates.LocalBoard(fILocalBoard);
   
@@ -216,10 +202,10 @@ void AliMUONTriggerCircuitNew::LoadYPos(const AliMUONTriggerCrateStore& crates)
 //----------------------------------------------------------------------
 void AliMUONTriggerCircuitNew::LoadXPos(const AliMUONTriggerCrateStore& crates)
 {
-  // fill fXpos11 -> x position of Y strips for the first plane only
-  // fXpos11 contains the x position of Y strip for the current circuit
-  // taking into account whether or nor not part(s) of the circuit
-  // (middle, up or down) has(have) 16 strips (handdled by means of switchs)
+/// fill fXpos11 -> x position of Y strips for the first plane only
+/// fXpos11 contains the x position of Y strip for the current circuit
+/// taking into account whether or nor not part(s) of the circuit
+/// (middle, up or down) has(have) 16 strips (handdled by means of switchs)
   
   const AliMUONLocalTriggerBoard* localBoard = crates.LocalBoard(fILocalBoard);
   
@@ -284,7 +270,7 @@ void AliMUONTriggerCircuitNew::FillYstrips(
                                            const Int_t iFirstStrip, const Int_t iLastStrip, Int_t liStripCircuit,
                                            const Bool_t doubling)
 {    
-  // fill
+/// fill
   Double_t xyGlobal[4]={0.,0.,0.,0.};
   for (Int_t istrip=iFirstStrip; istrip<iLastStrip; istrip++) {
     AliMpPad pad = seg->PadByIndices(AliMpIntPair(istrip,0),kTRUE);
@@ -317,7 +303,7 @@ void AliMUONTriggerCircuitNew::FillXstrips(
                                            const Int_t iFirstStrip, const Int_t iLastStrip, 
                                            Int_t liStripCircuit, Float_t *tab)
 {    
-  // fill 
+/// fill 
   Double_t xyGlobal[4]={0.,0.,0.,0.};
   for (Int_t istrip=iFirstStrip; istrip<iLastStrip; istrip++) {
     AliMpPad pad = seg->PadByIndices(AliMpIntPair(icol-1,istrip),kTRUE);
@@ -341,17 +327,17 @@ void AliMUONTriggerCircuitNew::FillXstrips(
 //--- methods which return member data related info
 //----------------------------------------------------------------------
 Float_t AliMUONTriggerCircuitNew::GetY11Pos(Int_t istrip) const {
-  // returns Y position of X strip istrip in MC11
+/// returns Y position of X strip istrip in MC11
   return fYpos11[istrip];
 }
 //----------------------------------------------------------------------
 Float_t AliMUONTriggerCircuitNew::GetY21Pos(Int_t istrip) const {
-  // returns Y position of X strip istrip in MC21
+/// returns Y position of X strip istrip in MC21
   return fYpos21[istrip];
 }
 //----------------------------------------------------------------------
 Float_t AliMUONTriggerCircuitNew::GetX11Pos(Int_t istrip) const {
-  // returns X position of Y strip istrip in MC11
+/// returns X position of Y strip istrip in MC11
   return fXpos11[istrip];
 }
 //----------------------------------------------------------------------
@@ -415,7 +401,7 @@ removed tmp*/
 //----------------------------------------------------------------------
 Int_t AliMUONTriggerCircuitNew::DetElemId(Int_t ichamber, char side, Int_t iline)
 {
-  // returns detection element Id for chamber iChamber, side side and line iline
+/// returns detection element Id for chamber iChamber, side side and line iline
   Int_t itmp=0;    
   if ( side == 'R' ) {        // right side 
     switch (iline) // (from 1 to 9, from bottom to top)
@@ -487,7 +473,7 @@ Int_t AliMUONTriggerCircuitNew::DetElemId(Int_t ichamber, char side, Int_t iline
 Int_t
 AliMUONTriggerCircuitNew::DetElemId(Int_t iChamber, const char* boardName)
 {
-  // returns detection element Id for chamber iChamber and board boardName
+/// returns detection element Id for chamber iChamber and board boardName
   char side = boardName[5];
   Int_t iline = boardName[4] - '0';
   return DetElemId(iChamber,side,iline);
@@ -500,8 +486,8 @@ AliMUONTriggerCircuitNew::DecodeBoardName(const char* boardName,
                                           Int_t& iLine,
                                           Int_t& iCol)
 {
-  // get side, line and col from board boardName
-  // note: icol = icol -1 for iline = 5 w.r.t other ilines
+/// get side, line and col from board boardName
+/// note: icol = icol -1 for iline = 5 w.r.t other ilines
   side = boardName[0];