Updated comments for Doxygen
authorivana <ivana@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 15 Mar 2007 21:03:10 +0000 (21:03 +0000)
committerivana <ivana@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 15 Mar 2007 21:03:10 +0000 (21:03 +0000)
40 files changed:
MUON/AliMUON.h
MUON/AliMUON2DMapIterator.cxx
MUON/AliMUON2DMapIterator.h
MUON/AliMUON2DStoreValidator.h
MUON/AliMUONAlignment.h
MUON/AliMUONChamber.h
MUON/AliMUONChamberTrigger.cxx
MUON/AliMUONChamberTrigger.h
MUON/AliMUONCheck.h
MUON/AliMUONCheckItem.h
MUON/AliMUONClusterDrawAZ.h
MUON/AliMUONClusterFinderAZ.h
MUON/AliMUONClusterFinderVS.h
MUON/AliMUONClusterInput.h
MUON/AliMUONConstants.cxx
MUON/AliMUONData.cxx
MUON/AliMUONData.h
MUON/AliMUONDigitizerV3.cxx
MUON/AliMUONEventRecoCombi.h
MUON/AliMUONGeometryEnvelope.cxx
MUON/AliMUONGeometryModuleTransformer.h
MUON/AliMUONGeometrySegmentation.cxx
MUON/AliMUONGlobalTriggerBoard.cxx
MUON/AliMUONGlobalTriggerBoard.h
MUON/AliMUONHitForRec.h
MUON/AliMUONPixel.cxx
MUON/AliMUONPixel.h
MUON/AliMUONRawStreamTracker.cxx
MUON/AliMUONRawStreamTracker.h
MUON/AliMUONRawStreamTrigger.cxx
MUON/AliMUONRawStreamTrigger.h
MUON/AliMUONRecoTrack.cxx
MUON/AliMUONRecoTrack.h
MUON/AliMUONRegionalTriggerBoard.cxx
MUON/AliMUONRegionalTriggerBoard.h
MUON/AliMUONResponseTriggerV1.cxx
MUON/AliMUONResponseV0.h
MUON/AliMUONVTrackReconstructor.cxx
MUON/AliMUONVTrackReconstructor.h
MUON/AliMillepede.h

index f46d628..c3dfbe5 100644 (file)
@@ -150,7 +150,9 @@ class AliMUON : public  AliDetector
     //PH    virtual void RemapTrackHitIDs(Int_t * map);
     
   protected:
+    /// Not implemented
     AliMUON(const AliMUON& rMUON);
+    /// Not implemented
     AliMUON& operator = (const AliMUON& rhs);
 
     const AliMUONGeometry* GetGeometry() const;
index fb282bc..ef5ed06 100644 (file)
@@ -41,14 +41,14 @@ fIter2(0x0),
 fCurrentI(-1),
 fCurrentJ(-1)
 {
-  // default ctor
+  /// default ctor
   Reset();
 }
 
 //_____________________________________________________________________________
 AliMUON2DMapIterator::~AliMUON2DMapIterator()
 {
-  // dtor
+  /// dtor
   delete fIter2;
 }
 
