Updated comments for Doxygen
authorivana <ivana@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 23 May 2006 16:08:52 +0000 (16:08 +0000)
committerivana <ivana@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 23 May 2006 16:08:52 +0000 (16:08 +0000)
131 files changed:
MUON/AliMUONBlockHeader.h
MUON/AliMUONBusStruct.h
MUON/AliMUONClusterDrawAZ.h
MUON/AliMUONClusterFinderAZ.h
MUON/AliMUONClusterFinderVS.h
MUON/AliMUONClusterInput.h
MUON/AliMUONClusterReconstructor.h
MUON/AliMUONDDLTracker.h
MUON/AliMUONDDLTrigger.h
MUON/AliMUONDarcHeader.h
MUON/AliMUONDetElement.h
MUON/AliMUONDigitCalibrator.h
MUON/AliMUONDigitMaker.h
MUON/AliMUONDigitizer.h
MUON/AliMUONDigitizerV3.h
MUON/AliMUONDspHeader.h
MUON/AliMUONEventRecoCombi.h
MUON/AliMUONGeometry.h
MUON/AliMUONGeometryBuilder.h
MUON/AliMUONGeometryConstituent.h
MUON/AliMUONGeometryDetElement.h
MUON/AliMUONGeometryEnvelope.h
MUON/AliMUONGeometryEnvelopeStore.h
MUON/AliMUONGeometryMisAligner.h
MUON/AliMUONGeometryModule.h
MUON/AliMUONGeometryModuleTransformer.h
MUON/AliMUONGeometrySegmentation.h
MUON/AliMUONGeometryStore.h
MUON/AliMUONGeometryTransformer.h
MUON/AliMUONGlobalTriggerBoard.h
MUON/AliMUONHitForRec.h
MUON/AliMUONLocalStruct.h
MUON/AliMUONLocalTriggerBoard.h
MUON/AliMUONPixel.h
MUON/AliMUONRawStreamTracker.h
MUON/AliMUONRawStreamTrigger.h
MUON/AliMUONRawWriter.h
MUON/AliMUONRecoTrack.h
MUON/AliMUONReconstructor.h
MUON/AliMUONRegHeader.h
MUON/AliMUONRegionalTriggerBoard.h
MUON/AliMUONResponseFactory.h
MUON/AliMUONResponseTrigger.h
MUON/AliMUONResponseTriggerV1.h
MUON/AliMUONResponseV0.h
MUON/AliMUONSegment.h
MUON/AliMUONSegmentation.h
MUON/AliMUONStringIntMap.h
MUON/AliMUONTest.h
MUON/AliMUONTrack.h
MUON/AliMUONTrackHit.h
MUON/AliMUONTrackK.h
MUON/AliMUONTrackParam.h
MUON/AliMUONTrackReconstructor.h
MUON/AliMUONTrigger.h
MUON/AliMUONTriggerBoard.h
MUON/AliMUONTriggerCrate.h
MUON/AliMUONTriggerDecision.h
MUON/AliMUONTriggerDecisionV1.h
MUON/AliMUONTriggerElectronics.h
MUON/AliMUONTriggerTrack.h
MUON/AliMUONVGeometryBuilder.h
MUON/mapping/AliMpArea.h
MUON/mapping/AliMpBusPatch.h
MUON/mapping/AliMpConnection.h
MUON/mapping/AliMpConstants.h
MUON/mapping/AliMpContainers.h
MUON/mapping/AliMpDEIterator.h
MUON/mapping/AliMpDEManager.h
MUON/mapping/AliMpExMap.h
MUON/mapping/AliMpFiles.h
MUON/mapping/AliMpGraphContext.h
MUON/mapping/AliMpHelper.h
MUON/mapping/AliMpIntPair.h
MUON/mapping/AliMpMotif.h
MUON/mapping/AliMpMotifMap.h
MUON/mapping/AliMpMotifPainter.h
MUON/mapping/AliMpMotifPosition.h
MUON/mapping/AliMpMotifPositionPadIterator.h
MUON/mapping/AliMpMotifReader.h
MUON/mapping/AliMpMotifSpecial.h
MUON/mapping/AliMpMotifType.h
MUON/mapping/AliMpMotifTypePadIterator.h
MUON/mapping/AliMpNeighboursPadIterator.h
MUON/mapping/AliMpPCB.h
MUON/mapping/AliMpPCBPainter.h
MUON/mapping/AliMpPad.h
MUON/mapping/AliMpPadIteratorPtr.h
MUON/mapping/AliMpPadPair.h
MUON/mapping/AliMpPadRow.h
MUON/mapping/AliMpPadRowLSegment.h
MUON/mapping/AliMpPadRowRSegment.h
MUON/mapping/AliMpPlaneType.h
MUON/mapping/AliMpRow.h
MUON/mapping/AliMpRowPainter.h
MUON/mapping/AliMpRowSegment.h
MUON/mapping/AliMpRowSegmentLSpecial.h
MUON/mapping/AliMpRowSegmentPainter.h
MUON/mapping/AliMpRowSegmentRSpecial.h
MUON/mapping/AliMpSector.h
MUON/mapping/AliMpSectorAreaHPadIterator.h
MUON/mapping/AliMpSectorAreaVPadIterator.h
MUON/mapping/AliMpSectorPadIterator.h
MUON/mapping/AliMpSectorPainter.h
MUON/mapping/AliMpSectorReader.h
MUON/mapping/AliMpSectorSegmentation.h
MUON/mapping/AliMpSegFactory.h
MUON/mapping/AliMpSlat.h
MUON/mapping/AliMpSlatPadIterator.h
MUON/mapping/AliMpSlatPainter.h
MUON/mapping/AliMpSlatSegmentation.h
MUON/mapping/AliMpSlatZonePadIterator.h
MUON/mapping/AliMpSt345Reader.h
MUON/mapping/AliMpStationType.h
MUON/mapping/AliMpStringObjMap.h
MUON/mapping/AliMpSubZone.h
MUON/mapping/AliMpSubZonePainter.h
MUON/mapping/AliMpTrigger.h
MUON/mapping/AliMpTriggerReader.h
MUON/mapping/AliMpTriggerSegmentation.h
MUON/mapping/AliMpVIndexed.h
MUON/mapping/AliMpVMotif.h
MUON/mapping/AliMpVPadIterator.h
MUON/mapping/AliMpVPadRowSegment.h
MUON/mapping/AliMpVPainter.h
MUON/mapping/AliMpVRowSegment.h
MUON/mapping/AliMpVRowSegmentSpecial.h
MUON/mapping/AliMpVSegmentation.h
MUON/mapping/AliMpXDirection.h
MUON/mapping/AliMpZone.h
MUON/mapping/AliMpZonePainter.h

index d5cf9da..edf2438 100644 (file)
@@ -58,15 +58,15 @@ public:
  private:
 
    // block header
-   Int_t     fTotalLength;    // total length of block structure (w/o padding word)
-   Int_t     fLength;         // length of raw data
-   Int_t     fDspId;          // Dsp id
-   Int_t     fTriggerWord[4]; // counter trigger word
-   Int_t     fPadding;        // padding dummy word for 64 bits transfer
+   Int_t     fTotalLength;    ///< total length of block structure (w/o padding word)
+   Int_t     fLength;         ///< length of raw data
+   Int_t     fDspId;          ///< Dsp id
+   Int_t     fTriggerWord[4]; ///< counter trigger word
+   Int_t     fPadding;        ///< padding dummy word for 64 bits transfer
 
-   static const Int_t fgkHeaderLength; // header length in word
+   static const Int_t fgkHeaderLength; ///< header length in word
  
-   TClonesArray*  fDspHeaderArray;  // array of block header
+   TClonesArray*  fDspHeaderArray;  ///< array of block header
 
    ClassDef(AliMUONBlockHeader,1)  // MUON block header for Tracker event
 };
index 9bdab8a..a81e5b5 100644 (file)
@@ -57,19 +57,19 @@ public:
    Int_t*  GetBusPatchHeader() {return &fTotalLength;}
 
  private:
-   Int_t     fTotalLength;   // total length of buspatch structure
-   Int_t     fLength;        // length of raw data
-   Int_t     fBusPatchId;    // bus patch id
-   Int_t     fTriggerWord ;  // counter trigger word
+   Int_t     fTotalLength;   ///< total length of buspatch structure
+   Int_t     fLength;        ///< length of raw data
+   Int_t     fBusPatchId;    ///< bus patch id
+   Int_t     fTriggerWord ;  ///< counter trigger word
 
-   static const Int_t fgkHeaderLength;   // header length in word
+   static const Int_t fgkHeaderLength;   ///< header length in word
 
-   UInt_t*   fData;          // data 
+   UInt_t*   fData;          ///< data 
 
-   Int_t     fBufSize;      // initial size for data array
+   Int_t     fBufSize;       ///< initial size for data array
 
-   Int_t     fDspId;             // Dsp number for monitoring
-   Int_t     fBlkId;             // block numer for monitoring
+   Int_t     fDspId;             ///< Dsp number for monitoring
+   Int_t     fBlkId;             ///< block numer for monitoring
 
    void ResizeData(Int_t size = 0);
 
index 490a5c1..629a2fb 100644 (file)
@@ -39,16 +39,16 @@ protected:
   AliMUONClusterDrawAZ& operator=(const AliMUONClusterDrawAZ& rhs);
 
 private:
-  AliMUONData *fData; //! pointer to muon data container
-  AliMUONClusterFinderAZ* fFind; //! pointer to ClusterFinder
-  TH2D*      fHist[4]; // ! histograms
-  Int_t      fnMu; // ! number of muons passing thru the selected area
-  Double_t   fxyMu[2][7]; // ! muon information
-  Int_t      fEvent; // ! current event
-  Int_t      fChamber; //! current chamber
-  Int_t      fidDE; //! current Det. Elem.
-  Int_t      fDebug; // ! debug level
-  Int_t      fModif; // ! modification flag (modified ROOT)
+  AliMUONData *fData; //!<  pointer to muon data container
+  AliMUONClusterFinderAZ* fFind; //!<  pointer to ClusterFinder
+  TH2D*      fHist[4]; //!<  histograms
+  Int_t      fnMu; //!<  number of muons passing thru the selected area
+  Double_t   fxyMu[2][7]; //!<  muon information
+  Int_t      fEvent; //!<  current event
+  Int_t      fChamber; //!<  current chamber
+  Int_t      fidDE; //!<  current Det. Elem.
+  Int_t      fDebug; //!<  debug level
+  Int_t      fModif; //!<  modification flag (modified ROOT)
 
   // Functions
 
index 02d2204..1cff26b 100644 (file)
@@ -46,30 +46,30 @@ protected:
 
  private:
   // Some constants
-  static const Int_t fgkDim = 10000; // array size
-  static const Double_t fgkCouplMin; // threshold on coupling 
-  static const Double_t fgkZeroSuppression; // average zero suppression value
-  static const Double_t fgkSaturation; // average saturation level
-
-  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
-  AliMUONVGeometryDESegmentation *fSegmentation[2]; // ! new segmentation
-  Float_t    fZpad;             // ! z-coordinate of the hit
-  Int_t      fNpar;             // ! number of fit parameters
-  Double_t   fQtot;             // ! total cluster charge
-  Int_t      fReco;             // ! !=0 if run reco with writing of reconstructed clusters 
-  Int_t fCathBeg;               // ! starting cathode (for combined cluster / track reco)
-  Int_t fPadBeg[2];             // ! starting pads (for combined cluster / track reco)
-
-  static     TMinuit* fgMinuit; // ! Fitter
-  Bool_t     fUsed[2][fgkDim]; // ! flags for used pads
-  AliMUONClusterDrawAZ *fDraw; // ! drawing object 
-  TObjArray* fPixArray; // ! collection of pixels
-  Int_t fnCoupled; // ! number of coupled clusters in precluster
-  Int_t fDebug; // ! debug level
+  static const Int_t fgkDim = 10000; ///< array size
+  static const Double_t fgkCouplMin; ///< threshold on coupling 
+  static const Double_t fgkZeroSuppression; ///< average zero suppression value
+  static const Double_t fgkSaturation; ///< average saturation level
+
+  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
+  AliMUONVGeometryDESegmentation *fSegmentation[2]; //!< new segmentation
+  Float_t    fZpad;             //!< z-coordinate of the hit
+  Int_t      fNpar;             //!< number of fit parameters
+  Double_t   fQtot;             //!< total cluster charge
+  Int_t      fReco;             //!< !=0 if run reco with writing of reconstructed clusters 
+  Int_t fCathBeg;               //!< starting cathode (for combined cluster / track reco)
+  Int_t fPadBeg[2];             //!< starting pads (for combined cluster / track reco)
+
+  static     TMinuit* fgMinuit; //!< Fitter
+  Bool_t     fUsed[2][fgkDim]; //!< flags for used pads
+  AliMUONClusterDrawAZ *fDraw; //!< drawing object 
+  TObjArray* fPixArray; //!< collection of pixels
+  Int_t fnCoupled; //!< number of coupled clusters in precluster
+  Int_t fDebug; //!< debug level
 
   // Functions
 
index 94cd5ae..aa405f6 100644 (file)
@@ -66,49 +66,49 @@ class AliMUONClusterFinderVS : public TObject
 //  Assignment operator
     AliMUONClusterFinderVS & operator = (const AliMUONClusterFinderVS& rhs);
 
-    AliMUONClusterInput*          fInput;              // ! AliMUONClusterInput instance
-    AliMUONDigitMapA1*            fDigitMap[2];          // Hit Maps for cathode 1 and 2
-    AliMUONGeometrySegmentation*  fSeg2[2];            // New Segmentations for cathode 1 and 2
+    AliMUONClusterInput*          fInput;        //!< AliMUONClusterInput instance
+    AliMUONDigitMapA1*            fDigitMap[2];  ///< Hit Maps for cathode 1 and 2
+    AliMUONGeometrySegmentation*  fSeg2[2];      ///< New Segmentations for cathode 1 and 2
 
     
 // Configuration    
-    Int_t                   fDeclusterFlag;      // flag for declusterin
-    Int_t                   fClusterSize;        // cluster size 
-    Int_t                   fNperMax;            // Maximum number of pads per peak
-    Float_t                 fGhostChi2Cut;       // Cut in charge matching chi2
-                                                // (2 degrees of freedom)
-                                                 // Used by ghost removal
+    Int_t                   fDeclusterFlag;      ///< flag for declusterin
+    Int_t                   fClusterSize;        ///< cluster size 
+    Int_t                   fNperMax;            ///< Maximum number of pads per peak
+    Float_t                 fGhostChi2Cut;       ///< \brief Cut in charge matching chi2
+                                                /// (2 degrees of freedom)
+                                                 /// Used by ghost removal
     // Current decluster result    
-    Int_t                   fMul[2];             // current multiplicity
-    Int_t                   fNPeaks;             // number of local maxima
-    Int_t                   fNRawClusters;       // Number of Raw Clusters
-    TClonesArray*           fRawClusters;        // array of cluster per ch.
+    Int_t                   fMul[2];             ///< current multiplicity
+    Int_t                   fNPeaks;             ///< number of local maxima
+    Int_t                   fNRawClusters;       ///< Number of Raw Clusters
+    TClonesArray*           fRawClusters;        ///< array of cluster per ch.
 
     // Local data store    
-    AliMUONDigit*           fDig[100][2];        // current list of digits 
-    Int_t                   fIx[100][2];         // current list of x-pad-coord.
-    Int_t                   fIy[100][2];         // current list of y-pad-coord.
-    Float_t                 fX[100][2];          // current list of x-coord.
-    Float_t                 fY[100][2];          // current list of y-coord.
-    Float_t                 fZ[100][2];          // current list of z-coord.
-    Int_t                   fIndLocal[100][2];   // indices of local maxima
-    Int_t                   fNLocal[2];          // Number of local maxima
-    Int_t                   fQ[100][2];          // current list of charges
-    Float_t                 fZPlane;             // currenz z-plane position
-    Int_t                   fSector;             // current sector
+    AliMUONDigit*           fDig[100][2];        ///< current list of digits 
+    Int_t                   fIx[100][2];         ///< current list of x-pad-coord.
+    Int_t                   fIy[100][2];         ///< current list of y-pad-coord.
+    Float_t                 fX[100][2];          ///< current list of x-coord.
+    Float_t                 fY[100][2];          ///< current list of y-coord.
+    Float_t                 fZ[100][2];          ///< current list of z-coord.
+    Int_t                   fIndLocal[100][2];   ///< indices of local maxima
+    Int_t                   fNLocal[2];          ///< Number of local maxima
+    Int_t                   fQ[100][2];          ///< current list of charges
+    Float_t                 fZPlane;             ///< currenz z-plane position
+    Int_t                   fSector;             ///< current sector
     
     // Current Fit
-    Double_t                 fXFit[2];         // x-coordinate
-    Double_t                 fYFit[2];         // y-coordinate
-    Double_t                 fQrFit[2];        // charge ratio
-    Float_t                  fChi2[2];         // chi2 of fit
-    Float_t                  fXInit[2];        // start values
-    Float_t                  fYInit[2];        // start values
-    Float_t                  fQrInit[2];       // start values
-    Int_t                    fFitStat;         // status of fit
+    Double_t                 fXFit[2];         ///< x-coordinate
+    Double_t                 fYFit[2];         ///< y-coordinate
+    Double_t                 fQrFit[2];        ///< charge ratio
+    Float_t                  fChi2[2];         ///< chi2 of fit
+    Float_t                  fXInit[2];        ///< start values
+    Float_t                  fYInit[2];        ///< start values
+    Float_t                  fQrInit[2];       ///< start values
+    Int_t                    fFitStat;         ///< status of fit
     
     // Selected track for debugging
-    Int_t                    fTrack[2];        // Only digits with main contributions from these tracks are
+    Int_t                    fTrack[2];        ///< Only digits with main contributions from these tracks are
     // considered 
     
     //  Return pointer to raw clusters    
index 7c245a8..ee07ab9 100644 (file)
@@ -61,34 +61,34 @@ class AliMUONClusterInput : public TObject
     AliMUONClusterInput(const AliMUONClusterInput& clusterInput);
     AliMUONClusterInput & operator = (const AliMUONClusterInput& rhs);
  private:
-    static AliMUONClusterInput*  fgClusterInput;  // ! singleton instance
-    static AliMUONMathieson*     fgMathieson;     // ! Mathieson
-    static AliMUONGeometryTransformer*  fgTransformer;  // ! Geometry transformer
-    static AliMUONSegmentation*  fgSegmentation;  // ! Segmentation
+    static AliMUONClusterInput*  fgClusterInput;  //!< singleton instance
+    static AliMUONMathieson*     fgMathieson;     //!< Mathieson
+    static AliMUONGeometryTransformer*  fgTransformer;  //!< Geometry transformer
+    static AliMUONSegmentation*  fgSegmentation;  //!< Segmentation
 
     // Digits
-    TClonesArray*        fDigits[2];       // ! Array of pointers to digits
-    Int_t                fNDigits[2];      // ! Number of digits
-    AliMUONGeometrySegmentation*     fSegmentation2[2]; // ! Geometry Segmentation per cathode
+    TClonesArray*        fDigits[2];       //!< Array of pointers to digits
+    Int_t                fNDigits[2];      //!< Number of digits
+    AliMUONGeometrySegmentation*     fSegmentation2[2]; //!< Geometry Segmentation per cathode
 
-    Int_t                fNseg;            // ! number of cathode planes
-    Int_t                fChamber;         // ! Current chamber number
+    Int_t                fNseg;            //!< number of cathode planes
+    Int_t                fChamber;         //!< Current chamber number
     
     // Current cluster
-    AliMUONRawCluster*   fCluster;         // ! current cluster
-    Int_t                fNmul[2];         // ! current cluster multiplicity
+    AliMUONRawCluster*   fCluster;         //!< current cluster
+    Int_t                fNmul[2];         //!< current cluster multiplicity
     // Digits contribuing to current cluster
-    Int_t                fix[500][2];      // ! List of x-positions for current cluster
-    Int_t                fiy[500][2];      // ! List of y-positions for current cluster
-    Float_t              fCharge[500][2];  // ! List of charges for current cluster
-    Int_t                fChargeTot[2];    // ! Total charge
-    Float_t              fQtot[2];         // ! Total charge
-    Float_t              fZ;               // ! Current z-position
-    Float_t              fChargeCorrel;    // ! charge correlation 
-    Int_t                fDetElemId;       // ! detection elt id    
+    Int_t                fix[500][2];      //!< List of x-positions for current cluster
+    Int_t                fiy[500][2];      //!< List of y-positions for current cluster
+    Float_t              fCharge[500][2];  //!< List of charges for current cluster
+    Int_t                fChargeTot[2];    //!< Total charge
+    Float_t              fQtot[2];         //!< Total charge
+    Float_t              fZ;               //!< Current z-position
+    Float_t              fChargeCorrel;    //!< charge correlation 
+    Int_t                fDetElemId;       //!< detection elt id    
 
     // Fitter
-    static TMinuit*      fgMinuit;          // ! Fitter
+    static TMinuit*      fgMinuit;          //!< Fitter
     ClassDef(AliMUONClusterInput, 0)        // Global data service for hit reconstruction
 };
 #endif
index b084ca2..ec04811 100644 (file)
@@ -42,11 +42,11 @@ class AliMUONClusterReconstructor : public TObject
   
  private:
 
-  AliMUONData*            fMUONData;           //! Data container for MUON subsystem 
-  AliMUONClusterFinderVS* fRecModel;           //! cluster recontruction model
+  AliMUONData*            fMUONData;           //!< Data container for MUON subsystem 
+  AliMUONClusterFinderVS* fRecModel;           //!< cluster recontruction model
 
-  TClonesArray* fDigitsCath0; //! digits for cathode 0 of the current DE
-  TClonesArray* fDigitsCath1; //! digits for cathode 1 of the current DE
+  TClonesArray* fDigitsCath0; //!< digits for cathode 0 of the current DE
+  TClonesArray* fDigitsCath1; //!< digits for cathode 1 of the current DE
   
   ClassDef(AliMUONClusterReconstructor,0) // MUON cluster reconstructor in ALICE
 };
index 0a5efb0..5b44f1c 100644 (file)
@@ -44,7 +44,7 @@ public:
 
  private:
 
-   TClonesArray* fBlkHeaderArray;  // array of block header
+   TClonesArray* fBlkHeaderArray;  ///< array of block header
    
  
    ClassDef(AliMUONDDLTracker,1)  // MUON DDL Tracker
index e89adf6..e7e80c4 100644 (file)
@@ -33,7 +33,7 @@ public:
 
  private:
 
-   AliMUONDarcHeader* fDarcHeader;  // pointer of darc header
+   AliMUONDarcHeader* fDarcHeader;  ///< pointer of darc header
    
 
    ClassDef(AliMUONDDLTrigger,1)  // MUON DDL Trigger
index 228b2b0..7a0ceb1 100644 (file)
@@ -89,34 +89,34 @@ public:
 
  private:
 
-   UInt_t    fWord;              // first word
-   Int_t     fGlobalInput[4];    // global input
-   Int_t     fGlobalOutput;      // global ouput
+   UInt_t    fWord;              ///< first word
+   Int_t     fGlobalInput[4];    ///< global input
+   Int_t     fGlobalOutput;      ///< global ouput
 
-   static const Int_t fgkHeaderLength; // header length
+   static const Int_t fgkHeaderLength; ///< header length
 
 
  // global card scalers   
-   UInt_t     fGlobalL0;         // global L0
-   UInt_t     fGlobalClk;        // global clock
-   UInt_t     fGlobalScaler[6];  // global ouput
-   UInt_t     fGlobalHold;       // global hold (dead time)
-   UInt_t     fGlobalSpare;      // global spare
-   static const Int_t      fgkGlobalScalerLength;  // length of global scaler in word
+   UInt_t     fGlobalL0;         ///< global L0
+   UInt_t     fGlobalClk;        ///< global clock
+   UInt_t     fGlobalScaler[6];  ///< global ouput
+   UInt_t     fGlobalHold;       ///< global hold (dead time)
+   UInt_t     fGlobalSpare;      ///< global spare
+   static const Int_t      fgkGlobalScalerLength;  ///< length of global scaler in word
 
    // DARC Scalers
