From 829425a512355433c2b59d05ddb13e541094c2ea Mon Sep 17 00:00:00 2001 From: ivana Date: Tue, 23 May 2006 16:08:52 +0000 Subject: [PATCH] Updated comments for Doxygen --- MUON/AliMUONBlockHeader.h | 14 +-- MUON/AliMUONBusStruct.h | 18 ++-- MUON/AliMUONClusterDrawAZ.h | 20 ++-- MUON/AliMUONClusterFinderAZ.h | 48 +++++----- MUON/AliMUONClusterFinderVS.h | 66 ++++++------- MUON/AliMUONClusterInput.h | 40 ++++---- MUON/AliMUONClusterReconstructor.h | 8 +- MUON/AliMUONDDLTracker.h | 2 +- MUON/AliMUONDDLTrigger.h | 2 +- MUON/AliMUONDarcHeader.h | 44 ++++----- MUON/AliMUONDetElement.h | 24 ++--- MUON/AliMUONDigitCalibrator.h | 4 +- MUON/AliMUONDigitMaker.h | 24 ++--- MUON/AliMUONDigitizer.h | 26 +++--- MUON/AliMUONDigitizerV3.h | 28 +++--- MUON/AliMUONDspHeader.h | 16 ++-- MUON/AliMUONEventRecoCombi.h | 10 +- MUON/AliMUONGeometry.h | 4 +- MUON/AliMUONGeometryBuilder.h | 26 +++--- MUON/AliMUONGeometryConstituent.h | 11 ++- MUON/AliMUONGeometryDetElement.h | 8 +- MUON/AliMUONGeometryEnvelope.h | 22 ++--- MUON/AliMUONGeometryEnvelopeStore.h | 18 ++-- MUON/AliMUONGeometryMisAligner.h | 22 ++--- MUON/AliMUONGeometryModule.h | 16 ++-- MUON/AliMUONGeometryModuleTransformer.h | 12 +-- MUON/AliMUONGeometrySegmentation.h | 16 ++-- MUON/AliMUONGeometryStore.h | 6 +- MUON/AliMUONGeometryTransformer.h | 4 +- MUON/AliMUONGlobalTriggerBoard.h | 4 +- MUON/AliMUONHitForRec.h | 30 +++--- MUON/AliMUONLocalStruct.h | 36 +++---- MUON/AliMUONLocalTriggerBoard.h | 38 ++++---- MUON/AliMUONPixel.h | 8 +- MUON/AliMUONRawStreamTracker.h | 32 +++---- MUON/AliMUONRawStreamTrigger.h | 20 ++-- MUON/AliMUONRawWriter.h | 40 ++++---- MUON/AliMUONRecoTrack.h | 14 +-- MUON/AliMUONReconstructor.h | 6 +- MUON/AliMUONRegHeader.h | 20 ++-- MUON/AliMUONRegionalTriggerBoard.h | 4 +- MUON/AliMUONResponseFactory.h | 4 +- MUON/AliMUONResponseTrigger.h | 4 +- MUON/AliMUONResponseTriggerV1.h | 8 +- MUON/AliMUONResponseV0.h | 22 ++--- MUON/AliMUONSegment.h | 32 +++---- MUON/AliMUONSegmentation.h | 8 +- MUON/AliMUONStringIntMap.h | 6 +- MUON/AliMUONTest.h | 6 +- MUON/AliMUONTrack.h | 28 +++--- MUON/AliMUONTrackHit.h | 8 +- MUON/AliMUONTrackK.h | 74 +++++++-------- MUON/AliMUONTrackParam.h | 12 +-- MUON/AliMUONTrackReconstructor.h | 98 ++++++++++---------- MUON/AliMUONTrigger.h | 6 +- MUON/AliMUONTriggerBoard.h | 4 +- MUON/AliMUONTriggerCrate.h | 8 +- MUON/AliMUONTriggerDecision.h | 77 ++++++++------- MUON/AliMUONTriggerDecisionV1.h | 66 +++++++------ MUON/AliMUONTriggerElectronics.h | 10 +- MUON/AliMUONTriggerTrack.h | 10 +- MUON/AliMUONVGeometryBuilder.h | 10 +- MUON/mapping/AliMpArea.h | 8 +- MUON/mapping/AliMpBusPatch.h | 10 +- MUON/mapping/AliMpConnection.h | 12 +-- MUON/mapping/AliMpConstants.h | 14 +-- MUON/mapping/AliMpContainers.h | 4 +- MUON/mapping/AliMpDEIterator.h | 14 +-- MUON/mapping/AliMpDEManager.h | 18 ++-- MUON/mapping/AliMpExMap.h | 24 ++--- MUON/mapping/AliMpFiles.h | 32 +++---- MUON/mapping/AliMpGraphContext.h | 20 ++-- MUON/mapping/AliMpHelper.h | 2 +- MUON/mapping/AliMpIntPair.h | 10 +- MUON/mapping/AliMpMotif.h | 4 +- MUON/mapping/AliMpMotifMap.h | 12 +-- MUON/mapping/AliMpMotifPainter.h | 4 +- MUON/mapping/AliMpMotifPosition.h | 8 +- MUON/mapping/AliMpMotifPositionPadIterator.h | 6 +- MUON/mapping/AliMpMotifReader.h | 6 +- MUON/mapping/AliMpMotifSpecial.h | 8 +- MUON/mapping/AliMpMotifType.h | 16 ++-- MUON/mapping/AliMpMotifTypePadIterator.h | 6 +- MUON/mapping/AliMpNeighboursPadIterator.h | 12 +-- MUON/mapping/AliMpPCB.h | 30 +++--- MUON/mapping/AliMpPCBPainter.h | 4 +- MUON/mapping/AliMpPad.h | 18 ++-- MUON/mapping/AliMpPadIteratorPtr.h | 4 +- MUON/mapping/AliMpPadPair.h | 6 +- MUON/mapping/AliMpPadRow.h | 12 +-- MUON/mapping/AliMpPadRowLSegment.h | 4 +- MUON/mapping/AliMpPadRowRSegment.h | 4 +- MUON/mapping/AliMpPlaneType.h | 2 +- MUON/mapping/AliMpRow.h | 12 +-- MUON/mapping/AliMpRowPainter.h | 5 +- MUON/mapping/AliMpRowSegment.h | 20 ++-- MUON/mapping/AliMpRowSegmentLSpecial.h | 4 +- MUON/mapping/AliMpRowSegmentPainter.h | 5 +- MUON/mapping/AliMpRowSegmentRSpecial.h | 4 +- MUON/mapping/AliMpSector.h | 26 +++--- MUON/mapping/AliMpSectorAreaHPadIterator.h | 16 ++-- MUON/mapping/AliMpSectorAreaVPadIterator.h | 16 ++-- MUON/mapping/AliMpSectorPadIterator.h | 14 +-- MUON/mapping/AliMpSectorPainter.h | 5 +- MUON/mapping/AliMpSectorReader.h | 30 +++--- MUON/mapping/AliMpSectorSegmentation.h | 15 ++- MUON/mapping/AliMpSegFactory.h | 8 +- MUON/mapping/AliMpSlat.h | 24 ++--- MUON/mapping/AliMpSlatPadIterator.h | 10 +- MUON/mapping/AliMpSlatPainter.h | 4 +- MUON/mapping/AliMpSlatSegmentation.h | 4 +- MUON/mapping/AliMpSlatZonePadIterator.h | 22 ++--- MUON/mapping/AliMpSt345Reader.h | 4 +- MUON/mapping/AliMpStationType.h | 2 +- MUON/mapping/AliMpStringObjMap.h | 6 +- MUON/mapping/AliMpSubZone.h | 8 +- MUON/mapping/AliMpSubZonePainter.h | 5 +- MUON/mapping/AliMpTrigger.h | 14 +-- MUON/mapping/AliMpTriggerReader.h | 16 ++-- MUON/mapping/AliMpTriggerSegmentation.h | 7 +- MUON/mapping/AliMpVIndexed.h | 6 +- MUON/mapping/AliMpVMotif.h | 6 +- MUON/mapping/AliMpVPadIterator.h | 2 +- MUON/mapping/AliMpVPadRowSegment.h | 14 +-- MUON/mapping/AliMpVPainter.h | 11 ++- MUON/mapping/AliMpVRowSegment.h | 2 +- MUON/mapping/AliMpVRowSegmentSpecial.h | 16 ++-- MUON/mapping/AliMpVSegmentation.h | 2 +- MUON/mapping/AliMpXDirection.h | 2 +- MUON/mapping/AliMpZone.h | 10 +- MUON/mapping/AliMpZonePainter.h | 5 +- 131 files changed, 1014 insertions(+), 1014 deletions(-) diff --git a/MUON/AliMUONBlockHeader.h b/MUON/AliMUONBlockHeader.h index d5cf9da88f9..edf24387818 100644 --- a/MUON/AliMUONBlockHeader.h +++ b/MUON/AliMUONBlockHeader.h @@ -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 }; diff --git a/MUON/AliMUONBusStruct.h b/MUON/AliMUONBusStruct.h index 9bdab8a64de..a81e5b5b06e 100644 --- a/MUON/AliMUONBusStruct.h +++ b/MUON/AliMUONBusStruct.h @@ -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); diff --git a/MUON/AliMUONClusterDrawAZ.h b/MUON/AliMUONClusterDrawAZ.h index 490a5c14fed..629a2fbc782 100644 --- a/MUON/AliMUONClusterDrawAZ.h +++ b/MUON/AliMUONClusterDrawAZ.h @@ -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 diff --git a/MUON/AliMUONClusterFinderAZ.h b/MUON/AliMUONClusterFinderAZ.h index 02d2204c99e..1cff26b3d0d 100644 --- a/MUON/AliMUONClusterFinderAZ.h +++ b/MUON/AliMUONClusterFinderAZ.h @@ -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 diff --git a/MUON/AliMUONClusterFinderVS.h b/MUON/AliMUONClusterFinderVS.h index 94cd5aea62e..aa405f6650a 100644 --- a/MUON/AliMUONClusterFinderVS.h +++ b/MUON/AliMUONClusterFinderVS.h @@ -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 diff --git a/MUON/AliMUONClusterInput.h b/MUON/AliMUONClusterInput.h index 7c245a80cc9..ee07ab95a90 100644 --- a/MUON/AliMUONClusterInput.h +++ b/MUON/AliMUONClusterInput.h @@ -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 diff --git a/MUON/AliMUONClusterReconstructor.h b/MUON/AliMUONClusterReconstructor.h index b084ca27f7e..ec048119149 100644 --- a/MUON/AliMUONClusterReconstructor.h +++ b/MUON/AliMUONClusterReconstructor.h @@ -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 }; diff --git a/MUON/AliMUONDDLTracker.h b/MUON/AliMUONDDLTracker.h index 0a5efb0f963..5b44f1cedc5 100644 --- a/MUON/AliMUONDDLTracker.h +++ b/MUON/AliMUONDDLTracker.h @@ -44,7 +44,7 @@ public: private: - TClonesArray* fBlkHeaderArray; // array of block header + TClonesArray* fBlkHeaderArray; ///< array of block header ClassDef(AliMUONDDLTracker,1) // MUON DDL Tracker diff --git a/MUON/AliMUONDDLTrigger.h b/MUON/AliMUONDDLTrigger.h index e89adf6922c..e7e80c47442 100644 --- a/MUON/AliMUONDDLTrigger.h +++ b/MUON/AliMUONDDLTrigger.h @@ -33,7 +33,7 @@ public: private: - AliMUONDarcHeader* fDarcHeader; // pointer of darc header + AliMUONDarcHeader* fDarcHeader; ///< pointer of darc header ClassDef(AliMUONDDLTrigger,1) // MUON DDL Trigger diff --git a/MUON/AliMUONDarcHeader.h b/MUON/AliMUONDarcHeader.h index 228b2b0f373..7a0ceb10dca 100644 --- a/MUON/AliMUONDarcHeader.h +++ b/MUON/AliMUONDarcHeader.h @@ -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 }; diff --git a/MUON/AliMUONDetElement.h b/MUON/AliMUONDetElement.h index 4ddc21413ce..43fdfdee84b 100644 --- a/MUON/AliMUONDetElement.h +++ b/MUON/AliMUONDetElement.h @@ -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 diff --git a/MUON/AliMUONDigitCalibrator.h b/MUON/AliMUONDigitCalibrator.h index cd688651eba..76bc8da1045 100644 --- a/MUON/AliMUONDigitCalibrator.h +++ b/MUON/AliMUONDigitCalibrator.h @@ -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. }; diff --git a/MUON/AliMUONDigitMaker.h b/MUON/AliMUONDigitMaker.h index 3c3f10c44d6..cfb73d31848 100644 --- a/MUON/AliMUONDigitMaker.h +++ b/MUON/AliMUONDigitMaker.h @@ -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 }; diff --git a/MUON/AliMUONDigitizer.h b/MUON/AliMUONDigitizer.h index 6df9b877c36..725ebf0da2e 100644 --- a/MUON/AliMUONDigitizer.h +++ b/MUON/AliMUONDigitizer.h @@ -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: diff --git a/MUON/AliMUONDigitizerV3.h b/MUON/AliMUONDigitizerV3.h index f32f794f845..9fea4b72f84 100644 --- a/MUON/AliMUONDigitizerV3.h +++ b/MUON/AliMUONDigitizerV3.h @@ -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 }; diff --git a/MUON/AliMUONDspHeader.h b/MUON/AliMUONDspHeader.h index 171e73f9f01..76a68fc29f8 100644 --- a/MUON/AliMUONDspHeader.h +++ b/MUON/AliMUONDspHeader.h @@ -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 }; diff --git a/MUON/AliMUONEventRecoCombi.h b/MUON/AliMUONEventRecoCombi.h index 2d5172b5630..25cf12ff12e 100644 --- a/MUON/AliMUONEventRecoCombi.h +++ b/MUON/AliMUONEventRecoCombi.h @@ -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 }; diff --git a/MUON/AliMUONGeometry.h b/MUON/AliMUONGeometry.h index 4e732d3cba3..ca957edd22e 100644 --- a/MUON/AliMUONGeometry.h +++ b/MUON/AliMUONGeometry.h @@ -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 }; diff --git a/MUON/AliMUONGeometryBuilder.h b/MUON/AliMUONGeometryBuilder.h index 3716fbc58be..a493640c9d8 100644 --- a/MUON/AliMUONGeometryBuilder.h +++ b/MUON/AliMUONGeometryBuilder.h @@ -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 }; diff --git a/MUON/AliMUONGeometryConstituent.h b/MUON/AliMUONGeometryConstituent.h index 72c77ce2bbe..a017f212c65 100644 --- a/MUON/AliMUONGeometryConstituent.h +++ b/MUON/AliMUONGeometryConstituent.h @@ -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 }; diff --git a/MUON/AliMUONGeometryDetElement.h b/MUON/AliMUONGeometryDetElement.h index 9c72eacd082..1c6635b9211 100644 --- a/MUON/AliMUONGeometryDetElement.h +++ b/MUON/AliMUONGeometryDetElement.h @@ -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 }; diff --git a/MUON/AliMUONGeometryEnvelope.h b/MUON/AliMUONGeometryEnvelope.h index fea08d334ea..3ebaaf064f1 100644 --- a/MUON/AliMUONGeometryEnvelope.h +++ b/MUON/AliMUONGeometryEnvelope.h @@ -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 }; diff --git a/MUON/AliMUONGeometryEnvelopeStore.h b/MUON/AliMUONGeometryEnvelopeStore.h index 1d96a24675a..1e73b8f45d8 100644 --- a/MUON/AliMUONGeometryEnvelopeStore.h +++ b/MUON/AliMUONGeometryEnvelopeStore.h @@ -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 }; diff --git a/MUON/AliMUONGeometryMisAligner.h b/MUON/AliMUONGeometryMisAligner.h index e22b6e3788f..370fb8965dd 100644 --- a/MUON/AliMUONGeometryMisAligner.h +++ b/MUON/AliMUONGeometryMisAligner.h @@ -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 }; diff --git a/MUON/AliMUONGeometryModule.h b/MUON/AliMUONGeometryModule.h index b017d021dad..f55e1fdd29d 100644 --- a/MUON/AliMUONGeometryModule.h +++ b/MUON/AliMUONGeometryModule.h @@ -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 }; diff --git a/MUON/AliMUONGeometryModuleTransformer.h b/MUON/AliMUONGeometryModuleTransformer.h index 922c2ff4d7b..5068c36a19e 100644 --- a/MUON/AliMUONGeometryModuleTransformer.h +++ b/MUON/AliMUONGeometryModuleTransformer.h @@ -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 }; diff --git a/MUON/AliMUONGeometrySegmentation.h b/MUON/AliMUONGeometrySegmentation.h index 6a22776764b..916bd0805d2 100644 --- a/MUON/AliMUONGeometrySegmentation.h +++ b/MUON/AliMUONGeometrySegmentation.h @@ -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 diff --git a/MUON/AliMUONGeometryStore.h b/MUON/AliMUONGeometryStore.h index c461789fea8..aadab58b4be 100644 --- a/MUON/AliMUONGeometryStore.h +++ b/MUON/AliMUONGeometryStore.h @@ -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 }; diff --git a/MUON/AliMUONGeometryTransformer.h b/MUON/AliMUONGeometryTransformer.h index 3733b4b6130..712ae1c773f 100644 --- a/MUON/AliMUONGeometryTransformer.h +++ b/MUON/AliMUONGeometryTransformer.h @@ -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 }; diff --git a/MUON/AliMUONGlobalTriggerBoard.h b/MUON/AliMUONGlobalTriggerBoard.h index b91fd79acd9..12ab7814aba 100644 --- a/MUON/AliMUONGlobalTriggerBoard.h +++ b/MUON/AliMUONGlobalTriggerBoard.h @@ -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) }; diff --git a/MUON/AliMUONHitForRec.h b/MUON/AliMUONHitForRec.h index 9ea66767a4b..07684b3395a 100644 --- a/MUON/AliMUONHitForRec.h +++ b/MUON/AliMUONHitForRec.h @@ -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 }; diff --git a/MUON/AliMUONLocalStruct.h b/MUON/AliMUONLocalStruct.h index 0515f4c8eb3..64f4be1f99f 100644 --- a/MUON/AliMUONLocalStruct.h +++ b/MUON/AliMUONLocalStruct.h @@ -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) }; diff --git a/MUON/AliMUONLocalTriggerBoard.h b/MUON/AliMUONLocalTriggerBoard.h index 8efecbef560..d598ba2adf0 100644 --- a/MUON/AliMUONLocalTriggerBoard.h +++ b/MUON/AliMUONLocalTriggerBoard.h @@ -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) }; diff --git a/MUON/AliMUONPixel.h b/MUON/AliMUONPixel.h index e21f10db801..9ce458b891d 100644 --- a/MUON/AliMUONPixel.h +++ b/MUON/AliMUONPixel.h @@ -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 diff --git a/MUON/AliMUONRawStreamTracker.h b/MUON/AliMUONRawStreamTracker.h index 23339706814..9ee543204d2 100644 --- a/MUON/AliMUONRawStreamTracker.h +++ b/MUON/AliMUONRawStreamTracker.h @@ -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 }; diff --git a/MUON/AliMUONRawStreamTrigger.h b/MUON/AliMUONRawStreamTrigger.h index 0cc469dde98..30c307f00f1 100644 --- a/MUON/AliMUONRawStreamTrigger.h +++ b/MUON/AliMUONRawStreamTrigger.h @@ -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 }; diff --git a/MUON/AliMUONRawWriter.h b/MUON/AliMUONRawWriter.h index b60ff8b35f3..426e90b88dd 100644 --- a/MUON/AliMUONRawWriter.h +++ b/MUON/AliMUONRawWriter.h @@ -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 }; diff --git a/MUON/AliMUONRecoTrack.h b/MUON/AliMUONRecoTrack.h index 97a6ea5568f..fe6e98fecf3 100644 --- a/MUON/AliMUONRecoTrack.h +++ b/MUON/AliMUONRecoTrack.h @@ -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 }; diff --git a/MUON/AliMUONReconstructor.h b/MUON/AliMUONReconstructor.h index 320b89a293b..84a924d4b29 100644 --- a/MUON/AliMUONReconstructor.h +++ b/MUON/AliMUONReconstructor.h @@ -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 }; diff --git a/MUON/AliMUONRegHeader.h b/MUON/AliMUONRegHeader.h index 85f84c6f050..a1f7d662df7 100644 --- a/MUON/AliMUONRegHeader.h +++ b/MUON/AliMUONRegHeader.h @@ -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) }; diff --git a/MUON/AliMUONRegionalTriggerBoard.h b/MUON/AliMUONRegionalTriggerBoard.h index 4748038048e..adbfbd1b5c5 100644 --- a/MUON/AliMUONRegionalTriggerBoard.h +++ b/MUON/AliMUONRegionalTriggerBoard.h @@ -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) }; diff --git a/MUON/AliMUONResponseFactory.h b/MUON/AliMUONResponseFactory.h index 4f2806abb3f..ca9cf32b339 100644 --- a/MUON/AliMUONResponseFactory.h +++ b/MUON/AliMUONResponseFactory.h @@ -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 }; diff --git a/MUON/AliMUONResponseTrigger.h b/MUON/AliMUONResponseTrigger.h index a56db758895..4df62cea041 100644 --- a/MUON/AliMUONResponseTrigger.h +++ b/MUON/AliMUONResponseTrigger.h @@ -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 diff --git a/MUON/AliMUONResponseTriggerV1.h b/MUON/AliMUONResponseTriggerV1.h index 39b3056cc07..92e43dd7b30 100644 --- a/MUON/AliMUONResponseTriggerV1.h +++ b/MUON/AliMUONResponseTriggerV1.h @@ -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 diff --git a/MUON/AliMUONResponseV0.h b/MUON/AliMUONResponseV0.h index e7af62ab42b..bcb17ab91a6 100644 --- a/MUON/AliMUONResponseV0.h +++ b/MUON/AliMUONResponseV0.h @@ -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 }; diff --git a/MUON/AliMUONSegment.h b/MUON/AliMUONSegment.h index e0050d8f1f2..7e0b4729af6 100644 --- a/MUON/AliMUONSegment.h +++ b/MUON/AliMUONSegment.h @@ -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 }; diff --git a/MUON/AliMUONSegmentation.h b/MUON/AliMUONSegmentation.h index dd1e7077c9c..551442f4d23 100644 --- a/MUON/AliMUONSegmentation.h +++ b/MUON/AliMUONSegmentation.h @@ -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 }; diff --git a/MUON/AliMUONStringIntMap.h b/MUON/AliMUONStringIntMap.h index d8cd2840e48..8b851c50777 100644 --- a/MUON/AliMUONStringIntMap.h +++ b/MUON/AliMUONStringIntMap.h @@ -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 }; diff --git a/MUON/AliMUONTest.h b/MUON/AliMUONTest.h index 7a7919f3b64..3e4d7726c6e 100644 --- a/MUON/AliMUONTest.h +++ b/MUON/AliMUONTest.h @@ -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 }; diff --git a/MUON/AliMUONTrack.h b/MUON/AliMUONTrack.h index dc6878a3b33..4177be119ba 100644 --- a/MUON/AliMUONTrack.h +++ b/MUON/AliMUONTrack.h @@ -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 }; diff --git a/MUON/AliMUONTrackHit.h b/MUON/AliMUONTrackHit.h index d2f4d567e8b..c646716af62 100644 --- a/MUON/AliMUONTrackHit.h +++ b/MUON/AliMUONTrackHit.h @@ -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 }; diff --git a/MUON/AliMUONTrackK.h b/MUON/AliMUONTrackK.h index fef00888af7..7616184fa84 100644 --- a/MUON/AliMUONTrackK.h +++ b/MUON/AliMUONTrackK.h @@ -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 }; diff --git a/MUON/AliMUONTrackParam.h b/MUON/AliMUONTrackParam.h index 3fadeaac32d..3275db1b50f 100644 --- a/MUON/AliMUONTrackParam.h +++ b/MUON/AliMUONTrackParam.h @@ -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); diff --git a/MUON/AliMUONTrackReconstructor.h b/MUON/AliMUONTrackReconstructor.h index ba29a6a88d9..b041f06cbd7 100644 --- a/MUON/AliMUONTrackReconstructor.h +++ b/MUON/AliMUONTrackReconstructor.h @@ -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); diff --git a/MUON/AliMUONTrigger.h b/MUON/AliMUONTrigger.h index c209a966771..f33fe634813 100644 --- a/MUON/AliMUONTrigger.h +++ b/MUON/AliMUONTrigger.h @@ -8,11 +8,7 @@ /// \ingroup sim /// \class AliMUONTrigger -/// \brief MUON trigger class -/// -///////////////////////////////////////////////// -/// MUON Trigger Detector Class // -///////////////////////////////////////////////// +/// \brief MUON trigger detector class #include "AliTriggerDetector.h" diff --git a/MUON/AliMUONTriggerBoard.h b/MUON/AliMUONTriggerBoard.h index 67672aa0213..1e8a6ace3cd 100644 --- a/MUON/AliMUONTriggerBoard.h +++ b/MUON/AliMUONTriggerBoard.h @@ -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; diff --git a/MUON/AliMUONTriggerCrate.h b/MUON/AliMUONTriggerCrate.h index 2a18da2bc1b..23eb52b8f11 100644 --- a/MUON/AliMUONTriggerCrate.h +++ b/MUON/AliMUONTriggerCrate.h @@ -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) }; diff --git a/MUON/AliMUONTriggerDecision.h b/MUON/AliMUONTriggerDecision.h index 93779c3accb..dff6d6b6a10 100644 --- a/MUON/AliMUONTriggerDecision.h +++ b/MUON/AliMUONTriggerDecision.h @@ -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 diff --git a/MUON/AliMUONTriggerDecisionV1.h b/MUON/AliMUONTriggerDecisionV1.h index 5565c2795b6..fc0858d4882 100644 --- a/MUON/AliMUONTriggerDecisionV1.h +++ b/MUON/AliMUONTriggerDecisionV1.h @@ -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 diff --git a/MUON/AliMUONTriggerElectronics.h b/MUON/AliMUONTriggerElectronics.h index 2035a362d4b..5de9a2a176e 100644 --- a/MUON/AliMUONTriggerElectronics.h +++ b/MUON/AliMUONTriggerElectronics.h @@ -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) }; diff --git a/MUON/AliMUONTriggerTrack.h b/MUON/AliMUONTriggerTrack.h index 4c1fbe23f77..ed2e751017e 100644 --- a/MUON/AliMUONTriggerTrack.h +++ b/MUON/AliMUONTriggerTrack.h @@ -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 }; diff --git a/MUON/AliMUONVGeometryBuilder.h b/MUON/AliMUONVGeometryBuilder.h index 1ab22da2c2e..4c58bbd6176 100644 --- a/MUON/AliMUONVGeometryBuilder.h +++ b/MUON/AliMUONVGeometryBuilder.h @@ -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 }; diff --git a/MUON/mapping/AliMpArea.h b/MUON/mapping/AliMpArea.h index 290ebb87c84..595bf96551a 100755 --- a/MUON/mapping/AliMpArea.h +++ b/MUON/mapping/AliMpArea.h @@ -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 }; diff --git a/MUON/mapping/AliMpBusPatch.h b/MUON/mapping/AliMpBusPatch.h index 3f772393537..151eed74f92 100644 --- a/MUON/mapping/AliMpBusPatch.h +++ b/MUON/mapping/AliMpBusPatch.h @@ -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 }; diff --git a/MUON/mapping/AliMpConnection.h b/MUON/mapping/AliMpConnection.h index a90646b12a7..46b0379dd29 100755 --- a/MUON/mapping/AliMpConnection.h +++ b/MUON/mapping/AliMpConnection.h @@ -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 }; diff --git a/MUON/mapping/AliMpConstants.h b/MUON/mapping/AliMpConstants.h index 225b0173b4c..0c8050d6321 100755 --- a/MUON/mapping/AliMpConstants.h +++ b/MUON/mapping/AliMpConstants.h @@ -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 }; diff --git a/MUON/mapping/AliMpContainers.h b/MUON/mapping/AliMpContainers.h index 545cc414983..4d4536cdea7 100644 --- a/MUON/mapping/AliMpContainers.h +++ b/MUON/mapping/AliMpContainers.h @@ -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 diff --git a/MUON/mapping/AliMpDEIterator.h b/MUON/mapping/AliMpDEIterator.h index bf73b69946d..b3ad62e375e 100644 --- a/MUON/mapping/AliMpDEIterator.h +++ b/MUON/mapping/AliMpDEIterator.h @@ -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 diff --git a/MUON/mapping/AliMpDEManager.h b/MUON/mapping/AliMpDEManager.h index a9ba36a70e0..a162d0e6493 100644 --- a/MUON/mapping/AliMpDEManager.h +++ b/MUON/mapping/AliMpDEManager.h @@ -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 diff --git a/MUON/mapping/AliMpExMap.h b/MUON/mapping/AliMpExMap.h index a44b8949b9c..6c9287e85ae 100644 --- a/MUON/mapping/AliMpExMap.h +++ b/MUON/mapping/AliMpExMap.h @@ -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 }; diff --git a/MUON/mapping/AliMpFiles.h b/MUON/mapping/AliMpFiles.h index baff9b579b7..39e6569a62e 100755 --- a/MUON/mapping/AliMpFiles.h +++ b/MUON/mapping/AliMpFiles.h @@ -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 diff --git a/MUON/mapping/AliMpGraphContext.h b/MUON/mapping/AliMpGraphContext.h index 70e40c425f8..2770d91fe4b 100755 --- a/MUON/mapping/AliMpGraphContext.h +++ b/MUON/mapping/AliMpGraphContext.h @@ -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 }; diff --git a/MUON/mapping/AliMpHelper.h b/MUON/mapping/AliMpHelper.h index 426f4ce7b1c..31cc695b294 100644 --- a/MUON/mapping/AliMpHelper.h +++ b/MUON/mapping/AliMpHelper.h @@ -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 diff --git a/MUON/mapping/AliMpIntPair.h b/MUON/mapping/AliMpIntPair.h index ecda7a055b9..a8688f0655a 100755 --- a/MUON/mapping/AliMpIntPair.h +++ b/MUON/mapping/AliMpIntPair.h @@ -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); diff --git a/MUON/mapping/AliMpMotif.h b/MUON/mapping/AliMpMotif.h index a3698efbc65..a09574add03 100755 --- a/MUON/mapping/AliMpMotif.h +++ b/MUON/mapping/AliMpMotif.h @@ -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 }; diff --git a/MUON/mapping/AliMpMotifMap.h b/MUON/mapping/AliMpMotifMap.h index d2fdb936d3c..ae48bdd733a 100755 --- a/MUON/mapping/AliMpMotifMap.h +++ b/MUON/mapping/AliMpMotifMap.h @@ -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 fMotifPositions; // motif positions map by Id + std::map 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 }; diff --git a/MUON/mapping/AliMpMotifPainter.h b/MUON/mapping/AliMpMotifPainter.h index 8a330588083..47ca63c080b 100755 --- a/MUON/mapping/AliMpMotifPainter.h +++ b/MUON/mapping/AliMpMotifPainter.h @@ -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 }; diff --git a/MUON/mapping/AliMpMotifPosition.h b/MUON/mapping/AliMpMotifPosition.h index a4e1097fc34..63b254889a6 100755 --- a/MUON/mapping/AliMpMotifPosition.h +++ b/MUON/mapping/AliMpMotifPosition.h @@ -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 }; diff --git a/MUON/mapping/AliMpMotifPositionPadIterator.h b/MUON/mapping/AliMpMotifPositionPadIterator.h index dd4f969bdb8..770f8463720 100755 --- a/MUON/mapping/AliMpMotifPositionPadIterator.h +++ b/MUON/mapping/AliMpMotifPositionPadIterator.h @@ -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 }; diff --git a/MUON/mapping/AliMpMotifReader.h b/MUON/mapping/AliMpMotifReader.h index dd4cf5722cd..3d46ba47f00 100644 --- a/MUON/mapping/AliMpMotifReader.h +++ b/MUON/mapping/AliMpMotifReader.h @@ -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 }; diff --git a/MUON/mapping/AliMpMotifSpecial.h b/MUON/mapping/AliMpMotifSpecial.h index 05a58e2eb70..6184350b490 100755 --- a/MUON/mapping/AliMpMotifSpecial.h +++ b/MUON/mapping/AliMpMotifSpecial.h @@ -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 }; diff --git a/MUON/mapping/AliMpMotifType.h b/MUON/mapping/AliMpMotifType.h index fb15e9bcacc..890744537d2 100755 --- a/MUON/mapping/AliMpMotifType.h +++ b/MUON/mapping/AliMpMotifType.h @@ -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 diff --git a/MUON/mapping/AliMpMotifTypePadIterator.h b/MUON/mapping/AliMpMotifTypePadIterator.h index 6b94a24f62c..80ec4d90678 100755 --- a/MUON/mapping/AliMpMotifTypePadIterator.h +++ b/MUON/mapping/AliMpMotifTypePadIterator.h @@ -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 }; diff --git a/MUON/mapping/AliMpNeighboursPadIterator.h b/MUON/mapping/AliMpNeighboursPadIterator.h index 8e327602047..ea86829f754 100755 --- a/MUON/mapping/AliMpNeighboursPadIterator.h +++ b/MUON/mapping/AliMpNeighboursPadIterator.h @@ -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 }; diff --git a/MUON/mapping/AliMpPCB.h b/MUON/mapping/AliMpPCB.h index 6ace684230c..ec095543000 100644 --- a/MUON/mapping/AliMpPCB.h +++ b/MUON/mapping/AliMpPCB.h @@ -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 fMotifs; // array of motifs + std::vector 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 }; diff --git a/MUON/mapping/AliMpPCBPainter.h b/MUON/mapping/AliMpPCBPainter.h index 1845ec929dc..7ea88827594 100644 --- a/MUON/mapping/AliMpPCBPainter.h +++ b/MUON/mapping/AliMpPCBPainter.h @@ -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 }; diff --git a/MUON/mapping/AliMpPad.h b/MUON/mapping/AliMpPad.h index 7e3bdbb59c8..cac54b872b1 100755 --- a/MUON/mapping/AliMpPad.h +++ b/MUON/mapping/AliMpPad.h @@ -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 }; diff --git a/MUON/mapping/AliMpPadIteratorPtr.h b/MUON/mapping/AliMpPadIteratorPtr.h index 2e0acc26130..b4604200a85 100755 --- a/MUON/mapping/AliMpPadIteratorPtr.h +++ b/MUON/mapping/AliMpPadIteratorPtr.h @@ -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 }; diff --git a/MUON/mapping/AliMpPadPair.h b/MUON/mapping/AliMpPadPair.h index 4f2185007ba..c66bb12ed75 100644 --- a/MUON/mapping/AliMpPadPair.h +++ b/MUON/mapping/AliMpPadPair.h @@ -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 diff --git a/MUON/mapping/AliMpPadRow.h b/MUON/mapping/AliMpPadRow.h index 6a109929ed7..d102ed15afb 100755 --- a/MUON/mapping/AliMpPadRow.h +++ b/MUON/mapping/AliMpPadRow.h @@ -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 diff --git a/MUON/mapping/AliMpPadRowLSegment.h b/MUON/mapping/AliMpPadRowLSegment.h index f0b29649357..43025191a6c 100755 --- a/MUON/mapping/AliMpPadRowLSegment.h +++ b/MUON/mapping/AliMpPadRowLSegment.h @@ -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 diff --git a/MUON/mapping/AliMpPadRowRSegment.h b/MUON/mapping/AliMpPadRowRSegment.h index 7b0f4e60bbe..bdb4b7c2df9 100644 --- a/MUON/mapping/AliMpPadRowRSegment.h +++ b/MUON/mapping/AliMpPadRowRSegment.h @@ -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 diff --git a/MUON/mapping/AliMpPlaneType.h b/MUON/mapping/AliMpPlaneType.h index 5f8654db6ed..1dbe974437f 100755 --- a/MUON/mapping/AliMpPlaneType.h +++ b/MUON/mapping/AliMpPlaneType.h @@ -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 diff --git a/MUON/mapping/AliMpRow.h b/MUON/mapping/AliMpRow.h index 2390c56e08e..bfabc205396 100755 --- a/MUON/mapping/AliMpRow.h +++ b/MUON/mapping/AliMpRow.h @@ -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 diff --git a/MUON/mapping/AliMpRowPainter.h b/MUON/mapping/AliMpRowPainter.h index f08a7efb2e4..eeae688385f 100755 --- a/MUON/mapping/AliMpRowPainter.h +++ b/MUON/mapping/AliMpRowPainter.h @@ -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 diff --git a/MUON/mapping/AliMpRowSegment.h b/MUON/mapping/AliMpRowSegment.h index 761b41ca951..6d264deee90 100755 --- a/MUON/mapping/AliMpRowSegment.h +++ b/MUON/mapping/AliMpRowSegment.h @@ -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 diff --git a/MUON/mapping/AliMpRowSegmentLSpecial.h b/MUON/mapping/AliMpRowSegmentLSpecial.h index 030ce691952..7f23bc1a6f0 100755 --- a/MUON/mapping/AliMpRowSegmentLSpecial.h +++ b/MUON/mapping/AliMpRowSegmentLSpecial.h @@ -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 diff --git a/MUON/mapping/AliMpRowSegmentPainter.h b/MUON/mapping/AliMpRowSegmentPainter.h index e06607b533b..e86dc6cf708 100755 --- a/MUON/mapping/AliMpRowSegmentPainter.h +++ b/MUON/mapping/AliMpRowSegmentPainter.h @@ -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 diff --git a/MUON/mapping/AliMpRowSegmentRSpecial.h b/MUON/mapping/AliMpRowSegmentRSpecial.h index 7a7665ed7a9..52600795339 100644 --- a/MUON/mapping/AliMpRowSegmentRSpecial.h +++ b/MUON/mapping/AliMpRowSegmentRSpecial.h @@ -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 diff --git a/MUON/mapping/AliMpSector.h b/MUON/mapping/AliMpSector.h index 9ed69e7b012..a401bbbe401 100755 --- a/MUON/mapping/AliMpSector.h +++ b/MUON/mapping/AliMpSector.h @@ -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 diff --git a/MUON/mapping/AliMpSectorAreaHPadIterator.h b/MUON/mapping/AliMpSectorAreaHPadIterator.h index c743149a465..ce30a03d0bb 100755 --- a/MUON/mapping/AliMpSectorAreaHPadIterator.h +++ b/MUON/mapping/AliMpSectorAreaHPadIterator.h @@ -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 }; diff --git a/MUON/mapping/AliMpSectorAreaVPadIterator.h b/MUON/mapping/AliMpSectorAreaVPadIterator.h index 4f7a9259561..2dbe37e41ce 100644 --- a/MUON/mapping/AliMpSectorAreaVPadIterator.h +++ b/MUON/mapping/AliMpSectorAreaVPadIterator.h @@ -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 }; diff --git a/MUON/mapping/AliMpSectorPadIterator.h b/MUON/mapping/AliMpSectorPadIterator.h index b649e341820..7a4883e056d 100755 --- a/MUON/mapping/AliMpSectorPadIterator.h +++ b/MUON/mapping/AliMpSectorPadIterator.h @@ -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 }; diff --git a/MUON/mapping/AliMpSectorPainter.h b/MUON/mapping/AliMpSectorPainter.h index a7e0b18b39c..cdfb4784ada 100755 --- a/MUON/mapping/AliMpSectorPainter.h +++ b/MUON/mapping/AliMpSectorPainter.h @@ -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 diff --git a/MUON/mapping/AliMpSectorReader.h b/MUON/mapping/AliMpSectorReader.h index a12111bc7ab..8391ca7c1c8 100755 --- a/MUON/mapping/AliMpSectorReader.h +++ b/MUON/mapping/AliMpSectorReader.h @@ -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 }; diff --git a/MUON/mapping/AliMpSectorSegmentation.h b/MUON/mapping/AliMpSectorSegmentation.h index 49d129d04f2..27ed6dc7229 100755 --- a/MUON/mapping/AliMpSectorSegmentation.h +++ b/MUON/mapping/AliMpSectorSegmentation.h @@ -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 }; diff --git a/MUON/mapping/AliMpSegFactory.h b/MUON/mapping/AliMpSegFactory.h index a6a8a9f7705..d5b0bf23029 100644 --- a/MUON/mapping/AliMpSegFactory.h +++ b/MUON/mapping/AliMpSegFactory.h @@ -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 diff --git a/MUON/mapping/AliMpSlat.h b/MUON/mapping/AliMpSlat.h index 1030e0812eb..b7c8d9b47f1 100644 --- a/MUON/mapping/AliMpSlat.h +++ b/MUON/mapping/AliMpSlat.h @@ -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 fPCBs; // array of AliMpPCB* + std::vector 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 }; diff --git a/MUON/mapping/AliMpSlatPadIterator.h b/MUON/mapping/AliMpSlatPadIterator.h index b759ca5c262..b29224edaaa 100644 --- a/MUON/mapping/AliMpSlatPadIterator.h +++ b/MUON/mapping/AliMpSlatPadIterator.h @@ -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 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 fDelegates; ///< iterators we do use + AliMpVPadIterator* fCurrentDelegate; ///< current iterator + UInt_t fCurrentDelegateIndex; ///< current iterator index ClassDef(AliMpSlatPadIterator,1) // Pad iterator for St 345 Slats }; diff --git a/MUON/mapping/AliMpSlatPainter.h b/MUON/mapping/AliMpSlatPainter.h index abcbc8ef31c..010a9f97b92 100644 --- a/MUON/mapping/AliMpSlatPainter.h +++ b/MUON/mapping/AliMpSlatPainter.h @@ -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 }; diff --git a/MUON/mapping/AliMpSlatSegmentation.h b/MUON/mapping/AliMpSlatSegmentation.h index fa8692a41d8..eef4b4da9e0 100644 --- a/MUON/mapping/AliMpSlatSegmentation.h +++ b/MUON/mapping/AliMpSlatSegmentation.h @@ -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 }; diff --git a/MUON/mapping/AliMpSlatZonePadIterator.h b/MUON/mapping/AliMpSlatZonePadIterator.h index c17d6668a83..a9b95d79dff 100644 --- a/MUON/mapping/AliMpSlatZonePadIterator.h +++ b/MUON/mapping/AliMpSlatZonePadIterator.h @@ -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. }; diff --git a/MUON/mapping/AliMpSt345Reader.h b/MUON/mapping/AliMpSt345Reader.h index e03809488f0..fd659ce67f8 100644 --- a/MUON/mapping/AliMpSt345Reader.h +++ b/MUON/mapping/AliMpSt345Reader.h @@ -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 }; diff --git a/MUON/mapping/AliMpStationType.h b/MUON/mapping/AliMpStationType.h index ccc4019cd83..e84a30436be 100644 --- a/MUON/mapping/AliMpStationType.h +++ b/MUON/mapping/AliMpStationType.h @@ -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 diff --git a/MUON/mapping/AliMpStringObjMap.h b/MUON/mapping/AliMpStringObjMap.h index a39bbc4f85e..a76ca3a18f5 100644 --- a/MUON/mapping/AliMpStringObjMap.h +++ b/MUON/mapping/AliMpStringObjMap.h @@ -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 }; diff --git a/MUON/mapping/AliMpSubZone.h b/MUON/mapping/AliMpSubZone.h index c88d05fc136..cfbc5bf1af0 100755 --- a/MUON/mapping/AliMpSubZone.h +++ b/MUON/mapping/AliMpSubZone.h @@ -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 diff --git a/MUON/mapping/AliMpSubZonePainter.h b/MUON/mapping/AliMpSubZonePainter.h index 0696402f04b..08774a6c0e3 100755 --- a/MUON/mapping/AliMpSubZonePainter.h +++ b/MUON/mapping/AliMpSubZonePainter.h @@ -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 diff --git a/MUON/mapping/AliMpTrigger.h b/MUON/mapping/AliMpTrigger.h index da91ea5f0a4..505f105557c 100644 --- a/MUON/mapping/AliMpTrigger.h +++ b/MUON/mapping/AliMpTrigger.h @@ -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 }; diff --git a/MUON/mapping/AliMpTriggerReader.h b/MUON/mapping/AliMpTriggerReader.h index d2bcd931b51..775ab45aea3 100644 --- a/MUON/mapping/AliMpTriggerReader.h +++ b/MUON/mapping/AliMpTriggerReader.h @@ -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 }; diff --git a/MUON/mapping/AliMpTriggerSegmentation.h b/MUON/mapping/AliMpTriggerSegmentation.h index 922a3eb33b5..d9cc21e7034 100644 --- a/MUON/mapping/AliMpTriggerSegmentation.h +++ b/MUON/mapping/AliMpTriggerSegmentation.h @@ -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 }; diff --git a/MUON/mapping/AliMpVIndexed.h b/MUON/mapping/AliMpVIndexed.h index 2b28d8c544f..7de26249caa 100755 --- a/MUON/mapping/AliMpVIndexed.h +++ b/MUON/mapping/AliMpVIndexed.h @@ -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 }; diff --git a/MUON/mapping/AliMpVMotif.h b/MUON/mapping/AliMpVMotif.h index df7540b73a5..583759afc6b 100755 --- a/MUON/mapping/AliMpVMotif.h +++ b/MUON/mapping/AliMpVMotif.h @@ -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 }; diff --git a/MUON/mapping/AliMpVPadIterator.h b/MUON/mapping/AliMpVPadIterator.h index 72c997b62e3..ae091bac42f 100755 --- a/MUON/mapping/AliMpVPadIterator.h +++ b/MUON/mapping/AliMpVPadIterator.h @@ -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 diff --git a/MUON/mapping/AliMpVPadRowSegment.h b/MUON/mapping/AliMpVPadRowSegment.h index 6e5a724dcb3..3a1094d8e85 100755 --- a/MUON/mapping/AliMpVPadRowSegment.h +++ b/MUON/mapping/AliMpVPadRowSegment.h @@ -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 diff --git a/MUON/mapping/AliMpVPainter.h b/MUON/mapping/AliMpVPainter.h index ee4af4ba76d..b24e830c716 100755 --- a/MUON/mapping/AliMpVPainter.h +++ b/MUON/mapping/AliMpVPainter.h @@ -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 }; diff --git a/MUON/mapping/AliMpVRowSegment.h b/MUON/mapping/AliMpVRowSegment.h index a334ce20b78..dfbe5613b04 100755 --- a/MUON/mapping/AliMpVRowSegment.h +++ b/MUON/mapping/AliMpVRowSegment.h @@ -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 diff --git a/MUON/mapping/AliMpVRowSegmentSpecial.h b/MUON/mapping/AliMpVRowSegmentSpecial.h index 88d60d2419f..f9282335552 100644 --- a/MUON/mapping/AliMpVRowSegmentSpecial.h +++ b/MUON/mapping/AliMpVRowSegmentSpecial.h @@ -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 diff --git a/MUON/mapping/AliMpVSegmentation.h b/MUON/mapping/AliMpVSegmentation.h index 81e33ff1d29..551d49755a0 100644 --- a/MUON/mapping/AliMpVSegmentation.h +++ b/MUON/mapping/AliMpVSegmentation.h @@ -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 diff --git a/MUON/mapping/AliMpXDirection.h b/MUON/mapping/AliMpXDirection.h index d526f7953ac..1b203ed8213 100644 --- a/MUON/mapping/AliMpXDirection.h +++ b/MUON/mapping/AliMpXDirection.h @@ -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 diff --git a/MUON/mapping/AliMpZone.h b/MUON/mapping/AliMpZone.h index c7ab8dc0bac..cc8be9729b6 100755 --- a/MUON/mapping/AliMpZone.h +++ b/MUON/mapping/AliMpZone.h @@ -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 diff --git a/MUON/mapping/AliMpZonePainter.h b/MUON/mapping/AliMpZonePainter.h index d8e7a0e087e..0d77e434661 100755 --- a/MUON/mapping/AliMpZonePainter.h +++ b/MUON/mapping/AliMpZonePainter.h @@ -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 -- 2.39.3