@@ -56,7 +56,7 @@ AliMUON2DMapIterator::~AliMUON2DMapIterator()
 TObject*
 AliMUON2DMapIterator::GetValue(TExMapIter& iter, Int_t& theKey) const
 {
-  // return the value corresponding to theKey in iterator iter
+  /// return the value corresponding to theKey in iterator iter
   theKey = -1;
   Long_t key, value;
   Bool_t ok = iter.Next(key,value);
@@ -69,7 +69,7 @@ AliMUON2DMapIterator::GetValue(TExMapIter& iter, Int_t& theKey) const
 AliMpExMap*
 AliMUON2DMapIterator::GetMap(TExMapIter& iter, Int_t& key) 
 {
-  // get the map corresponding to key
+  /// get the map corresponding to key
   AliMpExMap* rv(0x0);
   TObject* o = GetValue(iter,key);
   if (o)
@@ -87,9 +87,9 @@ AliMUON2DMapIterator::GetMap(TExMapIter& iter, Int_t& key)
 TObject*
 AliMUON2DMapIterator::Next()
 {
-  // logic :
-  // get TObject* from fIter2
-  // if null, increment fIter2 by getting next on fIter
+  /// logic :
+  /// get TObject* from fIter2
+  /// if null, increment fIter2 by getting next on fIter
   
   if (!fIter2) return 0x0;
   
@@ -116,7 +116,7 @@ AliMUON2DMapIterator::Next()
 void
 AliMUON2DMapIterator::Reset()
 {
-  // rewind the iterator
+  /// rewind the iterator
   delete fIter2;
   fIter.Reset();
   AliMpExMap* m = GetMap(fIter,fCurrentI);
@@ -130,7 +130,7 @@ AliMUON2DMapIterator::Reset()
 Bool_t
 AliMUON2DMapIterator::Remove()
 {
-  // to be implemented if needed
+  /// to be implemented if needed
   AliInfo("Not supported yet");
   return kFALSE;
 }
index f346d50..56d82a4 100644 (file)
@@ -44,19 +44,19 @@ public:
   virtual Bool_t Remove();
   
 private:
-    // copy ctor will not implemented
-    AliMUON2DMapIterator(const AliMUON2DMapIterator&);
-  // assignement operator will not implemented
+  /// copy ctor will not implemented
+  AliMUON2DMapIterator(const AliMUON2DMapIterator&);
+  /// assignement operator will not implemented
   AliMUON2DMapIterator& operator=(const AliMUON2DMapIterator&);
   
-    TObject* GetValue(TExMapIter& iter, Int_t& key) const;
+  TObject* GetValue(TExMapIter& iter, Int_t& key) const;
   AliMpExMap* GetMap(TExMapIter& iter, Int_t& key);
   
 private:
-    TExMapIter fIter; //! first iterator
-  TExMapIter* fIter2; //! second iterator
-  Int_t fCurrentI; //! current index in direction i 
-  Int_t fCurrentJ; //! current index in direction j
+  TExMapIter fIter; //!< first iterator
+  TExMapIter* fIter2; //!< second iterator
+  Int_t fCurrentI; //!< current index in direction i 
+  Int_t fCurrentJ; //!< current index in direction j
   
   ClassDef(AliMUON2DMapIterator,0) // VDataIterator for 2D maps
 };
index f5a9f3d..7eba3b3 100644 (file)
@@ -38,13 +38,15 @@ public:
 
   AliMUONV2DStore* GetStatus() const { return fStatus; }
   
+  /// Reports what is missing, trying to be as concise as possible.
   void Report(TList& lines) const;
 
   static void Report(TList& lines, const TObjArray& chambers);
 
 private:
-    
+  /// Not implemented  
   AliMUON2DStoreValidator(const AliMUON2DStoreValidator&);
+  /// Not implemented  
   AliMUON2DStoreValidator& operator=(const AliMUON2DStoreValidator&);
 
   void AddMissingChannel(Int_t detElemId, Int_t manuId, Int_t manuChannel);
@@ -60,9 +62,9 @@ private:
   static void ReportManu(TList& list, AliMUONCheckItem& manu);
   
 private:
-  TList* fManuList; //! List of (DE,manuID) pairs.
-  TObjArray* fChambers; //! Array of AliMUONCheckItem.
-  AliMUONV2DStore* fStatus; //! Statuses
+  TList* fManuList; //!< List of (DE,manuID) pairs.
+  TObjArray* fChambers; //!< Array of AliMUONCheckItem.
+  AliMUONV2DStore* fStatus; //!< Statuses
   
   ClassDef(AliMUON2DStoreValidator,2) // Validator of 2DStore
 };
index 1701bb7..5e12c18 100644 (file)
@@ -29,6 +29,7 @@ public:
   virtual ~AliMUONAlignment();
 
   void ProcessTrack(AliMUONTrack *track);
+  /// Set geometry transformer
   void SetGeometryTransformer(AliMUONGeometryTransformer * transformer) {
     fTransform = transformer;
   }
@@ -44,9 +45,11 @@ public:
   void SetNonLinear(Int_t param);
   void AddConstraint(Double_t *factor, Double_t value );
   void InitGlobalParameters(Double_t *par);   
+  /// Set array of local derivatives
   void SetLocalDerivative(Int_t index, Double_t value) {      
     fLocalDerivatives[index] = value;
   }
+  /// Set array of global derivatives
   void SetGlobalDerivative(Int_t index, Double_t value) {
     fGlobalDerivatives[index] = value;
   }  
@@ -58,12 +61,11 @@ public:
   AliMUONGeometryTransformer* 
     ReAlign(const AliMUONGeometryTransformer * transformer, double *misAlignments, Bool_t verbose);
 
- protected:
+ private:
+  /// Not implemented
   AliMUONAlignment(const AliMUONAlignment& right);
+  /// Not implemented
   AliMUONAlignment&  operator = (const AliMUONAlignment& right);
-  
- private:
 
   void Init(Int_t nGlobal, Int_t nLocal, Int_t nStdDev);
   void ConstrainT(Int_t lDetElem, Int_t lCh, Double_t *lConstraintT, Int_t iVar);
@@ -79,77 +81,77 @@ public:
 
   TGeoCombiTrans ReAlign(const TGeoCombiTrans& transform, double *detElemMisAlignment) const;
 
-  Bool_t fBFieldOn;        // Flag for Magnetic filed On/Off
+  Bool_t fBFieldOn;        ///< Flag for Magnetic filed On/Off
                                                                       
-  Bool_t fDoF[3];          // Flags degrees of freedom to align (x,y,phi)
-  Double_t fAllowVar[3];   // "Encouraged" variation for degrees of freedom 
-  Double_t fStartFac;      // Initial value for chi2 cut 
-                           // if > 1 Iterations in AliMillepede are turned on
-  Double_t fResCutInitial; // Cut on residual for first iteration
-  Double_t fResCut;        // Cut on residual for other iterations 
-
-  AliMillepede *fMillepede; // Detector independent alignment class
+  Bool_t fDoF[3];          ///< Flags degrees of freedom to align (x,y,phi)
+  Double_t fAllowVar[3];   ///< "Encouraged" variation for degrees of freedom 
+  Double_t fStartFac;      ///< Initial value for chi2 cut 
+                           ///< if > 1 Iterations in AliMillepede are turned on
+  Double_t fResCutInitial; ///< Cut on residual for first iteration
+  Double_t fResCut;        ///< Cut on residual for other iterations 
+
+  AliMillepede *fMillepede; ///< Detector independent alignment class
   
-  TClonesArray *fTrackParamAtHit; // Array of track parameters 
-  TClonesArray *fHitForRecAtHit;  // Array of track hits 
-  AliMUONTrack *fTrack;           // AliMUONTrack 
-  AliMUONHitForRec *fRecHit;      // AliMUONHitForRec
-  AliMUONTrackParam *fTrackParam; // Track parameters 
-
-  Int_t fNGlobal;  // Number of global parameters
-  Int_t fNLocal;   // Number of local parameters
-  Int_t fNStdDev;  // Number of standard deviations for chi2 cut
-  Double_t fClustPos[3];    // Cluster position
-  Double_t fClustPosLoc[3]; // Cluster position in local coordinates
-  Double_t fTrackSlope0[2]; // Track slope at reference point
-  Double_t fTrackSlope[2];  // Track slope at current point
-  Double_t fTrackPos0[3];   // Track intersection at reference point
-  Double_t fTrackPos[3];    // Track intersection at current point
-  Double_t fTrackPosLoc[3]; // Track intersection at current point in local coordinates 
-  Double_t fMeas[2];        // Current measurement (depend on B field On/Off)  
-  Double_t fSigma[2];       // Estimated resolution on measurement
-
-  Double_t fGlobalDerivatives[468]; // Array of global derivatives
-  Double_t fLocalDerivatives[4];    // Array of local derivatives
-
-  Double_t fConstraintX[468];   // Array for constraint equation all X
-  Double_t fConstraintY[468];   // Array for constraint equation all Y
-  Double_t fConstraintP[468];   // Array for constraint equation all P
-  Double_t fConstraintXT[468];  // Array for constraint equation X Top half
-  Double_t fConstraintYT[468];  // Array for constraint equation Y Top half
-  Double_t fConstraintPT[468];  // Array for constraint equation P Top half
-  Double_t fConstraintXB[468];  // Array for constraint equation X Bottom half
-  Double_t fConstraintYB[468];  // Array for constraint equation Y Bottom half
-  Double_t fConstraintPB[468];  // Array for constraint equation P Bottom half
-  Double_t fConstraintXR[468];  // Array for constraint equation X Right half
-  Double_t fConstraintYR[468];  // Array for constraint equation Y Right half
-  Double_t fConstraintPR[468];  // Array for constraint equation P Right half
-  Double_t fConstraintXL[468];  // Array for constraint equation X Left half
-  Double_t fConstraintYL[468];  // Array for constraint equation Y Left half
-  Double_t fConstraintPL[468];  // Array for constraint equation P Left half
-  Double_t fConstraintX3[468];  // Array for constraint equation St3 X
-  Double_t fConstraintY3[468];  // Array for constraint equation St3 Y
-  Double_t fConstraintX4[468];  // Array for constraint equation St4 X
-  Double_t fConstraintY4[468];  // Array for constraint equation St4 Y
-  Double_t fConstraintP4[468];  // Array for constraint equation St4 P
-  Double_t fConstraintX5[468];  // Array for constraint equation St5 X
-  Double_t fConstraintY5[468];  // Array for constraint equation St5 Y
-
-  Int_t fDetElemId;        // Detection element id
-  Int_t fDetElemNumber;    // Detection element number
-  Double_t fPhi;           // Azimuthal tilt of detection element 
-  Double_t fCosPhi;        // Cosine of fPhi
-  Double_t fSinPhi;        // Sine of fPhi
-  Double_t fDetElemPos[3]; // Position of detection element
-
-  AliMUONGeometryTransformer *fTransform; // Geometry transformation
-
-  static Int_t fgNSt;            // Number tracking stations
-  static Int_t fgNCh;            // Number tracking chambers
-  static Int_t fgNParCh;         // Number of degrees of freedom per chamber
-  static Int_t fgNDetElem;       // Total number of detection elements
-  static Int_t fgNDetElemCh[10]; // Number of detection elements per chamber
-  static Int_t fgSNDetElemCh[10];// Sum of detection elements up to this chamber (inc)
+  TClonesArray *fTrackParamAtHit; ///< Array of track parameters 
+  TClonesArray *fHitForRecAtHit;  ///< Array of track hits 
+  AliMUONTrack *fTrack;           ///< AliMUONTrack 
+  AliMUONHitForRec *fRecHit;      ///< AliMUONHitForRec
+  AliMUONTrackParam *fTrackParam; ///< Track parameters 
+
+  Int_t fNGlobal;  ///< Number of global parameters
+  Int_t fNLocal;   ///< Number of local parameters
+  Int_t fNStdDev;  ///< Number of standard deviations for chi2 cut
+  Double_t fClustPos[3];    ///< Cluster position
+  Double_t fClustPosLoc[3]; ///< Cluster position in local coordinates
+  Double_t fTrackSlope0[2]; ///< Track slope at reference point
+  Double_t fTrackSlope[2];  ///< Track slope at current point
+  Double_t fTrackPos0[3];   ///< Track intersection at reference point
+  Double_t fTrackPos[3];    ///< Track intersection at current point
+  Double_t fTrackPosLoc[3]; ///< Track intersection at current point in local coordinates 
+  Double_t fMeas[2];        ///< Current measurement (depend on B field On/Off)  
+  Double_t fSigma[2];       ///< Estimated resolution on measurement
+
+  Double_t fGlobalDerivatives[468]; ///< Array of global derivatives
+  Double_t fLocalDerivatives[4];    ///< Array of local derivatives
+
+  Double_t fConstraintX[468];   ///< Array for constraint equation all X
+  Double_t fConstraintY[468];   ///< Array for constraint equation all Y
+  Double_t fConstraintP[468];   ///< Array for constraint equation all P
+  Double_t fConstraintXT[468];  ///< Array for constraint equation X Top half
+  Double_t fConstraintYT[468];  ///< Array for constraint equation Y Top half
+  Double_t fConstraintPT[468];  ///< Array for constraint equation P Top half
+  Double_t fConstraintXB[468];  ///< Array for constraint equation X Bottom half
+  Double_t fConstraintYB[468];  ///< Array for constraint equation Y Bottom half
+  Double_t fConstraintPB[468];  ///< Array for constraint equation P Bottom half
+  Double_t fConstraintXR[468];  ///< Array for constraint equation X Right half
+  Double_t fConstraintYR[468];  ///< Array for constraint equation Y Right half
+  Double_t fConstraintPR[468];  ///< Array for constraint equation P Right half
+  Double_t fConstraintXL[468];  ///< Array for constraint equation X Left half
+  Double_t fConstraintYL[468];  ///< Array for constraint equation Y Left half
+  Double_t fConstraintPL[468];  ///< Array for constraint equation P Left half
+  Double_t fConstraintX3[468];  ///< Array for constraint equation St3 X
+  Double_t fConstraintY3[468];  ///< Array for constraint equation St3 Y
+  Double_t fConstraintX4[468];  ///< Array for constraint equation St4 X
+  Double_t fConstraintY4[468];  ///< Array for constraint equation St4 Y
+  Double_t fConstraintP4[468];  ///< Array for constraint equation St4 P
+  Double_t fConstraintX5[468];  ///< Array for constraint equation St5 X
+  Double_t fConstraintY5[468];  ///< Array for constraint equation St5 Y
+
+  Int_t fDetElemId;        ///< Detection element id
+  Int_t fDetElemNumber;    ///< Detection element number
+  Double_t fPhi;           ///< Azimuthal tilt of detection element 
+  Double_t fCosPhi;        ///< Cosine of fPhi
+  Double_t fSinPhi;        ///< Sine of fPhi
+  Double_t fDetElemPos[3]; ///< Position of detection element
+
+  AliMUONGeometryTransformer *fTransform; ///< Geometry transformation
+
+  static Int_t fgNSt;            ///< Number tracking stations
+  static Int_t fgNCh;            ///< Number tracking chambers
+  static Int_t fgNParCh;         ///< Number of degrees of freedom per chamber
+  static Int_t fgNDetElem;       ///< Total number of detection elements
+  static Int_t fgNDetElemCh[10]; ///< Number of detection elements per chamber
+  static Int_t fgSNDetElemCh[10];///< Sum of detection elements up to this chamber (inc)
 
 ClassDef(AliMUONAlignment, 0)};
 
index 5472bb4..c09ffa4 100644 (file)
@@ -9,6 +9,8 @@
 /// \ingroup base
 /// \class AliMUONChamber
 /// \brief MUON tracking chamber class
+///
+/// Now only providing DisIntegration function
 
 #include <TObject.h>
 #include <TObjArray.h>
@@ -67,8 +69,9 @@ class AliMUONChamber : public TObject
   virtual void SetChargeCorrel(Float_t correl) {fResponse->SetChargeCorrel(correl);}
 
  protected:
+  /// Not implemented
   AliMUONChamber(const AliMUONChamber & rChamber);
-  // assignment operator  
+  /// Not implemented
   AliMUONChamber& operator =(const AliMUONChamber& rhs);
 
   Int_t   fId;            ///< chamber number
index b3e3692..1413088 100644 (file)
@@ -31,7 +31,7 @@
 ///
 /// Implementation of AliMUONChamber for the trigger
 ///
-/// This class is to be deprecated.
+/// \deprecated This class is to be deprecated.
 ///
 
 /// \cond CLASSIMP
index 7182063..9e235e3 100644 (file)
@@ -33,7 +33,9 @@ class AliMUONChamberTrigger : public AliMUONChamber
                                         Int_t& nnew, Float_t newclust[6][500]);
 
   protected:   