-   UInt_t     fDarcL0R;       // DARC L0 received
-   UInt_t     fDarcL0U;       // DARC L0 used
-   UInt_t     fDarcL0P;       // DARC Physical L0
-   UInt_t     fDarcL0S;       // DARC Software (checking) L0
-   UInt_t     fDarcClk;       // DARC clock
-   UInt_t     fDarcHold;      // DARC hold (dead time)
-   static const Int_t      fgkDarcScalerLength;  // length of DARC scaler in word
-
-   static const UInt_t     fgkEndOfDarc;         // end of darc info word
-   static const UInt_t     fgkEndOfGlobal;       // end of global info word
-
-   TClonesArray* fRegHeaderArray; //container for regional header
+   UInt_t     fDarcL0R;       ///< DARC L0 received
+   UInt_t     fDarcL0U;       ///< DARC L0 used
+   UInt_t     fDarcL0P;       ///< DARC Physical L0
+   UInt_t     fDarcL0S;       ///< DARC Software (checking) L0
+   UInt_t     fDarcClk;       ///< DARC clock
+   UInt_t     fDarcHold;      ///< DARC hold (dead time)
+   static const Int_t      fgkDarcScalerLength;  ///< length of DARC scaler in word
+
+   static const UInt_t     fgkEndOfDarc;         ///< end of darc info word
+   static const UInt_t     fgkEndOfGlobal;       ///< end of global info word
+
+   TClonesArray* fRegHeaderArray; ///< container for regional header
 
    ClassDef(AliMUONDarcHeader,1)  // MUON DDL Trigger
 };
index 4ddc214..43fdfde 100644 (file)
@@ -60,18 +60,18 @@ class AliMUONDetElement : public TObject
 
  private:
  
-  Int_t fidDE; // det. elem. ID
-  Int_t fIndex; // det. elem. position index in container
-  Int_t fChamber; // chamber No
-  Double_t fZ; // det. elem. Z-coordinate
-  Int_t fLeft[2]; // numbers of digits not used for clustering
-  Int_t fNHitsForRec; // number of hits for rec.
-  AliMUONGeometrySegmentation* fSeg[2]; // segmentation
-  AliMUONHitMapA1 *fHitMap[2]; // map of digits
-  TObjArray *fDigits[2]; // container of digits from this det. elem.
-  TObjArray *fRawClus; // raw clusters
-  TClonesArray *fHitsForRec; // HitForRec's
-  AliMUONClusterFinderAZ *fRecModel; // cluster finder
+  Int_t fidDE; ///< det. elem. ID
+  Int_t fIndex; ///< det. elem. position index in container
+  Int_t fChamber; ///< chamber No
+  Double_t fZ; ///< det. elem. Z-coordinate
+  Int_t fLeft[2]; ///< numbers of digits not used for clustering
+  Int_t fNHitsForRec; ///< number of hits for rec.
+  AliMUONGeometrySegmentation* fSeg[2]; ///< segmentation
+  AliMUONHitMapA1 *fHitMap[2]; ///< map of digits
+  TObjArray *fDigits[2]; ///< container of digits from this det. elem.
+  TObjArray *fRawClus; ///< raw clusters
+  TClonesArray *fHitsForRec; ///< HitForRec's
+  AliMUONClusterFinderAZ *fRecModel; ///< cluster finder
 
   // Functions
 
index cd68865..76bc8da 100644 (file)
@@ -32,8 +32,8 @@ protected:
   AliMUONDigitCalibrator& operator=(const AliMUONDigitCalibrator& other);
        
 private:    
-    AliMUONData* fData; //!
-    AliMUONCalibrationData* fCalibrationData; //!
+    AliMUONData* fData;                       //!< MUON data 
+    AliMUONCalibrationData* fCalibrationData; //!< Calibration data
   
   ClassDef(AliMUONDigitCalibrator,1) // Subtract pedestal from digit charge.
 };
index 3c3f10c..cfb73d3 100644 (file)
@@ -52,25 +52,25 @@ class AliMUONDigitMaker : public TObject
 
  private:
 
-  AliMUONData*     fMUONData;          //! Data container for MUON subsystem 
+  AliMUONData*     fMUONData;          //!< Data container for MUON subsystem 
   
-  AliMpSegFactory* fSegFactory;        //! Mapping segmentation factory
+  AliMpSegFactory* fSegFactory;        //!< Mapping segmentation factory
 
-  AliMpBusPatch*   fBusPatchManager;   //! buspatch versus DE's & DDL
+  AliMpBusPatch*   fBusPatchManager;   //!< buspatch versus DE's & DDL
 
-  Bool_t           fScalerEvent;       //! flag to generates scaler event
+  Bool_t           fScalerEvent;       //!< flag to generates scaler event
 
-  AliMUONRawStreamTracker* fRawStreamTracker;  //!pointer of raw stream for tracker
-  AliMUONRawStreamTrigger* fRawStreamTrigger;  //!pointer of raw stream for trigger
+  AliMUONRawStreamTracker* fRawStreamTracker;  //!< pointer of raw stream for tracker
+  AliMUONRawStreamTrigger* fRawStreamTrigger;  //!< pointer of raw stream for trigger
 
-  AliMUONDigit*        fDigit;         //! pointer to digits
+  AliMUONDigit*        fDigit;         //!< pointer to digits
 
-  AliMUONLocalTrigger*  fLocalTrigger;  //! pointer to local trigger
-  AliMUONGlobalTrigger* fGlobalTrigger;  //! pointer to local trigger
+  AliMUONLocalTrigger*  fLocalTrigger; //!< pointer to local trigger
+  AliMUONGlobalTrigger* fGlobalTrigger;//!< pointer to local trigger
 
-  TStopwatch fTrackerTimer; //!
-  TStopwatch fTriggerTimer; //!
-  TStopwatch fMappingTimer; //!
+  TStopwatch fTrackerTimer; //!< 
+  TStopwatch fTriggerTimer; //!< 
+  TStopwatch fMappingTimer; //!< 
 
   ClassDef(AliMUONDigitMaker,1) // MUON digit maker from rawdata
 };
index 6df9b87..725ebf0 100644 (file)
@@ -173,19 +173,19 @@ protected:
                        Int_t charges[kMAXTRACKS], Int_t digits[6],
                        Int_t digitindex ) = 0;
 
-       AliRunLoader* fRunLoader;         //! Global run loader.
-       AliMUONLoader* fGime;             //! MUON specific loader.
-       AliMUON* fMUON;                   //! Pointer to MUON module.
-       AliMUONData* fMUONData;           //! muon data interface
-       AliMUONTriggerDecision* fTrigDec; //!trigger pointer
-
-       AliMUONHitMapA1 **fHitMap;      //! pointer to array of pointers to hitmaps
-       TObjArray *fTDList;             //! list of AliMUONTransientDigits
-       Int_t fTDCounter;               //! nr. of AliMUONTransientDigit
-       Int_t fMask;                    //! mask dependent on input file
-       Bool_t fSignal;                 //! kTRUE if signal file is processed 
-       Int_t fSegmentation;            //! segmentation type 1=old, 2=new;
-       Int_t fNDetElemId[1500];       //! detection element number array 
+       AliRunLoader* fRunLoader;         //!< Global run loader.
+       AliMUONLoader* fGime;             //!< MUON specific loader.
+       AliMUON* fMUON;                   //!< Pointer to MUON module.
+       AliMUONData* fMUONData;           //!< muon data interface
+       AliMUONTriggerDecision* fTrigDec; //!< trigger pointer
+
+       AliMUONHitMapA1 **fHitMap;    //!< pointer to array of pointers to hitmaps
+       TObjArray *fTDList;           //!< list of AliMUONTransientDigits
+       Int_t fTDCounter;             //!< nr. of AliMUONTransientDigit
+       Int_t fMask;                  //!< mask dependent on input file
+       Bool_t fSignal;               //!< kTRUE if signal file is processed 
+       Int_t fSegmentation;          //!< segmentation type 1=old, 2=new;
+       Int_t fNDetElemId[1500];      //!< detection element number array 
 
 
 private:
index f32f794..9fea4b7 100644 (file)
@@ -76,20 +76,20 @@ private:
                         Int_t mask);
   
 private:
-  Bool_t fIsInitialized; // are we initialized ?
-  AliMUONData* fOutputData; //! pointer to access digits
-  AliMUONCalibrationData* fCalibrationData; //! pointer to access calib parameters
-  TTask* fTriggerProcessor; // pointer to the trigger part of the job
-  ETriggerCodeVersion fTriggerCodeVersion; // which version of trigger job
-  Bool_t fUseTriggerEfficiency; // whether or not we should apply trigger efficiency
-  AliMUONTriggerEfficiencyCells* fTriggerEfficiency; // trigger efficiency map  
-  mutable TStopwatch fFindDigitIndexTimer; //! counting time spent in FindDigitIndex
-  TStopwatch fGenerateNoisyDigitsTimer; //! counting time spent in GenerateNoisyDigits()
-  TStopwatch fExecTimer; //! couting time spent in Exec()  
-  TF1* fNoiseFunction; //! function to randomly get signal above n*sigma_ped
-  Bool_t fGenerateNoisyDigits; //! whether or not we should generate noise-only digits for tracker
-  static const Double_t fgkNSigmas; // number of sigmas above ped to use 
-  // for noise-only digit generation and zero-suppression
+  Bool_t fIsInitialized; ///< are we initialized ?
+  AliMUONData* fOutputData; //!< pointer to access digits
+  AliMUONCalibrationData* fCalibrationData; //!< pointer to access calib parameters
+  TTask* fTriggerProcessor; ///< pointer to the trigger part of the job
+  ETriggerCodeVersion fTriggerCodeVersion; ///< which version of trigger job
+  Bool_t fUseTriggerEfficiency; ///< whether or not we should apply trigger efficiency
+  AliMUONTriggerEfficiencyCells* fTriggerEfficiency; ///< trigger efficiency map  
+  mutable TStopwatch fFindDigitIndexTimer; //!< counting time spent in FindDigitIndex
+  TStopwatch fGenerateNoisyDigitsTimer; //!< counting time spent in GenerateNoisyDigits()
+  TStopwatch fExecTimer; //!< couting time spent in Exec()  
+  TF1* fNoiseFunction; //!< function to randomly get signal above n*sigma_ped
+  Bool_t fGenerateNoisyDigits; //!< whether or not we should generate noise-only digits for tracker
+  static const Double_t fgkNSigmas; ///< \brief number of sigmas above ped to use 
+  /// for noise-only digit generation and zero-suppression
 
   ClassDef(AliMUONDigitizerV3,3) // MUON Digitizer V3-3
 };
index 171e73f..76a68fc 100644 (file)
@@ -59,14 +59,14 @@ public:
  private:
 
    // Dsp header
-   Int_t     fTotalLength;      // total length of block structure
-   Int_t     fLength;           // length of raw data
-   Int_t     fDspId;            // Dsp id ??
-   Int_t     fTriggerWord[4];   // counter trigger word ?
-   Int_t     fEventWord;        // nb word odd = 1, even = 0
-   static const Int_t fgkHeaderLength; // header length
-
-    TClonesArray* fBusPatchArray;   // array of buspatch structure
+   Int_t     fTotalLength;      ///< total length of block structure
+   Int_t     fLength;           ///< length of raw data
+   Int_t     fDspId;            ///< Dsp id ??
+   Int_t     fTriggerWord[4];   ///< counter trigger word ?
+   Int_t     fEventWord;        ///< nb word odd = 1, even = 0
+   static const Int_t fgkHeaderLength; ///< header length
+
+    TClonesArray* fBusPatchArray;   ///< array of buspatch structure
 
    ClassDef(AliMUONDspHeader,1)  // MUON Dsp header for Tracker event
 };
index 2d5172b..25cf12f 100644 (file)
@@ -40,11 +40,11 @@ class AliMUONEventRecoCombi : public TObject
     AliMUONEventRecoCombi & operator = (const AliMUONEventRecoCombi& rhs);
 
  private:
-    static AliMUONEventRecoCombi* fgRecoCombi; // ! singleton instance
-    TClonesArray *fDetElems; // ! array of Det. Elem. objects
-    TArrayD *fZ; // ! array of det. elem. Z-coordinates
-    Int_t fNZ; // ! number of different Z's
-    Int_t **fDEvsZ; // ! list of DE's vs Z-coordinates
+    static AliMUONEventRecoCombi* fgRecoCombi; //!<  singleton instance
+    TClonesArray *fDetElems; //!<  array of Det. Elem. objects
+    TArrayD *fZ; //!<  array of det. elem. Z-coordinates
+    Int_t fNZ; //!<  number of different Z's
+    Int_t **fDEvsZ; //!<  list of DE's vs Z-coordinates
 
     ClassDef(AliMUONEventRecoCombi, 0) // Combined cluster/track finder steering class
       };
index 4e732d3..ca957ed 100644 (file)
@@ -56,8 +56,8 @@ class AliMUONGeometry : public TObject
     void    WriteData3(ofstream& out) const;
 
     // data members
-    TObjArray*                  fModules;     // Array of geometry modules
-    AliMUONGeometryTransformer* fTransformer; // Geometry transformer
+    TObjArray*                  fModules;     ///< Array of geometry modules
+    AliMUONGeometryTransformer* fTransformer; ///< Geometry transformer
 
   ClassDef(AliMUONGeometry,1)  // Geometry parametrisation
 };
index 3716fbc..a493640 100644 (file)
@@ -71,21 +71,21 @@ class AliMUONGeometryBuilder : public TObject
     void SetAlign(AliMUONVGeometryBuilder* builder);        
 
     // static data members
-    static const TString  fgkDefaultVolPathsFileName;  // default volume paths file name                                          
-    static const TString  fgkDefaultTransformFileName; // default transformations file name                                       
-    static const TString  fgkDefaultSVMapFileName;     // default svmaps file name                                        
-    static const TString  fgkOutFileNameExtension;     // default output file name extension                                      
+    static const TString  fgkDefaultVolPathsFileName;  ///< default volume paths file name                                        
+    static const TString  fgkDefaultTransformFileName; ///< default transformations file name                                     
+    static const TString  fgkDefaultSVMapFileName;     ///< default svmaps file name                                      
+    static const TString  fgkOutFileNameExtension;     ///< default output file name extension                                    
 
     // data members
-    AliModule*       fModule;              // the AliRoot module
-    Bool_t           fAlign;               // option to read transformations 
-                                           // from a file
-    TString          fTransformFileName;   // transformations file name                                           
-    TString          fSVMapFileName;       // svmaps file name                                    
-    TGeoCombiTrans   fGlobalTransformation;// global transformation 
-                                           // applied to the whole geometry 
-    TObjArray*       fGeometryBuilders;    // list of Geometry Builders
-    AliMUONGeometry* fGeometry;            // geometry parametrisation
+    AliModule*       fModule;              ///< the AliRoot module
+    Bool_t           fAlign;               ///< \brief option to read transformations 
+                                           /// from a file
+    TString          fTransformFileName;   ///< transformations file name                                         
+    TString          fSVMapFileName;       ///< svmaps file name                                          
+    TGeoCombiTrans   fGlobalTransformation;///< \brief global transformation 
+                                           /// applied to the whole geometry 
+    TObjArray*       fGeometryBuilders;    ///< list of Geometry Builders
+    AliMUONGeometry* fGeometry;            ///< geometry parametrisation
 
   ClassDef(AliMUONGeometryBuilder,6)  // Geometry builder
 };
index 72c77ce..a017f21 100644 (file)
@@ -51,11 +51,14 @@ class AliMUONGeometryConstituent : public TNamed
     AliMUONGeometryConstituent& operator = (const AliMUONGeometryConstituent& rhs);
 
   private:
-    Int_t            fCopyNo;        // copy number
-    Int_t            fNpar;          // number of shape parameters
+    Int_t            fCopyNo;        ///< copy number
+    Int_t            fNpar;          ///< number of shape parameters
+    
+    /// shape parameters
     Double_t*        fParam;         //[fNpar] shape parameters
-    TGeoCombiTrans*  fTransformation;// the constituent transformation wrt to the
-                                     // envelope
+
+    TGeoCombiTrans*  fTransformation;///< \brief the constituent transformation
+                                     ///  wrt to the envelope
  
   ClassDef(AliMUONGeometryConstituent,1) // MUON chamber geometry base class
 };
index 9c72eac..1c6635b 100644 (file)
@@ -66,10 +66,10 @@ class AliMUONGeometryDetElement : public TObject
     void PrintTransform(const TGeoHMatrix* transform) const;
   
     // data members
-    TString       fVolumePath; // the full path of aligned volume or envelope
-                               // in geometry
-    TGeoHMatrix*  fLocalTransformation;  // the transformation wrt module
-    TGeoHMatrix*  fGlobalTransformation; // the transformation wrt world
+    TString       fVolumePath; ///< \brief the full path of aligned volume
+                               ///  or envelope in geometry
+    TGeoHMatrix*  fLocalTransformation;  ///< the transformation wrt module
+    TGeoHMatrix*  fGlobalTransformation; ///< the transformation wrt world
 
   ClassDef(AliMUONGeometryDetElement,2) // MUON det element transformations
 };
index fea08d3..3ebaaf0 100644 (file)
@@ -73,17 +73,17 @@ class AliMUONGeometryEnvelope : public TNamed
     AliMUONGeometryEnvelope& operator = (const AliMUONGeometryEnvelope& rhs);
 
   private:
-    Bool_t           fIsVirtual;     // true if envelope is not represented
-                                     // by a real volume
-    Bool_t           fIsMANY;        // true if envelope is placed with
-                                     // MANY option
-    Int_t            fCopyNo;        // copy number 
-                                     // (only non virtual envelope can have 
-                                    //  more than one copy)
-    TGeoCombiTrans*  fTransformation;// the envelope transformation wrt to the
-                                     // mother frame (the chamber position)
-    TObjArray*       fConstituents;  // the constituents names and transformations
-                                    // wrt to the envelope position                                 
+    Bool_t           fIsVirtual;     ///< \brief true if envelope is not represented
+                                     /// by a real volume
+    Bool_t           fIsMANY;        ///< \brief true if envelope is placed with
+                                     /// MANY option
+    Int_t            fCopyNo;        ///< \brief copy number 
+                                     /// (only non virtual envelope can have 
+                                    ///  more than one copy)
+    TGeoCombiTrans*  fTransformation;///< \brief  the envelope transformation wrt to the
+                                     /// mother frame (the chamber position)
+    TObjArray*       fConstituents;  ///< \brief the constituents names and transformations
+                                    /// wrt to the envelope position                                 
  
   ClassDef(AliMUONGeometryEnvelope,1) // MUON chamber geometry base class
 };
index 1d96a24..1e73b8f 100644 (file)
@@ -131,15 +131,15 @@ class AliMUONGeometryEnvelopeStore : public TObject
     Bool_t AlignEnvelope(AliMUONGeometryEnvelope* envelope) const;
  
     // data members
-    TObjArray*  fEnvelopes; // the envelopes names and transformations
-                           // wrt to the chamber position in mother volume                                 
-    AliMUONGeometryStore*  fDetElements; // detection elements
-                            // used for alignement of enevelopes
-    TGeoCombiTrans fReferenceFrame; // the transformation from the builder 
-                                    // reference frame to that of the transform 
-                                   // data files
-    Bool_t      fDebug;     // Switch for debugging  
-    Bool_t      fAlign;     // option to read transformations from a file
+    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
+    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      fAlign;     ///< option to read transformations from a file
  
   ClassDef(AliMUONGeometryEnvelopeStore,2) // Geometry envelope store
 };
index e22b6e3..370fb89 100644 (file)
@@ -72,17 +72,17 @@ class AliMUONGeometryMisAligner:public TObject
   void GetUniMisAlign(Double_t cartMisAlig[3], Double_t angMisAlig[3]) const;
   void GetGausMisAlign(Double_t cartMisAlig[3], Double_t angMisAlig[3]) const;
 
-  Bool_t fUseUni;            // use uniform distribution for misaligmnets
-  Bool_t fUseGaus;            // use gaussian distribution for misaligmnets
-  Double_t fCartXMisAligM;   // cartesian displacement mean along x,  (translations)
-  Double_t fCartXMisAligW;   // cartesian displacement width along x,  (translations)
-  Double_t fCartYMisAligM;   // cartesian displacement mean along y,  (translations)
-  Double_t fCartYMisAligW;   // cartesian displacement width along y,  (translations)
-  Double_t fAngMisAligM;    // Angular displacement mean (rotations)
-  Double_t fAngMisAligW;    // Angular displacement range (rotations)
-  Double_t fXYAngMisAligFactor; // factor (<1) to apply to angular misalignment range since range of motion is restricted out of the xy plane
-  Double_t fZCartMisAligFactor; // factor (<1) to apply to cartetian misalignment range since range of motion is restricted in z direction
-  TRandom *fDisplacementGenerator;  // random number generator for the displacements
+  Bool_t fUseUni;            ///< use uniform distribution for misaligmnets
+  Bool_t fUseGaus;           ///< use gaussian distribution for misaligmnets
+  Double_t fCartXMisAligM;   ///< cartesian displacement mean along x,  (translations)
+  Double_t fCartXMisAligW;   ///< cartesian displacement width along x,  (translations)
+  Double_t fCartYMisAligM;   ///< cartesian displacement mean along y,  (translations)
+  Double_t fCartYMisAligW;   ///< cartesian displacement width along y,  (translations)
+  Double_t fAngMisAligM;     ///< Angular displacement mean (rotations)
+  Double_t fAngMisAligW;     ///< Angular displacement range (rotations)
+  Double_t fXYAngMisAligFactor; ///< factor (<1) to apply to angular misalignment range since range of motion is restricted out of the xy plane
+  Double_t fZCartMisAligFactor; ///< factor (<1) to apply to cartetian misalignment range since range of motion is restricted in z direction
+  TRandom *fDisplacementGenerator;  ///< random number generator for the displacements
   
   ClassDef(AliMUONGeometryMisAligner,3)        // Geometry parametrisation
 };
index b017d02..f55e1fd 100644 (file)
@@ -75,14 +75,14 @@ class AliMUONGeometryModule : public TObject
     Int_t  GetSVIndex(Int_t svVolId) const; 
   
     // data members
-    Bool_t           fIsVirtual;     // true if module is not represented
-                                     // by a real volume
-    Int_t            fNofSVs;        // number of sensitive volumes   
-    TArrayI*         fSVVolumeIds;   // sensitive volumes IDs  
-
-    AliMUONGeometryEnvelopeStore*     fEnvelopes;  // envelopes                                 
-    AliMUONStringIntMap*              fSVMap;      // sensitive volumes map
-    AliMUONGeometryModuleTransformer* fTransformer;// geometry transformations
+    Bool_t           fIsVirtual;     ///< \brief true if module is not represented
+                                     /// by a real volume
+    Int_t            fNofSVs;        ///< number of sensitive volumes   
+    TArrayI*         fSVVolumeIds;   ///< sensitive volumes IDs  
+
+    AliMUONGeometryEnvelopeStore*     fEnvelopes;  ///< envelopes                                 
+    AliMUONStringIntMap*              fSVMap;      ///< sensitive volumes map
+    AliMUONGeometryModuleTransformer* fTransformer;///< geometry transformations
  
   ClassDef(AliMUONGeometryModule,4) // MUON geometry module class
 };
index 922c2ff..5068c36 100644 (file)
@@ -75,12 +75,12 @@ class AliMUONGeometryModuleTransformer : public TObject
 
   private:
     // data members
-    Int_t                 fModuleId;   // the module Id
-    TString               fVolumePath; // the full path of aligned module volume
-                                       // or envelope in geometry
-    TGeoHMatrix*          fTransformation;// the module transformation wrt to top
-                                          // volume
-    AliMUONGeometryStore* fDetElements;   // detection elements
+    Int_t                 fModuleId;   ///< the module Id
+    TString               fVolumePath; ///< \brief the full path of aligned module volume
+                                       /// or envelope in geometry
+    TGeoHMatrix*          fTransformation;///< \brief the module transformation wrt to top
+                                          /// volume
+    AliMUONGeometryStore* fDetElements;   ///< detection elements
  
   ClassDef(AliMUONGeometryModuleTransformer,3) // MUON geometry module class
 };
