- Revised comments and adapted them for Doxygen
authorivana <ivana@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 23 Jun 2006 10:47:13 +0000 (10:47 +0000)
committerivana <ivana@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 23 Jun 2006 10:47:13 +0000 (10:47 +0000)
- Removed implementation of protected copy constructor &
  assignment operator
- Cleanup some Effective C++ warnings

33 files changed:
MUON/AliMUONGeometry.cxx
MUON/AliMUONGeometry.h
MUON/AliMUONGeometryBuilder.cxx
MUON/AliMUONGeometryBuilder.h
MUON/AliMUONGeometryConstituent.cxx
MUON/AliMUONGeometryConstituent.h
MUON/AliMUONGeometryDetElement.cxx
MUON/AliMUONGeometryDetElement.h
MUON/AliMUONGeometryDirection.h
MUON/AliMUONGeometryEnvelope.cxx
MUON/AliMUONGeometryEnvelope.h
MUON/AliMUONGeometryEnvelopeStore.cxx
MUON/AliMUONGeometryEnvelopeStore.h
MUON/AliMUONGeometryMisAligner.cxx
MUON/AliMUONGeometryMisAligner.h
MUON/AliMUONGeometryModule.cxx
MUON/AliMUONGeometryModule.h
MUON/AliMUONGeometryModuleTransformer.cxx
MUON/AliMUONGeometryModuleTransformer.h
MUON/AliMUONGeometrySegmentation.cxx
MUON/AliMUONGeometrySegmentation.h
MUON/AliMUONGeometryStore.cxx
MUON/AliMUONGeometryStore.h
MUON/AliMUONGeometryTransformer.cxx
MUON/AliMUONGeometryTransformer.h
MUON/AliMUONSegmentation.cxx
MUON/AliMUONSegmentation.h
MUON/AliMUONStringIntMap.cxx
MUON/AliMUONStringIntMap.h
MUON/AliMUONVGeometryBuilder.cxx
MUON/AliMUONVGeometryBuilder.h
MUON/AliMUONVGeometryDESegmentation.cxx
MUON/AliMUONVGeometryDESegmentation.h

index 737da2e..5eb4053 100644 (file)
@@ -35,7 +35,9 @@
 
 #include <iostream>
 
+/// \cond CLASSIMP
 ClassImp(AliMUONGeometry)
+/// \endcond
  
 //______________________________________________________________________________
 AliMUONGeometry::AliMUONGeometry(Bool_t isOwner)
@@ -64,15 +66,6 @@ AliMUONGeometry::AliMUONGeometry()
 } 
 
 //______________________________________________________________________________
-AliMUONGeometry::AliMUONGeometry(const AliMUONGeometry& right) 
-  : TObject(right) 
-{  
-/// Copy constructor (not implemented)
-
-  AliFatal("Copy constructor not provided.");
-}
-
-//______________________________________________________________________________
 AliMUONGeometry::~AliMUONGeometry()
 {
 /// Destructor
@@ -81,20 +74,6 @@ AliMUONGeometry::~AliMUONGeometry()
   delete fTransformer;
 }
 
-//______________________________________________________________________________
-AliMUONGeometry& 
-AliMUONGeometry::operator=(const AliMUONGeometry& right)
-{
-/// Assignement operator (not implemented)
-
-  // check assignement to self
-  if (this == &right) return *this;
-
-  AliFatal("Assignement operator not provided.");
-    
-  return *this;  
-}    
-
 //
 // private methods
 //