+    /// Not implemented
     AliMUONChamberTrigger(const AliMUONChamberTrigger& right);
+    /// Not implemented
     AliMUONChamberTrigger&  operator = (const AliMUONChamberTrigger& right);
 
     const AliMUONGeometryTransformer* fkGeomTransformer;///< geometry transformations
index 28d0a14..bc339e4 100644 (file)
@@ -45,7 +45,9 @@ public:
   void SetEventsToCheck(Int_t firstEvent, Int_t lastEvent);
 
 private:
+  /// Not implemented
   AliMUONCheck(const AliMUONCheck& rhs);
+ /// Not implemented
   AliMUONCheck& operator=(const AliMUONCheck& rhs);
   
 private:
index 02683e5..d19f311 100644 (file)
@@ -29,6 +29,7 @@ public:
   AliMUONCheckItem(Int_t id, Int_t maxNumber, const char* name);
   virtual ~AliMUONCheckItem();
   
+  /// Return the identifier of this item
   Int_t GetID() const { return fID; }
   
   TObject* GetItem(Int_t id) const;
@@ -40,8 +41,11 @@ public:
   void Print(Option_t* opt="") const;
   
 private:
+  /// Not implemented
   AliMUONCheckItem(const AliMUONCheckItem&);
+  /// Not implemented
   AliMUONCheckItem& operator=(const AliMUONCheckItem&);