index 6a22776..916bd08 100644 (file)
@@ -192,17 +192,17 @@ class AliMUONGeometrySegmentation : public TObject
     Bool_t OwnNotify(Int_t detElemId, Bool_t warn = true) const;
 
     // static data members
-    static  const Float_t  fgkMaxDistance; // the big value passed to pad coordinates
-                                           // if pad does not exist
+    static  const Float_t  fgkMaxDistance; ///< \brief the big value passed to pad coordinates
+                                           /// if pad does not exist
   
     // data members
-    mutable  Int_t                           fCurrentDetElemId;   // current DE ID 
-    mutable  AliMUONGeometryDetElement*      fCurrentDetElement;  // current detection element 
-    mutable  AliMUONVGeometryDESegmentation* fCurrentSegmentation;// current DE segmentation
+    mutable  Int_t                           fCurrentDetElemId;   ///< current DE ID 
+    mutable  AliMUONGeometryDetElement*      fCurrentDetElement;  ///< current detection element 
+    mutable  AliMUONVGeometryDESegmentation* fCurrentSegmentation;///< current DE segmentation
    
-    const AliMUONGeometryModuleTransformer*  fkModuleTransformer; // associated geometry transformer
-    AliMUONGeometryStore*        fDESegmentations;// DE segmentations
-    AliMUONGeometryStore*        fDENames;        // DE names
+    const AliMUONGeometryModuleTransformer*  fkModuleTransformer; ///< associated geometry transformer
+    AliMUONGeometryStore*        fDESegmentations;///< DE segmentations
+    AliMUONGeometryStore*        fDENames;        ///< DE names
     
  
    ClassDef(AliMUONGeometrySegmentation,3) // Geometry segmentation
index c461789..aadab58 100644 (file)
@@ -47,14 +47,14 @@ class AliMUONGeometryStore : public TObject
   
   private:
     // static data members
-    static const Int_t fgkInitSize;    // Initial size of array of objects
-    static const Int_t fgkCoefficient; // Coefficient used in DE Id <-> Module Id
+    static const Int_t fgkInitSize;    ///< Initial size of array of objects
+    static const Int_t fgkCoefficient; ///< Coefficient used in DE Id <-> Module Id
 
     // methods
     Int_t GetDEIndex(Int_t detElemId) const;
 
     // data members
-    TObjArray  fObjects; // The array of detection elements
+    TObjArray  fObjects; ///< The array of detection elements
 
   ClassDef(AliMUONGeometryStore,1) // MUON geometry store
 };
index 3733b4b..712ae1c 100644 (file)
@@ -132,8 +132,8 @@ class AliMUONGeometryTransformer : public TObject
     void    WriteDetElemTransforms(ofstream& out) const;
 
     // data members
-    TObjArray*     fModuleTransformers; // arryy of module transformers
-    TClonesArray*  fMisAlignArray;      // array of misalignment data
+    TObjArray*     fModuleTransformers; ///< array of module transformers
+    TClonesArray*  fMisAlignArray;      ///< array of misalignment data
 
   ClassDef(AliMUONGeometryTransformer,2)  // Geometry parametrisation
 };
index b91fd79..12ab781 100644 (file)
@@ -37,8 +37,8 @@ class AliMUONGlobalTriggerBoard : public AliMUONTriggerBoard
       
    private:
 
-      UShort_t fRegionalResponse[16]; // REGIONAL BOARD RESPONSES
-      UShort_t fMask[16];             // MASK
+      UShort_t fRegionalResponse[16]; ///< REGIONAL BOARD RESPONSES
+      UShort_t fMask[16];             ///< MASK
 
    ClassDef(AliMUONGlobalTriggerBoard,1) 
 };
index 9ea6676..07684b3 100644 (file)
@@ -68,29 +68,29 @@ class AliMUONHitForRec : public TObject {
 
 
  private:
-  Double_t fBendingCoor; // coordinate (cm) in bending plane
-  Double_t fNonBendingCoor; // coordinate (cm) in non bending plane
-  Double_t fZ; // Z coordinate (cm)
-  Double_t fBendingReso2; // resolution**2 (cm**2) on coordinate in bending plane
-  Double_t fNonBendingReso2; // resolution**2 (cm**2) on coordinate in non bending plane
+  Double_t fBendingCoor; ///< coordinate (cm) in bending plane
+  Double_t fNonBendingCoor; ///< coordinate (cm) in non bending plane
+  Double_t fZ; ///< Z coordinate (cm)
+  Double_t fBendingReso2; ///< resolution**2 (cm**2) on coordinate in bending plane
+  Double_t fNonBendingReso2; ///< resolution**2 (cm**2) on coordinate in non bending plane
 
   // links back to original hit for various checks
   // ideal would be real link to "hit" or "reconstructed hit"
   // if everything would be in memory ????
-  Int_t fChamberNumber; // chamber number (0...)
-  Int_t fDetElemId; // detection element Id   
-  Int_t fHitNumber; // hit number (0...): RawCluster in "chamber" event of TR or track ref. hit in "track" event of TTR
-  Int_t fTTRTrack; // track number (0...) in TTR
-  Int_t fTrackRefSignal; // Track ref. signal (1) or background (0)
+  Int_t fChamberNumber; ///< chamber number (0...)
+  Int_t fDetElemId; ///< detection element Id   
+  Int_t fHitNumber; ///< hit number (0...): RawCluster in "chamber" event of TR or track ref. hit in "track" event of TTR
+  Int_t fTTRTrack; ///< track number (0...) in TTR
+  Int_t fTrackRefSignal; ///< Track ref. signal (1) or background (0)
 
   // links forward to the segment(s) if HitForRec in first chamber of a station
-  Int_t fIndexOfFirstSegment; //! index of first Segment
-  Int_t fNSegments; //! number of Segments
+  Int_t fIndexOfFirstSegment; //!<  index of first Segment
+  Int_t fNSegments; //!<  number of Segments
 
   // links forward to reconstructed track hits
-  AliMUONTrackHit *fFirstTrackHitPtr ; //! pointer to first TrackHit made with HitForRec
-  AliMUONTrackHit *fLastTrackHitPtr ; //! pointer to last TrackHit made with HitForRec
-  Int_t fNTrackHits; //! number of TrackHit's made with HitForRec
+  AliMUONTrackHit *fFirstTrackHitPtr ; //!<  pointer to first TrackHit made with HitForRec
+  AliMUONTrackHit *fLastTrackHitPtr ; //!<  pointer to last TrackHit made with HitForRec
+  Int_t fNTrackHits; //!<  number of TrackHit's made with HitForRec
   
   ClassDef(AliMUONHitForRec, 2) // Hit for reconstruction in ALICE dimuon spectrometer
     };
index 0515f4c..64f4be1 100644 (file)
@@ -79,32 +79,32 @@ public:
  private:
   
    // local info
-   UInt_t    fData[5];  // local data
+   UInt_t    fData[5];  ///< local data
    
    // local card scalers   
-   UInt_t     fL0;        // local L0
-   UInt_t     fHold;      // local hold (dead time)
-   UInt_t     fClk;       // local clock
+   UInt_t     fL0;        ///< local L0
+   UInt_t     fHold;      ///< local hold (dead time)
+   UInt_t     fClk;       ///< local clock
 
-   UInt_t     fLPtNTrig;  // local low Pt no trigger
-   UInt_t     fHPtNTrig;  // local high Pt no trigger
+   UInt_t     fLPtNTrig;  ///< local low Pt no trigger
+   UInt_t     fHPtNTrig;  ///< local high Pt no trigger
 
-   UInt_t     fLPtRTrig;  // local low Pt right trigger
-   UInt_t     fHPtRTrig;  // local high Pt right trigger
+   UInt_t     fLPtRTrig;  ///< local low Pt right trigger
+   UInt_t     fHPtRTrig;  ///< local high Pt right trigger
 
-   UInt_t     fLPtLTrig;  // local low Pt left trigger
-   UInt_t     fHPtLTrig;  // local high Pt left trigger
+   UInt_t     fLPtLTrig;  ///< local low Pt left trigger
+   UInt_t     fHPtLTrig;  ///< local high Pt left trigger
 
-   UInt_t     fLPtSTrig;  // local low Pt straight trigger
-   UInt_t     fHPtSTrig;  // local high Pt straight trigger
+   UInt_t     fLPtSTrig;  ///< local low Pt straight trigger
+   UInt_t     fHPtSTrig;  ///< local high Pt straight trigger
 
-   UInt_t     fScaler[8*4];   // local data
-   UInt_t     fEOS;           // contains switches conf. & flag for reading X (0) or Y (1) in fScaler
-   UInt_t     fReset;         // reset signal
+   UInt_t     fScaler[8*4];   ///< local data
+   UInt_t     fEOS;           ///< contains switches conf. & flag for reading X (0) or Y (1) in fScaler
+   UInt_t     fReset;         ///< reset signal
 
-   static const Int_t  fgkLength;       // local info length in word
-   static const Int_t  fgkScalerLength; // scaler length in word
-   static const UInt_t fgkEndOfLocal;   // end of local info word
+   static const Int_t  fgkLength;       ///< local info length in word
+   static const Int_t  fgkScalerLength; ///< scaler length in word
+   static const UInt_t fgkEndOfLocal;   ///< end of local info word
 
    ClassDef(AliMUONLocalStruct,3)
 };
index 8efecbe..d598ba2 100644 (file)
@@ -127,35 +127,35 @@ class AliMUONLocalTriggerBoard : public AliMUONTriggerBoard
 
    private:
 
-      Int_t    fNumber;           // Board number
+      Int_t    fNumber;           ///< Board number
 
-      TString  fCrate;            // Crate name
+      TString  fCrate;            ///< Crate name
 
-      UShort_t fSwitch[10];       // Switch
-      UShort_t fXY[2][4];         // Bit pattern
-      UShort_t fXYU[2][4];        // Bit pattern UP
-      UShort_t fXYD[2][4];        // Bit pattern DOWN
-      UShort_t fMask[2][4];       // Mask
+      UShort_t fSwitch[10];       ///< Switch
+      UShort_t fXY[2][4];         ///< Bit pattern
+      UShort_t fXYU[2][4];        ///< Bit pattern UP
+      UShort_t fXYD[2][4];        ///< Bit pattern DOWN
+      UShort_t fMask[2][4];       ///< Mask
 
-      Bool_t   fTC;               // Transverse connector
+      Bool_t   fTC;               ///< Transverse connector
 
-      Int_t    fStripX11;         // MT1 X position of the valid road 
+      Int_t    fStripX11;         ///< MT1 X position of the valid road 
 
-      Int_t    fStripY11;         // MT1 Y position of the valid road
+      Int_t    fStripY11;         ///< MT1 Y position of the valid road
 
-      Int_t    fDev;              // Deviation in [0;+30]
+      Int_t    fDev;              ///< Deviation in [0;+30]
 
-      Int_t    fLutLpt[2];        // Low Pt cuts estimated from LUT
-      Int_t    fLutHpt[2];        // High Pt cuts estimated from LUT
-      Int_t    fLutApt[2];        // All Pt cuts estimated from LUT
+      Int_t    fLutLpt[2];        ///< Low Pt cuts estimated from LUT
+      Int_t    fLutHpt[2];        ///< High Pt cuts estimated from LUT
+      Int_t    fLutApt[2];        ///< All Pt cuts estimated from LUT
 
 //    Outputs of the local logic
-      Int_t    fOutput;           // Board has triggered
-      Int_t    fMinDevStrip[5];   // X (from algo)
-      Int_t    fMinDev[5];        // Dev (from algo)
-      Int_t    fCoordY[5];        // Y (from algo)
+      Int_t    fOutput;           ///< Board has triggered
+      Int_t    fMinDevStrip[5];   ///< X (from algo)
+      Int_t    fMinDev[5];        ///< Dev (from algo)
+      Int_t    fCoordY[5];        ///< Y (from algo)
 
-      AliMUONTriggerLut *fLUT;    //! Pointer to trigger LUT, that we do not own.
+      AliMUONTriggerLut *fLUT;    //!< Pointer to trigger LUT, that we do not own.
       
       ClassDef(AliMUONLocalTriggerBoard,1) 
 };
index e21f10d..9ce458b 100644 (file)
@@ -41,10 +41,10 @@ class AliMUONPixel : public TObject {
 
  private:
  
-  Double_t fCharge; // ! pixel charge
-  Double_t fSize[2]; // ! pixel size
-  Double_t fXY[2]; // ! pixel coordinates
-  Int_t fFlag; // ! pixel flag
+  Double_t fCharge; //!< pixel charge
+  Double_t fSize[2]; //!< pixel size
+  Double_t fXY[2]; //!< pixel coordinates
+  Int_t fFlag; //!< pixel flag
 
   // Functions
 
index 2333970..9ee5432 100644 (file)
@@ -61,29 +61,29 @@ class AliMUONRawStreamTracker: public TObject {
 
   protected :
 
-    AliRawReader*    fRawReader;    // object for reading the raw data
+    AliRawReader*    fRawReader;    ///< object for reading the raw data
  
-    Int_t  fDDL;          // number of DDL
-    Int_t  fBusPatchId;   // entry of buspatch structure
-    Int_t  fDspId;        // entry of Dsp header
-    Int_t  fBlkId;        // entry of Block header
+    Int_t  fDDL;          ///< number of DDL
+    Int_t  fBusPatchId;   ///< entry of buspatch structure
+    Int_t  fDspId;        ///< entry of Dsp header
+    Int_t  fBlkId;        ///< entry of Block header
 
-    Bool_t fNextDDL;      // flag for next DDL to be read
+    Bool_t fNextDDL;      ///< flag for next DDL to be read
 
-    Int_t fMaxDDL;        // maximum number of DDL in DATE file
-    Int_t fMaxBlock;      // maximum number of block per DDL in DATE file
-    Int_t fMaxDsp;        // maximum number of Dsp per block in DATE file
-    Int_t fMaxBus;        // maximum number of Buspatch per Dsp in DATE file
+    Int_t fMaxDDL;        ///< maximum number of DDL in DATE file
+    Int_t fMaxBlock;      ///< maximum number of block per DDL in DATE file
+    Int_t fMaxDsp;        ///< maximum number of Dsp per block in DATE file
+    Int_t fMaxBus;        ///< maximum number of Buspatch per Dsp in DATE file
 
 
-    AliMpBusPatch* fBusPatchManager; //! buspatch versus DE's & DDL
+    AliMpBusPatch* fBusPatchManager; //!< buspatch versus DE's & DDL
 
-    AliMUONDDLTracker*      fDDLTracker;      //! pointer for buspatch structure
-    AliMUONBusStruct*       fBusStruct;       //! pointer for local structure
-    AliMUONBlockHeader*     fBlockHeader;     //! pointer for block structure 
-    AliMUONDspHeader*       fDspHeader;       //! pointer for dsp structure 
+    AliMUONDDLTracker*      fDDLTracker;      //!< pointer for buspatch structure
+    AliMUONBusStruct*       fBusStruct;       //!< pointer for local structure
+    AliMUONBlockHeader*     fBlockHeader;     //!< pointer for block structure 
+    AliMUONDspHeader*       fDspHeader;       //!< pointer for dsp structure 
 
-    AliMUONBusStruct*       fBusStructPtr;       //! pointer for local structure
+    AliMUONBusStruct*       fBusStructPtr;    //!< pointer for local structure
 
     ClassDef(AliMUONRawStreamTracker, 1)    // base class for reading MUON raw digits
 };
index 0cc469d..30c307f 100644 (file)
@@ -55,19 +55,19 @@ class AliMUONRawStreamTrigger: public TObject {
 
   protected :
 
-    AliRawReader*    fRawReader;    // object for reading the raw data
+    AliRawReader*    fRawReader;    ///< object for reading the raw data
  
-    Int_t  fDDL;          // number of DDL
-    Int_t  fSubEntries;   // entries of buspatch structure
-    Bool_t fNextDDL;      // flag for next DDL to be read
+    Int_t  fDDL;          ///< number of DDL
+    Int_t  fSubEntries;   ///< entries of buspatch structure
+    Bool_t fNextDDL;      ///< flag for next DDL to be read
 
-    Int_t fMaxDDL;        // maximum number of DDL in DATE file
-    Int_t fMaxReg;        // maximum number of regional cards in DATE file
-    Int_t fMaxLoc;        // maximum number of local cards in DATE file
+    Int_t fMaxDDL;        ///< maximum number of DDL in DATE file
+    Int_t fMaxReg;        ///< maximum number of regional cards in DATE file
+    Int_t fMaxLoc;        ///< maximum number of local cards in DATE file
 
-    AliMUONDDLTrigger*       fDDLTrigger;   //! pointer for DDL structure
-    AliMUONRegHeader*        fRegHeader;    //! pointer for regional structure
-    AliMUONLocalStruct*      fLocalStruct;  //! pointer to local structure
+    AliMUONDDLTrigger*       fDDLTrigger;   //!< pointer for DDL structure
+    AliMUONRegHeader*        fRegHeader;    //!< pointer for regional structure
+    AliMUONLocalStruct*      fLocalStruct;  //!< pointer to local structure
 
     ClassDef(AliMUONRawStreamTrigger, 2)    // base class for reading MUON trigger rawdata
 };
index b60ff8b..426e90b 100644 (file)
@@ -62,36 +62,36 @@ private:
 
 private:
 
-  AliMUONData*  fMUONData;           //! Data container for MUON subsystem 
+  AliMUONData*  fMUONData;           //!< Data container for MUON subsystem 
  
-  FILE*         fFile[2];            //! DDL binary file pointer one per 1/2 chamber
+  FILE*         fFile[2];            //!< DDL binary file pointer one per 1/2 chamber
 
-  TClonesArray* fBusArray;           //! array to sub event tracker
+  TClonesArray* fBusArray;           //!< array to sub event tracker
    
-  AliMUONBlockHeader* fBlockHeader;  //! DDL block header class pointers
-  AliMUONDspHeader*   fDspHeader;    //! DDL Dsp header class pointers
-  AliMUONBusStruct*   fBusStruct;    //! DDL bus patch structure class pointers
-  AliMUONDarcHeader*  fDarcHeader;   //! DDL darc header class pointers
-  AliMUONRegHeader*   fRegHeader;    //! DDL regional header class pointers
-  AliMUONLocalStruct* fLocalStruct;  //! DDL local structure class pointers
+  AliMUONBlockHeader* fBlockHeader;  //!< DDL block header class pointers
+  AliMUONDspHeader*   fDspHeader;    //!< DDL Dsp header class pointers
+  AliMUONBusStruct*   fBusStruct;    //!< DDL bus patch structure class pointers
+  AliMUONDarcHeader*  fDarcHeader;   //!< DDL darc header class pointers
+  AliMUONRegHeader*   fRegHeader;    //!< DDL regional header class pointers
+  AliMUONLocalStruct* fLocalStruct;  //!< DDL local structure class pointers
 
-  AliMpBusPatch* fBusPatchManager;   //! buspatch versus DE's & DDL
+  AliMpBusPatch* fBusPatchManager;   //!< buspatch versus DE's & DDL
 
-  Bool_t fScalerEvent;               // flag to generates scaler event
+  Bool_t fScalerEvent;               ///< flag to generates scaler event
 
-  AliRawDataHeader    fHeader;           // header of DDL
+  AliRawDataHeader    fHeader;           ///< header of DDL
 
-  static Int_t fgManuPerBusSwp1B[12];   //! array containing the first manuId for each buspatch st1, Bending
-  static Int_t fgManuPerBusSwp1NB[12];  //! array containing the first manuId for each buspatch st1, NBending
+  static Int_t fgManuPerBusSwp1B[12];   //!< array containing the first manuId for each buspatch st1, Bending
+  static Int_t fgManuPerBusSwp1NB[12];  //!< array containing the first manuId for each buspatch st1, NBending
 
-  static Int_t fgManuPerBusSwp2B[12];   //! array containing the first manuId for each buspatch st2, Bending
-  static Int_t fgManuPerBusSwp2NB[12];  //! array containing the first manuId for each buspatch st2, NBending
+  static Int_t fgManuPerBusSwp2B[12];   //!< array containing the first manuId for each buspatch st2, Bending
+  static Int_t fgManuPerBusSwp2NB[12];  //!< array containing the first manuId for each buspatch st2, NBending
   
-  TStopwatch fTrackerTimer; //!
-  TStopwatch fTriggerTimer; //!
-  TStopwatch fMappingTimer; //!
+  TStopwatch fTrackerTimer;             //!< 
+  TStopwatch fTriggerTimer;             //!< 
+  TStopwatch fMappingTimer;             //!< 
   
-  AliMpSegFactory* fSegFactory; //!
+  AliMpSegFactory* fSegFactory;         //!< mapping segmentation factory
   
   ClassDef(AliMUONRawWriter,1) // MUON cluster reconstructor in ALICE
 };
index 97a6ea5..fe6e98f 100644 (file)
@@ -49,14 +49,14 @@ class AliMUONRecoTrack : public TObject
     void TrackInfo() const;
 
   private:
-    Int_t       fSign;                  // charge sign
-    Int_t       fFlag;                  //  flag of reconstructed track (0-"good", >0-"bad") 
-    Double_t   fZvr;                   // z of track vertex point
-    Double_t   fChi2r;                 // chi squared for reco. track
+    Int_t       fSign;                  ///< charge sign
+    Int_t       fFlag;                  ///<  flag of reconstructed track (0-"good", >0-"bad") 
+    Double_t   fZvr;                   ///< z of track vertex point
+    Double_t   fChi2r;                 ///< chi squared for reco. track
     Double_t   fPr[3];                 // reconstr. momentum (same as in vertex)
-    Double_t   fPosX[10];              // hit X position in all chambers
-    Double_t   fPosY[10];              // hit Y position in all chambers    
-    Double_t   fPosZ[10];              // hit Z position in all chambers
+    Double_t   fPosX[10];              ///< hit X position in all chambers
+    Double_t   fPosY[10];              ///< hit Y position in all chambers    
+    Double_t   fPosZ[10];              ///< hit Z position in all chambers
 
   ClassDef(AliMUONRecoTrack,1) // A reconstructed muon track
 };
index 320b89a..84a924d 100644 (file)
@@ -50,10 +50,10 @@ private:
     TTask* GetCalibrationTask(AliMUONData* data) const;
 
 private:
-    AliRunLoader* fRunLoader;       //! pointer to runloader
-    AliMUONDigitMaker* fDigitMaker; //! pointer to the digit maker class
+    AliRunLoader* fRunLoader;       //!< pointer to runloader
+    AliMUONDigitMaker* fDigitMaker; //!< pointer to the digit maker class
 
-    mutable AliMUONCalibrationData* fCalibrationData; //! pointer to calibration data
+    mutable AliMUONCalibrationData* fCalibrationData; //!< pointer to calibration data
     
   ClassDef(AliMUONReconstructor, 0)   // class for the MUON reconstruction
 };
index 85f84c6..a1f7d66 100644 (file)
@@ -74,20 +74,20 @@ public:
  private:
    
    // regional header
-   UInt_t    fWord;          // first word
-   UInt_t    fInput[2];      // regional input
+   UInt_t    fWord;          ///< first word
+   UInt_t    fInput[2];      ///< regional input
 
    // regional card scalers   
-   UInt_t     fL0;         // regional L0
-   UInt_t     fClk;        // regional clock
-   UInt_t     fScaler[8];  // regional ouput
-   UInt_t     fHold;       // regional hold (dead time)
+   UInt_t     fL0;         ///< regional L0
+   UInt_t     fClk;        ///< regional clock
+   UInt_t     fScaler[8];  ///< regional ouput
+   UInt_t     fHold;       ///< regional hold (dead time)
 
