Comments for Doxygen (mostly added comments for inline functions)
authorivana <ivana@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 19 Mar 2007 15:28:39 +0000 (15:28 +0000)
committerivana <ivana@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 19 Mar 2007 15:28:39 +0000 (15:28 +0000)
187 files changed:
MUON/AliMUON2DStoreValidator.h
MUON/AliMUONBlockHeader.h
MUON/AliMUONBusStruct.h
MUON/AliMUONCalibrationData.h
MUON/AliMUONCheck.cxx
MUON/AliMUONCheck.h
MUON/AliMUONCheckItemIterator.h
MUON/AliMUONCluster.cxx
MUON/AliMUONCluster.h
MUON/AliMUONClusterFinderCOG.h
MUON/AliMUONClusterFinderMLEM.cxx
MUON/AliMUONClusterFinderMLEM.h
MUON/AliMUONClusterFinderSimpleFit.h
MUON/AliMUONClusterFinderVS.h
MUON/AliMUONClusterInput.h
MUON/AliMUONClusterReconstructor.h
MUON/AliMUONClusterSplitterMLEM.cxx
MUON/AliMUONClusterSplitterMLEM.h
MUON/AliMUONCommonGeometryBuilder.h
MUON/AliMUONDDLTracker.h
MUON/AliMUONDDLTrigger.h
MUON/AliMUONDarcHeader.h
MUON/AliMUONData.cxx
MUON/AliMUONData.h
MUON/AliMUONDataInterface.h
MUON/AliMUONDataIterator.cxx
MUON/AliMUONDataIterator.h
MUON/AliMUONDetElement.h
MUON/AliMUONDigit.cxx
MUON/AliMUONDigit.h
MUON/AliMUONDigitCalibrator.h
MUON/AliMUONDigitMaker.h
MUON/AliMUONDigitMapA1.h
MUON/AliMUONDigitizerV3.h
MUON/AliMUONDisplay.h
MUON/AliMUONDspHeader.h
MUON/AliMUONEventRecoCombi.h
MUON/AliMUONGMSSubprocessor.h
MUON/AliMUONGeometry.h
MUON/AliMUONGeometryBuilder.h
MUON/AliMUONGeometryConstituent.h
MUON/AliMUONGeometryDetElement.h
MUON/AliMUONGeometryEnvelope.h
MUON/AliMUONGeometryEnvelopeStore.h
MUON/AliMUONGeometryMisAligner.h
MUON/AliMUONGeometryModule.h
MUON/AliMUONGeometryModuleTransformer.h
MUON/AliMUONGeometrySegmentation.h
MUON/AliMUONGeometryTransformer.h
MUON/AliMUONGlobalTrigger.cxx
MUON/AliMUONGlobalTriggerBoard.cxx
MUON/AliMUONGlobalTriggerBoard.h
MUON/AliMUONHVNamer.h
MUON/AliMUONHVSubprocessor.h
MUON/AliMUONHitForRec.cxx
MUON/AliMUONHitForRec.h
MUON/AliMUONHitMapA1.h
MUON/AliMUONLoader.h
MUON/AliMUONLocalStruct.cxx
MUON/AliMUONLocalStruct.h
MUON/AliMUONLocalTrigger.cxx
MUON/AliMUONLocalTrigger.h
MUON/AliMUONLocalTriggerBoard.cxx
MUON/AliMUONLocalTriggerBoard.h
MUON/AliMUONLogger.cxx
MUON/AliMUONLogger.h
MUON/AliMUONObjectPair.h
MUON/AliMUONPad.cxx
MUON/AliMUONPad.h
MUON/AliMUONPadStatusMaker.cxx
MUON/AliMUONPadStatusMaker.h
MUON/AliMUONPayloadTracker.cxx
MUON/AliMUONPayloadTracker.h
MUON/AliMUONPayloadTrigger.h
MUON/AliMUONPedestalEventGenerator.h
MUON/AliMUONPedestalSubprocessor.cxx
MUON/AliMUONPixel.h
MUON/AliMUONPoints.h
MUON/AliMUONPreprocessor.h
MUON/AliMUONRawCluster.cxx
MUON/AliMUONRawCluster.h
MUON/AliMUONRawStreamTracker.h
MUON/AliMUONRawStreamTrigger.h
MUON/AliMUONRecoCheck.h
MUON/AliMUONRecoTrack.cxx
MUON/AliMUONRecoTrack.h
MUON/AliMUONReconstructor.h
MUON/AliMUONRegHeader.h
MUON/AliMUONRegionalTrigger.cxx
MUON/AliMUONRegionalTrigger.h
MUON/AliMUONRegionalTriggerBoard.cxx
MUON/AliMUONRegionalTriggerBoard.h
MUON/AliMUONResponse.cxx
MUON/AliMUONResponse.h
MUON/AliMUONResponseFactory.cxx
MUON/AliMUONResponseFactory.h
MUON/AliMUONResponseTriggerV1.cxx
MUON/AliMUONResponseV0.h
MUON/AliMUONSDigitizerV2.cxx
MUON/AliMUONSegFactory.h
MUON/AliMUONSegmentation.h
MUON/AliMUONSlatGeometryBuilder.cxx
MUON/AliMUONSlatGeometryBuilder.h
MUON/AliMUONSt12QuadrantSegmentation.h
MUON/AliMUONSt1GeometryBuilder.h
MUON/AliMUONSt1GeometryBuilderV2.h
MUON/AliMUONSt2GeometryBuilder.cxx
MUON/AliMUONSt2GeometryBuilder.h
MUON/AliMUONSt2GeometryBuilderV2.cxx
MUON/AliMUONSt2GeometryBuilderV2.h
MUON/AliMUONSt345SlatSegmentation.h
MUON/AliMUONStringIntMap.h
MUON/AliMUONTrackExtrap.cxx
MUON/AliMUONTrackExtrap.h
MUON/AliMUONTrackK.h
MUON/AliMUONTrackReconstructor.cxx
MUON/AliMUONTrackReconstructor.h
MUON/AliMUONTracker.h
MUON/AliMUONTrackerPreprocessor.h
MUON/AliMUONTrigger.cxx
MUON/AliMUONTrigger.h
MUON/AliMUONTriggerBoard.cxx
MUON/AliMUONTriggerBoard.h
MUON/AliMUONTriggerChamberEff.cxx
MUON/AliMUONTriggerChamberEff.h
MUON/AliMUONTriggerCircuit.h
MUON/AliMUONTriggerCrate.cxx
MUON/AliMUONTriggerCrate.h
MUON/AliMUONTriggerCrateStore.cxx
MUON/AliMUONTriggerCrateStore.h
MUON/AliMUONTriggerEfficiencyCells.h
MUON/AliMUONTriggerElectronics.cxx
MUON/AliMUONTriggerElectronics.h
MUON/AliMUONTriggerGeometryBuilder.cxx
MUON/AliMUONTriggerGeometryBuilder.h
MUON/AliMUONTriggerLut.cxx
MUON/AliMUONTriggerLut.h
MUON/AliMUONTriggerSegmentation.cxx
MUON/AliMUONTriggerSegmentation.h
MUON/AliMUONTriggerTrack.h
MUON/AliMUONV2DStore.h
MUON/AliMUONVCalibParam.h
MUON/AliMUONVClusterFinder.cxx
MUON/AliMUONVClusterFinder.h
MUON/AliMUONVDataIterator.h
MUON/AliMUONVGeometryBuilder.h
MUON/AliMUONVGeometryDESegmentation.h
MUON/AliMUONVSubprocessor.h
MUON/AliMUONVTrackReconstructor.cxx
MUON/AliMUONVTrackReconstructor.h
MUON/AliMUONv1.h
MUON/mapping/AliMpArea.cxx
MUON/mapping/AliMpBusPatch.h
MUON/mapping/AliMpConnection.h
MUON/mapping/AliMpDDL.h
MUON/mapping/AliMpDDLStore.h
MUON/mapping/AliMpDEStore.h
MUON/mapping/AliMpDEVisu.cxx
MUON/mapping/AliMpDEVisu.h
MUON/mapping/AliMpDetElement.h
MUON/mapping/AliMpFiles.cxx
MUON/mapping/AliMpIntPair.h
MUON/mapping/AliMpIteratorPainter.h
MUON/mapping/AliMpManuGeo.h
MUON/mapping/AliMpMotifType.cxx
MUON/mapping/AliMpPCB.cxx
MUON/mapping/AliMpPCB.h
MUON/mapping/AliMpPCBPadIterator.cxx
MUON/mapping/AliMpPCBPadIterator.h
MUON/mapping/AliMpPCBPainter.cxx
MUON/mapping/AliMpPCBPainter.h
MUON/mapping/AliMpSectorSegmentation.cxx
MUON/mapping/AliMpSlat.cxx
MUON/mapping/AliMpSlat.h
MUON/mapping/AliMpSlatMotifMap.h
MUON/mapping/AliMpSlatPadIterator.cxx
MUON/mapping/AliMpSlatPadIterator.h
MUON/mapping/AliMpSlatPainter.cxx
MUON/mapping/AliMpSlatPainter.h
MUON/mapping/AliMpSlatSegmentation.cxx
MUON/mapping/AliMpSlatSegmentation.h
MUON/mapping/AliMpSt345Reader.cxx
MUON/mapping/AliMpTrigger.cxx
MUON/mapping/AliMpTriggerReader.cxx
MUON/mapping/AliMpTriggerReader.h
MUON/mapping/AliMpTriggerSegmentation.cxx
MUON/mapping/AliMpTriggerSegmentation.h

index 7eba3b3..f5ac748 100644 (file)
@@ -36,6 +36,7 @@ public:
   TObjArray* Validate(const AliMUONV2DStore& store, 
                       Bool_t (*check)(const AliMUONVCalibParam&,Int_t));
 
+  /// Return statuses
   AliMUONV2DStore* GetStatus() const { return fStatus; }
   
   /// Reports what is missing, trying to be as concise as possible.
index 0935fdc..aa824a3 100644 (file)
@@ -25,39 +25,62 @@ public:
 
    virtual ~AliMUONBlockHeader();
 
+   //
    // Block header
+   //
+           /// Return data key word for CRT header
    Int_t   GetDataKey()        const {return fDataKey;}
+           /// Return total length of block structure (w/o padding word)
    Int_t   GetTotalLength()    const {return fTotalLength;}
+           /// Return length of raw data
    Int_t   GetLength()         const {return fLength;}
+           /// Return Dsp id
    Int_t   GetDspId()          const {return fDspId;}
+           /// Return L0 trigger word
    Int_t   GetL0Trigger()      const {return fL0Trigger;}
+           /// Return Bunch Crossing for mini-event id (see TDR chapter 8)
    Int_t   GetMiniEventId()    const {return fMiniEventId;}
+           /// Return Event Id in bunch crossing
    Int_t   GetEventId1()       const {return fEventId1;}
+           /// Return Event Id in orbit number
    Int_t   GetEventId2()       const {return fEventId2;}
 
+           /// Return header length in word
    Int_t   GetHeaderLength()   const {return fgkHeaderLength;}
+           /// Return default data key word for CRT header
    UInt_t  GetDefaultDataKey() const {return fgkDefaultDataKey;}
 
+
+           /// Set data key word for CRT header
    void    SetDataKey(Int_t d)     {fDataKey = d;}
+           /// Set total length of block structure (w/o padding word)
    void    SetTotalLength(Int_t l) {fTotalLength = l;}
+           /// Set length of raw data
    void    SetLength(Int_t l)      {fLength = l;}
+           /// Set Dsp id
    void    SetDspId(Int_t d)       {fDspId = d;}  
+           /// Set L0 trigger word
    void    SetL0Trigger(Int_t l)   {fL0Trigger = l;}
+           /// Set Bunch Crossing for mini-event id (see TDR chapter 8)
    void    SetMiniEventId(Int_t e) {fMiniEventId = e;}
+           /// Set Event Id in bunch crossing
    void    SetEventId1(Int_t e)    {fEventId1 = e;}
+           /// Set Event Id in orbit number
    void    SetEventId2(Int_t e)    {fEventId2 = e;}
-
+   
+   
+   /// Return header
    Int_t* GetHeader() {return &fDataKey;}
 
    void   AddDspHeader(const AliMUONDspHeader& dspHeader);
 
-   // get TClonesArray
+   /// get TClonesArray
    TClonesArray*      GetDspHeaderArray()  const {return fDspHeaderArray;}
 
-   // get entries
+   /// get entries
    Int_t              GetDspHeaderEntries() const {return fDspHeaderArray->GetEntriesFast();}
 
-   // get entry
+   /// get entry
    AliMUONDspHeader*  GetDspHeaderEntry(Int_t i) const {
      return (AliMUONDspHeader*)fDspHeaderArray->At(i);}
 
index 5813558..fb879ce 100644 (file)
@@ -22,20 +22,31 @@ public:
    AliMUONBusStruct& operator=(const AliMUONBusStruct& rhs);
 
    // header
+           /// Return Data key word for bus patch header
    Int_t   GetDataKey()     const {return fDataKey;}
+           /// Return total length of buspatch structure
    Int_t   GetTotalLength() const {return fTotalLength;}
+           /// Return length of raw data
    Int_t   GetLength()      const {return fLength;}
+           /// Return bus patch id
    Int_t   GetBusPatchId()  const {return fBusPatchId;}
 
+           /// Return header length in word
    Int_t   GetHeaderLength()   const {return fgkHeaderLength;}
+           /// Return default data key word for Bus Patch Header
    UInt_t  GetDefaultDataKey() const {return fgkDefaultDataKey;}
 
+           /// Return header
    Int_t*  GetHeader() {return &fDataKey;}
 
    // data
+           /// Return initial size for data array
    Int_t   GetBufSize()     const {return fBufSize;}
+           /// Return data
    UInt_t* GetData()        const {return fData;}
+           /// Return block numer for monitoring
    Int_t   GetBlockId()     const {return fBlkId;}
+           /// Return Dsp number for monitoring
    Int_t   GetDspId()       const {return fDspId;}
 
    Char_t   GetParity(Int_t n) const;
@@ -45,20 +56,28 @@ public:
    UInt_t   GetData(Int_t n) const;
 
    // header setter
+           /// Set Data key word for bus patch header 
    void    SetDataKey(Int_t d)     {fDataKey = d;}
+           /// Set total length of buspatch structure 
    void    SetTotalLength(Int_t l) {fTotalLength = l;}
+           /// Set length of raw data 
    void    SetLength(Int_t l)      {fLength = l;}
+           /// Set bus patch id 
    void    SetBusPatchId(Int_t b)  {fBusPatchId = b;} 
  
    // data 
+           /// Set data 
    void    SetData(UInt_t d, Int_t n)  {fData[n] = d;}
+           /// Set block numer for monitoring 
    void    SetBlockId(Int_t b)     {fBlkId = b;}  
+           /// Set Dsp number for monitoring 
    void    SetDspId(Int_t d)       {fDspId = d;}  
 
    void    AddData(UInt_t d);
    void    SetAlloc(Int_t size);
 
    // TClonesArray
+           /// Return true as  Compare() is implemented
    Bool_t  IsSortable() const {return kTRUE;}
    Int_t   Compare(const TObject *obj) const;
    void    Clear(Option_t* opt);
index af3bc1d..6c7dead 100644 (file)
@@ -73,7 +73,9 @@ public:
   AliMUONTriggerEfficiencyCells* TriggerEfficiency() const;
   
 protected:
+  /// Not implemented
   AliMUONCalibrationData(const AliMUONCalibrationData& other);
+  /// Not implemented
   AliMUONCalibrationData& operator=(const AliMUONCalibrationData& other);
   
 private:
@@ -88,16 +90,16 @@ private:
   AliMUONTriggerEfficiencyCells* OnDemandTriggerEfficiency() const;
   
 private:  
-  mutable Bool_t fIsValid; // Whether we were able to correctly initialize
-  Int_t fRunNumber; // The run number for which we hold calibrations
-  mutable AliMUONV2DStore* fGains; //!
-  mutable AliMUONV2DStore* fPedestals; //!
-  mutable TMap* fHV; //!
-  mutable AliMUONV1DStore* fLocalTriggerBoardMasks; //!
-  mutable AliMUONV1DStore* fRegionalTriggerBoardMasks; //!
-  mutable AliMUONVCalibParam* fGlobalTriggerBoardMasks; //!
-  mutable AliMUONTriggerLut* fTriggerLut; //!
-  mutable AliMUONTriggerEfficiencyCells* fTriggerEfficiency; //!
+  mutable Bool_t fIsValid; ///<  Whether we were able to correctly initialize
+  Int_t fRunNumber; ///<  The run number for which we hold calibrations
+  mutable AliMUONV2DStore* fGains; //!< Gains
+  mutable AliMUONV2DStore* fPedestals; //!< Pedestals
+  mutable TMap* fHV; //!< HV
+  mutable AliMUONV1DStore* fLocalTriggerBoardMasks; //!< Local trigger board maska
+  mutable AliMUONV1DStore* fRegionalTriggerBoardMasks; //!< Regional trigger board maska
+  mutable AliMUONVCalibParam* fGlobalTriggerBoardMasks; //!< Global trigger board maska
+  mutable AliMUONTriggerLut* fTriggerLut; //!< TRigger LUTs
+  mutable AliMUONTriggerEfficiencyCells* fTriggerEfficiency; //!< Trigger efficiency cells
   
   ClassDef(AliMUONCalibrationData,4) // Storage for all MUON calibration data.
 };