+
   void ComputeDead() const;
   
 private:
index 3c3c0b0..e22b7d8 100644 (file)
@@ -31,7 +31,7 @@ public:
   Int_t    Next(); // commands for drawing
   Bool_t   FindEvCh(Int_t nev, Int_t ch); // find requested event and chamber
   void     FillMuon(Int_t nfit, const Double_t *parOk, const Double_t *errOk); // fill muon info
-  void     ResetMuon() { fxyMu[0][6] = fxyMu[1][6] = 9999; } // reset muons
+  void     ResetMuon() { fxyMu[0][6] = fxyMu[1][6] = 9999; } ///< reset muons
   void     UpdateCluster(Int_t npad); // update cluster after removing non-overlapped pads
 
 private:
@@ -48,8 +48,11 @@ private:
 
   // Functions
 
+  /// Not implemented
   AliMUONClusterDrawAZ(const AliMUONClusterDrawAZ& rhs);
+  /// Not implemented
   AliMUONClusterDrawAZ& operator=(const AliMUONClusterDrawAZ& rhs);
+
   void   Init(); // initialization
   void   ModifyHistos(); // modify histograms
   void   DrawHits(); // draw simulated and reconstructed hits
index 019ccf7..5f210ac 100644 (file)
@@ -30,16 +30,27 @@ public:
   void     FindRawClusters(); // the same interface as for old cluster finder
   void     EventLoop(Int_t nev = 0, Int_t ch = 0); // first event 
   Bool_t   TestTrack(Int_t t) const; // test if track was selected
+  
+  /// Return the number of pads in the cluster on the given cathode
   Int_t    GetNPads(Int_t cath) const { return fnPads[cath]; }
+  /// Return pad information \todo add more details
   Int_t    GetIJ(Int_t indx, Int_t iPad) const { return fPadIJ[indx][iPad]; }
+  /// Return pad information \todo add more details
   Float_t  GetXyq(Int_t indx, Int_t iPad) const { return fXyq[indx][iPad]; }
+  /// Return the z-coordinate of the hit
   Float_t  GetZpad() const { return fZpad; }
+  /// Return the flag for used pads
   Bool_t GetUsed(Int_t cath, Int_t dig) const { return fUsed[cath][dig]; }
-  void SetUsed(Int_t cath, Int_t dig) { fUsed[cath][dig] = kTRUE; } // mark used digits
-  void SetUnused(Int_t cath, Int_t dig) { fUsed[cath][dig] = kFALSE; } // unmark digits
-  void SetReco(Int_t iReco) { fReco = iReco; } // set reco flag
-  void SetStart(Int_t iCath, Int_t iPad) { fCathBeg = iCath; fPadBeg[0] = fPadBeg[1] = 0; fPadBeg[fCathBeg] = iPad; } // start
+
+  /// Mark used digits
+  void SetUsed(Int_t cath, Int_t dig) { fUsed[cath][dig] = kTRUE; } 
+  /// Unmark digits
+  void SetUnused(Int_t cath, Int_t dig) { fUsed[cath][dig] = kFALSE; } 
+  /// Set reco flag
+  void SetReco(Int_t iReco) { fReco = iReco; } 
+  /// Start  \todo add more details
+  void SetStart(Int_t iCath, Int_t iPad) { fCathBeg = iCath; fPadBeg[0] = fPadBeg[1] = 0; fPadBeg[fCathBeg] = iPad; } 
+
 private:
   // Some constants
   static const Int_t fgkDim = 10000; ///< array size
@@ -50,8 +61,8 @@ private:
   static  AliMUONClusterFinderAZ* fgClusterFinder; ///< the ClusterFinderAZ instance
 
   Int_t      fnPads[2];         //!< number of pads in the cluster on 2 cathodes
-  Float_t    fXyq[7][fgkDim];   //!< pad information
-  Int_t      fPadIJ[4][fgkDim]; //!< pad information
+  Float_t    fXyq[7][fgkDim];   //!< pad information \todo add more details
+  Int_t      fPadIJ[4][fgkDim]; //!< pad information \todo add more details
   AliMUONVGeometryDESegmentation *fSegmentation[2]; //!< new segmentation
   Float_t    fZpad;             //!< z-coordinate of the hit
   Int_t      fNpar;             //!< number of fit parameters
@@ -69,8 +80,11 @@ private:
 
   // Functions
 
+  /// Not implemented
   AliMUONClusterFinderAZ(const AliMUONClusterFinderAZ& rhs);
+  /// Not implemented
   AliMUONClusterFinderAZ& operator=(const AliMUONClusterFinderAZ& rhs);
+
   void   AddPad(Int_t cath, Int_t digit); // add a pad to the cluster
   Bool_t Overlap(Int_t cath, AliMUONDigit *dig); // check if the pad from one cathode overlaps with a pad in the cluster on the other cathode
   Bool_t Overlap(Float_t *xy1, Int_t iPad, Float_t *xy12, Int_t iSkip); // check if pads xy1 and iPad overlap and return overlap area
@@ -107,10 +121,13 @@ private:
              Double_t dyc, Double_t dxc, Double_t qtot, 
              Double_t &yrec, Double_t &xrec, Double_t &erry, Double_t &errx);
 
-  // Dummy methods for overloading warnings
+  /// Dummy method for overloading warnings
   void FindCluster(int, int, int, AliMUONRawCluster&) {return;}
+  /// Dummy method for overloading warnings
   void FindLocalMaxima(AliMUONRawCluster*) {return;}
+  /// Dummy method for overloading warnings
   void Split(AliMUONRawCluster*) {return;}
+  /// Dummy method for overloading warnings
   void AddRawCluster(AliMUONRawCluster&) {return;}
 
 ClassDef(AliMUONClusterFinderAZ,0) // cluster finder in MUON arm of ALICE
index 2c2f69d..d8ab5c9 100644 (file)
@@ -9,6 +9,8 @@
 /// \ingroup rec
 /// \class AliMUONClusterFinderVS
 /// \brief Class for clustering and reconstruction of space points