-   static const Int_t  fgkScalerLength;  // length of regional scaler in word
-   static const Int_t  fgkHeaderLength;  // header length in word
-   static const UInt_t fgkEndOfReg;      // end of regional info word
+   static const Int_t  fgkScalerLength;  ///< length of regional scaler in word
+   static const Int_t  fgkHeaderLength;  ///< header length in word
+   static const UInt_t fgkEndOfReg;      ///< end of regional info word
 
-   TClonesArray* fLocalArray;   // array of local structure
+   TClonesArray* fLocalArray;   ///< array of local structure
 
    ClassDef(AliMUONRegHeader,3)
 };
index 4748038..adbfbd1 100644 (file)
@@ -35,8 +35,8 @@ class AliMUONRegionalTriggerBoard : public AliMUONTriggerBoard
       void Mask(Int_t index, UShort_t mask);
       
    private:
-      UShort_t fLocalResponse[16]; // Local trigger inputs
-      UShort_t fMask[16];          // Entry mask
+      UShort_t fLocalResponse[16]; ///< Local trigger inputs
+      UShort_t fMask[16];          ///< Entry mask
       
       ClassDef(AliMUONRegionalTriggerBoard,1)
 };
index 4f2806a..ca9cf32 100644 (file)
@@ -43,8 +43,8 @@ class AliMUONResponseFactory : public  TNamed {
     void BuildStation6();
     
     // data members    
-    AliMUON*             fMUON;           // MUON detector 
-    AliMUONResponseV0*   fResponse0;      // default response 
+    AliMUON*             fMUON;           ///< MUON detector 
+    AliMUONResponseV0*   fResponse0;      ///< default response 
 
   ClassDef(AliMUONResponseFactory,0)  // MUON Factory for Chambers and Segmentation
 };
index a56db75..4df62ce 100644 (file)
@@ -27,8 +27,8 @@ class AliMUONResponseTrigger : public AliMUONResponse
   virtual void DisIntegrate(const AliMUONHit& hit, TList& digits);
   
  private:
-  static const Float_t fgkTofLimit; // particle above this threshold are discarded
-  ClassDef(AliMUONResponseTrigger,1) // Implementation of RPC response
+  static const Float_t fgkTofLimit;  ///< Particle above this threshold are discarded
+  ClassDef(AliMUONResponseTrigger,1) ///< Implementation of RPC response
     
 };
 #endif
index 39b3056..92e43dd 100644 (file)
@@ -26,10 +26,10 @@ class AliMUONResponseTriggerV1 : public AliMUONResponseTrigger
     virtual Int_t SetGenerCluster();
 
   protected:
-    Float_t fGenerCluster;   // Random number  
-    Float_t fA;              // first parameter  of the cluster-size param
-    Float_t fB;              // second parameter of the cluster-size param
-    Float_t fC;              // third parameter  of the cluster-size param
+    Float_t fGenerCluster;   ///< Random number  
+    Float_t fA;              ///< first parameter  of the cluster-size param
+    Float_t fB;              ///< second parameter of the cluster-size param
+    Float_t fC;              ///< third parameter  of the cluster-size param
 
   private:
     // initialize parameters
index e7af62a..bcb17ab 100644 (file)
@@ -99,17 +99,17 @@ class AliMUONResponseV0 : public AliMUONResponse
     AliMUONResponseV0(const AliMUONResponseV0& rhs);
     AliMUONResponseV0& operator = (const AliMUONResponseV0& rhs);
 
-    Float_t fChargeSlope;              // Slope of the charge distribution
-    Float_t fChargeSpreadX;            // Width of the charge distribution in x
-    Float_t fChargeSpreadY;            // Width of the charge distribution in y
-    Float_t fSigmaIntegration;         // Number of sigma's used for charge distribution
-    Int_t   fMaxAdc;                   // Maximum ADC channel
-    Int_t   fSaturation;               // Pad saturation in ADC channel
-    Int_t   fZeroSuppression;          // Zero suppression threshold
-    Float_t fChargeCorrel;             // amplitude of charge correlation on 2 cathods
-                                       // is RMS of ln(q1/q2)
-    AliMUONMathieson* fMathieson;      // pointer to mathieson fct
-    Float_t fChargeThreshold;          // Charges below this threshold are = 0  
+    Float_t fChargeSlope;              ///< Slope of the charge distribution
+    Float_t fChargeSpreadX;            ///< Width of the charge distribution in x
+    Float_t fChargeSpreadY;            ///< Width of the charge distribution in y
+    Float_t fSigmaIntegration;         ///< Number of sigma's used for charge distribution
+    Int_t   fMaxAdc;                   ///< Maximum ADC channel
+    Int_t   fSaturation;               ///< Pad saturation in ADC channel
+    Int_t   fZeroSuppression;          ///< Zero suppression threshold
+    Float_t fChargeCorrel;             ///< \brief amplitude of charge correlation on 2 cathods
+                                       ///  is RMS of ln(q1/q2)
+    AliMUONMathieson* fMathieson;      ///< pointer to mathieson fct
+    Float_t fChargeThreshold;          ///< Charges below this threshold are = 0  
     
     ClassDef(AliMUONResponseV0,2) // Implementation of detector response
 };
index e0050d8..7e0b472 100644 (file)
@@ -61,26 +61,26 @@ class AliMUONSegment : public TObject
   AliMUONSegment& operator=(const AliMUONSegment& AliMUONSegment); // assignment operator
 
  private:
-  AliMUONHitForRec* fHitForRecPtr1; // pointer to HitForRec in first chamber
-  AliMUONHitForRec* fHitForRecPtr2; // pointer to HitForRec in second chamber
+  AliMUONHitForRec* fHitForRecPtr1; ///< pointer to HitForRec in first chamber
+  AliMUONHitForRec* fHitForRecPtr2; ///< pointer to HitForRec in second chamber
   // Bending plane:
-  Double_t fBendingCoor; // Coordinate in bending plane
-  Double_t fBendingSlope; // Slope in bending plane
+  Double_t fBendingCoor; ///< Coordinate in bending plane
+  Double_t fBendingSlope; ///< Slope in bending plane
   // Covariance in bending plane:
-  Double_t fBendingCoorReso2; // Covariance(coordinate C1 in first chamber)
-  Double_t fBendingSlopeReso2; // Covariance(slope)
-  Double_t fBendingCoorSlopeReso2; // Covariance(C1,slope)
-  Double_t fBendingImpact; // Impact parameter in bending plane
+  Double_t fBendingCoorReso2; ///< Covariance(coordinate C1 in first chamber)
+  Double_t fBendingSlopeReso2; ///< Covariance(slope)
+  Double_t fBendingCoorSlopeReso2; ///< Covariance(C1,slope)
+  Double_t fBendingImpact; ///< Impact parameter in bending plane
   // Non Bending plane:
-  Double_t fNonBendingCoor; // Coordinate in non bending plane
-  Double_t fNonBendingSlope; // Slope in non bending plane
+  Double_t fNonBendingCoor; ///< Coordinate in non bending plane
+  Double_t fNonBendingSlope; ///< Slope in non bending plane
   // Covariance in non bending plane:
-  Double_t fNonBendingCoorReso2; // Covariance(coordinate C1 in first chamber)
-  Double_t fNonBendingSlopeReso2; // Covariance(slope)
-  Double_t fNonBendingCoorSlopeReso2; // Covariance(C1,slope)
-  Double_t fNonBendingImpact; // Impact parameter in non bending plane
-  Double_t fZ;                // Z of the segment
-  Bool_t fInTrack; // TRUE if segment belongs to one track
+  Double_t fNonBendingCoorReso2; ///< Covariance(coordinate C1 in first chamber)
+  Double_t fNonBendingSlopeReso2; ///< Covariance(slope)
+  Double_t fNonBendingCoorSlopeReso2; ///< Covariance(C1,slope)
+  Double_t fNonBendingImpact; ///< Impact parameter in non bending plane
+  Double_t fZ;                ///< Z of the segment
+  Bool_t fInTrack; ///< TRUE if segment belongs to one track
   
   ClassDef(AliMUONSegment, 1) // Segment for reconstruction in ALICE dimuon spectrometer
 };
index dd1e707..551442f 100644 (file)
@@ -85,10 +85,10 @@ class AliMUONSegmentation : public TObject
      
   private:
     // data members
-    TObjArray*  fMpSegmentations;        // array of mapping segmentations
-    TObjArray*  fDESegmentations;        // array of DE segmentations
-    TObjArray*  fModuleSegmentations[2]; // array of module segmentations
-                                         // for two cathods         
+    TObjArray*  fMpSegmentations;        ///< array of mapping segmentations
+    TObjArray*  fDESegmentations;        ///< array of DE segmentations
+    TObjArray*  fModuleSegmentations[2]; ///< \brief array of module segmentations
+                                         /// for two cathods         
   ClassDef(AliMUONSegmentation,2)  // Container class for module segmentations
 };
 
index d8cd284..8b851c5 100644 (file)
@@ -38,9 +38,9 @@ class AliMUONStringIntMap : public TObject
  
   private:
     // data members
-    Int_t      fNofItems;    // number of items
-    TObjArray  fFirstArray;  // first item array
-    TArrayI    fSecondArray; // second item array
+    Int_t      fNofItems;    ///< number of items
+    TObjArray  fFirstArray;  ///< first item array
+    TArrayI    fSecondArray; ///< second item array
  
   ClassDef(AliMUONStringIntMap,1)  // motif map
 };    
index 7a7919f..3e4d772 100644 (file)
@@ -67,9 +67,9 @@ class AliMUONTest : public  TObject
                   Int_t detElemId, Int_t ix, Int_t iy,
                   AliMUONGeometrySegmentation* segmentation);
     // data members
-    const AliMUONGeometryTransformer* fkTransformer; // Geometry parametrisation
-    AliMUONSegmentation*  fSegmentation;  // Segmentation
-    TCanvas*              fCanvas;        // The canvas for drawing                                   
+    const AliMUONGeometryTransformer* fkTransformer; ///< Geometry parametrisation
+    AliMUONSegmentation*  fSegmentation;  ///< Segmentation
+    TCanvas*              fCanvas;        ///< The canvas for drawing                                 
 
     ClassDef(AliMUONTest,0)  // MUON class for tests
 };
index dc6878a..4177be1 100644 (file)
@@ -83,21 +83,21 @@ class AliMUONTrack : public TObject
 
  protected:
  private:
-  static TVirtualFitter* fgFitter; //!                  Pointer to track fitter
-  AliMUONTrackReconstructor* fTrackReconstructor; //!   Pointer to TrackReconstructor
-  AliMUONTrackParam fTrackParamAtVertex; // Track parameters at vertex
-  TClonesArray *fTrackParamAtHit; // Track parameters at hit
-  TClonesArray *fHitForRecAtHit; // Cluster parameters at hit
-  TObjArray *fTrackHitsPtr; //!  Pointer to array of pointers to TrackHit's
-  Int_t fNTrackHits; // Number of TrackHit's
-  Int_t fFitMCS; // 0(1) for fit without(with) multiple Coulomb scattering
-  Int_t fFitNParam; // 3(5) for fit with 3(5) parameters
-  Int_t fFitStart; // 0 or 1 for fit starting from parameters at vertex (0) or at first TrackHit(1)
-  Double_t fFitFMin; // minimum value of the function minimized by the fit
-  Bool_t fMatchTrigger; // 1 if track matches with trigger track, 0 if not
-  Double_t fChi2MatchTrigger; // chi2 of trigger/track matching 
+  static TVirtualFitter* fgFitter; //!< Pointer to track fitter
+  AliMUONTrackReconstructor* fTrackReconstructor; //!< Pointer to TrackReconstructor
+  AliMUONTrackParam fTrackParamAtVertex; ///< Track parameters at vertex
+  TClonesArray *fTrackParamAtHit; ///< Track parameters at hit
+  TClonesArray *fHitForRecAtHit; ///< Cluster parameters at hit
+  TObjArray *fTrackHitsPtr; //!<  Pointer to array of pointers to TrackHit's
+  Int_t fNTrackHits; ///< Number of TrackHit's
+  Int_t fFitMCS; ///< 0(1) for fit without(with) multiple Coulomb scattering
+  Int_t fFitNParam; ///< 3(5) for fit with 3(5) parameters
+  Int_t fFitStart; ///< 0 or 1 for fit starting from parameters at vertex (0) or at first TrackHit(1)
+  Double_t fFitFMin; ///< minimum value of the function minimized by the fit
+  Bool_t fMatchTrigger; ///< 1 if track matches with trigger track, 0 if not
+  Double_t fChi2MatchTrigger; ///< chi2 of trigger/track matching 
  
-  Int_t fTrackID; // track ID = track number in TrackRefs
+  Int_t fTrackID; ///< track ID = track number in TrackRefs
 
   ClassDef(AliMUONTrack, 2) // Reconstructed track in ALICE dimuon spectrometer
     };
index d2f4d56..c646716 100644 (file)
@@ -44,10 +44,10 @@ class AliMUONTrackHit : public TObject
   void SetNextTrackHitWithSameHitForRec(AliMUONTrackHit *Next) {fNextTrackHitWithSameHitForRec = Next;}
   void SetPrevTrackHitWithSameHitForRec(AliMUONTrackHit *Prev) {fPrevTrackHitWithSameHitForRec = Prev;}
 
-  AliMUONTrackParam fTrackParam; // Track parameters
-  AliMUONHitForRec *fHitForRecPtr; // Pointer to HitForRec
-  AliMUONTrackHit *fNextTrackHitWithSameHitForRec; // Pointer to next track hit with same HitForRec
-  AliMUONTrackHit *fPrevTrackHitWithSameHitForRec; // Pointer to previous track hit with same HitForRec
+  AliMUONTrackParam fTrackParam; ///< Track parameters
+  AliMUONHitForRec *fHitForRecPtr; ///< Pointer to HitForRec
+  AliMUONTrackHit *fNextTrackHitWithSameHitForRec; ///< Pointer to next track hit with same HitForRec
+  AliMUONTrackHit *fPrevTrackHitWithSameHitForRec; ///< Pointer to previous track hit with same HitForRec
 
   ClassDef(AliMUONTrackHit, 1) // Reconstructed track hit in ALICE dimuon spectrometer
     };
index fef0088..7616184 100644 (file)
@@ -80,42 +80,42 @@ class AliMUONTrackK : public AliMUONTrack {
 
  private:
  
-  static Int_t fgDebug; // debug level
-  static Int_t fgNOfPoints; // number of points in event
-  //static AliMUON *fgMUON; // pointer to MUON module  
-  static AliMUONTrackReconstructor *fgTrackReconstructor; // pointer to event reconstructor
-  static TClonesArray *fgHitForRec; // pointer to hits
-  static AliMUONEventRecoCombi *fgCombi; // pointer to combined cluster/track finder
-
-  AliMUONSegment *fStartSegment; // seed segment  
-  Double_t fPosition; // Z-coordinate of track
-  Double_t fPositionNew; //! Z-coordinate of track
-  Double_t fChi2; // Chi2 of track
-  TObjArray *fTrackHits; // pointer to hits on track
-  Int_t fNmbTrackHits; // number of points on track
-  Int_t fTrackDir; // track direction (+(-) towards high (low) z)
-  Bool_t fBPFlag; // backpropagation flag (TRUE if backpropagation)
-  Int_t fRecover; // recover flag (!=0 if recovery procedure was applied)
-  AliMUONHitForRec *fSkipHit; // hit to skip during recovery procedure
-
-  TMatrixD *fTrackPar; // track parameters
-  TMatrixD *fTrackParNew; //! track parameters
-  TMatrixD *fCovariance; // covariance matrix
-  TMatrixD *fWeight; //! weight matrix (inverse of covariance)
+  static Int_t fgDebug; ///< debug level
+  static Int_t fgNOfPoints; ///< number of points in event
+  //static AliMUON *fgMUON; ///< pointer to MUON module  
+  static AliMUONTrackReconstructor *fgTrackReconstructor; ///< pointer to event reconstructor
+  static TClonesArray *fgHitForRec; ///< pointer to hits
+  static AliMUONEventRecoCombi *fgCombi; ///< pointer to combined cluster/track finder
+
+  AliMUONSegment *fStartSegment; ///< seed segment  
+  Double_t fPosition; ///< Z-coordinate of track
+  Double_t fPositionNew; //!< Z-coordinate of track
+  Double_t fChi2; ///< Chi2 of track
+  TObjArray *fTrackHits; ///< pointer to hits on track
+  Int_t fNmbTrackHits; ///< number of points on track
+  Int_t fTrackDir; ///< track direction (+(-) towards high (low) z)
+  Bool_t fBPFlag; ///< backpropagation flag (TRUE if backpropagation)
+  Int_t fRecover; ///< recover flag (!=0 if recovery procedure was applied)
+  AliMUONHitForRec *fSkipHit; ///< hit to skip during recovery procedure
+
+  TMatrixD *fTrackPar; ///< track parameters
+  TMatrixD *fTrackParNew; //!< track parameters
+  TMatrixD *fCovariance; ///< covariance matrix
+  TMatrixD *fWeight; //!< weight matrix (inverse of covariance)
 
   // For smoother
-  TObjArray *fParExtrap; //! extrapolated track parameters
-  TObjArray *fParFilter; //! filtered track parameters
-  TObjArray *fParSmooth; //! smoothed track parameters
+  TObjArray *fParExtrap; //!< extrapolated track parameters
+  TObjArray *fParFilter; //!< filtered track parameters
+  TObjArray *fParSmooth; //!< smoothed track parameters
 
-  TObjArray *fCovExtrap; //! extrapolated covariance matrices
-  TObjArray *fCovFilter; //! filtered covariance matrices
+  TObjArray *fCovExtrap; //!< extrapolated covariance matrices
+  TObjArray *fCovFilter; //!< filtered covariance matrices
 
-  TObjArray *fJacob; //! Jacobian matrices
-  Int_t fNSteps; //!
-  TArrayD *fSteps; //!
-  TArrayD *fChi2Array; //!
-  TArrayD *fChi2Smooth; //!
+  TObjArray *fJacob; //!< Jacobian matrices
+  Int_t fNSteps; //!< 
+  TArrayD *fSteps; //!< 
+  TArrayD *fChi2Array; //!< 
+  TArrayD *fChi2Smooth; //!< 
 
   // Functions
 
@@ -142,11 +142,11 @@ class AliMUONTrackK : public AliMUONTrack {
 
   private:
    // Some constants
-   static const Int_t fgkSize; // number of track parameters
-   static const Int_t fgkNSigma; //4; // acceptance window width in sigmas
-   static const Double_t fgkChi2max; //25; // chi2 cut in smoother for outlier detection
-   static const Int_t fgkTriesMax; // max number of attempts to find exact position during tracking
-   static const Double_t fgkEpsilon; // tracking precision (cm)
+   static const Int_t fgkSize; ///< number of track parameters
+   static const Int_t fgkNSigma; ///< 4; acceptance window width in sigmas
+   static const Double_t fgkChi2max; ///< 25; chi2 cut in smoother for outlier detection
+   static const Int_t fgkTriesMax; ///< max number of attempts to find exact position during tracking
+   static const Double_t fgkEpsilon; ///< tracking precision (cm)
 
   ClassDef(AliMUONTrackK,0) // Kalman track in MUON arm of ALICE
     };
index 3fadeaa..3275db1 100644 (file)
@@ -59,12 +59,12 @@ class AliMUONTrackParam : public TObject
                               Double_t* vect, Double_t* vout) const;
  protected:
  private:
-  Double_t fInverseBendingMomentum; // Inverse bending momentum (GeV/c ** -1) times the charge (assumed forward motion)
-  Double_t fBendingSlope; // Bending slope (cm ** -1)
-  Double_t fNonBendingSlope; // Non bending slope (cm ** -1)
-  Double_t fZ; // Z coordinate (cm)
-  Double_t fBendingCoor; // bending coordinate (cm)
-  Double_t fNonBendingCoor; // non bending coordinate (cm)
+  Double_t fInverseBendingMomentum; ///< Inverse bending momentum (GeV/c ** -1) times the charge (assumed forward motion)
+  Double_t fBendingSlope; ///< Bending slope (cm ** -1)
+  Double_t fNonBendingSlope; ///< Non bending slope (cm ** -1)
+  Double_t fZ; ///< Z coordinate (cm)
+  Double_t fBendingCoor; ///< bending coordinate (cm)
+  Double_t fNonBendingCoor; ///< non bending coordinate (cm)
 
   void SetGeant3Parameters(Double_t *VGeant3, Double_t ForwardBackward);
   void GetFromGeant3Parameters(Double_t *VGeant3, Double_t Charge);