index aaa7a54..76d3b3f 100644 (file)
@@ -73,7 +73,7 @@ ClassImp(AliMUONCheck)
   fData(0x0),
   fTree(0)
 {
-  // ctor
+  /// ctor
  
   fRunLoader = AliRunLoader::Open(fFileName.Data(),"MUONFolder","READ");
   if (!fRunLoader) 
@@ -103,7 +103,7 @@ ClassImp(AliMUONCheck)
 //_____________________________________________________________________________
 AliMUONCheck::AliMUONCheck(const AliMUONCheck& rhs) : TObject(rhs)
 {
-  // copy ctor
+  /// copy ctor
   AliFatal("Implement me if needed");
 }
 
@@ -111,7 +111,7 @@ AliMUONCheck::AliMUONCheck(const AliMUONCheck& rhs) : TObject(rhs)
 AliMUONCheck& 
 AliMUONCheck::operator=(const AliMUONCheck&)
 {
-  // assignement operator
+  /// assignement operator
   AliFatal("Implement me if needed")
   return *this;
 }
@@ -130,7 +130,7 @@ AliMUONCheck::~AliMUONCheck()
 void
 AliMUONCheck::CheckESD(Bool_t pdc06TriggerResponse) 
 {
-  // Check ESD files
+  /// Check ESD files
 
   if ( !IsValid() ) return;
   
@@ -439,7 +439,7 @@ AliMUONCheck::CheckESD(Bool_t pdc06TriggerResponse)
 void
 AliMUONCheck::CheckKine() 
 {
-  // Check Stack 
+  /// Check Stack 
   if ( !IsValid() ) return;
   
   // Stack of particle for each event
@@ -580,7 +580,7 @@ AliMUONCheck::CheckKine()
 void
 AliMUONCheck::CheckTrackRef() 
 {
-   // Check TrackRef files
+   /// Check TrackRef files
   
   if ( !IsValid() ) return;
   Int_t flag11=0,flag12=0,flag13=0,flag14=0;
index bc339e4..f2c1c0f 100644 (file)
@@ -47,7 +47,7 @@ public:
 private:
   /// Not implemented
   AliMUONCheck(const AliMUONCheck& rhs);
- /// Not implemented
+  /// Not implemented
   AliMUONCheck& operator=(const AliMUONCheck& rhs);
   
 private:
@@ -64,8 +64,8 @@ private:
 
   AliMUONData*  fData;  //!< AliMUONData pointer (to access containers)
 
-  TTree   * fTree ;     //!pointer to the analyzed TTree or TChain
-  AliESD  * fESD ;      //! Declaration of leave types
+  TTree   * fTree ;     //!< pointer to the analyzed TTree or TChain
+  AliESD  * fESD ;      //!< Declaration of leave types
 
   ClassDef(AliMUONCheck,0) // Dumper of MUON related data
 }; 
index 7f33dfd..9d33ff2 100644 (file)
@@ -30,7 +30,9 @@ public:
   TObject* Next();
   
 private:
+  /// Not implemented
   AliMUONCheckItemIterator(const AliMUONCheckItemIterator&);
+  /// Not implemented
   AliMUONCheckItemIterator& operator=(const AliMUONCheckItemIterator&);
   
 private:
index 46f6d8e..c44a654 100644 (file)
@@ -198,9 +198,9 @@ AliMUONCluster::Area() const
 void
 AliMUONCluster::Copy(TObject& obj) const
 {
-  //
-  // Copy this cluster to (cluster&)obj
-  //
+  ///
+  /// Copy this cluster to (cluster&)obj
+  ///
   TObject::Copy(obj);
   AliMUONCluster& dest = static_cast<AliMUONCluster&>(obj);
   dest.fPads = static_cast<TObjArray*>(fPads->Clone());
index 5ce63e2..4440900 100644 (file)
@@ -51,10 +51,12 @@ public:
   /// Return the cathode's charges asymmetry
   Float_t ChargeAsymmetry() const;
 
+  /// Return chi2 of the RawCharge fit (if any)
   Float_t Chi2() const { return fChi2; }
 
   virtual void Copy(TObject& obj) const;
 
+  /// Return false for pre-cluster
   Bool_t HasPosition() const { return fHasPosition; }
 
   /// Whether we have at least one saturated pad in a given cathode 
@@ -63,8 +65,10 @@ public:
   /// Whether we have one saturated pad on *each* cathode
   Bool_t IsSaturated() const { return IsSaturated(0) && IsSaturated(1); }
   
+  /// Return the max charge on the chathod
   Int_t MaxChargeCathode() const { return Charge(0) > Charge(1) ? 0:1; }
 
+  /// Return the max raw charge on the chathod
   Int_t MaxRawChargeCathode() const { return RawCharge(0) > RawCharge(1) ? 0:1; }
 
   /// Return the smallest pad dimensions for a given cathode
@@ -86,7 +90,9 @@ public:
   
   virtual void Paint(Option_t* opt="");
   
+  /// Return (x,y) of that cluster
   TVector2 Position() const { return fPosition; }
+  /// Return errors on (x,y)
   TVector2 PositionError() const { return fPositionError; }
 
   virtual void Print(Option_t* opt="") const;
@@ -101,12 +107,15 @@ public:
   Float_t RawChargeAsymmetry() const;
   
   void RemovePad(AliMUONPad* pad);
-  
+
+  /// Set cathode (re)computed charges  
   void SetCharge(Float_t chargeCath0, Float_t chargeCath1)
   { fHasCharge = kTRUE; fCharge[0]=chargeCath0; fCharge[1]=chargeCath1; }
-  
+
+  /// Set chi2 of the RawCharge fit   
   void SetChi2(Float_t chi2) { fChi2 = chi2; }
 
+  /// Set (x,y) of that cluster and errors   
   void SetPosition(const TVector2& pos, const TVector2& errorOnPos) 
   { fHasPosition = kTRUE; fPosition = pos; fPositionError = errorOnPos; }
   
index 51d9edd..c23db59 100644 (file)
@@ -30,8 +30,11 @@ public:
   virtual AliMUONCluster* NextCluster();
   
 private:
+  /// Not implemented
   AliMUONClusterFinderCOG(const AliMUONClusterFinderCOG& rhs);
+  /// Not implemented
   AliMUONClusterFinderCOG& operator=(const AliMUONClusterFinderCOG& rhs);
+
   void ComputePosition(AliMUONCluster& cluster);
 
 private:
index 4f5a0cc..9e1b2af 100644 (file)
@@ -350,7 +350,7 @@ AliMUONClusterFinderMLEM::CheckPreclusterOneCathode(AliMUONCluster* cluster)
 AliMUONCluster*
 AliMUONClusterFinderMLEM::CheckPreclusterTwoCathodes(AliMUONCluster* cluster)
 {
-  // Check two-cathode cluster
+  /// Check two-cathode cluster
   
   Int_t i1 = cluster->Multiplicity(0) ? 0 : 1;
   Int_t i2 = cluster->Multiplicity(1) ? 1 : 0;
index 2c3e37e..535f9e6 100644 (file)
@@ -46,7 +46,9 @@ public:
   virtual void Paint(Option_t* opt="");
 
 private:
+  /// Not implemented
   AliMUONClusterFinderMLEM(const AliMUONClusterFinderMLEM& rhs);
+  /// Not implemented
   AliMUONClusterFinderMLEM& operator=(const AliMUONClusterFinderMLEM& rhs);
 
   Bool_t WorkOnPreCluster();
@@ -111,13 +113,13 @@ private:
   static const TVector2 fgkIncreaseSize; ///< idem
   static const TVector2 fgkDecreaseSize; ///< idem
   
-  AliMUONVClusterFinder* fPreClusterFinder; ///!< the pre-clustering worker
-  AliMUONCluster* fPreCluster; ///<! current pre-cluster
-  TObjArray fClusterList; ///!< clusters corresponding to the current pre-cluster
+  AliMUONVClusterFinder* fPreClusterFinder; //!< the pre-clustering worker
+  AliMUONCluster* fPreCluster; //!< current pre-cluster
+  TObjArray fClusterList; //!< clusters corresponding to the current pre-cluster
   
-  Int_t fEventNumber; ///!< current event being processed
-  Int_t fDetElemId; ///!< current DE being processed
-  Int_t fClusterNumber; ///!< current cluster number
+  Int_t fEventNumber; //!< current event being processed
+  Int_t fDetElemId; //!< current DE being processed
+  Int_t fClusterNumber; //!< current cluster number
   
   const AliMpVSegmentation *fSegmentation[2]; //!< new segmentation
   
@@ -133,6 +135,8 @@ private:
   Bool_t fPlot; //!< whether we should plot thing (for debug only, quite slow!)
   
   TObjArray* fTimers; //!< internal timers
+  
+  /// \todo add comment
   enum ETimer { kMainLoop, kCheckPreCluster, kLast };
   
   AliMUONClusterSplitterMLEM* fSplitter; //!< helper class to go from pixel arrays to clusters
index d2a95ff..d93b5c1 100644 (file)
@@ -30,8 +30,11 @@ public:
   virtual AliMUONCluster* NextCluster();
   
 private:
+  /// Not implemented
   AliMUONClusterFinderSimpleFit(const AliMUONClusterFinderSimpleFit& rhs);
+  /// Not implemented
   AliMUONClusterFinderSimpleFit& operator=(const AliMUONClusterFinderSimpleFit& rhs);
+
   void ComputePosition(AliMUONCluster& cluster);
 
 private:
index d8ab5c9..0cedb06 100644 (file)
@@ -64,7 +64,7 @@ class AliMUONClusterFinderVS : public TObject
     TClonesArray*  GetRawClusters() {return fRawClusters;}
 /// Reset raw clusters
     void ResetRawClusters();
-// set evt number
+/// Set evt number
     void SetEventNumber(Int_t evtNumber) {fEvtNumber = evtNumber;}
 
  protected:
index 505aecc..8aec46f 100644 (file)
@@ -71,10 +71,12 @@ class AliMUONClusterInput : public TObject
     Float_t DiscrChargeS2(Int_t i,Double_t *par);
     Float_t DiscrChargeCombiS2(Int_t i,Double_t *par, Int_t cath);
 // 
- protected:
-    AliMUONClusterInput();
  private:
+    /// Not implemented
+    AliMUONClusterInput();
+    /// Not implemented
     AliMUONClusterInput(const AliMUONClusterInput& clusterInput);
+    /// Not implemented
     AliMUONClusterInput & operator = (const AliMUONClusterInput& rhs);
 
     static AliMUONClusterInput*  fgClusterInput;  //!< singleton instance
index 40cc7a0..b684a2a 100644 (file)
@@ -32,14 +32,15 @@ class AliMUONClusterReconstructor : public TObject
   virtual void   Digits2Clusters(Int_t chBeg = 0);
   virtual void   Trigger2Trigger() ;
 
-  // Reco Model
+  /// Return cluster recontruction model
   AliMUONClusterFinderVS* GetRecoModel() {return fRecModel;}
 
   void SetRecoModel(AliMUONClusterFinderVS* rec);
 
  protected:
-
+  /// Not implemented
   AliMUONClusterReconstructor (const AliMUONClusterReconstructor& rhs); // copy constructor
+  /// Not implemented
   AliMUONClusterReconstructor& operator=(const AliMUONClusterReconstructor& rhs); // assignment operator
 
   void ClusterizeOneDE(Int_t detElemId);
index 44883c1..0f077dc 100644 (file)
@@ -87,6 +87,8 @@ fnCoupled(0)
 //_____________________________________________________________________________
 AliMUONClusterSplitterMLEM::~AliMUONClusterSplitterMLEM()
 {
+  /// Destructor
+  
   delete fMathieson;
 }
 
index d2d28e9..1c7dc5b 100644 (file)
@@ -75,17 +75,17 @@ public:
   void UpdatePads(const AliMUONCluster& cluster, Int_t nfit, Double_t *par);
 
 private:
-  // will not be implemented
+  /// will not be implemented
   AliMUONClusterSplitterMLEM(const AliMUONClusterSplitterMLEM&);
-  // will not be implemented
+  /// will not be implemented
   AliMUONClusterSplitterMLEM& operator=(const AliMUONClusterSplitterMLEM&);
   
 private:
   
     static const Double_t fgkCouplMin; ///< threshold on coupling 
 
-  TObjArray* fPixArray; //! < not owner
-  AliMUONMathieson* fMathieson; //!< 
+  TObjArray* fPixArray; //!< \todo add comment
+  AliMUONMathieson* fMathieson; //!< Mathieson
   Int_t fDetElemId; //!< detection element we are working on
   Int_t fNpar; //!< number of fit parameters
   Double_t fQtot; //!< total charge
index 66ebf62..81e0c58 100644 (file)
@@ -33,7 +33,9 @@ class AliMUONCommonGeometryBuilder : public AliMUONVGeometryBuilder
   protected:
  
   private:
+    /// Not implemented
     AliMUONCommonGeometryBuilder(const AliMUONCommonGeometryBuilder& right);
+    /// Not implemented
     AliMUONCommonGeometryBuilder&  
                      operator = (const AliMUONCommonGeometryBuilder& right);
     // data members
index 8344722..162f876 100644 (file)
@@ -28,13 +28,13 @@ public:
    void    AddDspHeader(const AliMUONDspHeader& dspHeader, Int_t iBlock);
    void    AddBlkHeader(const AliMUONBlockHeader& blkHeader);
 
-   // get TClonesArray
+   /// get TClonesArray
    TClonesArray*  GetBlkHeaderArray() const {return fBlkHeaderArray;}
 
-   // get entries
+   /// get entries
    Int_t GetBlkHeaderEntries() const {return fBlkHeaderArray->GetEntriesFast();}
  
-   // get entry
+   /// get entry
    AliMUONBlockHeader* GetBlkHeaderEntry(Int_t i) const {
      return (AliMUONBlockHeader*)fBlkHeaderArray->At(i);}
 
@@ -43,11 +43,12 @@ public:
 
 
  private:
-
-   TClonesArray* fBlkHeaderArray;  ///< array of block header
+   /// Not implemented
    AliMUONDDLTracker(const AliMUONDDLTracker& event);
+   /// Not implemented
    AliMUONDDLTracker& operator=(const AliMUONDDLTracker& event);
+
+   TClonesArray* fBlkHeaderArray;  ///< array of block header
  
    ClassDef(AliMUONDDLTracker,1)  // MUON DDL Tracker
 };
index 97e3a07..9ed440f 100644 (file)
@@ -27,17 +27,17 @@ public:
    void    AddLocStruct(const AliMUONLocalStruct& loc, Int_t iReg);
    void    AddRegHeader(const AliMUONRegHeader& regHeader);
 
-   // get AliMUONDarcHeader
+   /// get AliMUONDarcHeader
    AliMUONDarcHeader*  GetDarcHeader() const {return fDarcHeader;}
 
  private:
-
-
-   AliMUONDarcHeader* fDarcHeader;  ///< pointer of darc header
-
+   /// Not implemented
    AliMUONDDLTrigger(const AliMUONDDLTrigger& event);
+   /// Not implemented
    AliMUONDDLTrigger& operator=(const AliMUONDDLTrigger& event);
 
+   AliMUONDarcHeader* fDarcHeader;  ///< pointer of darc header
+
    ClassDef(AliMUONDDLTrigger,1)  // MUON DDL Trigger
 };
 #endif
index c74c30f..18185c0 100644 (file)
@@ -26,70 +26,108 @@ public:
    virtual ~AliMUONDarcHeader();
 
 
+            /// Return first word
    UInt_t   GetWord()               const {return fWord;}
+            /// Return global input
    Int_t    GetGlobalInput(Int_t n) const {return fGlobalInput[n];}
+            /// Return global output
    UChar_t  GetGlobalOutput()       const {return (fGlobalOutput & 0xFF);}
+            /// Return global config  
    UShort_t GetGlobalConfig()       const {return ((fGlobalOutput >> 16) & 0xFFFF);}
 
    //MBZ:1, phys trig:1, type:3, ,SerialNb:4,Version:8,VME trig:1, 
    //GlobalFlag:1, CTP trig:1, DAQ:1, Reg pattern:8;
 
+            /// Return event type
    Bool_t  GetEventType()  const {return (fWord &  0x40000000);}
+            /// Return Darc type
    UChar_t GetDarcType()   const {return (UChar_t)(fWord >> 27) &  0x7;}
+            /// Return serial number
    UChar_t GetSerialNb()   const {return (UChar_t)(fWord >> 23) &  0xF;}
+            /// Return version
    UChar_t GetVersion()    const {return (UChar_t)(fWord >> 15) &  0xFF;}
+            /// Return VME trig
    Bool_t  GetVMETrig()    const {return (fWord &  0x800);}
+            /// Return global flag
    Bool_t  GetGlobalFlag() const {return (fWord &  0x400);}
+            /// Return CPT trigger
    Bool_t  GetCTPTrig()    const {return (fWord &  0x200);}
+            /// Return DAQ flag
    Bool_t  GetDAQFlag()    const {return (fWord &  0x100);}
+            /// Return reg pattern
    UChar_t GetRegPattern() const {return (UChar_t)(fWord &  0xFF);}
 
+           /// Set first word
    void    SetWord(UInt_t w) {fWord = w;}
+           /// Set global input
    void    SetGlobalInput(Int_t in, Int_t n) {fGlobalInput[n] = in;}
+           /// Set global output
    void    SetGlobalOutput(Int_t out) {fGlobalOutput = out;}
 
+            /// Return darc header length
    Int_t   GetDarcHeaderLength()   const {return fgkDarcHeaderLength;}
+            /// Return global header length
    Int_t   GetGlobalHeaderLength() const {return fgkGlobalHeaderLength;}
 
+            /// Return header
    UInt_t* GetHeader() {return &fWord;}
+            /// Return global input
    Int_t*  GetGlobalInput()    {return &fGlobalInput[0];}
 
   // DARC get methods
+            /// Return DARC L0 received and used
    UInt_t  GetDarcL0R()     const {return fDarcL0R;}
+            /// Return DARC L1 physics
    UInt_t  GetDarcL1P()     const {return fDarcL1P;}
+            /// Return DARC L1 software
    UInt_t  GetDarcL1S()     const {return fDarcL1S;}
+            /// Return DARC L2 accept
    UInt_t  GetDarcL2A()     const {return fDarcL2A;}
+            /// Return DARC L2 reject
    UInt_t  GetDarcL2R()     const {return fDarcL2R;}
+            /// Return DARC clock
    UInt_t  GetDarcClock()   const {return fDarcClk;}
+            /// Return DARC hold (dead time)
    UInt_t  GetDarcHold()    const {return fDarcHold;}
    
    // don't use setting methods but memcpy
+            /// Return global L0
    UInt_t* GetGlobalScalers()  {return &fGlobalL0;}
+            /// Return DARC L0 received and used
    UInt_t* GetDarcScalers()    {return &fDarcL0R;} 
 
    // global get methods
+            /// Return global L0
    UInt_t  GetGlobalL0()      const {return fGlobalL0;}
+            /// Return global clock
    UInt_t  GetGlobalClock()   const {return fGlobalClk;}
+            /// Return global scaler
    const UInt_t* GetGlobalScaler()  const {return fGlobalScaler;}
+            /// Return global hold (dead time)
    UInt_t  GetGlobalHold()    const {return fGlobalHold;}
+            /// Return global spare
    UInt_t  GetGlobalSpare()   const {return fGlobalSpare;}
 
+            /// Return length of global scaler in word
    Int_t GetGlobalScalerLength() const {return fgkGlobalScalerLength;}
+            /// Return length of DARC scaler in word
    Int_t GetDarcScalerLength()   const {return fgkDarcScalerLength;} 
 
+            /// Return end of darc info word
    UInt_t GetEndOfDarc()     const {return fgkEndOfDarc;} 
+            /// Return end of global info word
    UInt_t GetEndOfGlobal()   const {return fgkEndOfGlobal;} 
 
    // set random numbers to fill variable
    void SetScalersNumbers();
 
-  // get TClonesArray
+   /// get TClonesArray
    TClonesArray*  GetRegHeaderArray()  const {return fRegHeaderArray;}
 
-   // get entries
+   /// get entries
    Int_t GetRegHeaderEntries()  const {return fRegHeaderArray->GetEntriesFast();}
 
-   // get entry
+   /// get entry
    AliMUONRegHeader* GetRegHeaderEntry(Int_t i) const  {
      return (AliMUONRegHeader*)fRegHeaderArray->At(i);}
 
index 25f28fc..b3bee02 100644 (file)
@@ -15,7 +15,7 @@
 
 /* $Id$ */
 
-/// \class AliMUONData class
+/// \class AliMUONData
 ///
 /// Class containing MUON data: hits, digits, rawclusters, globaltrigger, localtrigger, etc ..
 /// The classe makes the lik between the MUON data lists and the event trees from loaders
@@ -80,7 +80,7 @@ ClassImp(AliMUONData)
     fSplitLevel(0),
     fCurrentEvent(-1)
 {
-  // Default constructor
+/// Default constructor
 }
 //_____________________________________________________________________________
 AliMUONData::AliMUONData(AliLoader * loader, const char* name, const char* title):
@@ -206,7 +206,7 @@ void AliMUONData::AddHit(Int_t fIshunt, Int_t track, Int_t detElemId,
                         Float_t phi, Float_t length, Float_t destep,
                         Float_t Xref,Float_t Yref,Float_t Zref)
 {
- // Add new hit to the hit list
+ /// Add new hit to the hit list
 
   TClonesArray &lhits = *fHits;
   new(lhits[fNhits++]) AliMUONHit(fIshunt, track, detElemId, 
@@ -1207,7 +1207,8 @@ AliMUONData::Print(Option_t* opt) const
 void 
 AliMUONData::DumpKine(Int_t event2Check)
 {
-  // Load kinematics
+/// Dump kinematics
+
   fRunLoader->LoadKinematics("READ");
 
   Int_t nevents = fRunLoader->GetNumberOfEvents();
@@ -1236,7 +1237,8 @@ AliMUONData::DumpKine(Int_t event2Check)
 void 
 AliMUONData::DumpHits(Int_t event2Check, Option_t* opt)
 {
-  // Loading data
+/// Dump hits
+
   fLoader->LoadHits("READ");
 
   // Event loop
@@ -1272,7 +1274,8 @@ AliMUONData::DumpHits(Int_t event2Check, Option_t* opt)
 void 
 AliMUONData::DumpDigits(Int_t event2Check, Option_t* opt)
 {
-  // Loading data
+/// Dump digits
+
   fLoader->LoadDigits("READ");
   
   // Event loop
@@ -1302,7 +1305,8 @@ AliMUONData::DumpDigits(Int_t event2Check, Option_t* opt)
 void 
 AliMUONData::DumpSDigits(Int_t event2Check, Option_t* opt)
 {
-  // Loading data
+/// Dump SDigits
+
   fLoader->LoadSDigits("READ");
   
   // Event loop
@@ -1338,7 +1342,8 @@ AliMUONData::DumpSDigits(Int_t event2Check, Option_t* opt)
 void 
 AliMUONData::DumpRecPoints(Int_t event2Check, Option_t* opt) 
 {
-  // Loading data
+/// Dump rec points
+
   fLoader->LoadRecPoints("READ");
 
   // Event loop
index 8ce3a25..fa7959e 100644 (file)
@@ -96,6 +96,7 @@ class AliMUONData : public TNamed
     void           GetRecTracks() const;
     void           GetRecTriggerTracks() const;
 
+                   /// Return split level
     Int_t          GetSplitLevel() const {return fSplitLevel;}
 
     Bool_t        IsRawClusterBranchesInTree();
@@ -150,7 +151,9 @@ class AliMUONData : public TNamed
     void DumpRecTrigger(Int_t event2Check=0, Int_t write = 0, Bool_t readFromRP = kTRUE);
     
   protected: 
+    /// Not implemented
     AliMUONData(const AliMUONData& rhs);
+    /// Not implemented
     AliMUONData& operator=(const AliMUONData& rhs);
 
     AliRunLoader*   fRunLoader; //!< Run loader pointer
index fc6efed..ea821a5 100644 (file)
@@ -92,25 +92,28 @@ class AliMUONDataInterface : public TObject
   Int_t NumberOfRecTracks();
   AliMUONTrack* RecTrack(Int_t rectrack);
   
+  /// Returns the file name from which we are fetching data
   TString CurrentFile() const    { return fFilename;    };
   
-  // Returns the name of the currently selected folder.
+  /// Returns the name of the currently selected folder.
   TString CurrentFolder() const   { return fFoldername;  };
   
-  // Returns the number of the currently selected event.
+  /// Returns the number of the currently selected event.
   Int_t   CurrentEvent() const    { return fEventnumber; };
   
-  // Returns the currently selected track.
+  /// Returns the currently selected track.
   Int_t   CurrentTrack() const    { return fTrack;       };
   
-  // Returns the currently selected cathode in TreeS.
+  /// Returns the currently selected cathode in TreeS.
   Int_t   CurrentSCathode() const { return fSCathode;    };
   
-  // Returns the currently selected cathode in TreeD.
+  /// Returns the currently selected cathode in TreeD.
   Int_t   CurrentDCathode() const { return fCathode;     };
   
  private:
+  /// Not implemented
   AliMUONDataInterface(const AliMUONDataInterface& rhs);
+  /// Not implemented
   AliMUONDataInterface& operator=(const AliMUONDataInterface& rhs);
   
   Bool_t FetchMuonLoader(TString filename, TString foldername);
index b48a4bc..79711c5 100644 (file)
@@ -66,6 +66,7 @@ AliMUONDataIterator::AliMUONDataIterator()
 TObject(),
 fIterator(0x0)
 {
+/// Default constructor
 }
 
 //_____________________________________________________________________________
@@ -76,6 +77,8 @@ AliMUONDataIterator::AliMUONDataIterator(AliMUONData* data,
 TObject(),
 fIterator(0x0)
 {
+/// Standard constructor
+
   TString opt(onWhatToIterate);
   opt.ToLower();
   if ( opt.Contains("digit") || opt.Contains("d") )
@@ -95,6 +98,8 @@ fIterator(0x0)
 //_____________________________________________________________________________
 AliMUONDataIterator::~AliMUONDataIterator()
 {
+/// Destructor
+
   delete fIterator;
 }
 
@@ -102,6 +107,8 @@ AliMUONDataIterator::~AliMUONDataIterator()
 TObject* 
 AliMUONDataIterator::Next() 
 { 
+/// Set iterator to the next element
+
   if (fIterator) return fIterator->Next(); 
   return 0x0;
 }
@@ -109,7 +116,9 @@ AliMUONDataIterator::Next()
 //_____________________________________________________________________________
 Bool_t 
 AliMUONDataIterator::Remove() 
-{ 
+{
+/// Remove current element
   if (fIterator) return fIterator->Remove(); 
   return kFALSE;
 }
@@ -118,5 +127,7 @@ AliMUONDataIterator::Remove()
 void 
 AliMUONDataIterator::Reset() 
 { 
+/// Reset 
+
   if (fIterator) fIterator->Reset(); 
 }
index 423d04e..0c3bf6d 100644 (file)
@@ -22,7 +22,7 @@ class AliMUONVDataIterator;
 class AliMUONDataIterator : public TObject
 {
 public:
-
+  /// Iteration style
   enum EIterationStyle { kAllChambers, kTrackingChambers, kTriggerChambers };
   
   AliMUONDataIterator();
@@ -40,7 +40,9 @@ private:
   AliMUONVDataIterator* fIterator; //!< the real worker   
 
 private:
+  /// Not implemented
   AliMUONDataIterator(const AliMUONDataIterator& rhs);
+  /// Not implemented
   AliMUONDataIterator& operator=(const AliMUONDataIterator& rhs);
   
   ClassDef(AliMUONDataIterator,0) // Iterator on MUON data structures.
index d2e00e6..a17ddfd 100644 (file)
@@ -32,30 +32,30 @@ class AliMUONDetElement : public TObject
                     AliMUONClusterFinderAZ *recModel, AliMUONSegmentation* segmentation); // constructor
   virtual ~AliMUONDetElement(); // Destructor
 
-  Int_t IdDE(void) const { return fidDE; } // det. elem. ID
-  Int_t Chamber(void) const { return fChamber; } // chamber No
-  Double_t Z(void) const { return fZ; } // Z-coordinate
-  Int_t Left(Int_t cath) const { return fLeft[cath]; } // number of unused digits
-  //Int_t GetMapElem(AliMUONDigit *digit) const; // get map element
-  TObjArray *Digits(Int_t cath) const { return fDigits[cath]; } // array of digits
-  TObjArray *RawClusters() const { return fRawClus; } // array of raw clusters
-  TObjArray *HitsForRec() const { return fHitsForRec; } // hits for rec.
-  Int_t NHitsForRec() const { return fNHitsForRec; } // No. of hits for rec.
+  Int_t IdDE(void) const { return fidDE; } ///< det. elem. ID
+  Int_t Chamber(void) const { return fChamber; } ///< chamber No
+  Double_t Z(void) const { return fZ; } ///< Z-coordinate
+  Int_t Left(Int_t cath) const { return fLeft[cath]; } ///< number of unused digits
+  //Int_t GetMapElem(AliMUONDigit *digit) const; ///< get map element
+  TObjArray *Digits(Int_t cath) const { return fDigits[cath]; } ///< array of digits
+  TObjArray *RawClusters() const { return fRawClus; } ///< array of raw clusters
+  TObjArray *HitsForRec() const { return fHitsForRec; } ///< hits for rec.
+  Int_t NHitsForRec() const { return fNHitsForRec; } ///< No. of hits for rec.
   //Bool_t Inside(Double_t x, Double_t y, Double_t z) const; // check if point inside DE
   Bool_t Inside(Double_t x, Double_t y, Double_t z, Double_t dx, Double_t dy) const; // check if point inside DE
   
-  void SetID(Int_t idDE) { fidDE = idDE; } // set det. elem. ID
-  void SetIndex(Int_t index) { fIndex = index; } // set position index
-  void SetZ(Double_t z) { fZ = z; } // set Z-coord.
-  void SetLeft(Int_t cath, Int_t left) { fLeft[cath] = left; } // set No. of digits
-  //void SetMapElem(const AliMUONDigit *digit, Int_t flag); // set map element 
-  void AddDigit(AliMUONDigit *dig); // add digit
-  void Fill(AliMUONData *data); // fill hit maps 
-  void ClusterReco(Double_t x, Double_t y, Double_t dx, Double_t dy); // run cluster reco around (x,y)
-  void AddHitForRec(AliMUONRawCluster *clus); // make HitForRec
-  // What is necessary for sorting TObjArray's
+  void SetID(Int_t idDE) { fidDE = idDE; } ///< set det. elem. ID
+  void SetIndex(Int_t index) { fIndex = index; } ///< set position index
+  void SetZ(Double_t z) { fZ = z; } ///< set Z-coord.
+  void SetLeft(Int_t cath, Int_t left) { fLeft[cath] = left; } ///< set No. of digits
+  //void SetMapElem(const AliMUONDigit *digit, Int_t flag); ///< set map element 
+  void AddDigit(AliMUONDigit *dig); ///< add digit
+  void Fill(AliMUONData *data); ///< fill hit maps 
+  void ClusterReco(Double_t x, Double_t y, Double_t dx, Double_t dy); ///< run cluster reco around (x,y)
+  void AddHitForRec(AliMUONRawCluster *clus); ///< make HitForRec
+  /// What is necessary for sorting TObjArray's
   Bool_t IsSortable() const { return kTRUE; }
-  Int_t Compare(const TObject* detElem) const; // "Compare" function for sorting
+  Int_t Compare(const TObject* detElem) const; ///< "Compare" function for sorting
 
  private:
   Int_t fidDE; ///< det. elem. ID
@@ -72,7 +72,9 @@ class AliMUONDetElement : public TObject
   AliMUONClusterFinderAZ *fRecModel; ///< cluster finder
 
   // Functions
+  /// Not implemented
   AliMUONDetElement(const AliMUONDetElement & rhs); // copy constructor
+  /// Not implemented
   AliMUONDetElement& operator = (const AliMUONDetElement& rhs); // assignment operator
 
   ClassDef(AliMUONDetElement,0) // detection element object
index d2f03bb..195e242 100644 (file)
@@ -383,6 +383,8 @@ AliMUONDigit::Saturated(Bool_t value)
 void
 AliMUONDigit::SetElectronics(Int_t manuId, Int_t manuChannel)
 {
+  /// Set manuIs and manuChannel
+
   //
   //FIXME: should we check that the values are ok here ??
   //
index d30c6b2..693bf9c 100644 (file)
@@ -29,9 +29,9 @@ class AliMUONDigit : public TObject
     virtual Int_t PadY() const         {return fPadY;}       ///< Return pad number along y
     virtual Int_t Cathode() const      {return fCathode;}    ///< Return cathode number
     
-    virtual Float_t Signal() const       {return fSignal;}     ///< Return signal amplitude
+    virtual Float_t Signal() const     {return fSignal;}     ///< Return signal amplitude
     
-    virtual Float_t Physics() const      {return fPhysics;}    ///< Return MC physics contribution to signal
+    virtual Float_t Physics() const    {return fPhysics;}    ///< Return MC physics contribution to signal
     
     virtual Int_t Hit() const          {return fHit;}        ///< Return MC hit number
     
@@ -46,24 +46,24 @@ class AliMUONDigit : public TObject
     virtual Bool_t IsSaturated() const;
     virtual Bool_t IsNoiseOnly() const;
     virtual Bool_t IsEfficiencyApplied() const;
-    virtual UInt_t StatusMap() const { return fStatusMap; }
+    virtual UInt_t StatusMap() const { return fStatusMap; }    ///< Return Neighbouring pad status
     
     virtual void NoiseOnly(Bool_t value=kTRUE);
     virtual void Saturated(Bool_t saturated=kTRUE);
     virtual void EfficiencyApplied(Bool_t value=kTRUE);
     
     virtual void SetElectronics(Int_t manuId, Int_t manuChannel);
-    virtual void SetADC(Int_t adc) { fADC=adc; }
+    virtual void SetADC(Int_t adc)         {fADC=adc; }        ///< Set ADC value
     virtual void SetDetElemId(Int_t id)    {fDetElemId = id;}  ///< Set detection element ID
     virtual void SetPadX(Int_t pad)        {fPadX = pad;}      ///< Set pad number along x
     virtual void SetPadY(Int_t pad)        {fPadY = pad;}      ///< Set pad number along y
-    virtual void SetSignal(Float_t q)        {fSignal = q;}      ///< Set signal amplitude
-    virtual void AddSignal(Float_t q)        {fSignal += q;}     ///< Add signal amplitude
-    virtual void AddPhysicsSignal(Float_t q) {fPhysics += q;}    ///< Add MC physics contribution to signal
+    virtual void SetSignal(Float_t q)        {fSignal = q;}    ///< Set signal amplitude
+    virtual void AddSignal(Float_t q)        {fSignal += q;}   ///< Add signal amplitude
+    virtual void AddPhysicsSignal(Float_t q) {fPhysics += q;}  ///< Add MC physics contribution to signal
     virtual void SetHit(Int_t n)           {fHit = n;}         ///< Set MC hit number
     virtual void SetCathode(Int_t c)       {fCathode = c;}     ///< Set cathode number
-    virtual void SetPhysicsSignal(Float_t q) {fPhysics = q; }    ///< Set MC physics contribution to signal
-    virtual void SetStatusMap(UInt_t statusMap) { fStatusMap = statusMap; }
+    virtual void SetPhysicsSignal(Float_t q) {fPhysics = q; }  ///< Set MC physics contribution to signal
+    virtual void SetStatusMap(UInt_t statusMap) { fStatusMap = statusMap; } ///< Set status map
     
     virtual void Print(Option_t* opt="") const;
     
index 50922c3..ec3d19d 100644 (file)
@@ -32,7 +32,9 @@ public:
   virtual void Exec(Option_t*);
 
 private:    
+    /// Not implemented
     AliMUONDigitCalibrator(const AliMUONDigitCalibrator& other);
+    /// Not implemented
     AliMUONDigitCalibrator& operator=(const AliMUONDigitCalibrator& other);
 
     AliMUONData* fData;                       //!< MUON data 
index 84b5759..6c19203 100644 (file)
@@ -61,6 +61,12 @@ class AliMUONDigitMaker : public TObject
   void  SetCrateManager(AliMUONTriggerCrateStore* crateManager) {fCrateManager =  crateManager;}
 
  private:
+  /// Not implemented
+  AliMUONDigitMaker (const AliMUONDigitMaker& rhs); // copy constructor
+  /// Not implemented
+  AliMUONDigitMaker& operator=(const AliMUONDigitMaker& rhs); // assignment operator
+
+  void GetCrateName(Char_t* name, Int_t iDDL, Int_t iReg) const;
 
   AliMUONData*     fMUONData;          //!< Data container for MUON subsystem 
   
@@ -84,11 +90,6 @@ class AliMUONDigitMaker : public TObject
   TStopwatch fTriggerTimer;                    //!< time watcher for trigger part
   TStopwatch fMappingTimer;                    //!< time watcher for mapping-tracker part
 
-  AliMUONDigitMaker (const AliMUONDigitMaker& rhs); // copy constructor
-  AliMUONDigitMaker& operator=(const AliMUONDigitMaker& rhs); // assignment operator
-
-  void GetCrateName(Char_t* name, Int_t iDDL, Int_t iReg) const;
-
   ClassDef(AliMUONDigitMaker,1) // MUON digit maker from rawdata
 };
        
index 583150a..54eeb24 100644 (file)
@@ -44,8 +44,9 @@ class AliMUONDigitMapA1 : public TObject
     virtual FlagType TestHit(Int_t ix, Int_t iy) const;
 
  private:
+    /// Not implemented
     AliMUONDigitMapA1(const AliMUONDigitMapA1 & hitMap);
-    // Assignment operator
+    /// Not implemented
     AliMUONDigitMapA1& operator = (const AliMUONDigitMapA1& rhs);
 
     // Check index
index 3b28a95..0323abc 100644 (file)
@@ -41,8 +41,9 @@ public:
   virtual Bool_t Init();
 
 private:
-    
+  /// Not implemented
   AliMUONDigitizerV3(const AliMUONDigitizerV3& other);
+  /// Not implemented
   AliMUONDigitizerV3& operator=(const AliMUONDigitizerV3& other);
   
   void AddOrUpdateDigit(TClonesArray& array, 
index 009e424..3e77839 100644 (file)
@@ -67,17 +67,17 @@ public:
    TObjArray        *Phits() {return fPhits;}     ///< Return hit points for each chamber
    TObjArray        *Rpoints() {return fRpoints;} ///< Return cog points for each cathode
    virtual void      Paint(Option_t *option="");
-   virtual void      SetDrawClusters(Bool_t draw=kTRUE) {fDrawClusters=draw;}   // *MENU*
-   virtual void      SetChamberAndCathode(Int_t chamber=1, Int_t cathode=1);    // *MENU*
-   virtual void      SetDrawCoG(Bool_t draw=kTRUE) {fDrawCoG=draw;}             // *MENU*
-   virtual void      SetDrawTracks(Bool_t draw=kTRUE) {fDrawTracks=draw;}       // *MENU*
-   virtual void      SetRange(Float_t rrange=250., Float_t zrange=1050.);       // *MENU*
-   virtual void      SetEvent(Int_t newevent=0);                                // *MENU*   
+   virtual void      SetDrawClusters(Bool_t draw=kTRUE) {fDrawClusters=draw;}   ///< Set flag to draw clusters
+   virtual void      SetChamberAndCathode(Int_t chamber=1, Int_t cathode=1);    ///< Set chamber and cathod
+   virtual void      SetDrawCoG(Bool_t draw=kTRUE) {fDrawCoG=draw;}             ///< Set flag to draw CoG 
+   virtual void      SetDrawTracks(Bool_t draw=kTRUE) {fDrawTracks=draw;}       ///< Set flag to draw tracks
+   virtual void      SetRange(Float_t rrange=250., Float_t zrange=1050.);      
+   virtual void      SetEvent(Int_t newevent=0);                                  
    virtual void      SetView(Float_t theta=0, Float_t phi=-90, Float_t psi=0);
    virtual void      SetPickMode();
    virtual void      SetZoomMode();
    virtual void      ShowNextEvent(Int_t delta=1);
-   virtual void      UnZoom();                                                   // *MENU* 
+   virtual void      UnZoom();                                                
    virtual void      ResetPoints();
    virtual void      ResetPhits();
    virtual void      ResetRpoints();
@@ -86,7 +86,9 @@ public:
            void      Trigger();
 
 protected:
+                     /// Not implemented
                     AliMUONDisplay(const AliMUONDisplay& display);
+                     /// Not implemented
    AliMUONDisplay&   operator = (const AliMUONDisplay& rhs);
           
 
index 856aa75..5063722 100644 (file)
@@ -26,43 +26,67 @@ public:
    virtual ~AliMUONDspHeader();
 
    // DSP header
+           /// Return Data key word for FRT header
    Int_t   GetDataKey()        const {return fDataKey;}
+           /// Return total length of block structure
    Int_t   GetTotalLength()    const {return fTotalLength;}
+           /// Return length of raw data
    Int_t   GetLength()         const {return fLength;}
+           /// Return Dsp id
    Int_t   GetDspId()          const {return fDspId;}
+           /// Return L1 accept in Block Structure (CRT)
    Int_t   GetBlkL1ATrigger()  const {return fBlkL1ATrigger;}
+           /// Return Mini Event Id in bunch crossing
    Int_t   GetMiniEventId()    const {return fMiniEventId;}
+           /// Return Number of L1 accept in DSP Structure (FRT)
    Int_t   GetL1ATrigger()     const {return fL1ATrigger;}
+           /// Return Number of L1 reject in DSP Structure (FRT)
    Int_t   GetL1RTrigger()     const {return fL1RTrigger;}
+           /// Return padding dummy word for 64 bits transfer
    UInt_t  GetPaddingWord()    const {return fPaddingWord;}
+           /// Return Error word
    Int_t   GetErrorWord()      const {return fErrorWord;}
 
+           /// Return header length
    Int_t   GetHeaderLength()   const {return fgkHeaderLength;}
+           /// Return default data key word for FRT header
    UInt_t  GetDefaultDataKey() const {return fgkDefaultDataKey;}
+           /// Return default padding word value
    UInt_t  GetDefaultPaddingWord() const {return fgkDefaultPaddingWord;}
 
+           /// Set Data key word for FRT header
    void    SetDataKey(Int_t d)        {fDataKey = d;}
+           /// Set total length of block structure
    void    SetTotalLength(Int_t l)    {fTotalLength = l;}
+           /// Set length of raw data
    void    SetLength(Int_t l)         {fLength = l;}
+           /// Set Dsp id
    void    SetDspId(Int_t d)          {fDspId = d;}  
+           /// Set L1 accept in Block Structure (CRT)
    void    SetBlkL1ATrigger(Int_t l1) {fBlkL1ATrigger = l1;}
+           /// Set Mini Event Id in bunch crossing
    void    SetMiniEventId(Int_t id)   {fMiniEventId = id;}
+           /// Set Number of L1 accept in DSP Structure (FRT)
    void    SetL1ATrigger(Int_t l1a)   {fL1ATrigger = l1a;}
+           /// Set Number of L1 reject in DSP Structure (FRT)
    void    SetL1RTrigger(Int_t l1r)   {fL1RTrigger = l1r;}
+           /// Set padding dummy word for 64 bits transfer
    void    SetPaddingWord(UInt_t w)   {fPaddingWord = w;}
+           /// Set Error word
    void    SetErrorWord(Int_t w)      {fErrorWord = w;}
 
+           /// Return header
    Int_t*  GetHeader() {return &fDataKey;}
 
    void    AddBusPatch(const AliMUONBusStruct& busPatch);
 
-   // get TClonesArray
+   /// get TClonesArray
    TClonesArray*  GetBusPatchArray()  const {return fBusPatchArray;}
 
-   // get entries
+   /// get entries
    Int_t GetBusPatchEntries()  const {return fBusPatchArray->GetEntriesFast();}
 
-   // get entry
+   /// get entry
    AliMUONBusStruct* GetBusPatchEntry(Int_t i) const {
      return (AliMUONBusStruct*)fBusPatchArray->At(i);}
 
index 8ebbb6b..7222b08 100644 (file)
@@ -30,16 +30,21 @@ class AliMUONEventRecoCombi : public TObject
     void FillEvent(AliMUONData *data, AliMUONClusterFinderAZ *recModel); // fill event info
     void FillRecP(AliMUONData *dataCluster, AliMUONTrackReconstructorK *recoTrack) const; // fill used rec. points from det. elems
 
-    Int_t Nz() const { return fNZ; } // number of DE different Z-positions
-    Double_t Z(Int_t iz) const { return (*fZ)[iz]; } // Z of DE
-    Int_t *DEatZ(Int_t iz) const { return fDEvsZ[iz]+1; } // list of DE's at Z
-    AliMUONDetElement *DetElem(Int_t iPos) const { return (AliMUONDetElement*) fDetElems->UncheckedAt(iPos); }
+    Int_t Nz() const { return fNZ; } ///< number of DE different Z-positions
+    Double_t Z(Int_t iz) const { return (*fZ)[iz]; } ///< Z of DE
+    Int_t *DEatZ(Int_t iz) const { return fDEvsZ[iz]+1; } ///< list of DE's at Z
+    AliMUONDetElement *DetElem(Int_t iPos) const { return (AliMUONDetElement*) fDetElems->UncheckedAt(iPos); } ///< Det element
     Int_t IZfromHit(AliMUONHitForRec *hit) const; // IZ from Hit
 
  protected:
     AliMUONEventRecoCombi(AliMUONSegmentation* segmentation = 0);
 
  private:
+    /// Not implemented
+    AliMUONEventRecoCombi(const AliMUONEventRecoCombi& rhs);
+    /// Not implemented
+    AliMUONEventRecoCombi & operator = (const AliMUONEventRecoCombi& rhs);
+
     static AliMUONEventRecoCombi* fgRecoCombi; //!< singleton instance
     AliMUONSegmentation*  fSegmentation;  //!< Segmentation
     TClonesArray *fDetElems; //!< array of Det. Elem. objects
@@ -47,9 +52,6 @@ class AliMUONEventRecoCombi : public TObject
     Int_t fNZ; //!< number of different Z's
     Int_t **fDEvsZ; //!< list of DE's vs Z-coordinates
 
-    AliMUONEventRecoCombi(const AliMUONEventRecoCombi& rhs);
-    AliMUONEventRecoCombi & operator = (const AliMUONEventRecoCombi& rhs);
-
     ClassDef(AliMUONEventRecoCombi, 0) // Combined cluster/track finder steering class
       };
 #endif
index 7d65920..2bb279f 100644 (file)
@@ -32,7 +32,9 @@ class AliMUONGMSSubprocessor : public AliMUONVSubprocessor
     virtual UInt_t Process(TMap* /*dcsAliasMap*/);
 
   private:
+    /// Not implemented
     AliMUONGMSSubprocessor(const AliMUONGMSSubprocessor&);
+    /// Not implemented
     AliMUONGMSSubprocessor& operator=(const AliMUONGMSSubprocessor&);
 
     UInt_t ProcessFile(const TString& filename);
@@ -43,9 +45,9 @@ class AliMUONGMSSubprocessor : public AliMUONVSubprocessor
     static const TString  fgkMatrixArrayName;  ///< The fixed matrix array name
   
     // data members
-    AliMUONGeometryTransformer fTransformer;///< Geometry transformer (used to get vo
+    AliMUONGeometryTransformer fTransformer;///< Geometry transformer
 
-    ClassDef(AliMUONGMSSubprocessor, 1); // Shuttle sub-processor for GMS
+    ClassDef(AliMUONGMSSubprocessor, 1) // Shuttle sub-processor for GMS
 };
 
 #endif
index d024c13..37faac0 100644 (file)
@@ -44,7 +44,9 @@ class AliMUONGeometry : public TObject
 
 
   protected:
+    /// Not implemented
     AliMUONGeometry(const AliMUONGeometry& right);
+    /// Not implemented
     AliMUONGeometry&  operator = (const AliMUONGeometry& right);
  
   private:
index 07185a9..3744af2 100644 (file)
@@ -58,7 +58,9 @@ class AliMUONGeometryBuilder : public TObject
     virtual void    SetAlign(const TString& fileName, Bool_t align = true);
  
   protected:
+    /// Not implemented
     AliMUONGeometryBuilder(const AliMUONGeometryBuilder& right);
+    /// Not implemented
     AliMUONGeometryBuilder&  operator = (const AliMUONGeometryBuilder& right);
  
   private:
index 946ad45..3014a8e 100644 (file)
@@ -45,7 +45,9 @@ class AliMUONGeometryConstituent : public TNamed
     const TGeoCombiTrans*  GetTransformation() const;
 
   protected:
+    /// Not implemented
     AliMUONGeometryConstituent(const AliMUONGeometryConstituent& rhs);
+    /// Not implemented
     AliMUONGeometryConstituent& operator = (const AliMUONGeometryConstituent& rhs);
 
   private:
index ffdfe29..87b78e7 100644 (file)
@@ -60,7 +60,9 @@ class AliMUONGeometryDetElement : public TObject
     const TGeoHMatrix*  GetGlobalTransformation() const;
 
   protected:
+    /// Not implemented
     AliMUONGeometryDetElement(const AliMUONGeometryDetElement& rhs);
+    /// Not implemented
     AliMUONGeometryDetElement& operator = (const AliMUONGeometryDetElement& rhs);
   
   private:
@@ -68,7 +70,7 @@ class AliMUONGeometryDetElement : public TObject
     void PrintTransform(const TGeoHMatrix* transform) const;
  
      // static data members
-    static const TString  fgkDENamePrefix; /// < Geometry module name prefix
+    static const TString  fgkDENamePrefix; ///< Geometry module name prefix
  
     // data members
     TString       fDEName;     ///< detection element name
index 561f3df..942705e 100644 (file)
@@ -67,7 +67,9 @@ class AliMUONGeometryEnvelope : public TNamed
     const TObjArray*       GetConstituents() const;
 
   protected:
+    /// Not implemented
     AliMUONGeometryEnvelope(const AliMUONGeometryEnvelope& rhs);
+    /// Not implemented
     AliMUONGeometryEnvelope& operator = (const AliMUONGeometryEnvelope& rhs);
 
   private:
index a02896f..2a1b82d 100644 (file)
@@ -122,7 +122,9 @@ class AliMUONGeometryEnvelopeStore : public TObject
     AliMUONGeometryEnvelope* FindEnvelope(const TString& name) const;
 
   protected:
+    /// Not implemented
     AliMUONGeometryEnvelopeStore(const AliMUONGeometryEnvelopeStore& rhs);
+    /// Not implemented
     AliMUONGeometryEnvelopeStore& operator = (const AliMUONGeometryEnvelopeStore& rhs);
 
   private:
index c862880..2f9e9de 100644 (file)
@@ -69,7 +69,9 @@ class AliMUONGeometryMisAligner:public TObject
     {fUseGaus=!useuni; fUseUni=useuni;}
   
  protected:
+  /// Not implemented
   AliMUONGeometryMisAligner(const AliMUONGeometryMisAligner & right);
+  /// Not implemented
   AliMUONGeometryMisAligner & operator =(const AliMUONGeometryMisAligner &right);
   
   
index 836972e..dce48e7 100644 (file)
@@ -66,7 +66,9 @@ class AliMUONGeometryModule : public TObject
     AliMUONGeometryModuleTransformer* GetTransformer() const;
 
   protected:
+    /// Not implemented
     AliMUONGeometryModule(const AliMUONGeometryModule& rhs);
+    /// Not implemented
     AliMUONGeometryModule& operator = (const AliMUONGeometryModule& rhs);
 
   private:
index 2f03eb8..12d3279 100644 (file)
@@ -71,13 +71,15 @@ class AliMUONGeometryModuleTransformer : public TObject
                         GetDetElement(Int_t detElemId, Bool_t warn = true) const;    
 
   protected:
+    /// Not implemented
     AliMUONGeometryModuleTransformer(const AliMUONGeometryModuleTransformer& rhs);
+    /// Not implemented
     AliMUONGeometryModuleTransformer& 
       operator = (const AliMUONGeometryModuleTransformer& rhs);
 
   private:
     // static data members
-    static const TString  fgkModuleNamePrefix; /// < Geometry module name prefix
+    static const TString  fgkModuleNamePrefix; ///< Geometry module name prefix
 
     // data members
     Int_t                 fModuleId;   ///< the module Id
index d41d419..91d1bef 100644 (file)
@@ -183,7 +183,9 @@ class AliMUONGeometrySegmentation : public TObject
     virtual void Print(Option_t* opt = "") const;
        
   protected:
+    /// Not implemented
     AliMUONGeometrySegmentation(const AliMUONGeometrySegmentation& rhs);
+    /// Not implemented
     AliMUONGeometrySegmentation& operator=(const AliMUONGeometrySegmentation & rhs);
 
   private:
index 9896a34..1ca5bdc 100644 (file)
@@ -93,7 +93,9 @@ class AliMUONGeometryTransformer : public TObject
     Bool_t  HasDE(Int_t detElemId) const;
 
   protected:
+    /// Not implemented
     AliMUONGeometryTransformer(const AliMUONGeometryTransformer& right);
+    /// Not implemented
     AliMUONGeometryTransformer&  operator = (const AliMUONGeometryTransformer& right);
  
   private:
index 1d690b5..8aa5add 100644 (file)
@@ -137,9 +137,9 @@ UChar_t AliMUONGlobalTrigger::GetGlobalResponse() const
 //----------------------------------------------------------------------
 void AliMUONGlobalTrigger::Print(Option_t* opt) const
 {
-  //
-  // Printing Global Trigger information
-  //
+  ///
+  /// Printing Global Trigger information
+  ///
   TString sopt(opt);
   sopt.ToUpper();
   if ( sopt.Contains("FULL") ) { 
index 9d8607f..4141816 100644 (file)
@@ -20,6 +20,7 @@
 /// - inputs are regional responses
 /// - output is a 12-bit word
 /// - 4 bits per trigger level
+/// \todo Change member functions comments in capital letters to normal text
 ///
 /// \author Rachid Guernane (LPCCFd)
 
@@ -34,19 +35,29 @@ ClassImp(AliMUONGlobalTriggerBoard)
 //___________________________________________
 AliMUONGlobalTriggerBoard::AliMUONGlobalTriggerBoard()
 {
+/// Default constructor
+
    for (Int_t i=0;i<16;i++) fRegionalResponse[i] = 0;
 }
 
 //___________________________________________
 AliMUONGlobalTriggerBoard::AliMUONGlobalTriggerBoard(const char *name, Int_t a) : AliMUONTriggerBoard(name, a)
 {
+/// Standard constructor
+
    for (Int_t i=0;i<16;i++) fRegionalResponse[i] = 0;
 }
 
 //___________________________________________
+AliMUONGlobalTriggerBoard::~AliMUONGlobalTriggerBoard()
+{
+/// Destructor
+}
+
+//___________________________________________
 void AliMUONGlobalTriggerBoard::Mask(Int_t index, UShort_t mask)
 {
-  // MASK GLOBAL TRIGGER BOARD INPUT index WITH VALUE mask
+  /// MASK GLOBAL TRIGGER BOARD INPUT index WITH VALUE mask
   if ( index>=0 && index < 16 ) 
   {
     fMask[index]=mask;
@@ -60,12 +71,12 @@ void AliMUONGlobalTriggerBoard::Mask(Int_t index, UShort_t mask)
 //___________________________________________
 void AliMUONGlobalTriggerBoard::Response()
 {
-   // COMPUTE THE GLOBAL TRIGGER BOARD
-   // RESPONSE ACCORDING TO THE Algo() METHOD
-/// output from global trigger algorithm
-/// [+, -, LS, US] * [Hpt, Lpt]
-/// transformed to [usHpt, usLpt, lsHpt, lsLpt, sHpt, sLpt] according
-/// to Global Trigger Unit user manual
+   /// COMPUTE THE GLOBAL TRIGGER BOARD
+   /// RESPONSE ACCORDING TO THE Algo() METHOD
+// output from global trigger algorithm
+// [+, -, LS, US] * [Hpt, Lpt]
+// transformed to [usHpt, usLpt, lsHpt, lsLpt, sHpt, sLpt] according
+// to Global Trigger Unit user manual
 
    Int_t t[16];
    for (Int_t i=0;i<16;i++) t[i] = fRegionalResponse[i] & fMask[i];
@@ -109,7 +120,7 @@ void AliMUONGlobalTriggerBoard::Response()
 //___________________________________________
 UShort_t AliMUONGlobalTriggerBoard::Algo(UShort_t i, UShort_t j, char *thres)
 {
-   // GLOBAL TRIGGER ALGORITHM
+   /// GLOBAL TRIGGER ALGORITHM
    TBits a(8), b(8); a.Set(8,&i); b.Set(8,&j);
 
    TBits trg1(2), trg2(2), trg(2);
@@ -160,7 +171,7 @@ UShort_t AliMUONGlobalTriggerBoard::Algo(UShort_t i, UShort_t j, char *thres)
 //___________________________________________
 void AliMUONGlobalTriggerBoard::Scan(Option_t*) const
 {
-  // PRINT GLOBAL TRIGGER OUTPUT 
+  /// PRINT GLOBAL TRIGGER OUTPUT 
   TBits w(8); w.Set(8,&fResponse);
 
 // TRG[1:0]
index efefa5d..1e21d70 100644 (file)
@@ -7,7 +7,7 @@
 
 /// \ingroup sim
 /// \class AliMUONGlobalTriggerBoard
-/// \brief Global trigger
+/// \brief Global trigger board
 ///
 //  Author: Rachid Guernane (LPCCFd)
 
@@ -19,18 +19,21 @@ class AliMUONGlobalTriggerBoard : public AliMUONTriggerBoard
 
       AliMUONGlobalTriggerBoard();  
       AliMUONGlobalTriggerBoard(const char *name, Int_t a);
-      virtual ~AliMUONGlobalTriggerBoard() {;}
-    
+      virtual ~AliMUONGlobalTriggerBoard();
+                       
+                       /// Set regional board responses
       virtual void     SetRegionalResponse(UShort_t resp[16]) {for (Int_t i=0; i<16; i++) fRegionalResponse[i] = resp[i];}
 
       virtual void     Response();
 
       virtual UShort_t Algo(UShort_t i, UShort_t j, char *thres);
-
+                      
+                       /// Reset regional board responses
       virtual void     Reset() {for (Int_t i=0; i<16; i++) fRegionalResponse[i] = 0;}
 
       virtual void     Scan(Option_t *option) const;
 
+                       /// \todo add comment
       virtual void     Resp(Option_t*) const {}
 
       void Mask(Int_t index, UShort_t mask);
index 157eaaf..1667f37 100644 (file)
@@ -46,12 +46,14 @@ public:
   TObjArray* CompactAliases() const;
   
 private:
+  /// Not implemented
   AliMUONHVNamer(const AliMUONHVNamer& right);
+  /// Not implemented
   AliMUONHVNamer&  operator = (const AliMUONHVNamer& right);
     
-  static const char* fgHVChannelSt345Pattern[]; // HV Channel name template
-  static const char* fgHVChannelSt12Pattern[]; // HV Channel name template
-  static const char* fgHVSwitchSt345Pattern; // HV Switch name template
+  static const char* fgHVChannelSt345Pattern[]; ///< HV Channel name template
+  static const char* fgHVChannelSt12Pattern[]; ///< HV Channel name template
+  static const char* fgHVSwitchSt345Pattern; ///< HV Switch name template
   
   ClassDef(AliMUONHVNamer,0) // Utility class for coding/decoding DCS HV aliases
 };
index acb595e..3cd3205 100644 (file)
@@ -25,7 +25,9 @@ public:
   virtual UInt_t Process(TMap* dcsAliasMap);
 
 private:
+  /// Not implemented
   AliMUONHVSubprocessor(const AliMUONHVSubprocessor&);
+  /// Not implemented
   AliMUONHVSubprocessor& operator=(const AliMUONHVSubprocessor&);
   
   ClassDef(AliMUONHVSubprocessor,1) // Shuttle Subprocessor for MUON TRK HV
index 5346b54..ba464bb 100644 (file)
@@ -141,6 +141,12 @@ AliMUONHitForRec::AliMUONHitForRec (const AliMUONHitForRec& theMUONHitForRec)
 }
 
   //__________________________________________________________________________
+AliMUONHitForRec::~AliMUONHitForRec()
+{
+/// Destructor
+}
+
+  //__________________________________________________________________________
 AliMUONHitForRec & AliMUONHitForRec::operator=(const AliMUONHitForRec& theMUONHitForRec)
 {
 /// Assignment operator
index fcb202e..7f92fc3 100644 (file)
@@ -22,39 +22,61 @@ class AliMUONTrackParam;
 class AliMUONHitForRec : public TObject {
  public:
   AliMUONHitForRec(); // Constructor
-  virtual ~AliMUONHitForRec(){} // Destructor
+  virtual ~AliMUONHitForRec(); // Destructor
   AliMUONHitForRec (const AliMUONHitForRec& AliMUONHitForRec); // copy constructor
   AliMUONHitForRec& operator=(const AliMUONHitForRec& AliMUONHitForRec); // assignment operator
   AliMUONHitForRec(AliTrackReference* mHit); // Constructor from track ref. hit
   AliMUONHitForRec(AliMUONRawCluster* theRawCluster); // Constructor from raw cluster
 
   // Inline functions for Get and Set
+           /// Return coordinate (cm) in bending plane
   Double_t GetBendingCoor(void) const { return fBendingCoor;}
+           /// Set coordinate (cm) in bending plane
   void SetBendingCoor(Double_t BendingCoor) { fBendingCoor = BendingCoor;}
+           /// Return coordinate (cm) in non bending plane
   Double_t GetNonBendingCoor(void) const { return fNonBendingCoor;}
+           /// Set coordinate (cm) in non bending plane
   void SetNonBendingCoor(Double_t NonBendingCoor) { fNonBendingCoor = NonBendingCoor;}
+           /// Return Z coordinate (cm)
   Double_t GetZ(void) const { return fZ;}
+           /// Set Z coordinate (cm)
   void SetZ(Double_t Z) { fZ = Z;}
+           /// Return resolution**2 (cm**2) on coordinate in bending plane
   Double_t GetBendingReso2(void) const { return fBendingReso2;}
+           /// Set resolution**2 (cm**2) on coordinate in bending plane
   void SetBendingReso2(Double_t BendingReso2) { fBendingReso2 = BendingReso2;}
+           /// Return resolution**2 (cm**2) on coordinate in non bending plane
   Double_t GetNonBendingReso2(void) const { return fNonBendingReso2;}
+           /// Set resolution**2 (cm**2) on coordinate in non bending plane
   void SetNonBendingReso2(Double_t NonBendingReso2) { fNonBendingReso2 = NonBendingReso2;}
+           /// Return chamber number (0...)
   Int_t GetChamberNumber(void) const { return fChamberNumber;}
+           /// Set chamber number (0...)
   void SetChamberNumber(Int_t ChamberNumber) { fChamberNumber = ChamberNumber;}
+           /// Return detection element Id
   Int_t GetDetElemId(void) const {return fDetElemId;}
+           /// Set detection element Id
   void SetDetElemId(Int_t id) { fDetElemId = id;}
+           /// Return hit number (0...)
   Int_t GetHitNumber(void) const { return fHitNumber;}
+           /// Set hit number (0...)
   void SetHitNumber(Int_t HitNumber) { fHitNumber = HitNumber;}
+           /// Return track number (0...) in TTR
   Int_t GetTTRTrack(void) const { return fTTRTrack;}
+           /// Set track number (0...) in TTR
   void SetTTRTrack(Int_t TTRTrack) { fTTRTrack = TTRTrack;}
+           /// Return Track ref. signal (1) or background (0)
   Int_t GetTrackRefSignal(void) const { return fTrackRefSignal;}
+           /// Set Track ref. signal (1) or background (0)
   void SetTrackRefSignal(Int_t TrackRefSignal) { fTrackRefSignal = TrackRefSignal;}
+           /// Return number of TrackHit's made with HitForRec
   Int_t GetNTrackHits(void) const { return fNTrackHits;}
+           /// Set number of TrackHit's made with HitForRec
   void SetNTrackHits(Int_t NTrackHits) { fNTrackHits = NTrackHits;}
 
   Double_t NormalizedChi2WithHitForRec(AliMUONHitForRec* Hit, Double_t Sigma2Cut) const;
 
-  // What is necessary for sorting TClonesArray's; sufficient too ????
+  /// What is necessary for sorting TClonesArray's; sufficient too ????
   Bool_t IsSortable() const { return kTRUE; }
   Int_t Compare(const TObject* HitForRec) const; // "Compare" function for sorting
 
index c68c47d..dc0d242 100644 (file)
@@ -43,8 +43,9 @@ class AliMUONHitMapA1 : public AliHitMap
     virtual FlagType TestHit(Int_t ix, Int_t iy);
 
  private:
+    /// Not implemented
     AliMUONHitMapA1(const AliMUONHitMapA1 & hitMap);
-    // Assignment operator
+    /// Not implemented
     AliMUONHitMapA1& operator = (const AliMUONHitMapA1& rhs);
 
     // Check index
index 1dd7b09..49ac94b 100644 (file)
@@ -30,23 +30,13 @@ class AliMUONLoader : public AliLoader
     AliMUONData *  GetMUONData();
  
   protected:
+    /// Not implemented
     AliMUONLoader(const AliMUONLoader& rhs);
+    /// Not implemented
     AliMUONLoader& operator=(const AliMUONLoader& rhs);
 
     AliMUONData * fMUONData; ///< data for MUON subsystem 
 
-  private:
-    //descendant classes should
-    //use protected interface methods to access these folders
-
-    /**********************************************/
-    /***********     P U B L I C     **************/
-    /*********       S T A T I C       ************/
-    /*********         METHODS         ************/
-    /*********     They are used by    ************/
-    /*********** AliRunLoader as well**************/
-    /**********************************************/
-
   ClassDef(AliMUONLoader,1)
 };
 
index e2f9b28..65b1f40 100644 (file)
@@ -91,6 +91,13 @@ AliMUONLocalStruct::AliMUONLocalStruct(const AliMUONLocalStruct& event)
 
 
 }
+
+//___________________________________________
+AliMUONLocalStruct::~AliMUONLocalStruct()
+{
+/// Destructor
+}
+
 //___________________________________________
 AliMUONLocalStruct& 
 AliMUONLocalStruct::operator=(const AliMUONLocalStruct& event)
index 6ffb244..696ce18 100644 (file)
@@ -22,68 +22,102 @@ public:
    AliMUONLocalStruct& operator=(const AliMUONLocalStruct& event);
 
 
-   virtual ~AliMUONLocalStruct(){;}
+   virtual ~AliMUONLocalStruct();
 
    // local board info
+            /// Return local data
    UInt_t  GetData(Int_t n) const {return fData[n];}
 
+            /// Return X2
    UShort_t GetX2() const {return (fData[0]     >> 16) &  0xFFFF;}
+            /// Return X1
    UShort_t GetX1() const {return (fData[0])           &  0xFFFF;}
+            /// Return X4
    UShort_t GetX4() const {return (fData[1] >> 16) &  0xFFFF;}
+            /// Return X3
    UShort_t GetX3() const {return (fData[1])       &  0xFFFF;}
 
+            /// Return Y2
    UShort_t GetY2() const {return (fData[2] >> 16) &  0xFFFF;}
+            /// Return Y1
    UShort_t GetY1() const {return (fData[2])       &  0xFFFF;}
+            /// Return Y4
    UShort_t GetY4() const {return (fData[3] >> 16) &  0xFFFF;}
+            /// Return Y3
    UShort_t GetY3() const {return (fData[3])       &  0xFFFF;}
 
+            /// Return Id
    UChar_t  GetId()  const  {return fData[4] >> 19 &  0xF;}
+            /// Return Dec
    UChar_t  GetDec() const  {return fData[4] >> 15 &  0xF;}
+            /// Return TriggerY
    Bool_t   GetTriggerY() const {return (fData[4] >> 14 & 0x1);}
+            /// Return Upos
    UChar_t  GetYPos() const {return fData[4] >> 10 &  0xF;}
+            /// Return Xdev
    UChar_t  GetXDev() const {return fData[4] >> 5  &  0x1F;}
+            /// Return TriggerX
    Bool_t   GetTriggerX() const {return ((GetXDev() >> 4  & 0x1) && !(GetXDev() & 0xF));}
+            /// Return Xpos
    UChar_t  GetXPos() const {return fData[4]       &  0x1F;}
 
+            /// Return LPT
    Int_t   GetLpt() const {return (GetDec() & 0x3);}
+            /// Return HPT
    Int_t   GetHpt() const {return (GetDec() >> 2) & 0x3;}
 
+            /// Set local data
    void    SetData(UInt_t d, Int_t n) {fData[n] = d;}
 
+            /// Return data
    UInt_t* GetData() {return &fData[0];}
 
  // Scaler methods
+            /// Return local L0
    UInt_t  GetL0()      const {return fL0;}
+            /// Return local hold (dead time)
    UInt_t  GetHold()    const {return fHold;}
+            /// Return local clock
    UInt_t  GetClock()   const {return fClk;}
+            /// Return switch
    UChar_t GetSwitch()  const {return (fEOS >> 2) & 0x3FF;}
+            /// Return ComptXY
    UChar_t GetComptXY() const {return  fEOS & 3;}
 
+            /// Return XY1
    UShort_t GetXY1(Int_t n) const {return  (n % 2 == 0) ?
        (fScaler[TMath::Nint(Float_t(n/2))] &  0xFFFF) : 
        (fScaler[TMath::Nint(Float_t(n/2))] >> 16) &  0xFFFF;}
 
+            /// Return XY2
    UShort_t GetXY2(Int_t n) const {return  (n % 2 == 0) ?
        (fScaler[8 + TMath::Nint(Float_t(n/2))] &  0xFFFF) : 
        (fScaler[8 + TMath::Nint(Float_t(n/2))] >> 16) &  0xFFFF;}
 
+            /// Return XY3
    UShort_t GetXY3(Int_t n) const {return  (n % 2 == 0) ?
        (fScaler[8*2 + TMath::Nint(Float_t(n/2))] &  0xFFFF) : 
        (fScaler[8*2 + TMath::Nint(Float_t(n/2))] >> 16) &  0xFFFF;}
 
+            /// Return XY4
    UShort_t GetXY4(Int_t n) const {return  (n % 2 == 0) ?
        (fScaler[8*3 + TMath::Nint(Float_t(n/2))] &  0xFFFF) : 
        (fScaler[8*3 + TMath::Nint(Float_t(n/2))] >> 16) &  0xFFFF;}
 
+            /// Return scalers
    UInt_t* GetScalers()  {return &fL0;} 
 
    // get  length
+            /// Return scaler length in word
    Int_t  GetScalerLength()  const {return fgkScalerLength;} 
+            /// Return local info length in word
    Int_t  GetLength()        const {return fgkLength;} 
+            /// Return end of local info word
    UInt_t GetEndOfLocal()    const {return fgkEndOfLocal;}
+            /// Return Word for "empty" slots
    UInt_t GetDisableWord()   const {return fgkDisableWord;}
 
-  // set random numbers to fill variable
+   // set random numbers to fill variable
    void SetScalersNumbers();
 
  private:
index 1957c47..2a5a466 100644 (file)
@@ -79,6 +79,13 @@ AliMUONLocalTrigger::AliMUONLocalTrigger(const AliMUONLocalTrigger& theMUONLocal
 /// Copy constructor (useful for TClonesArray)
 
 }
+
+//----------------------------------------------------------------------
+AliMUONLocalTrigger::~AliMUONLocalTrigger()
+{
+/// Destructor
+}
+
 //----------------------------------------------------------------------
 AliMUONLocalTrigger& AliMUONLocalTrigger::operator=(const AliMUONLocalTrigger& theMUONLocalTrig)
 {
@@ -162,9 +169,8 @@ void AliMUONLocalTrigger::SetLocalStruct(Int_t loCircuit, AliMUONLocalStruct& lo
 //----------------------------------------------------------------------
 void AliMUONLocalTrigger::Print(Option_t* opt) const
 {
-  //
-  // Printing Local Trigger information
-  //
+/// Printing Local Trigger information
+
   TString sopt(opt);
   sopt.ToUpper();
  
index 7cd2eb7..ed95467 100644 (file)
@@ -20,7 +20,7 @@ class AliMUONLocalTrigger : public TObject {
  public:
   AliMUONLocalTrigger();
   AliMUONLocalTrigger(const AliMUONLocalTrigger& rhs); // copy constructor !
-  virtual ~AliMUONLocalTrigger(){;}
+  virtual ~AliMUONLocalTrigger();
   AliMUONLocalTrigger& operator=(const AliMUONLocalTrigger& rhs); 
 
   // getter methods
index f1daa67..37fe3a7 100644 (file)
 
 /* $Id$ */
 
-//_________________________________________________________________________
-// Implementation of local trigger board objects
-// A local trigger board has as input a bit pattern and returns 
-// the local trigger response after comparison w/ a LUT
-//*-- Author: Rachid Guernane (LPCCFd)
-//*
-//*
+/// \class AliMUONLocalTriggerBoard
+/// A local trigger board has as input a bit pattern and returns 
+/// the local trigger response after comparison w/ a LUT
+/// \todo Change member functions comments in capital letters to normal text
+///
+/// \author Rachid Guernane (LPCCFd)
 
 #include "AliMUONLocalTriggerBoard.h"
 #include "AliMUONTriggerLut.h"
 #include <TBits.h>
 #include <Riostream.h>
 
+/// \cond CLASSIMP
+ClassImp(AliMUONLocalTriggerBoard)
+/// \endcond
+
 const Int_t AliMUONLocalTriggerBoard::fgkCircuitId[234] = 
 {
   111,  121,  131,  141,  151,  161,  171,
@@ -66,8 +69,8 @@ AliMUONLocalTriggerBoard::AliMUONLocalTriggerBoard()
       fLUT(0x0),
       fCoinc44(0)      
 {
-//* constructor
-//*
+/// Default constructor
+///
 
    for (Int_t i=0; i<2; i++) 
       for (Int_t j=0; j<4; j++) 
@@ -98,8 +101,8 @@ AliMUONLocalTriggerBoard::AliMUONLocalTriggerBoard(const char *name, Int_t a,
       fLUT(lut),
       fCoinc44(0)
 {
-//* constructor
-//*
+/// Standard constructor
+///
    
    for (Int_t i=0; i<2; i++) 
       for (Int_t j=0; j<4; j++) 
@@ -116,43 +119,17 @@ AliMUONLocalTriggerBoard::AliMUONLocalTriggerBoard(const char *name, Int_t a,
    for (Int_t i=0; i<2; i++) fLutLpt[i] = fLutHpt[i] = 0;
 }
 
-//______________________________________________________________________________
-AliMUONLocalTriggerBoard::AliMUONLocalTriggerBoard(const AliMUONLocalTriggerBoard& right) 
-    : AliMUONTriggerBoard(right),
-      fNumber(right.fNumber),
-      fCrate(right.fCrate),
-      fTC(right.fTC),
-      fStripX11(right.fStripX11),
-      fStripY11(right.fStripY11),
-      fDev(right.fDev),
-      fOutput(right.fOutput),
-      fLUT(right.fLUT),
-      fCoinc44(right.fCoinc44)
-{  
-/// Protected copy constructor (not implemented)
-
-  AliFatal("Copy constructor not provided.");
-}
-
-//______________________________________________________________________________
-AliMUONLocalTriggerBoard& 
-AliMUONLocalTriggerBoard::operator=(const AliMUONLocalTriggerBoard& right)
+//___________________________________________
+AliMUONLocalTriggerBoard::~AliMUONLocalTriggerBoard()
 {
-/// Protected assignement operator (not implemented)
-
-  // check assignement to self
-  if (this == &right) return *this;
-
-  AliFatal("Assignement operator not provided.");
-    
-  return *this;  
-}    
+/// Destructor
+}
 
 //___________________________________________
 void AliMUONLocalTriggerBoard::Reset()
 {
-//* reset board
-//*
+/// reset board
+///
    for (Int_t i=0; i<2; i++) 
       for (Int_t j=0; j<4; j++) 
          fXY[i][j] = fXYU[i][j] = fXYD[i][j] = 0;
@@ -171,7 +148,7 @@ void AliMUONLocalTriggerBoard::Reset()
 //___________________________________________
 void AliMUONLocalTriggerBoard::Setbit(Int_t strip, Int_t cathode, Int_t chamber)
 {
-// 0 .. LBS   :   N-1 .. MSB
+/// 0 .. LBS   :   N-1 .. MSB
    TBits w, m;
 
    UShort_t xy = fXY[cathode][chamber], mask = fMask[cathode][chamber];
@@ -195,7 +172,7 @@ void AliMUONLocalTriggerBoard::Setbit(Int_t strip, Int_t cathode, Int_t chamber)
 //___________________________________________
 void AliMUONLocalTriggerBoard::SetbitM(Int_t strip, Int_t cathode, Int_t chamber)
 {
-// 0 .. LBS   :   N-1 .. MSB
+/// 0 .. LBS   :   N-1 .. MSB
    TBits w, m;
 
    UShort_t xy = fXY[cathode][chamber], mask = fMask[cathode][chamber];
@@ -217,8 +194,8 @@ void AliMUONLocalTriggerBoard::SetbitM(Int_t strip, Int_t cathode, Int_t chamber
 //___________________________________________
 void AliMUONLocalTriggerBoard::Pattern(Option_t *option) const
 {
-//* print bit pattern
-//*
+/// print bit pattern
+///
    TString op = option;
    
    if (op.Contains("X")) BP("X");
@@ -230,7 +207,7 @@ void AliMUONLocalTriggerBoard::Pattern(Option_t *option) const
 //___________________________________________
 void AliMUONLocalTriggerBoard::BP(Option_t *option) const
 {
-// RESPECT THE OLD PRINTOUT FORMAT
+/// RESPECT THE OLD PRINTOUT FORMAT
   
   const Int_t kModuleId[126] = 
   {11,12,13,14,15,16,17,         // right side of the chamber
@@ -429,8 +406,8 @@ void AliMUONLocalTriggerBoard::BP(Option_t *option) const
 //___________________________________________
 void AliMUONLocalTriggerBoard::Conf() const
 {
-//* board switches
-//*
+/// board switches
+///
    cout << "Switch(" << GetName() << ")" 
         << " x2d = "           << fSwitch[0] 
         << " x2m = "           << fSwitch[1] 
@@ -450,8 +427,8 @@ void AliMUONLocalTriggerBoard::Conf() const
 //___________________________________________
 void AliMUONLocalTriggerBoard::Module(char *mod)
 {
-//* get module from name
-//*
+/// get module from name
+///
    const Int_t kMaxfields = 2; char **fields = new char*[kMaxfields];
 
    char s[100]; strcpy(s, GetName());
@@ -472,10 +449,10 @@ void AliMUONLocalTriggerBoard::Module(char *mod)
 //___________________________________________
 void AliMUONLocalTriggerBoard::TrigX(Int_t ch1q[16], Int_t ch2q[16], Int_t ch3q[32], Int_t ch4q[32])
 {
-// note : coinc44 = flag 0 or 1 (0 coincidence -> 3/4, 1 coincidence -> 4/4)
-//---------------------------------------------------------
-// step # 1 : declustering, reduction DS, calculate sgle & dble
-//---------------------------------------------------------
+/// note : coinc44 = flag 0 or 1 (0 coincidence -> 3/4, 1 coincidence -> 4/4) \n
+///---------------------------------------------------------                  \n
+/// step # 1 : declustering, reduction DS, calculate sgle & dble              \n 
+///---------------------------------------------------------
    Int_t ch1e[19], ch2e[20], ch3e[35], ch4e[36]; 
    Int_t sgleHit1[31], sgleHit2[63];
    Int_t dbleHit1[31], dbleHit2[63];
@@ -832,7 +809,7 @@ void AliMUONLocalTriggerBoard::TrigX(Int_t ch1q[16], Int_t ch2q[16], Int_t ch3q[
 void AliMUONLocalTriggerBoard::Sort2x5(Int_t dev1[6], Int_t dev2[6],
                                        Int_t minDev[6], Int_t &dev1GTdev2)
 { 
-// returns minimun between dev1 and dev2
+/// returns minimun between dev1 and dev2
    Int_t tmpDev1=0, tmpDev2=0;
 
    for (Int_t j=0; j<5; j++)
@@ -857,10 +834,10 @@ void AliMUONLocalTriggerBoard::Sort2x5(Int_t dev1[6], Int_t dev2[6],
 void AliMUONLocalTriggerBoard::TrigY(Int_t y1[16], Int_t y2[16], Int_t y3[16], Int_t y4[16],
                                      Int_t y3u[16], Int_t y3d[16], Int_t y4u[16], Int_t y4d[16])
 {
-// note : resMid = 1 -> cancel 
-//---------------------------------------------------------
-// step # 1 : prehandling Y
-//--------------------------------------------------------- 
+/// note : resMid = 1 -> cancel                             \n
+///---------------------------------------------------------\n
+/// step # 1 : prehandling Y                                \n
+///--------------------------------------------------------- 
    Int_t i;
    Int_t istrip;
 
@@ -1076,8 +1053,8 @@ void AliMUONLocalTriggerBoard::TrigY(Int_t y1[16], Int_t y2[16], Int_t y3[16], I
 //___________________________________________
 void AliMUONLocalTriggerBoard::LocalTrigger()
 {
-//* L0 trigger after LUT
-//*
+/// L0 trigger after LUT
+///
     Int_t deviation=0, iStripY=0, iStripX=0;
 
    for (Int_t i=0; i<4; i++) deviation += static_cast<int>( fMinDev[i] << i );
@@ -1118,8 +1095,8 @@ void AliMUONLocalTriggerBoard::LocalTrigger()
 //___________________________________________
 Int_t AliMUONLocalTriggerBoard::GetI() const
 {
-//* old numbering
-//*
+/// old numbering
+///
    const Int_t kMaxfields = 2; char **fields = new char*[kMaxfields];
 
    char s[100]; strcpy(s, GetName());
@@ -1163,8 +1140,8 @@ Int_t AliMUONLocalTriggerBoard::GetI() const
 //___________________________________________
 void AliMUONLocalTriggerBoard::Mask(Int_t index, UShort_t mask)
 {
-//* set mask
-//*
+/// set mask
+///
   if ( index >= 0 && index < 2*4 )
   {
     Int_t i = index/4;
@@ -1180,8 +1157,8 @@ void AliMUONLocalTriggerBoard::Mask(Int_t index, UShort_t mask)
 //___________________________________________
 void AliMUONLocalTriggerBoard::Scan(Option_t *option) const
 {
-//* full dump
-//*
+/// full dump
+///
    TString op = option;
 
    if (op.Contains("CONF")) Conf();
@@ -1204,8 +1181,8 @@ void AliMUONLocalTriggerBoard::Scan(Option_t *option) const
 //___________________________________________
 void AliMUONLocalTriggerBoard::Resp(Option_t *option) const
 {
-//* board I/O
-//*
+/// board I/O
+///
    TString op = option;
 
    if (op.Contains("I"))
@@ -1251,8 +1228,8 @@ void AliMUONLocalTriggerBoard::Resp(Option_t *option) const
 //___________________________________________
 void AliMUONLocalTriggerBoard::Response()
 {
-//* algo
-//*
+/// algo
+///
    Int_t xX1[16], xX2[16], xXX3[32], xXX4[32];
 
    TBits x1(16), x2(16), x3(16), x4(16);
@@ -1337,5 +1314,3 @@ void AliMUONLocalTriggerBoard::Response()
        static_cast<int>(fLutHpt[1]<<3);
 }
 
-ClassImp(AliMUONLocalTriggerBoard)
-
index fce7f15..355c1a1 100644 (file)
@@ -9,10 +9,7 @@
 /// \class AliMUONLocalTriggerBoard
 /// \brief Implementation of local trigger board objects
 ///
-/// A local trigger board has as input a bit pattern and returns 
-/// the local trigger response after comparison w/ a LUT
-///
-/// \author Rachid Guernane (LPCCFd)
+//  Author Rachid Guernane (LPCCFd)
 
 #include "AliMUONTriggerBoard.h"
 
@@ -22,6 +19,7 @@ class AliMUONLocalTriggerBoard : public AliMUONTriggerBoard
 {
    public: 
 
+     /// \todo add comment
      enum ESwitch { 
        kX2d = 0,
        kX2m,
@@ -36,12 +34,15 @@ class AliMUONLocalTriggerBoard : public AliMUONTriggerBoard
        
       AliMUONLocalTriggerBoard();
       AliMUONLocalTriggerBoard(const char *name, Int_t a, AliMUONTriggerLut* lut);
-      virtual ~AliMUONLocalTriggerBoard() {;}
-      
-      Bool_t HasLUT() const { return (fLUT != 0); }
+      virtual ~AliMUONLocalTriggerBoard();
       
-      void SetLUT(AliMUONTriggerLut* lut) { fLUT = lut; }
-      void SetCoinc44(Int_t coinc44=0) { fCoinc44 = coinc44; }
+                       /// Return true if LUT is set
+      Bool_t           HasLUT() const { return (fLUT != 0); }
+
+                       /// Set LUT     
+      void             SetLUT(AliMUONTriggerLut* lut) { fLUT = lut; }
+                       /// Set Coinc 44 (0/1 = coinc34/coinc44)
+      void             SetCoinc44(Int_t coinc44=0) { fCoinc44 = coinc44; }
       
       virtual void     Setbit(Int_t strip, Int_t cathode, Int_t chamber);
       virtual void     SetbitM(Int_t strip, Int_t cathode, Int_t chamber);
@@ -50,32 +51,45 @@ class AliMUONLocalTriggerBoard : public AliMUONTriggerBoard
 
       virtual void     Reset();
 
+                       /// Set i-th Switch value
       virtual void     SetSwitch(Int_t i, Int_t value) {fSwitch[i] = value;}
 
+                       /// Return i-th Switch value
       virtual UShort_t GetSwitch(Int_t i) const {return fSwitch[i];}
 
+                       /// Set Transverse connector
       virtual void     SetTC(Bool_t con) {fTC = con;}
 
+                       /// Return Transverse connector
       virtual Bool_t   GetTC() const {return fTC;}
 
+                       /// Set Board number
       virtual void     SetNumber(Int_t nb) {fNumber = nb;}
 
+                       /// Return Board number
       virtual Int_t    GetNumber() const {return fNumber;}
 
       virtual void     Module(char *mod);
 
+                       /// Return X34
       virtual void     GetX34(UShort_t *X) const {for (Int_t i=0;i<2;i++) X[i] = fXY[0][i+2];}
 
+                       /// Set X34
       virtual void     SetX34(UShort_t *X) {for (Int_t i=0;i<2;i++) fXY[0][i+2] = X[i];}
 
+                       /// Return Y
       virtual void     GetY(UShort_t *Y) const {for (Int_t i=0;i<4;i++) Y[i] = fXY[1][i];}
 
+                       /// Set Y
       virtual void     SetY(UShort_t *Y) {for (Int_t i=0;i<4;i++) fXY[1][i] = Y[i];}
 
+                       /// Return XY
       virtual void     GetXY(UShort_t XY[2][4]) const {for (Int_t i=0;i<2;i++) for (Int_t j=0;j<4;j++) XY[i][j] = fXY[i][j];}
 
+                       /// Return XY
       virtual UShort_t GetXY(Int_t i, Int_t j) const {return fXY[i][j];} 
 
+                       /// Set XY
       virtual void     SetXY(UShort_t XY[2][4]) {for (Int_t i=0;i<2;i++) for (Int_t j=0;j<4;j++) fXY[i][j] = XY[i][j];}
 
       virtual void     Conf() const;
@@ -92,8 +106,10 @@ class AliMUONLocalTriggerBoard : public AliMUONTriggerBoard
       virtual void     TrigY(Int_t y1[16], Int_t y2[16], Int_t y3[16], Int_t y4[16],
                              Int_t y3u[16], Int_t y3d[16], Int_t y4u[16], Int_t y4d[16]);
 
+                       /// Set XYU
       virtual void     SetXYU(UShort_t V[2][4]) {for (Int_t i=0;i<2;i++) for (Int_t j=0;j<4;j++) fXYU[i][j] = V[i][j];}
 
+                       /// Set XYD
       virtual void     SetXYD(UShort_t V[2][4]) {for (Int_t i=0;i<2;i++) for (Int_t j=0;j<4;j++) fXYD[i][j] = V[i][j];}
 
       virtual void     Scan(Option_t *option = "") const;
@@ -102,29 +118,37 @@ class AliMUONLocalTriggerBoard : public AliMUONTriggerBoard
 
       virtual void     LocalTrigger();
 
+                       /// Return info if Board has triggered
       virtual Int_t    Triggered() const {return fOutput;}
 
+                       /// Return MT1 X position of the valid road
       virtual Int_t    GetStripX11() const {return fStripX11;}
 
+                       /// Return MT1 Y position of the valid road
       virtual Int_t    GetStripY11() const {return fStripY11;}
 
+                       /// Return Deviation in [0;+30]
       virtual Int_t    GetDev() const {return fDev;}
       
+                       /// Set Crate name
       virtual void     SetCrate(TString crate) {fCrate = crate;}
 
+                       /// Return Crate name
       virtual TString  GetCrate() const {return fCrate;}
 
    protected:
-      AliMUONLocalTriggerBoard(const AliMUONLocalTriggerBoard& right);
-      AliMUONLocalTriggerBoard&  operator = (const AliMUONLocalTriggerBoard& right);
-      
-      static const Int_t fgkCircuitId[234]; // old numbering (to be removed)
 
-      virtual void     Resp(Option_t *option) const; // local trigger info before ("I") and after ("F") LUT
+      static const Int_t fgkCircuitId[234]; ///< old numbering (to be removed)
+
+      virtual void     Resp(Option_t *option) const; ///< local trigger info before ("I") and after ("F") LUT
 
-      virtual void     BP(Option_t *option) const;   // display X/Y bp
+      virtual void     BP(Option_t *option) const;   ///< display X/Y bp
 
    private:
+      /// Not implemented
+      AliMUONLocalTriggerBoard(const AliMUONLocalTriggerBoard& right);
+      /// Not implemented
+      AliMUONLocalTriggerBoard&  operator = (const AliMUONLocalTriggerBoard& right);
 
       Int_t    fNumber;           ///< Board number
 
index 74967da..0decb71 100644 (file)
@@ -34,7 +34,9 @@
 ///
 /// \author Laurent Aphecetche
 
+/// \cond CLASSIMP
 ClassImp(AliMUONLogger)
+/// \endcond
 
 //_____________________________________________________________________________
 AliMUONLogger::AliMUONLogger(Int_t maxNumberOfEntries) 
index cacbdb0..428e25a 100644 (file)
@@ -29,8 +29,9 @@ public:
   void Print(Option_t* opt="") const;
   
 private:
-  
+  /// Not implemented
   AliMUONLogger(const AliMUONLogger& rhs); // not implemented
+  /// Not implemented
   AliMUONLogger& operator=(const AliMUONLogger& rhs); // not implemented
   
 private:
index 9025e7a..c232925 100644 (file)
@@ -29,10 +29,14 @@ public:
   
   virtual ~AliMUONObjectPair();
 
+  /// Return the first element of the pair
   TObject* First() const { return fFirst; }
+  /// Return  the second element of the pair
   TObject* Second() const { return fSecond; }
 
+  /// Return the first element of the pair 
   TObject* Key() const { return fFirst; }
+  /// Return the second element of the pair 
   TObject* Value() const { return fSecond; }
 
   virtual void Copy(TObject& other) const;
index 9cabb56..f297efe 100644 (file)
@@ -153,6 +153,12 @@ fChargeBackup(0.0)
 }
 
 //_____________________________________________________________________________
+AliMUONPad::~AliMUONPad()
+{
+/// Dtor
+}
+
+//_____________________________________________________________________________
 Bool_t 
 AliMUONPad::AreNeighbours(const AliMUONPad& d1, const AliMUONPad& d2) 
 {
index 839ff7e..10acb80 100644 (file)
@@ -33,75 +33,106 @@ public:
   AliMUONPad(Int_t detElemId, Int_t cathode,
              Int_t ix, Int_t iy, Double_t x, Double_t y,
              Double_t dx, Double_t dy, Double_t charge);
-  virtual ~AliMUONPad() {}
+  virtual ~AliMUONPad();
 
+  /// \brief Backup charge 
+  /// Usefull if clustering somehow plays with the charge, this one is the "original" one
   void BackupCharge() { fChargeBackup = fCharge; }
   
+  /// Return cathode number
   Int_t Cathode() const { return fCathode; }
 
   Double_t Coord(Int_t ixy) const;
   
+  /// Return pad charge
   Double_t Charge() const { return fCharge; }
+  /// Return backup charge
   Double_t ChargeBackup() const { return fChargeBackup; }
 
   virtual Int_t Compare(const TObject* obj) const;
 
+  /// Return detection element id
   Int_t DetElemId() const { return fDetElemId; }
   
+  /// \brief Return corresponding digit index 
+  /// To get back the digit from which this pad was constructed, if needed
   Int_t DigitIndex() const { return fDigitIndex; }
 
+  /// Return half dimensions in x and y (cm)
   TVector2 Dimensions() const { return fDimensions; }
   
+  /// Return half dimensions in x (cm)
   Double_t DX() const { return fDimensions.X(); }
+  /// Return  half dimensions in y (cm)
   Double_t DY() const { return fDimensions.Y(); }
 
+  /// Return info whether this is a real pad or a virtual one
   Bool_t IsReal() const { return fIsReal; }
 
+  /// Return info whether this pad is saturated or not
   Bool_t IsSaturated() const { return fIsSaturated; }
   
+  /// Return true as the function Sort is implemented
   Bool_t IsSortable() const { return kTRUE; }
   
+  /// Return true if is used
   Bool_t IsUsed() const { return fClusterId >= 0; }
 
+  /// Return x-index
   Int_t Ix() const { return fIx; }
+  /// Return y-index
   Int_t Iy() const { return fIy; }
 
   virtual void Paint(Option_t* opt="");
 
+  /// Return positions in x and y (cm)
   TVector2 Position() const { return fPosition; }
 
   void Print(Option_t* opt = "") const;
 
-  // Detach this pad from a cluster
+  /// Detach this pad from a cluster
   void Release() { fClusterId = -1; }
   
+  /// Set charge to value in backup charge
   void RevertCharge() { fCharge = fChargeBackup; }
 
+  /// Set charge
   void SetCharge(Double_t charge) { fCharge = charge; }
   
+  /// Set charge backup
   void SetChargeBackup(Double_t charge) { fChargeBackup = charge; }
 
   void SetCoord(Int_t ixy, Double_t Coord);
 
+  /// \brief Set corresponding digit index
+  /// To get back the digit from which this pad was constructed, if needed
   void SetDigitIndex(Int_t digitIndex) { fDigitIndex = digitIndex; }
 
+  /// Set status word
   void SetStatus(Int_t status) { fStatus = status; }
     
+  /// \brief Set cluster id this pad belongs to
+  /// -1 if not attached to a cluster
   void SetClusterId(Int_t id) { fClusterId = id; }  
   
+  /// Set info whether this pad is saturated or not
   void SetSaturated(Bool_t val) { fIsSaturated = val; }
   
   void SetSize(Int_t ixy, Double_t Size);
   
+  /// Set info whether this is a real pad or a virtual one
   void SetReal(Bool_t val) { fIsReal = val; }
 
   void Shift(Int_t ixy, Double_t shift);
   
   Double_t Size(Int_t ixy) const;
 
+  /// Return status word
   Int_t Status() const { return fStatus; }
   
+  /// Return position in x (cm)
   Double_t X() const { return fPosition.X(); }
+  /// Return position in y (cm)
   Double_t Y() const { return fPosition.Y(); }
   
   static AliMpArea Overlap(const AliMUONPad& d1, const AliMUONPad& d2);
@@ -124,19 +155,19 @@ private:
               Double_t charge);
   
 private:
-  Bool_t fIsSaturated; /// whether this pad is saturated or not
-  Bool_t fIsReal; /// whether this is a real pad or a virtual one
-  Int_t fClusterId; /// cluster id this pad belongs to (-1 if not attached to a cluster)
-  Int_t fCathode; /// cathode number
-  Int_t fDetElemId; /// detection element id
-  Int_t fDigitIndex; /// corresponding digit index (to get back the digit from which this pad was constructed, if needed)
-  Int_t fIx; /// x-index
-  Int_t fIy; /// y-index
-  Int_t fStatus; /// status word
-  TVector2 fDimensions; /// half dimensions in x and y (cm)
-  TVector2 fPosition; /// positions in x and y (cm)
-  Double_t fCharge; /// pad charge
-  Double_t fChargeBackup; /// backup charge (usefull if clustering somehow plays with the charge, this one is the "original" one)
+  Bool_t fIsSaturated; ///< whether this pad is saturated or not
+  Bool_t fIsReal; ///< whether this is a real pad or a virtual one
+  Int_t fClusterId; ///< cluster id this pad belongs to (-1 if not attached to a cluster)
+  Int_t fCathode; ///< cathode number
+  Int_t fDetElemId; ///< detection element id
+  Int_t fDigitIndex; ///< corresponding digit index (to get back the digit from which this pad was constructed, if needed)
+  Int_t fIx; ///< x-index
+  Int_t fIy; ///< y-index
+  Int_t fStatus; ///< status word
+  TVector2 fDimensions; ///< half dimensions in x and y (cm)
+  TVector2 fPosition; ///< positions in x and y (cm)
+  Double_t fCharge; ///< pad charge
+  Double_t fChargeBackup; ///< backup charge (usefull if clustering somehow plays with the charge, this one is the "original" one)
   
   ClassDef(AliMUONPad,1) // A full grown pad 
 };
index f680359..a99cd3d 100644 (file)
@@ -73,13 +73,13 @@ AliMUONPadStatusMaker::AliMUONPadStatusMaker(const AliMUONCalibrationData& calib
   fHVSt12Limits(0,5000),
   fHVSt345Limits(0,5000)
 {
-    // ctor
+   /// ctor
 }
 
 //_____________________________________________________________________________
 AliMUONPadStatusMaker::~AliMUONPadStatusMaker()
 {
-  // dtor.
+  /// dtor.
 }
 
 //_____________________________________________________________________________
index 55999ab..41cc91e 100644 (file)
@@ -40,20 +40,30 @@ public:
 
   static AliMUONV2DStore* GeneratePadStatus(Int_t value);
 
+  /// Return Low and High threshold for St12 HV
   TVector2 HVSt12Limits() const { return fHVSt12Limits; }
+  /// Return Low and High threshold for St345 HV
   TVector2 HVSt345Limits() const { return fHVSt345Limits; }
   
+  /// Return Low and High threshold for pedestal mean
   TVector2 PedMeanLimits() const { return fPedMeanLimits; }
+  /// Return Low and High threshold for pedestal sigma
   TVector2 PedSigmaLimits() const { return fPedSigmaLimits; }
   
+  /// Set Low and High threshold for St12 HV
   void SetHVSt12Limits(float low, float high) { fHVSt12Limits.Set(low,high); }
+  /// Set Low and High threshold for St345 HV
   void SetHVSt345Limits(float low, float high) { fHVSt345Limits.Set(low,high); }
 
+  /// Set Low and High threshold for pedestal mean
   void SetPedMeanLimits(float low, float high) { fPedMeanLimits.Set(low,high); }
+  /// Set Low and High threshold for pedestal sigma 
   void SetPedSigmaLimits(float low, float high) { fPedSigmaLimits.Set(low,high); }
   
 private:
+  /// Not implemented
   AliMUONPadStatusMaker(const AliMUONPadStatusMaker&);
+  /// Not implemented
   AliMUONPadStatusMaker& operator=(const AliMUONPadStatusMaker&);
   
 private:
@@ -82,12 +92,13 @@ private:
 
   
 private:
-  
+  /// General status
   enum EGeneralStatus
   {
     kMissing = (1<<7)
   };
   
+  /// Pedestal status
   enum EPedestalStatus
   {
     kPedOK = 0,
@@ -100,6 +111,7 @@ private:
     kPedMissing = kMissing // please always use last bit for meaning "missing"
   };
   
+  /// HV Error
   enum EHVError 
   {
     kHVOK = 0,
index b07cf47..1868c6e 100644 (file)
@@ -53,18 +53,18 @@ AliMUONPayloadTracker::AliMUONPayloadTracker()
     fBlockHeader(new AliMUONBlockHeader()),
     fDspHeader(new AliMUONDspHeader())
 {
-  //
-  // create an object to decode MUON payload
-  //
+  ///
+  /// create an object to decode MUON payload
+  ///
 
 }
 
 //___________________________________
 AliMUONPayloadTracker::~AliMUONPayloadTracker()
 {
-  //
-  // clean up
-  //
+  ///
+  /// clean up
+  ///
   delete fDDLTracker;
   delete fBusStruct;
   delete fBlockHeader;
@@ -75,11 +75,11 @@ AliMUONPayloadTracker::~AliMUONPayloadTracker()
 Bool_t AliMUONPayloadTracker::Decode(UInt_t* buffer, Int_t totalDDLSize)
 {
 
-  // Each DDL is made with 2 Blocks each of which consists of 5 DSP's at most 
-  // and each of DSP has at most 5 buspatches.
-  // The different structures, Block (CRT), DSP (FRT) and Buspatch,
-  // are identified by a key word 0xFC0000FC, 0xF000000F and 0xB000000B respectively.
-  // (fBusPatchManager no more needed !)
+  /// Each DDL is made with 2 Blocks each of which consists of 5 DSP's at most 
+  /// and each of DSP has at most 5 buspatches.
+  /// The different structures, Block (CRT), DSP (FRT) and Buspatch,
+  /// are identified by a key word 0xFC0000FC, 0xF000000F and 0xB000000B respectively.
+  /// (fBusPatchManager no more needed !)
 
 
   //Read Header Size of DDL,Block,DSP and BusPatch
@@ -218,16 +218,16 @@ Bool_t AliMUONPayloadTracker::Decode(UInt_t* buffer, Int_t totalDDLSize)
 //______________________________________________________
 void AliMUONPayloadTracker::ResetDDL()
 {
-  // reseting TClonesArray
-  // after each DDL
-  //
+  /// reseting TClonesArray
+  /// after each DDL
+  ///
   fDDLTracker->GetBlkHeaderArray()->Delete();
 }
 
 //______________________________________________________
 void AliMUONPayloadTracker::SetMaxBlock(Int_t blk) 
 {
-  // set regional card number
+  /// set regional card number
   if (blk > 2) blk = 2;
   fMaxBlock = blk;
 }
@@ -235,9 +235,9 @@ void AliMUONPayloadTracker::SetMaxBlock(Int_t blk)
 //______________________________________________________
 Bool_t AliMUONPayloadTracker::CheckDataParity()
 {
-  // parity check
-  // taken from MuTrkBusPatch.cxx (sotfware test for CROCUS)
-  // A. Baldisseri
+  /// parity check
+  /// taken from MuTrkBusPatch.cxx (sotfware test for CROCUS)
+  /// A. Baldisseri
 
   Int_t  parity;
   UInt_t data;
index 1c27f2d..3d7ab69 100644 (file)
@@ -23,25 +23,39 @@ class AliMUONPayloadTracker: public TObject {
     AliMUONPayloadTracker();
     virtual ~AliMUONPayloadTracker();
 
+    /// Return maximum number of block per DDL in DATE file
     Int_t GetMaxBlock() const {return fMaxBlock;}
+    /// Return maximum number of Dsp per block in DATE file
     Int_t GetMaxDsp()   const {return fMaxDsp;}
+    /// Return maximum number of Buspatch per Dsp in DATE file
     Int_t GetMaxBus()   const {return fMaxBus;}
 
     // check input before assigment
     void SetMaxBlock(Int_t blk);
 
-    // does not check, done via BusPatchManager
+    /// \brief Set maximum number of Dsp per block in DATE file
+    /// does not check, done via BusPatchManager
     void SetMaxDsp(Int_t dsp) {fMaxDsp = dsp;}
+    /// \brief Set maximum number of Buspatch per Dsp in DATE file
+    /// does not check, done via BusPatchManager
     void SetMaxBus(Int_t bus) {fMaxBus = bus;}
 
     void ResetDDL();
 
     Bool_t Decode(UInt_t* buffer, Int_t datasize);
 
+    /// Return pointer for local structure
     AliMUONBusStruct*       GetBusPatchInfo() const {return fBusStruct;}
+    /// Return pointer for buspatch structure
     AliMUONDDLTracker*      GetDDLTracker()   const {return fDDLTracker;}
 
   private :
+    /// Not implemented
+    AliMUONPayloadTracker(const AliMUONPayloadTracker& stream);
+    /// Not implemented
+    AliMUONPayloadTracker& operator = (const AliMUONPayloadTracker& stream);
+
+    Bool_t CheckDataParity();
 
     Int_t  fBusPatchId;   ///< entry of buspatch structure
     Int_t  fDspId;        ///< entry of Dsp header
@@ -57,11 +71,6 @@ class AliMUONPayloadTracker: public TObject {
     AliMUONBlockHeader*     fBlockHeader;     //!< pointer for block structure 
     AliMUONDspHeader*       fDspHeader;       //!< pointer for dsp structure 
 
-    AliMUONPayloadTracker(const AliMUONPayloadTracker& stream);
-    AliMUONPayloadTracker& operator = (const AliMUONPayloadTracker& stream);
-
-    Bool_t CheckDataParity();
-
     ClassDef(AliMUONPayloadTracker, 1)    // base class for reading MUON raw digits
 };
 
index ff20008..a194f45 100644 (file)
@@ -25,18 +25,27 @@ class AliMUONPayloadTrigger: public TObject {
     Bool_t Decode(UInt_t *buffer);
     void   ResetDDL();
 
+    /// Return maximum number of regional cards in DATE file
     Int_t GetMaxReg() const {return fMaxReg;}
+    /// Return maximum number of local cards in DATE file
     Int_t GetMaxLoc() const {return fMaxLoc;}
 
 
     void SetMaxReg(Int_t reg);
     void SetMaxLoc(Int_t loc);
 
+    /// Return pointer to local structure
     AliMUONLocalStruct*     GetLocalInfo()  const {return fLocalStruct;}
+    /// Return pointer for regional structure
     AliMUONRegHeader*       GetRegHeader()  const {return fRegHeader;}
+    /// Return pointer for DDL structure
     AliMUONDDLTrigger*      GetDDLTrigger() const {return fDDLTrigger;}
 
   private :
+    /// Not implemented
+    AliMUONPayloadTrigger(const AliMUONPayloadTrigger& stream);
+    /// Not implemented
+    AliMUONPayloadTrigger& operator = (const AliMUONPayloadTrigger& stream);
 
     Int_t fMaxReg;        ///< maximum number of regional cards in DATE file
     Int_t fMaxLoc;        ///< maximum number of local cards in DATE file
@@ -45,10 +54,6 @@ class AliMUONPayloadTrigger: public TObject {
     AliMUONRegHeader*        fRegHeader;    //!< pointer for regional structure
     AliMUONLocalStruct*      fLocalStruct;  //!< pointer to local structure
 
-
-    AliMUONPayloadTrigger(const AliMUONPayloadTrigger& stream);
-    AliMUONPayloadTrigger& operator = (const AliMUONPayloadTrigger& stream);
-
     ClassDef(AliMUONPayloadTrigger, 1)    // base class for reading MUON trigger rawdata
 };
 
index 4409681..1fa19e0 100644 (file)
@@ -32,11 +32,15 @@ public:
   
   void Exec(Option_t* option);
   
+  /// Set option whether to generate DDL ascii files or not
   void MakeDDL(Bool_t value) { fMakeDDL = value; }
   
 private:
+  /// Not implemented
   AliMUONPedestalEventGenerator(const AliMUONPedestalEventGenerator&);
+  /// Not implemented
   AliMUONPedestalEventGenerator& operator=(const AliMUONPedestalEventGenerator&);
+
   Bool_t ConvertRawFilesToDate();
   void GenerateDigits(AliMUONData* data);
   AliMUONData* GetDataAccess(const char* mode);
@@ -44,12 +48,12 @@ private:
   void Digits2Raw();
   
 private:
-  TList* fManuList; //! list of (de,manu) pairs
-  AliMUONCalibrationData* fCalibrationData; //! access to pedestal CDB
-  TString fDateFileName; //! basefilename of the DATE output file
-  TString fGAliceFileName; //! absolute path to galice.root file
-  Bool_t fMakeDDL; //! whether to generate DDL ascii files or not
-  static Int_t fgCounter; //! 
+  TList* fManuList; //!< list of (de,manu) pairs
+  AliMUONCalibrationData* fCalibrationData; //!< access to pedestal CDB
+  TString fDateFileName; //!< basefilename of the DATE output file
+  TString fGAliceFileName; //!< absolute path to galice.root file
+  Bool_t fMakeDDL; //!< whether to generate DDL ascii files or not
+  static Int_t fgCounter; //!< counter 
   
   ClassDef(AliMUONPedestalEventGenerator,1) // Random generator of pedestal events for MUON TRK
 };
index 43135bc..aee2479 100644 (file)
@@ -57,13 +57,13 @@ AliMUONPedestalSubprocessor::AliMUONPedestalSubprocessor(AliMUONPreprocessor* ma
                        "Upload MUON Tracker pedestals to OCDB"),
 fPedestals(0x0)
 {
-  // default ctor
+  /// default ctor
 }
 
 //_____________________________________________________________________________
 AliMUONPedestalSubprocessor::~AliMUONPedestalSubprocessor()
 {
-  // dtor
+  /// dtor
   delete fPedestals;
 }
 
@@ -114,7 +114,7 @@ AliMUONPedestalSubprocessor::Initialize(Int_t run, UInt_t startTime, UInt_t endT
 UInt_t 
 AliMUONPedestalSubprocessor::Process(TMap* /*dcsAliasMap*/)
 {
-  // Store the pedestals into the CDB
+  /// Store the pedestals into the CDB
   
   if (!fPedestals) return 0;
     
@@ -135,14 +135,14 @@ AliMUONPedestalSubprocessor::Process(TMap* /*dcsAliasMap*/)
 Int_t
 AliMUONPedestalSubprocessor::ReadFile(const char* filename)
 {
-  // Read the pedestals from an ASCII file.
-  // Format of that file is one line per channel :
-  //---------------------------------------------------------------------------
-  // BUS_PATCH MANU_ADDR CHANNEL      MEAN       SIGMA
-  //---------------------------------------------------------------------------
-  //
-  // Return kFALSE if reading was not successfull.
-  //
+  /// Read the pedestals from an ASCII file.                                  \n
+  /// Format of that file is one line per channel :                           \n
+  ///-------------------------------------------------------------------------\n
+  /// BUS_PATCH MANU_ADDR CHANNEL      MEAN       SIGMA                       \n
+  ///-------------------------------------------------------------------------\n
+  ///                                                                         \n
+  /// Return kFALSE if reading was not successfull.                           \n
+  ///
   
   TString sFilename(gSystem->ExpandPathName(filename));
   
index a97f15d..e1278d1 100644 (file)
@@ -22,18 +22,18 @@ class AliMUONPixel : public TObject {
   AliMUONPixel(Double_t xc, Double_t yc, Double_t wx, Double_t wy, Double_t charge); // constructor
   virtual ~AliMUONPixel(); // Destructor
 
-  Double_t Charge(void) const { return fCharge; } // pixel charge
-  Double_t Size(Int_t ixy) const { return fSize[ixy]; } // pixel size
-  Double_t Coord(Int_t ixy) const { return fXY[ixy]; } // pixel coordinate
-  Int_t Flag(void) const { return fFlag; } // pixel flag
+  Double_t Charge(void) const { return fCharge; } ///< pixel charge
+  Double_t Size(Int_t ixy) const { return fSize[ixy]; } ///< pixel size
+  Double_t Coord(Int_t ixy) const { return fXY[ixy]; } ///< pixel coordinate
+  Int_t Flag(void) const { return fFlag; } ///< pixel flag
   
-  void SetCharge(Double_t Charge) { fCharge = Charge; } // set charge
-  void SetSize(Int_t ixy, Double_t Size) { fSize[ixy] = Size; } // set size
-  void SetCoord(Int_t ixy, Double_t Coord) { fXY[ixy] = Coord; } // set coordinate
-  void SetFlag(Int_t flag) { fFlag = flag; } // set flag
-  void Shift(Int_t ixy, Double_t shift) { fXY[ixy] += shift; }
+  void SetCharge(Double_t Charge) { fCharge = Charge; } ///< set charge
+  void SetSize(Int_t ixy, Double_t Size) { fSize[ixy] = Size; } ///< set size
+  void SetCoord(Int_t ixy, Double_t Coord) { fXY[ixy] = Coord; } ///< set coordinate
+  void SetFlag(Int_t flag) { fFlag = flag; } ///< set flag
+  void Shift(Int_t ixy, Double_t shift) { fXY[ixy] += shift; } ///< \todo add comment
   void Print(const char* opt="") const;
-  // What is necessary for sorting TObjArray's
+  /// What is necessary for sorting TObjArray's
   Bool_t IsSortable() const { return kTRUE; }
   Int_t Compare(const TObject* pixel) const; // "Compare" function for sorting
 
index 5d022d2..3032da5 100644 (file)
@@ -50,7 +50,9 @@ public:
   virtual void          SetMatrix(TMatrixF *matrix) {fMatrix = matrix;}
   
 protected:
+  /// Not implemented
   AliMUONPoints(const AliMUONPoints& points);  
+  /// Not implemented
   AliMUONPoints& operator = (const AliMUONPoints& rhs);
 
    Int_t            fHitIndex;         ///< Link to hit number 
index b38a544..909d481 100644 (file)
@@ -26,11 +26,14 @@ public:
   virtual UInt_t Process(TMap* dcsAliasMap);
   virtual void Print(Option_t* opt="") const;
   
+  /// Publish AliPreprocessor::Log function
   void Log(const char* message) { AliPreprocessor::Log(message); }
   
+  /// Publish AliPreprocessor::GetFileSources function
   TList* GetFileSources(Int_t system, const char* id) 
   { return AliPreprocessor::GetFileSources(system,id); }
 
+  /// Publish AliPreprocessor::Store function
   UInt_t Store(const char* pathLevel2, const char* pathLevel3, TObject* object,
                AliCDBMetaData* metaData, 
                Int_t validityStart = 0, Bool_t validityInfinite = kFALSE)
@@ -39,6 +42,7 @@ public:
                                   validityStart,validityInfinite);
   }
   
+  /// Publish AliPreprocessor::GetFile function
   const char* GetFile(Int_t system, const char* id, const char* source)
   {
     return AliPreprocessor::GetFile(system,id,source);
@@ -52,14 +56,16 @@ protected:
   void ClearSubprocessors();
   
 private:
+  /// Not implemented
   AliMUONPreprocessor(const AliMUONPreprocessor& rhs);
+  /// Not implemented
   AliMUONPreprocessor& operator=(const AliMUONPreprocessor& rhs);
   
   AliMUONVSubprocessor* Subprocessor(Int_t i) const;
   
 private:
 
-  TObjArray* fSubprocessors; ///!< sub processors to execute
+  TObjArray* fSubprocessors; //!< sub processors to execute
   
   ClassDef(AliMUONPreprocessor,1) // MUON Shuttle preprocessor
 };
index 5abe6f0..b2a613b 100644 (file)
@@ -34,6 +34,7 @@
 ClassImp(AliMUONRawCluster)
 /// \endcond
 
+//____________________________________________________
 AliMUONRawCluster::AliMUONRawCluster() 
   : TObject(),
     fClusterType(0),
@@ -61,6 +62,13 @@ AliMUONRawCluster::AliMUONRawCluster()
     fErrXY[0] = 0.144;
     fErrXY[1] = 0.01;
 }
+
+//____________________________________________________
+AliMUONRawCluster::~AliMUONRawCluster() 
+{
+/// Destructor
+}
+
 //____________________________________________________
 Int_t AliMUONRawCluster::Compare(const TObject *obj) const
 {
@@ -179,10 +187,10 @@ Int_t AliMUONRawCluster::PhysicsContribution() const
 //____________________________________________________
 void AliMUONRawCluster::Print(Option_t* opt) const
 {
-  //
-  // Printing Raw Cluster (Rec Point) information 
-  // "full" option for printing all the information about the raw cluster
-  //
+  ///
+  /// Printing Raw Cluster (Rec Point) information 
+  /// "full" option for printing all the information about the raw cluster
+  ///
   TString sopt(opt);
   sopt.ToUpper();
  
index 7ec3ec0..1431fe6 100644 (file)
@@ -23,8 +23,11 @@ class AliMUONRawCluster : public TObject {
 
 public:
    AliMUONRawCluster();
-   virtual ~AliMUONRawCluster() { }
+   virtual ~AliMUONRawCluster();
+   
+   /// Return radius
    Float_t      GetRadius(Int_t i) {return TMath::Sqrt(fX[i]*fX[i]+fY[i]*fY[i]);}
+   /// Return true as the function Compare() is implemented
    Bool_t       IsSortable() const {return kTRUE;}
    Int_t        Compare(const TObject *obj) const;
    Int_t        PhysicsContribution() const;
@@ -107,51 +110,67 @@ private:
 
 // inline functions
 
+/// Return Indices of digits
 inline  Int_t  AliMUONRawCluster::GetIndex(Int_t i, Int_t j) const
 { return fIndexMap[i][j]; }
 
+/// Return Emmanuel special offset map
 inline  Int_t  AliMUONRawCluster::GetOffset(Int_t i, Int_t j) const
 { return fOffsetMap[i][j]; }
 
+/// Return Contribution from digit
 inline  Float_t  AliMUONRawCluster::GetContrib(Int_t i, Int_t j) const
 { return fContMap[i][j]; }
 
+/// Return Distinguish signal and background contr.
 inline  Int_t  AliMUONRawCluster::GetPhysics(Int_t i) const
 { return fPhysicsMap[i]; }
 
+/// Set Indices of digits
 inline  void  AliMUONRawCluster::SetIndex(Int_t i, Int_t j, Int_t index)
 { fIndexMap[i][j] = index; }
 
+/// Set Emmanuel special offset map
 inline  void  AliMUONRawCluster::SetOffset(Int_t i, Int_t j, Int_t offset)
 { fOffsetMap[i][j] = offset; }
 
+/// Set Contribution from digit
 inline  void  AliMUONRawCluster::SetContrib(Int_t i, Int_t j, Float_t contrib)
 { fContMap[i][j] = contrib; }
 
+/// Set Distinguish signal and background contr.
 inline  void  AliMUONRawCluster::SetPhysics(Int_t i, Int_t physics)
 { fPhysicsMap[i] = physics; }
 
+/// Set ID number of the detection element (slat) on which the cluster is found.
 inline void AliMUONRawCluster::SetDetElemId(Int_t Id)
 { fDetElemId = Id; }
 
+/// Return ID number of the detection element (slat) on which the cluster is found.
 inline Int_t AliMUONRawCluster::GetDetElemId() const
 { return fDetElemId;}
 
+/// Set coordinate errors
 inline void AliMUONRawCluster::SetError(Int_t iXY, Float_t err)
 { fErrXY[iXY] = err; }
 
+/// Set x coordinate error
 inline void AliMUONRawCluster::SetErrX(Float_t err)
 { SetError(0, err); }
 
+/// Set y coordinate error
 inline void AliMUONRawCluster::SetErrY(Float_t err)
 { SetError(1, err); }
 
+/// Return coordinate errors
 inline Float_t AliMUONRawCluster::GetError(Int_t iXY) const
 { return fErrXY[iXY]; }
 
+/// Return x coordinate error
 inline Float_t AliMUONRawCluster::GetErrX() const
 { return GetError(0); }
 
+/// Return y coordinate error
 inline Float_t AliMUONRawCluster::GetErrY() const
 { return GetError(1); }
 
index 6358cf9..20f16a3 100644 (file)
@@ -27,26 +27,39 @@ class AliMUONRawStreamTracker: public TObject {
     virtual Bool_t   Next();
     virtual Bool_t   NextDDL();
 
+    /// Return maximum number of DDL in DATE file
     Int_t GetMaxDDL()   const {return fMaxDDL;}
+    /// Return maximum number of block per DDL in DATE file
     Int_t GetMaxBlock() const {return  fPayload->GetMaxBlock();}
+    /// Return maximum number of Dsp per block in DATE file
     Int_t GetMaxDsp()   const {return  fPayload->GetMaxDsp();}
+    /// Return maximum number of Buspatch per Dsp in DATE file
     Int_t GetMaxBus()   const {return  fPayload->GetMaxBus();}
 
     // check input before assigment
     void SetMaxDDL(Int_t ddl);
     void SetMaxBlock(Int_t blk);
 
-    // does not check, done via BusPatchManager
+    /// Set maximum number of Dsp per block in DATE file
+    /// does not check, done via BusPatchManager
     void SetMaxDsp(Int_t dsp) {fPayload->SetMaxDsp(dsp);}
+    /// Set maximum number of Buspatch per Dsp in DATE file
+    /// does not check, done via BusPatchManager
     void SetMaxBus(Int_t bus) {fPayload->SetMaxBus(bus);}
 
-
+    /// Set object for reading the raw data
     void SetReader(AliRawReader* rawReader) {fRawReader = rawReader;}
 
+    /// Return pointer for buspatch structure
     AliMUONDDLTracker*      GetDDLTracker()   const {return fPayload->GetDDLTracker();}
+    /// Return number of DDL
     Int_t                   GetDDL()          const {return fDDL - 1;}
 
   private :
+    /// Not implemented
+    AliMUONRawStreamTracker(const AliMUONRawStreamTracker& stream);
+    /// Not implemented
+    AliMUONRawStreamTracker& operator = (const AliMUONRawStreamTracker& stream);
 
     AliRawReader*    fRawReader;    ///< object for reading the raw data
  
@@ -61,9 +74,6 @@ class AliMUONRawStreamTracker: public TObject {
 
     AliMUONPayloadTracker* fPayload; ///< pointer to payload decoder
 
-    AliMUONRawStreamTracker(const AliMUONRawStreamTracker& stream);
-    AliMUONRawStreamTracker& operator = (const AliMUONRawStreamTracker& stream);
-
     ClassDef(AliMUONRawStreamTracker, 2)    // base class for reading MUON raw digits
 };
 
index e00563f..e6699b7 100644 (file)
@@ -27,8 +27,11 @@ class AliMUONRawStreamTrigger: public TObject {
     virtual Bool_t   Next();
     virtual Bool_t   NextDDL();
 
+    /// Return maximum number of DDL in DATE file
     Int_t GetMaxDDL() const {return fMaxDDL;}
+    /// Return maximum number of regional cards in DATE file
     Int_t GetMaxReg() const {return fPayload->GetMaxReg();}
+    /// Return maximum number of local cards in DATE file
     Int_t GetMaxLoc() const {return fPayload->GetMaxLoc();}
 
 
@@ -36,13 +39,19 @@ class AliMUONRawStreamTrigger: public TObject {
     void SetMaxReg(Int_t reg);
     void SetMaxLoc(Int_t loc);
 
-
+    /// Set object for reading the raw data
     void SetReader(AliRawReader* rawReader) {fRawReader = rawReader;}
 
+    /// Return pointer for DDL structure
     AliMUONDDLTrigger* GetDDLTrigger() const {return fPayload->GetDDLTrigger();}
+    /// Return number of DDL
     Int_t              GetDDL()        const {return fDDL - 1;}
 
   private :
+    /// Not implemented
+    AliMUONRawStreamTrigger(const AliMUONRawStreamTrigger& stream);
+    /// Not implemented
+    AliMUONRawStreamTrigger& operator = (const AliMUONRawStreamTrigger& stream);
 
     AliRawReader*    fRawReader;     ///< object for reading the raw data
     AliMUONPayloadTrigger* fPayload; ///< pointer to payload decoder
@@ -52,9 +61,6 @@ class AliMUONRawStreamTrigger: public TObject {
     Bool_t fNextDDL;      ///< flag for next DDL to be read
     Int_t  fMaxDDL;       ///< maximum number of DDL in DATE file
 
-    AliMUONRawStreamTrigger(const AliMUONRawStreamTrigger& stream);
-    AliMUONRawStreamTrigger& operator = (const AliMUONRawStreamTrigger& stream);
-
     ClassDef(AliMUONRawStreamTrigger, 3)    // base class for reading MUON trigger rawdata
 };
 
index 06cc3c8..061af4b 100644 (file)
@@ -48,6 +48,10 @@ public:
   TClonesArray *GetMuonTrackRef() {return fMuonTrackRef;}
 
 private:
+  /// Not implemented
+  AliMUONRecoCheck(const AliMUONRecoCheck& rhs);
+  /// Not implemented
+  AliMUONRecoCheck& operator = (const AliMUONRecoCheck& rhs);
   
   AliRunLoader* fRunLoader;     ///< alice run loader 
   AliMUONData*  fMUONData;      ///< Data container for MUON subsystem 
@@ -59,9 +63,6 @@ private:
                                 /// to decide if the class should or not deal with the loaders
 
 
-  AliMUONRecoCheck(const AliMUONRecoCheck& rhs);
-  AliMUONRecoCheck& operator = (const AliMUONRecoCheck& rhs);
-
   ClassDef(AliMUONRecoCheck, 0)   //Utility class to check reconstruction
 };
 
index f5b89a2..c8e8b29 100644 (file)
@@ -62,6 +62,12 @@ AliMUONRecoTrack::AliMUONRecoTrack(Bool_t active)
 }
 
 //-------------------------------------------------------------------
+AliMUONRecoTrack::~AliMUONRecoTrack() 
+{
+/// Destructor
+}
+
+//-------------------------------------------------------------------
 Double_t AliMUONRecoTrack::Phi() const
 {
 /// Return trach phi angle
index 29e3f8e..8f219b1 100644 (file)
@@ -20,21 +20,35 @@ class AliMUONRecoTrack : public TObject
   public:
     AliMUONRecoTrack();
     AliMUONRecoTrack(Bool_t active);
-    virtual        ~AliMUONRecoTrack() { }     //desctructor
+    virtual        ~AliMUONRecoTrack();
+
+    /// Return chi squared for reco. track
     Double_t GetChi2r() const {return fChi2r;};
+    /// Return reconstr. momentum (same as in vertex)
     Double_t GetMomReconstr(Int_t axis) const {return fPr[axis];};
+    /// Return charge sign
     Int_t    GetSign() const {return fSign;};
+    /// Return hit X position in all chambers
     Double_t GetPosX(Int_t chamber) const {return fPosX[chamber];};
+    /// Return hit Y position in all chambers
     Double_t GetPosY(Int_t chamber) const {return fPosY[chamber];};
+    /// Return hit Z position in all chambers
     Double_t GetPosZ(Int_t chamber) const {return fPosZ[chamber];};
+    /// Return z of track vertex point
     Double_t GetVertexPos() const { return fZvr;};
+    /// \todo add comment
     Double_t P() const {return TMath::Sqrt(fPr[0]*fPr[0] + fPr[1]*fPr[1] + fPr[2]*fPr[2]);};
     Double_t Phi() const;
+    
+    /// Set chi squared for reco. track
     void           SetChi2r(Double_t chi) { fChi2r = chi;};
     void           SetHitPosition(Int_t chamber, Double_t x, Double_t y, Double_t z);
     void           SetMomReconstr(Double_t px, Double_t py, Double_t pz);
+    /// Set charge sign
     void           SetSign(Int_t sign) {fSign = sign;};
+    /// Set z of track vertex point
     void           SetVertexPos(Double_t zvr) {fZvr = zvr;};
+    /// Set flag of reconstructed track (0-"good", >0-"bad")
     void           SetFlag(Int_t flag)  {fFlag = flag;};
 
     Double_t Theta() const;
@@ -42,10 +56,10 @@ class AliMUONRecoTrack : public TObject
 
   private:
     Int_t       fSign;                  ///< charge sign
-    Int_t       fFlag;                  ///<  flag of reconstructed track (0-"good", >0-"bad") 
+    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   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
index 30663d9..e8887a9 100644 (file)
@@ -30,16 +30,20 @@ class AliMUONReconstructor: public AliReconstructor
     AliMUONReconstructor();
     virtual ~AliMUONReconstructor();
 
+    /// Dummy implementation    
     virtual void         Reconstruct(TTree* /*digitsTree*/, 
                                     TTree* /*clustersTree*/) const {return;}
+    /// Dummy implementation    
     virtual void         Reconstruct(AliRawReader* /*rawReader*/, 
                                     TTree* /*clustersTree*/) const {return;}
     virtual void         Reconstruct(AliRunLoader* runLoader) const;
     virtual void         Reconstruct(AliRunLoader* runLoader, 
                                    AliRawReader* rawReader) const;
 
+    /// Dummy implementation    
     virtual void         FillESD(TTree* /*digitsTree*/, TTree* /*clustersTree*/, 
                                 AliESD* /*esd*/) const {return;}
+    /// Dummy implementation    
     virtual void         FillESD(AliRawReader* /*rawReader*/, TTree* /*clustersTree*/, 
                                 AliESD* /*esd*/) const {return;}
     virtual void         FillESD(AliRunLoader* runLoader, AliESD* esd) const;
@@ -55,7 +59,9 @@ private:
     TTask* GetCalibrationTask() const;
     AliMUONClusterReconstructor* CreateClusterReconstructor() const;
     
+    /// Not implemented
     AliMUONReconstructor(const AliMUONReconstructor& right);
+    /// Not implemented
     AliMUONReconstructor&  operator = (const AliMUONReconstructor& right);
 
 private:
index cd49c23..9303313 100644 (file)
@@ -25,69 +25,104 @@ public:
 
    virtual ~AliMUONRegHeader();
 
+   /// Return darc word
    UInt_t   GetDarcWord()      const {return fDarcWord;}
+   /// Return first reg word
    UInt_t   GetWord()          const {return fWord;}
+   /// Return regional input
    UInt_t   GetInput(Int_t n)  const {return fInput[n];}
+   /// Return L0
    UShort_t GetL0()            const {return fL0   & 0xFFFF;}
+   /// Return mask
    UShort_t GetMask()          const {return fMask & 0xFFFF;}
 
    //word: phys type:1, reset: 6, serialNb:5, Id:4, version: 8, regional output:8
    //true for phys, false for soft
+   /// Return RegPhysFlag
    Bool_t    GetRegPhysFlag() const {return (fWord & 0x80000000);} 
+   /// Return ResetNb
    UChar_t   GetResetNb()    const {return (UChar_t)(fWord >> 25) &  0x20;}
+   /// Return SerialNb
    UChar_t   GetSerialNb()   const {return (UChar_t)(fWord >> 20) &  0x1F;}
+   /// Return Id
    UChar_t   GetId()         const {return (UChar_t)(fWord >> 16) &  0x0F;}
+   /// Return Version
    UChar_t   GetVersion()    const {return (UChar_t)(fWord >> 8)  &  0xFF;}
+   /// Return Output
    UChar_t   GetOutput()     const {return (UChar_t)(fWord       &  0xFF);}
 
    //Darc Status: error:10, #fpag:3, MBZ:3, phys type:1, present:1, not_full:1
    // not_empty:1, L2Rej:1, L2Acc:1, L1:1, L0:1, #evt:4, busy:4
+   /// Return ErrorBits
    UShort_t GetErrorBits()       const {return (UShort_t)(fDarcWord >> 21) &  0x3FF;}
+   /// Return FPGANumber
    UChar_t  GetFPGANumber()      const {return (UChar_t)  (fDarcWord >> 18) &  0x7;}
+   /// Return DarcPhysFlag
    Bool_t   GetDarcPhysFlag()    const {return (fDarcWord  &  0x1000);}
+   /// Return PresentFlag
    Bool_t   GetPresentFlag()     const {return (fDarcWord  &  0x800);}
+   /// Return RamNotFullFlag
    Bool_t   GetRamNotFullFlag()  const {return (fDarcWord  &  0x400);}
+   /// Return RamNotEmptyFlag
    Bool_t   GetRamNotEmptyFlag() const {return (fDarcWord  &  0x200);}
+   /// Return L2RejStatus
    Bool_t   GetL2RejStatus()     const {return (fDarcWord  &  0x100);}
+   /// Return L2AccStatus
    Bool_t   GetL2AccStatus()     const {return (fDarcWord  &  0x80);}
+   /// Return L1Status
    Bool_t   GetL1Status()        const {return (fDarcWord  &  0x40);}
+   /// Return L0Status
    Bool_t   GetL0Status()        const {return (fDarcWord  &  0x20);}
+   /// Return EventInRam
    UChar_t  GetEventInRam()      const {return (UChar_t)  (fDarcWord >> 4)  &  0x4;}
+   /// Return Busy
    UChar_t  GetBusy()            const {return (UChar_t)  (fDarcWord)       &  0x4;}
 
+   /// Set darc word
    void    SetDarcWord(UInt_t w) {fDarcWord = w;}
+   /// Set first reg word
    void    SetWord(UInt_t w)     {fWord = w;}
+   /// Set local mask ("poids faible" 16 bits)
    void    SetMask(UShort_t m)   {fMask = m;}
+   /// Set L0
    void    SetL0(UShort_t l)     {fL0   = (l & 0xFFFF);}
+   /// Set regional input
    void    SetInput(UInt_t in, Int_t n) {fInput[n] = in;}
  
 
+   /// Return header length in word
    Int_t   GetHeaderLength() const {return fgkHeaderLength;}
+   /// Return end of regional info word
    UInt_t  GetEndOfReg()     const {return fgkEndOfReg;}
 
 
+   /// Return header
    UInt_t* GetHeader() {return &fDarcWord;}
 
   // scalar methods
+   /// Return regional clock
    UInt_t  GetClock()   const {return fClk;}
+    /// Return regional ouput
    const UInt_t* GetScaler()  const {return fScaler;}
+   /// Return regional hold (dead time)
    UInt_t  GetHold()    const {return fHold;}
 
+   /// Return scalers
    UInt_t* GetScalers()    {return &fClk;}   
 
-   // get scaler length
+   /// get scaler length
    Int_t GetScalerLength()  const {return fgkScalerLength;} 
 
-  // set random numbers to fill variable
+   /// set random numbers to fill variable
    void SetScalersNumbers();
 
-  // get TClonesArray
+   /// get TClonesArray
    TClonesArray*  GetLocalArray()  const {return fLocalArray;}
 
-   // get entries
+   /// get entries
    Int_t GetLocalEntries()  const {return fLocalArray->GetEntriesFast();}
 
-   // get entry
+   /// get entry
    AliMUONLocalStruct* GetLocalEntry(Int_t i) const {
      return (AliMUONLocalStruct*)fLocalArray->At(i);}
 
index 0aa5f56..bf2da84 100644 (file)
@@ -54,6 +54,11 @@ AliMUONRegionalTrigger::AliMUONRegionalTrigger(const AliMUONRegionalTrigger& the
  
 }
 //----------------------------------------------------------------------
+AliMUONRegionalTrigger::~AliMUONRegionalTrigger()
+{
+/// Destructor
+}
+//----------------------------------------------------------------------
 AliMUONRegionalTrigger& AliMUONRegionalTrigger::operator=(const AliMUONRegionalTrigger& theMUONRegionalTrig)
 {
 /// Assigment operator;
@@ -79,9 +84,9 @@ AliMUONRegionalTrigger& AliMUONRegionalTrigger::operator=(const AliMUONRegionalT
 //----------------------------------------------------------------------
 void AliMUONRegionalTrigger::Print(Option_t* opt) const
 {
-  //
-  // Printing Regional Trigger information
-  //
+  ///
+  /// Printing Regional Trigger information
+  ///
   TString sopt(opt);
   sopt.ToUpper();
  
index 1ff35fe..2245b1a 100644 (file)
@@ -18,19 +18,27 @@ class AliMUONRegionalTrigger : public TObject {
  public:
   AliMUONRegionalTrigger();
   AliMUONRegionalTrigger(const AliMUONRegionalTrigger& rhs); // copy constructor !
-  virtual ~AliMUONRegionalTrigger(){;}
+  virtual ~AliMUONRegionalTrigger();
   AliMUONRegionalTrigger& operator=(const AliMUONRegionalTrigger& rhs); 
 
   // getter methods
+  /// Return regional id 
   Int_t    GetId()        const {return fId;}
+  /// Return local output Lpt & Hpt
   UInt_t   GetLocalOutput(Int_t n) const {return fLocalOutput[n];}
+  /// Return local mask
   UShort_t GetLocalMask() const {return fLocalMask;}
+  /// Return regional output (single muon:2, unlike sign:1, like sign:1)
   Char_t   GetOutput()    const {return fOutput;}
 
   // setter methods
+  /// Set regional id 
   void  SetId(Int_t d)           {fId = d;}
+  /// Set local output Lpt & Hpt
   void  SetLocalOutput(UInt_t local, Int_t n) {fLocalOutput[n] = local;}
+  /// Set local mask
   void  SetLocalMask(UShort_t m) {fLocalMask = m;}
+  /// Set regional output (single muon:2, unlike sign:1, like sign:1)
   void  SetOutput(Char_t o)      {fOutput = o;}
 
   virtual void Print(Option_t* opt="") const;
index 2d1f88a..c32002c 100644 (file)
@@ -20,6 +20,7 @@
 /// - entry are local board responses
 /// - output is 12-bit word
 /// - algorithm is similar to the global one
+/// \todo Change member functions comments in capital letters to normal text
 ///
 /// \author Rachid Guernane (LPCCFd)
 
 
 #include <Riostream.h>
 
+/// \cond CLASSIMP
 ClassImp(AliMUONRegionalTriggerBoard)
+/// \endcond
 
 //___________________________________________
 AliMUONRegionalTriggerBoard::AliMUONRegionalTriggerBoard()
 {
+/// Default constructor
    for (Int_t i=0; i<16; i++) fLocalResponse[i] = 0;
 }
 
 //___________________________________________
 AliMUONRegionalTriggerBoard::AliMUONRegionalTriggerBoard(const char *name, Int_t a) : AliMUONTriggerBoard(name, a)
 {
+/// Standard constructor
    for (Int_t i=0; i<16; i++) fLocalResponse[i] = 0;
 }
 
 //___________________________________________
+AliMUONRegionalTriggerBoard::~AliMUONRegionalTriggerBoard()
+{
+/// Destructor
+}
+
+//___________________________________________
 void AliMUONRegionalTriggerBoard::Response()
 {
-/*   
-  RESPONSE IS GIVEN FOLLOWING THE REGIONAL ALGORITHM
-*/
+/// RESPONSE IS GIVEN FOLLOWING THE REGIONAL ALGORITHM
+
   Int_t t[16];
 
    for (Int_t i=0;i<16;i++) t[i] = fLocalResponse[i] & fMask[i];
@@ -81,9 +91,10 @@ void AliMUONRegionalTriggerBoard::Response()
 //___________________________________________
 UShort_t AliMUONRegionalTriggerBoard::Algo(UShort_t i, UShort_t j, char *thres, Int_t level)
 {
-// IMPLEMENTATION OF THE REGIONAL ALGORITHM
-// SIMILAR TO THE GLOBAL ALGORITHM EXCEPT FOR THE
-// INPUT LAYER
+/// IMPLEMENTATION OF THE REGIONAL ALGORITHM
+/// SIMILAR TO THE GLOBAL ALGORITHM EXCEPT FOR THE
+/// INPUT LAYER
+
   TBits a(8), b(8); a.Set(8,&i); b.Set(8,&j);
 
    TBits trg1(2), trg2(2), trg(2);
@@ -157,9 +168,8 @@ UShort_t AliMUONRegionalTriggerBoard::Algo(UShort_t i, UShort_t j, char *thres,
 //___________________________________________
 void AliMUONRegionalTriggerBoard::Scan(Option_t*) const
 {
-/*  
-  SCAN LOCAL BOARD ENTRIES 
-*/
+/// SCAN LOCAL BOARD ENTRIES 
+
   for (Int_t i=0; i<16; i++) 
    {
       TBits b;
@@ -174,7 +184,8 @@ void AliMUONRegionalTriggerBoard::Scan(Option_t*) const
 //___________________________________________
 void AliMUONRegionalTriggerBoard::Mask(Int_t index, UShort_t mask)
 {
-// MASK ENTRY index
+/// MASK ENTRY index
+
   if ( index>=0 && index < 16 ) 
   {
     fMask[index]=mask;
@@ -184,5 +195,3 @@ void AliMUONRegionalTriggerBoard::Mask(Int_t index, UShort_t mask)
     AliError(Form("Index %d out of bounds (max %d)",index,16));
   }
 }
-
-ClassImp(AliMUONRegionalTriggerBoard)
index a419f83..e6ad58e 100644 (file)
@@ -18,16 +18,19 @@ class AliMUONRegionalTriggerBoard : public AliMUONTriggerBoard
    public: 
       AliMUONRegionalTriggerBoard();  
       AliMUONRegionalTriggerBoard(const char *name, Int_t a);
-      virtual ~AliMUONRegionalTriggerBoard() {;}
+      virtual ~AliMUONRegionalTriggerBoard();
     
+      /// Reset Local trigger inputs
       virtual void Reset() {for (Int_t i=0; i<16; i++) fLocalResponse[i] = 0;}
 
       virtual void Scan(Option_t *option) const;
 
+      /// Dummy implementation
       virtual void Resp(Option_t*) const {}
 
       virtual void Response();
 
+      /// Set Local trigger inputs
       virtual void SetLocalResponse(UShort_t val[16]) {for (Int_t i=0;i<16;i++) fLocalResponse[i] = val[i];}
 
       virtual UShort_t Algo(UShort_t i, UShort_t j, char *thres, Int_t level);
index 6745beb..6aaf104 100644 (file)
@@ -26,7 +26,9 @@
 #include "AliLog.h"
 #include "TList.h"
 
+/// \cond CLASSIMP
 ClassImp(AliMUONResponse)
+/// \endcond
 
 AliMUONResponse::AliMUONResponse()
   : TObject()
index 801d262..76d52f5 100644 (file)
@@ -29,48 +29,48 @@ class AliMUONResponse : public TObject
     //
     // Configuration methods
     //
-    // Set number of sigmas over which cluster disintegration is performed
+    /// Set number of sigmas over which cluster disintegration is performed (dummy)
     virtual void    SetSigmaIntegration(Float_t)           {return;}
-    // Get number of sigmas over which cluster disintegration is performed
+    /// Get number of sigmas over which cluster disintegration is performed (dummy)
     virtual Float_t SigmaIntegration() const                  {return 1.;}
-    // Set single electron pulse height (ADCcounts/e)
+    /// Set single electron pulse height (ADCcounts/e) (dummy)
     virtual void    SetChargeSlope(Float_t )                {return;}
-    // Get single electron pulse height (ADCcounts/e)
+    /// Get single electron pulse height (ADCcounts/e) (dummy)
     virtual Float_t ChargeSlope() const                       {return 1.;}
-    // Set sigmas of the charge spread function
+    /// Set sigmas of the charge spread function (dummy)
     virtual void    SetChargeSpread(Float_t , Float_t )   {return;}
-    // Get sigma_X of the charge spread function
+    /// Get sigma_X of the charge spread function (dummy)
     virtual Float_t ChargeSpreadX() const                     {return 1.;}
-    // Get sigma_Y of the charge spread function
+    /// Get sigma_Y of the charge spread function (dummy)
     virtual Float_t ChargeSpreadY() const                     {return 1.;}
-    // Set maximum Adc-count value
+    /// Set maximum Adc-count value (dummy)
     virtual void    SetMaxAdc(Int_t )                       {return;}
-    // Set saturation value
+    /// Set saturation value (dummy)
     virtual void    SetSaturation(Int_t )                   {return;}
-    // Set zero suppression threshold
+    /// Set zero suppression threshold (dummy)
     virtual void    SetZeroSuppression(Int_t )             {return;}
-    // Get maximum Adc-count value
+    /// Get maximum Adc-count value (dummy)
     virtual Int_t MaxAdc() const                              {return kTRUE;}
-    // Get saturation value
+    /// Get saturation value (dummy)
     virtual Int_t Saturation() const                          {return kTRUE;}
-    // Get maximum zero suppression threshold
+    /// Get maximum zero suppression threshold (dummy)
     virtual Int_t ZeroSuppression() const                     {return kTRUE;}
-    // Set anode cathode Pitch
+    /// Set anode cathode Pitch (dummy)
     virtual void    SetPitch(Float_t)                         {return;}
-    // Get anode cathode Pitch
+    /// Get anode cathode Pitch (dummy)
     virtual Float_t Pitch() const                             {return 1.;}
-    // Set the charge correlation
+    /// Set the charge correlation (dummy)
     virtual void SetChargeCorrel(Float_t)                     {return;}
-    // Get the charge correlation
+    /// Get the charge correlation (dummy)
     virtual Float_t ChargeCorrel() const                      {return 1.;}
-    //  
+    ///  
     // Chamber response methods
-    // Pulse height from scored quantity (eloss)
+    /// Pulse height from scored quantity (eloss) (dummy)
     virtual Float_t IntPH(Float_t) const                      {return 1.;}
-    // Charge disintegration 
+    /// Charge disintegration (dummy)
     virtual Float_t IntXY(Int_t, AliMUONGeometrySegmentation*) const {return 1.;}
     
-    /// Go from one hit to several digits, applying charge spreading.
+    //// Go from one hit to several digits, applying charge spreading.
     virtual void DisIntegrate(const AliMUONHit& hit, TList& digits);
 
     // 
index 9e3651d..b68eaa5 100644 (file)
@@ -34,7 +34,9 @@
 #include "AliMUONResponseTrigger.h"
 #include "AliMUONResponseTriggerV1.h"
 
+/// \cond CLASSIMP
 ClassImp(AliMUONResponseFactory)
+/// \endcond
 
 //__________________________________________________________________________
   AliMUONResponseFactory::AliMUONResponseFactory(const char* name)
index ac86ee9..3205bdc 100644 (file)
@@ -30,7 +30,9 @@ class AliMUONResponseFactory : public  TNamed {
     void BuildStation(AliMUON* where, Int_t stationNumber);
 
   private:
+    /// Not implemented
     AliMUONResponseFactory(const AliMUONResponseFactory& rhs);
+    /// Not implemented
     AliMUONResponseFactory& operator=(const AliMUONResponseFactory& rhs);
 
     void BuildCommon();
index 69f6c4e..57e05d7 100644 (file)
@@ -123,9 +123,9 @@ Int_t AliMUONResponseTriggerV1::SetGenerCluster()
 Float_t AliMUONResponseTriggerV1::FireStripProb(Float_t x4, Float_t theta)
 const
 {
-// parametrisation of the probability that a strip neighbour of the main 
-// strip is fired (V.Barret B.Espagnon and P.Rosnet INT/DIM/01-04 (2001)
-// WARNING : need to convert x4 from cm to mm
+/// parametrisation of the probability that a strip neighbour of the main 
+/// strip is fired (V.Barret B.Espagnon and P.Rosnet INT/DIM/01-04 (2001)
+/// WARNING : need to convert x4 from cm to mm
 
  return 
      (TMath::Cos(theta)*fA/(fA+TMath::Cos(theta)*TMath::Power(x4*10.,fB))+fC)/
index ee587b5..bd177f5 100644 (file)
@@ -93,6 +93,11 @@ class AliMUONResponseV0 : public AliMUONResponse
     virtual void Print(Option_t* opt="") const;
      
  protected:
+    /// Not implemented
+    AliMUONResponseV0(const AliMUONResponseV0& rhs);
+    /// Not implemented
+    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
@@ -105,11 +110,6 @@ class AliMUONResponseV0 : public AliMUONResponse
     AliMUONMathieson* fMathieson;      ///< pointer to mathieson fct
     Float_t fChargeThreshold;          ///< Charges below this threshold are = 0  
 
-  private:
-    AliMUONResponseV0(const AliMUONResponseV0& rhs);
-    AliMUONResponseV0& operator = (const AliMUONResponseV0& rhs);
-
-   
     ClassDef(AliMUONResponseV0,2) // Implementation of detector response
 };
 
index 017f808..9912a70 100644 (file)
@@ -54,31 +54,31 @@ ClassImp(AliMUONSDigitizerV2)
 AliMUONSDigitizerV2::AliMUONSDigitizerV2() 
 : TTask("AliMUONSDigitizerV2","From Hits to SDigits for MUON")
 {
-  //
-  // ctor.
-  //
+  ///
+  /// ctor.
+  ///
 }
 
 //_____________________________________________________________________________
 AliMUONSDigitizerV2::~AliMUONSDigitizerV2()
 {
-  //
-  // dtor.
-  //
+  ///
+  /// dtor.
+  ///
 }
 
 //_____________________________________________________________________________
 void
 AliMUONSDigitizerV2::Exec(Option_t*)
 {
-  //
-  // Go from hits to sdigits.
-  //
-  // In the code below, apart from the loop itself (which look complicated
-  // but is really only a loop on each hit in the input file) the main
-  // work is done in AliMUONResponse::DisIntegrate method, which converts
-  // a single hit in (possibly) several sdigits.
-  //
+  ///
+  /// Go from hits to sdigits.
+  ///
+  /// In the code below, apart from the loop itself (which look complicated
+  /// but is really only a loop on each hit in the input file) the main
+  /// work is done in AliMUONResponse::DisIntegrate method, which converts
+  /// a single hit in (possibly) several sdigits.
+  ///
   
   AliDebug(1,"");
   
index eeaf6af..e3fd0fd 100644 (file)
@@ -69,11 +69,12 @@ class AliMUONSegFactory : public  TObject {
               // Returned segmentation contains all the lower level segmentations
              // created with the factory
 
-  protected:
+  private:
+    /// Not implemented
     AliMUONSegFactory(const AliMUONSegFactory& rhs);
+    /// Not implemented
     AliMUONSegFactory& operator=(const AliMUONSegFactory& rhs);
 
-  private:
     AliMUONVGeometryDESegmentation*  
       CreateDESegmentation(Int_t detElemId, AliMp::CathodType cath);
               // Create DE segmentation, operating in local reference frame
index 80ee5d5..50b7b67 100644 (file)
@@ -71,7 +71,9 @@ class AliMUONSegmentation : public TObject
     TString  GetDEName(Int_t detElemId, Int_t cathod = 0) const;
 
   protected:
+    /// Not implemented
     AliMUONSegmentation(const AliMUONSegmentation& right);
+    /// Not implemented
     AliMUONSegmentation&  operator = (const AliMUONSegmentation& right);
      
   private:
index 86a6997..534064e 100644 (file)
 
 // $Id$
 //
-// Class AliMUONSlatGeometryBuilder
-// -------------------------------
-// Abstract base class for geometry construction per chamber.
-//
-
-
 
-// This Builder is designed according to the enveloppe methode. The basic idea is to be able to allow moves 
-// of the slats on the support panels. 
-// Those moves can be described with a simple set of parameters. The next step should be now to describe all 
-// the slats and their places by a unique 
-// class, which would make the SlatBuilder far more compact since now only three parameters can define a slat 
-// and its position, like:
-//   * Bool_t rounded_shape_slat
-//   * Float_t slat_length
-//   * Float_t slat_number or Float_t slat_position
-// Reference system is the one described in the note ALICE-INT-2003-038  v.2  EDMS Id 406391 
+/// \class AliMUONSlatGeometryBuilder
+/// This Builder is designed according to the enveloppe methode. The basic idea is to be able to allow moves 
+/// of the slats on the support panels. 
+/// Those moves can be described with a simple set of parameters. The next step should be now to describe all 
+/// the slats and their places by a unique 
+/// class, which would make the SlatBuilder far more compact since now only three parameters can define a slat 
+/// and its position, like:
+///   - Bool_t rounded_shape_slat
+///   - Float_t slat_length
+///   - Float_t slat_number or Float_t slat_position
+/// Reference system is the one described in the note ALICE-INT-2003-038  v.2  EDMS Id 406391 
+///
+/// \author Eric Dumonteil (dumontei@cea.fr)
 
 #include "AliMUONSlatGeometryBuilder.h"
 #include "AliMUON.h"
@@ -63,7 +60,7 @@ AliMUONSlatGeometryBuilder::AliMUONSlatGeometryBuilder(AliMUON* muon)
  : AliMUONVGeometryBuilder(4, 12),
    fMUON(muon)
 {
-// Standard constructor
+/// Standard constructor
 
 }
 
@@ -72,12 +69,13 @@ AliMUONSlatGeometryBuilder::AliMUONSlatGeometryBuilder()
  : AliMUONVGeometryBuilder(),
    fMUON(0)
 {
-// Default constructor
+/// Default constructor
 }
 
 //______________________________________________________________________________
-AliMUONSlatGeometryBuilder::~AliMUONSlatGeometryBuilder() {
-//
+AliMUONSlatGeometryBuilder::~AliMUONSlatGeometryBuilder() 
+{
+/// Destructor
 }
 
 //
@@ -87,13 +85,13 @@ AliMUONSlatGeometryBuilder::~AliMUONSlatGeometryBuilder() {
 //______________________________________________________________________________
 void AliMUONSlatGeometryBuilder::CreateGeometry()
 {
-  // CreateGeometry is the method containing all the informations concerning Stations 345 geometry.
-  // It includes description and placements of support panels and slats.
-  // The code comes directly from what was written in AliMUONv1.cxx before, with modifications concerning 
-  // the use of Enveloppe method to place the Geant volumes.
-  // Now, few changes would allow the creation of a Slat methode where slat could be described by few parameters, 
-  // and this builder would then be dedicated only to the
-  // placements of the slats. Those modifications could shorten the Station 345 geometry by a non-negligeable factor...
+  /// CreateGeometry is the method containing all the informations concerning Stations 345 geometry.
+  /// It includes description and placements of support panels and slats.
+  /// The code comes directly from what was written in AliMUONv1.cxx before, with modifications concerning 
+  /// the use of Enveloppe method to place the Geant volumes.
+  /// Now, few changes would allow the creation of a Slat methode where slat could be described by few parameters, 
+  /// and this builder would then be dedicated only to the
+  /// placements of the slats. Those modifications could shorten the Station 345 geometry by a non-negligeable factor...
  
   Int_t *idtmed = fMUON->GetIdtmed()->GetArray()-1099;
 
@@ -1257,8 +1255,7 @@ void AliMUONSlatGeometryBuilder::CreateGeometry()
 //______________________________________________________________________________
 void AliMUONSlatGeometryBuilder::SetTransformations()
 {
-// Defines the transformations for the station345 chambers.
-// ---
+/// Defines the transformations for the station345 chambers.
 
   if (gAlice->GetModule("DIPO")) {
     // if DIPO is preset, the whole station will be placed in DDIP volume
@@ -1326,8 +1323,7 @@ void AliMUONSlatGeometryBuilder::SetTransformations()
 //______________________________________________________________________________
 void AliMUONSlatGeometryBuilder::SetSensitiveVolumes()
 {
-// Defines the sensitive volumes for slat stations chambers.
-// ---
+/// Defines the sensitive volumes for slat stations chambers.
 
   GetGeometry( 4)->SetSensitiveVolume("S05G");
   GetGeometry( 5)->SetSensitiveVolume("S05G");
@@ -1346,8 +1342,8 @@ void AliMUONSlatGeometryBuilder::SetSensitiveVolumes()
 //______________________________________________________________________________
 Int_t  AliMUONSlatGeometryBuilder::ConvertSlatNum(Int_t numslat, Int_t quadnum, Int_t fspq) const
 {
-// On-line function establishing the correspondance between numslat (the slat number on a particular quadrant (numslat->0....4 for St3))
-// and slatnum (the slat number on the whole panel (slatnum->1...18 for St3)
+/// On-line function establishing the correspondance between numslat (the slat number on a particular quadrant (numslat->0....4 for St3))
+/// and slatnum (the slat number on the whole panel (slatnum->1...18 for St3)
   numslat += 1;
   if (quadnum==2 || quadnum==3) 
     numslat += fspq;
index 87e4cf5..bdcb455 100644 (file)
@@ -8,7 +8,7 @@
 /// \class AliMUONSlatGeometryBuilder
 /// \brief MUON Station3 geometry construction class
 ///
-/// Author: Eric Dumonteil (dumontei@cea.fr)
+//  Author: Eric Dumonteil (dumontei@cea.fr)
 
 
 #ifndef ALI_MUON_SLAT_GEOMETRY_BUILDER_H
@@ -30,13 +30,12 @@ class AliMUONSlatGeometryBuilder : public AliMUONVGeometryBuilder
     virtual void SetTransformations();
     virtual void SetSensitiveVolumes();
 
-  protected:
-    
   private:
+    /// Not implemented
     AliMUONSlatGeometryBuilder(const AliMUONSlatGeometryBuilder& rhs);
-
-    // operators  
+    /// Not implemented
     AliMUONSlatGeometryBuilder& operator = (const AliMUONSlatGeometryBuilder& rhs);
+
     Int_t  ConvertSlatNum(Int_t numslat, Int_t quadnum, Int_t fspq) const;
 
     AliMUON*  fMUON; ///< the MUON detector class 
index 475121e..ff351cd 100644 (file)
@@ -150,13 +150,12 @@ class AliMUONSt12QuadrantSegmentation : public AliMUONVGeometryDESegmentation
     virtual TF1* CorrFunc(Int_t isec)  const;
                    // Get the correction Function
  
-  protected:
+  private:
+    /// Not implemented
     AliMUONSt12QuadrantSegmentation(const AliMUONSt12QuadrantSegmentation& rhs);
-  
-    // operators
+    /// Not implemented
     AliMUONSt12QuadrantSegmentation& operator=(const AliMUONSt12QuadrantSegmentation & rhs);
 
-  private:
     // methods
     void UpdateCurrentPadValues(const AliMpPad& pad);
   
index 38ce7cf..da2d4f6 100644 (file)
@@ -33,11 +33,12 @@ class AliMUONSt1GeometryBuilder : public AliMUONVGeometryBuilder
   protected:
     
   private:
+    /// Not implemented
     AliMUONSt1GeometryBuilder(const AliMUONSt1GeometryBuilder& rhs);
-
-    // operators  
+    /// Not implemented
     AliMUONSt1GeometryBuilder& operator = (const AliMUONSt1GeometryBuilder& rhs);
-     AliMUON*  fMUON; ///< the MUON detector class 
+
+    AliMUON*  fMUON; ///< the MUON detector class 
         
   ClassDef(AliMUONSt1GeometryBuilder,1) //MUON Station1 coarse geometry construction class 
 };
index cfd8993..5586aec 100644 (file)
@@ -34,7 +34,7 @@
   typedef map<Int_t , AliMUONSt1SpecialMotif> SpecialMap;
 #endif
 
-//typedef Float_t GReal_t; // for AliGeant3
+// typedef Float_t GReal_t; // for AliGeant3
 typedef Double_t GReal_t;  // for VirtualMC
 
 class AliMUON;
@@ -59,8 +59,11 @@ class AliMUONSt1GeometryBuilderV2 : public AliMUONVGeometryBuilder
   protected:
  
   private:
+    /// Not implemented
     AliMUONSt1GeometryBuilderV2(const AliMUONSt1GeometryBuilderV2& rMUON);
+    /// Not implemented
     AliMUONSt1GeometryBuilderV2& operator = (const AliMUONSt1GeometryBuilderV2& rhs);    
+
     // Constants
     //
     static const GReal_t fgkHzPadPlane;    ///< Pad plane
index bf15341..8cc2496 100644 (file)
@@ -41,7 +41,7 @@ AliMUONSt2GeometryBuilder::AliMUONSt2GeometryBuilder(AliMUON* muon)
  : AliMUONVGeometryBuilder(2, 2), 
    fMUON(muon)
 {
-// Standard constructor
+/// Standard constructor
 
 }
 
@@ -50,13 +50,14 @@ AliMUONSt2GeometryBuilder::AliMUONSt2GeometryBuilder()
  : AliMUONVGeometryBuilder(),
    fMUON(0)
 {
-// Default constructor
+/// Default constructor
 }
 
 
 //______________________________________________________________________________
-AliMUONSt2GeometryBuilder::~AliMUONSt2GeometryBuilder() {
-//
+AliMUONSt2GeometryBuilder::~AliMUONSt2GeometryBuilder() 
+{
+/// Destructor
 }
 
 //
@@ -66,7 +67,7 @@ AliMUONSt2GeometryBuilder::~AliMUONSt2GeometryBuilder() {
 //______________________________________________________________________________
 void AliMUONSt2GeometryBuilder::CreateGeometry() 
 {
-// From AliMUONv1::CreateGeometry()
+/// From AliMUONv1::CreateGeometry()
 
 //
 //********************************************************************
@@ -190,8 +191,7 @@ void AliMUONSt2GeometryBuilder::CreateGeometry()
 //______________________________________________________________________________
 void AliMUONSt2GeometryBuilder::SetTransformations()
 {
-// Defines the transformations for the station2 chambers.
-// ---
+/// Defines the transformations for the station2 chambers.
 
   // Define chamber volumes as virtual
   SetVolume(2, "SC03", true);
@@ -207,8 +207,7 @@ void AliMUONSt2GeometryBuilder::SetTransformations()
 //______________________________________________________________________________
 void AliMUONSt2GeometryBuilder::SetSensitiveVolumes()
 {
-// Defines the sensitive volumes for station2 chambers.
-// ---
+/// Defines the sensitive volumes for station2 chambers.
 
   GetGeometry(2)->SetSensitiveVolume("S03G");
   GetGeometry(3)->SetSensitiveVolume("S04G");
index 0557cfb..459a443 100644 (file)
@@ -30,14 +30,13 @@ class AliMUONSt2GeometryBuilder : public AliMUONVGeometryBuilder
     virtual void SetTransformations();
     virtual void SetSensitiveVolumes();
     
-  protected:
-    
   private:
+    /// Not implemented
     AliMUONSt2GeometryBuilder(const AliMUONSt2GeometryBuilder& rhs);
-
-    // operators  
+    /// Not implemented
     AliMUONSt2GeometryBuilder& operator = (const AliMUONSt2GeometryBuilder& rhs);
-     AliMUON*  fMUON; ///< the MUON detector class 
+
+    AliMUON*  fMUON; ///< the MUON detector class 
         
   ClassDef(AliMUONSt2GeometryBuilder,1) // MUON Station2 coarse geometry construction class
 };
index 1009400..5ef841a 100644 (file)
@@ -49,7 +49,7 @@ AliMUONSt2GeometryBuilderV2::AliMUONSt2GeometryBuilderV2(AliMUON* muon)
  : AliMUONVGeometryBuilder(2, 2),
    fMUON(muon)
 {
-// Standard constructor
+/// Standard constructor
 
 }
 
@@ -58,12 +58,13 @@ AliMUONSt2GeometryBuilderV2::AliMUONSt2GeometryBuilderV2()
  : AliMUONVGeometryBuilder(),
    fMUON(0)
 {
-// Default constructor
+/// Default constructor
 }
 
 //______________________________________________________________________________
-AliMUONSt2GeometryBuilderV2::~AliMUONSt2GeometryBuilderV2() {
-//
+AliMUONSt2GeometryBuilderV2::~AliMUONSt2GeometryBuilderV2() 
+{
+/// Destructor
 }
 
 //
@@ -73,6 +74,7 @@ AliMUONSt2GeometryBuilderV2::~AliMUONSt2GeometryBuilderV2() {
 //______________________________________________________________________________
 void AliMUONSt2GeometryBuilderV2::CreateGeometry()
 {
+/// Geometry construction
 
 //
 //********************************************************************
@@ -761,8 +763,7 @@ void AliMUONSt2GeometryBuilderV2::CreateGeometry()
 //______________________________________________________________________________
 void AliMUONSt2GeometryBuilderV2::SetTransformations()
 {
-// Defines the transformations for the station2 chambers.
-// ---
+/// Defines the transformations for the station2 chambers.
 
   if (gAlice->GetModule("SHIL")) {
     SetMotherVolume(2, "YOUT1");
@@ -783,8 +784,7 @@ void AliMUONSt2GeometryBuilderV2::SetTransformations()
 //______________________________________________________________________________
 void AliMUONSt2GeometryBuilderV2::SetSensitiveVolumes()
 {
-// Defines the sensitive volumes for station2 chambers.
-// ---
+/// Defines the sensitive volumes for station2 chambers.
 
   GetGeometry(2)->SetSensitiveVolume("C3G0");
   GetGeometry(2)->SetSensitiveVolume("C3G1");
index b3eeebd..a822b40 100644 (file)
@@ -33,11 +33,12 @@ class AliMUONSt2GeometryBuilderV2 : public AliMUONVGeometryBuilder
   protected:
     
   private:
+    /// Not implemented
     AliMUONSt2GeometryBuilderV2(const AliMUONSt2GeometryBuilderV2& rhs);
-
-    // operators  
+    /// Not implemented
     AliMUONSt2GeometryBuilderV2& operator = (const AliMUONSt2GeometryBuilderV2& rhs);
-     AliMUON*  fMUON; ///< the MUON detector class 
+
+    AliMUON*  fMUON; ///< the MUON detector class 
         
   ClassDef(AliMUONSt2GeometryBuilderV2,1) //MUON Station2 detailed geometry construction class
 };
index c6449bf..157f235 100644 (file)
@@ -123,7 +123,9 @@ class AliMUONSt345SlatSegmentation : public AliMUONVGeometryDESegmentation
   void Print(Option_t* opt = "") const;
 
  protected:
+  /// Not implemented
   AliMUONSt345SlatSegmentation(const AliMUONSt345SlatSegmentation& right);
+  /// Not implemented
   AliMUONSt345SlatSegmentation&  operator = (const AliMUONSt345SlatSegmentation& right);
      
  private:
index 810206e..6bc1142 100644 (file)
@@ -34,7 +34,9 @@ class AliMUONStringIntMap : public TObject
     void Print(const TString& key, ofstream& out) const;
     
   protected:
+    /// Not implemented
     AliMUONStringIntMap(const AliMUONStringIntMap& rhs);
+    /// Not implemented
     AliMUONStringIntMap& operator = (const AliMUONStringIntMap& rhs);
  
   private:
index 41a7b18..5c0db1b 100644 (file)
@@ -746,12 +746,12 @@ Double_t AliMUONTrackExtrap::TotalMomentumEnergyLoss(Double_t pTotal, Double_t p
 }
 
   //__________________________________________________________________________
-Double_t AliMUONTrackExtrap::ApproximateBetheBloch(Double_t beta2) {
-  //------------------------------------------------------------------
-  // This is an approximation of the Bethe-Bloch formula with 
-  // the density effect taken into account at beta*gamma > 3.5
-  // (the approximation is reasonable only for solid materials) 
-  //------------------------------------------------------------------
+Double_t AliMUONTrackExtrap::ApproximateBetheBloch(Double_t beta2) 
+{
+/// This is an approximation of the Bethe-Bloch formula with 
+/// the density effect taken into account at beta*gamma > 3.5
+/// (the approximation is reasonable only for solid materials) 
+
   if (beta2/(1-beta2)>3.5*3.5)
      return 0.153e-3/beta2*(log(3.5*5940)+0.5*log(beta2/(1-beta2)) - beta2);
 
@@ -761,6 +761,7 @@ Double_t AliMUONTrackExtrap::ApproximateBetheBloch(Double_t beta2) {
  //__________________________________________________________________________
 void AliMUONTrackExtrap::ExtrapOneStepHelix(Double_t charge, Double_t step, Double_t *vect, Double_t *vout)
 {
+/// <pre>
 ///    ******************************************************************
 ///    *                                                                *
 ///    *  Performs the tracking of one step in a magnetic field         *
@@ -780,6 +781,7 @@ void AliMUONTrackExtrap::ExtrapOneStepHelix(Double_t charge, Double_t step, Doub
 ///    *       modified  v.perevoztchikov
 ///    *                                                                *
 ///    ******************************************************************
+/// </pre>
 
 // modif: everything in double precision
 
@@ -878,6 +880,7 @@ void AliMUONTrackExtrap::ExtrapOneStepHelix(Double_t charge, Double_t step, Doub
  //__________________________________________________________________________
 void AliMUONTrackExtrap::ExtrapOneStepHelix3(Double_t field, Double_t step, Double_t *vect, Double_t *vout)
 {
+/// <pre>
 ///    ******************************************************************
 ///    *                                                                *
 ///    *       Tracking routine in a constant field oriented            *
@@ -890,6 +893,7 @@ void AliMUONTrackExtrap::ExtrapOneStepHelix3(Double_t field, Double_t step, Doub
 ///    *       Rewritten  V.Perevoztchikov
 ///    *                                                                *
 ///    ******************************************************************
+/// </pre>
 
     Double_t hxp[3];
     Double_t h4, hp, rho, tet;
@@ -954,6 +958,7 @@ void AliMUONTrackExtrap::ExtrapOneStepHelix3(Double_t field, Double_t step, Doub
  //__________________________________________________________________________
 void AliMUONTrackExtrap::ExtrapOneStepRungekutta(Double_t charge, Double_t step, Double_t* vect, Double_t* vout)
 {
+/// <pre>
 ///    ******************************************************************
 ///    *                                                                *
 ///    *  Runge-Kutta method for tracking a particle through a magnetic *
@@ -975,6 +980,7 @@ void AliMUONTrackExtrap::ExtrapOneStepRungekutta(Double_t charge, Double_t step,
 ///    *                                                                *
 ///    *                                                                *
 ///    ******************************************************************
+/// </pre>
 
     Double_t h2, h4, f[4];
     Double_t xyzt[3], a, b, c, ph,ph2;
index 7faf95d..0aa630d 100644 (file)
@@ -55,7 +55,10 @@ class AliMUONTrackExtrap : public TObject
   static const Double_t fgkRungeKuttaMaxResidue;//!< Maximal distance (in Z) to destination to stop the track extrapolation (used in Runge-Kutta)
   
   // Functions
+
+  /// Not implemented
   AliMUONTrackExtrap(const AliMUONTrackExtrap& trackExtrap);
+  /// Not implemented
   AliMUONTrackExtrap& operator=(const AliMUONTrackExtrap& trackExtrap);
 
   static void ExtrapToZHelix(AliMUONTrackParam *trackParam, Double_t Z);
index c275c96..2c48aae 100644 (file)
@@ -35,20 +35,20 @@ class AliMUONTrackK : public AliMUONTrack {
   AliMUONTrackK(AliMUONObjectPair *segment); // Constructor from a segment
 
   // Pointer to hits on track
-  TObjArray* GetTrackHits(void) const {return fTrackHits;} // ptr. to hits on track
-  Int_t GetNTrackHits(void) const {return fNmbTrackHits;} // hits on track
-  Double_t GetTrackQuality(void) const {return fChi2;} // track quality
-  TMatrixD* GetTrackParameters(void) const {return fTrackPar;} // track parameters
-  Double_t GetZ(void) const {return fPosition;} // Z-coordinate of track 
-  TMatrixD* GetCovariance(void) const {return fCovariance;} // covariance matrix
-  Int_t GetTrackDir(void) const {return fTrackDir;} // get track propagation direction
-  void SetTrackDir(Int_t iDir) {fTrackDir = iDir;} // set track propagation direction  
-  Bool_t GetBPFlag(void) const {return fBPFlag;} // get backpropagation flag
-  void SetBPFlag(Bool_t BPFlag) {fBPFlag = BPFlag;} // set backpropagation flag
-  Int_t GetRecover(void) const {return fRecover;} // return recover flag 
-  void SetRecover(Int_t iRecover) {fRecover = iRecover;} // set recover flag
-  AliMUONObjectPair* GetStartSegment(void) const {return fStartSegment;} // return seed segment
-  Bool_t KalmanFilter(Int_t ichamBeg, Int_t ichamEnd, Bool_t Back, Double_t zDipole1, Double_t zDipole2); // Kalman filter
+  TObjArray* GetTrackHits(void) const {return fTrackHits;} ///< ptr. to hits on track
+  Int_t GetNTrackHits(void) const {return fNmbTrackHits;} ///< hits on track
+  Double_t GetTrackQuality(void) const {return fChi2;} ///< track quality
+  TMatrixD* GetTrackParameters(void) const {return fTrackPar;} ///< track parameters
+  Double_t GetZ(void) const {return fPosition;} ///< Z-coordinate of track 
+  TMatrixD* GetCovariance(void) const {return fCovariance;} ///< covariance matrix
+  Int_t GetTrackDir(void) const {return fTrackDir;} ///< get track propagation direction
+  void SetTrackDir(Int_t iDir) {fTrackDir = iDir;} ///< set track propagation direction  
+  Bool_t GetBPFlag(void) const {return fBPFlag;} ///< get backpropagation flag
+  void SetBPFlag(Bool_t BPFlag) {fBPFlag = BPFlag;} ///< set backpropagation flag
+  Int_t GetRecover(void) const {return fRecover;} ///< return recover flag 
+  void SetRecover(Int_t iRecover) {fRecover = iRecover;} ///< set recover flag
+  AliMUONObjectPair* GetStartSegment(void) const {return fStartSegment;} ///< return seed segment
+  Bool_t KalmanFilter(Int_t ichamBeg, Int_t ichamEnd, Bool_t Back, Double_t zDipole1, Double_t zDipole2); ///< Kalman filter
   void StartBack(void); // start backpropagator
   void SetTrackQuality(Int_t iChi2); // compute track quality or Chi2
   Bool_t KeepTrack(AliMUONTrackK* track0) const; // keep or discard track 
@@ -56,15 +56,15 @@ class AliMUONTrackK : public AliMUONTrack {
   Bool_t Smooth(void); // apply smoother
   Double_t GetChi2PerPoint(Int_t iPoint) const; // return Chi2 at point
   void Print(FILE *lun) const; // print track information
-  void Print(const char* /*opt*/) const {return;} // print track information
+  void Print(const char* /*opt*/) const {return;} ///< print track information
   AliMUONHitForRec* GetHitLastOk(void); // get hit before the skipped one
   Int_t GetStation0(void); // return seed station number
-  Int_t DebugLevel(void) const {return fgDebug;} // return debug level
-  void SetDebugLevel(Int_t iDebug) {fgDebug = iDebug;} // set debug level
+  Int_t DebugLevel(void) const {return fgDebug;} ///< return debug level
+  void SetDebugLevel(Int_t iDebug) {fgDebug = iDebug;} ///< set debug level
   void FillMUONTrack(void); // set track parameters as for AliMUONTrack
   void SetTrackParam(AliMUONTrackParam *trackParam, TMatrixD *par, Double_t z); // fill AliMUONTrackParam object
 
-  // What is necessary for sorting TClonesArray's
+  /// What is necessary for sorting TClonesArray's
   Bool_t IsSortable() const { return kTRUE; }
   Int_t Compare(const TObject* trackK) const; // "Compare" function for sorting
 
@@ -115,7 +115,7 @@ class AliMUONTrackK : public AliMUONTrack {
 
   // Functions
 
-  AliMUONTrackK (const AliMUONTrackK& source); // copy constructor
+  AliMUONTrackK (const AliMUONTrackK& source); ///< Not implemented copy constructor
   void EvalCovariance(Double_t dZ);
   void ParPropagation(Double_t zEnd);
   void WeightPropagation(Double_t zEnd, Bool_t smooth);
index b933308..e3fbb50 100644 (file)
@@ -935,7 +935,7 @@ Double_t MultipleScatteringAngle2(AliMUONTrackParam *param)
 }
 
   //__________________________________________________________________________
-void AliMUONTrackReconstructor::FillMUONTrack()
+void AliMUONTrackReconstructor::FillMUONTrack(void)
 {
   /// Fill fHitForRecAtHit of AliMUONTrack's
   AliMUONTrack *track;
index df6f017..1f5f381 100644 (file)
@@ -37,11 +37,13 @@ class AliMUONTrackReconstructor : public AliMUONVTrackReconstructor {
   
   // Parameters for reconstruction
   static const Double_t fgkMaxNormChi2; ///< maximum Chi2 per degree of freedom for reconstruction
-  static const Bool_t fgkTrackAllTracks; /// kTRUE to track all the possible candidates; kFALSE to track only the best ones
+  static const Bool_t fgkTrackAllTracks; ///< kTRUE to track all the possible candidates; kFALSE to track only the best ones
 
   // Functions
-  AliMUONTrackReconstructor (const AliMUONTrackReconstructor& rhs); ///< copy constructor
-  AliMUONTrackReconstructor& operator=(const AliMUONTrackReconstructor& rhs); ///< assignment operator
+  /// Not implemented copy constructor
+  AliMUONTrackReconstructor (const AliMUONTrackReconstructor& rhs); 
+  /// Not implemented copy assignment operator
+  AliMUONTrackReconstructor& operator=(const AliMUONTrackReconstructor& rhs);
   
   void RemoveIdenticalTracks(void);
   void FollowTrackInStation(AliMUONTrack* trackCandidate, Int_t nextStation);
index 9842955..a4b28d6 100644 (file)
@@ -24,25 +24,34 @@ class AliMUONTracker : public AliTracker
     
   virtual Int_t Clusters2Tracks(AliESD* /*esd*/); 
   
+  /// Dummy implementation
   virtual Int_t PropagateBack(AliESD* /*event*/) {return 0;}
+  /// Dummy implementation
   virtual Int_t RefitInward(AliESD* /*event*/) {return 0;}
+  /// Dummy implementation
   virtual Int_t LoadClusters(TTree* /*tree*/) {return 0;}
+  /// Dummy implementation
   virtual void  UnloadClusters() {return;}
+  /// Dummy implementation
   virtual AliCluster *GetCluster(Int_t /*index*/) const {return 0;}
 
+  /// Set trigger circuit
   void SetTriggerCircuit(TClonesArray* circuit) {fTriggerCircuit = circuit;}
+  /// Set pointer to data container
   void SetMUONData(AliMUONData* data) {fMUONData = data;}
+  /// Set option
   void SetOption(Option_t* opt);
 
 private:
-
+  /// Not implemented
+  AliMUONTracker(const AliMUONTracker& rhs);
+  /// Not implemented
+  AliMUONTracker& operator=(const AliMUONTracker& rhs);
+    
   TClonesArray* fTriggerCircuit;                //!< trigger circuit
   AliMUONData*  fMUONData;                      //!< pointer to container
   AliMUONVTrackReconstructor* fTrackReco;       //!< track reconstructor
 
-  AliMUONTracker(const AliMUONTracker& rhs);
-  AliMUONTracker& operator=(const AliMUONTracker& rhs);
-    
   ClassDef(AliMUONTracker,0)  //tracker base class for MUON
 };
 #endif
index f49eb0a..aacb14d 100644 (file)
@@ -29,7 +29,9 @@ public:
   virtual void Initialize(Int_t run, UInt_t startTime, UInt_t endTime);
 
 private:
+  /// Not implemented
   AliMUONTrackerPreprocessor(const AliMUONTrackerPreprocessor& rhs);
+  /// Not implemented
   AliMUONTrackerPreprocessor& operator=(const AliMUONTrackerPreprocessor& rhs);
   
 private:
index 03ead8d..150f3c9 100644 (file)
 /// May 06, taken info from Global Trigger branch (Ch.F)
 
 //----------------------------------------------------------------------
+/// \cond CLASSIMP
 ClassImp(AliMUONTrigger)
+/// \endcond
 
 //----------------------------------------------------------------------
 AliMUONTrigger::AliMUONTrigger()
   : AliTriggerDetector() 
 {
+/// Default constructor
+
    SetName("MUON");
    CreateInputs();
 }
 
 //----------------------------------------------------------------------
+AliMUONTrigger::~AliMUONTrigger()
+{
+/// Destructor
+}
+
+//----------------------------------------------------------------------
 void AliMUONTrigger::CreateInputs()
 {
-   // inputs 
+   /// inputs 
    
    // Do not create inputs again!!
    if( fInputs.GetEntriesFast() > 0 ) return;
@@ -70,7 +80,8 @@ void AliMUONTrigger::CreateInputs()
 //----------------------------------------------------------------------
 void AliMUONTrigger::Trigger()
 {
-  // sets the trigger inputs
+  /// sets the trigger inputs
+
   AliMUONGlobalTrigger* globalTrigger;
   TClonesArray* globalTriggerArray;
 
index f33fe63..ffa0637 100644 (file)
@@ -16,7 +16,7 @@ class AliMUONTrigger : public AliTriggerDetector
 {
  public:
    AliMUONTrigger();  // constructor
-  virtual ~AliMUONTrigger(){}  // destructor
+  virtual ~AliMUONTrigger();  // destructor
    virtual void    CreateInputs();
    virtual void    Trigger();
 
index 3f2b36c..526583d 100644 (file)
 
 /* $Id$ */
 
-//*-- Author: Rachid Guernane (LPCCFd)
-//    TRIGGER BOARD SUPER CLASS IMPLEMENTATION
-//    CAN BE A LOCAL, REGIONAL, OR GLOBAL BOARD
-//    REGIONAL BOARD IS PER CONVENTION
-//    ALWAYS IN THE SLOT 0
+///  \class AliMUONTriggerBoard
+///  TRIGGER BOARD SUPER CLASS IMPLEMENTATION
+///  CAN BE A LOCAL, REGIONAL, OR GLOBAL BOARD
+///  REGIONAL BOARD IS PER CONVENTION
+///  ALWAYS IN THE SLOT 0
+/// \todo Change comments in capital letters to normal text
+///
+///  \author Rachid Guernane (LPCCFd)
 
 #include "AliMUONTriggerBoard.h"
 #include "AliLog.h"
 
+/// \cond CLASSIMP
+ClassImp(AliMUONTriggerBoard)
+/// \endcond
+
 //___________________________________________
 AliMUONTriggerBoard::AliMUONTriggerBoard()
     : TNamed(),
       fSlot(0),
       fResponse(0)
 {
-// Default Ctor
+/// Default Ctor
 
 }
 
@@ -40,33 +47,16 @@ AliMUONTriggerBoard::AliMUONTriggerBoard(const char *Name, Int_t islot)
       fSlot(islot),
       fResponse(0)
 {
-// Standard Ctor
+/// Standard Ctor
 
 }
 
 //___________________________________________
-AliMUONTriggerBoard::AliMUONTriggerBoard(const AliMUONTriggerBoard &board)
-    : TNamed(board),
-      fSlot(board.fSlot),
-      fResponse(board.fResponse)
+AliMUONTriggerBoard::~AliMUONTriggerBoard()
 {
-// Dummy Copy Ctor
-//   board.Copy(*this);
-}
+/// Destructor
+}  
 
-//___________________________________________
-AliMUONTriggerBoard& AliMUONTriggerBoard::operator=(const AliMUONTriggerBoard&)
-{
-   AliFatal("Assignment operator not implemented");
-   return *this;
-}
 
-//___________________________________________
-void AliMUONTriggerBoard::Copy(TObject&) const
-{
-   Fatal("Copy","Not implemented!\n");
-}
-
-ClassImp(AliMUONTriggerBoard)
 
 
index 1e8a6ac..b9db31d 100644 (file)
@@ -9,7 +9,7 @@
 /// \class AliMUONTriggerBoard
 /// \brief TRIGGER BOARD BASE CLASS
 ///
-/// \author Rachid Guernane (LPCCFd)
+//  Author Rachid Guernane (LPCCFd)
 
 #include <TNamed.h>
 
@@ -17,36 +17,37 @@ class AliMUONTriggerBoard : public TNamed
 {
    public:
       AliMUONTriggerBoard();
-      AliMUONTriggerBoard(const AliMUONTriggerBoard &entry);
       AliMUONTriggerBoard(const char *name, Int_t islot);
-      virtual ~AliMUONTriggerBoard() {}
-
-      AliMUONTriggerBoard& operator=(const AliMUONTriggerBoard &rhs);
+      virtual ~AliMUONTriggerBoard();
 
+      /// \todo add comment 
       virtual void Response() = 0;
 
+      /// \todo add comment 
       virtual void Reset() = 0;
 
+      /// \todo add comment 
       virtual void Scan(Option_t *option) const = 0;
 
+      /// \todo add comment 
       virtual void Resp(Option_t *option) const = 0;
 
+      /// Return response
       virtual UShort_t GetResponse() const {return fResponse;}
 
+      /// \todo add comment 
       virtual void Mask(Int_t index, UShort_t mask) = 0;
       
    protected:
+      /// Not implemented
+      AliMUONTriggerBoard(const AliMUONTriggerBoard &entry);
+      /// Not implemented
+      AliMUONTriggerBoard& operator=(const AliMUONTriggerBoard &rhs);
 
       Int_t fSlot;                ///< SLOT NUMBER IN CRATE
 
       UShort_t fResponse;         ///< RESPONSE
 
-      void Copy(TObject&) const;
-
-   private:
-
-
-
    ClassDef(AliMUONTriggerBoard,1)
 };
 #endif
index 41b2846..c379fd2 100644 (file)
@@ -88,6 +88,7 @@ AliMUONTriggerChamberEff::AliMUONTriggerChamberEff(Int_t firstRun, Int_t lastRun
   fDebugLevel(0),
   fGaliceDir(galiceRunDir)
 {
+/// Standard constructor
     ResetArrays();
     delete gAlice;
 }
index d556b9a..41bdae5 100644 (file)
@@ -25,10 +25,13 @@ public:
     AliMUONTriggerChamberEff(Int_t firstRun, Int_t lastRun, const char* galiceRunDir, Int_t firstEvent=0, Int_t lastEvent=-1);
     virtual ~AliMUONTriggerChamberEff();
 
+    /// Set Reproduce trigger response
     void SetReproduceTrigResponse(Bool_t reproduceTrigRes=kFALSE)
     {fReproduceTrigResponse=reproduceTrigRes;}
+    /// Set Print informations on event
     void SetPrintInfo(Bool_t printInfo=kFALSE)
     {fPrintInfo=printInfo;}
+    /// Set Debug level
     void SetDebugLevel(Int_t debugLevel)
     {fDebugLevel=debugLevel;}
 
@@ -48,7 +51,9 @@ protected:
     void WriteEfficiencyMap(const char* outputDir);
     
 private:
+    /// Not implemented
     AliMUONTriggerChamberEff(const AliMUONTriggerChamberEff& other);
+    /// Not implemented
     AliMUONTriggerChamberEff& operator=(const AliMUONTriggerChamberEff& other);
     
     void SetGaliceFile(const char* galiceFile);
index a8a38f6..5f8c643 100644 (file)
@@ -49,6 +49,7 @@ public:
   //  void dump(const char* what, const Float_t* array, Int_t size);
   //  void dump(const char* what, const Int_t* array, Int_t size);
   
+  /// Set pointer to transformations
   void  SetTransformer(const AliMUONGeometryTransformer* transformer) {fTransformer = transformer;}
 
 private:
index fe2ddca..0b2231b 100644 (file)
 
 /* $Id$ */
 
-//*-- Author: Rachid Guernane (LPCCFd)
-//    COLLECTION OF TRIGGER BOARDS
-//    ONE REGIONAL
-//    SIXTEEN LOCAL
-//    SLOT 0 HOLDS THE REGIONAL BOARD
+/// \class AliMUONTriggerCrate
+///  Collection of trigger boards
+///  - one regional
+///  - sixteen local
+///  slot 0 holds the regional board
+/// \author Rachid Guernane (LPCCFd)
 
 #include <TObjArray.h>
 
@@ -35,12 +36,14 @@ AliMUONTriggerCrate::AliMUONTriggerCrate()
       fBoards(0x0),
       fSourceFileName(0)    
 {
-    // Def Ctor
+/// Default constructor
 }
 
 //___________________________________________
 AliMUONTriggerCrate::~AliMUONTriggerCrate()
 {
+/// Destructor
+
   delete fBoards;
 }
 
@@ -52,39 +55,14 @@ AliMUONTriggerCrate::AliMUONTriggerCrate(const char *name, Int_t n) :
     fBoards(new TObjArray(fNslots)),
     fSourceFileName(0)
 {
+/// Standard constructor
 }
 
 //___________________________________________
 void AliMUONTriggerCrate::AddBoard(AliMUONTriggerBoard *board, Int_t i)
 {
-  // ADD BOARD IN CRATE CONTAINER
+/// Add board in crate container
    fBoards->AddAt(board,i);
    fNboards++;
 }
 
-//___________________________________________
-AliMUONTriggerCrate::AliMUONTriggerCrate(const AliMUONTriggerCrate &crate) 
-    : TNamed(crate),
-      fNslots(crate.fNslots),
-      fNboards(crate.fNboards),
-      fBoards(crate.fBoards),
-      fSourceFileName(crate.fSourceFileName)
-{
-    
-// Dummy Copy Ctor
-//   crate.Copy(*this);
-}
-
-//___________________________________________
-AliMUONTriggerCrate& AliMUONTriggerCrate::operator=(const AliMUONTriggerCrate &rhs)
-{
-// Assignment optor
-   rhs.Copy(*this);
-   return (*this);
-}
-
-//___________________________________________
-void AliMUONTriggerCrate::Copy(TObject&) const
-{
-   Fatal("Copy","Not implemented!\n");
-}
index 23eb52b..3161947 100644 (file)
@@ -9,7 +9,7 @@
 /// \class AliMUONTriggerCrate
 /// \brief Trigger Crate
 ///
-/// \author Rachid Guernane (LPCCFd)
+//  Author Rachid Guernane (LPCCFd)
 
 #include <TNamed.h>
 
@@ -19,32 +19,31 @@ class TObjArray;
 class AliMUONTriggerCrate : public TNamed
 {
    public:
-
       AliMUONTriggerCrate();
-      AliMUONTriggerCrate(const AliMUONTriggerCrate &entry);
       AliMUONTriggerCrate(const char *name, Int_t n = 17); // 16 + 1
       virtual ~AliMUONTriggerCrate();
 
-//    CRATE CONFIG FROM ASCII FILE
+      /// Crate config from ascii file
       virtual void SetDataSource(TString SourceFile) {fSourceFileName = SourceFile;}
 
       virtual void AddBoard(AliMUONTriggerBoard *board, Int_t i);
 
+      /// Return pointer to board objects
       virtual TObjArray* Boards() {return fBoards;}
 
-      AliMUONTriggerCrate& operator=(const AliMUONTriggerCrate &rhs);
-
-   protected:
 
-      void Copy(TObject&) const;
 
    private:
+      /// Not implemented
+      AliMUONTriggerCrate(const AliMUONTriggerCrate &entry);
+      /// Not implemented
+      AliMUONTriggerCrate& operator=(const AliMUONTriggerCrate &rhs);
 
-      Int_t     fNslots;          ///< NUMBER OF SLOTS
-      Int_t     fNboards;         ///< NUMBER OF BOARDS
+      Int_t     fNslots;          ///< Number of slots
+      Int_t     fNboards;         ///< Number of boards
 
-      TObjArray *fBoards;         ///< POINTER TO BOARD OBJECTS
-      TString   fSourceFileName;  ///< SOURCE FILE
+      TObjArray *fBoards;         ///< Pointer to board objects
+      TString   fSourceFileName;  ///< Source file
 
    ClassDef(AliMUONTriggerCrate,1)
 };
index 6de3e59..d4bae23 100644 (file)
@@ -128,7 +128,7 @@ AliMUONTriggerCrateStore::Crate(Int_t ddl, Int_t reg) const
 // //____________________________________________________________________
 TString AliMUONTriggerCrateStore::GetCrateName(Int_t ddl, Int_t reg) const
 {
-  // set crate name from DDL & reg number
+  /// set crate name from DDL & reg number
 
   Char_t name[10];
   switch(reg) {
index 2a5664b..3b7a06f 100644 (file)
@@ -45,7 +45,9 @@ public:
  
 
 protected:
+  /// Not implemented
   AliMUONTriggerCrateStore(const AliMUONTriggerCrateStore& rhs);
+  /// Not implemented
   AliMUONTriggerCrateStore& operator = (const AliMUONTriggerCrateStore& rhs);
 
 private:
index 882eaba..c6aed22 100755 (executable)
@@ -45,12 +45,14 @@ private:
     
     static const Int_t fgkNofCells=80; ///< Number of cells
     
+    /// the cells content
     Float_t fCellContent[4][18][2][fgkNofCells][fgkNofCells]; //[trig. chambers][RPCs][cathode][cellsX][cellsY]
 
     Float_t fCellSize[4][18][2]; ///< the size of the cells
     Int_t fCellNumber[4][18][2]; ///< id of the cells
 
     static const Int_t fgkNofBoards=234; ///< Number of boards
+    /// the boards content
     Float_t fBoardContent[4][2][fgkNofBoards]; //[trig. chambers][RPCs][cathode][board]
     
     ClassDef(AliMUONTriggerEfficiencyCells,2) // Trigger efficiency store
index 8714a85..45c3c5f 100644 (file)
@@ -363,7 +363,7 @@ void AliMUONTriggerElectronics::Reset()
 //_______________________________________________________________________
 void AliMUONTriggerElectronics::LoadMasks(AliMUONCalibrationData* calibData)
 {
-  // LOAD MASKS FROM CDB
+  /// LOAD MASKS FROM CDB
   
 
   // SET MASKS
index 2748ae2..ebc018e 100644 (file)
@@ -67,7 +67,9 @@ class AliMUONTriggerElectronics : public TTask
       virtual void Trigger();
 
    private:
+      /// Not implemented
       AliMUONTriggerElectronics(const AliMUONTriggerElectronics& right);
+      /// Not implemented
       AliMUONTriggerElectronics&  operator = (const AliMUONTriggerElectronics& right);
      
    private:
index 7d6f6a2..1d85c75 100644 (file)
@@ -43,7 +43,7 @@ AliMUONTriggerGeometryBuilder::AliMUONTriggerGeometryBuilder(AliMUON* muon)
  : AliMUONVGeometryBuilder(16, 4),
    fMUON(muon)
 {
-// Standard constructor
+/// Standard constructor
 
 }
 
@@ -52,12 +52,13 @@ AliMUONTriggerGeometryBuilder::AliMUONTriggerGeometryBuilder()
  : AliMUONVGeometryBuilder(),
    fMUON(0)
 {
-// Default constructor
+/// Default constructor
 }
 
 //______________________________________________________________________________
-AliMUONTriggerGeometryBuilder::~AliMUONTriggerGeometryBuilder() {
-//
+AliMUONTriggerGeometryBuilder::~AliMUONTriggerGeometryBuilder() 
+{
+/// Destructor
 }
 
 //
@@ -67,7 +68,7 @@ AliMUONTriggerGeometryBuilder::~AliMUONTriggerGeometryBuilder() {
 //______________________________________________________________________________
 void AliMUONTriggerGeometryBuilder::CreateGeometry()
 {
-// From AliMUONv1::CreateGeometry()
+/// From AliMUONv1::CreateGeometry()
 
     /* 
        zpos1 and zpos2 are the middle of the first and second
@@ -315,8 +316,7 @@ void AliMUONTriggerGeometryBuilder::CreateGeometry()
 //______________________________________________________________________________
 void AliMUONTriggerGeometryBuilder::SetTransformations() 
 {
-// Defines the transformations for the trigger chambers.
-// ---
+/// Defines the transformations for the trigger chambers.
 
     if (gAlice->GetModule("SHIL")) {
       SetMotherVolume(16, "YOUT2");
@@ -346,8 +346,7 @@ void AliMUONTriggerGeometryBuilder::SetTransformations()
 //______________________________________________________________________________
 void AliMUONTriggerGeometryBuilder::SetSensitiveVolumes()
 {
-// Defines the sensitive volumes for trigger station chambers.
-// ---
+/// Defines the sensitive volumes for trigger station chambers.
 
   GetGeometry(16)->SetSensitiveVolume("S11G");
   GetGeometry(17)->SetSensitiveVolume("S12G");
index 2189409..9301776 100644 (file)
@@ -28,16 +28,19 @@ class AliMUONTriggerGeometryBuilder : public AliMUONVGeometryBuilder
     virtual void CreateGeometry();
     virtual void SetTransformations();
     virtual void SetSensitiveVolumes();
+    
+    /// Do not apply global transformation (geometry is defined in the new ALICE reference frame)
     virtual bool ApplyGlobalTransformation() { return false; }
     
   protected:  
     
   private:
+    /// Not implemented
     AliMUONTriggerGeometryBuilder(const AliMUONTriggerGeometryBuilder& rhs);
-
-    // operators  
+    /// Not implemented
     AliMUONTriggerGeometryBuilder& operator = (const AliMUONTriggerGeometryBuilder& rhs);
-     AliMUON*  fMUON; ///< the MUON detector class 
+
+    AliMUON*  fMUON; ///< the MUON detector class 
         
   ClassDef(AliMUONTriggerGeometryBuilder,1) // MUON Trigger stations geometry construction class
 };
index 82c8a38..de5bd58 100644 (file)
@@ -66,8 +66,8 @@ AliMUONTriggerLut::~AliMUONTriggerLut()
   delete fAptUnde;
 }
 
-void
-AliMUONTriggerLut::ReadFromFile(const char* filename)
+//----------------------------------------------------------------------
+void AliMUONTriggerLut::ReadFromFile(const char* filename)
 {
 /// Return output of LuT for corresponding TH3S  
 
index 415d605..974fefa 100644 (file)
@@ -28,13 +28,12 @@ class AliMUONTriggerLut : public TNamed
   void GetLutOutput(Int_t circuit, Int_t xstrip, Int_t idev, Int_t ystrip, 
                    Int_t lutLpt[2], Int_t lutHpt[2]);
 
- protected:
-  // assignment operator
-  AliMUONTriggerLut& operator=(const AliMUONTriggerLut& AliMUONTriggerLut); 
-               
  private:
-  // copy constructor
+  /// Not implemented copy constructor
   AliMUONTriggerLut (const AliMUONTriggerLut& AliMUONTriggerLut);
+  /// Not implemented assignment operator
+  AliMUONTriggerLut& operator=(const AliMUONTriggerLut& AliMUONTriggerLut); 
+
   Int_t GetMask(Int_t ystrip);
 
 private:
index b2ef34a..a97d7ce 100644 (file)
@@ -370,7 +370,7 @@ void
 AliMUONTriggerSegmentation::GiveTestPoints(Int_t& /*n*/, 
                                              Float_t* /*x*/, Float_t*/*y*/) const
 {
-// Not implemented
+/// Not implemented
 
   AliFatal("Not Implemented");
 }
@@ -451,9 +451,9 @@ void AliMUONTriggerSegmentation::IntegrationLimits(Float_t& x1,
                                                      Float_t& x4) 
 {
 /// \param x1 : hit x(y) position
-/// \param  x2 : x(y) coordinate of the main strip
-/// \param  x3 : current strip real x(y) coordinate  
-/// \param  x4 : dist. between x(y) hit pos. and the closest border of the current strip
+/// \param x2 : x(y) coordinate of the main strip
+/// \param x3 : current strip real x(y) coordinate  
+/// \param x4 : dist. between x(y) hit pos. and the closest border of the current strip
 ///
 /// Note : need to return (only) x4.
   
index ac41236..1b6d64d 100644 (file)
@@ -66,7 +66,7 @@ class AliMUONTriggerSegmentation : public AliMUONVGeometryDESegmentation
                   
   virtual void Init(Int_t) {} ///< Not implemented
   
-  virtual void IntegrationLimits(Float_t& x1, Float_t& x2, Float_t& y1, Float_t& y2);
+  virtual void IntegrationLimits(Float_t& x1, Float_t& x2, Float_t& x3, Float_t& x4);
   
   virtual Int_t ISector();
   virtual Int_t Ix();
@@ -116,12 +116,12 @@ public:
     
     Int_t ModuleColNum(Int_t ixGlo) const;
     
-protected:
-
+private:
+    /// Not implemented
     AliMUONTriggerSegmentation(const AliMUONTriggerSegmentation& rhs);
+    /// Not implemented
     AliMUONTriggerSegmentation& operator=(const AliMUONTriggerSegmentation& rhs);
 
-private:
     Int_t fDetElemId;          ///< det elem Id
     AliMp::PlaneType fPlaneType; ///< plane type
     const AliMpTrigger* fSlat; ///< slat
index 9013e75..7dd8e25 100644 (file)
@@ -23,21 +23,35 @@ class AliMUONTriggerTrack : public TObject
     AliMUONTriggerTrack& operator=(const AliMUONTriggerTrack& AliMUONTriggerTrack); // assignment operator
     AliMUONTriggerTrack(Float_t x11, Float_t y11, Float_t thetax, Float_t thetay, Int_t iloTrg, Long_t theGTPattern); 
     
-    // getter
+    // getters
+    
+    /// Return x position of fired Y strip in MC11
     Float_t GetX11()    const {return fx11;}
+    /// Return y position of fired X strip in MC11
     Float_t GetY11()    const {return fy11;}
+    /// Return track theta angle in X 
     Float_t GetThetax() const {return fthetax;}
+    /// Return track theta angle in Y
     Float_t GetThetay() const {return fthetay;}
+    /// Return local trigger number
     Int_t   GetLoTrgNum() const {return floTrgNum;}    
 
-    // setter
+    // setters
+    
+    /// Set x position of fired Y strip in MC11
     void SetX11(Float_t x)     {fx11 = x;}
+    /// Set y position of fired X strip in MC11
     void SetY11(Float_t y)     {fy11 = y;}
+    /// Set track theta angle in X 
     void SetThetax(Float_t tx) {fthetax = tx;}
+    /// Set track theta angle in Y
     void SetThetay(Float_t ty) {fthetay = ty;}
+    /// Set local trigger number
     void SetLoTrgNum(Int_t loTrgNum) {floTrgNum = loTrgNum;}    
 
+    /// Set Global trigger pattern  (do not work with static statement) 
     void SetGTPattern(UChar_t pat) {fGTPattern = pat;}    
+    /// Return Global trigger pattern  (do not work with static statement) 
     UChar_t GetGTPattern() const {return fGTPattern;}    
     
 protected:
index 4cce53c..21b1d0e 100644 (file)
@@ -27,6 +27,7 @@ public:
   /// Return an empty copy of self.
   virtual AliMUONV2DStore* CloneEmpty() const { return 0x0; }
   
+  /// Return iterator
   virtual AliMUONVDataIterator* Iterator() const { return 0x0; }
   
   /// Return the object stored at (i,j).
index fd72232..7d02a50 100644 (file)
@@ -37,9 +37,10 @@ public:
   /// Retrieve the value for a given (channel,dim) as a float.
   virtual Float_t ValueAsFloat(Int_t i, Int_t j=0) const = 0;
   
-    /// Retrieve the value for a given (channel,dim) as an integer.
+  /// Retrieve the value for a given (channel,dim) as an integer.
   virtual Int_t ValueAsInt(Int_t i, Int_t j=0) const = 0;
 
+  /// Return 1E38 as invalid float value
   static Float_t InvalidFloatValue() { return 1E38; }
   
   ClassDef(AliMUONVCalibParam,0) // 
index b24e0ac..3e127a3 100644 (file)
@@ -35,11 +35,13 @@ ClassImp(AliMUONVClusterFinder)
 //_____________________________________________________________________________
 AliMUONVClusterFinder::AliMUONVClusterFinder() : TObject()
 {
+/// Default constructor
 }
 
 //_____________________________________________________________________________
 AliMUONVClusterFinder::~AliMUONVClusterFinder()
 {
+/// Destructor
 }
 
 //_____________________________________________________________________________
index adae074..d2d3d78 100644 (file)
@@ -27,9 +27,11 @@ public:
   AliMUONVClusterFinder();
   virtual ~AliMUONVClusterFinder();
   
+  /// \todo add comment
   virtual Bool_t Prepare(const AliMpVSegmentation* segmentations[2],
                          TClonesArray* digits[2]) = 0;
   
+  /// \todo add comment
   virtual AliMUONCluster* NextCluster() = 0;
   
   /** Add a pad to the list of pads to be considered for clustering.
index 424816e..217df47 100644 (file)
@@ -22,10 +22,13 @@ public:
   AliMUONVDataIterator();
   virtual ~AliMUONVDataIterator();
   
+  /// \todo add comment
   virtual TObject* Next() = 0;
   
+  /// \todo add comment
   virtual void Reset() = 0; 
   
+  /// \todo add comment
   virtual Bool_t Remove() = 0;
   
   ClassDef(AliMUONVDataIterator,0) // Interface for an iterator on AliMUONData.
index ed9f855..2a2911c 100644 (file)
@@ -101,7 +101,10 @@ class AliMUONVGeometryBuilder : public TObject
     
   private:
     //methods
+    
+    /// Not implemented
     AliMUONVGeometryBuilder(const AliMUONVGeometryBuilder& rhs);
+    /// Not implemented
     AliMUONVGeometryBuilder& operator = (const AliMUONVGeometryBuilder& rhs);
 
     TGeoHMatrix ConvertTransform(const TGeoHMatrix& transform) const;
index 9a4b7b6..205ec0a 100644 (file)
@@ -43,7 +43,9 @@ class AliMUONVGeometryDESegmentation : public AliSegmentation
     virtual const AliMpVSegmentation* GetMpSegmentation() const = 0;                  
 
   protected:
+    /// Not implemented
     AliMUONVGeometryDESegmentation(const AliMUONVGeometryDESegmentation& rhs);
+    /// Not implemented
     AliMUONVGeometryDESegmentation& operator=(
       const AliMUONVGeometryDESegmentation& rhs);
 
index 39d1c1f..a9a7e9c 100644 (file)
@@ -27,13 +27,19 @@ public:
   virtual ~AliMUONVSubprocessor();
   
   virtual void Initialize(Int_t run, UInt_t startTime, UInt_t endTime);
+  
+  /// Process this sub-task
   virtual UInt_t Process(TMap* dcsAliasMap) = 0;
   
 protected:
+  /// Return the pointer to our master
   AliMUONPreprocessor* Master() const { return fMaster; }
   
+  /// Not implemented
   AliMUONVSubprocessor();
+  /// Not implemented
   AliMUONVSubprocessor(const AliMUONVSubprocessor&);
+  /// Not implemented
   AliMUONVSubprocessor& operator=(const AliMUONVSubprocessor&);
   
 private:
index de82ef1..2427cbf 100644 (file)
@@ -313,7 +313,7 @@ void AliMUONVTrackReconstructor::EventReconstructTrigger(void)
   //__________________________________________________________________________
 Bool_t AliMUONVTrackReconstructor::MakeTriggerTracks(void)
 {
-    // To make the trigger tracks from Local Trigger
+  /// To make the trigger tracks from Local Trigger
   AliDebug(1, "Enter MakeTriggerTracks");
   
   TTree* treeR;
index 1afb87e..171da60 100644 (file)
@@ -43,11 +43,12 @@ class AliMUONVTrackReconstructor : public TObject {
   // Functions
   void EventReconstruct(void);
   void EventReconstructTrigger(void);
-  virtual void EventDump(void) = 0;  // dump reconstructed event
+  virtual void EventDump(void) = 0;  ///< dump reconstructed event
   void EventDumpTrigger(void);  // dump reconstructed trigger event
   
           /// Return MUON data
   AliMUONData*  GetMUONData() {return fMUONData;}
+          /// Set MUON data
   void SetMUONData(AliMUONData* data) {fMUONData = data;}
 
           /// Set trigger circuit
@@ -93,11 +94,17 @@ class AliMUONVTrackReconstructor : public TObject {
   void SortHitsForRecWithIncreasingChamber();
   TClonesArray *MakeSegmentsInStation(Int_t station);
 
+               /// \todo add comment
   virtual void AddHitsForRecFromRawClusters() = 0;
+               /// \todo add comment
   virtual void MakeTracks(void) = 0;
+               /// \todo add comment
   virtual void MakeTrackCandidates(void) = 0;
+               /// \todo add comment
   virtual void FollowTracks(void) = 0;
+               /// \todo add comment
   virtual void RemoveDoubleTracks(void) = 0;
+               /// \todo add comment
   virtual void FillMUONTrack(void) = 0;
 
  private:
index 2aa8c94..adaef52 100644 (file)
@@ -45,7 +45,9 @@ class AliMUONv1 : public AliMUON
      {fStepMaxInActiveGas = StepMax; }
 
  protected:
+   /// Not implemented
    AliMUONv1(const AliMUONv1& right);
+   /// Not implemented
    AliMUONv1&  operator = (const AliMUONv1& right);
 
    virtual Int_t  GetGeomModuleId(Int_t volId) const;
index 5d334f1..d8320f7 100755 (executable)
@@ -173,6 +173,8 @@ TVector2 AliMpArea::RightUpCorner() const
 void
 AliMpArea::Print(Option_t*) const
 {
+/// Printing
+
   cout << (*this) << endl;
 }
 
index 4cedb0e..971fb8c 100644 (file)
@@ -41,12 +41,15 @@ class AliMpBusPatch : public  TObject {
     
 
   private:
+    /// Not implemented
     AliMpBusPatch();
+    /// Not implemented
     AliMpBusPatch(const AliMpBusPatch& rhs);
+    /// Not implemented
     AliMpBusPatch& operator=(const AliMpBusPatch& rhs);
 
     // static data members     
-    static const Int_t  fgkOffset; //< Offset for conversion global/local ID  
+    static const Int_t  fgkOffset; ///< Offset for conversion global/local ID  
 
     // data members    
     Int_t        fId;    ///< Identifier (unique)
index 578a41b..f71109e 100755 (executable)
@@ -43,14 +43,15 @@ class AliMpConnection : public TObject
           /// Return the motif type which contains this connection
     AliMpMotifType *GetOwner() const {return fOwner;}
     
-    void SetGassiNum(Int_t n) { fGassiNum = n; }
-    
     AliMpIntPair LocalIndices() const;
     TString  PadName() const;
     
     //
     // modifiers
     //
+
+          /// Set Gassiplex channel number
+    void SetGassiNum(Int_t n) { fGassiNum = n; }
           /// Set the motif type which contains this connection
     void SetOwner(AliMpMotifType *owner) {fOwner=owner;}
 
index 846c890..238ec59 100644 (file)
@@ -46,8 +46,11 @@ class AliMpDDL : public  TObject {
     void   GetBusPerDsp(Int_t* iBusPerDSP) const; 
 
   private:
+    /// Not implemented
     AliMpDDL();
+    /// Not implemented
     AliMpDDL(const AliMpDDL& rhs);
+    /// Not implemented
     AliMpDDL& operator=(const AliMpDDL& rhs);
 
     // data members    
index 7de6a5c..fb5f088 100644 (file)
@@ -54,7 +54,9 @@ class AliMpDDLStore : public  TObject {
 
   private:
     AliMpDDLStore();
+    /// Not implemented
     AliMpDDLStore(const AliMpDDLStore& rhs);
+    /// Not implemented
     AliMpDDLStore& operator=(const AliMpDDLStore& rhs);
 
     // methods
index c146e9d..1a77981 100644 (file)
@@ -41,7 +41,9 @@ class AliMpDEStore : public  TObject {
     
   private:
     AliMpDEStore();
+    /// Not implemented
     AliMpDEStore(const AliMpDEStore& rhs);
+    /// Not implemented
     AliMpDEStore& operator=(const AliMpDEStore& rhs);
 
     // methods
index 6ec2f68..ebe885f 100644 (file)
@@ -376,7 +376,7 @@ void AliMpDEVisu::DrawDE(Bool_t info)
 //__________________________________________________________
 void AliMpDEVisu::DrawManuMotif(Bool_t popup) 
 {
-  //  Draw manu motif in yellow and popup channel motif window
+  ///  Draw manu motif in yellow and popup channel motif window
   
   fEcanvas->GetCanvas()->SetEditable(kTRUE);
   
@@ -699,7 +699,7 @@ AliMpDEVisu::CreatePopupWindow(Int_t w, Int_t h, const char* windowName,
                                AliMpVPainter* painter,
                                const char* option)
 {
-  // Create transient frame
+  /// Create transient frame
   
   TCanvas* c = new TCanvas(windowName,windowName,-200,100,w,h);
 
index b1e0dc7..6bead64 100644 (file)
@@ -73,6 +73,10 @@ private:
                            const char* option);
     
 private:
+    /// Not implemented
+    AliMpDEVisu(const AliMpDEVisu& src);
+    /// Not implemented
+    AliMpDEVisu& operator=(const AliMpDEVisu& src);
 
     const TGWindow*    fkMainWindow; //!< main window
     TGMainFrame*       fMain;        //!< main frame
@@ -101,9 +105,6 @@ private:
 
     enum {kChamberCombo, kDECombo, kPlaneType, kDEName, kManuEntries, kLogMessage, kZoomMode};
 
-    AliMpDEVisu(const AliMpDEVisu& src);
-    AliMpDEVisu& operator=(const AliMpDEVisu& src);
-
     ClassDef(AliMpDEVisu,1)
 };
 #endif
index 14b4a74..fbf9694 100644 (file)
@@ -61,8 +61,11 @@ class AliMpDetElement : public  TObject {
     Int_t  GetManuIdFromSerial(Int_t serialNb) const;
 
   private:
+    /// Not implemented
     AliMpDetElement();
+    /// Not implemented
     AliMpDetElement(const AliMpDetElement& rhs);
+    /// Not implemented
     AliMpDetElement& operator=(const AliMpDetElement& rhs);
 
     // static data members     
@@ -76,8 +79,8 @@ class AliMpDetElement : public  TObject {
     AliMp::PlaneType fPlaneType;  ///< Plane type on cathod0
     //AliMpExMap     fBusPatches; ///< Bus patches connected to this detection element
     AliMpArrayI    fBusPatchIds;  ///< Bus patches connected to this detection element
-    mutable TExMap fManuToSerialNbs; //< Map from manuId to serial #   
-    mutable TExMap fSerialNbToManus; //< Map manu serial # to manuId
+    mutable TExMap fManuToSerialNbs; ///< Map from manuId to serial #   
+    mutable TExMap fSerialNbToManus; ///< Map manu serial # to manuId
      
   ClassDef(AliMpDetElement,1)  // The manager class for definition of detection element types
 };
index d0700f3..5c09525 100755 (executable)
@@ -311,6 +311,8 @@ TString AliMpFiles::ManuToSerialPath(const TString& deName, AliMp::StationType s
 void 
 AliMpFiles::SetTopPath(const TString& topPath)
 { 
+/// Set top file path
+
   GetTop() = topPath; 
 }
 
index 63d237d..a3846c6 100755 (executable)
@@ -58,9 +58,13 @@ class AliMpIntPair : public TObject
   void SetFirst(Int_t ix)  {fFirst=ix; fValidity=true; }
          /// Set second value 
   void SetSecond(Int_t iy) {fSecond=iy; fValidity=true;}
+         /// Set both first and second value
   void Set(Int_t ix, Int_t iy) { fFirst=ix; fSecond=iy; fValidity=true; }
   
+  //
   // TObject functions used for sorting in Root collections
+  //
+         /// Return true as Compare() function is implemented 
   virtual Bool_t  IsSortable() const {return kTRUE;}
   virtual Int_t   Compare(const TObject* obj) const;
 
index 1f4371d..d7e3d8e 100644 (file)
@@ -36,8 +36,11 @@ public:
   TVector2 GetPosition() const { return fPosition; }
 
 private:
+  /// Not implemented
   AliMpIteratorPainter();
+  /// Not implemented
   AliMpIteratorPainter(const AliMpIteratorPainter&);
+  /// Not implemented
   AliMpIteratorPainter& operator=(const AliMpIteratorPainter&);
   
   TObjArray* fPads; //!< pads of the iterator
index a826fb4..25d0e32 100644 (file)
@@ -37,7 +37,9 @@ class AliMpManuGeo : public TObject
   Int_t         GetManuSerial(AliMpIntPair& pair);
 
  private:
+  /// Not implemented
   AliMpManuGeo(const AliMpManuGeo& src);
+  /// Not implemented
   AliMpManuGeo& operator = (const AliMpManuGeo& src) ;
 
 
index f7757d1..9ab47c0 100755 (executable)
@@ -510,6 +510,8 @@ void AliMpMotifType::Print(Option_t *option) const
 Bool_t
 AliMpMotifType::Save() const
 {
+/// Save this motif type
+
   return Save(fID.Data());
 }
 
index a374d3c..cc42c60 100644 (file)
@@ -72,9 +72,9 @@ AliMpPCB::AliMpPCB()
   fNofPads(0),
   fMotifMap(0)
 {
-      //
-      // Default ctor.
-      //
+      ///
+      /// Default ctor.
+      ///
 #ifdef WITH_ROOT
     fMotifPositions.SetOwner(kTRUE);
 #endif
@@ -101,10 +101,10 @@ AliMpPCB::AliMpPCB(AliMpSlatMotifMap* motifMap, const char* id, Double_t padSize
   fNofPads(0),
   fMotifMap(motifMap)
 {
-      //
-      // Normal ctor. Must be fed with the PCB's name (id), the pad dimensions
-      // and the global dimension of the virtual enveloppe of the PCB
-      // (usually 400x400 mm)
+      ///
+      /// Normal ctor. Must be fed with the PCB's name (id), the pad dimensions
+      /// and the global dimension of the virtual enveloppe of the PCB
+      /// (usually 400x400 mm)
 #ifdef WITH_ROOT
     fMotifPositions.SetOwner(kTRUE);
 #endif
@@ -130,8 +130,8 @@ AliMpPCB::AliMpPCB(const AliMpPCB& o)
   fNofPads(0),
   fMotifMap(0x0)
 {
-  //
-  // Copy constructor
+  ///
+  /// Copy constructor
 
 #ifdef WITH_ROOT
     fMotifPositions.SetOwner(kTRUE);
@@ -160,14 +160,14 @@ AliMpPCB::AliMpPCB(const char* id, AliMpMotifSpecial* ms)
   fNofPads(ms->GetMotifType()->GetNofPads()),
   fMotifMap(0x0)
 {
-  //
-  // Very special ctor to be used by trigger stations only (and for a very
-  // specific case).
-  //
-  // Note that in this very case, we only allow one (special) motif per PCB.
-  // This limitation might not be justified, except that it's all we need
-  // so far ;-)
-  //
+  ///
+  /// Very special ctor to be used by trigger stations only (and for a very
+  /// specific case).
+  ///
+  /// Note that in this very case, we only allow one (special) motif per PCB.
+  /// This limitation might not be justified, except that it's all we need
+  /// so far ;-)
+  ///
  
     AliDebug(1,Form("this=%p (ctor special motif)",this));
     
@@ -189,7 +189,7 @@ AliMpPCB::AliMpPCB(const char* id, AliMpMotifSpecial* ms)
 AliMpPCB&
 AliMpPCB::operator=(const AliMpPCB& o)
 {
-  // Assignment operator
+  /// Assignment operator
 
   AliDebug(1,Form("this=%p (assignment op) : begin",this));
   o.Copy(*this);
@@ -200,9 +200,9 @@ AliMpPCB::operator=(const AliMpPCB& o)
 //_____________________________________________________________________________
 AliMpPCB::~AliMpPCB()
 {
-  //
-  // Dtor.
-  //
+  ///
+  /// Dtor.
+  ///
   AliDebug(1,Form("this=%p",this));
 #ifndef WITH_ROOT
   for ( size_t i = 0; i < fMotifPositions.size(); ++i )
@@ -217,10 +217,10 @@ AliMpPCB::~AliMpPCB()
 Double_t
 AliMpPCB::ActiveXmin() const
 {
-  //
-  // Returns the mininum x for which there is a pad in this PCB.
-  // Different from Xmin only for PCB which are not full of pads.
-  //
+  ///
+  /// Returns the mininum x for which there is a pad in this PCB.
+  /// Different from Xmin only for PCB which are not full of pads.
+  ///
   
   return fActiveXmin;
 }
@@ -229,10 +229,10 @@ AliMpPCB::ActiveXmin() const
 Double_t
 AliMpPCB::ActiveXmax() const
 {
-  //
-  // Returns the maximum x for which there is a pad in this PCB.
-  // Different from Xmax only for PCB which are not full of pads.
-  //  
+  ///
+  /// Returns the maximum x for which there is a pad in this PCB.
+  /// Different from Xmax only for PCB which are not full of pads.
+  ///  
   
   return fActiveXmax;
 }
@@ -241,15 +241,15 @@ AliMpPCB::ActiveXmax() const
 void
 AliMpPCB::Add(AliMpMotifType* mt, Int_t ix, Int_t iy)
 {
-  //
-  // Add a motif to this PCB. (ix,iy) indicates one corner position of the motif
-  // where the sign of ix and iy is used to indicate which corner is the 
-  // reference (then for values, abs(ix) and abs(iy) are used indeed) :
-  //
-  // (ix>0,iy>0) : bottom-left corner
-  // (ix<0,iy>0) : bottom-right corner
-  // (ix<0,iy<0) : top-right corner
-  // (ix>0,iy<0) : top-left corner.
+  ///
+  /// Add a motif to this PCB. (ix,iy) indicates one corner position of the motif
+  /// where the sign of ix and iy is used to indicate which corner is the 
+  /// reference (then for values, abs(ix) and abs(iy) are used indeed) :
+  ///
+  /// (ix>0,iy>0) : bottom-left corner
+  /// (ix<0,iy>0) : bottom-right corner
+  /// (ix<0,iy<0) : top-right corner
+  /// (ix>0,iy<0) : top-left corner.
   
   TString id(Form("%s-%e-%e",mt->GetID().Data(),PadSizeX(),PadSizeY()));
 
@@ -327,6 +327,8 @@ AliMpPCB::Add(AliMpMotifType* mt, Int_t ix, Int_t iy)
 AliMpArea 
 AliMpPCB::Area() const
 {
+  /// Return the area of this PCB
+
   return AliMpArea(TVector2( (Xmin()+Xmax())/2.0,DY()),
                    TVector2( DX(), DY() ) );
 }
@@ -335,9 +337,9 @@ AliMpPCB::Area() const
 TObject*
 AliMpPCB::Clone(const char* /*newname*/) const
 {
-  //
-  // Return a full copy of this object.
-  //
+  ///
+  /// Return a full copy of this object.
+  ///
   AliDebug(1,"begin");
   TObject* object = new AliMpPCB(*this);
   AliDebug(1,"end");
@@ -348,14 +350,14 @@ AliMpPCB::Clone(const char* /*newname*/) const
 AliMpPCB*
 AliMpPCB::Clone(const TArrayI& manuids, Int_t ixOffset, Double_t xOffset) const
 {
-  //
-  // Get a full copy of *this, and then apply 2 changes to it :
-  //
-  // a) define the relationship motifType <-> manu id
-  // b) define the x-offset
-  // c) shift ix indices backwards to insure that e.g. the first
-  //    pcb of a slat will start at ix=0 (only relevant for rounded pcbs).
-  //
+  ///
+  /// Get a full copy of *this, and then apply 2 changes to it :
+  ///
+  /// a) define the relationship motifType <-> manu id
+  /// b) define the x-offset
+  /// c) shift ix indices backwards to insure that e.g. the first
+  ///    pcb of a slat will start at ix=0 (only relevant for rounded pcbs).
+  ///
 
   AliDebug(1,"begin");
   
@@ -406,7 +408,7 @@ AliMpPCB::Clone(const TArrayI& manuids, Int_t ixOffset, Double_t xOffset) const
 void
 AliMpPCB::Copy(TObject& o) const
 {
-  // Copy *this into o
+  /// Copy *this into o
 
   AliDebug(1,"begin");
   
@@ -466,9 +468,9 @@ AliMpPCB::Copy(TObject& o) const
 Double_t
 AliMpPCB::ActiveDX() const
 {
-  //
-  // Half-length (in x-direction) occupied by pads  
-  //
+  ///
+  /// Half-length (in x-direction) occupied by pads  
+  ///
   
   return GetNofPadsX()*fPadSizeX/2.0;
 }
@@ -477,13 +479,13 @@ AliMpPCB::ActiveDX() const
 Double_t
 AliMpPCB::DX() const
 {
-  //
-  // Half-length (in x-direction) of the PCB.
-  // This length is the one of the virtual enveloppe of the PCB and might
-  // be bigger than the length occupied by pads (e.g. for rounded or short
-  // PCBs).  
-  // See also ActiveDX().
-  //
+  ///
+  /// Half-length (in x-direction) of the PCB.
+  /// This length is the one of the virtual enveloppe of the PCB and might
+  /// be bigger than the length occupied by pads (e.g. for rounded or short
+  /// PCBs).  
+  /// See also ActiveDX().
+  ///
   
   return fEnveloppeSizeX/2.0;
 }
@@ -492,9 +494,9 @@ AliMpPCB::DX() const
 Double_t
 AliMpPCB::ActiveDY() const
 {
-  //
-  // Half-length (in y-direction) occupied by pads
-  //
+  ///
+  /// Half-length (in y-direction) occupied by pads
+  ///
   
   return GetNofPadsY()*fPadSizeY/2.0;
 }
@@ -503,13 +505,13 @@ AliMpPCB::ActiveDY() const
 Double_t
 AliMpPCB::DY() const
 {
-  //
-  // Half-length (in y-direction) of the PCB.
-  // This length is the one of the virtual enveloppe of the PCB and might
-  // be bigger than the length occupied by pads (e.g. for rounded or short
-  // PCBs).
-  // See also ActiveDY().
-  //
+  ///
+  /// Half-length (in y-direction) of the PCB.
+  /// This length is the one of the virtual enveloppe of the PCB and might
+  /// be bigger than the length occupied by pads (e.g. for rounded or short
+  /// PCBs).
+  /// See also ActiveDY().
+  ///
   
   return fEnveloppeSizeY/2.0;
 }
@@ -518,10 +520,10 @@ AliMpPCB::DY() const
 AliMpMotifPosition*
 AliMpPCB::FindMotifPosition(Int_t ix, Int_t iy) const
 {
-  //
-  // Returns the motifPosition located at the position referenced by
-  // integer indices (ix,iy).
-  //
+  ///
+  /// Returns the motifPosition located at the position referenced by
+  /// integer indices (ix,iy).
+  ///
   
 #ifdef WITH_ROOT
   for (Size_t i = 0; i < fMotifPositions.GetEntriesFast(); ++i )
@@ -542,9 +544,9 @@ AliMpPCB::FindMotifPosition(Int_t ix, Int_t iy) const
 AliMpMotifPosition*
 AliMpPCB::FindMotifPosition(Double_t x, Double_t y) const
 {
-  //
-  // Returns the motifPosition located at position (x,y)
-  //
+  ///
+  /// Returns the motifPosition located at position (x,y)
+  ///
   
 #ifdef WITH_ROOT
   for (Size_t i = 0; i < fMotifPositions.GetEntriesFast(); ++i )
@@ -570,9 +572,9 @@ AliMpPCB::FindMotifPosition(Double_t x, Double_t y) const
 const char*
 AliMpPCB::GetID() const
 {
-  //
-  // Returns the name of this PCB.
-  //
+  ///
+  /// Returns the name of this PCB.
+  ///
   
   return fId.Data();
 }
@@ -581,9 +583,9 @@ AliMpPCB::GetID() const
 AliMpMotifPosition*
 AliMpPCB::GetMotifPosition(AliMpPCB::Size_t i) const
 {
-  //
-  // Get the i-th motifPosition stored in this PCB's internal array.
-  //
+  ///
+  /// Get the i-th motifPosition stored in this PCB's internal array.
+  ///
   
 #ifdef WITH_ROOT
   if ( i >= fMotifPositions.GetEntriesFast() ) return 0;
@@ -597,9 +599,9 @@ AliMpPCB::GetMotifPosition(AliMpPCB::Size_t i) const
 Int_t
 AliMpPCB::GetNofPadsX() const
 {
-  //
-  // Returns the number of pads in x-direction.
-  //
+  ///
+  /// Returns the number of pads in x-direction.
+  ///
   
   return fIxmax-fIxmin+1;
 }
@@ -608,9 +610,9 @@ AliMpPCB::GetNofPadsX() const
 Int_t
 AliMpPCB::GetNofPadsY() const
 {
-  //
-  // Returns the number of pads in y-direction.
-  //
+  ///
+  /// Returns the number of pads in y-direction.
+  ///
   
   return fIymax-fIymin+1;
 }
@@ -619,9 +621,9 @@ AliMpPCB::GetNofPadsY() const
 AliMpPCB::Size_t
 AliMpPCB::GetSize() const
 {
-  //
-  // Returns the number of motifPositions stored in this PCB.
-  //
+  ///
+  /// Returns the number of motifPositions stored in this PCB.
+  ///
   
 #ifdef WITH_ROOT
   return fMotifPositions.GetEntriesFast();
@@ -635,9 +637,9 @@ AliMpPCB::GetSize() const
 Int_t
 AliMpPCB::Ixmin() const
 {
-  //
-  // Returns the index value of the leftmost pad.
-  //
+  ///
+  /// Returns the index value of the leftmost pad.
+  ///
   
   return fIxmin;
 }
@@ -646,9 +648,9 @@ AliMpPCB::Ixmin() const
 Int_t
 AliMpPCB::Ixmax() const
 {
-  //
-  // Returns the index value of the rightmost pad.
-  //
+  ///
+  /// Returns the index value of the rightmost pad.
+  ///
   
   return Ixmin() + GetNofPadsX() - 1;
 }
@@ -657,9 +659,9 @@ AliMpPCB::Ixmax() const
 Int_t
 AliMpPCB::Iymin() const
 {
-  //
-  // Returns the index value of the bottom pad.
-  //
+  ///
+  /// Returns the index value of the bottom pad.
+  ///
   
   return fIymin;
 }
@@ -668,9 +670,9 @@ AliMpPCB::Iymin() const
 Int_t
 AliMpPCB::Iymax() const
 {
-  //
-  // Returns the index value of the top pad.
-  //
+  ///
+  /// Returns the index value of the top pad.
+  ///
   
   return Iymin() + GetNofPadsY() - 1;
 }
@@ -679,9 +681,9 @@ AliMpPCB::Iymax() const
 Double_t
 AliMpPCB::PadSizeX() const
 {
-  //
-  // Returns the pad size in x-direction (in mm)
-  //
+  ///
+  /// Returns the pad size in x-direction (in mm)
+  ///
   
   return fPadSizeX;
 }
@@ -690,9 +692,9 @@ AliMpPCB::PadSizeX() const
 Double_t
 AliMpPCB::PadSizeY() const
 {
-  //
-  // Returns the pad size in y-direction (in mm)
-  //
+  ///
+  /// Returns the pad size in y-direction (in mm)
+  ///
   
   return fPadSizeY;
 }
@@ -701,10 +703,10 @@ AliMpPCB::PadSizeY() const
 void
 AliMpPCB::Print(Option_t* option) const
 {
-  //
-  // Printout of this PCB.
-  // If option="M", the contained motifs are printed too.
-  //
+  ///
+  /// Printout of this PCB.
+  /// If option="M", the contained motifs are printed too.
+  ///
   
   cout << "PCB " << GetID() << " PADSIZES=(" << fPadSizeX << ","
   << fPadSizeY << ") iMin=(" << fIxmin << "," << fIymin << ") "
@@ -737,8 +739,8 @@ AliMpPCB::Print(Option_t* option) const
 void 
 AliMpPCB::Save() const
 {
-  // 
-  // Save this PCB in the file
+  /// 
+  /// Save this PCB in the file
 
   TString fileName(fId);
   fileName += ".pcb";
@@ -789,9 +791,9 @@ AliMpPCB::Save() const
 Double_t
 AliMpPCB::X() const
 {
-  //
-  // Returns the x-position of the PCB center.
-  //
+  ///
+  /// Returns the x-position of the PCB center.
+  ///
   
   return fXoffset + DX();
 }
@@ -800,9 +802,9 @@ AliMpPCB::X() const
 Double_t
 AliMpPCB::Xmin() const
 {
-  //
-  // Returns the leftmost x-position in this PCB.
-  //
+  ///
+  /// Returns the leftmost x-position in this PCB.
+  ///
   
   return X() - DX();
 }
@@ -811,9 +813,9 @@ AliMpPCB::Xmin() const
 Double_t
 AliMpPCB::Xmax() const
 {
-  //
-  // Returns the rightmost x-position in this PCB.
-  //
+  ///
+  /// Returns the rightmost x-position in this PCB.
+  ///
   
   return X() + DX();
 }
@@ -822,9 +824,9 @@ AliMpPCB::Xmax() const
 Double_t
 AliMpPCB::Y() const
 {
-  //
-  // Returns the y-position of the PCB center.
-  //
+  ///
+  /// Returns the y-position of the PCB center.
+  ///
   
   return DY(); // this works as PCB are organized in a single row within slats.
 }
@@ -833,9 +835,9 @@ AliMpPCB::Y() const
 Double_t
 AliMpPCB::Ymin() const
 {
-  //
-  // Returns the smallest y-position in this PCB.
-  //
+  ///
+  /// Returns the smallest y-position in this PCB.
+  ///
   
   return Y() - DY();
 }
@@ -844,9 +846,9 @@ AliMpPCB::Ymin() const
 Double_t
 AliMpPCB::Ymax() const
 {
-  //
-  // Returns the largest y-position in this PCB.
-  //
+  ///
+  /// Returns the largest y-position in this PCB.
+  ///
   
   return Y() + DY();
 }
index 4a6ff43..06b6b7e 100644 (file)
@@ -49,8 +49,10 @@ class AliMpPCB : public TObject
  public:
 
 #ifdef WITH_ROOT
+  /// Type def for the array size
   typedef Int_t  Size_t;
 #else  
+  /// Type def for the array size
   typedef UInt_t Size_t;
 #endif
   
@@ -139,8 +141,10 @@ class AliMpPCB : public TObject
   
   const char* GetID() const;
   
+  /// Return the number of pads in this PCB 
   Int_t NofPads() const { return fNofPads; }
   
+  /// Return the motif map
   AliMpSlatMotifMap* MotifMap() const { return fMotifMap; }
   
   void Save() const;
@@