+///
+/// (Not used by default)
 
 #include <TObject.h>
 
@@ -26,11 +28,11 @@ class AliMUONClusterFinderVS : public TObject
  public:
     AliMUONClusterFinderVS();
     virtual ~AliMUONClusterFinderVS();
-// Decluster ?
+/// Decluster ?
     virtual void SetDeclusterFlag(Int_t flag=1) {fDeclusterFlag =flag;}
-// Set max. cluster size ; bigger clusters will deconvoluted
+/// Set max. cluster size ; bigger clusters will deconvoluted
     virtual void SetClusterSize(Int_t clsize=5) {fClusterSize = clsize;}
-// Set max. number of pads per local cluster
+/// Set max. number of pads per local cluster
     virtual void SetNperMax(Int_t npermax=5) {fNperMax = npermax;}
 // Search for raw clusters
     virtual void  FindRawClusters();
@@ -50,15 +52,17 @@ class AliMUONClusterFinderVS : public TObject
 //  Build up full cluster information    
     virtual void   FillCluster(AliMUONRawCluster *cluster, Int_t flag, Int_t cath);
     virtual void   FillCluster(AliMUONRawCluster *cluster, Int_t cath);
+/// \todo add comment    
     virtual void   FillCluster(AliMUONRawCluster *cluster) {FillCluster(cluster,1,0);}
 // Add a new raw cluster    
     virtual void AddRawCluster(AliMUONRawCluster& cluster);
-//  Set tracks for debugging    
+/// Set tracks for debugging    
     virtual void SetTracks(Int_t t1, Int_t t2) {fTrack[0]=t1; fTrack[1]=t2;}
+/// Set cut in charge matching chi2
     void SetGhostChi2Cut(Float_t cut) {fGhostChi2Cut = cut;}
-// get raw cluster pointer 
+/// Get raw cluster pointer 
     TClonesArray*  GetRawClusters() {return fRawClusters;}
-// reset raw clusters
+/// Reset raw clusters
     void ResetRawClusters();
 // set evt number
     void SetEventNumber(Int_t evtNumber) {fEvtNumber = evtNumber;}
@@ -113,8 +117,9 @@ class AliMUONClusterFinderVS : public TObject
     Int_t                    fEvtNumber;       ///< evt number for AZ
     
  private:
+    /// Not implemented
     AliMUONClusterFinderVS(const AliMUONClusterFinderVS& clusterFinder);
-//  Assignment operator
+    /// Not implemented assignment operator
     AliMUONClusterFinderVS & operator = (const AliMUONClusterFinderVS& rhs);
 
     ClassDef(AliMUONClusterFinderVS,3) //Class for clustering and reconstruction of space points
index 5872d46..505aecc 100644 (file)
@@ -32,24 +32,39 @@ class AliMUONClusterInput : public TObject
     void SetDigits(Int_t chamber, Int_t idDE, TClonesArray* dig);
     void SetCluster(AliMUONRawCluster* cluster);
 // Access functions
+    /// Return the current chamber number
     Int_t Chamber() const {return fChamber;}
+    /// Return i-th digit for given cath
     AliMUONDigit* Digit(Int_t cath, Int_t i) const {return (AliMUONDigit*) (fDigits[cath]->UncheckedAt(i));}
+    /// Return the array of digits for given cathod 
     TClonesArray* Digits(Int_t cath) const {return fDigits[cath];}
+    /// Return number of digits for given cathod 
     Int_t NDigits(Int_t cath) const {return fNDigits[cath];}
+    /// Return geometry segmentation for given cathod 
     AliMUONGeometrySegmentation* Segmentation2(Int_t cath) const {return fSegmentation2[cath];}
 
+    /// Return Mathieson    
     AliMUONMathieson* Mathieson() const {return fgMathieson;}    
+    /// Return charge correlation
     Float_t ChargeCorrel() const {return fChargeCorrel;}    
+    /// Return detection elt id
     Int_t DetElemId() const {return fDetElemId;}
 
 // Fitting    
+    /// Return the fitter
     TMinuit*      Fitter() const {return fgMinuit;}
 // Current cluster information    
+    /// Return the total charge for given cathod 
     Float_t       TotalCharge(Int_t cath) const {return fChargeTot[cath];}
+    /// Return the charge for the given cluster and cathod
     Float_t       Charge(Int_t dig, Int_t cath) const {return fCharge[dig][cath];}
+    /// Return the x-position for the given cluster and cathod
     Int_t         Ix(Int_t dig, Int_t cath) const {return fix[dig][cath];}
+    /// Return the y-position for the given cluster and cathod
     Int_t         Iy(Int_t dig, Int_t cath) const {return fiy[dig][cath];}
+    /// Return the cluster multiplicity for given cathod 
     Int_t         Nmul(Int_t cath) const {return fNmul[cath];}
+
 //  Helpers for Fit     
     Float_t DiscrChargeS1(Int_t i,Double_t *par);
     Float_t DiscrChargeCombiS1(Int_t i,Double_t *par, Int_t cath);
index 7e2d3b9..a3c2a45 100644 (file)
@@ -23,6 +23,7 @@
 #include "TClass.h"
 
 ///
+/// \class AliMUONConstants
 /// This class holds various constants to be used in many places,
 /// such as the number of tracking and trigger chambers, 
 /// some geometrical constants (to build the initial geometry for simulation)
index a148462..25f28fc 100644 (file)
 
 /* $Id$ */
 
-/// AliMUONData class
+/// \class AliMUONData class
 ///
 /// Class containing MUON data: hits, digits, rawclusters, globaltrigger, localtrigger, etc ..
 /// The classe makes the lik between the MUON data lists and the event trees from loaders
 ///
-/// Gines Martinez, Subatech,  September 2003
+/// \author Gines Martinez, Subatech,  September 2003
 ///
 
 #include "AliMUONData.h"
index d09c45d..8ce3a25 100644 (file)
@@ -9,12 +9,10 @@
 //
 /// \ingroup base
 /// \class AliMUONData
-/// \brief MUON data
-///
-/// Class containing MUON data: hits, digits, rawclusters, globaltrigger, 
+/// \brief Class containing MUON data: hits, digits, rawclusters, globaltrigger, 
 /// localtrigger, etc ...
 ///
-/// Author: Gines Martinez, Subatech,  September 2003
+//  Author: Gines Martinez, Subatech,  September 2003
 
 #include <TNamed.h>
 
index 8a91324..5fbf692 100644 (file)
@@ -65,6 +65,7 @@
 /// (for performance reason mainly, and because anyway we know we have to do it
 /// here, at the digitization level).
 ///