index ba29a6a..b041f06 100644 (file)
@@ -100,86 +100,86 @@ class AliMUONTrackReconstructor : public TObject {
  private:
 
   // Constants which should be elsewhere ????
-  static const Int_t fgkMaxMuonTrackingChambers = 10; // Max number of Muon tracking chambers
-  static const Int_t fgkMaxMuonTrackingStations = 5; // Max number of Muon tracking stations
+  static const Int_t fgkMaxMuonTrackingChambers = 10; ///< Max number of Muon tracking chambers
+  static const Int_t fgkMaxMuonTrackingStations = 5; ///< Max number of Muon tracking stations
 
   // Defaults parameters for reconstruction
-  static const Double_t fgkDefaultMinBendingMomentum; // default min. bending momentum for reconstruction
-  static const Double_t fgkDefaultMaxBendingMomentum; // default max. bending momentum for reconstruction
-  static const Double_t fgkDefaultMaxChi2; // default max. track chi2 for reconstruction
-  static const Double_t fgkDefaultMaxSigma2Distance; // default square of max. distance for window size 
-  static const Double_t fgkDefaultBendingResolution; // default bending coordinate resolution for reconstruction 
-  static const Double_t fgkDefaultNonBendingResolution; // default non bending coordinate resolution for reconstruction
-  static const Double_t fgkDefaultChamberThicknessInX0; // default chamber thickness in X0 for reconstruction
+  static const Double_t fgkDefaultMinBendingMomentum; ///< default min. bending momentum for reconstruction
+  static const Double_t fgkDefaultMaxBendingMomentum; ///< default max. bending momentum for reconstruction
+  static const Double_t fgkDefaultMaxChi2; ///< default max. track chi2 for reconstruction
+  static const Double_t fgkDefaultMaxSigma2Distance; ///< default square of max. distance for window size 
+  static const Double_t fgkDefaultBendingResolution; ///< default bending coordinate resolution for reconstruction 
+  static const Double_t fgkDefaultNonBendingResolution; ///< default non bending coordinate resolution for reconstruction
+  static const Double_t fgkDefaultChamberThicknessInX0; ///< default chamber thickness in X0 for reconstruction
   // Simple magnetic field:
   // Value taken from macro MUONtracking.C: 0.7 T, hence 7 kG
   // Length and Position from reco_muon.F, with opposite sign:
   // Length = ZMAGEND-ZCOIL
   // Position = (ZMAGEND+ZCOIL)/2
   // to be ajusted differently from real magnetic field ????
-  static const Double_t fgkDefaultSimpleBValue; // default value of magnetic field (dipole)
-  static const Double_t fgkDefaultSimpleBLength; // default length of magnetic field (dipole)
-  static const Double_t fgkDefaultSimpleBPosition; // default position of magnetic field (dipole)
-  static const Int_t fgkDefaultRecTrackRefHits; // default flag for reconstrution track ref. hits or Clusters
-  static const Double_t fgkDefaultEfficiency; // default chamber efficiency for track ref. hits recontruction
+  static const Double_t fgkDefaultSimpleBValue; ///< default value of magnetic field (dipole)
+  static const Double_t fgkDefaultSimpleBLength; ///< default length of magnetic field (dipole)
+  static const Double_t fgkDefaultSimpleBPosition; ///< default position of magnetic field (dipole)
+  static const Int_t fgkDefaultRecTrackRefHits; ///< default flag for reconstrution track ref. hits or Clusters
+  static const Double_t fgkDefaultEfficiency; ///< default chamber efficiency for track ref. hits recontruction
 
 
-  Int_t fTrackMethod; // AZ - tracking method
+  Int_t fTrackMethod; ///< AZ - tracking method
 
   // Parameters for track reconstruction
-  Double_t fMinBendingMomentum; // minimum value (GeV/c) of momentum in bending plane
+  Double_t fMinBendingMomentum; ///< minimum value (GeV/c) of momentum in bending plane
   // Parameters for track reconstruction
-  Double_t fMaxBendingMomentum; // maximum value (GeV/c) of momentum in bending plane
-  Double_t fMaxChi2; // maximum Chi2 per degree of Freedom
-  Double_t fMaxSigma2Distance; // maximum square distance in units of the variance (maximum chi2)
-  Double_t fRMin[fgkMaxMuonTrackingChambers]; // minimum radius (cm)
-  Double_t fRMax[fgkMaxMuonTrackingChambers]; // maximum radius (cm)
-  Double_t fSegmentMaxDistBending[fgkMaxMuonTrackingStations]; // maximum distance (cm) for segments in bending plane
-  Double_t fSegmentMaxDistNonBending[fgkMaxMuonTrackingStations]; // maximum distance (cm) for segments in non bending plane
-  Double_t fBendingResolution; // chamber resolution (cm) in bending plane
-  Double_t fNonBendingResolution; // chamber resolution (cm) in non bending plane
-  Double_t fChamberThicknessInX0; // chamber thickness in number of radiation lengths
+  Double_t fMaxBendingMomentum; ///< maximum value (GeV/c) of momentum in bending plane
+  Double_t fMaxChi2; ///< maximum Chi2 per degree of Freedom
+  Double_t fMaxSigma2Distance; ///< maximum square distance in units of the variance (maximum chi2)
+  Double_t fRMin[fgkMaxMuonTrackingChambers]; ///< minimum radius (cm)
+  Double_t fRMax[fgkMaxMuonTrackingChambers]; ///< maximum radius (cm)
+  Double_t fSegmentMaxDistBending[fgkMaxMuonTrackingStations]; ///< maximum distance (cm) for segments in bending plane
+  Double_t fSegmentMaxDistNonBending[fgkMaxMuonTrackingStations]; ///< maximum distance (cm) for segments in non bending plane
+  Double_t fBendingResolution; ///< chamber resolution (cm) in bending plane
+  Double_t fNonBendingResolution; ///< chamber resolution (cm) in non bending plane
+  Double_t fChamberThicknessInX0; ///< chamber thickness in number of radiation lengths
                                   // how to take it from simulation ????
-  Double_t fSimpleBValue; // simple magnetic field: value (kG)
-  Double_t fSimpleBLength; // simple magnetic field: length (cm)
-  Double_t fSimpleBPosition; // simple magnetic field: Z central position (cm)
-  Int_t fRecTrackRefHits; // reconstruction from raw clusters (0) or from track ref. hits (1)
-  Double_t fEfficiency; // chamber efficiency (used for track ref. hits only)
+  Double_t fSimpleBValue; ///< simple magnetic field: value (kG)
+  Double_t fSimpleBLength; ///< simple magnetic field: length (cm)
+  Double_t fSimpleBPosition; ///< simple magnetic field: Z central position (cm)
+  Int_t fRecTrackRefHits; ///< reconstruction from raw clusters (0) or from track ref. hits (1)
+  Double_t fEfficiency; ///< chamber efficiency (used for track ref. hits only)
 
   // Parameters for track ref. background events
   // should be in AliMUON class ????
-  TFile *fBkgTrackRefFile; // pointer to file
-  TTree *fBkgTrackRefTK; // pointer to tree TK
-  TClonesArray *fBkgTrackRefParticles;   // pointer to list of particles in tree TK
-  TTree *fBkgTrackRefTTR; // pointer to tree TTR
-  Int_t fBkgTrackRefEventNumber; // event number
+  TFile *fBkgTrackRefFile; ///< pointer to file
+  TTree *fBkgTrackRefTK; ///< pointer to tree TK
+  TClonesArray *fBkgTrackRefParticles;   ///< pointer to list of particles in tree TK
+  TTree *fBkgTrackRefTTR; ///< pointer to tree TTR
+  Int_t fBkgTrackRefEventNumber; ///< event number
   
   // Hits for reconstruction (should be in AliMUON ????)
-  TClonesArray *fHitsForRecPtr; // pointer to the array of hits for reconstruction
-  Int_t fNHitsForRec; // number of hits for reconstruction
+  TClonesArray *fHitsForRecPtr; ///< pointer to the array of hits for reconstruction
+  Int_t fNHitsForRec; ///< number of hits for reconstruction
   // Information per chamber (should be in AliMUONChamber ????)
-  Int_t fNHitsForRecPerChamber[fgkMaxMuonTrackingChambers]; // number of HitsForRec
-  Int_t fIndexOfFirstHitForRecPerChamber[fgkMaxMuonTrackingChambers]; // index (0...) of first HitForRec
+  Int_t fNHitsForRecPerChamber[fgkMaxMuonTrackingChambers]; ///< number of HitsForRec
+  Int_t fIndexOfFirstHitForRecPerChamber[fgkMaxMuonTrackingChambers]; ///< index (0...) of first HitForRec
 
   // Segments inside a station
-  TClonesArray *fSegmentsPtr[fgkMaxMuonTrackingStations]; // array of pointers to the segments for each station
-  Int_t fNSegments[fgkMaxMuonTrackingStations]; // number of segments for each station
+  TClonesArray *fSegmentsPtr[fgkMaxMuonTrackingStations]; ///< array of pointers to the segments for each station
+  Int_t fNSegments[fgkMaxMuonTrackingStations]; ///< number of segments for each station
 
   // Reconstructed tracks
-  TClonesArray *fRecTracksPtr; // pointer to array of reconstructed tracks
-  Int_t fNRecTracks; // number of reconstructed tracks
+  TClonesArray *fRecTracksPtr; ///< pointer to array of reconstructed tracks
+  Int_t fNRecTracks; ///< number of reconstructed tracks
 
   // Track hits on reconstructed tracks
-  TClonesArray *fRecTrackHitsPtr; // pointer to array of hits on reconstructed tracks
-  Int_t fNRecTrackHits; // number of hits on reconstructed tracks
+  TClonesArray *fRecTrackHitsPtr; ///< pointer to array of hits on reconstructed tracks
+  Int_t fNRecTrackHits; ///< number of hits on reconstructed tracks
 
   // data container
-  AliMUONData* fMUONData; // Data container for MUON subsystem 
+  AliMUONData* fMUONData; ///< Data container for MUON subsystem 
 
   // alice loader
-  AliLoader* fLoader; // MUON loader to get data
+  AliLoader* fLoader; ///< MUON loader to get data
 
-  Int_t fMuons; // AZ - number of muons within acceptance - just for tests
+  Int_t fMuons; ///< AZ - number of muons within acceptance - just for tests
 
   // Functions
   void ResetHitsForRec(void);
index c209a96..f33fe63 100644 (file)
@@ -8,11 +8,7 @@
 
 /// \ingroup sim
 /// \class AliMUONTrigger
-/// \brief MUON trigger class
-///
-/////////////////////////////////////////////////
-///  MUON Trigger Detector Class               //
-/////////////////////////////////////////////////
+/// \brief MUON trigger detector class
 
 #include "AliTriggerDetector.h"
 
index 67672aa..1e8a6ac 100644 (file)
@@ -37,9 +37,9 @@ class AliMUONTriggerBoard : public TNamed
       
    protected:
 
-      Int_t fSlot;                // SLOT NUMBER IN CRATE
+      Int_t fSlot;                ///< SLOT NUMBER IN CRATE
 
-      UShort_t fResponse;         // RESPONSE
+      UShort_t fResponse;         ///< RESPONSE
 
       void Copy(TObject&) const;
 
index 2a18da2..23eb52b 100644 (file)
@@ -40,11 +40,11 @@ class AliMUONTriggerCrate : public TNamed
 
    private:
 
-      Int_t     fNslots;          // NUMBER OF SLOTS
-      Int_t     fNboards;         // NUMBER OF BOARDS
+      Int_t     fNslots;          ///< NUMBER OF SLOTS
+      Int_t     fNboards;         ///< NUMBER OF BOARDS
 
-      TObjArray *fBoards;         // POINTER TO BOARD OBJECTS
-      TString   fSourceFileName;  // SOURCE FILE
+      TObjArray *fBoards;         ///< POINTER TO BOARD OBJECTS
+      TString   fSourceFileName;  ///< SOURCE FILE
 
    ClassDef(AliMUONTriggerCrate,1)
 };
index 93779c3..dff6d6b 100644 (file)
@@ -77,10 +77,6 @@ class AliMUONTriggerDecision : public TObject
                        Int_t singleUndef[3], Int_t pairUnlike[3], 
                        Int_t pairLike[3]) const;  
 
-
-  ClassDef(AliMUONTriggerDecision,1) // Trigger Decision class
-
-
 protected:
 
   AliMUONTriggerDecision(const AliMUONTriggerDecision& rhs);
@@ -94,53 +90,54 @@ protected:
         );
 
 
-  Int_t fDebug;               // print option     
+  Int_t fDebug;                ///< print option     
 
   // Global Trigger information [0] : Low pt, [1] : High pt, [2] : All pt 
-  Int_t fGlobalSinglePlus[3];  // tot num of single plus
-  Int_t fGlobalSingleMinus[3]; // tot num of single minus
-  Int_t fGlobalSingleUndef[3]; // tot num of single undefined
-  Int_t fGlobalPairUnlike[3];  // tot num of unlike-sign pairs
-  Int_t fGlobalPairLike[3];    // tot num of like-sign pairs
+  Int_t fGlobalSinglePlus[3];  ///< tot num of single plus
+  Int_t fGlobalSingleMinus[3]; ///< tot num of single minus
+  Int_t fGlobalSingleUndef[3]; ///< tot num of single undefined
+  Int_t fGlobalPairUnlike[3];  ///< tot num of unlike-sign pairs
+  Int_t fGlobalPairLike[3];    ///< tot num of like-sign pairs
 
   // Local Trigger information
-  Int_t fTrigger[234];  // fTrigger = 0 : no trigger, 1 : trigger
-  Int_t fStripX11[234];  // X strip in MC11 which triggers
-  Int_t fDev[234];       // deviation which triggers
-  Int_t fStripY11[234];  // Y strip in MC11 which triggers
-  Int_t fLutLpt[234][2]; // Local Trigger info Low pt
-  Int_t fLutHpt[234][2]; // Local Trigger info High pt
-  Int_t fLutApt[234][2]; // Local Trigger info All pt
+  Int_t fTrigger[234];  ///< fTrigger = 0 : no trigger, 1 : trigger
+  Int_t fStripX11[234];  ///< X strip in MC11 which triggers
+  Int_t fDev[234];       ///< deviation which triggers
+  Int_t fStripY11[234];  ///< Y strip in MC11 which triggers
+  Int_t fLutLpt[234][2]; ///< Local Trigger info Low pt
+  Int_t fLutHpt[234][2]; ///< Local Trigger info High pt
+  Int_t fLutApt[234][2]; ///< Local Trigger info All pt
 
   // bit pattern
-  Int_t fXbit11[234][16]; // bit pattern XM11
-  Int_t fXbit12[234][16]; // bit pattern XM12
-  Int_t fXbit21[234][32]; // bit pattern XM21
-  Int_t fXbit22[234][32]; // bit pattern XM22
-  Int_t fYbit11[234][16]; // bit pattern YM11
-  Int_t fYbit12[234][16]; // bit pattern YM12
-  Int_t fYbit21[234][16]; // bit pattern YM21
-  Int_t fYbit22[234][16]; // bit pattern YM22
-
-  Int_t fYbit21U[234][16]; // bit pattern YM21 Up
-  Int_t fYbit22U[234][16]; // bit pattern YM22 Up
-  Int_t fYbit21D[234][16]; // bit pattern YM21 Down
-  Int_t fYbit22D[234][16]; // bit pattern YM22 Down
-
-  TArrayI fDigitNumbers[234];  //! The digit number that fired a circuit.
+  Int_t fXbit11[234][16]; ///< bit pattern XM11
+  Int_t fXbit12[234][16]; ///< bit pattern XM12
+  Int_t fXbit21[234][32]; ///< bit pattern XM21
+  Int_t fXbit22[234][32]; ///< bit pattern XM22
+  Int_t fYbit11[234][16]; ///< bit pattern YM11
+  Int_t fYbit12[234][16]; ///< bit pattern YM12
+  Int_t fYbit21[234][16]; ///< bit pattern YM21
+  Int_t fYbit22[234][16]; ///< bit pattern YM22
+
+  Int_t fYbit21U[234][16]; ///< bit pattern YM21 Up
+  Int_t fYbit22U[234][16]; ///< bit pattern YM22 Up
+  Int_t fYbit21D[234][16]; ///< bit pattern YM21 Down
+  Int_t fYbit22D[234][16]; ///< bit pattern YM22 Down
+
+  TArrayI fDigitNumbers[234];  //!< The digit number that fired a circuit.
   
-  AliLoader*     fLoader;             //! alice loader
-  TObjArray*     fTriggerCircuit;     //! List of Trigger Circuit
-  TObjArray*     fDigits;             // temp array for digits (both cathodes !) for trigger
-  TArrayI*       fDigitIndices;       //! Array of digit index numbers, one for each entry in fDigits.
+  AliLoader*     fLoader;             //!< alice loader
+  TObjArray*     fTriggerCircuit;     //!< List of Trigger Circuit
+  TObjArray*     fDigits;             ///< temp array for digits (both cathodes !) for trigger
+  TArrayI*       fDigitIndices;       //!< Array of digit index numbers, one for each entry in fDigits.
 
-  AliMUONData*   fMUONData;           //! Data container for MUON subsystem 
-  AliMUON*       fMUON;               //! pointer to MUON  
+  AliMUONData*   fMUONData;           //!< Data container for MUON subsystem 
+  AliMUON*       fMUON;               //!< pointer to MUON  
 
   // ???
-  //  TClonesArray* fLocalTriggers;   // Local Triggers
-  // Int_t fNLocalTriggers;          // Number of Local Triggers
+  //  TClonesArray* fLocalTriggers;   ///< Local Triggers
+  // Int_t fNLocalTriggers;           ///< Number of Local Triggers
 
+  ClassDef(AliMUONTriggerDecision,1) // Trigger Decision class
 };
 #endif
 
index 5565c27..fc0858d 100644 (file)
@@ -74,10 +74,6 @@ class AliMUONTriggerDecisionV1 : public TTask
   Int_t ModuleNumber(Int_t idModule) const; 
   static const Int_t fgkCircuitSortedAsBoard[234]; // circuit Id. number
 
-  
-  ClassDef(AliMUONTriggerDecisionV1,1) // Trigger Decision class
-
-
 protected:
 
   AliMUONTriggerDecisionV1(const AliMUONTriggerDecisionV1& rhs);
@@ -91,41 +87,43 @@ protected:
         );
 
   // Global Trigger information [0] : Low pt, [1] : High pt, [2] : All pt 
-  Int_t fGlobalSinglePlus[3];  // tot num of single plus
-  Int_t fGlobalSingleMinus[3]; // tot num of single minus
-  Int_t fGlobalSingleUndef[3]; // tot num of single undefined
-  Int_t fGlobalPairUnlike[3];  // tot num of unlike-sign pairs
-  Int_t fGlobalPairLike[3];    // tot num of like-sign pairs
+  Int_t fGlobalSinglePlus[3];  ///< tot num of single plus
+  Int_t fGlobalSingleMinus[3]; ///< tot num of single minus
+  Int_t fGlobalSingleUndef[3]; ///< tot num of single undefined
+  Int_t fGlobalPairUnlike[3];  ///< tot num of unlike-sign pairs
+  Int_t fGlobalPairLike[3];    ///< tot num of like-sign pairs
 
   // Local Trigger information
-  Int_t fTrigger[234];  // fTrigger = 0 : no trigger, 1 : trigger
-  Int_t fStripX11[234];  // X strip in MC11 which triggers
-  Int_t fDev[234];       // deviation which triggers
-  Int_t fStripY11[234];  // Y strip in MC11 which triggers
-  Int_t fLutLpt[234][2]; // Local Trigger info Low pt
-  Int_t fLutHpt[234][2]; // Local Trigger info High pt
-  Int_t fLutApt[234][2]; // Local Trigger info All pt
+  Int_t fTrigger[234];   ///< fTrigger = 0 : no trigger, 1 : trigger
+  Int_t fStripX11[234];  ///< X strip in MC11 which triggers
+  Int_t fDev[234];       ///< deviation which triggers
+  Int_t fStripY11[234];  ///< Y strip in MC11 which triggers
+  Int_t fLutLpt[234][2]; ///< Local Trigger info Low pt
+  Int_t fLutHpt[234][2]; ///< Local Trigger info High pt
+  Int_t fLutApt[234][2]; ///< Local Trigger info All pt
 
   // bit pattern
-  Int_t fXbit11[234][16]; // bit pattern XM11
-  Int_t fXbit12[234][16]; // bit pattern XM12
-  Int_t fXbit21[234][32]; // bit pattern XM21
-  Int_t fXbit22[234][32]; // bit pattern XM22
-  Int_t fYbit11[234][16]; // bit pattern YM11
-  Int_t fYbit12[234][16]; // bit pattern YM12
-  Int_t fYbit21[234][16]; // bit pattern YM21
-  Int_t fYbit22[234][16]; // bit pattern YM22
-
-  Int_t fYbit21U[234][16]; // bit pattern YM21 Up
-  Int_t fYbit22U[234][16]; // bit pattern YM22 Up
-  Int_t fYbit21D[234][16]; // bit pattern YM21 Down
-  Int_t fYbit22D[234][16]; // bit pattern YM22 Down
-
-  TArrayI fDigitNumbers[234];  //! The digit number that fired a circuit.
+  Int_t fXbit11[234][16]; ///< bit pattern XM11
+  Int_t fXbit12[234][16]; ///< bit pattern XM12
+  Int_t fXbit21[234][32]; ///< bit pattern XM21
+  Int_t fXbit22[234][32]; ///< bit pattern XM22
+  Int_t fYbit11[234][16]; ///< bit pattern YM11
+  Int_t fYbit12[234][16]; ///< bit pattern YM12
+  Int_t fYbit21[234][16]; ///< bit pattern YM21
+  Int_t fYbit22[234][16]; ///< bit pattern YM22
+
+  Int_t fYbit21U[234][16]; ///< bit pattern YM21 Up
+  Int_t fYbit22U[234][16]; ///< bit pattern YM22 Up
+  Int_t fYbit21D[234][16]; ///< bit pattern YM21 Down
+  Int_t fYbit22D[234][16]; ///< bit pattern YM22 Down
+
+  TArrayI fDigitNumbers[234];  //!< The digit number that fired a circuit.
   
-  TObjArray*     fTriggerCircuit;     //! List of Trigger Circuit
-  AliMUONData*   fMUONData;           //! Data container for MUON subsystem 
-  AliMUON*       fMUON;               //! pointer to MUON  
+  TObjArray*     fTriggerCircuit;     //!< List of Trigger Circuit
+  AliMUONData*   fMUONData;           //!< Data container for MUON subsystem 
+  AliMUON*       fMUON;               //!< pointer to MUON  
+
+  ClassDef(AliMUONTriggerDecisionV1,1) // Trigger Decision class
 };
 #endif
 
index 2035a36..5de9a2a 100644 (file)
@@ -74,11 +74,11 @@ class AliMUONTriggerElectronics : public TTask
       AliMUONTriggerElectronics&  operator = (const AliMUONTriggerElectronics& right);
      
    private:
-      TString                    fSourceFileName;     // Source file
-      AliMUONTriggerCrateStore  *fCrates;             // Crate array
-      AliMUONGlobalTriggerBoard *fGlobalTriggerBoard; // Global trigger board
-      AliMUONData               *fMUONData;           //! Data container for MUON subsystem 
-      TArrayI                    fDigitNumbers[234];  //! The digit number that fired a circuit.
+      TString                    fSourceFileName;     ///< Source file
+      AliMUONTriggerCrateStore  *fCrates;             ///< Crate array
+      AliMUONGlobalTriggerBoard *fGlobalTriggerBoard; ///< Global trigger board
+      AliMUONData               *fMUONData;           //!< Data container for MUON subsystem 
+      TArrayI                    fDigitNumbers[234];  //!< The digit number that fired a circuit.
 
    ClassDef(AliMUONTriggerElectronics,2)
 };
index 4c1fbe2..ed2e751 100644 (file)
@@ -38,11 +38,11 @@ class AliMUONTriggerTrack : public TObject
     
 protected:
   private:
-  Float_t fx11;    // x position of fired Y strip in MC11
-  Float_t fy11;    // y position of fired X strip in MC11
-  Float_t fthetax; // track theta angle in X   
-  Float_t fthetay; // track theta angle in Y
-  Long_t fGTPattern; // Global trigger pattern  (do not work with static statement) 
+  Float_t fx11;    ///< x position of fired Y strip in MC11
+  Float_t fy11;    ///< y position of fired X strip in MC11
+  Float_t fthetax; ///< track theta angle in X   
+  Float_t fthetay; ///< track theta angle in Y
+  Long_t fGTPattern; ///< Global trigger pattern  (do not work with static statement) 
 
   ClassDef(AliMUONTriggerTrack, 3) // Reconstructed trigger track in ALICE dimuon spectrometer
     };
index 1ab22da..4c58bbd 100644 (file)
@@ -118,11 +118,11 @@ class AliMUONVGeometryBuilder : public TObject
                       const TString& volName, Int_t detElemId) const;
 
     // data members
-    TObjArray*  fGeometryModules;   // the modules geometries that will be built
-                                    // by this builder                             
-    TGeoCombiTrans fReferenceFrame; // the transformation from the builder 
-                                    // reference frame to that of the transform 
-                                   // data files
+    TObjArray*  fGeometryModules;   ///< \brief the modules geometries that will be built
+                                    /// by this builder                                    
+    TGeoCombiTrans fReferenceFrame; ///< \brief the transformation from the builder 
+                                    /// reference frame to that of the transform 
+                                   /// data files
                                        
   ClassDef(AliMUONVGeometryBuilder,4) // MUON chamber geometry base class
 };
index 290ebb8..595bf96 100755 (executable)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpArea.h,v 1.7 2005/08/26 15:43:36 ivana Exp $
+// $MpId: AliMpArea.h,v 1.8 2006/05/23 13:07:29 ivana Exp $
 
 /// \ingroup basic
 /// \class AliMpArea
@@ -45,9 +45,9 @@ class AliMpArea : public TObject
   
  private:
   // data members
-  TVector2  fPosition;  // position
-  TVector2  fDimensions;// dimensions (half lengths)
-  Bool_t    fValidity;  // validity
+  TVector2  fPosition;  ///<  position
+  TVector2  fDimensions;///<  dimensions (half lengths)
+  Bool_t    fValidity;  ///<  validity
 
   ClassDef(AliMpArea,1) //utility class for area iterators
 };
index 3f77239..151eed7 100644 (file)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpBusPatch.h,v 1.2 2006/03/17 11:35:58 ivana Exp $
+// $MpId: AliMpBusPatch.h,v 1.4 2006/05/23 13:07:38 ivana Exp $
 
 /// \ingroup management
 /// \class AliMpBusPatch
@@ -43,11 +43,11 @@ class AliMpBusPatch : public TObject
 
  private:
 
-  TExMap fDetElemIdToBusPatch;       //! Map from idDE to BusPatch   
-  TExMap fBusPatchToDetElem;         //! Map from BusPatch to idDE
-  TExMap fBusPatchToDDL;             //! Map from BusPatch to iDDL
+  TExMap fDetElemIdToBusPatch;       //!< Map from idDE to BusPatch   
+  TExMap fBusPatchToDetElem;         //!< Map from BusPatch to idDE
+  TExMap fBusPatchToDDL;             //!< Map from BusPatch to iDDL
 
-  Int_t fMaxBusPerCh[10];            //! max buspatch number per chamber
+  Int_t fMaxBusPerCh[10];            //!< max buspatch number per chamber
 
   ClassDef(AliMpBusPatch,1) //utility class for the motif type
 };