@@ -103,8 +82,7 @@ AliMUONGeometry::operator=(const AliMUONGeometry& right)
 TString  AliMUONGeometry::ComposePath(const TString& volName, 
                                        Int_t copyNo) const
 {
-// Compose path from given volName and copyNo
-// ---
+/// Compose path from given volName and copyNo
 
   TString path(volName);
   path += ".";
@@ -117,8 +95,7 @@ TString  AliMUONGeometry::ComposePath(const TString& volName,
 void AliMUONGeometry::FillData3(const TString& sensVolumePath, 
                                 Int_t detElemId)
 {
-// Fill the mapping of the sensitive volume path to the detection element.
-// ---
+/// Fill the mapping of the sensitive volume path to the detection element.
 
   // Module Id
   Int_t moduleId = AliMUONGeometryStore::GetModuleId(detElemId);
@@ -144,9 +121,8 @@ void AliMUONGeometry::FillData3(const TString& sensVolumePath,
 //______________________________________________________________________________
 TString  AliMUONGeometry::ReadData3(ifstream& in)
 {
-// Reads SV maps from a file
-// Returns true, if reading finished correctly.
-// ---
+/// Read SV maps from a file.
+/// Return true, if reading finished correctly.
 
   TString key("SV");
   while ( key == TString("SV") ) {
@@ -175,9 +151,8 @@ TString  AliMUONGeometry::ReadData3(ifstream& in)
 //______________________________________________________________________________
 void AliMUONGeometry::WriteData3(ofstream& out) const
 {
-// Writes association of sensitive volumes and detection elements
-// from the sensitive volume map
-// ---
+/// Write association of sensitive volumes and detection elements
+/// from the sensitive volume map
 
   for (Int_t i=0; i<fModules->GetEntriesFast(); i++) {
     AliMUONGeometryModule* geometry 
@@ -197,7 +172,7 @@ void AliMUONGeometry::WriteData3(ofstream& out) const
 //_____________________________________________________________________________
 void AliMUONGeometry::AddModule(AliMUONGeometryModule* module)
 {
-/// Add the geometrymodule to the array
+/// Add the geometry module to the array
 
   fModules->Add(module);
 
@@ -209,9 +184,8 @@ void AliMUONGeometry::AddModule(AliMUONGeometryModule* module)
 Bool_t  
 AliMUONGeometry::ReadSVMap(const TString& fileName)
 {
-// Reads the sensitive volume maps from a file
-// Returns true, if reading finished correctly.
-// ---
+/// Read the sensitive volume maps from a file.
+/// Return true, if reading finished correctly.
 
   // No reading
   // if builder is not associated with any geometry module
@@ -248,9 +222,8 @@ AliMUONGeometry::ReadSVMap(const TString& fileName)
 Bool_t  
 AliMUONGeometry::WriteSVMap(const TString& fileName) const
 {
-// Writes sensitive volume map into a file
-// Returns true, if writing finished correctly.
-// ---
+/// Write sensitive volume map into a file.
+/// Return true, if writing finished correctly.
 
   // No writing
   // if builder is not associated with any geometry module
@@ -297,7 +270,7 @@ AliMUONGeometry::GetModule(Int_t index, Bool_t warn) const
 const AliMUONGeometryModule* 
 AliMUONGeometry::GetModuleByDEId(Int_t detElemId, Bool_t warn) const
 {
-/// Return the geometry module specified by index
+/// Return the geometry module specified by detElemId
 
   // Get module index
   Int_t index = AliMUONGeometryStore::GetModuleId(detElemId);
index ca957ed..d024c13 100644 (file)
@@ -7,7 +7,7 @@
 /// \class AliMUONGeometry
 /// \brief Container class for geometry modules
 ///
-/// Author: Ivana Hrivnacova, IPN Orsay
+/// \author Ivana Hrivnacova, IPN Orsay
 
 #ifndef ALI_MUON_GEOMETRY_H
 #define ALI_MUON_GEOMETRY_H
@@ -62,6 +62,7 @@ class AliMUONGeometry : public TObject
   ClassDef(AliMUONGeometry,1)  // Geometry parametrisation
 };
 
+/// Return geometry transformer
 inline AliMUONGeometryTransformer* AliMUONGeometry::GetTransformer() const
 { return fTransformer; }
 
index 9d6e258..e11326f 100644 (file)
@@ -48,7 +48,9 @@ const TString  AliMUONGeometryBuilder::fgkDefaultTransformFileName = "transform.
 const TString  AliMUONGeometryBuilder::fgkDefaultSVMapFileName = "svmap.dat";    
 const TString  AliMUONGeometryBuilder::fgkOutFileNameExtension = ".out";    
 
+/// \cond CLASSIMP
 ClassImp(AliMUONGeometryBuilder)
+/// \endcond
 
 // static functions
 
@@ -149,15 +151,6 @@ AliMUONGeometryBuilder::AliMUONGeometryBuilder()
 } 
 
 //______________________________________________________________________________
-AliMUONGeometryBuilder::AliMUONGeometryBuilder(const AliMUONGeometryBuilder& right) 
-  : TObject(right) 
-{  
-/// Copy constructor (not implemented)
-
-  AliFatal("Copy constructor not provided.");
-}
-
-//______________________________________________________________________________
 AliMUONGeometryBuilder::~AliMUONGeometryBuilder()
 {
 /// Destructor
@@ -166,20 +159,6 @@ AliMUONGeometryBuilder::~AliMUONGeometryBuilder()
   delete fGeometry;
 }
 
-//______________________________________________________________________________
-AliMUONGeometryBuilder& 
-AliMUONGeometryBuilder::operator=(const AliMUONGeometryBuilder& right)
-{
-/// Assignement operator (not implemented)
-
-  // check assignement to self
-  if (this == &right) return *this;
-
-  AliFatal("Assignement operator not provided.");
-    
-  return *this;  
-}    
-
 //
 // private functions
 //
@@ -351,7 +330,7 @@ void AliMUONGeometryBuilder::CreateGeometryWithTGeo()
 void AliMUONGeometryBuilder::CreateGeometryWithoutTGeo()
 {
 /// Construct geometry using geometry builders.
-/// Virtual modules/enevlopes are not placed
+/// Virtual modules/envelopes are not placed
 
   if (fAlign) {
     // Read transformations from ASCII data file  
@@ -624,7 +603,7 @@ void AliMUONGeometryBuilder::SetAlign(Bool_t align)
 //_____________________________________________________________________________
 void AliMUONGeometryBuilder::SetAlign(const TString& fileName, Bool_t align)
 { 
-/// Set the option for alignement
+/// Set the option for alignement and the transformations file name
 
   fTransformFileName = fileName;
   fAlign = align; 
index a493640..07185a9 100644 (file)
@@ -7,7 +7,7 @@
 /// \class AliMUONGeometryBuilder
 /// \brief Manager class for geometry construction via geometry builders.
 ///
-/// Author: Ivana Hrivnacova, IPN Orsay
+/// \author Ivana Hrivnacova, IPN Orsay
 
 #ifndef ALI_MUON_GEOMETRY_BUILDER_H
 #define ALI_MUON_GEOMETRY_BUILDER_H
@@ -92,20 +92,25 @@ class AliMUONGeometryBuilder : public TObject
 
 // inline functions
 
+/// Initialize geometry
 inline void  AliMUONGeometryBuilder::InitGeometry()
 { InitGeometry(fSVMapFileName); }
 
+/// Write sensitive volume maps
 inline void  AliMUONGeometryBuilder::WriteSVMaps()
 { WriteSVMaps(fSVMapFileName + fgkOutFileNameExtension); }
 
+/// Return geometry parametrisation
 inline 
 const AliMUONGeometry* AliMUONGeometryBuilder::GetGeometry() const
 { return fGeometry; }
 
+/// Return geometry transformer
 inline 
 const AliMUONGeometryTransformer* AliMUONGeometryBuilder::GetTransformer() const
 { return fGeometry->GetTransformer(); }
 
+/// Return option for reading transformations from a file
 inline Bool_t  AliMUONGeometryBuilder::GetAlign() const
 { return fAlign; }
 
index 88ef8c5..3cebad8 100644 (file)
@@ -26,7 +26,9 @@
 #include "AliMUONGeometryConstituent.h"
 #include "AliLog.h"
 
+/// \cond CLASSIMP
 ClassImp(AliMUONGeometryConstituent)
+/// \endcond
 
 //______________________________________________________________________________
 AliMUONGeometryConstituent::AliMUONGeometryConstituent(const TString& name, 
@@ -34,7 +36,8 @@ AliMUONGeometryConstituent::AliMUONGeometryConstituent(const TString& name,
   : TNamed(name, name),
     fCopyNo(copyNo),
     fNpar(npar),
-    fParam(0)                             
+    fParam(0), 
+    fTransformation(0)                            
 {                                  
 /// Standard constructor for a constituent without translation & rotation
 
@@ -134,17 +137,6 @@ AliMUONGeometryConstituent::AliMUONGeometryConstituent()
 /// Default constructor
 }
 
-
-//______________________________________________________________________________
-AliMUONGeometryConstituent::AliMUONGeometryConstituent(
-                                        const AliMUONGeometryConstituent& rhs)
-  : TNamed(rhs)
-{
-/// Protected copy constructor
-
-  AliFatal("Copy constructor is not implemented.");
-}
-
 //______________________________________________________________________________
 AliMUONGeometryConstituent::~AliMUONGeometryConstituent() 
 {
@@ -153,18 +145,3 @@ AliMUONGeometryConstituent::~AliMUONGeometryConstituent()
   delete fTransformation;
   delete [] fParam;
 }
-
-//______________________________________________________________________________
-AliMUONGeometryConstituent& 
-AliMUONGeometryConstituent::operator = (const AliMUONGeometryConstituent& rhs) 
-{
-/// Protected assignment operator
-
-  // check assignement to self
-  if (this == &rhs) return *this;
-
-  AliFatal("Assignment operator is not implemented.");
-    
-  return *this;  
-}
-
index a017f21..946ad45 100644 (file)
@@ -8,7 +8,7 @@
 /// \class AliMUONGeometryConstituent
 /// \brief Helper class for definititon of an assembly of volumes.
 ///
-/// Author: Ivana Hrivnacova, IPN Orsay
+/// \author Ivana Hrivnacova, IPN Orsay
 
 #ifndef ALI_MUON_GEOMETRY_CONSTITUENT_H
 #define ALI_MUON_GEOMETRY_CONSTITUENT_H
@@ -46,8 +46,6 @@ class AliMUONGeometryConstituent : public TNamed
 
   protected:
     AliMUONGeometryConstituent(const AliMUONGeometryConstituent& rhs);
-
-    // operators  
     AliMUONGeometryConstituent& operator = (const AliMUONGeometryConstituent& rhs);
 
   private:
@@ -65,15 +63,19 @@ class AliMUONGeometryConstituent : public TNamed
 
 // inline functions
 
+/// Return copy number
 inline Int_t AliMUONGeometryConstituent::GetCopyNo() const
 { return fCopyNo; }  
 
+/// Return number of shape parameters
 inline Int_t AliMUONGeometryConstituent::GetNpar() const
 { return fNpar; }
 
+/// Return the array of shape parameters
 inline Double_t* AliMUONGeometryConstituent::GetParam() const
 { return fParam; }
 
+/// Return the constituent transformation wrt to the envelope
 inline const TGeoCombiTrans* AliMUONGeometryConstituent::GetTransformation() const 
 { return fTransformation; }
 
index 46f87da..e94829f 100644 (file)
@@ -30,7 +30,9 @@
 
 #include <sstream>
 
+/// \cond CLASSIMP
 ClassImp(AliMUONGeometryDetElement)
+/// \endcond
 
 //______________________________________________________________________________
 AliMUONGeometryDetElement::AliMUONGeometryDetElement(
@@ -57,16 +59,6 @@ AliMUONGeometryDetElement::AliMUONGeometryDetElement()
 }
 
 //______________________________________________________________________________
-AliMUONGeometryDetElement::AliMUONGeometryDetElement(
-                                   const AliMUONGeometryDetElement& rhs)
-  : TObject(rhs)
-{
-/// Protected copy constructor
-
-  AliFatal("Copy constructor is not implemented.");
-}
-
-//______________________________________________________________________________
 AliMUONGeometryDetElement::~AliMUONGeometryDetElement() 
 {
 /// Destructor
@@ -75,20 +67,6 @@ AliMUONGeometryDetElement::~AliMUONGeometryDetElement()
   delete fGlobalTransformation;
 }
 
-//______________________________________________________________________________
-AliMUONGeometryDetElement& 
-AliMUONGeometryDetElement::operator = (const AliMUONGeometryDetElement& rhs) 
-{
-/// Protected assignement operator
-
-  // check assignement to self
-  if (this == &rhs) return *this;
-
-  AliFatal("Assignment operator is not implemented.");
-    
-  return *this;  
-}
-
 //
 // private methods
 //
@@ -97,7 +75,7 @@ AliMUONGeometryDetElement::operator = (const AliMUONGeometryDetElement& rhs)
 void  AliMUONGeometryDetElement::PrintTransform(
                                             const TGeoHMatrix* transform) const
 {
-/// Prints the detection element transformation
+/// Print the detection element transformation
 
   cout << "DetElemId: " << GetUniqueID();
   cout << "  name: " << fVolumePath << endl;
@@ -148,9 +126,8 @@ void  AliMUONGeometryDetElement::Global2Local(
                                   Float_t xg, Float_t yg, Float_t zg, 
                                   Float_t& xl, Float_t& yl, Float_t& zl) const
 {
-/// Transforms point from the global reference frame (ALIC)
-/// to the local reference frame of the detection element specified
-/// by detElemId.
+/// Transform point from the global reference frame (ALIC)
+/// to the local reference frame of this detection element.
 
   Double_t dxg = xg;
   Double_t dyg = yg;
@@ -169,9 +146,8 @@ void  AliMUONGeometryDetElement::Global2Local(
                                   Double_t xg, Double_t yg, Double_t zg, 
                                   Double_t& xl, Double_t& yl, Double_t& zl) const
 {
-/// Transforms point from the global reference frame (ALIC)
-/// to the local reference frame of the detection element specified
-/// by detElemId.
+/// Transform point from the global reference frame (ALIC)
+/// to the local reference frame of this detection element
 
    // Check transformation
    if (!fGlobalTransformation) {
@@ -196,8 +172,8 @@ void  AliMUONGeometryDetElement::Local2Global(
                  Float_t xl, Float_t yl, Float_t zl, 
                  Float_t& xg, Float_t& yg, Float_t& zg) const
 {
-/// Transforms point from the local reference frame of the detection element 
-/// specified by detElemId to the global reference frame (ALIC).
+/// Transform point from the local reference frame of this detection element 
+/// to the global reference frame (ALIC).
 
   Double_t dxl = xl;
   Double_t dyl = yl;
@@ -216,8 +192,8 @@ void  AliMUONGeometryDetElement::Local2Global(
                  Double_t xl, Double_t yl, Double_t zl, 
                  Double_t& xg, Double_t& yg, Double_t& zg) const
 {
-/// Transforms point from the local reference frame of the detection element 
-/// specified by detElemId to the global reference frame (ALIC).
+/// Transform point from the local reference frame of this detection element 
+/// to the global reference frame (ALIC).
 
    // Check transformation
    if (!fGlobalTransformation) {
@@ -241,8 +217,8 @@ void  AliMUONGeometryDetElement::Local2Global(
 void AliMUONGeometryDetElement::SetLocalTransformation(
                                                 const TGeoHMatrix& transform)
 { 
-/// Sets global transformation;
-/// gives warning if the global transformation is already defined.
+/// Set local transformation;
+/// give warning if the global transformation is already defined.
  
   if (fLocalTransformation) {
     delete fLocalTransformation;
@@ -256,8 +232,8 @@ void AliMUONGeometryDetElement::SetLocalTransformation(
 void AliMUONGeometryDetElement::SetGlobalTransformation(
                                                 const TGeoHMatrix& transform)
 { 
-/// Sets global transformation;
-/// gives warning if the global transformation is already defined.
+/// Set global transformation;
+/// give warning if the global transformation is already defined.
  
   if (fGlobalTransformation) {
     delete fGlobalTransformation;
@@ -270,7 +246,7 @@ void AliMUONGeometryDetElement::SetGlobalTransformation(
 //______________________________________________________________________________
 void AliMUONGeometryDetElement::PrintLocalTransform() const
 {
-/// Prints detection element relative transformation
+/// Print detection element relative transformation
 /// (the transformation wrt module frame)
 
   PrintTransform(fLocalTransformation);
@@ -279,7 +255,7 @@ void AliMUONGeometryDetElement::PrintLocalTransform() const
 //______________________________________________________________________________
 void AliMUONGeometryDetElement::PrintGlobalTransform() const
 {
-/// Prints detection element global transformation
+/// Print detection element global transformation
 /// (the transformation wrt global frame)
 
   PrintTransform(fGlobalTransformation);
index 1c6635b..7f1e5da 100644 (file)
@@ -7,7 +7,7 @@
 /// \class AliMUONGeometryDetElement
 /// \brief Class for storing detection element transformations 
 ///
-/// Author: Ivana Hrivnacova, IPN Orsay
+/// \author Ivana Hrivnacova, IPN Orsay
 
 #ifndef ALI_MUON_GEOMETRY_DET_ELEMENT_H
 #define ALI_MUON_GEOMETRY_DET_ELEMENT_H
@@ -57,8 +57,6 @@ class AliMUONGeometryDetElement : public TObject
 
   protected:
     AliMUONGeometryDetElement(const AliMUONGeometryDetElement& rhs);
-
-    // operators  
     AliMUONGeometryDetElement& operator = (const AliMUONGeometryDetElement& rhs);
   
   private:
@@ -76,19 +74,24 @@ class AliMUONGeometryDetElement : public TObject
 
 // inline functions
 
+/// Set the full path of the aligned volume or envelope in geometry
 inline void AliMUONGeometryDetElement::SetVolumePath(const TString& volumePath)
 { fVolumePath = volumePath; }
 
+/// Return detection element ID
 inline Int_t AliMUONGeometryDetElement::GetId() const
 { return GetUniqueID(); }
 
+/// Return the full path of the aligned volume or envelope in geometry
 inline TString AliMUONGeometryDetElement::GetVolumePath() const
 { return fVolumePath; }
 
+/// Return the detection element transformation wrt module
 inline const TGeoHMatrix* 
 AliMUONGeometryDetElement::GetLocalTransformation() const
 { return fLocalTransformation; }
 
+/// Return the detection element transformation wrt world
 inline const TGeoHMatrix* 
 AliMUONGeometryDetElement::GetGlobalTransformation() const
 { return fGlobalTransformation; }
index fdb3cdc..a123b56 100644 (file)
@@ -14,9 +14,9 @@
 
 enum AliMUONGeometryDirection 
 {
-  kDirX,          // direction in x
-  kDirY,          // direction in y
-  kDirUndefined   // undefined direction
+  kDirX,          ///< direction in x
+  kDirY,          ///< direction in y
+  kDirUndefined   ///< undefined direction
 };
 
 #endif //ALI_MUON_GEOMETRY_DIRECTION_H
index f92f689..15d6c42 100644 (file)
@@ -29,7 +29,9 @@
 #include "AliMUONGeometryConstituent.h"
 #include "AliLog.h"
 
+/// \cond CLASSIMP
 ClassImp(AliMUONGeometryEnvelope)
+/// \endcond
 
 //______________________________________________________________________________
 AliMUONGeometryEnvelope::AliMUONGeometryEnvelope(const TString& name, 
@@ -94,17 +96,6 @@ AliMUONGeometryEnvelope::AliMUONGeometryEnvelope()
 /// Default constructor
 }
 
-
-//______________________________________________________________________________
-AliMUONGeometryEnvelope::AliMUONGeometryEnvelope(
-                                        const AliMUONGeometryEnvelope& rhs)
-  : TNamed(rhs)
-{
-/// Protected copy constructor
-
-  AliFatal("Copy constructor is not implemented.");
-}
-
 //______________________________________________________________________________
 AliMUONGeometryEnvelope::~AliMUONGeometryEnvelope() 
 {
@@ -120,20 +111,6 @@ AliMUONGeometryEnvelope::~AliMUONGeometryEnvelope()
   }  
 }
 
-//______________________________________________________________________________
-AliMUONGeometryEnvelope& 
-AliMUONGeometryEnvelope::operator = (const AliMUONGeometryEnvelope& rhs) 
-{
-/// Protected assignement operator
-
-  // check assignement to self
-  if (this == &rhs) return *this;
-
-  AliFatal("Assignment operator is not implemented.");
-    
-  return *this;  
-}
-
 //
 // public methods
 //
@@ -247,7 +224,7 @@ void  AliMUONGeometryEnvelope::SetTranslation(const TGeoTranslation& translation
 //______________________________________________________________________________
 void  AliMUONGeometryEnvelope::SetRotation(const TGeoRotation& rotation)
 {
-/// Set the enevlope rotation
+/// Set the envelope rotation
 
   TGeoRotation* rot = new TGeoRotation();
   rot->SetMatrix(const_cast<Double_t*>(rotation.GetRotationMatrix()));
@@ -258,8 +235,7 @@ void  AliMUONGeometryEnvelope::SetRotation(const TGeoRotation& rotation)
 //______________________________________________________________________________
 void  AliMUONGeometryEnvelope::SetTransform(const TGeoCombiTrans& transform)
 {
-// Sets the enevlope transformation
-// ---
+/// Set the envelope transformation
 
   fTransformation
     ->SetTranslation(const_cast<Double_t*>(transform.GetTranslation()));
index 3ebaaf0..561f3df 100644 (file)
@@ -10,7 +10,7 @@
 ///
 /// Helper class for definititon of an assembly of volumes.
 ///
-/// Author: Ivana Hrivnacova, IPN Orsay
+/// \author Ivana Hrivnacova, IPN Orsay
 
 #ifndef ALI_MUON_GEOMETRY_ENVELOPE_H
 #define ALI_MUON_GEOMETRY_ENVELOPE_H
@@ -68,8 +68,6 @@ class AliMUONGeometryEnvelope : public TNamed
 
   protected:
     AliMUONGeometryEnvelope(const AliMUONGeometryEnvelope& rhs);
-
-    // operators  
     AliMUONGeometryEnvelope& operator = (const AliMUONGeometryEnvelope& rhs);
 
   private:
@@ -90,18 +88,25 @@ class AliMUONGeometryEnvelope : public TNamed
 
 // inline functions
 
+/// Return true if envelope is virtual
 inline Bool_t AliMUONGeometryEnvelope::IsVirtual() const
 { return fIsVirtual; }  
 
+/// Return true if envelope is placed with MANY option
 inline Bool_t AliMUONGeometryEnvelope::IsMANY() const
 { return fIsMANY; }  
 
+/// Return copy number
 inline Int_t AliMUONGeometryEnvelope::GetCopyNo() const
 { return fCopyNo; }  
 
+/// Return the envelope transformation wrt to the mother frame 
+/// (the chamber position)
 inline const TGeoCombiTrans* AliMUONGeometryEnvelope::GetTransformation() const 
 { return fTransformation; }
 
+/// Return the array of constituents names and transformations 
+/// wrt to the envelope position
 inline const TObjArray* AliMUONGeometryEnvelope::GetConstituents() const
 { return fConstituents; }
 
index cd9b863..046f13f 100644 (file)
@@ -35,7 +35,9 @@
 #include <Riostream.h>
 #include <TString.h>
 
+/// \cond CLASSIMP
 ClassImp(AliMUONGeometryEnvelopeStore)
+/// \endcond
 
 //______________________________________________________________________________
 AliMUONGeometryEnvelopeStore::AliMUONGeometryEnvelopeStore(
@@ -67,13 +69,6 @@ AliMUONGeometryEnvelopeStore::AliMUONGeometryEnvelopeStore()
 
 
 //______________________________________________________________________________
-AliMUONGeometryEnvelopeStore::AliMUONGeometryEnvelopeStore(const AliMUONGeometryEnvelopeStore& rhs)
-  : TObject(rhs)
-{
-  AliFatal("Copy constructor is not implemented.");
-}
-
-//______________________________________________________________________________
 AliMUONGeometryEnvelopeStore::~AliMUONGeometryEnvelopeStore() 
 {
 /// Destructor
@@ -86,20 +81,6 @@ AliMUONGeometryEnvelopeStore::~AliMUONGeometryEnvelopeStore()
   }  
 }
 
-//______________________________________________________________________________
-AliMUONGeometryEnvelopeStore& 
-AliMUONGeometryEnvelopeStore::operator = (const AliMUONGeometryEnvelopeStore& rhs) 
-{
-/// Protected assignement operator
-
-  // check assignement to self
-  if (this == &rhs) return *this;
-
-  AliFatal("Assignment operator is not implemented.");
-    
-  return *this;  
-}
-
 //
 // private methods
 //
@@ -108,7 +89,7 @@ AliMUONGeometryEnvelopeStore::operator = (const AliMUONGeometryEnvelopeStore& rh
 TGeoHMatrix 
 AliMUONGeometryEnvelopeStore::ConvertDETransform(const TGeoHMatrix& transform) const
 {
-// Convert transformation into the reference frame
+/// Convert transformation into the reference frame
 
   if ( fReferenceFrame.IsIdentity() )
     return transform;
@@ -423,7 +404,7 @@ void  AliMUONGeometryEnvelopeStore::AddEnvelopeConstituent(const TString& name,
                                          const TString& envName, Int_t copyNo) 
 {
 /// Add the volume with the specified name and transformation
-/// to the list of envelopes.
+/// as a constituent of the envelope envName.
 
   if (fDebug) {
     cout << "... Adding constituent " << name
@@ -447,7 +428,7 @@ void  AliMUONGeometryEnvelopeStore::AddEnvelopeConstituent(const TString& name,
                                           const TGeoTranslation& translation)
 {
 /// Add the volume with the specified name and transformation
-/// to the list of envelopes.
+/// as a constituent of the envelope envName.
 
   if (fDebug) {
     cout << "... Adding constituent " << name
@@ -473,7 +454,7 @@ void  AliMUONGeometryEnvelopeStore::AddEnvelopeConstituent(const TString& name,
                                          const TGeoRotation& rotation)
 {
 /// Add the volume with the specified name and transformation
-/// to the list of envelopes.
+/// as a constituent of the envelope envName.
 
   if (fDebug) {
     cout << "... Adding constituent " << name
@@ -498,7 +479,7 @@ void  AliMUONGeometryEnvelopeStore::AddEnvelopeConstituent(const TString& name,
                                           const TGeoCombiTrans& transform)
 {
 /// Add the volume with the specified name and transformation
-/// to the list of envelopes.
+/// as a constituent of the envelope envName.
 
   if (fDebug) {
     cout << "... Adding constituent " << name
@@ -523,7 +504,7 @@ void  AliMUONGeometryEnvelopeStore::AddEnvelopeConstituentParam(const TString& n
                                         Int_t npar, Double_t* param) 
 {
 /// Add the volume with the specified name and transformation
-/// to the list of envelopes.
+/// as a constituent of the envelope envName.
 
   if (fDebug) {
     cout << "... Adding parameterised constituent " << name
@@ -548,7 +529,7 @@ void  AliMUONGeometryEnvelopeStore::AddEnvelopeConstituentParam(const TString& n
                                          Int_t npar, Double_t* param)
 {
 /// Add the volume with the specified name and transformation
-/// to the list of envelopes.
+/// as a constituent of the envelope envName.
 
   if (fDebug) {
     cout << "... Adding parameterised constituent " << name
@@ -575,7 +556,7 @@ void  AliMUONGeometryEnvelopeStore::AddEnvelopeConstituentParam(const TString& n
                                          Int_t npar, Double_t* param)
 {
 /// Add the volume with the specified name and transformation
-/// to the list of envelopes.
+/// as a constituent of the envelope envName.
 
   if (fDebug) {
     cout << "... Adding parameterised constituent " << name
@@ -601,7 +582,7 @@ void  AliMUONGeometryEnvelopeStore::AddEnvelopeConstituentParam(const TString& n
                                          Int_t npar, Double_t* param)
 {
 /// Add the volume with the specified name and transformation
-/// to the list of envelopes.
+/// as a constituent of the envelope envName.
 
   if (fDebug) {
     cout << "... Adding parameterised constituent " << name
index 1e73b8f..bbb27bf 100644 (file)
@@ -10,7 +10,7 @@
 /// Class for definititon of the temporary volume envelopes
 /// used in geometry construction
 ///
-/// Author: Ivana Hrivnacova, IPN Orsay
+/// \author Ivana Hrivnacova, IPN Orsay
 
 #ifndef ALI_MUON_GEOMETRY_ENVELOPE_STORE_H
 #define ALI_MUON_GEOMETRY_ENVELOPE_STORE_H
@@ -34,13 +34,8 @@ class AliMUONGeometryEnvelopeStore : public TObject
   public:
     AliMUONGeometryEnvelopeStore(AliMUONGeometryStore* detElements);
     AliMUONGeometryEnvelopeStore();
-    AliMUONGeometryEnvelopeStore(const AliMUONGeometryEnvelopeStore& rhs);
     virtual ~AliMUONGeometryEnvelopeStore();
 
-    // operators  
-    AliMUONGeometryEnvelopeStore& 
-    operator = (const AliMUONGeometryEnvelopeStore& rhs);
-  
     // methods
         
           // adding virtual envelopes  
@@ -124,6 +119,10 @@ class AliMUONGeometryEnvelopeStore : public TObject
     const TObjArray*  GetEnvelopes() const;
     Int_t             GetNofDetElements() const;
 
+  protected:
+    AliMUONGeometryEnvelopeStore(const AliMUONGeometryEnvelopeStore& rhs);
+    AliMUONGeometryEnvelopeStore& operator = (const AliMUONGeometryEnvelopeStore& rhs);
+
   private:
     // methods
     TGeoHMatrix ConvertDETransform(const TGeoHMatrix& transform) const;
@@ -134,11 +133,11 @@ class AliMUONGeometryEnvelopeStore : public TObject
     TObjArray*  fEnvelopes; ///< \brief the envelopes names and transformations
                            /// wrt to the chamber position in mother volume                                 
     AliMUONGeometryStore*  fDetElements; ///< \brief detection elements
-                            /// used for alignement of enevelopes
+                                         /// used for alignement of envelopes
     TGeoCombiTrans fReferenceFrame; ///< \brief the transformation from the builder 
                                     /// reference frame to that of the transform 
                                    /// data files
-    Bool_t      fDebug;     ///< Switch for debugging  
+    Bool_t      fDebug;     ///< Switch for debugging  \deprecated - use AliLog instead
     Bool_t      fAlign;     ///< option to read transformations from a file
  
   ClassDef(AliMUONGeometryEnvelopeStore,2) // Geometry envelope store
@@ -146,18 +145,26 @@ class AliMUONGeometryEnvelopeStore : public TObject
 
 // inline functions
 
+/// Set debug option
+/// \deprecated - use AliLog instead
 inline void  AliMUONGeometryEnvelopeStore::SetDebug(Bool_t debug)
 { fDebug = debug; }
 
+/// Return align option - if true, transformations are read from a file
 inline Bool_t  AliMUONGeometryEnvelopeStore::GetAlign() const
 { return fAlign; }
 
+/// Set align option - if true, transformations are read from a file
 inline void AliMUONGeometryEnvelopeStore::SetAlign(Bool_t align)
 { fAlign = align; }
 
+/// Return the array of the envelopes names and transformations
+/// wrt to the chamber position in mother volume
 inline const TObjArray* AliMUONGeometryEnvelopeStore::GetEnvelopes() const
 { return fEnvelopes; }
 
+/// Set the transformation from the builder reference frame to that of the transform 
+/// data files
 inline void 
 AliMUONGeometryEnvelopeStore::SetReferenceFrame(const TGeoCombiTrans& referenceFrame)
 { fReferenceFrame = referenceFrame; }
index f686725..95c88ac 100644 (file)
 
 // $Id$
 //
-// Class AliMUONGeometryMisAligner 
-// ----------------------------
-// Class for misalignment of geometry transformations
-//
-// Authors: Bruce Becker, Javier Castillo
-
 //__________________________________________________________________
-//
-/////////////////////////////////////////////////////////////////////
-//This performs the misalignment on an existing muon arm geometry
-//  based on the standard definition of the detector elements in 
-//  $ALICE_ROOT/MUON/data
-//
-//  --> User has to specify the magnitude of the alignments, in the Cartesian 
-//  co-ordiantes (which are used to apply translation misalignments) and in the
-//  spherical co-ordinates (which are used to apply angular displacements)
-//  --> If the constructor is used with no arguments, user has to set 
-//  misalignment ranges by hand using the methods : 
-//  SetApplyMisAlig, SetMaxCartMisAlig, SetMaxAngMisAlig, SetXYAngMisAligFactor
-//  (last method takes account of the fact that the misalingment is greatest in 
-//  the XY plane, since the detection elements are fixed to a support structure
-//  in this plane. Misalignments in the XZ and YZ plane will be very small 
-//  compared to those in the XY plane, which are small already - of the order 
-//  of microns)
-
-//  Note : If the detection elements are allowed to be misaligned in all
-//  directions, this has consequences for the alignment algorithm
-//  (AliMUONAlignment), which needs to know the number of free parameters. 
-//  Eric only allowed 3 :  x,y,theta_xy, but in principle z and the other 
-//  two angles are alignable as well.
+/// \class AliMUONGeometryMisAligner
+///
+/// This performs the misalignment on an existing muon arm geometry
+/// based on the standard definition of the detector elements in 
+/// $ALICE_ROOT/MUON/data
+///
+/// --> User has to specify the magnitude of the alignments, in the Cartesian 
+/// co-ordiantes (which are used to apply translation misalignments) and in the
+/// spherical co-ordinates (which are used to apply angular displacements)
+///
+/// --> If the constructor is used with no arguments, user has to set 
+/// misalignment ranges by hand using the methods : 
+/// SetApplyMisAlig, SetMaxCartMisAlig, SetMaxAngMisAlig, SetXYAngMisAligFactor
+/// (last method takes account of the fact that the misalingment is greatest in 
+/// the XY plane, since the detection elements are fixed to a support structure
+/// in this plane. Misalignments in the XZ and YZ plane will be very small 
+/// compared to those in the XY plane, which are small already - of the order 
+/// of microns)
+///
+/// Note : If the detection elements are allowed to be misaligned in all
+/// directions, this has consequences for the alignment algorithm
+/// (AliMUONAlignment), which needs to know the number of free parameters. 
+/// Eric only allowed 3 :  x,y,theta_xy, but in principle z and the other 
+/// two angles are alignable as well.
+///
+/// \authors Bruce Becker, Javier Castillo
 
 #include "AliMUONGeometryMisAligner.h"
 #include "AliMUONGeometryTransformer.h"
 #include <TMath.h>
 #include <TRandom.h>
 
+/// \cond CLASSIMP
 ClassImp(AliMUONGeometryMisAligner)
+/// \endcond
+
 //______________________________________________________________________________
 AliMUONGeometryMisAligner::AliMUONGeometryMisAligner(Double_t cartXMisAligM, Double_t cartXMisAligW, Double_t cartYMisAligM, Double_t cartYMisAligW, Double_t angMisAligM, Double_t angMisAligW)
 :TObject(), fDisplacementGenerator(0)
@@ -122,16 +122,6 @@ AliMUONGeometryMisAligner::AliMUONGeometryMisAligner()
 }
 
 //______________________________________________________________________________
-AliMUONGeometryMisAligner::
-AliMUONGeometryMisAligner(const AliMUONGeometryMisAligner & right):
-TObject(right)
-{
-  /// Copy constructor (not implemented)
-
-  AliFatal("Copy constructor not provided.");
-}
-
-//______________________________________________________________________________
 AliMUONGeometryMisAligner::~AliMUONGeometryMisAligner()
 {
 /// Destructor
@@ -139,21 +129,6 @@ AliMUONGeometryMisAligner::~AliMUONGeometryMisAligner()
   delete fDisplacementGenerator;
 }
 
-//______________________________________________________________________________
-AliMUONGeometryMisAligner & AliMUONGeometryMisAligner::
-operator=(const AliMUONGeometryMisAligner & right)
-{
-  /// Assignement operator (not implemented)
-
-  // check assignement to self
-  if (this == &right)
-    return *this;
-
-  AliFatal("Assignement operator not provided.");
-
-  return *this;
-}
-
 //_________________________________________________________________________
 void
 AliMUONGeometryMisAligner::SetXYAngMisAligFactor(Double_t factor)
@@ -177,10 +152,10 @@ void AliMUONGeometryMisAligner::SetZCartMisAligFactor(Double_t factor)
 }
 
 //_________________________________________________________________________
-void AliMUONGeometryMisAligner::GetUniMisAlign(Double_t *cartMisAlig, Double_t *angMisAlig) const
+void AliMUONGeometryMisAligner::GetUniMisAlign(Double_t cartMisAlig[3], Double_t angMisAlig[3]) const
 {
   /// Misalign using uniform distribution
-  /*
+  /**
     misalign the centre of the local transformation
     rotation axes : 
     fAngMisAlig[1,2,3] = [x,y,z]
@@ -202,7 +177,7 @@ void AliMUONGeometryMisAligner::GetUniMisAlign(Double_t *cartMisAlig, Double_t *
 void AliMUONGeometryMisAligner::GetGausMisAlign(Double_t cartMisAlig[3], Double_t angMisAlig[3]) const
 {
   /// Misalign using gaussian distribution
-  /*
+  /**
     misalign the centre of the local transformation
     rotation axes : 
     fAngMisAlig[1,2,3] = [x,y,z]
@@ -264,17 +239,16 @@ AliMUONGeometryTransformer *
 AliMUONGeometryMisAligner::MisAlign(const AliMUONGeometryTransformer *
                                 transformer, Bool_t verbose)
 {
-  /////////////////////////////////////////////////////////////////////
-  //   Takes the internal geometry module transformers, copies them
-  // and gets the Detection Elements from them.
-  // Calculates misalignment parameters and applies these
-  // to the local transform of the Detection Element
-  // Obtains the global transform by multiplying the module transformer
-  // transformation with the local transformation 
-  // Applies the global transform to a new detection element
-  // Adds the new detection element to a new module transformer
-  // Adds the new module transformer to a new geometry transformer
-  // Returns the new geometry transformer
+  /// Takes the internal geometry module transformers, copies them
+  /// and gets the Detection Elements from them.
+  /// Calculates misalignment parameters and applies these
+  /// to the local transform of the Detection Element
+  /// Obtains the global transform by multiplying the module transformer
+  /// transformation with the local transformation 
+  /// Applies the global transform to a new detection element
+  /// Adds the new detection element to a new module transformer
+  /// Adds the new module transformer to a new geometry transformer
+  /// Returns the new geometry transformer
 
 
   AliMUONGeometryTransformer *newGeometryTransformer =
index 370fb89..c862880 100644 (file)
@@ -6,8 +6,8 @@
 /// \ingroup geometry
 /// \class AliMUONGeometryMisAligner
 /// \brief Class for misalignment of geometry transformations
-///
-/// Authors: Bruce Becker, Javier Castillo
+//
+//  Authors: Bruce Becker, Javier Castillo
 
 
 #ifndef ALI_MUON_GEOMETRY_MIS_ALIGNER_H
@@ -36,28 +36,35 @@ class AliMUONGeometryMisAligner:public TObject
   AliMUONGeometryTransformer* MisAlign(const AliMUONGeometryTransformer* transformer, 
                                        Bool_t verbose = kFALSE);
   
+  /// Set cartesian displacement parameters different along x, y
   void SetCartMisAlig(Double_t xmean, Double_t xwidth, Double_t ymean, Double_t ywidth)
     {fCartXMisAligM = xmean; fCartXMisAligW = xwidth; fCartYMisAligM = ymean; fCartYMisAligW = ywidth;}
 
+  /// Set cartesian displacement parameters, the same along x, y
   void SetCartMisAlig(Double_t mean, Double_t width)
     {fCartXMisAligM = mean; fCartXMisAligW = width; fCartYMisAligM = mean; fCartYMisAligW = width;}
   
+  /// Set angular displacement
   void SetAngMisAlig(Double_t mean, Double_t width)
     {fAngMisAligM = mean; fAngMisAligW = width;}
   
-  void SetMaxCartMisAlig(Double_t width) // Kept for backward compatibility
+  /// Set cartesian displacement (Kept for backward compatibility)
+  void SetMaxCartMisAlig(Double_t width) 
     {fCartXMisAligM = 0.0; fCartXMisAligW = width; fCartYMisAligM = 0.0; fCartYMisAligW = width;}
   
-  void SetMaxAngMisAlig(Double_t width) // Kept for backward compatibility
+  /// Set angular displacement (Kept for backward compatibility)
+  void SetMaxAngMisAlig(Double_t width) 
     {fAngMisAligM = 0.0; fAngMisAligW = width;}
 
   void SetXYAngMisAligFactor(Double_t factor);
 
   void SetZCartMisAligFactor(Double_t factor);
 
+  /// Set option for gaussian distribution 
   void SetUseGaus(Bool_t usegaus)
     {fUseGaus=usegaus; fUseUni=!usegaus;}
 
+  /// Set option for uniform distribution 
   void SetUseUni(Bool_t useuni)
     {fUseGaus=!useuni; fUseUni=useuni;}
   
index 4c884fa..16067dd 100644 (file)
@@ -39,7 +39,9 @@
 #include <TArrayI.h>
 #include <Riostream.h>
 
+/// \cond CLASSIMP
 ClassImp(AliMUONGeometryModule)
+/// \endcond
 
 //______________________________________________________________________________
 AliMUONGeometryModule::AliMUONGeometryModule(Int_t moduleId)
@@ -81,16 +83,6 @@ AliMUONGeometryModule::AliMUONGeometryModule()
 /// Default constructor
 }
 
-
-//______________________________________________________________________________
-AliMUONGeometryModule::AliMUONGeometryModule(const AliMUONGeometryModule& rhs)
-  : TObject(rhs)
-{
-/// Protected copy constructor
-
-  AliFatal("Copy constructor is not implemented.");
-}
-
 //______________________________________________________________________________
 AliMUONGeometryModule::~AliMUONGeometryModule() 
 {
@@ -102,20 +94,6 @@ AliMUONGeometryModule::~AliMUONGeometryModule()
   delete fTransformer;
 }
 
-//______________________________________________________________________________
-AliMUONGeometryModule& 
-AliMUONGeometryModule::operator = (const AliMUONGeometryModule& rhs) 
-{
-/// Protected assignement operator
-
-  // check assignement to self
-  if (this == &rhs) return *this;
-
-  AliFatal("Assignment operator is not implemented.");
-    
-  return *this;  
-}
-
 //
 // private methods
 //
@@ -186,7 +164,7 @@ void  AliMUONGeometryModule::SetAlign(Bool_t align)
 AliMUONGeometryDetElement* 
 AliMUONGeometryModule::FindBySensitiveVolume(const TString& sensVolume) const
 {
-/// Find TGeoCombiTrans for the detector element Id specified by aligned volume 
+/// Find detection element which the sensitive volume specified by name belongs to
 
   Int_t detElemId = fSVMap->Get(sensVolume);
 
index f55e1fd..aadc5b1 100644 (file)
@@ -12,7 +12,7 @@
 /// (the transformations of detection elements, mapping between
 ///  sensitive volumes and detection elements).
 ///
-/// Author: Ivana Hrivnacova, IPN Orsay
+/// \author Ivana Hrivnacova, IPN Orsay
 
 #ifndef ALI_MUON_GEOMETRY_MODULE_H
 #define ALI_MUON_GEOMETRY_MODULE_H
@@ -89,26 +89,33 @@ class AliMUONGeometryModule : public TObject
 
 // inline functions
 
+/// Set virtuality (true if module is not represented by a real volume)
 inline void  AliMUONGeometryModule::SetIsVirtual(Bool_t isVirtual)
 { fIsVirtual = isVirtual; }
 
+/// Return true if module is not represented by a real volume
 inline Bool_t AliMUONGeometryModule::IsVirtual() const
 { return fIsVirtual; }  
 
+/// Return module ID
 inline Int_t  AliMUONGeometryModule::GetModuleId() const
 { return fTransformer->GetModuleId(); }
 
+/// Return the full path of aligned module volume or envelope in geometry
 inline TString AliMUONGeometryModule::GetVolumePath() const
 { return fTransformer->GetVolumePath(); }
 
+/// Return envelopes associated with this module
 inline  
 AliMUONGeometryEnvelopeStore* AliMUONGeometryModule::GetEnvelopeStore() const
 { return fEnvelopes; }
 
+/// Return sensitive volume map
 inline 
 AliMUONStringIntMap* AliMUONGeometryModule::GetSVMap() const
 { return fSVMap; }
 
+/// Return transformer
 inline 
 AliMUONGeometryModuleTransformer* AliMUONGeometryModule::GetTransformer() const
 { return fTransformer; }
index 6c6ccd6..356927e 100644 (file)
@@ -33,7 +33,9 @@
 #include <TArrayI.h>
 #include <Riostream.h>
 
+/// \cond CLASSIMP
 ClassImp(AliMUONGeometryModuleTransformer)
+/// \endcond
 
 //______________________________________________________________________________
 AliMUONGeometryModuleTransformer::AliMUONGeometryModuleTransformer(Int_t moduleId)
@@ -66,16 +68,6 @@ AliMUONGeometryModuleTransformer::AliMUONGeometryModuleTransformer()
 
 
 //______________________________________________________________________________
-AliMUONGeometryModuleTransformer::AliMUONGeometryModuleTransformer(
-                                    const AliMUONGeometryModuleTransformer& rhs)
-  : TObject(rhs)
-{
-/// Protected copy constructor
-
-  AliFatal("Copy constructor is not implemented.");
-}
-
-//______________________________________________________________________________
 AliMUONGeometryModuleTransformer::~AliMUONGeometryModuleTransformer() 
 {
 /// Destructor
@@ -84,21 +76,6 @@ AliMUONGeometryModuleTransformer::~AliMUONGeometryModuleTransformer()
   delete fDetElements;
 }
 
-//______________________________________________________________________________
-AliMUONGeometryModuleTransformer& 
-AliMUONGeometryModuleTransformer::operator = (
-                                    const AliMUONGeometryModuleTransformer& rhs) 
-{
-/// Protected assignement operator
-
-  // check assignement to self
-  if (this == &rhs) return *this;
-
-  AliFatal("Assignment operator is not implemented.");
-    
-  return *this;  
-}
-
 //
 // public methods
 //
@@ -193,7 +170,7 @@ TString AliMUONGeometryModuleTransformer::GetVolumeName() const
 //______________________________________________________________________________
 TString AliMUONGeometryModuleTransformer::GetMotherVolumeName() const
 { 
-/// Extract volume name from the path
+/// Extract mother volume name from the path
   
   std::string volPath = fVolumePath.Data();
   std::string::size_type first = volPath.rfind('/');
@@ -210,7 +187,7 @@ AliMUONGeometryDetElement*
 AliMUONGeometryModuleTransformer::GetDetElement(Int_t detElemId, Bool_t warn) const
 {
 /// Return the detection element specified by detElemId.
-/// Give error if detection element is not defined.
+/// Give error if detection element is not defined and warn is true.
 
    // Get detection element
    AliMUONGeometryDetElement* detElement
index 5068c36..0b567e9 100644 (file)
@@ -6,13 +6,12 @@
 
 /// \ingroup geometry
 /// \class AliMUONGeometryModuleTransformer
-/// \brief Geometry transformationer for detector module
+/// \brief Geometry transformer for a detector module
 ///
-/// Class for definition of the detector module parameters
-/// (the transformations of detection elements, mapping between
-///  sensitive volumes and detection elements).
+/// Class for definition of the trasformation for adetector module
+/// and its detection elements
 ///
-/// Author: Ivana Hrivnacova, IPN Orsay
+/// \author Ivana Hrivnacova, IPN Orsay
 
 #ifndef ALI_MUON_GEOMETRY_MODULE_TRANSFORMER_H
 #define ALI_MUON_GEOMETRY_MODULE_TRANSFORMER_H
@@ -69,7 +68,6 @@ class AliMUONGeometryModuleTransformer : public TObject
 
   protected:
     AliMUONGeometryModuleTransformer(const AliMUONGeometryModuleTransformer& rhs);
-    // operators  
     AliMUONGeometryModuleTransformer& 
       operator = (const AliMUONGeometryModuleTransformer& rhs);
 
@@ -79,7 +77,7 @@ class AliMUONGeometryModuleTransformer : public TObject
     TString               fVolumePath; ///< \brief the full path of aligned module volume
                                        /// or envelope in geometry
     TGeoHMatrix*          fTransformation;///< \brief the module transformation wrt to top
-                                          /// volume
+                                          /// volume (world)
     AliMUONGeometryStore* fDetElements;   ///< detection elements
  
   ClassDef(AliMUONGeometryModuleTransformer,3) // MUON geometry module class
@@ -87,22 +85,27 @@ class AliMUONGeometryModuleTransformer : public TObject
 
 // inline functions
 
+/// Set the full path of aligned module volume or envelope in geometry
 inline void 
 AliMUONGeometryModuleTransformer::SetVolumePath(const TString& volumePath)
 { fVolumePath = volumePath; }
 
+/// Return module ID
 inline Int_t  
 AliMUONGeometryModuleTransformer::GetModuleId() const
 { return fModuleId; }
 
+/// Return the full path of aligned module volume or envelope in geometry
 inline TString 
 AliMUONGeometryModuleTransformer::GetVolumePath() const
 { return fVolumePath; }
 
+/// Return the module transformation wrt to the top volume (world)
 inline const TGeoHMatrix* 
 AliMUONGeometryModuleTransformer::GetTransformation() const 
 { return fTransformation; }
 
+/// Return detection elements associated with this module
 inline  AliMUONGeometryStore* 
 AliMUONGeometryModuleTransformer::GetDetElementStore() const
 { return fDetElements; }
index df35483..fbf897c 100644 (file)
@@ -38,7 +38,9 @@
 
 const Float_t  AliMUONGeometrySegmentation::fgkMaxDistance = 1.0e6;
 
+/// \cond CLASSIMP
 ClassImp(AliMUONGeometrySegmentation)
+/// \endcond
 
 //______________________________________________________________________________
 AliMUONGeometrySegmentation::AliMUONGeometrySegmentation(
@@ -78,17 +80,6 @@ AliMUONGeometrySegmentation::AliMUONGeometrySegmentation()
 }
 
 //______________________________________________________________________________
-AliMUONGeometrySegmentation::AliMUONGeometrySegmentation(
-                                  const AliMUONGeometrySegmentation& rhs) 
-  : TObject(rhs)
-{
-/// Protected copy constructor
-
-  AliFatal("Copy constructor is not implemented.");
-}
-
-#include <Riostream.h>
-//______________________________________________________________________________
 AliMUONGeometrySegmentation::~AliMUONGeometrySegmentation() 
 {
 /// Destructor
@@ -100,24 +91,6 @@ AliMUONGeometrySegmentation::~AliMUONGeometrySegmentation()
 } 
 
 //
-// operators
-//
-
-//______________________________________________________________________________
-AliMUONGeometrySegmentation& 
-AliMUONGeometrySegmentation::operator=(const AliMUONGeometrySegmentation& rhs)
-{
-/// Protected assignment operator 
-
-  // check assignement to self
-  if (this == &rhs) return *this;
-
-  AliFatal("Assignment operator is not implemented.");
-    
-  return *this;  
-}
-
-//
 // private methods
 //
 
@@ -186,7 +159,7 @@ AliMUONGeometrySegmentation::GetDESegmentation(Int_t detElemId, Bool_t warn) con
 AliMUONGeometryDirection 
 AliMUONGeometrySegmentation::GetDirection(Int_t detElemId) const
 {
-/// Return direction with a constant pad size 
+/// Return direction with a constant pad size. 
 /// (Direction or coordinate where the resolution is the best)
 
   if (!OwnNotify(detElemId)) return kDirUndefined;
@@ -213,7 +186,7 @@ TString AliMUONGeometrySegmentation::GetDEName(Int_t detElemId) const
 //______________________________________________________________________________
 void AliMUONGeometrySegmentation::Print(Option_t* opt) const
 {
-// Print DE segmentations
+/// Print DE segmentations
 
   std::cout << "fDESegmentations (class " 
            << fDESegmentations->Class()->GetName() << ") entries=" 
@@ -281,7 +254,7 @@ Bool_t  AliMUONGeometrySegmentation::GetPadI(Int_t detElemId,
 Bool_t
 AliMUONGeometrySegmentation::HasPad(Int_t detElemId, Int_t ix, Int_t iy)
 {
-// Tells if a given pad exists in a given detector element
+/// Tell if a given pad exists in a given detector element
 
   if (!OwnNotify(detElemId)) return false;
        
@@ -293,7 +266,7 @@ Bool_t
 AliMUONGeometrySegmentation::HasPad(Int_t detElemId, 
                                     Float_t& xg, Float_t& yg, Float_t& zg)
 {
-// Tells if a given pad exists in a given detector element
+/// Tell if a given pad exists in a given detector element
 
   if (!OwnNotify(detElemId)) return false;
        
@@ -384,7 +357,7 @@ Float_t AliMUONGeometrySegmentation::Dpx(Int_t detElemId, Int_t isector) const
 //______________________________________________________________________________
 Float_t AliMUONGeometrySegmentation::Dpy(Int_t detElemId, Int_t isector) const
 {
-/// Pad size in x, y by Sector 
+/// Pad size in y by Sector 
 
   if (!OwnNotify(detElemId)) return 0.;
 
@@ -428,7 +401,7 @@ void  AliMUONGeometrySegmentation::SetPad(Int_t detElemId, Int_t ix, Int_t iy)
 void  AliMUONGeometrySegmentation::SetHit(Int_t detElemId, 
                                         Float_t xghit, Float_t yghit, Float_t zghit)
 {
-/// Set hit position
+/// Set hit position.
 /// Sets virtual hit position, needed for evaluating pad response 
 /// outside the tracking program 
 /// From AliMUONGeometrySegmentationV01.
@@ -562,7 +535,7 @@ Int_t  AliMUONGeometrySegmentation::ISector()
 //______________________________________________________________________________
 Int_t AliMUONGeometrySegmentation::Sector(Int_t detElemId, Int_t ix, Int_t iy)
 {
-/// Calculate sector from pad coordinates
+/// Calculate sector from pad indices
 
   if (!OwnNotify(detElemId)) return 0;
 
index 916bd08..23c6811 100644 (file)
@@ -11,7 +11,7 @@
 /// composed of the segmentations of detection elements.
 /// Applies transformations defined in geometry.
 ///
-/// Author:Ivana Hrivnacova, IPN Orsay
+/// \author Ivana Hrivnacova, IPN Orsay
 
 #ifndef ALI_MUON_GEOMETRY_SEGMENTATION_H
 #define ALI_MUON_GEOMETRY_SEGMENTATION_H
@@ -183,8 +183,6 @@ class AliMUONGeometrySegmentation : public TObject
        
   protected:
     AliMUONGeometrySegmentation(const AliMUONGeometrySegmentation& rhs);
-  
-    // operators
     AliMUONGeometrySegmentation& operator=(const AliMUONGeometrySegmentation & rhs);
 
   private:
@@ -210,6 +208,7 @@ class AliMUONGeometrySegmentation : public TObject
 
 // inline functions
 
+/// Return associated geometry transformer
 inline 
 const AliMUONGeometryModuleTransformer* 
 AliMUONGeometrySegmentation::GetTransformer() const
index 7f3ef84..58a23cd 100644 (file)
@@ -33,7 +33,9 @@
 const Int_t AliMUONGeometryStore::fgkInitSize = 100;
 const Int_t AliMUONGeometryStore::fgkCoefficient = 100;
 
+/// \cond CLASSIMP
 ClassImp(AliMUONGeometryStore)
+/// \endcond
 
 //
 // static methods
@@ -42,8 +44,7 @@ ClassImp(AliMUONGeometryStore)
 //______________________________________________________________________________
 Int_t AliMUONGeometryStore::GetModuleId(Int_t detElemId)
 {
-// Get module Id from detection element Id
-// ---
+/// Get module Id from detection element Id
 
   return detElemId/fgkCoefficient - 1;
 }  
@@ -72,35 +73,12 @@ AliMUONGeometryStore::AliMUONGeometryStore()
 }
 
 //______________________________________________________________________________
-AliMUONGeometryStore::AliMUONGeometryStore(const AliMUONGeometryStore& rhs)
-  : TObject(rhs)
-{
-/// Protected copy constructor
-
-  AliFatal("Copy constructor is not implemented.");
-}
-
-//______________________________________________________________________________
 AliMUONGeometryStore::~AliMUONGeometryStore() 
 {
 /// Destructor
 
 }
 
-//______________________________________________________________________________
-AliMUONGeometryStore& 
-AliMUONGeometryStore::operator = (const AliMUONGeometryStore& rhs) 
-{
-/// Protected assignment operator 
-
- // check assignement to self
-  if (this == &rhs) return *this;
-
-  AliFatal("Assignment operator is not implemented.");
-    
-  return *this;  
-}
-
 //
 // private methods
 //
@@ -108,7 +86,7 @@ AliMUONGeometryStore::operator = (const AliMUONGeometryStore& rhs)
 //______________________________________________________________________________
 Int_t AliMUONGeometryStore::GetDEIndex(Int_t detElemId) const
 {
-/// Returns the index of detector element specified by detElemId
+/// Return the index of detector element specified by detElemId
 
   return detElemId - detElemId/fgkCoefficient*fgkCoefficient;
  }  
@@ -142,7 +120,7 @@ void AliMUONGeometryStore::Add(Int_t objectId, TObject* object)
 TObject* 
 AliMUONGeometryStore::Get(Int_t objectId, Bool_t warn) const
 {
-/// Returns the object for the specified detector element Id
+/// Return the object for the specified detector element Id
 
   Int_t index = GetDEIndex(objectId);
   
@@ -157,8 +135,8 @@ AliMUONGeometryStore::Get(Int_t objectId, Bool_t warn) const
 //______________________________________________________________________________
 Int_t  AliMUONGeometryStore::GetNofEntries() const
 {
-/// Return number of entries
-/// Add check if the array is already filled
+/// Return number of entries.
+/// \todo Add check if the array is already filled
 
   return fObjects.GetEntriesFast();
 }  
@@ -169,7 +147,7 @@ TObject*
 AliMUONGeometryStore::GetEntry(Int_t index) const
 {
 /// Return entry at specified index.
-/// Add check if the array is already filled
+/// \todo Add check if the array is already filled
   
   return (TObject*) fObjects.At(index);
 }  
index aadab58..f39cd45 100644 (file)
@@ -11,7 +11,7 @@
 /// which are sorted using the AliMUONVGeometryDEIndexing class.
 /// The class provides fast access to detection element via detElemId.
 ///
-/// Author: Ivana Hrivnacova, IPN Orsay
+/// \author Ivana Hrivnacova, IPN Orsay
 
 #ifndef ALI_MUON_GEOMETRY_STORE_H
 #define ALI_MUON_GEOMETRY_STORE_H
@@ -41,8 +41,6 @@ class AliMUONGeometryStore : public TObject
 
   protected:
     AliMUONGeometryStore(const AliMUONGeometryStore& rhs);
-
-    // operators  
     AliMUONGeometryStore& operator = (const AliMUONGeometryStore& rhs);
   
   private:
index f6885a0..9d0a8a3 100644 (file)
@@ -40,7 +40,9 @@
 
 #include <sstream>
 
+/// \cond CLASSIMP
 ClassImp(AliMUONGeometryTransformer)
+/// \endcond
  
 //______________________________________________________________________________
 AliMUONGeometryTransformer::AliMUONGeometryTransformer(Bool_t isOwner)
@@ -65,16 +67,6 @@ AliMUONGeometryTransformer::AliMUONGeometryTransformer()
 } 
 
 //______________________________________________________________________________
-AliMUONGeometryTransformer::AliMUONGeometryTransformer(
-                                   const AliMUONGeometryTransformer& right) 
-  : TObject(right) 
-{  
-/// Copy constructor (not implemented)
-
-  AliFatal("Copy constructor not provided.");
-}
-
-//______________________________________________________________________________
 AliMUONGeometryTransformer::~AliMUONGeometryTransformer()
 {
 /// Destructor
@@ -83,20 +75,6 @@ AliMUONGeometryTransformer::~AliMUONGeometryTransformer()
   delete fMisAlignArray;
 }
 
-//______________________________________________________________________________
-AliMUONGeometryTransformer& 
-AliMUONGeometryTransformer::operator=(const AliMUONGeometryTransformer& right)
-{
-/// Assignement operator (not implemented)
-
-  // check assignement to self
-  if (this == &right) return *this;
-
-  AliFatal("Assignement operator not provided.");
-    
-  return *this;  
-}    
-
 //
 // private methods
 //
@@ -125,8 +103,7 @@ TGeoHMatrix AliMUONGeometryTransformer::GetTransform(
                  Double_t a1, Double_t a2, Double_t a3, 
                  Double_t a4, Double_t a5, Double_t a6) const
 {                
-// Builds the transformation from the given parameters
-// ---
+/// Build the transformation from the given parameters
 
   // Compose transform
   return TGeoCombiTrans(TGeoTranslation(x, y, z), 
@@ -138,8 +115,7 @@ TGeoHMatrix AliMUONGeometryTransformer::GetTransform(
 void AliMUONGeometryTransformer::FillModuleVolPath(Int_t moduleId,
                                            const TString& volPath) 
 {
-// Create module with the given moduleId and volPath
-// ---
+/// Create module with the given moduleId and volPath
 
   // Get/Create geometry module transformer
   AliMUONGeometryModuleTransformer* moduleTransformer
@@ -156,7 +132,7 @@ void AliMUONGeometryTransformer::FillModuleVolPath(Int_t moduleId,
 void AliMUONGeometryTransformer::FillDetElemVolPath(Int_t detElemId, 
                                            const TString& volPath) 
 {
-// Create detection element with the given detElemId and volPath
+/// Create detection element with the given detElemId and volPath
 
   // Module Id
   Int_t moduleId = AliMUONGeometryStore::GetModuleId(detElemId);
@@ -178,8 +154,7 @@ void AliMUONGeometryTransformer::FillModuleTransform(Int_t moduleId,
                  Double_t a1, Double_t a2, Double_t a3,
                  Double_t a4, Double_t a5, Double_t a6) 
 {
-// Fill the transformation of the module.
-// ---
+/// Fill the transformation of the module.
 
   // Get/Create geometry module transformer
   moduleId--;
@@ -207,8 +182,7 @@ void AliMUONGeometryTransformer::FillDetElemTransform(
                  Double_t a1, Double_t a2, Double_t a3,
                  Double_t a4, Double_t a5, Double_t a6) 
 {
-// Fill the transformation of the detection element.
-// ---
+/// Fill the transformation of the detection element.
 
   // Module Id
   Int_t moduleId = AliMUONGeometryStore::GetModuleId(detElemId);
@@ -248,8 +222,7 @@ void AliMUONGeometryTransformer::FillDetElemTransform(
 Bool_t  
 AliMUONGeometryTransformer::ReadVolPaths(ifstream& in)
 {
-// Reads modules and detection element volume paths from stream
-// ---
+/// Read modules and detection element volume paths from stream
 
   Int_t id;
   TString key, volumePath;
@@ -282,9 +255,8 @@ AliMUONGeometryTransformer::ReadVolPaths(ifstream& in)
 //______________________________________________________________________________
 TString  AliMUONGeometryTransformer::ReadModuleTransforms(ifstream& in)
 {
-// Reads and fills modules transformations from a file
-// Returns true, if reading finished correctly.
-// ---
+/// Read and fill modules transformations from the stream.
+/// Return true, if reading finished correctly.
 
   TString key("CH");
   while ( key == TString("CH") ) {
@@ -325,9 +297,8 @@ TString  AliMUONGeometryTransformer::ReadModuleTransforms(ifstream& in)
 //______________________________________________________________________________
 TString  AliMUONGeometryTransformer::ReadDetElemTransforms(ifstream& in)
 {
-// Reads detection elements transformations from a file
-// Returns true, if reading finished correctly.
-// ---
+/// Read detection elements transformations from the stream.
+/// Return true, if reading finished correctly.
 
   TString key("DE");
   while ( key == TString("DE") ) {
@@ -371,7 +342,7 @@ TString  AliMUONGeometryTransformer::ReadDetElemTransforms(ifstream& in)
 Bool_t  
 AliMUONGeometryTransformer::LoadTransforms(TGeoManager* tgeoManager)
 {
-/// Loads transformations for defined modules and detection elements
+/// Load transformations for defined modules and detection elements
 /// from the root file
 
   if ( !tgeoManager) {
@@ -437,9 +408,8 @@ AliMUONGeometryTransformer::LoadTransforms(TGeoManager* tgeoManager)
 Bool_t  
 AliMUONGeometryTransformer::ReadVolPaths(const TString& fileName)
 {
-// Reads detection element volume paths from a file
-// Returns true, if reading finished correctly.
-// ---
+/// Read detection element volume paths from a file.
+/// Return true, if reading finished correctly.
 
   // File path
   TString filePath = gSystem->Getenv("ALICE_ROOT");
@@ -462,9 +432,8 @@ AliMUONGeometryTransformer::ReadVolPaths(const TString& fileName)
 Bool_t  
 AliMUONGeometryTransformer::ReadTransformations(const TString& fileName)
 {
-// Reads transformations from a file
-// Returns true, if reading finished correctly.
-// ---
+/// Read transformations from a file.
+/// Return true, if reading finished correctly.
 
   // File path
   TString filePath = gSystem->Getenv("ALICE_ROOT");
@@ -499,9 +468,8 @@ AliMUONGeometryTransformer::ReadTransformations(const TString& fileName)
 Bool_t  
 AliMUONGeometryTransformer::ReadTransformations2(const TString& fileName)
 {
-// Reads transformations from root geometry file
-// Returns true, if reading finished correctly.
-// ---
+/// Read transformations from root geometry file.
+/// Return true, if reading finished correctly.
 
   // File path
   TString filePath = gSystem->Getenv("ALICE_ROOT");
@@ -521,8 +489,7 @@ AliMUONGeometryTransformer::ReadTransformations2(const TString& fileName)
 void AliMUONGeometryTransformer::WriteTransform(ofstream& out,
                                    const TGeoMatrix* transform) const
 {
-// Writes the transformations 
-// ---
+/// Write given transformation 
 
   out << "   pos: ";
   const Double_t* xyz = transform->GetTranslation();
@@ -548,7 +515,7 @@ void AliMUONGeometryTransformer::WriteTransform(ofstream& out,
 //______________________________________________________________________________
 void AliMUONGeometryTransformer::WriteModuleVolPaths(ofstream& out) const
 {
-// Write modules volume paths
+/// Write module volume paths for all module transformers
 
   for (Int_t i=0; i<fModuleTransformers->GetEntriesFast(); i++) {
     AliMUONGeometryModuleTransformer* moduleTransformer 
@@ -565,7 +532,8 @@ void AliMUONGeometryTransformer::WriteModuleVolPaths(ofstream& out) const
 //______________________________________________________________________________
 void AliMUONGeometryTransformer::WriteDetElemVolPaths(ofstream& out) const
 {
-// Write detection elements volume paths
+/// Write detection element volume paths for all detection elements in all 
+/// module transformers
 
   for (Int_t i=0; i<fModuleTransformers->GetEntriesFast(); i++) {
     AliMUONGeometryModuleTransformer* moduleTransformer 
@@ -589,7 +557,7 @@ void AliMUONGeometryTransformer::WriteDetElemVolPaths(ofstream& out) const
 //______________________________________________________________________________
 void AliMUONGeometryTransformer::WriteModuleTransforms(ofstream& out) const
 {
-// Write modules transformations
+/// Write module transformations for all module transformers
 
   for (Int_t i=0; i<fModuleTransformers->GetEntriesFast(); i++) {
     AliMUONGeometryModuleTransformer* moduleTransformer 
@@ -609,8 +577,8 @@ void AliMUONGeometryTransformer::WriteModuleTransforms(ofstream& out) const
 //______________________________________________________________________________
 void AliMUONGeometryTransformer::WriteDetElemTransforms(ofstream& out) const
 {
-// Writes detection elements transformations
-// ---
+/// Write detection element transformations for all detection elements in all 
+/// module transformers
 
   for (Int_t i=0; i<fModuleTransformers->GetEntriesFast(); i++) {
     AliMUONGeometryModuleTransformer* moduleTransformer 
@@ -669,7 +637,7 @@ AliMUONGeometryTransformer::ReadGeometryData(
                                 TGeoManager* tgeoManager)
 {
 /// Load geometry data from root geometry using defined
-/// voluem paths from file
+/// volume paths from file
 
   Bool_t result1 = ReadVolPaths(volPathFileName);
 
@@ -701,9 +669,8 @@ AliMUONGeometryTransformer::WriteGeometryData(
 Bool_t  
 AliMUONGeometryTransformer::WriteVolumePaths(const TString& fileName) const
 {
-// Writes volume paths for modules and detection element volumes into a file
-// Returns true, if writing finished correctly.
-// ---
+/// Write volume paths for modules and detection element volumes into a file.
+/// Return true, if writing finished correctly.
 
   // No writing
   // if builder is not associated with any geometry module
@@ -734,9 +701,8 @@ AliMUONGeometryTransformer::WriteVolumePaths(const TString& fileName) const
 Bool_t  
 AliMUONGeometryTransformer::WriteTransformations(const TString& fileName) const
 {
-// Writes transformations into a file
-// Returns true, if writing finished correctly.
-// ---
+/// Write transformations into a file.
+/// Return true, if writing finished correctly.
 
   // No writing
   // if builder is not associated with any geometry module
@@ -767,9 +733,8 @@ AliMUONGeometryTransformer::WriteTransformations(const TString& fileName) const
 Bool_t  
 AliMUONGeometryTransformer::WriteMisAlignmentData(const TString& fileName) const
 {
-// Writes misalignment data into a file
-// Returns true, if writing finished correctly.
-// ---
+/// Write misalignment data into a file
+/// Return true, if writing finished correctly.
 
   // No writing
   // if builder is not associated with any geometry module
@@ -802,7 +767,7 @@ AliMUONGeometryTransformer::WriteMisAlignmentData(const TString& fileName) const
 void AliMUONGeometryTransformer::AddModuleTransformer(
                           AliMUONGeometryModuleTransformer* moduleTransformer)
 {
-/// Add the geometrymodule to the array
+/// Add the module transformer to the array
 
   fModuleTransformers->AddAt(moduleTransformer, 
                              moduleTransformer->GetModuleId());
@@ -812,7 +777,7 @@ void AliMUONGeometryTransformer::AddModuleTransformer(
 void  AliMUONGeometryTransformer::AddMisAlignModule(Int_t moduleId, 
                                               const TGeoHMatrix& matrix)
 {
-/// Build AliAlignObjMatrix with module ID, its volumePaths
+/// Build AliAlignObjMatrix with module ID, its volumePath
 /// and the given delta transformation matrix                                        
 
   if ( ! fMisAlignArray )
@@ -842,7 +807,7 @@ void  AliMUONGeometryTransformer::AddMisAlignModule(Int_t moduleId,
 void  AliMUONGeometryTransformer::AddMisAlignDetElement(Int_t detElemId, 
                                               const TGeoHMatrix& matrix)
 {
-/// Build AliAlignObjMatrix with detection element ID, its volumePaths
+/// Build AliAlignObjMatrix with detection element ID, its volumePath
 /// and the given delta transformation matrix                                        
 
   if ( ! fMisAlignArray )
@@ -990,7 +955,7 @@ void AliMUONGeometryTransformer::Local2Global(Int_t detElemId,
 const AliMUONGeometryModuleTransformer* 
 AliMUONGeometryTransformer::GetModuleTransformer(Int_t index, Bool_t warn) const
 {
-/// Return the geometry module specified by index
+/// Return the geometry module transformer specified by index
 
   return GetModuleTransformerNonConst(index, warn);
 }    
@@ -1000,7 +965,7 @@ const AliMUONGeometryModuleTransformer*
 AliMUONGeometryTransformer::GetModuleTransformerByDEId(Int_t detElemId, 
                                                        Bool_t warn) const
 {
-/// Return the geometry module specified by index
+/// Return the geometry module transformer specified by detection element ID
 
   // Get module index
   Int_t index = AliMUONGeometryStore::GetModuleId(detElemId);
@@ -1012,7 +977,7 @@ AliMUONGeometryTransformer::GetModuleTransformerByDEId(Int_t detElemId,
 const AliMUONGeometryDetElement* 
 AliMUONGeometryTransformer::GetDetElement(Int_t detElemId, Bool_t warn) const
 {
-/// Return detection ellemnt with given detElemId                             
+/// Return detection element with given detElemId                             
 
   const AliMUONGeometryModuleTransformer* kTransformer 
     = GetModuleTransformerByDEId(detElemId, warn);
index 712ae1c..5eb8e2e 100644 (file)
@@ -14,7 +14,7 @@
 /// If geometry is loaded from a file, the list of aligned volume paths
 /// has to be read first from volpaths.dat file.
 /// 
-/// Author: Ivana Hrivnacova, IPN Orsay
+/// \author Ivana Hrivnacova, IPN Orsay
 
 #ifndef ALI_MUON_GEOMETRY_TRANSFORMER_H
 #define ALI_MUON_GEOMETRY_TRANSFORMER_H
@@ -139,9 +139,12 @@ class AliMUONGeometryTransformer : public TObject
 };
 
 // inline methods
+
+/// Return the number of contained module transformers
 inline Int_t AliMUONGeometryTransformer::GetNofModuleTransformers() const
 { return fModuleTransformers->GetEntriesFast(); }
 
+/// Return the array of misalignment data
 inline const TClonesArray* AliMUONGeometryTransformer::GetMisAlignmentData() const     
 { return fMisAlignArray; }                    
 
index 5f11328..147f446 100644 (file)
@@ -34,8 +34,9 @@
 
 #include "AliLog.h"
 
-
+/// \cond CLASSIMP
 ClassImp(AliMUONSegmentation)
+/// \endcond
  
 //______________________________________________________________________________
 AliMUONSegmentation::AliMUONSegmentation(Int_t nofModules)
@@ -80,15 +81,6 @@ AliMUONSegmentation::AliMUONSegmentation()
 } 
 
 //______________________________________________________________________________
-AliMUONSegmentation::AliMUONSegmentation(const AliMUONSegmentation& right) 
-  : TObject(right) 
-{  
-/// Protected copy constructor (not implemented)
-
-  AliFatal("Copy constructor not provided.");
-}
-
-//______________________________________________________________________________
 AliMUONSegmentation::~AliMUONSegmentation()
 {
 /// Destructor
@@ -101,20 +93,6 @@ AliMUONSegmentation::~AliMUONSegmentation()
   delete fModuleSegmentations[1];
 }
 
-//______________________________________________________________________________
-AliMUONSegmentation& 
-AliMUONSegmentation::operator=(const AliMUONSegmentation& right)
-{
-/// Protected assignement operator (not implemented)
-
-  // check assignement to self
-  if (this == &right) return *this;
-
-  AliFatal("Assignement operator not provided.");
-    
-  return *this;  
-}    
-
 //
 // public functions
 //
@@ -195,7 +173,7 @@ AliMUONGeometrySegmentation*
 AliMUONSegmentation::GetModuleSegmentation(
                         Int_t moduleId, Int_t cathod, Bool_t warn) const
 {
-/// Return the geometry module specified by moduleId
+/// Return the geometry module segmentation specified by moduleId
 
   if (cathod < 0 || cathod >= 2) {
     if (warn) {
@@ -267,7 +245,8 @@ AliMUONSegmentation::GetMpSegmentation(
 Bool_t 
 AliMUONSegmentation::HasDE(Int_t detElemId, Int_t cathod) const
 {
-  // Get DE segmentation 
+/// Return true if segmentation for detElemId and cathod is defined.
+
   const AliMUONVGeometryDESegmentation* kdeSegmentation
     = GetDESegmentation(detElemId, cathod, false);
     
@@ -279,8 +258,8 @@ AliMUONSegmentation::HasDE(Int_t detElemId, Int_t cathod) const
 TString 
 AliMUONSegmentation::GetDEName(Int_t detElemId, Int_t cathod) const
 {
+/// Get detection element name 
 
-  // Get geometry segmentation 
   AliMUONGeometrySegmentation* moduleSegmentation
     = GetModuleSegmentationByDEId(detElemId, cathod, true);
     
index 551442f..608953e 100644 (file)
 /// - mapping segmentation
 /// - DE segmentation (operating in local DE reference frame)
 /// - module segmentation (operating in global reference frame)
-/// As some detection element are sharing the same objects
+///
+/// As some detection elements are sharing the same objects
 /// (AliMpVSegmentation, AliMUONVGeometryDESegmentation),
 /// all segmentations objects have to be always deleted
 /// altogether via deleting this container object. 
 /// 
-/// Author: Ivana Hrivnacova, IPN Orsay
+/// \author Ivana Hrivnacova, IPN Orsay
 
 #ifndef ALI_MUON_SEGMENTATION_H
 #define ALI_MUON_SEGMENTATION_H
@@ -68,7 +69,7 @@ class AliMUONSegmentation : public TObject
 
     /** Mapping segmentations access by cathode number.
       cathod can be 0 or 1. Note that there's no trivial relationship
-      between the cathode number and whether the corresponding plane
+      between the cathod number and whether the corresponding plane
       is a Bending or NonBending one.
       **/
     const AliMpVSegmentation* GetMpSegmentation(
index 24ac2e7..f4d8210 100644 (file)
@@ -28,7 +28,9 @@
 #include "AliMUONStringIntMap.h"
 #include "AliLog.h"
 
+/// \cond CLASSIMP
 ClassImp(AliMUONStringIntMap)
+/// \endcond
 
 //______________________________________________________________________________
 AliMUONStringIntMap::AliMUONStringIntMap()
@@ -43,15 +45,6 @@ AliMUONStringIntMap::AliMUONStringIntMap()
 }
 
 //______________________________________________________________________________
-AliMUONStringIntMap::AliMUONStringIntMap(const AliMUONStringIntMap& rhs)
-  : TObject(rhs)
-{
-/// Protected copy constructor
-
-  AliFatal("Copy constructor is not implemented.");
-}
-
-//______________________________________________________________________________
 AliMUONStringIntMap::~AliMUONStringIntMap()
 {
 /// Destructor
@@ -59,21 +52,6 @@ AliMUONStringIntMap::~AliMUONStringIntMap()
   fFirstArray.Delete();
 }
 
-//______________________________________________________________________________
-AliMUONStringIntMap& 
-AliMUONStringIntMap::operator = (const AliMUONStringIntMap& rhs) 
-{
-/// Protected assignement operator
-
-  // check assignement to self
-  if (this == &rhs) return *this;
-
-  AliFatal("Assignment operator is not implemented.");
-    
-  return *this;  
-}
-
-
 //
 // public methods
 //
@@ -149,7 +127,7 @@ void AliMUONStringIntMap::Print(const char* /*option*/) const
 //______________________________________________________________________________
 void AliMUONStringIntMap::Print(const TString& key, ofstream& out) const
 {
-// Prints the map elements
+/// Print the map elements preceded by a key word
 
   for (Int_t i=0; i<fNofItems; i++) {
     out  << key << "  "
index 8b851c5..d574c81 100644 (file)
@@ -7,7 +7,7 @@
 /// \class AliMUONStringIntMap
 /// \brief Substitutes map <string, int> which ALICE does not allow to use 
 ///
-/// Author: Ivana Hrivnacova, IPN Orsay
+/// \author Ivana Hrivnacova, IPN Orsay
 
 #ifndef ALI_MUON_STRING_INT_MAP_H
 #define ALI_MUON_STRING_INT_MAP_H
@@ -32,8 +32,6 @@ class AliMUONStringIntMap : public TObject
     
   protected:
     AliMUONStringIntMap(const AliMUONStringIntMap& rhs);
-
-    // operators  
     AliMUONStringIntMap& operator = (const AliMUONStringIntMap& rhs);
  
   private:
index ffa14a0..4edb04a 100644 (file)
@@ -38,7 +38,9 @@
 #include "AliMUONStringIntMap.h"
 #include "AliLog.h"
 
+/// \cond CLASSIMP
 ClassImp(AliMUONVGeometryBuilder)
+/// \endcond
 
 //______________________________________________________________________________
 AliMUONVGeometryBuilder::AliMUONVGeometryBuilder(
@@ -49,7 +51,7 @@ AliMUONVGeometryBuilder::AliMUONVGeometryBuilder(
    fGeometryModules(0),
    fReferenceFrame()
  {
-// Standard constructor
+/// Standard constructor
 
   // Create the module geometries array
   fGeometryModules = new TObjArray();
@@ -79,42 +81,20 @@ AliMUONVGeometryBuilder::AliMUONVGeometryBuilder()
    fGeometryModules(0),
    fReferenceFrame()
 {
-// Default constructor
+/// Default constructor
 }
 
-
 //______________________________________________________________________________
-AliMUONVGeometryBuilder::AliMUONVGeometryBuilder(const AliMUONVGeometryBuilder& rhs)
-  : TObject(rhs)
+AliMUONVGeometryBuilder::~AliMUONVGeometryBuilder() 
 {
-// Protected copy constructor
-
-  AliFatal("Copy constructor is not implemented.");
-}
+/// Destructor
 
-//______________________________________________________________________________
-AliMUONVGeometryBuilder::~AliMUONVGeometryBuilder() {
-//
   if (fGeometryModules) {
     fGeometryModules->Clear(); // Sets pointers to 0 since it is not the owner
     delete fGeometryModules;
   }
 }
 
-//______________________________________________________________________________
-AliMUONVGeometryBuilder& 
-AliMUONVGeometryBuilder::operator = (const AliMUONVGeometryBuilder& rhs) 
-{
-// Protected assignement operator
-
-  // check assignement to self
-  if (this == &rhs) return *this;
-
-  AliFatal("Assignment operator is not implemented.");
-    
-  return *this;  
-}
-
 //
 // private methods
 //
@@ -123,7 +103,7 @@ AliMUONVGeometryBuilder::operator = (const AliMUONVGeometryBuilder& rhs)
 TGeoHMatrix 
 AliMUONVGeometryBuilder::ConvertTransform(const TGeoHMatrix& transform) const
 {
-// Convert transformation into the reference frame
+/// Convert transformation into the reference frame
 
   if ( fReferenceFrame.IsIdentity() )
     return transform;
@@ -138,7 +118,7 @@ AliMUONVGeometryBuilder::ConvertTransform(const TGeoHMatrix& transform) const
 TGeoHMatrix 
 AliMUONVGeometryBuilder::ConvertDETransform(const TGeoHMatrix& transform) const
 {
-// Convert transformation into the reference frame
+/// Convert DE transformation into the reference frame
 
   if ( fReferenceFrame.IsIdentity() )
     return transform;
@@ -152,8 +132,7 @@ AliMUONVGeometryBuilder::ConvertDETransform(const TGeoHMatrix& transform) const
 TString  AliMUONVGeometryBuilder::ComposePath(const TString& volName,
                                               Int_t copyNo) const
 {
-// Compose path from given volName and copyNo
-// ---
+/// Compose path from given volName and copyNo
 
   TString path = "/";
   path += volName;
@@ -167,9 +146,8 @@ TString  AliMUONVGeometryBuilder::ComposePath(const TString& volName,
 void AliMUONVGeometryBuilder::MapSV(const TString& path0, 
                                     const TString& volName, Int_t detElemId) const
 {
-// Update the path with all daughters volumes recursively
-// and map it to the detection element Id if it is a sensitive volume
-// ---
+/// Update the path with all daughters volumes recursively
+/// and map it to the detection element Id if it is a sensitive volume
 
   // Get module sensitive volumes map
   Int_t moduleId = AliMUONGeometryStore::GetModuleId(detElemId);
@@ -216,8 +194,7 @@ void AliMUONVGeometryBuilder::MapSV(const TString& path0,
 AliMUONGeometryModule*  
 AliMUONVGeometryBuilder::GetGeometry(Int_t moduleId) const
 {
-// Returns the module geometry specified by moduleId
-// ---
+/// Return the module geometry specified by moduleId
 
   for (Int_t i=0; i<fGeometryModules->GetEntriesFast(); i++) {
 
@@ -234,8 +211,7 @@ AliMUONVGeometryBuilder::GetGeometry(Int_t moduleId) const
 AliMUONGeometryEnvelopeStore*  
 AliMUONVGeometryBuilder::GetEnvelopes(Int_t moduleId) const
 {
-// Returns the envelope store of the module geometry specified by moduleId
-// ---
+/// Return the envelope store of the module geometry specified by moduleId
 
   AliMUONGeometryModule* geometry = GetGeometry(moduleId);
   
@@ -251,8 +227,7 @@ AliMUONVGeometryBuilder::GetEnvelopes(Int_t moduleId) const
 AliMUONStringIntMap*  
 AliMUONVGeometryBuilder::GetSVMap(Int_t moduleId) const
 {
-// Returns the transformation store of the module geometry specified by moduleId
-// ---
+/// Return the transformation store of the module geometry specified by moduleId
 
   AliMUONGeometryModule* geometry = GetGeometry(moduleId);
   
@@ -268,9 +243,8 @@ AliMUONVGeometryBuilder::GetSVMap(Int_t moduleId) const
 void AliMUONVGeometryBuilder::SetTranslation(Int_t moduleId, 
                                   const TGeoTranslation& translation)
 {
-// Sets the translation to the geometry module given by moduleId,
-// applies reference frame transformation 
-// ---
+/// Set the translation to the geometry module given by moduleId,
+/// apply reference frame transformation 
 
   AliMUONGeometryModule* geometry = GetGeometry(moduleId);
   
@@ -292,9 +266,8 @@ void AliMUONVGeometryBuilder::SetTransformation(Int_t moduleId,
                                   const TGeoTranslation& translation,
                                  const TGeoRotation& rotation)
 {
-// Sets the translation to the geometry module given by moduleId,
-// applies reference frame transformation 
-// ---
+/// Set the transformation to the geometry module given by moduleId,
+/// apply reference frame transformation 
 
   AliMUONGeometryModule* geometry = GetGeometry(moduleId);
   
@@ -373,7 +346,7 @@ void  AliMUONVGeometryBuilder::SetReferenceFrame(
 //______________________________________________________________________________
 void  AliMUONVGeometryBuilder::CreateDetElements() const
 {
-/// Create detection element and fill their global and
+/// Create detection elements and fill their global and
 /// local transformations from geometry.
 
   for (Int_t i=0; i<fGeometryModules->GetEntriesFast(); i++) {
@@ -426,8 +399,7 @@ void  AliMUONVGeometryBuilder::CreateDetElements() const
 //_____ _________________________________________________________________________
 void  AliMUONVGeometryBuilder::RebuildSVMaps(Bool_t withEnvelopes) const
 {
-// Clear the SV maps in memory and fill them from defined geometry.
-// ---
+/// Clear the SV maps in memory and fill them from defined geometry.
 
   for (Int_t i=0; i<fGeometryModules->GetEntriesFast(); i++) {
     AliMUONGeometryModule* geometry 
index 4c58bbd..4b1de52 100644 (file)
@@ -8,7 +8,7 @@
 /// \class AliMUONVGeometryBuilder
 /// \brief Abstract base class for geometry construction per module(s)
 ///
-/// Author: Ivana Hrivnacova, IPN Orsay
+/// \author Ivana Hrivnacova, IPN Orsay
 
 #ifndef ALI_MUON_V_GEOMETRY_BUILDER_H
 #define ALI_MUON_V_GEOMETRY_BUILDER_H
@@ -45,39 +45,39 @@ class AliMUONVGeometryBuilder : public TObject
     void  RebuildSVMaps(Bool_t withEnvelopes = true) const;
     void  CreateDetElements() const;
 
+                  /// Function to be overriden in a concrete chamber/station
+                 /// geometry builder class.
+                 /// Only materials that are not defined in the common
+                 /// functions should be defined here.
     virtual void CreateMaterials() {}  // make = 0; ?
-                  // Function to be overriden in a concrete chamber/station
-                 // geometry builder class.
-                 // Only materials that are not defined in the common
-                 // functions should be defined here.
 
+                  /// Function to be overriden in a concrete chamber/station
+                 /// geometry builder class. \n
+                 /// The geometry built there should not be placed
+                 /// in ALIC; but all volumes going to ALIC
+                 /// have to be added as envelopes to the chamber
+                 /// geometries
+                 /// (They will be then placed automatically 
+                 /// usind the provided transformation.
     virtual void CreateGeometry() = 0;
-                  // Function to be overriden in a concrete chamber/station
-                 // geometry builder class.
-                 // The geometry built there should not be placed
-                 // in ALIC; but all volumes going to ALIC
-                 // have to be added as envelopes to the chamber
-                 // geometries
-                 // (They will be then placed automatically 
-                 // usind the provided transformation.
 
+                  /// Function to be overriden in a concrete chamber/station
+                 /// geometry class. \n
+                 /// The transformation of each chamber(s) wrt ALICE
+                 /// should be defined and set to its geometry class. 
     virtual void SetTransformations() = 0;
-                  // Function to be overriden in a concrete chamber/station
-                 // geometry class.
-                 // The transformation of each chamber(s) wrt ALICE
-                 // should be defined and set to its geometry class. 
 
+                  /// Function to be overriden in a concrete chamber/station
+                 /// geometry class. \n
+                 /// The sensitive volumes Ids for each chamber
+                 /// should be defined and set to its geometry class. 
     virtual void SetSensitiveVolumes() = 0;
-                  // Function to be overriden in a concrete chamber/station
-                 // geometry class.
-                 // The sensitive volumes Ids for each chamber
-                 // should be defined and set to its geometry class. 
 
+                  /// Function to be overriden (and return false) 
+                 /// in the concrete geometry builder classes 
+                 /// which are already defined in the new ALICE
+                 /// coordinate frame
     virtual bool ApplyGlobalTransformation() { return true; }
-                  // Function to be overriden (and return false) 
-                 // in the concrete geometry builder classes 
-                 // which are already defined in the new ALICE
-                 // coordinate frame
 
     // access to module geometries
     Int_t  NofGeometries() const;
@@ -88,8 +88,6 @@ class AliMUONVGeometryBuilder : public TObject
 
   protected:
     AliMUONVGeometryBuilder(const AliMUONVGeometryBuilder& rhs);
-
-    // operators  
     AliMUONVGeometryBuilder& operator = (const AliMUONVGeometryBuilder& rhs);
 
     // methods
@@ -129,9 +127,11 @@ class AliMUONVGeometryBuilder : public TObject
 
 // inline functions
 
+/// Return the number of geometry modules
 inline Int_t  AliMUONVGeometryBuilder::NofGeometries() const
 { return fGeometryModules->GetEntriesFast(); }
 
+/// Return the \a i th geometry module
 inline AliMUONGeometryModule* AliMUONVGeometryBuilder::Geometry(Int_t i) const
 { return (AliMUONGeometryModule*)fGeometryModules->At(i); }
 
index e932273..dbe0473 100644 (file)
 
 #include "AliMUONVGeometryDESegmentation.h"
 
+/// \cond CLASSIMP
 ClassImp(AliMUONVGeometryDESegmentation)
+/// \endcond
 
 
 //______________________________________________________________________________
 AliMUONVGeometryDESegmentation::AliMUONVGeometryDESegmentation() 
 : AliSegmentation()
 {
-// Normal/default constructor
+/// Normal/default constructor
 }
 
 //______________________________________________________________________________
-AliMUONVGeometryDESegmentation::AliMUONVGeometryDESegmentation(
-                                  const AliMUONVGeometryDESegmentation& rhs) 
-  : AliSegmentation(rhs)
+AliMUONVGeometryDESegmentation::~AliMUONVGeometryDESegmentation() 
 {
-// Copy constructor
-}
-
-//______________________________________________________________________________
-AliMUONVGeometryDESegmentation::~AliMUONVGeometryDESegmentation() {
-// Destructor
+/// Destructor
 } 
-
-//
-// operators
-//
-
-//______________________________________________________________________________
-AliMUONVGeometryDESegmentation& 
-AliMUONVGeometryDESegmentation::operator=(const AliMUONVGeometryDESegmentation& rhs)
-{
-// Copy operator 
-
-  // check assignement to self
-  if (this == &rhs) return *this;
-
-  AliFatal("Assignment operator is not implemented.");
-    
-  return *this;  
-}
index 01a4fc5..9a4b7b6 100644 (file)
@@ -7,12 +7,9 @@
 /// \class AliMUONVGeometryDESegmentation
 /// \brief Extension for AliSegmentation interface for detection elements
 ///
-/// Extension for AliSegmentation interface,
-/// added functions:                                                         \n
-/// Bool_t  HasPad(Float_t x, Float_t y, Float_t z);                         \n
-/// Bool_t  HasPad(Int_t ix, Int_t iy);                                      \n
+/// \deprecated - To be removed with passing to maping segmentation interface
 ///
-/// Author:Ivana Hrivnacova, IPN Orsay
+/// \author Ivana Hrivnacova, IPN Orsay
 
 #ifndef ALI_MUON_V_GEOMETRY_DE_SEGMENTATION_H
 #define ALI_MUON_V_GEOMETRY_DE_SEGMENTATION_H
@@ -29,28 +26,26 @@ class AliMUONVGeometryDESegmentation : public AliSegmentation
     virtual ~AliMUONVGeometryDESegmentation();
 
     // methods
+                       /// Return true if a pad exists in the given position
     virtual Bool_t  HasPad(Float_t x, Float_t y, Float_t z) = 0; 
-                       // Returns true if a pad exists in the given position
+                       /// Return true if a pad with given indices exists
     virtual Bool_t  HasPad(Int_t ix, Int_t iy) = 0;
-                       // Returns true if a pad with given indices exists
 
+                       /// Return the direction with a constant pad size  
+                      /// (Direction or coordinate where the spatial resolution 
+                      /// is the best) \n
+                       /// Normally kDirY will correspond with cathode segmentation 
+                      /// for the bending plane and kDirX with cathode segmentation 
+                      /// for the non bending plane
     virtual AliMUONGeometryDirection  GetDirection() = 0;
-                       // Returns the direction with a constant pad size  
-                      // (Direction or coordinate where the spatial resolution 
-                      // is the best)
-                       // Normally kDirY will correspond with cathode segmentation 
-                      // for the bending plane and kDirX with cathode segmentation 
-                      // for the non bending plane
                       
+                       /// Access to mapping
     virtual const AliMpVSegmentation* GetMpSegmentation() const = 0;                  
-                       // Access to mapping
 
   protected:
     AliMUONVGeometryDESegmentation(const AliMUONVGeometryDESegmentation& rhs);
-  
-    // operators
     AliMUONVGeometryDESegmentation& operator=(
-      const AliMUONVGeometryDESegmentation & rhs);
+      const AliMUONVGeometryDESegmentation& rhs);
 
    ClassDef(AliMUONVGeometryDESegmentation,1) // Det element segmentation interface
 };