+/// \author Laurent Aphecetche
 
 namespace
 {
index 6428f89..8ebbb6b 100644 (file)
@@ -8,6 +8,7 @@
 /// \ingroup rec
 /// \class AliMUONEventRecoCombi
 /// \brief Combined cluster / track finder in the MUON arm of ALICE
+/// \author Alexander Zinchenko, JINR Dubna
  
 #include <TObject.h>
 #include <TArrayD.h>
index 15d6c42..aba4c7c 100644 (file)
@@ -17,7 +17,7 @@
 //
 // Class AliMUONGeometryEnvelope
 // -----------------------------
-// Helper class for definititon an assembly of volumes.
+// Helper class for definititon of an assembly of volumes.
 // Author: Ivana Hrivnacova, IPN Orsay
 // 23/01/2004
 
index 9d99817..2f03eb8 100644 (file)
@@ -8,7 +8,7 @@
 /// \class AliMUONGeometryModuleTransformer
 /// \brief Geometry transformer for a detector module
 ///
-/// Class for definition of the trasformation for adetector module
+/// Class for definition of the transformation for a detector module
 /// and its detection elements
 ///
 /// \author Ivana Hrivnacova, IPN Orsay
index 4c500af..16a908d 100644 (file)
@@ -13,6 +13,8 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
+/* $Id$ */
+
 //
 // Class AliMUONGeometrySegmentation
 // -------------------------------
@@ -22,8 +24,6 @@
 //
 // Author:Ivana Hrivnacova, IPN Orsay
 
-/* $Id$ */
-
 #include "AliMUONGeometrySegmentation.h"
 #include "AliMUONVGeometryDESegmentation.h"
 #include "AliMUONGeometryModuleTransformer.h"
index 774e7d2..9d8607f 100644 (file)
 
 /* $Id$ */
 
-//*-- Author: Rachid Guernane (LPCCFd)
-//    GLOBAL TRIGGER IMPLEMENTATION
-//    INPUTS ARE REGIONAL RESPONSES
-//    OUTPUT IS A 12-BIT WORD
-//    4 BITS PER TRIGGER LEVEL
+/// \class AliMUONGlobalTriggerBoard
+/// Global trigger implementation:
+/// - inputs are regional responses
+/// - output is a 12-bit word
+/// - 4 bits per trigger level
+///
+/// \author Rachid Guernane (LPCCFd)
 
 #include "AliMUONGlobalTriggerBoard.h"
 #include "AliLog.h"
index 12ab781..efefa5d 100644 (file)
@@ -7,9 +7,9 @@
 
 /// \ingroup sim
 /// \class AliMUONGlobalTriggerBoard
-/// \brief GLOBAL TRIGGER
+/// \brief Global trigger
 ///
-/// \author Rachid Guernane (LPCCFd)
+//  Author: Rachid Guernane (LPCCFd)
 
 #include "AliMUONTriggerBoard.h"
 
index b9a39e5..fcb202e 100644 (file)
@@ -9,6 +9,8 @@
 /// \ingroup rec
 /// \class AliMUONHitForRec
 /// \brief Hit for reconstruction in ALICE dimuon spectrometer
+///
+/// \author J. Gosset
 
 #include <TObject.h>
 
index 6a815e2..0a595fa 100644 (file)
 
 /* $Id$ */
 
-// -------------------------------------
-// Class AliMUONPixel
-// -------------------------------------
-// Basic object of the cluster / rec. point finder based 
-// on Expectation-Minimization approach (AZ cluster finder)
-// Author: Alexander Zinchenko, JINR Dubna
+/// \class AliMUONPixel
+/// Basic object of the cluster / rec. point finder based 
+/// on Expectation-Minimization approach (AZ cluster finder)
+///
+/// \author Alexander Zinchenko, JINR Dubna
 
 #include "AliMUONPixel.h"
 
index 9ce458b..a97f15d 100644 (file)
@@ -10,7 +10,7 @@
 /// \class AliMUONPixel
 /// \brief Pixel for MLEM method of cluster finding
 ///
-/// \author Alexander Zinchenko, JINR Dubna
+//  Author Alexander Zinchenko, JINR Dubna
 
 #include <TObject.h>
 
index 80ebce9..98b6dfa 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
+/* $Id $ */
+
 
 ///////////////////////////////////////////////////////////////////////////////
 ///
+/// \class AliMUONRawStreamTracker
 /// This class provides access to MUON digits in raw data.
 ///
 /// It loops over all MUON digits in the raw data given by the AliRawReader.
@@ -26,6 +29,7 @@
 /// 
 /// First version implement for Tracker
 ///
+/// \author Christian Finck
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "AliMUONRawStreamTracker.h"
index 85a808f..6358cf9 100644 (file)
@@ -9,13 +9,7 @@
 /// \class AliMUONRawStreamTracker
 /// \brief Class for reading MUON raw digits
 ///
-/// \author Christian Finck
-///
-///////////////////////////////////////////////////////////////////////////////
-///
-/// This class provides access to MUON digits in raw data.
-///
-///////////////////////////////////////////////////////////////////////////////
+//  Author: Christian Finck
 
 #include <TObject.h>
 #include "AliMUONPayloadTracker.h"
index a27a98b..3ed48b8 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
+/* $Id $ */
 
 ///////////////////////////////////////////////////////////////////////////////
 ///
+/// \class AliMUONRawStreamTrigger
 /// This class provides access to MUON digits in raw data.
 ///
 /// It loops over all MUON digits in the raw data given by the AliRawReader.
@@ -25,6 +27,7 @@
 /// in payload class.
 /// 
 /// First version implement for Trigger
+/// \author Christian Finck
 ///
 ///////////////////////////////////////////////////////////////////////////////
 
index cc54b2c..e00563f 100644 (file)
@@ -9,13 +9,7 @@
 /// \class AliMUONRawStreamTrigger
 /// \brief Class for reading MUON raw digits
 ///
-/// \author Christian Finck
-///
-///////////////////////////////////////////////////////////////////////////////
-///
-/// This class provides access to MUON digits in raw data.
-///
-///////////////////////////////////////////////////////////////////////////////
+//  Author: Christian Finck
 
 #include <TObject.h>
 #include "AliMUONPayloadTrigger.h"
index f398953..f5b89a2 100644 (file)
 
 /* $Id$ */
 
-// ----------------------                                                               
-// Class AliMUONRecoTrack 
-// ----------------------                                                               
-// This class represents a reconstructed muon track
-// in the tree of reconstructed events.            
-// Authors: Mihaela Gheata, Andrei Gheata 09/10/00
+/// \class AliMUONRecoTrack 
+/// This class represents a reconstructed muon track
+/// in the tree of reconstructed events.   
+///         
+/// \author Mihaela Gheata, Andrei Gheata 09/10/00
 
 #include <Riostream.h>
 
index c448081..29e3f8e 100644 (file)
@@ -10,7 +10,7 @@
 /// \class AliMUONRecoTrack
 /// \brief A reconstructed muon track
 ///
-/// \author M.Gheata, A.Gheata 09/10/00
+//  Author: M.Gheata, A.Gheata 09/10/00
 
 #include <TObject.h>
 #include <TMath.h>
index 2b6ae11..2d1f88a 100644 (file)
 
 /* $Id$ */
 
-//*-- Author: Rachid Guernane (LPCCFd)
-//    DIMUON REGIONAL TRIGGER IMPLEMENTATION
-//    ENTRY ARE LOCAL BOARD RESPONSES
-//    OUTPUT IS 12-BIT WORD
-//    ALGORITHM IS SIMILAR TO THE GLOBAL ONE
+/// \class AliMUONRegionalTriggerBoard
+/// Dimuon regional trigger implementation:
+/// - entry are local board responses
+/// - output is 12-bit word
+/// - algorithm is similar to the global one
+///
+/// \author Rachid Guernane (LPCCFd)
 
 #include "AliMUONRegionalTriggerBoard.h"
 
index adbfbd1..a419f83 100644 (file)
@@ -7,9 +7,9 @@
 
 /// \ingroup sim
 /// \class AliMUONRegionalTriggerBoard
-/// \brief REGIONAL TRIGGER
-/// REAL HW ALGORITHM IS IMPLEMENTED
-/// \author Rachid Guernane (LPCCFd)
+/// \brief Regional trigger - real HW algorithm is implemented
+///
+//  Author: Rachid Guernane (LPCCFd)
 
 #include "AliMUONTriggerBoard.h"
 
index 340bd82..69f6c4e 100644 (file)
@@ -253,7 +253,8 @@ void AliMUONResponseTriggerV1::Neighbours(const Int_t cath,
     ///-----------------NON-BENDING-------------------------------------      /n
     /// Returns list of 10 next neighbours for given Y strip (ix, iy)         /n 
     /// neighbour number 9 8 7 6 5 (Y strip (ix, iy)) 0 1 2 3 4 in the list   /n 
-    ///                  \_______/                    \_______/               /n 
+    ///                  |_______|                    |_______/               /n 
+
     ///                    left                         right                 /n
     
     for (Int_t i=0; i<10; i++) {
index 1ec6dce..ee587b5 100644 (file)
@@ -61,18 +61,18 @@ class AliMUONResponseV0 : public AliMUONResponse
     virtual void    SetPitch(Float_t p1)    {fMathieson->SetPitch(p1);};
 
     /// Set Mathieson parameters
-    /// Mathieson \sqrt{Kx3} and derived Kx2 and Kx4 
+    /// Mathieson sqrt{Kx3} and derived Kx2 and Kx4 
     /// passing pointer to class Mathieson for backward compatibility
     virtual void    SetSqrtKx3AndDeriveKx2Kx4(Float_t SqrtKx3);
-    /// Mathieson \sqrt{Kx3}
+    /// Mathieson sqrt{Kx3}
     virtual void    SetSqrtKx3(Float_t p1) {fMathieson->SetSqrtKx3(p1);};
     /// Mathieson Kx2
     virtual void    SetKx2(Float_t p1)     {fMathieson->SetKx2(p1);};
     /// Mathieson Kx4
     virtual void    SetKx4(Float_t p1)     {fMathieson->SetKx4(p1);};
-    /// Mathieson \sqrt{Ky3} and derived Ky2 and Ky4
+    /// Mathieson sqrt{Ky3} and derived Ky2 and Ky4
     virtual void SetSqrtKy3AndDeriveKy2Ky4(Float_t SqrtKy3);
-    /// Mathieson \sqrt{Ky3}
+    /// Mathieson sqrt{Ky3}
     virtual void    SetSqrtKy3(Float_t p1) {fMathieson->SetSqrtKy3(p1);};
     /// Mathieson Ky2
     virtual void    SetKy2(Float_t p1)     {fMathieson->SetKy2(p1);};
index c952512..de82ef1 100644 (file)
@@ -15,9 +15,9 @@
 
 /* $Id$ */
 
-/// \class AliMUONVTrackReconstructor
 ////////////////////////////////////
 ///
+/// \class AliMUONVTrackReconstructor
 /// Virtual MUON track reconstructor in ALICE (class renamed from AliMUONEventReconstructor)
 ///
 /// This class contains as data:
@@ -29,6 +29,8 @@
 /// * EventReconstruct to build the muon tracks
 /// * EventReconstructTrigger to build the trigger tracks
 ///
+///  \author Philippe Pillot
+///
 ////////////////////////////////////
 
 #include "AliMUONVTrackReconstructor.h"
index 280894a..1afb87e 100644 (file)
@@ -9,9 +9,7 @@
 /// \class AliMUONVTrackReconstructor
 /// \brief Virtual class for the MUON track reconstruction
 ///
-/////////////////////////////////////////////
-/// Virtual MUON track reconstructor in ALICE
-/////////////////////////////////////////////
+//  Author: Philippe Pillot
 
 #include <TObject.h>
 
index 1b5b61d..b5fbe86 100644 (file)
@@ -36,7 +36,9 @@ public:
   virtual Int_t SetGlobalConstraint(double dercs[], double rhs);
   virtual Int_t SetLocalEquation(double dergb[], double derlc[], double rmeas, double sigma);
   virtual Int_t LocalFit(int n, double localParams[], Bool_t bSingleFit);
+                /// Get number of local equations
   virtual Int_t GetNLocalEquations() const {return fNLocalEquations;};
+                /// Set number of local equations
   virtual void  SetNLocalEquations(int value) {fNLocalEquations = value;};
   virtual Int_t PrintGlobalParameters() const;
   virtual Int_t SetIterations (double cutfac);
@@ -46,15 +48,15 @@ private:
 
 // Max. dimensions
 
-  static const int fgkMaxGlobalPar  = 1000; // Max. number of global parameters
-  static const int fgkMaxLocalPar   = 20;  // Max. number of local parameters
-  static const int fgkMaxGloCsts    = 10;  // Max. number of constraint equations
-  static const int fgkMaxGloPC     = 1010; // fgkMaxGlobalPar+fgkMaxGloCsts
+  static const int fgkMaxGlobalPar  = 1000; ///< Max. number of global parameters
+  static const int fgkMaxLocalPar   = 20;   ///< Max. number of local parameters
+  static const int fgkMaxGloCsts    = 10;   ///< Max. number of constraint equations
+  static const int fgkMaxGloPC     = 1010; ///< fgkMaxGlobalPar+fgkMaxGloCsts
 
 
 // Private methods 
 
-  Double_t GetParCorrelation(int i, int j);
+  // Double_t GetParCorrelation(int i, int j);
 
   int   SpmInv(double v[][fgkMaxGloPC], double b[], int n);
   int   SpmInv(double v[][fgkMaxLocalPar], double b[], int n);
@@ -64,57 +66,57 @@ private:
 
 // Matrices
 
-  double fMatCGlo[fgkMaxGloPC][fgkMaxGloPC];            // Matrix C global
-  double fMatCLoc[fgkMaxLocalPar][fgkMaxLocalPar];      // Matrix C local
-  double fMatCGloLoc[fgkMaxGlobalPar][fgkMaxLocalPar];  // Rectangular matrix C g*l
-  double fMatCGloCorr[fgkMaxGlobalPar][fgkMaxGlobalPar];// Correction of matrix C global
-  double fMatDerConstr[fgkMaxGloCsts][fgkMaxGlobalPar]; // Constrained derivatives
+  double fMatCGlo[fgkMaxGloPC][fgkMaxGloPC];            ///< Matrix C global
+  double fMatCLoc[fgkMaxLocalPar][fgkMaxLocalPar];      ///< Matrix C local
+  double fMatCGloLoc[fgkMaxGlobalPar][fgkMaxLocalPar];  ///< Rectangular matrix C g*l
+  double fMatCGloCorr[fgkMaxGlobalPar][fgkMaxGlobalPar];///< Correction of matrix C global
+  double fMatDerConstr[fgkMaxGloCsts][fgkMaxGlobalPar]; ///< Constrained derivatives
 
 // Vectors and useful variables
 
-  double fDiagCGlo[fgkMaxGloPC];        // Initial diagonal elements of C global matrix
-  double fVecBGlo[fgkMaxGloPC];         // Vector B global (parameters) 
-  double fVecBGloCorr[fgkMaxGlobalPar]; // Correction of vector B global
-  double fVecBLoc[fgkMaxLocalPar];      // Vector B local (parameters) 
+  double fDiagCGlo[fgkMaxGloPC];        ///< Initial diagonal elements of C global matrix
+  double fVecBGlo[fgkMaxGloPC];         ///< Vector B global (parameters) 
+  double fVecBGloCorr[fgkMaxGlobalPar]; ///< Correction of vector B global
+  double fVecBLoc[fgkMaxLocalPar];      ///< Vector B local (parameters) 
 
-  double fInitPar[fgkMaxGlobalPar];    // Initial global parameters
-  double fDeltaPar[fgkMaxGlobalPar];   // Variation of global parameters 
-  double fSigmaPar[fgkMaxGlobalPar];   // Sigma of allowed variation of global parameter 
+  double fInitPar[fgkMaxGlobalPar];    ///< Initial global parameters
+  double fDeltaPar[fgkMaxGlobalPar];   ///< Variation of global parameters 
+  double fSigmaPar[fgkMaxGlobalPar];   ///< Sigma of allowed variation of global parameter 
 
-  double fLagMult[fgkMaxGloCsts];   // Lagrange multipliers of constrained equations
+  double fLagMult[fgkMaxGloCsts];   ///< Lagrange multipliers of constrained equations
 
-  Bool_t fIsNonLinear[fgkMaxGlobalPar]; // Flag for non linear parameters
-  int   fGlo2CGLRow[fgkMaxGlobalPar];   // Global parameter to row in "used" g*l matrix
-  int   fCGLRow2Glo[fgkMaxGlobalPar];   // Row in "used" g*l matrix to global parameter 
+  Bool_t fIsNonLinear[fgkMaxGlobalPar]; ///< Flag for non linear parameters
+  int   fGlo2CGLRow[fgkMaxGlobalPar];   ///< Global parameter to row in "used" g*l matrix
+  int   fCGLRow2Glo[fgkMaxGlobalPar];   ///< Row in "used" g*l matrix to global parameter 
 
-  TArrayI fIndexLocEq; // Table of parameter indexes in local equation 
-  TArrayD fDerivLocEq; // Table of local equation derivatives wrt. parameter 
-  TArrayI fIndexAllEqs; // Index in all loc. eq. storage for iterations
-  TArrayD fDerivAllEqs; // derivative in all loc. eq. storage for iterations
-  TArrayI fLocEqPlace;  // Loc. Eq. position in AllEqs storage
+  TArrayI fIndexLocEq;  ///< Table of parameter indexes in local equation 
+  TArrayD fDerivLocEq;  ///< Table of local equation derivatives wrt. parameter 
+  TArrayI fIndexAllEqs; ///< Index in all loc. eq. storage for iterations
+  TArrayD fDerivAllEqs; ///< derivative in all loc. eq. storage for iterations
+  TArrayI fLocEqPlace;  ///< Loc. Eq. position in AllEqs storage
 
-  Int_t fNIndexLocEq;   // Number of entries in fIndexLocEq
-  Int_t fNDerivLocEq;   // Number of entries in fDerivLocEq
-  Int_t fNIndexAllEqs;  // Number of entries in fIndexAllEqs
-  Int_t fNDerivAllEqs;  // Number of entries in fDerivAllEqs
-  Int_t fNLocEqPlace;   // Number of entries in fLocEqPlace
+  Int_t fNIndexLocEq;   ///< Number of entries in fIndexLocEq
+  Int_t fNDerivLocEq;   ///< Number of entries in fDerivLocEq
+  Int_t fNIndexAllEqs;  ///< Number of entries in fIndexAllEqs
+  Int_t fNDerivAllEqs;  ///< Number of entries in fDerivAllEqs
+  Int_t fNLocEqPlace;   ///< Number of entries in fLocEqPlace
   
 
-  int    fNLocalEquations;       // Number of local equations 
-  double fResCutInit;            // Cut in residual for first iterartion
-  double fResCut;                // Cut in residual for other iterartiona
-
-  double fChi2CutFactor;         // Cut factor for chi2 cut to accept local fit 
-  double fChi2CutRef;            // Reference cut for chi2 cut to accept local fit 
-
-  int fIter;                   // Current iteration
-  int fMaxIter;                // Maximum number of iterations
-  int fNStdDev;                // Number of standard deviations for chi2 cut 
-  int fNGlobalConstraints;     // Number of constraint equations
-  int fNLocalFits;             // Number of local fits
-  int fNLocalFitsRejected;     // Number of local fits rejected
-  int fNGlobalPar;             // Number of global parameters
-  int fNLocalPar;              // Number of local parameters
+  int    fNLocalEquations;       ///< Number of local equations 
+  double fResCutInit;            ///< Cut in residual for first iterartion
+  double fResCut;                ///< Cut in residual for other iterartiona
+
+  double fChi2CutFactor;         ///< Cut factor for chi2 cut to accept local fit 
+  double fChi2CutRef;            ///< Reference cut for chi2 cut to accept local fit 
+
+  int fIter;                   ///< Current iteration
+  int fMaxIter;                ///< Maximum number of iterations
+  int fNStdDev;                ///< Number of standard deviations for chi2 cut 
+  int fNGlobalConstraints;     ///< Number of constraint equations
+  int fNLocalFits;             ///< Number of local fits
+  int fNLocalFitsRejected;     ///< Number of local fits rejected
+  int fNGlobalPar;             ///< Number of global parameters
+  int fNLocalPar;              ///< Number of local parameters
 
   ClassDef(AliMillepede, 0)  // Millepede Class
 };