index a90646b..46b0379 100755 (executable)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpConnection.h,v 1.7 2006/03/17 11:37:50 ivana Exp $
+// $MpId: AliMpConnection.h,v 1.8 2006/05/23 13:07:41 ivana Exp $
 
 /// \ingroup motif
 /// \class AliMpConnection
@@ -49,11 +49,11 @@ class AliMpConnection : public TObject
     
   private:
     // data members
-    Int_t fPadNum;    // Pad number
-    Int_t fBergNum;   // Berg connector number
-    Int_t fKaptonNum; // Kapton connector number
-    Int_t fGassiNum;  // Gassiplex channel number
-    AliMpMotifType *fOwner; //The motif type which contains this connection
+    Int_t fPadNum;    ///< Pad number
+    Int_t fBergNum;   ///< Berg connector number
+    Int_t fKaptonNum; ///< Kapton connector number
+    Int_t fGassiNum;  ///< Gassiplex channel number
+    AliMpMotifType *fOwner; ///< The motif type which contains this connection
 
   ClassDef(AliMpConnection,1)  // Connection description
 };
index 225b017..0c8050d 100755 (executable)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpConstants.h,v 1.9 2006/03/13 12:08:51 ivana Exp $
+// $MpId: AliMpConstants.h,v 1.10 2006/05/23 13:07:29 ivana Exp $
 
 /// \ingroup basic
 /// \class AliMpConstants
@@ -40,12 +40,12 @@ class AliMpConstants : public TObject
   virtual Bool_t  IsEqual(const TObject*) const { return true; }
  
   // static data members
-  static const Double_t  fgkLengthTolerance;// the length precision for tests
-  static const Double_t  fgkLengthStep;     // the step in length used to move from
-                                            // a geometric border inside (pad, motif)
-  static const Int_t     fgkStartPadIndex;  // global pad indices start value
-  static const Int_t     fgkNCh;            // number of chambers
-  static const Int_t     fgkNonBendingManuMask; // bit to set to indicate a manu located in non-bending plane
+  static const Double_t  fgkLengthTolerance;///< the length precision for tests
+  static const Double_t  fgkLengthStep;     ///< \brief the step in length used to move from
+                                            /// a geometric border inside (pad, motif)
+  static const Int_t     fgkStartPadIndex;  ///< global pad indices start value
+  static const Int_t     fgkNCh;            ///< number of chambers
+  static const Int_t     fgkNonBendingManuMask; ///< bit to set to indicate a manu located in non-bending plane
   
   ClassDef(AliMpConstants,3) //Class for globally used constants definition
 };
index 545cc41..4d4536c 100644 (file)
@@ -2,9 +2,9 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpContainers.h,v 1.3 2005/08/26 15:43:36 ivana Exp $
+// $MpId: AliMpContainers.h,v 1.4 2006/05/23 13:07:29 ivana Exp $
 
-/// \ingroup basis
+/// \ingroup basic
 /// AliMpContainers
 /// Compiler directive for selection of containers type:
 /// Either STL or ROOT
index bf73b69..b3ad62e 100644 (file)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$ 
-// $MpId: AliMpDEIterator.h,v 1.3 2006/03/17 11:35:58 ivana Exp $ 
+// $MpId: AliMpDEIterator.h,v 1.4 2006/05/23 13:07:38 ivana Exp $ 
 
 /// \ingroup management
 /// \class AliMpDEIterator
@@ -51,15 +51,15 @@ class AliMpDEIterator : public  TObject {
     static void   ReadData();
 
     // static data members     
-    static const Int_t  fgkMaxNofDetElements; // Maximum number of DEs
-    static TArrayI      fgDetElemIds;         // DE Ids        
-    static Int_t        fgNofDetElemIds;      // Number of DE Ids      
+    static const Int_t  fgkMaxNofDetElements; ///< Maximum number of DEs
+    static TArrayI      fgDetElemIds;         ///< DE Ids      
+    static Int_t        fgNofDetElemIds;      ///< Number of DE Ids    
 
     // data members    
-    Int_t  fIndex;    // Current DE index
-    Int_t  fModuleId; // The iterated module 
+    Int_t  fIndex;    ///< Current DE index
+    Int_t  fModuleId; ///< The iterated module 
 
-  ClassDef(AliMpDEIterator,0)  // MUON Factory for Chambers and Segmentation
+  ClassDef(AliMpDEIterator,0)  // The iterator over valid detection element IDs
 };
 
 #endif //ALI_MP_DE_ITERATOR_H
index a9ba36a..a162d0e 100644 (file)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpDEManager.h,v 1.4 2006/03/17 11:35:58 ivana Exp $ 
+// $MpId: AliMpDEManager.h,v 1.5 2006/05/23 13:07:38 ivana Exp $ 
 
 /// \ingroup management
 /// \class AliMpDEManager
@@ -61,17 +61,17 @@ class AliMpDEManager : public  TObject {
     static void   FillDENames();
 
     // static data members     
-    static const char  fgkNameSeparator; // Separator character used in DE names
-    static const char  fgkCommentPrefix; // Comment prefix in DE names file
-    static const Int_t fgkCoefficient;   // Coefficient used in DE Id <-> station
+    static const char  fgkNameSeparator; ///< Separator character used in DE names
+    static const char  fgkCommentPrefix; ///< Comment prefix in DE names file
+    static const Int_t fgkCoefficient;   ///< Coefficient used in DE Id <-> station
 
     // data members    
-    static  AliMpExMap fgDENamesMap;  // Map between DE Ids and 
-                                      // a pair of DE names for 2 cathods
-    static  AliMpExMap fgDECathBNBMap;// Map between DE Is and a pair
-                                      // of planeTypes for cathodes (0,1)
+    static  AliMpExMap fgDENamesMap;  ///< \brief Map between DE Ids and 
+                                      /// a pair of DE names for 2 cathods
+    static  AliMpExMap fgDECathBNBMap;///< \brief  Map between DE Is and a pair
+                                      /// of planeTypes for cathodes (0,1)
 
-  ClassDef(AliMpDEManager,0)  // 
+  ClassDef(AliMpDEManager,0)  // The manager class for definition of detection element types
 };
 
 #endif //ALI_MP_MANAGER_H
index a44b894..6c9287e 100644 (file)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpExMap.h,v 1.2 2006/03/17 11:34:29 ivana Exp $
+// $MpId: AliMpExMap.h,v 1.3 2006/05/23 13:07:29 ivana Exp $
 
 /// \ingroup basic
 /// \class AliMpExMap
@@ -62,20 +62,20 @@ class AliMpExMap : public TObject
     void AddKey(Long_t key);
     
     // static data members
-    static const Int_t    fgkDefaultSize;      // Default initial size
-    static const Bool_t   fgkDefaultOwnership; // Default ownership
+    static const Int_t    fgkDefaultSize;      ///< Default initial size
+    static const Bool_t   fgkDefaultOwnership; ///< Default ownership
 
-    static const Int_t    fgkSeparator1; // the separator used for conversion
-                                         // of AliMpIntPair to Int_t
-    static const Int_t    fgkSeparator2; // the separator used for conversion
-                                         // of TString to Int_t
-    static const TString  fgkCharacterMap; // the string mapping characters 
-                                           // to integers 
+    static const Int_t    fgkSeparator1; ///< \brief the separator used for conversion
+                                         ///  of AliMpIntPair to Int_t
+    static const Int_t    fgkSeparator2; ///< \brief the separator used for conversion
+                                         ///  of TString to Int_t
+    static const TString  fgkCharacterMap; ///< \brief the string mapping characters 
+                                           ///  to integers 
     
     // data members
-    mutable TExMap  fMap;     //! Transient map class
-    TObjArray       fObjects; // Array of objects 
-    TArrayL         fKeys;    // Array of keys 
+    mutable TExMap  fMap;     //!<  Transient map class
+    TObjArray       fObjects; ///<  Array of objects 
+    TArrayL         fKeys;    ///<  Array of keys 
 
   ClassDef(AliMpExMap,1)  // Root persistent TExMap
 };
index baff9b5..39e6569 100755 (executable)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpFiles.h,v 1.8 2006/03/17 11:34:29 ivana Exp $
+// $MpId: AliMpFiles.h,v 1.9 2006/05/23 13:07:29 ivana Exp $
 
 /// \ingroup basic
 /// \class AliMpFiles
@@ -91,21 +91,21 @@ class AliMpFiles : public TObject
     static TString StationDataDir(AliMpStationType station); 
   
     // static data members  
-    static const TString fgkDataDir;       //data directory
-    static const TString fgkStationDir;    //station directory
-    static const TString fgkBendingDir;    //bending plane directory
-    static const TString fgkNonBendingDir; //non-bending plane directory
-    static const TString fgkDENames;       //DE names data file name
-    static const TString fgkSector;        //sector data file name
-    static const TString fgkSectorSpecial; //sector special data file name
-    static const TString fgkSectorSpecial2;//sector special data file name
-    static const TString fgkMotifPrefix;   //motif data file name
-    static const TString fgkMotifSpecialPrefix; //special motif data file name 
-    static const TString fgkPadPosPrefix;  //pad position data file name
-    static const TString fgkDataExt;       //file extension
-    static const TString fgkBergToGCFileName;  //BergToGC mapping filr name
-    static const TString fgkTriggerLocalBoards;// local board name to id mapping
-    static const TString fgkBusPatchFileName;  //DetElemIdToBusPatch file name
+    static const TString fgkDataDir;       ///< data directory
+    static const TString fgkStationDir;    ///< station directory
+    static const TString fgkBendingDir;    ///< bending plane directory
+    static const TString fgkNonBendingDir; ///< non-bending plane directory
+    static const TString fgkDENames;       ///< DE names data file name
+    static const TString fgkSector;        ///< sector data file name
+    static const TString fgkSectorSpecial; ///< sector special data file name
+    static const TString fgkSectorSpecial2;///< sector special data file name
+    static const TString fgkMotifPrefix;   ///< motif data file name
+    static const TString fgkMotifSpecialPrefix; ///< special motif data file name 
+    static const TString fgkPadPosPrefix;  ///< pad position data file name
+    static const TString fgkDataExt;       ///< file extension
+    static const TString fgkBergToGCFileName;  ///< BergToGC mapping filr name
+    static const TString fgkTriggerLocalBoards;///<  local board name to id mapping
+    static const TString fgkBusPatchFileName;  ///< DetElemIdToBusPatch file name
     
 
   ClassDef(AliMpFiles, 0) //File names and paths 
index 70e40c4..2770d91 100755 (executable)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpGraphContext.h,v 1.9 2006/03/17 11:35:15 ivana Exp $
+// $MpId: AliMpGraphContext.h,v 1.10 2006/05/23 13:07:35 ivana Exp $
 
 /// \ingroup graphics
 /// \class AliMpGraphContext
@@ -75,20 +75,20 @@ class AliMpGraphContext : public TObject
   //private constructor (not instanciable from outside)
   AliMpGraphContext();
 
-  // static data members
-  static AliMpGraphContext *fgInstance;   // the global instance
-  static GraphContextVector fgStack;  // the object stack
+  ///< static data members
+  static AliMpGraphContext *fgInstance; ///< the global instance
+  static GraphContextVector fgStack;    ///< the object stack
 #ifdef WITH_ROOT
-  static Int_t fgStackSize;  // the object stack size
+  static Int_t fgStackSize;  ///< the object stack size
 #endif
 
   //data members
-  Int_t    fColor;          // color to use
-  TVector2 fPadPosition;    // Position of the pad area where to draw
-  TVector2 fPadDimensions;   // Dimensions of the pad area where to draw
+  Int_t    fColor;          ///< color to use
+  TVector2 fPadPosition;    ///< Position of the pad area where to draw
+  TVector2 fPadDimensions;  ///< Dimensions of the pad area where to draw
 
-  TVector2 fRealPosition;   // Position of the real area to draw
-  TVector2 fRealDimensions;  // Dimensions of the real area to draw
+  TVector2 fRealPosition;   ///< Position of the real area to draw
+  TVector2 fRealDimensions; ///< Dimensions of the real area to draw
 
   ClassDef(AliMpGraphContext,1) // Correspondance pad area/real world
 };
index 426f4ce..31cc695 100644 (file)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$ 
-// $MpId: AliMpHelper.h,v 1.4 2005/09/19 19:01:09 ivana Exp $ 
+// $MpId: AliMpHelper.h,v 1.5 2006/05/23 13:07:47 ivana Exp $ 
 
 /// \ingroup slat
 /// \class AliMpHelper
index ecda7a0..a8688f0 100755 (executable)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpIntPair.h,v 1.4 2005/08/26 15:43:36 ivana Exp $
+// $MpId: AliMpIntPair.h,v 1.5 2006/05/23 13:07:29 ivana Exp $
 
 /// \ingroup basic
 /// \class AliMpIntPair
@@ -49,11 +49,11 @@ class AliMpIntPair : public TObject
   
  private:
   // data members
-  Int_t   fFirst;    // position along x
-  Int_t   fSecond;   // position along y
-  Bool_t  fValidity; // validity
+  Int_t   fFirst;    ///< the first value
+  Int_t   fSecond;   ///< the second value
+  Bool_t  fValidity; ///< validity
 
-  ClassDef(AliMpIntPair,1) //utility class for the motif type
+  ClassDef(AliMpIntPair,1) // utility class for the motif type
 };
 
 AliMpIntPair operator + (const AliMpIntPair& op1,const AliMpIntPair& op2);
index a3698ef..a09574a 100755 (executable)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpMotif.h,v 1.6 2006/03/17 11:37:50 ivana Exp $
+// $MpId: AliMpMotif.h,v 1.7 2006/05/23 13:07:41 ivana Exp $
 
 /// \ingroup motif
 /// \class AliMpMotif
@@ -43,7 +43,7 @@ class AliMpMotif : public AliMpVMotif
   // methods
 
   // data members 
-  TVector2    fPadDimensions; //pad dimensions (halflength x, y size) 
+  TVector2  fPadDimensions; ///< pad dimensions (halflength x, y size) 
 
   ClassDef(AliMpMotif,1) // A motif with its ID
 };
index d2fdb93..ae48bdd 100755 (executable)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpMotifMap.h,v 1.12 2006/03/17 11:37:50 ivana Exp $
+// $MpId: AliMpMotifMap.h,v 1.13 2006/05/23 13:07:41 ivana Exp $
 
 /// \ingroup motif
 /// \class AliMpMotifMap
@@ -103,15 +103,15 @@ class AliMpMotifMap : public TObject
     void  PrintMotifPositions2() const;
  
     // data members
-    MotifMap           fMotifs;         //  motifs map
-    MotifTypeMap       fMotifTypes;     //  motifs types map
+    MotifMap           fMotifs;         ///< motifs map
+    MotifTypeMap       fMotifTypes;     ///< motifs types map
 #ifdef WITH_STL
-    std::map<Int_t, AliMpMotifPosition*> fMotifPositions; // motif positions map by Id
+    std::map<Int_t, AliMpMotifPosition*> fMotifPositions; ///< motif positions map by Id
 #endif
 #ifdef WITH_ROOT
-    MotifPositionMap   fMotifPositions; //  motifs positions map
+    MotifPositionMap   fMotifPositions; ///< motifs positions map
 #endif
-    MotifPositionMap2  fMotifPositions2;//  motifs positions map
+    MotifPositionMap2  fMotifPositions2;///< motifs positions map
 
   ClassDef(AliMpMotifMap,1)  // motif map
 };
index 8a33058..47ca63c 100755 (executable)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpMotifPainter.h,v 1.6 2005/08/26 15:43:36 ivana Exp $
+// $MpId: AliMpMotifPainter.h,v 1.7 2006/05/23 13:07:35 ivana Exp $
 
 /// \ingroup graphics
 /// \class AliMpMotifPainter
@@ -34,7 +34,7 @@ class AliMpMotifPainter : public AliMpVPainter
   AliMpMotifPainter&  operator = (const AliMpMotifPainter& right);
 
  private:
-  AliMpMotifPosition *fMotifPos;          // the motif to draw
+  AliMpMotifPosition *fMotifPos; ///< the motif to draw
 
   ClassDef(AliMpMotifPainter,1) // Motif painter
 };
index a4e1097..63b2548 100755 (executable)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpMotifPosition.h,v 1.7 2006/03/17 11:37:51 ivana Exp $
+// $MpId: AliMpMotifPosition.h,v 1.8 2006/05/23 13:07:42 ivana Exp $
 
 /// \ingroup motif
 /// \class AliMpMotifPosition
@@ -53,9 +53,9 @@ class AliMpMotifPosition : public AliMpVIndexed
  private:
   // methods
   // data members 
-  Int_t         fID;       //identifier=manu id
-  AliMpVMotif*  fMotif;    //motif
-  TVector2      fPosition; //position
+  Int_t         fID;       ///< identifier=manu id
+  AliMpVMotif*  fMotif;    ///< motif
+  TVector2      fPosition; ///< position
 
   ClassDef(AliMpMotifPosition,1) // A motif position
 };
index dd4f969..770f846 100755 (executable)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpMotifPositionPadIterator.h,v 1.5 2005/08/26 15:43:36 ivana Exp $
+// $MpId: AliMpMotifPositionPadIterator.h,v 1.6 2006/05/23 13:07:42 ivana Exp $
 
 /// \ingroup motif
 /// \class AliMpMotifPositionPadIterator
@@ -41,8 +41,8 @@ class AliMpMotifPositionPadIterator : public AliMpVPadIterator
     Bool_t IsValid() const;
 
     // private data members
-    const AliMpMotifPosition* fMotifPos; // the AliMpMotifPosition over which iterate
-    AliMpMotifTypePadIterator fIterator; // Iterator over the motif type
+    const AliMpMotifPosition* fMotifPos; ///< the AliMpMotifPosition over which iterate
+    AliMpMotifTypePadIterator fIterator; ///< Iterator over the motif type
 
  ClassDef(AliMpMotifPositionPadIterator,1) // iterator over motif's pads
 };
index dd4cf57..3d46ba4 100644 (file)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpMotifReader.h,v 1.7 2006/03/17 11:37:51 ivana Exp $
+// $MpId: AliMpMotifReader.h,v 1.8 2006/05/23 13:07:42 ivana Exp $
 
 /// \ingroup motif
 /// \class AliMpMotifReader
@@ -67,8 +67,8 @@ class AliMpMotifReader : public TObject
 
   private:
     // data members  
-    AliMpStationType  fStationType; // station type 
-    AliMpPlaneType    fPlaneType;   // plane type 
+    AliMpStationType  fStationType; ///< station type 
+    AliMpPlaneType    fPlaneType;   ///< plane type 
 
   ClassDef(AliMpMotifReader,1)  // Data reader
 };
index 05a58e2..6184350 100755 (executable)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpMotifSpecial.h,v 1.9 2006/04/24 13:54:27 ivana Exp $
+// $MpId: AliMpMotifSpecial.h,v 1.10 2006/05/23 13:07:42 ivana Exp $
 
 /// \ingroup motif
 /// \class AliMpMotifSpecial
@@ -70,9 +70,9 @@ class AliMpMotifSpecial : public AliMpVMotif
   Int_t VectorIndex(const AliMpIntPair& indices) const;
 
   // data members
-  TVector2        fDimensions;           // motif dimensions
-  DimensionsMap   fPadDimensionsVector;  // the vector of pad dimensions
-  DimensionsMap2  fPadDimensionsVector2; // the vector of different pad dimensions
+  TVector2        fDimensions;           ///< motif dimensions
+  DimensionsMap   fPadDimensionsVector;  ///< the vector of pad dimensions
+  DimensionsMap2  fPadDimensionsVector2; ///< the vector of different pad dimensions
 
   ClassDef(AliMpMotifSpecial,2) // A motif with its ID
 };
index fb15e9b..8907445 100755 (executable)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpMotifType.h,v 1.9 2006/03/17 11:37:51 ivana Exp $
+// $MpId: AliMpMotifType.h,v 1.10 2006/05/23 13:07:42 ivana Exp $
 
 /// \ingroup motif
 /// \class AliMpMotifType
@@ -85,16 +85,16 @@ class AliMpMotifType : public TObject
 
   private:
     // static data members
-    static const Int_t   fgkPadNumForA; // the pad number for the pad "A"
+    static const Int_t  fgkPadNumForA; ///< the pad number for the pad "A"
   
     // data members
-    TString   fID;              // unique motif ID
-    Int_t     fNofPadsX;        // number of pads in x direction
-    Int_t     fNofPadsY;        // number of pads in y direction
-    Int_t     fVerboseLevel;    // verbose level
-    ConnectionMap fConnections; // Map (ix,iy) of connections
+    TString   fID;              ///< unique motif ID
+    Int_t     fNofPadsX;        ///< number of pads in x direction
+    Int_t     fNofPadsY;        ///< number of pads in y direction
+    Int_t     fVerboseLevel;    ///< verbose level
+    ConnectionMap fConnections; ///< Map (ix,iy) of connections
     
-  ClassDef(AliMpMotifType,1)  //Motif type
+  ClassDef(AliMpMotifType,1)  // Motif type
 };
 
 // inline functions
index 6b94a24..80ec4d9 100755 (executable)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpMotifTypePadIterator.h,v 1.6 2005/09/26 16:10:46 ivana Exp $
+// $MpId: AliMpMotifTypePadIterator.h,v 1.7 2006/05/23 13:07:42 ivana Exp $
 
 /// \ingroup motif
 /// \class AliMpMotifTypePadIterator
@@ -42,8 +42,8 @@ class AliMpMotifTypePadIterator : public AliMpVPadIterator
     Bool_t IsValid() const;
 
     // private data members
-    const AliMpMotifType* fMotifType;// the motif type over which iterate
-    AliMpIntPair fCurrentPosition;   // the current position inside the motif type
+    const AliMpMotifType* fMotifType;///< the motif type over which iterate
+    AliMpIntPair fCurrentPosition;   ///< the current position inside the motif type
 
  ClassDef(AliMpMotifTypePadIterator,1) // iterator over motif's pads
 };
index 8e32760..ea86829 100755 (executable)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpNeighboursPadIterator.h,v 1.10 2006/03/17 11:38:28 ivana Exp $
+// $MpId: AliMpNeighboursPadIterator.h,v 1.11 2006/05/23 13:07:44 ivana Exp $
 
 /// \ingroup sector
 /// \class AliMpNeighboursPadIterator
@@ -82,11 +82,11 @@ class AliMpNeighboursPadIterator : public AliMpVPadIterator
     Bool_t    IsValid() const;
 
     // private data members
-    const AliMpSectorSegmentation* fkSegmentation; // The sector segmentation 
-                                                   // over which to iterate
-    AliMpPad   fCenterPad; // Pad arround which we iterate
-    PadVector  fPads;      // The list of pad arround fCenterIndices
-    UInt_t     fIndex;     // Current index inside the fPads vector
+    const AliMpSectorSegmentation* fkSegmentation; ///< \brief The sector
+                           ///  segmentation over which to iterate
+    AliMpPad   fCenterPad; ///< Pad arround which we iterate
+    PadVector  fPads;      ///< The list of pad arround fCenterIndices
+    UInt_t     fIndex;     ///< Current index inside the fPads vector
 
   ClassDef(AliMpNeighboursPadIterator,1) // iterator over motif's pads
 };
index 6ace684..ec09554 100644 (file)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$ 
-// $MpId: AliMpPCB.h,v 1.6 2006/03/17 16:42:28 ivana Exp $ 
+// $MpId: AliMpPCB.h,v 1.8 2006/05/23 13:07:47 ivana Exp $ 
 
 /// \ingroup slat
 /// \class AliMpPCB
@@ -134,24 +134,24 @@ class AliMpPCB : public TObject
   Int_t NofPads() const { return fNofPads; }
   
  private:
-  TString fId; // PCB name
-  Double_t fPadSizeX; // x-size of this PCB's pads (cm)
-  Double_t fPadSizeY; // y-size of this PCB's pads (cm)
-  Double_t fEnveloppeSizeX; // max x-size of this PCB (cm)
+  TString fId; ///< PCB name
+  Double_t fPadSizeX; ///< x-size of this PCB's pads (cm)
+  Double_t fPadSizeY; ///< y-size of this PCB's pads (cm)
+  Double_t fEnveloppeSizeX; ///< max x-size of this PCB (cm)
   Double_t fEnveloppeSizeY; // max y-size of this PCB (cm)
-  Double_t fXoffset; // x-offset = x of first pad of this PCB (cm)
-  Double_t fActiveXmin; // min x of an actual pad in this PCB (cm)
-  Double_t fActiveXmax; // max x of an actual pad in this PCB (cm)
-  Int_t fIxmin; // min pad index in x
-  Int_t fIxmax; // max pad index in x
-  Int_t fIymin; // min pad index in y
-  Int_t fIymax; // max pad index in y
+  Double_t fXoffset; ///< x-offset = x of first pad of this PCB (cm)
+  Double_t fActiveXmin; ///< min x of an actual pad in this PCB (cm)
+  Double_t fActiveXmax; ///< max x of an actual pad in this PCB (cm)
+  Int_t fIxmin; ///< min pad index in x
+  Int_t fIxmax; ///< max pad index in x
+  Int_t fIymin; ///< min pad index in y
+  Int_t fIymax; ///< max pad index in y
 #ifdef WITH_ROOT
-  TObjArray fMotifs; // array of motifs
+  TObjArray fMotifs; ///< array of motifs
 #else  
-  std::vector<AliMpMotifPosition*> fMotifs; // array of motifs
+  std::vector<AliMpMotifPosition*> fMotifs; ///< array of motifs
 #endif
-  Int_t fNofPads; // number of pads in this PCB
+  Int_t fNofPads; ///< number of pads in this PCB
   
   ClassDef(AliMpPCB,2) // A PCB for Stations 3,4,5
 };
index 1845ec9..7ea8882 100644 (file)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpPCBPainter.h,v 1.3 2005/08/26 15:43:36 ivana Exp $
+// $MpId: AliMpPCBPainter.h,v 1.6 2006/05/23 13:07:35 ivana Exp $
 
 /// \ingroup graphics
 /// \class AliMpPCBPainter
@@ -35,7 +35,7 @@ public:
   AliMpPCBPainter&  operator = (const AliMpPCBPainter& right);
      
  private:
-  AliMpPCB* fPCB; //! PCB to be plotted.
+  AliMpPCB* fPCB; //!< PCB to be plotted.
 
   ClassDef(AliMpPCBPainter,1) // A painter for a PCB of stations 3,4,5
 };
index 7e3bdbb..cac54b8 100755 (executable)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpPad.h,v 1.9 2006/03/17 11:34:29 ivana Exp $
+// $MpId: AliMpPad.h,v 1.10 2006/05/23 13:07:29 ivana Exp $
 
 /// \ingroup basic
 /// \class AliMpPad
@@ -73,15 +73,15 @@ class AliMpPad : public TObject
 
  private:
   // static data members
-  static const Int_t  fgkMaxNofLocations; // maximum number of pad locations
-                                          // in the collection
+  static const Int_t  fgkMaxNofLocations; ///< \brief maximum number of pad locations
+                                          /// in the collection
   // data members
-  IntPairVector*  fLocations;      // collection of pad locations 
-  AliMpIntPair    fLocation;       // pad location
-  AliMpIntPair    fIndices;        // pad indices
-  TVector2        fPosition;       // the pad position (in cm)
-  TVector2        fDimensions;     // the pad dimensions (in cm)
-  Bool_t          fValidity;       // validity
+  IntPairVector*  fLocations;      ///<  collection of pad locations 
+  AliMpIntPair    fLocation;       ///<  pad location
+  AliMpIntPair    fIndices;        ///<  pad indices
+  TVector2        fPosition;       ///<  the pad position (in cm)
+  TVector2        fDimensions;     ///<  the pad dimensions (in cm)
+  Bool_t          fValidity;       ///<  validity
 
   ClassDef(AliMpPad,1) //utility class for the motif type
 };
index 2e0acc2..b460420 100755 (executable)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpPadIteratorPtr.h,v 1.5 2005/08/26 15:43:36 ivana Exp $
+// $MpId: AliMpPadIteratorPtr.h,v 1.6 2006/05/23 13:07:29 ivana Exp $
 
 /// \ingroup basic
 /// \class AliMpPadIteratorPtr
@@ -42,7 +42,7 @@ class AliMpPadIteratorPtr : public TObject
     
   private:   
     // data members
-    AliMpVPadIterator*  fIterator; //The pad iterator
+    AliMpVPadIterator*  fIterator; ///< The pad iterator
      
   ClassDef(AliMpPadIteratorPtr,1) // Pointer to abstract pad iterator
 };
index 4f21850..c66bb12 100644 (file)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpPadPair.h,v 1.8 2006/03/17 11:34:29 ivana Exp $
+// $MpId: AliMpPadPair.h,v 1.9 2006/05/23 13:07:29 ivana Exp $
 
 /// \ingroup basic
 /// \class AliMpPadPair
@@ -37,8 +37,8 @@ class AliMpPadPair : public TObject
 
   private:
     // data members
-    AliMpPad  fPadFirst;  // first pad
-    AliMpPad  fPadSecond; // second pad
+    AliMpPad  fPadFirst;  ///<  first pad
+    AliMpPad  fPadSecond; ///<  second pad
     
     
   ClassDef(AliMpPadPair,1) //utility class for the motif type
index 6a10992..d102ed1 100755 (executable)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpPadRow.h,v 1.8 2006/03/17 11:38:28 ivana Exp $
+// $MpId: AliMpPadRow.h,v 1.9 2006/05/23 13:07:44 ivana Exp $
 
 /// \ingroup sector
 /// \class AliMpPadRow
@@ -67,12 +67,12 @@ class AliMpPadRow : public TObject
     Double_t CurrentBorderX() const;
 
     // data members
-    AliMpXDirection     fDirection;//the pad row x direction
-    Int_t               fID;       //the pad row ID
-    Double_t            fOffsetX;  //the x position of the border
-    PadRowSegmentVector fSegments; //the pad row segments
+    AliMpXDirection     fDirection; ///< the pad row x direction
+    Int_t               fID;        ///< the pad row ID
+    Double_t            fOffsetX;   ///< the x position of the border
+    PadRowSegmentVector fSegments;  ///< the pad row segments
 
-  ClassDef(AliMpPadRow,1)  //Pad row
+  ClassDef(AliMpPadRow,1)  // Pad row
 };
 
 #endif //ALI_MP_PAD_ROW_H
index f0b2964..4302519 100755 (executable)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpPadRowLSegment.h,v 1.5 2006/03/17 11:38:28 ivana Exp $
+// $MpId: AliMpPadRowLSegment.h,v 1.6 2006/05/23 13:07:44 ivana Exp $
 
 /// \ingroup sector
 /// \class AliMpPadRowLSegment
@@ -41,7 +41,7 @@ class AliMpPadRowLSegment : public AliMpVPadRowSegment
     Double_t  FirstPadBorderX() const;
     Double_t  LastPadBorderX() const;
     
-  ClassDef(AliMpPadRowLSegment,1)  //Row segment
+  ClassDef(AliMpPadRowLSegment,1)  // Row segment
 };
 
 #endif //ALI_MP_PAD_ROW_L_SEGMENT_H
index 7b0f4e6..bdb4b7c 100644 (file)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpPadRowRSegment.h,v 1.5 2006/03/17 11:38:28 ivana Exp $
+// $MpId: AliMpPadRowRSegment.h,v 1.6 2006/05/23 13:07:44 ivana Exp $
 
 /// \ingroup sector
 /// \class AliMpPadRowRSegment
@@ -41,7 +41,7 @@ class AliMpPadRowRSegment : public AliMpVPadRowSegment
     Double_t  FirstPadBorderX() const;
     Double_t  LastPadBorderX() const;
     
-  ClassDef(AliMpPadRowRSegment,1)  //Row segment
+  ClassDef(AliMpPadRowRSegment,1)  // Row segment
 };
 
 #endif //ALI_MP_PAD_ROW_R_SEGMENT_H
index 5f8654d..1dbe974 100755 (executable)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpPlaneType.h,v 1.6 2006/03/17 11:34:29 ivana Exp $
+// $MpId: AliMpPlaneType.h,v 1.7 2006/05/23 13:07:29 ivana Exp $
 
 /// \ingroup basic
 /// \enum AliMpPlaneType
index 2390c56..bfabc20 100755 (executable)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpRow.h,v 1.9 2006/03/17 11:38:28 ivana Exp $
+// $MpId: AliMpRow.h,v 1.10 2006/05/23 13:07:44 ivana Exp $
 
 /// \ingroup sector
 /// \class AliMpRow
@@ -83,12 +83,12 @@ class AliMpRow : public AliMpVIndexed
     void CheckEmpty() const;
   
     // data members
-    UInt_t            fID;      // row ID
-    Double_t          fOffsetY; // the y position of the centre of motifs
-    RowSegmentVector  fSegments;// row segments
-    AliMpMotifMap*    fMotifMap;// the motif map associated with its sector
+    UInt_t            fID;      ///< row ID
+    Double_t          fOffsetY; ///< the y position of the centre of motifs
+    RowSegmentVector  fSegments;///< row segments
+    AliMpMotifMap*    fMotifMap;///< the motif map associated with its sector
 
-  ClassDef(AliMpRow,1)  //Row
+  ClassDef(AliMpRow,1)  // Row
 };
 
 // inline functions
index f08a7ef..eeae688 100755 (executable)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpRowPainter.h,v 1.6 2005/08/26 15:43:36 ivana Exp $
+// $MpId: AliMpRowPainter.h,v 1.7 2006/05/23 13:07:35 ivana Exp $
 
 /// \ingroup graphics
 /// \class AliMpRowPainter
@@ -35,7 +35,8 @@ class AliMpRowPainter : public AliMpVPainter
   AliMpRowPainter&  operator = (const AliMpRowPainter& right);
 
  private: 
-  AliMpRow *fRow;             // the row to paint
+  AliMpRow *fRow;             ///< the row to paint
+  
   ClassDef(AliMpRowPainter,1) // Row painter
 };
 #endif //ALI_MP_ROW_PAINTER_H
index 761b41c..6d264de 100755 (executable)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpRowSegment.h,v 1.8 2006/03/17 11:38:28 ivana Exp $
+// $MpId: AliMpRowSegment.h,v 1.9 2006/05/23 13:07:44 ivana Exp $
 
 /// \ingroup sector
 /// \class AliMpRowSegment
@@ -69,16 +69,16 @@ class AliMpRowSegment : public AliMpVRowSegment
     Bool_t    IsInside(const TVector2& position, Bool_t warn = true) const;
 
     // data members
-    Int_t         fNofMotifs;  //number of motifs
-    AliMpIntPair  fPadOffset;  //the offset in nof pads 
-    TVector2      fOffset;     //the position of the centre of the first motif
-                               //(x wtr to left border, y wtr to row center)
-    AliMpRow*     fRow;        //the row containing this segment 
-    AliMpVMotif*  fMotif;      //the motif 
-    Int_t   fMotifPositionId;  // the first motif position id
-    Int_t   fMotifPositionDId; // +1 if ids are increasing, -1 if decreasing
+    Int_t         fNofMotifs;  ///< number of motifs
+    AliMpIntPair  fPadOffset;  ///< the offset in nof pads 
+    TVector2      fOffset;     ///< \brief the position of the centre of the first motif
+                               /// (x wtr to left border, y wtr to row center)
+    AliMpRow*     fRow;        ///< the row containing this segment 
+    AliMpVMotif*  fMotif;      ///< the motif 
+    Int_t   fMotifPositionId;  ///< the first motif position id
+    Int_t   fMotifPositionDId; ///< +1 if ids are increasing, -1 if decreasing
     
-  ClassDef(AliMpRowSegment,1)  //Row segment
+  ClassDef(AliMpRowSegment,1)  // Row segment
 };
 
 #endif //ALI_MP_ROW_SEGMENT_H
index 030ce69..7f23bc1 100755 (executable)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpRowSegmentLSpecial.h,v 1.7 2006/03/17 11:38:28 ivana Exp $
+// $MpId: AliMpRowSegmentLSpecial.h,v 1.8 2006/05/23 13:07:44 ivana Exp $
 
 /// \ingroup sector
 /// \class AliMpRowSegmentLSpecial
@@ -50,7 +50,7 @@ class AliMpRowSegmentLSpecial : public AliMpVRowSegmentSpecial
     // methods
     AliMpVPadRowSegment* FindMostRightPadRowSegment(Int_t motifPositionId) const;
     
-  ClassDef(AliMpRowSegmentLSpecial,1)  //Row segment
+  ClassDef(AliMpRowSegmentLSpecial,1)  // Row segment
 };
 
 #endif //ALI_MP_ROW_SEGMENT_L_SPECIAL_H
index e06607b..e86dc6c 100755 (executable)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpRowSegmentPainter.h,v 1.6 2005/08/26 15:43:36 ivana Exp $
+// $MpId: AliMpRowSegmentPainter.h,v 1.7 2006/05/23 13:07:35 ivana Exp $
 
 /// \ingroup graphics
 /// \class AliMpRowSegmentPainter
@@ -35,7 +35,8 @@ class AliMpRowSegmentPainter : public AliMpVPainter
   AliMpRowSegmentPainter&  operator = (const AliMpRowSegmentPainter& right);
 
  private: 
-  AliMpVRowSegment *fRowSegment;      // the row segment to draw
+  AliMpVRowSegment *fRowSegment; ///< the row segment to draw
+
   ClassDef(AliMpRowSegmentPainter,1) // Row Segment painter
 };
 #endif //ALI_MP_ROW_SEGMENT_PAINTER_H
index 7a7665e..5260079 100644 (file)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpRowSegmentRSpecial.h,v 1.7 2006/03/17 11:38:28 ivana Exp $
+// $MpId: AliMpRowSegmentRSpecial.h,v 1.8 2006/05/23 13:07:44 ivana Exp $
 
 /// \ingroup sector
 /// \class AliMpRowSegmentRSpecial
@@ -51,7 +51,7 @@ class AliMpRowSegmentRSpecial : public AliMpVRowSegmentSpecial
     AliMpVPadRowSegment* FindMostLeftPadRowSegment(Int_t motifPositionId) const;
     void SetGlobalIndicesLow();
     
-  ClassDef(AliMpRowSegmentRSpecial,1)  //Row segment
+  ClassDef(AliMpRowSegmentRSpecial,1)  // Row segment
 };
 
 #endif //ALI_MP_ROW_SEGMENT_R_SPECIAL_H
index 9ed69e7..a401bbb 100755 (executable)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpSector.h,v 1.12 2006/03/17 11:38:28 ivana Exp $
+// $MpId: AliMpSector.h,v 1.13 2006/05/23 13:07:44 ivana Exp $
 
 /// \ingroup sector
 /// \class AliMpSector
@@ -116,18 +116,18 @@ class AliMpSector : public TNamed
     void SetNofPads();
 
     // data members        
-    TString    fID;       // sector ID
-    TVector2   fOffset;   // sector position
-    ZoneVector fZones;    // zones
-    RowVector  fRows;     // rows
-    AliMpMotifMap* fMotifMap; // motif map
-    AliMpDirection fDirection;// the direction of constant pad size
-    TVector2       fMinPadDimensions; // minimal pad dimensions
-    AliMpIntPair   fMaxPadIndices;    // maximum pad indices    
-    Int_t          fNofPads;     //  total number of pads
-
-
-  ClassDef(AliMpSector,1)  //Sector
+    TString    fID;       ///< sector ID
+    TVector2   fOffset;   ///< sector position
+    ZoneVector fZones;    ///< zones
+    RowVector  fRows;     ///< rows
+    AliMpMotifMap* fMotifMap; ///< motif map
+    AliMpDirection fDirection;///< the direction of constant pad size
+    TVector2       fMinPadDimensions; ///< minimal pad dimensions
+    AliMpIntPair   fMaxPadIndices;    ///< maximum pad indices    
+    Int_t          fNofPads;          ///<  total number of pads
+
+
+  ClassDef(AliMpSector,1)  // Sector
 };
 
 // inline functions
index c743149..ce30a03 100755 (executable)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpSectorAreaHPadIterator.h,v 1.5 2005/08/26 15:43:36 ivana Exp $
+// $MpId: AliMpSectorAreaHPadIterator.h,v 1.6 2006/05/23 13:07:44 ivana Exp $
 
 /// \ingroup sector
 /// \class AliMpSectorAreaHPadIterator
@@ -46,13 +46,13 @@ class AliMpSectorAreaHPadIterator : public AliMpVPadIterator
     void MoveUp();
 
     // private data members
-    const AliMpSectorSegmentation*  fkSegmentation; // the sector segmentation 
-                                    // over which we iterate
-    //const AliMpArea  fkArea;         // the area
-                                       // (const caused problem with CINT)
-    AliMpArea  fkArea;                 // the area
-    AliMpPad   fCurrentPad;         // the current pad
-    Double_t   fCurrentRowPosition; // the current row position
+    const AliMpSectorSegmentation*  fkSegmentation; ///< \brief the sector segmentation 
+                                    /// over which we iterate
+    //const AliMpArea  fkArea;      ///< \brief the area
+                                    /// (const caused problem with CINT)
+    AliMpArea  fkArea;              ///< the area
+    AliMpPad   fCurrentPad;         ///< the current pad
+    Double_t   fCurrentRowPosition; ///< the current row position
 
  ClassDef(AliMpSectorAreaHPadIterator,1) // iterator over motif's pads
 };
index 4f7a925..2dbe37e 100644 (file)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpSectorAreaVPadIterator.h,v 1.5 2006/03/17 11:38:28 ivana Exp $
+// $MpId: AliMpSectorAreaVPadIterator.h,v 1.6 2006/05/23 13:07:44 ivana Exp $
 
 /// \ingroup sector
 /// \class AliMpSectorAreaVPadIterator
@@ -46,13 +46,13 @@ class AliMpSectorAreaVPadIterator : public AliMpVPadIterator
     void MoveRight();
 
     // private data members
-    const AliMpSectorSegmentation*  fkSegmentation; // the sector segmentation 
-                                       // over which we iterate
-    //const AliMpArea  fkArea;            // the area
-                                          // (const caused problem with CINT)
-    AliMpArea  fkArea;                 // the area
-    AliMpPad   fCurrentPad;            // the current pad
-    Double_t   fCurrentColumnPosition; // the current column position
+    const AliMpSectorSegmentation*  fkSegmentation; ///< \brief the sector segmentation 
+                                       /// over which we iterate
+    //const AliMpArea  fkArea;         ///< \brief the area
+                                       /// (const caused problem with CINT)
+    AliMpArea  fkArea;                 ///< the area
+    AliMpPad   fCurrentPad;            ///< the current pad
+    Double_t   fCurrentColumnPosition; ///< the current column position
 
  ClassDef(AliMpSectorAreaVPadIterator,1) // iterator over motif's pads
 };
index b649e34..7a4883e 100755 (executable)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpSectorPadIterator.h,v 1.5 2005/08/26 15:43:36 ivana Exp $
+// $MpId: AliMpSectorPadIterator.h,v 1.6 2006/05/23 13:07:44 ivana Exp $
 
 /// \ingroup sector
 /// \class AliMpSectorPadIterator
@@ -44,12 +44,12 @@ class AliMpSectorPadIterator : public AliMpVPadIterator
     Bool_t IsValid() const;
 
     // private data members
-    const AliMpSector*  fkSector; // the sector over which to iterate
-    Int_t  fCurrentRow;       // the current row number
-    Int_t  fCurrentSeg;       // the current Row Segment number in fCurrentRow
-    Int_t  fCurrentMotif;     // the current motif number in fCurrentSeg
-    AliMpMotifPosition* fMotifPos; // the current motif position
-    AliMpMotifPositionPadIterator  fIterator; // iterator over the current motif type
+    const AliMpSector*  fkSector; ///< the sector over which to iterate
+    Int_t  fCurrentRow;       ///< the current row number
+    Int_t  fCurrentSeg;       ///< the current Row Segment number in fCurrentRow
+    Int_t  fCurrentMotif;     ///< the current motif number in fCurrentSeg
+    AliMpMotifPosition* fMotifPos; ///< the current motif position
+    AliMpMotifPositionPadIterator  fIterator; ///< iterator over the current motif type
 
  ClassDef(AliMpSectorPadIterator,1) // iterator over motif's pads
 };
index a7e0b18..cdfb478 100755 (executable)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpSectorPainter.h,v 1.6 2005/08/26 15:43:36 ivana Exp $
+// $MpId: AliMpSectorPainter.h,v 1.7 2006/05/23 13:07:35 ivana Exp $
 
 /// \ingroup graphics
 /// \class AliMpSectorPainter
@@ -35,7 +35,8 @@ class AliMpSectorPainter : public AliMpVPainter
   AliMpSectorPainter&  operator = (const AliMpSectorPainter& right);
 
  private:
-  AliMpSector *fSector;          // the sector to draw
+  AliMpSector *fSector; ///< the sector to draw
+
   ClassDef(AliMpSectorPainter,1) // Sector painter
 };
 #endif //ALI_MP_SECTOR_PAINTER_H
index a12111b..8391ca7 100755 (executable)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpSectorReader.h,v 1.5 2006/03/17 11:38:28 ivana Exp $
+// $MpId: AliMpSectorReader.h,v 1.6 2006/05/23 13:07:44 ivana Exp $
 
 /// \ingroup sector
 /// \class AliMpSectorReader
@@ -64,22 +64,22 @@ class AliMpSectorReader : public TObject
                          AliMpXDirection direction);
     
     // static data members
-    static const TString  fgkSectorKeyword;        // sector keyword
-    static const TString  fgkZoneKeyword;          // zone keyword
-    static const TString  fgkSubZoneKeyword;       // subzone keyword
-    static const TString  fgkRowKeyword;           // row keyword
-    static const TString  fgkEofKeyword;           // eof keyword
-    static const TString  fgkSectorSpecialKeyword; // sector special keyword
-    static const TString  fgkMotifKeyword;         // motif keyword
-    static const TString  fgkRowSpecialKeyword;    // row special keyword
-    static const TString  fgkPadRowsKeyword;       // pad rows keyword
-    static const TString  fgkPadRowSegmentKeyword; // pad row segment keyword
+    static const TString  fgkSectorKeyword;        ///< sector keyword
+    static const TString  fgkZoneKeyword;          ///< zone keyword
+    static const TString  fgkSubZoneKeyword;       ///< subzone keyword
+    static const TString  fgkRowKeyword;           ///< row keyword
+    static const TString  fgkEofKeyword;           ///< eof keyword
+    static const TString  fgkSectorSpecialKeyword; ///< sector special keyword
+    static const TString  fgkMotifKeyword;         ///< motif keyword
+    static const TString  fgkRowSpecialKeyword;    ///< row special keyword
+    static const TString  fgkPadRowsKeyword;       ///< pad rows keyword
+    static const TString  fgkPadRowSegmentKeyword; ///< pad row segment keyword
   
     // data members  
-    AliMpStationType  fStationType; // station type 
-    AliMpPlaneType    fPlaneType;   // plane type 
-    AliMpSector*      fSector;      // sector
-    AliMpMotifReader* fMotifReader; // motif reader
+    AliMpStationType  fStationType; ///< station type 
+    AliMpPlaneType    fPlaneType;   ///< plane type 
+    AliMpSector*      fSector;      ///< sector
+    AliMpMotifReader* fMotifReader; ///< motif reader
 
   ClassDef(AliMpSectorReader,1)  // Data reader
 };
index 49d129d..27ed6dc 100755 (executable)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpSectorSegmentation.h,v 1.13 2006/03/17 11:38:28 ivana Exp $
+// $MpId: AliMpSectorSegmentation.h,v 1.14 2006/05/23 13:07:44 ivana Exp $
 
 /// \ingroup sector
 /// \class AliMpSectorSegmentation
@@ -115,18 +115,17 @@ protected:
                                      Double_t maxY) const;
  
     // data members        
-    const AliMpSector*  fkSector;   // Sector
-    AliMpPad*           fPadBuffer; // The pad buffer
+    const AliMpSector*  fkSector;   ///< Sector
+    AliMpPad*           fPadBuffer; ///< The pad buffer
 #ifdef WITH_STL
-    PadDimensionsMap    fPadDimensionsMap; // Map between zone IDs and pad dimensions
-                              // EXCLUDED FOR CINT (does not compile on HP)    
+    PadDimensionsMap    fPadDimensionsMap; ///< Map between zone IDs and pad dimensions
 #endif    
 #ifdef WITH_ROOT
-    mutable PadDimensionsMap  fPadDimensionsMap; //  Map between zone IDs and pad dimensions
+    mutable PadDimensionsMap  fPadDimensionsMap; ///< Map between zone IDs and pad dimensions
 #endif 
 
-    Int_t  fMaxIndexInX;  // maximum pad index in x    
-    Int_t  fMaxIndexInY;  // maximum pad index in y    
+    Int_t  fMaxIndexInX;  ///< maximum pad index in x    
+    Int_t  fMaxIndexInY;  ///< maximum pad index in y    
 
   ClassDef(AliMpSectorSegmentation,1)  // Segmentation
 };
index a6a8a9f..d5b0bf2 100644 (file)
@@ -5,7 +5,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$ 
-// $MpId: AliMpSegFactory.h,v 1.5 2006/03/17 11:35:58 ivana Exp $ 
+// $MpId: AliMpSegFactory.h,v 1.6 2006/05/23 13:07:38 ivana Exp $ 
 
 /// \ingroup management
 /// \class AliMpSegFactory
@@ -53,10 +53,10 @@ class AliMpSegFactory : public  TObject {
   
   private:
 
-    AliMpStringObjMap  fMpSegmentations;// Map of mapping segmentations to DE names
-    AliMpExMap*        fMpMap;          // Map of el. cards IDs to segmentations
+    AliMpStringObjMap  fMpSegmentations;///< Map of mapping segmentations to DE names
+    AliMpExMap*        fMpMap;          ///< Map of el. cards IDs to segmentations
       
-  ClassDef(AliMpSegFactory,0)  // MUON Factory for Chambers and Segmentation
+  ClassDef(AliMpSegFactory,0)  // The factory for building mapping segmentations
 };
 
 #endif //ALI_MP_SEG_FACTORY_H
index 1030e08..b7c8d9b 100644 (file)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpSlat.h,v 1.5 2006/03/17 16:42:28 ivana Exp $
+// $MpId: AliMpSlat.h,v 1.7 2006/05/23 13:07:47 ivana Exp $
 
 /// \ingroup slat
 /// \class AliMpSlat
@@ -144,20 +144,20 @@ class AliMpSlat : public TObject
   AliMpSlat& operator=(const AliMpSlat& rhs);
   
  private:
-  TString fId; // The name of this slat, e.g. 112233N
-  AliMpPlaneType fPlaneType; // Whether it's bending or non-bending plane
-  Double_t fDX; // Half-size in X (cm)
-  Double_t fDY; // Half-size in Y (cm)
-  Int_t fNofPadsX; // Actual number of pads in x direction
-  Int_t fMaxNofPadsY; // Maximum number of pads in y direction
-  mutable AliMpExMap fManuMap; // map of int to AliMpMotifPosition*
+  TString fId; ///< The name of this slat, e.g. 112233N
+  AliMpPlaneType fPlaneType; ///< Whether it's bending or non-bending plane
+  Double_t fDX; ///< Half-size in X (cm)
+  Double_t fDY; ///< Half-size in Y (cm)
+  Int_t fNofPadsX; ///< Actual number of pads in x direction
+  Int_t fMaxNofPadsY; ///< Maximum number of pads in y direction
+  mutable AliMpExMap fManuMap; ///< map of int to AliMpMotifPosition*
 #ifdef WITH_ROOT
-  TObjArray fPCBs; // array of AliMpPCB*
+  TObjArray fPCBs; ///< array of AliMpPCB*
 #else  
-  std::vector<AliMpPCB*> fPCBs; // array of AliMpPCB*
+  std::vector<AliMpPCB*> fPCBs; ///< array of AliMpPCB*
 #endif
-  TVector2 fPosition; // Position of the slat center.
-  Int_t fNofPads; // number of pads in this slat
+  TVector2 fPosition; ///< Position of the slat center.
+  Int_t fNofPads; ///< number of pads in this slat
   
   ClassDef(AliMpSlat,2) // A slat for stations 3,4,5
 };
index b759ca5..b29224e 100644 (file)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpSlatPadIterator.h,v 1.4 2005/09/19 19:01:09 ivana Exp $
+// $MpId: AliMpSlatPadIterator.h,v 1.7 2006/05/23 13:07:47 ivana Exp $
 
 /// \ingroup slat
 /// \class AliMpSlatPadIterator
@@ -40,10 +40,10 @@ class AliMpSlatPadIterator : public AliMpVPadIterator
   AliMpArea Intersect(const AliMpArea& a, const AliMpArea& b) const;
 
  private:
-  const AliMpSlat* fkSlat; // pointer to the slat being iterated over
-  std::vector<AliMpVPadIterator*> fDelegates; // iterators we do use
-  AliMpVPadIterator* fCurrentDelegate; // current iterator
-  UInt_t fCurrentDelegateIndex; // current iterator index
+  const AliMpSlat* fkSlat; ///< pointer to the slat being iterated over
+  std::vector<AliMpVPadIterator*> fDelegates; ///< iterators we do use
+  AliMpVPadIterator* fCurrentDelegate; ///< current iterator
+  UInt_t fCurrentDelegateIndex; ///< current iterator index
 
   ClassDef(AliMpSlatPadIterator,1) // Pad iterator for St 345 Slats
 };
index abcbc8e..010a9f9 100644 (file)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpSlatPainter.h,v 1.6 2005/09/19 18:56:46 ivana Exp $
+// $MpId: AliMpSlatPainter.h,v 1.9 2006/05/23 13:07:35 ivana Exp $
 
 /// \ingroup graphics
 /// \class AliMpSlatPainter
@@ -40,7 +40,7 @@ class AliMpSlatPainter : public AliMpVPainter
      
   
  private:
-  const AliMpSlat* fkSlat; //! pointer to the slat to be drawn
+  const AliMpSlat* fkSlat; //!< pointer to the slat to be drawn
 
   ClassDef(AliMpSlatPainter,1) // A painter for a slat of stations 3,4,5
 };
index fa8692a..eef4b4d 100644 (file)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpSlatSegmentation.h,v 1.9 2006/03/14 09:04:25 ivana Exp $
+// $MpId: AliMpSlatSegmentation.h,v 1.11 2006/05/23 13:07:47 ivana Exp $
 
 /// \ingroup slat
 /// \class AliMpSlatSegmentation
@@ -75,7 +75,7 @@ class AliMpSlatSegmentation : public AliMpVSegmentation
   AliMpSlatSegmentation&  operator = (const AliMpSlatSegmentation& right);
      
  private:
-  const AliMpSlat* fkSlat; // Slat
+  const AliMpSlat* fkSlat; ///< Slat
 
   ClassDef(AliMpSlatSegmentation,1) // A slat for stations 3,4,5
 };
index c17d666..a9b95d7 100644 (file)
@@ -5,7 +5,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpSlatZonePadIterator.h,v 1.3 2005/08/26 15:42:32 ivana Exp $
+// $MpId: AliMpSlatZonePadIterator.h,v 1.6 2006/05/23 13:07:47 ivana Exp $
 
 /// \ingroup slat
 /// \class AliMpSlatZonePadIterator
@@ -41,16 +41,16 @@ class AliMpSlatZonePadIterator : public AliMpVPadIterator
   void SetPad(AliMpPad& pad, const TVector2& pos);
 
  private:
-  const AliMpSlat*       fkSlat; //! the slat we're iterating over
-  AliMpSlatSegmentation* fSlatSegmentation; //! segmentation pointer
-  AliMpArea  fArea; //! area we're iterating over
-  TVector2   fOffset; //! current position (relative to bottom-left of area)
-  TVector2   fStep; //! step sizes
-  AliMpPad   fCurrentPad; //! current pad
-  Bool_t     fIsDone; //! whether we've finished or not
-
-  static const Double_t fgkDmax; // maximum double
-  static const Double_t fgkEpsilon; // comparison precision 
+  const AliMpSlat*       fkSlat; //!< the slat we're iterating over
+  AliMpSlatSegmentation* fSlatSegmentation; //!< segmentation pointer
+  AliMpArea  fArea; //!< area we're iterating over
+  TVector2   fOffset; //!< current position (relative to bottom-left of area)
+  TVector2   fStep; //!< step sizes
+  AliMpPad   fCurrentPad; //!< current pad
+  Bool_t     fIsDone; //!< whether we've finished or not
+
+  static const Double_t fgkDmax; ///< maximum double
+  static const Double_t fgkEpsilon; ///< comparison precision 
 
   ClassDef(AliMpSlatZonePadIterator,1) // Pad iterator for a zone of constant density, for St345.
 };
index e038094..fd659ce 100644 (file)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpSt345Reader.h,v 1.4 2005/09/19 19:01:09 ivana Exp $
+// $MpId: AliMpSt345Reader.h,v 1.6 2006/05/23 13:07:47 ivana Exp $
 
 /// \ingroup slat
 /// \class AliMpSt345Reader
@@ -47,7 +47,7 @@ class AliMpSt345Reader : public TObject
 
        static AliMpPCB* PCB(const char* pcbType); 
 
-  static TMap fgPCBMap; // map of TObjString to AliMpPCB*
+  static TMap fgPCBMap; ///< map of TObjString to AliMpPCB*
 
   ClassDef(AliMpSt345Reader,1) // Reader for slat stations mapping files 
 };
index ccc4019..e84a304 100644 (file)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpStationType.h,v 1.7 2006/03/17 11:34:29 ivana Exp $
+// $MpId: AliMpStationType.h,v 1.8 2006/05/23 13:07:29 ivana Exp $
 
 /// \ingroup basic
 /// \enum AliMpStationType
index a39bbc4..a76ca3a 100644 (file)
@@ -38,9 +38,9 @@ class AliMpStringObjMap : public TObject
  
   private:
     // data members
-    Int_t      fNofItems;    // number of items
-    TObjArray  fFirstArray;  // first item array
-    TObjArray  fSecondArray; // second item array
+    Int_t      fNofItems;    ///<  number of items
+    TObjArray  fFirstArray;  ///<  first item array
+    TObjArray  fSecondArray; ///<  second item array
  
   ClassDef(AliMpStringObjMap,1)  // motif map
 };    
index c88d05f..cfbc5bf 100755 (executable)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpSubZone.h,v 1.9 2006/03/17 11:38:28 ivana Exp $
+// $MpId: AliMpSubZone.h,v 1.10 2006/05/23 13:07:44 ivana Exp $
 
 /// \ingroup sector
 /// \class AliMpSubZone
@@ -59,10 +59,10 @@ class AliMpSubZone : public TObject
 
   private:
     // data members
-    AliMpVMotif*     fMotif;   // the motif in this subzone
-    RowSegmentVector fSegments;// contained row segments
+    AliMpVMotif*     fMotif;   ///< the motif in this subzone
+    RowSegmentVector fSegments;///< contained row segments
     
-  ClassDef(AliMpSubZone,1)  //Zone segment
+  ClassDef(AliMpSubZone,1)  // Zone segment
 };
 
 #endif //ALI_MP_SUB_ZONE_H
index 0696402..08774a6 100755 (executable)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpSubZonePainter.h,v 1.6 2005/08/26 15:43:36 ivana Exp $
+// $MpId: AliMpSubZonePainter.h,v 1.7 2006/05/23 13:07:35 ivana Exp $
 
 /// \ingroup graphics
 /// \class AliMpSubZonePainter
@@ -37,7 +37,8 @@ class AliMpSubZonePainter : public AliMpVPainter
   AliMpSubZonePainter&  operator = (const AliMpSubZonePainter& right);
 
  private: 
-  AliMpSubZone *fSubZone;         // the subzone to draw
+  AliMpSubZone *fSubZone; ///< the subzone to draw
+
   ClassDef(AliMpSubZonePainter,1) // SubZone painter
 };
 #endif //ALI_MP_SUBZONE_PAINTER_H
index da91ea5..505f105 100644 (file)
@@ -2,7 +2,7 @@
 * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpTrigger.h,v 1.2 2006/03/02 16:35:27 ivana Exp $
+// $MpId: AliMpTrigger.h,v 1.4 2006/05/23 13:07:51 ivana Exp $
 
 /// \ingroup trigger
 /// \class AliMpTrigger
@@ -75,12 +75,12 @@ private:
     
   Bool_t IsLayerValid(int layer) const;
   
-  TString fId; // name of that slat
-  AliMpPlaneType fPlaneType; // bending or non-bending
-  TObjArray fSlats; // virtual slat composing this trigger slat
-  Int_t fMaxNofPadsY; // max number of pads in y direction
-  Double_t fDX; // half-size in x (cm)
-  Double_t fDY; // half-size in y (cm)
+  TString fId; ///< name of that slat
+  AliMpPlaneType fPlaneType; ///< bending or non-bending
+  TObjArray fSlats; ///< virtual slat composing this trigger slat
+  Int_t fMaxNofPadsY; ///< max number of pads in y direction
+  Double_t fDX; ///< half-size in x (cm)
+  Double_t fDY; ///< half-size in y (cm)
   
   ClassDef(AliMpTrigger,3) // Slat for trigger
 };
index d2bcd93..775ab45 100644 (file)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpTriggerReader.h,v 1.2 2006/03/02 16:36:26 ivana Exp $
+// $MpId: AliMpTriggerReader.h,v 1.4 2006/05/23 13:07:51 ivana Exp $
 
 /// \ingroup trigger
 /// \class AliMpTriggerReader
@@ -86,15 +86,15 @@ private:
   
 private:
     
-  static TMap fgPCBMap; //! map of TObjString to AliMpPCB*
+  static TMap fgPCBMap; //!< map of TObjString to AliMpPCB*
   
-  static TMap fgLocalBoardMap; //! map of TObjString to TObjString
+  static TMap fgLocalBoardMap; //!< map of TObjString to TObjString
 
-  static const TString fgkKeywordLayer; //! Keyword: LAYER
-  static const TString fgkKeywordScale; //! Keyword: SCALE
-  static const TString fgkKeywordPcb; //! Keyword : PCB
-  static const TString fgkKeywordFlipX; //! Keyword : FLIPX
-  static const TString fgkKeywordFlipY; //! Keyword : FLIPY
+  static const TString fgkKeywordLayer; //!< Keyword: LAYER
+  static const TString fgkKeywordScale; //!< Keyword: SCALE
+  static const TString fgkKeywordPcb; //!< Keyword : PCB
+  static const TString fgkKeywordFlipX; //!< Keyword : FLIPX
+  static const TString fgkKeywordFlipY; //!< Keyword : FLIPY
   
   ClassDef(AliMpTriggerReader,1) // Reader for trigger slats mapping files 
 };
index 922a3eb..d9cc21e 100644 (file)
@@ -2,7 +2,7 @@
 * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpTriggerSegmentation.h,v 1.5 2006/03/17 16:42:36 ivana Exp $
+// $MpId: AliMpTriggerSegmentation.h,v 1.7 2006/05/23 13:07:51 ivana Exp $
 
 /// \ingroup trigger
 /// \class AliMpTriggerSegmentation
@@ -67,8 +67,9 @@ protected:
   AliMpTriggerSegmentation&  operator = (const AliMpTriggerSegmentation& right);
      
 private:
-    const AliMpTrigger* fkSlat; // Slat
-  Int_t fNofStrips; // Number of strips in this slat
+  const AliMpTrigger* fkSlat; ///< Slat
+  Int_t fNofStrips; ///< Number of strips in this slat
+
   ClassDef(AliMpTriggerSegmentation,2) // Segmentation for slat trigger stations
 };
 
index 2b28d8c..7de2624 100755 (executable)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpVIndexed.h,v 1.5 2005/08/26 15:43:36 ivana Exp $
+// $MpId: AliMpVIndexed.h,v 1.6 2006/05/23 13:07:29 ivana Exp $
 
 /// \ingroup basic
 /// \class AliMpVIndexed
@@ -42,8 +42,8 @@ class AliMpVIndexed : public TObject
 
  private:
   // data members 
-  AliMpIntPair   fLowIndicesLimit;  // the lowest global pad indices 
-  AliMpIntPair   fHighIndicesLimit; // the hihgest global pad indices 
+  AliMpIntPair   fLowIndicesLimit;  ///<  the lowest global pad indices 
+  AliMpIntPair   fHighIndicesLimit; ///<  the hihgest global pad indices 
 
   ClassDef(AliMpVIndexed,1) // A motif position
 };
index df7540b..583759a 100755 (executable)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpVMotif.h,v 1.6 2005/08/26 15:43:36 ivana Exp $
+// $MpId: AliMpVMotif.h,v 1.7 2006/05/23 13:07:42 ivana Exp $
 
 /// \ingroup motif
 /// \class AliMpVMotif
@@ -52,8 +52,8 @@ class AliMpVMotif : public TObject
   // methods
 
   // data members 
-  TString         fID;            //identifier
-  AliMpMotifType *fMotifType;     //the motif type
+  TString         fID;        ///< identifier
+  AliMpMotifType *fMotifType; ///< the motif type
 
   ClassDef(AliMpVMotif,1) // A motif with its ID
 };
index 72c997b..ae091ba 100755 (executable)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpVPadIterator.h,v 1.4 2005/08/26 15:43:36 ivana Exp $
+// $MpId: AliMpVPadIterator.h,v 1.5 2006/05/23 13:07:29 ivana Exp $
 
 /// \ingroup basic
 /// \class AliMpVPadIterator
index 6e5a724..3a1094d 100755 (executable)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpVPadRowSegment.h,v 1.5 2005/08/26 15:43:36 ivana Exp $
+// $MpId: AliMpVPadRowSegment.h,v 1.6 2006/05/23 13:07:44 ivana Exp $
 
 /// \ingroup sector
 /// \class AliMpVPadRowSegment
@@ -49,13 +49,13 @@ class AliMpVPadRowSegment : public TObject
 
   private:
     // data members
-    Int_t         fNofPads;  //number of pads
-    Double_t      fOffsetX;  //the x position of the right/left border
-    AliMpPadRow*  fPadRow;   //the pad row containing this segment 
-    AliMpMotif*   fMotif;    //the motif 
-    Int_t         fMotifPositionId;  // the motif position id
+    Int_t         fNofPads;  ///< number of pads
+    Double_t      fOffsetX;  ///< the x position of the right/left border
+    AliMpPadRow*  fPadRow;   ///< the pad row containing this segment 
+    AliMpMotif*   fMotif;    ///< the motif 
+    Int_t         fMotifPositionId;  ///< the motif position id
     
-  ClassDef(AliMpVPadRowSegment,1)  //Row segment
+  ClassDef(AliMpVPadRowSegment,1)  // Row segment
 };
 
 #endif //ALI_MP_V_PAD_ROW_SEGMENT_H
index ee4af4b..b24e830 100755 (executable)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpVPainter.h,v 1.6 2005/08/26 15:43:36 ivana Exp $
+// $MpId: AliMpVPainter.h,v 1.7 2006/05/23 13:07:35 ivana Exp $
 
 /// \ingroup graphics
 /// \class AliMpVPainter
@@ -58,10 +58,11 @@ class AliMpVPainter : public TObject
   AliMpVPainter *DrawObject(TObject *object,Option_t *option="");
 
  private:
-  Int_t fColor;               //  color
-  TVector2 fPadPosition;      // position inside the graphics pad
-  TVector2 fPadDimensions;    // dimensions inside the graphics pad
-  TList *fTrashList;           // list of painter object created
+  Int_t fColor;            ///< color
+  TVector2 fPadPosition;   ///< position inside the graphics pad
+  TVector2 fPadDimensions; ///< dimensions inside the graphics pad
+  TList *fTrashList;       ///< list of painter object created
+
   ClassDef(AliMpVPainter,1) // abstract object painter
 };
 
index a334ce2..dfbe561 100755 (executable)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpVRowSegment.h,v 1.7 2006/03/17 11:38:28 ivana Exp $
+// $MpId: AliMpVRowSegment.h,v 1.8 2006/05/23 13:07:44 ivana Exp $
 
 /// \ingroup sector
 /// \class AliMpVRowSegment
index 88d60d2..f928233 100644 (file)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpVRowSegmentSpecial.h,v 1.8 2006/03/17 11:38:28 ivana Exp $
+// $MpId: AliMpVRowSegmentSpecial.h,v 1.9 2006/05/23 13:07:44 ivana Exp $
 
 /// \ingroup sector
 /// \class AliMpVRowSegmentSpecial
@@ -107,15 +107,15 @@ class AliMpVRowSegmentSpecial : public AliMpVRowSegment
 #endif    
 
     // data members
-    AliMpRow*     fRow;     //the row containing this segment 
-    Double_t      fOffsetX; //the x position of the border that touches a standard
-                            //row segment
-    PadRowVector  fPadRows; //pad rows vector
-    MotifVector   fMotifs;  //motifs vector
-    MotifPositionIdVector  fMotifPositionIds; //motifs position Ids vector
+    AliMpRow*     fRow;     ///< the row containing this segment 
+    Double_t      fOffsetX; ///< \brief the x position of the border that touches a standard
+                            /// row segment
+    PadRowVector  fPadRows; ///< pad rows vector
+    MotifVector   fMotifs;  ///< motifs vector
+    MotifPositionIdVector  fMotifPositionIds; ///< motifs position Ids vector
 
 #ifdef WITH_ROOT
-    Int_t  fNofMotifPositionIds; // number of motif positions Ids
+    Int_t  fNofMotifPositionIds; ///< number of motif positions Ids
 #endif    
     
   ClassDef(AliMpVRowSegmentSpecial,1)  //Row segment
index 81e33ff..551d497 100644 (file)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpVSegmentation.h,v 1.10 2006/03/17 11:34:29 ivana Exp $
+// $MpId: AliMpVSegmentation.h,v 1.11 2006/05/23 13:07:29 ivana Exp $
 
 /// \ingroup basic
 /// \class AliMpVSegmentation
index d526f79..1b203ed 100644 (file)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpXDirection.h,v 1.4 2005/08/26 15:43:36 ivana Exp $
+// $MpId: AliMpXDirection.h,v 1.5 2006/05/23 13:07:29 ivana Exp $
 
 /// \ingroup basic
 /// \enum  AliMpDirection
index c7ab8dc..cc8be97 100755 (executable)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpZone.h,v 1.8 2006/03/17 11:38:28 ivana Exp $
+// $MpId: AliMpZone.h,v 1.9 2006/05/23 13:07:44 ivana Exp $
 
 /// \ingroup sector
 /// \class AliMpZone
@@ -64,11 +64,11 @@ class AliMpZone : public TObject
 
   private:
     // data members
-    UInt_t        fID;           // ID
-    SubZoneVector fSubZones;     // subzones
-    TVector2      fPadDimensions;// pad dimensions
+    UInt_t        fID;           ///< ID
+    SubZoneVector fSubZones;     ///< subzones
+    TVector2      fPadDimensions;///< pad dimensions
 
-  ClassDef(AliMpZone,1)  //Zone
+  ClassDef(AliMpZone,1)  // Zone
 };
 
 // inline functions
index d8e7a0e..0d77e43 100755 (executable)
@@ -2,7 +2,7 @@
  * See cxx source for full Copyright notice                               */
 
 // $Id$
-// $MpId: AliMpZonePainter.h,v 1.6 2005/08/26 15:43:36 ivana Exp $
+// $MpId: AliMpZonePainter.h,v 1.7 2006/05/23 13:07:35 ivana Exp $
 
 /// \ingroup graphics
 /// \class AliMpZonePainter
@@ -38,7 +38,8 @@ class AliMpZonePainter : public AliMpVPainter
   AliMpZonePainter&  operator = (const AliMpZonePainter& right);
 
  private: 
-  AliMpZone *fZone;            // the zone to draw
+  AliMpZone *fZone; ///< the zone to draw
+
   ClassDef(AliMpZonePainter,1) // Zone painter
 };
 #endif //ALI_MP_ZONE_PAINTER_H