Coding conventions (Laurent)
authorhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sat, 22 Apr 2006 08:02:13 +0000 (08:02 +0000)
committerhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sat, 22 Apr 2006 08:02:13 +0000 (08:02 +0000)
59 files changed:
MUON/AliMUONChamberTrigger.cxx
MUON/AliMUONChamberTrigger.h
MUON/AliMUONClusterFinderAZ.h
MUON/AliMUONClusterReconstructor.cxx
MUON/AliMUONClusterReconstructor.h
MUON/AliMUONDDLTracker.cxx
MUON/AliMUONDDLTracker.h
MUON/AliMUONDDLTrigger.cxx
MUON/AliMUONDDLTrigger.h
MUON/AliMUONDataDigitIterator.cxx
MUON/AliMUONDataInterface.cxx
MUON/AliMUONDataInterface.h
MUON/AliMUONDataIterator.h
MUON/AliMUONDetElement.cxx
MUON/AliMUONDigitMapA1.cxx
MUON/AliMUONDigitMapA1.h
MUON/AliMUONDigitizerV3.cxx
MUON/AliMUONDigitizerV3.h
MUON/AliMUONMathieson.cxx
MUON/AliMUONMathieson.h
MUON/AliMUONRecoTrack.cxx
MUON/AliMUONRecoTrack.h
MUON/AliMUONReconstructor.cxx
MUON/AliMUONResponse.h
MUON/AliMUONResponseTrigger.cxx
MUON/AliMUONResponseTrigger.h
MUON/AliMUONResponseTriggerV1.cxx
MUON/AliMUONResponseTriggerV1.h
MUON/AliMUONResponseV0.cxx
MUON/AliMUONResponseV0.h
MUON/AliMUONTrigger.cxx
MUON/AliMUONVCalibParam.cxx
MUON/AliMUONVCalibParam.h
MUON/AliMUONVDataIterator.cxx
MUON/AliMUONVDataIterator.h
MUON/mapping/AliMpBusPatch.cxx
MUON/mapping/AliMpBusPatch.h
MUON/mapping/AliMpHelper.cxx
MUON/mapping/AliMpPCB.cxx
MUON/mapping/AliMpPCB.h
MUON/mapping/AliMpPCBPainter.cxx
MUON/mapping/AliMpPCBPainter.h
MUON/mapping/AliMpSlat.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/AliMpSlatZonePadIterator.cxx
MUON/mapping/AliMpSlatZonePadIterator.h
MUON/mapping/AliMpSt345Reader.cxx
MUON/mapping/AliMpSt345Reader.h
MUON/mapping/AliMpTrigger.cxx
MUON/mapping/AliMpTrigger.h
MUON/mapping/AliMpTriggerReader.cxx
MUON/mapping/AliMpTriggerReader.h
MUON/mapping/AliMpTriggerSegmentation.cxx
MUON/mapping/AliMpTriggerSegmentation.h

index e0be611..2160d89 100644 (file)
 
 ClassImp(AliMUONChamberTrigger)
 
+///
+/// \class AliMUONChamberTrigger
+///
+/// Implementation of AliMUONChamber for the trigger
+///
+/// This class is to be deprecated.
+///
+
 //-------------------------------------------
 
 AliMUONChamberTrigger::AliMUONChamberTrigger()
index cf3ecf0..c403ec7 100644 (file)
 /// \class AliMUONChamberTrigger
 /// \brief Muon trigger chamber class
 
-#include <TRef.h>
-
 #include "AliMUONChamber.h"
 
-
 class AliMUONClusterFinder;
 class AliMUONSegmentationTrigger;
 class AliMUONResponseTrigger;
index b3d5d36..02d2204 100644 (file)
@@ -33,7 +33,7 @@ public:
   Int_t    GetNPads(Int_t cath) const { return fnPads[cath]; }
   Int_t    GetIJ(Int_t indx, Int_t iPad) const { return fPadIJ[indx][iPad]; }
   Float_t  GetXyq(Int_t indx, Int_t iPad) const { return fXyq[indx][iPad]; }
-  Float_t  GetZpad() { return fZpad; }
+  Float_t  GetZpad() const { return fZpad; }
   Bool_t GetUsed(Int_t cath, Int_t dig) const { return fUsed[cath][dig]; }
   void SetUsed(Int_t cath, Int_t dig) { fUsed[cath][dig] = kTRUE; } // mark used digits
   void SetUnused(Int_t cath, Int_t dig) { fUsed[cath][dig] = kFALSE; } // unmark digits
index e4222e6..4a21ae3 100644 (file)
@@ -85,21 +85,6 @@ AliMUONClusterReconstructor::~AliMUONClusterReconstructor(void)
 
 //______________________________________________________________________________
 void
-AliMUONClusterReconstructor::CheckSize(TClonesArray& a)
-{
-/// Check if one can adds a new element, or if a is already full.
-/// If full, it is resized.
-
-  if ( a.GetLast()+1 >= a.GetSize() )
-  {
-    AliInfo(Form("Increasing array size from %d to %d",
-                 a.GetSize(),a.GetSize()*2));
-    a.Expand(a.GetSize()*2);
-  }
-}
-
-//______________________________________________________________________________
-void
 AliMUONClusterReconstructor::ClusterizeOneDE(Int_t detElemId)
 {
 /// Clusterize one detection element, and let fMUONData know about
@@ -183,12 +168,10 @@ void AliMUONClusterReconstructor::Digits2Clusters(Int_t chBeg)
       // Add the digit to the array with the right cathode number.
       if (digit->Cathode() == 0)
       {
-        CheckSize(*fDigitsCath0);
         new((*fDigitsCath0)[fDigitsCath0->GetLast()+1]) AliMUONDigit(*digit);
       }
       else 
       {
-        CheckSize(*fDigitsCath1);
         new((*fDigitsCath1)[fDigitsCath1->GetLast()+1]) AliMUONDigit(*digit);
       }
     } // end of loop on chamber digits
index 944461f..b084ca2 100644 (file)
@@ -40,8 +40,6 @@ class AliMUONClusterReconstructor : public TObject
 
   void ClusterizeOneDE(Int_t detElemId);
   
-  void CheckSize(TClonesArray&);
-  
  private:
 
   AliMUONData*            fMUONData;           //! Data container for MUON subsystem 
index c589a23..0f9b61b 100644 (file)
 #include "AliRawDataHeader.h"
 
 ClassImp(AliMUONDDLTracker)
+
+///
+/// \class AliMUONDDLTracker
+///
+/// A wrapper object for 1 DDL of the MUON tracking chambers.
+///
+/// \author C. Finck
+
  const Int_t AliMUONDDLTracker::fgkBlkHeaderLength = 8;
  const Int_t AliMUONDDLTracker::fgkDspHeaderLength = 8;
  const Int_t AliMUONDDLTracker::fgkEndOfDDL = 0x0FFFFFFFF;
index 2d81149..ed8699d 100644 (file)
@@ -49,8 +49,8 @@ public:
    Int_t* GetBlkHeader() {return &fTotalBlkLength;}
    Int_t* GetDspHeader() {return &fTotalDspLength;}
 
-   AliRawDataHeader GetHeader(){return fHeader;}
-   Int_t GetHeaderSize() {return sizeof(AliRawDataHeader)/4;} // in words
+   AliRawDataHeader GetHeader() const {return fHeader;}
+   Int_t GetHeaderSize() const {return sizeof(AliRawDataHeader)/4;} // in words
 
    Int_t   GetEoD()      const {return fgkEndOfDDL;}  
 
index 5651d5a..f3edec4 100644 (file)
 #include "AliMUONDDLTrigger.h"
 
 ClassImp(AliMUONDDLTrigger)
- const Int_t AliMUONDDLTrigger::fgkHeaderLength = 6;
+
+///
+/// \class AliMUONDDLTrigger
+///
+/// One DDL for trigger part of the MUON spectrometer.
+/// 
+/// \author C. Finck
+///
+
+const Int_t AliMUONDDLTrigger::fgkHeaderLength = 6;
 
 //___________________________________________
 AliMUONDDLTrigger::AliMUONDDLTrigger()
index 61b5b26..bd2d4c2 100644 (file)
@@ -43,8 +43,8 @@ public:
    Int_t*  GetGlobalInput()    {return &fGlobalInput[0];}
 
 
-   AliRawDataHeader GetHeader(){return fHeader;}
-   Int_t GetHeaderSize() {return sizeof(AliRawDataHeader)/4;} // in words
+   AliRawDataHeader GetHeader() const {return fHeader;}
+   Int_t GetHeaderSize() const {return sizeof(AliRawDataHeader)/4;} // in words
 
  private:
 
index 7ccb943..961330a 100644 (file)
 #include "AliMUONDataDigitIterator.h"
 
 #include "AliMUONData.h"
-#include "AliMUONDigit.h"
 #include "TClonesArray.h"
 
 ///
+/// \class AliMUONDataDigitIterator
+///
 /// An iterator to access digits (stored into AliMUONData).
 ///
 /// Iteration can occur on tracking chambers only, trigger chambers only,
 /// or both.
 ///
+/// \author L. Aphecetche
+///
 
 //_____________________________________________________________________________
 AliMUONDataDigitIterator::AliMUONDataDigitIterator(const AliMUONData* data,
@@ -64,6 +67,7 @@ AliMUONDataDigitIterator::operator=(const AliMUONDataDigitIterator& rhs)
 void
 AliMUONDataDigitIterator::CopyTo(AliMUONDataDigitIterator& destination) const
 {
+  // Copy *this to destination
   destination.fData=fData;
   destination.fFirstChamber=fFirstChamber;
   destination.fLastChamber=fLastChamber;
@@ -127,6 +131,7 @@ AliMUONDataDigitIterator::Remove()
 void
 AliMUONDataDigitIterator::Reset()
 {
+  // Resets the iterator
   fData->GetDigits();
   fCurrentDigit = 0;
   fCurrentChamber = fFirstChamber;
index de5e177..ed6062c 100644 (file)
@@ -24,6 +24,30 @@ using std::cout;
 
 ClassImp(AliMUONDataInterface)
 
+///
+/// \class AliMUONDataInterface
+///
+/// An easy to use interface to the MUON module data stored in
+/// TreeK, TreeH, TreeS, TreeD and TreeR
+/// One can fetch any of the data objects with all the calls to runloader, 
+/// muon loader and AliMUONData done behind the scenes and automatically.
+///
+/// This interface in not necessarily the fastest way to fetch the data but
+/// it is the easiest.
+/// Note: If independant calls to the run loader, muon loader or 
+/// AliMUONData objects are interspersed with calls to the 
+/// AliMUONDataInterface to fetch data, one might need to call the Reset 
+/// method between these method calls at some point to prevent 
+/// AliMUONDataInterface from getting confused.
+/// This is necessary since this object assumes the state of runloader,
+/// muon loader nor AliMUONData has not changed between calls.
+/// If the state has changes then one must call Reset so that 
+/// AliMUONDataInterface refreshes what it knows about the state
+/// of the loader and AliMUONData objects.
+///
+/// \deprecated We have to revisit all this AliMUONData stuff anyway,
+/// and probably make a real AliMUONLoader instead...
+///
 
 AliMUONDataInterface::AliMUONDataInterface()
        : TObject(), fData(NULL, "MUON", "MUON")
@@ -111,6 +135,8 @@ Bool_t AliMUONDataInterface::UseCurrentRunLoader()
 
 Bool_t AliMUONDataInterface::FetchMuonLoader(TString filename, TString foldername)
 {
+  // fetches the muon loader for the given filename/foldername
+
        fMuonloader = fRunloader->GetLoader("MUONLoader");
        if (fMuonloader == NULL)
        {
index 2bb46c0..da778c8 100644 (file)
@@ -28,17 +28,9 @@ class AliMUONHit;
 class AliMUONDigit;
 class AliMUONTrack;
 
-// An easy to use interface to the MUON module data stored in TreeK, TreeH, TreeS, TreeD and TreeR
-// One can fetch any of the data objects with all the calls to runloader, muon loader and AliMUONData
-// done behind the scenes and automatically.
-// This interface in not necessarily the fastest way to fetch the data but it is the easiest.
-// Note: If independant calls to the run loader, muon loader or AliMUONData objects are interspersed
-// with calls to the AliMUONDataInterface to fetch data, one might need to call the Reset method
-// between these method calls at some point to prevent AliMUONDataInterface from getting confused.
-// This is necessary since this object assumes the state of runloader, muon loader nor AliMUONData
-// has not changed between calls. If the state has changes then one must call Reset so that 
-// AliMUONDataInterface refreshes what it knows about the state of the loader and AliMUONData objects.
-//
+/// An easy to use interface to the MUON module data stored.
+/// \deprecated
+
 class AliMUONDataInterface : public TObject
 {
  public:
index d7f2e27..216a69e 100644 (file)
@@ -28,7 +28,6 @@ public:
   AliMUONDataIterator();
   AliMUONDataIterator(AliMUONData* data, const char* onWhatToIterate,
                       EIterationStyle howToIterate);
-  
   virtual ~AliMUONDataIterator();
     
   TObject* Next();
@@ -38,7 +37,11 @@ public:
   void Reset();
   
 private:
-  AliMUONVDataIterator* fIterator;   
+  AliMUONVDataIterator* fIterator; //! the real worker   
+
+private:
+  AliMUONDataIterator(const AliMUONDataIterator& rhs);
+  AliMUONDataIterator& operator=(const AliMUONDataIterator& rhs);
   
   ClassDef(AliMUONDataIterator,0) // 
 };
index b101cce..f0257eb 100644 (file)
@@ -30,7 +30,6 @@
 #include "AliMUONSegmentation.h"
 #include "AliMUONDigit.h"
 #include "AliMUONHitMapA1.h"
-#include "AliMUONData.h"
 #include "AliMUONRawCluster.h"
 #include "AliMUONHitForRec.h"
 #include "AliMUONClusterInput.h"
@@ -39,7 +38,6 @@
 #include "AliLog.h"
 
 ClassImp(AliMUONDetElement) // Class implementation in ROOT context
-  FILE *lun = 0x0; //fopen("hitmap.dat","w");
 
 //_________________________________________________________________________
 AliMUONDetElement::AliMUONDetElement()
@@ -257,7 +255,7 @@ void AliMUONDetElement::ClusterReco(Double_t xTrack, Double_t yTrack)
          if (!fRecModel->GetUsed(cath1,j)) continue;
          if (fHitMap[cath1]->TestHit(dig->PadX(), dig->PadY()) == kUsed) continue;
          fHitMap[cath1]->FlagHit(dig->PadX(), dig->PadY());
-         if (lun) fprintf(lun," %d %d %d %d \n", cath1, fidDE, dig->PadX(), dig->PadY());
+         AliDebug(10,Form(" %d %d %d %d \n", cath1, fidDE, dig->PadX(), dig->PadY()));
          fLeft[cath1]--;
        }
       }
index 33d926d..1adc8a5 100644 (file)
@@ -139,7 +139,7 @@ TObject* AliMUONDigitMapA1::GetHit(Int_t ix, Int_t iy) const
     return (index <0) ? 0 : fDigits->UncheckedAt(GetHitIndex(ix,iy));
 }
 //_________________________________________________
-FlagType AliMUONDigitMapA1::TestHit(Int_t ix, Int_t iy)
+FlagType AliMUONDigitMapA1::TestHit(Int_t ix, Int_t iy) const
 {
 /// Check if hit cell is empty, used or unused
 
index d3e50ed..65d36b4 100644 (file)
@@ -41,7 +41,7 @@ class AliMUONDigitMapA1 : public TObject
     // Flag a hit as used
     virtual  void  FlagHit(Int_t ix, Int_t iy);
     // Test hit status
-    virtual FlagType TestHit(Int_t ix, Int_t iy);
+    virtual FlagType TestHit(Int_t ix, Int_t iy) const;
 
  protected:
     AliMUONDigitMapA1(const AliMUONDigitMapA1 & hitMap);
index 6192934..696475f 100644 (file)
@@ -479,7 +479,7 @@ AliMUONDigitizerV3::Exec(Option_t*)
 //_____________________________________________________________________________
 AliMUONDigit* 
 AliMUONDigitizerV3::FindCorrespondingDigit(AliMUONDigit& digit,
-                                           AliMUONData* data)
+                                           AliMUONData* data) const
 {                                                
   AliMUONDataIterator it(data,"D",AliMUONDataIterator::kTriggerChambers);
   AliMUONDigit* cd;
index 9355a82..f32f794 100644 (file)
@@ -61,7 +61,7 @@ private:
   void ApplyResponseToTriggerDigit(AliMUONDigit& digit, AliMUONData* data);
 
 private:  
-  AliMUONDigit* FindCorrespondingDigit(AliMUONDigit& digit,AliMUONData* data);
+  AliMUONDigit* FindCorrespondingDigit(AliMUONDigit& digit,AliMUONData* data) const;
   
   Int_t FindDigitIndex(TClonesArray& array, const AliMUONDigit& digit) const;
 
index 98936e5..e0a6b7b 100644 (file)
@@ -98,7 +98,7 @@ AliMUONMathieson::IntXY(Float_t xi1, Float_t yi1, Float_t xi2, Float_t yi2) cons
 }
 
 // -------------------------------------------
-Float_t AliMUONMathieson::IntXY(Int_t idDE, AliMUONGeometrySegmentation* segmentation)
+Float_t AliMUONMathieson::IntXY(Int_t idDE, AliMUONGeometrySegmentation* segmentation) const
 {
 /// Calculate charge on current pad according to Mathieson distribution
 /// using Detection elt
index e9902a7..33fe006 100644 (file)
@@ -45,7 +45,7 @@ class AliMUONMathieson : public TObject
     // Mathieson Ky4
     void    SetKy4(Float_t p1) {fKy4 = p1;};
     /// \deprecated To be removed when old (s)digitizers go off.
-    Float_t  IntXY(Int_t id, AliMUONGeometrySegmentation* segmentation);
+    Float_t  IntXY(Int_t id, AliMUONGeometrySegmentation* segmentation) const;
     /// Charge integration on region (x1,y1,x2,y2).
     Float_t IntXY(Float_t xi1, Float_t yi1, Float_t xi2, Float_t yi2) const;
     
index 7ee2c66..d9eb2a5 100644 (file)
@@ -84,7 +84,7 @@ void AliMUONRecoTrack::SetHitPosition(Int_t chamber, Double_t x, Double_t y, Dou
 }
 
 //-------------------------------------------------------------------          
-void AliMUONRecoTrack::TrackInfo()
+void AliMUONRecoTrack::TrackInfo() const
 {
 // Prints momentum info for this track
    cout << "Px=" << GetMomReconstr(0) << " Py=" << GetMomReconstr(1) <<
index 211ae84..97a6ea5 100644 (file)
@@ -46,7 +46,7 @@ class AliMUONRecoTrack : public TObject
     void           SetFlag(Int_t flag)  {fFlag = flag;};
 
     Double_t Theta() const;
-    void           TrackInfo();
+    void TrackInfo() const;
 
   private:
     Int_t       fSign;                  // charge sign
index cba3211..a2bcc41 100644 (file)
@@ -24,8 +24,6 @@
 
 #include "AliESD.h"
 #include "AliESDMuonTrack.h"
-#include "AliGenEventHeader.h"
-#include "AliHeader.h"
 #include "AliLog.h"
 #include "AliMUON.h"
 #include "AliMUONCalibrationData.h"
@@ -44,8 +42,6 @@
 #include "AliRun.h"
 #include "AliRunLoader.h"
 #include "TTask.h"
-#include <TArrayF.h>
-#include <TParticle.h>
 #include "TStopwatch.h"
 
 ClassImp(AliMUONReconstructor)
index 50c49dd..fb7c633 100644 (file)
@@ -67,14 +67,14 @@ class AliMUONResponse : public TObject
     //  
     // Chamber response methods
     // Pulse height from scored quantity (eloss)
-    virtual Float_t IntPH(Float_t)                            {return 1.;}
+    virtual Float_t IntPH(Float_t) const                      {return 1.;}
     // Charge disintegration 
-    virtual Float_t IntXY(Int_t, AliMUONGeometrySegmentation*) {return 1.;}
+    virtual Float_t IntXY(Int_t, AliMUONGeometrySegmentation*) const {return 1.;}
 
     // Noise, zero-suppression, adc saturation
     //virtual Int_t DigitResponse(Int_t )                {return kTRUE;}
     virtual Int_t DigitResponse(Int_t , 
-                                AliMUONTransientDigit* ) {return kTRUE;}
+                                AliMUONTransientDigit* ) const {return kTRUE;}
     
     /// Go from one hit to several digits, applying charge spreading.
     virtual void DisIntegrate(const AliMUONHit& hit, TList& digits);
index d03431b..747ab12 100644 (file)
@@ -35,8 +35,6 @@ ClassImp(AliMUONResponseTrigger)
 
 namespace
 {
-  Float_t TOFLIMIT = 75E-9;
-
   AliMUON* muon()
   {
     return static_cast<AliMUON*>(gAlice->GetModule("MUON"));
@@ -62,6 +60,9 @@ namespace
   }
 }
 
+const Float_t 
+AliMUONResponseTrigger::fgkTofLimit = 75E-9;
+
 //------------------------------------------------------------------   
 AliMUONResponseTrigger::AliMUONResponseTrigger()
   : AliMUONResponse()
@@ -71,7 +72,8 @@ AliMUONResponseTrigger::AliMUONResponseTrigger()
 
 //------------------------------------------------------------------   
 Int_t AliMUONResponseTrigger::DigitResponse(Int_t digit, 
-                                           AliMUONTransientDigit* /*where*/){
+                                           AliMUONTransientDigit* /*where*/) const
+{
 //  only digital (0/1) information available
 
   if (digit) 
@@ -103,7 +105,7 @@ AliMUONResponseTrigger::DisIntegrate(const AliMUONHit& hit, TList& digits)
   
   Float_t tof = hit.Age();
   Int_t twentyNano(100);
-  if (tof<TOFLIMIT)
+  if (tof<fgkTofLimit)
   {
     twentyNano=1;
   }
index 67758e0..a56db75 100644 (file)
@@ -18,7 +18,7 @@ class AliMUONResponseTrigger : public AliMUONResponse
   AliMUONResponseTrigger();
   virtual ~AliMUONResponseTrigger(){} 
 
-  virtual Int_t DigitResponse(Int_t digit, AliMUONTransientDigit* where);
+  virtual Int_t DigitResponse(Int_t digit, AliMUONTransientDigit* where) const;
 
 
   // Set the GenerCluster parameter       
@@ -26,6 +26,8 @@ class AliMUONResponseTrigger : public AliMUONResponse
 
   virtual void DisIntegrate(const AliMUONHit& hit, TList& digits);
   
+ private:
+  static const Float_t fgkTofLimit; // particle above this threshold are discarded
   ClassDef(AliMUONResponseTrigger,1) // Implementation of RPC response
     
 };
index 5fe7696..5688f71 100644 (file)
@@ -57,7 +57,8 @@ Int_t AliMUONResponseTriggerV1::SetGenerCluster(){
 } 
 
 //------------------------------------------------------------------   
-Float_t AliMUONResponseTriggerV1::IntXY(Int_t idDE, AliMUONGeometrySegmentation * segmentation){
+Float_t AliMUONResponseTriggerV1::IntXY(Int_t idDE, AliMUONGeometrySegmentation * segmentation) const
+{
 // Returns 1 or 0 if the current strip is fired or not 
 // get the "parameters" needed to evaluate the strip response
 // x1 : hit x(y) position
@@ -73,7 +74,9 @@ Float_t AliMUONResponseTriggerV1::IntXY(Int_t idDE, AliMUONGeometrySegmentation
 }
 
 //------------------------------------------------------------------   
-Float_t AliMUONResponseTriggerV1::FireStripProb(Float_t x4, Float_t theta){
+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 Alice/note xxx)
 // WARNING : need to convert x4 from cm to mm
index 394ed98..39b3056 100644 (file)
@@ -20,7 +20,7 @@ class AliMUONResponseTriggerV1 : public AliMUONResponseTrigger
     AliMUONResponseTriggerV1(Float_t hv);
     virtual ~AliMUONResponseTriggerV1(){} 
     // Charge disintegration
-    virtual Float_t  IntXY(Int_t idDE, AliMUONGeometrySegmentation * segmentation);
+    virtual Float_t  IntXY(Int_t idDE, AliMUONGeometrySegmentation * segmentation) const;
 
     // Set the GenerCluster parameter       
     virtual Int_t SetGenerCluster();
@@ -35,7 +35,7 @@ class AliMUONResponseTriggerV1 : public AliMUONResponseTrigger
     // initialize parameters
     void SetParameters(Float_t hv);
     // parametrization of the cluster-size
-    Float_t FireStripProb(Float_t x4, Float_t theta);
+    Float_t FireStripProb(Float_t x4, Float_t theta) const;
 
   ClassDef(AliMUONResponseTriggerV1,1) // Implementation of RPC response
     
index 1828361..93f6f4d 100644 (file)
@@ -159,7 +159,7 @@ void AliMUONResponseV0::SetSqrtKy3AndDeriveKy2Ky4(Float_t SqrtKy3)
   fMathieson->SetSqrtKy3AndDeriveKy2Ky4(SqrtKy3);
 }
   //__________________________________________________________________________
-Float_t AliMUONResponseV0::IntPH(Float_t eloss)
+Float_t AliMUONResponseV0::IntPH(Float_t eloss) const
 {
   // Calculate charge from given ionization energy loss
   Int_t nel;
@@ -175,7 +175,9 @@ Float_t AliMUONResponseV0::IntPH(Float_t eloss)
 }
 
   //-------------------------------------------
-Float_t AliMUONResponseV0::IntXY(Int_t idDE, AliMUONGeometrySegmentation* segmentation)
+Float_t AliMUONResponseV0::IntXY(Int_t idDE,
+                                AliMUONGeometrySegmentation* segmentation) 
+const
 {
  // Calculate charge on current pad according to Mathieson distribution
 
@@ -184,7 +186,9 @@ Float_t AliMUONResponseV0::IntXY(Int_t idDE, AliMUONGeometrySegmentation* segmen
 
 
   //-------------------------------------------
-Int_t  AliMUONResponseV0::DigitResponse(Int_t digit, AliMUONTransientDigit* /*where*/)
+Int_t  AliMUONResponseV0::DigitResponse(Int_t digit,
+                                       AliMUONTransientDigit* /*where*/)
+const
 {
   // \deprecated method
   // Now part of the digitizer (where it belongs really), e.g. DigitizerV3
index 3ed5d43..e7af62a 100644 (file)
@@ -81,11 +81,13 @@ class AliMUONResponseV0 : public AliMUONResponse
     //  
     // Chamber response methods
     // Pulse height from scored quantity (eloss)
-    virtual Float_t  IntPH(Float_t eloss);
+    virtual Float_t  IntPH(Float_t eloss) const;
     // Charge disintegration
-    virtual Float_t  IntXY(Int_t idDE, AliMUONGeometrySegmentation* segmentation);
+    virtual Float_t  IntXY(Int_t idDE, 
+                          AliMUONGeometrySegmentation* segmentation) const;
     // Noise, zero-suppression, adc saturation
-    virtual Int_t DigitResponse(Int_t digit, AliMUONTransientDigit* where);
+    virtual Int_t DigitResponse(Int_t digit, 
+                               AliMUONTransientDigit* where) const;
 
     virtual Float_t GetAnod(Float_t x) const;
     
index 29b03f2..67f7ec9 100644 (file)
 #include "AliMUONTriggerDecision.h"
 #include "AliMUONTrigger.h"
 
+///
+/// \class AliMUONTrigger
+///
+/// Implementation of AliTriggerDetector for MUON detector
+///
+/// So far, the inputs are taken from AliMUONTriggerDecision object
+///
+
 //----------------------------------------------------------------------
 ClassImp(AliMUONTrigger)
 
@@ -70,7 +78,7 @@ void AliMUONTrigger::CreateInputs()
 //----------------------------------------------------------------------
 void AliMUONTrigger::Trigger()
 {
-
+  // sets the trigger inputs
 
    AliRunLoader* runLoader = gAlice->GetRunLoader();
 
index bcba7c7..b5121ee 100644 (file)
 
 #include "AliMUONVCalibParam.h"
 
-#include "Riostream.h"
+/// 
+/// \class AliMUONVCalibParam
+///  
+/// Defines an interface for a calibration container object.
+///
+/// \author Laurent Aphecetche
 
 ClassImp(AliMUONVCalibParam)
 
 //_____________________________________________________________________________
+  AliMUONVCalibParam::AliMUONVCalibParam() : TObject()
+{
+  // ctor
+}
+
+//_____________________________________________________________________________
 AliMUONVCalibParam::~AliMUONVCalibParam()
 {
   // 
index 9816c97..8db3714 100644 (file)
@@ -19,6 +19,7 @@
 class AliMUONVCalibParam : public TObject
 {
 public:
+  AliMUONVCalibParam();
   virtual ~AliMUONVCalibParam();
 
   /// j indices in following methods are valid from 0 to Dimension()-1.
index eae0fd3..ce55e9d 100644 (file)
 
 ClassImp(AliMUONVDataIterator)
 
+///
+/// \class AliMUONVDataIterator
+///
+/// Defines an interface of an iterator over muon data structure(s).
+///
+/// \author L. Aphecetche
+
+//_____________________________________________________________________________
+AliMUONVDataIterator::AliMUONVDataIterator() : TObject()
+{
+}
+
 //_____________________________________________________________________________
 AliMUONVDataIterator::~AliMUONVDataIterator()
 {
index 44310c6..fe3b2fe 100644 (file)
@@ -19,6 +19,7 @@
 class AliMUONVDataIterator : public TObject
 {
 public:
+  AliMUONVDataIterator();
   virtual ~AliMUONVDataIterator();
   
   virtual TObject* Next() = 0;
index 9a5f976..279b2bd 100644 (file)
@@ -31,8 +31,8 @@
 
 #include "AliLog.h"
 
-#include <TArrayI.h>
-#include <Riostream.h>
+#include "TArrayI.h"
+#include "Riostream.h"
 
 ClassImp(AliMpBusPatch)
 
@@ -119,7 +119,8 @@ Int_t AliMpBusPatch::GetDDLfromBus(Int_t busPatchId)
 }
 
 //____________________________________________________________________
-void AliMpBusPatch::GetDspInfo(Int_t iCh, Int_t& iDspMax, Int_t* iBusPerDSP)
+void AliMpBusPatch::GetDspInfo(Int_t iCh, Int_t& iDspMax, Int_t* iBusPerDSP) 
+const
 {
 /// calculates the number of DSP & buspatch per block
 
index e41587e..3f77239 100644 (file)
@@ -35,7 +35,7 @@ class AliMpBusPatch : public TObject
   
   // methods
   void ReadBusPatchFile();
-  void GetDspInfo(Int_t iCh, Int_t& iDspMax, Int_t* iBusPerDSP);
+  void GetDspInfo(Int_t iCh, Int_t& iDspMax, Int_t* iBusPerDSP) const;
 
   Int_t    GetDEfromBus(Int_t busPatchId);
   TArrayI* GetBusfromDE(Int_t idDE);
index 60a3553..52c7d43 100644 (file)
 
 #include "AliMpHelper.h"
 
-#include "AliLog.h"
 #include "TArrayI.h"
-#include "TClass.h"
 #include "TObjArray.h"
 #include "TObjString.h"
 #include "TString.h"
 
+///
+/// \class AliMpHelper
+///
+/// Helper class used to parse mapping files for St345 slats.
+///
+/// \author L. Aphecetche
+
 ClassImp(AliMpHelper)
 
 //_____________________________________________________________________________
index 3b1300c..561d91f 100644 (file)
 #include "TMath.h"
 #include <sstream>
 
+/// 
+/// \class AliMpPCB
+///
+/// A PCB for station 3,4 or 5
+/// 
+/// A PCB is a group of pads having the same size
+/// Pads are grouped in motifs, where 1 motif = 1 MANU
+///
+/// The notion of PCB enveloppe is due to the fact that not all PCBs are
+/// "full" of pads, e.g. the rounded or short ones miss some pads,
+/// but the enveloppe is a virtual size that should be constant 
+/// across the slats, and is 400x400 mm.
+/// It's a usefull notion to compute e.g. slat center in a uniform way, 
+/// considering that a slat is N PCBs, of the same "virtual" size, that of 
+/// the enveloppe.
+///
+/// \author L. Aphecetche
+
 ClassImp(AliMpPCB)
 
 //_____________________________________________________________________________
@@ -286,6 +304,8 @@ AliMpPCB::Clone(const TArrayI& manuids, Int_t ixOffset, Double_t xOffset) const
 void
 AliMpPCB::Copy(TObject& o) const
 {
+  // Copy *this into o
+
   TObject::Copy(o);
   AliMpPCB& pcb = static_cast<AliMpPCB&>(o);
   pcb.fId = fId;
index 3978dde..6ace684 100644 (file)
@@ -51,13 +51,7 @@ class AliMpPCB : public TObject
   
   AliMpPCB();
   /** Ctor. The sizes are given in mm.
-      enveloppe is due to the fact that not all PCBs are "full" of pads,
-      e.g. the rounded or short ones miss some pads, but the enveloppe 
-      is a virtual size that should be constant across the slats, 
-      and is 400x400 mm.
-      It's a usefull notion to compute e.g. slat center in a uniform way, 
-      considering that a slat is N PCBs, of the same "virtual" size, that of 
-      the enveloppe.
+      See full doc for the meaning of enveloppe parameters.
   */
   AliMpPCB(const char* id, Double_t padSizeX, Double_t padSizeY,
           Double_t enveloppeSizeX, Double_t enveloppeSizeY);
@@ -140,24 +134,24 @@ class AliMpPCB : public TObject
   Int_t NofPads() const { return fNofPads; }
   
  private:
-  TString fId;
-  Double_t fPadSizeX;
-  Double_t fPadSizeY;
-  Double_t fEnveloppeSizeX;
-  Double_t fEnveloppeSizeY;
-  Double_t fXoffset;
-  Double_t fActiveXmin;
-  Double_t fActiveXmax;
-  Int_t fIxmin;
-  Int_t fIxmax;
-  Int_t fIymin;
-  Int_t fIymax;
+  TString fId; // PCB name
+  Double_t fPadSizeX; // x-size of this PCB's pads (cm)
+  Double_t fPadSizeY; // y-size of this PCB's pads (cm)
+  Double_t fEnveloppeSizeX; // max x-size of this PCB (cm)
+  Double_t fEnveloppeSizeY; // max y-size of this PCB (cm)
+  Double_t fXoffset; // x-offset = x of first pad of this PCB (cm)
+  Double_t fActiveXmin; // min x of an actual pad in this PCB (cm)
+  Double_t fActiveXmax; // max x of an actual pad in this PCB (cm)
+  Int_t fIxmin; // min pad index in x
+  Int_t fIxmax; // max pad index in x
+  Int_t fIymin; // min pad index in y
+  Int_t fIymax; // max pad index in y
 #ifdef WITH_ROOT
-  TObjArray fMotifs;
+  TObjArray fMotifs; // array of motifs
 #else  
-  std::vector<AliMpMotifPosition*> fMotifs;
+  std::vector<AliMpMotifPosition*> fMotifs; // array of motifs
 #endif
-  Int_t fNofPads;
+  Int_t fNofPads; // number of pads in this PCB
   
   ClassDef(AliMpPCB,2) // A PCB for Stations 3,4,5
 };
index 2311290..b5dbbb0 100644 (file)
 
 // $Id$
 // $MpId: AliMpPCBPainter.cxx,v 1.4 2005/09/19 18:56:46 ivana Exp $
-// Category: graphics
-//
-// Class AliMpSlatPainter
-// -----------------------
-// Class for drawing a PCB into canvas
-// Authors: Laurent Aphecetche
+
+///
+/// \class AliMpSlatPainter
+/// 
+/// Class for drawing a PCB into canvas
+/// 
+/// \author L. Aphecetche
 
 #include "AliMpPCBPainter.h"
 
index 7d28771..1845ec9 100644 (file)
@@ -8,7 +8,7 @@
 /// \class AliMpPCBPainter
 /// \brief Class for drawing a PCB into canvas
 ///
-/// Authors: Laurent Aphecetche
+/// \author Laurent Aphecetche
 
 #ifndef ALIMPPCBPAINTER_H
 #define ALIMPPCBPAINTER_H
@@ -35,7 +35,7 @@ public:
   AliMpPCBPainter&  operator = (const AliMpPCBPainter& right);
      
  private:
-  AliMpPCB* fPCB;
+  AliMpPCB* fPCB; //! PCB to be plotted.
 
   ClassDef(AliMpPCBPainter,1) // A painter for a PCB of stations 3,4,5
 };
index 54b404f..1030e08 100644 (file)
@@ -153,13 +153,11 @@ class AliMpSlat : public TObject
   mutable AliMpExMap fManuMap; // map of int to AliMpMotifPosition*
 #ifdef WITH_ROOT
   TObjArray fPCBs; // array of AliMpPCB*
-  //mutable AliMpExMap fManuMap; // map of int to AliMpMotifPosition*
 #else  
   std::vector<AliMpPCB*> fPCBs; // array of AliMpPCB*
-  //std::map<int,AliMpMotifPosition*> fManuMap;
 #endif
   TVector2 fPosition; // Position of the slat center.
-  Int_t fNofPads;
+  Int_t fNofPads; // number of pads in this slat
   
   ClassDef(AliMpSlat,2) // A slat for stations 3,4,5
 };
index b24811e..da140b6 100644 (file)
 #include <limits>
 #include <cassert>
 
-ClassImp(AliMpSlatPadIterator)
+///
+/// \class AliMpSlatPadIterator
+///
+/// Implementation of AliMpVPadIterator for slats.
+///
+/// This class first split the input area (upon which to iterate)
+/// into a set of areas of constant pad size.
+/// Then each of those areas is iterated over, using
+/// AliMpSlatZonePadIterator objects.
+///
+/// \author L. Aphecetche
+///
 
+ClassImp(AliMpSlatPadIterator)
 
-namespace 
-{
-  Double_t DMAX(std::numeric_limits<Double_t>::max());
-}
+//const Double_t
+//AliMpSlatPadIterator::fgkDmax = std::numeric_limits<Double_t>::max();
 
 //_____________________________________________________________________________
 AliMpSlatPadIterator::AliMpSlatPadIterator()
index ddf8ddd..b759ca5 100644 (file)
@@ -40,10 +40,10 @@ class AliMpSlatPadIterator : public AliMpVPadIterator
   AliMpArea Intersect(const AliMpArea& a, const AliMpArea& b) const;
 
  private:
-  const AliMpSlat* fkSlat;
-  std::vector<AliMpVPadIterator*> fDelegates;
-  AliMpVPadIterator* fCurrentDelegate;
-  UInt_t fCurrentDelegateIndex;
+  const AliMpSlat* fkSlat; // pointer to the slat being iterated over
+  std::vector<AliMpVPadIterator*> fDelegates; // iterators we do use
+  AliMpVPadIterator* fCurrentDelegate; // current iterator
+  UInt_t fCurrentDelegateIndex; // current iterator index
 
   ClassDef(AliMpSlatPadIterator,1) // Pad iterator for St 345 Slats
 };
index cc8d1d5..450d16a 100644 (file)
 
 // $Id$
 // $MpId: AliMpSlatPainter.cxx,v 1.6 2005/09/19 18:56:46 ivana Exp $
-// Category: graphics
-//
-// Class AliMpSlatPainter
-// -----------------------
-// Class for drawing a slat into canvas
-// Authors: Laurent Aphecetche
+
+///
+/// \class AliMpSlatPainter
+/// 
+/// Class for drawing a slat into canvas
+///
+/// \author Laurent Aphecetche
 
 #include "AliMpSlatPainter.h"
 
index 5e190a7..abcbc8e 100644 (file)
@@ -40,7 +40,7 @@ class AliMpSlatPainter : public AliMpVPainter
      
   
  private:
-  const AliMpSlat* fkSlat;
+  const AliMpSlat* fkSlat; //! pointer to the slat to be drawn
 
   ClassDef(AliMpSlatPainter,1) // A painter for a slat of stations 3,4,5
 };
index abb3f4d..b8597ba 100644 (file)
@@ -30,7 +30,6 @@
 #include "AliMpMotif.h"
 #include "AliMpMotifPosition.h"
 #include "AliMpMotifType.h"
-#include "AliMpPCB.h"
 #include "AliMpSlat.h"
 #include "AliMpSlatPadIterator.h"
 
@@ -128,6 +127,8 @@ AliMpSlatSegmentation::GetAllElectronicCardIDs(TArrayI& ecn) const
 const char*
 AliMpSlatSegmentation::GetName() const
 {
+  // The name of this segmentation is "SlatSegmentation"+slatName
+
   TString name("SlatSegmentation");
   if ( fkSlat) 
   {
index 09db08d..fa8692a 100644 (file)
@@ -60,7 +60,7 @@ class AliMpSlatSegmentation : public AliMpVSegmentation
   virtual AliMpPad PadByPosition(const TVector2& position,
                         Bool_t warning) const;
 
-  virtual void Print(Option_t*) const;
+  virtual void Print(Option_t* opt) const;
   
   const AliMpSlat* Slat() const;
   
index 6e98691..065a986 100644 (file)
 #include "Riostream.h"
 #include <algorithm>
 #include <limits>
-#include <cassert>
 
 ClassImp(AliMpSlatZonePadIterator)
 
-// This iterator only works within a region of constant density.
+/// 
+/// \class AliMpSlatZonePadIterator
+/// 
+/// Iterates over slat pads within a region of constant pad size.
+/// 
+/// \author Laurent Aphecetche
 
-namespace 
-{
-  const Double_t epsilon = 1E-4; // cm
-  Double_t DMAX(std::numeric_limits<Double_t>::max());
-}
+const Double_t AliMpSlatZonePadIterator::fgkEpsilon = 1E-4; // cm
+const Double_t AliMpSlatZonePadIterator::fgkDmax = std::numeric_limits<Double_t>::max();
 
 //_____________________________________________________________________________
 AliMpSlatZonePadIterator::AliMpSlatZonePadIterator(const AliMpSlat* slat,
@@ -109,7 +110,7 @@ AliMpSlatZonePadIterator::CropArea()
   // Left and right x-limits have to come from first and last pcbs
   // to deal with short and rounded pcbs cases.
   AliMpPCB* first = fkSlat->FindPCB(fArea.LeftBorder(),fArea.DownBorder());
-  AliMpPCB* last = fkSlat->FindPCB(fArea.RightBorder()-epsilon,
+  AliMpPCB* last = fkSlat->FindPCB(fArea.RightBorder()-fgkEpsilon,
                                  fArea.DownBorder());
 
   AliDebug(3,Form("First PCB %s Ixmin %2d Last PCB %s Ixmax %2d",
@@ -117,14 +118,14 @@ AliMpSlatZonePadIterator::CropArea()
                  last->GetID(),last->Ixmax()));
 
   Double_t xleft = first->ActiveXmin();
-  Double_t xright = last->ActiveXmax() - epsilon;
+  Double_t xright = last->ActiveXmax() - fgkEpsilon;
 
   AliDebug(3,Form("xleft,xright=%e,%e",xleft,xright));
 
   Double_t xmin = std::max(fArea.LeftBorder(),xleft);
   Double_t xmax = std::min(fArea.RightBorder(),xright);
   Double_t ymin = std::max(fArea.DownBorder(),0.0);
-  Double_t ymax = std::min(fArea.UpBorder(),fkSlat->DY()*2.0-epsilon);
+  Double_t ymax = std::min(fArea.UpBorder(),fkSlat->DY()*2.0-fgkEpsilon);
 
   AliDebug(3,Form("Cropped area (%e,%e)->(%e,%e)",
                  xmin,ymin,xmax,ymax));
@@ -278,7 +279,7 @@ AliMpSlatZonePadIterator::Invalidate()
   // Invalidate the iterator.
   //
   
-  fOffset = TVector2(DMAX,DMAX);
+  fOffset = TVector2(fgkDmax,fgkDmax);
   fCurrentPad = AliMpPad::Invalid();
   fIsDone = kTRUE;
 }
index 3a4399e..c17d666 100644 (file)
@@ -1,3 +1,6 @@
+#ifndef ALI_MP_SLAT_ZONE_PAD_ITERATOR_H
+#define ALI_MP_SLAT_ZONE_PAD_ITERATOR_H
+
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
 
@@ -6,12 +9,8 @@
 
 /// \ingroup slat
 /// \class AliMpSlatZonePadIterator
-/// \brief To be added ...
-/// 
-/// Author: Laurent Aphecetche
-
-#ifndef ALI_MP_SLAT_ZONE_PAD_ITERATOR_H
-#define ALI_MP_SLAT_ZONE_PAD_ITERATOR_H
+/// \brief Iterates over slat pads within a region of constant pad size.
+/// \author Laurent Aphecetche
 
 #include "AliMpVPadIterator.h"
 #include "AliMpArea.h"
@@ -42,13 +41,16 @@ class AliMpSlatZonePadIterator : public AliMpVPadIterator
   void SetPad(AliMpPad& pad, const TVector2& pos);
 
  private:
-  const AliMpSlat*       fkSlat;
-  AliMpSlatSegmentation* fSlatSegmentation;
-  AliMpArea  fArea;
-  TVector2   fOffset;
-  TVector2   fStep;
-  AliMpPad   fCurrentPad;
-  Bool_t     fIsDone;
+  const AliMpSlat*       fkSlat; //! the slat we're iterating over
+  AliMpSlatSegmentation* fSlatSegmentation; //! segmentation pointer
+  AliMpArea  fArea; //! area we're iterating over
+  TVector2   fOffset; //! current position (relative to bottom-left of area)
+  TVector2   fStep; //! step sizes
+  AliMpPad   fCurrentPad; //! current pad
+  Bool_t     fIsDone; //! whether we've finished or not
+
+  static const Double_t fgkDmax; // maximum double
+  static const Double_t fgkEpsilon; // comparison precision 
 
   ClassDef(AliMpSlatZonePadIterator,1) // Pad iterator for a zone of constant density, for St345.
 };
index 39f1592..99ca08c 100644 (file)
 #include <sstream>
 #include <assert.h>
 
-TMap AliMpSt345Reader::fgPCBMap;
+/// 
+/// \class AliMpSt345Reader
+//
+/// Read slat and pcb ASCII files.
+/// 
+/// Basically this class provides 2 static methods :
+/// - AliMpSlat* ReadSlat()
+/// - AliMpPCB ReadPCB()
+///
+/// \author Laurent Aphecetche
 
 ClassImp(AliMpSt345Reader)
 
+TMap AliMpSt345Reader::fgPCBMap;
+
 //_____________________________________________________________________________
 AliMpSt345Reader::AliMpSt345Reader() : TObject()
 {
index 610814e..e038094 100644 (file)
@@ -8,7 +8,7 @@
 /// \class AliMpSt345Reader
 /// \brief Read slat and pcb ASCII files
 /// 
-/// Author: Laurent Aphecetche
+/// \author Laurent Aphecetche
 
 #ifndef ALI_MP_ST345_READER_H
 #define ALI_MP_ST345_READER_H
index c40e3c8..522ca2a 100644 (file)
 #include "TArrayI.h"
 #include "TObjArray.h"
 
+/// 
+/// \class AliMpTrigger
+/// 
+/// A trigger 'slat' object. 
+/// It is to be viewed as a superposition of  
+/// virtual layers of AliMpSlat objects. The need for more than one layer  
+/// arise from the fact that a given local board deals with strips  
+/// located in different detelem. So a given strip (pad) can have several  
+/// "locations".
+///
+/// \author Laurent Aphecetche
+
 ClassImp(AliMpTrigger)
 
 namespace
@@ -52,6 +64,7 @@ AliMpTrigger::AliMpTrigger()
 : TObject(), fId(""), fPlaneType(kNonBendingPlane), 
 fMaxNofPadsY(0), fDX(0), fDY(0)
 {
+  // default ctor
 }
 
 //_____________________________________________________________________________
@@ -59,11 +72,13 @@ AliMpTrigger::AliMpTrigger(const char* slatType, AliMpPlaneType bendingOrNot)
 :  TObject(), fId(slatType), fPlaneType(bendingOrNot), 
 fMaxNofPadsY(0), fDX(0), fDY(0)
 {
+  // normal ctor
 }
 
 //_____________________________________________________________________________
 AliMpTrigger::~AliMpTrigger()
 {
+  // dtor
   AliDebug(1,Form("this=%p before fSlats.Delete()",this));                     
   fSlats.Delete();
   AliDebug(1,Form("this=%p after fSlats.Delete()",this));                      
@@ -73,6 +88,9 @@ AliMpTrigger::~AliMpTrigger()
 Bool_t
 AliMpTrigger::AdoptLayer(AliMpSlat* slat)
 {
+  // Adopt (i.e. we become owner of that pointer) a slat, as 
+  // a layer of this trigger slat.
+
   AliDebug(1,Form("%s is adopting %s :\n",
                   GetID(),slat->GetID()));
 
@@ -101,6 +119,7 @@ AliMpTrigger::AdoptLayer(AliMpSlat* slat)
 TVector2
 AliMpTrigger::Dimensions() const
 {
+  // Returns the dimensions (half-sizes) of that slat (cm)
   return TVector2(DX(),DY());
 }
 
@@ -108,6 +127,7 @@ AliMpTrigger::Dimensions() const
 Double_t
 AliMpTrigger::DX() const
 {
+  // Returns the half-size in X (cm)
   return fDX;
 }
 
@@ -115,6 +135,7 @@ AliMpTrigger::DX() const
 Double_t
 AliMpTrigger::DY() const
 {
+  // Returns the half-size in Y (cm)
   return fDY;
 }
 
@@ -122,6 +143,7 @@ AliMpTrigger::DY() const
 void 
 AliMpTrigger::GetAllLocalBoardNumbers(TArrayI& lbn) const
 {
+  // Fills lbn with the local board numbers we're dealing with
   Int_t n(0);
   for ( Int_t i = 0; i < GetSize(); ++i )
   {
@@ -148,6 +170,7 @@ AliMpTrigger::GetAllLocalBoardNumbers(TArrayI& lbn) const
 const char*
 AliMpTrigger::GetID() const
 {
+  // returns the id of this slat
   return fId.Data();
 }
 
@@ -155,6 +178,7 @@ AliMpTrigger::GetID() const
 const char*
 AliMpTrigger::GetName() const
 {
+  // returns the name (=id+bending/non-bending) of this slat
   TString name(GetID());
   if ( fPlaneType == kBendingPlane )
   {
@@ -175,6 +199,7 @@ AliMpTrigger::GetName() const
 AliMpSlat*
 AliMpTrigger::GetLayer(int layer) const
 {
+  // Returns a given layer
   if ( IsLayerValid(layer) )
   {
     return (AliMpSlat*)fSlats.At(layer);
@@ -186,6 +211,7 @@ AliMpTrigger::GetLayer(int layer) const
 Int_t
 AliMpTrigger::GetNofPadsX() const
 {
+  // Returns the number of pad in x direction
   if ( !GetSize() ) return -1;
   if ( GetLayer(0) )
   {
@@ -198,6 +224,7 @@ AliMpTrigger::GetNofPadsX() const
 Int_t
 AliMpTrigger::GetMaxNofPadsY() const
 {
+  // Maximum number of pads in y direction
   return fMaxNofPadsY;
 }
 
@@ -205,6 +232,7 @@ AliMpTrigger::GetMaxNofPadsY() const
 Int_t
 AliMpTrigger::GetSize() const
 {
+  // Number of layers
   return fSlats.GetEntriesFast();
 }
 
@@ -212,6 +240,7 @@ AliMpTrigger::GetSize() const
 Bool_t
 AliMpTrigger::IsLayerValid(int layer) const
 {
+  // Whether a given layer index is valid or not
   if ( layer >= 0 && layer < GetSize() )
   {
     return kTRUE;
@@ -223,6 +252,7 @@ AliMpTrigger::IsLayerValid(int layer) const
 AliMpPlaneType
 AliMpTrigger::PlaneType() const
 {
+  // Bending or not
   return fPlaneType;
 }
 
@@ -230,6 +260,7 @@ AliMpTrigger::PlaneType() const
 TVector2
 AliMpTrigger::Position() const
 {
+  // Slat position (cm)
   return TVector2(DX(),DY());
 }
 
@@ -237,6 +268,7 @@ AliMpTrigger::Position() const
 void
 AliMpTrigger::Print(Option_t* opt) const
 {
+  // Dump on screen
   cout << "AliMpTrigger::" << GetID();
   if ( GetSize() == 0 )
   {
index d3594e9..bcd1aa1 100644 (file)
@@ -7,13 +7,7 @@
 /// \ingroup trigger
 /// \class AliMpTrigger
 /// \brief A trigger slat
-/// 
-/// A trigger 'slat' object. It is to be viewed as a superposition of  
-/// virtual layers of AliMpSlat objects. The need for more than one layer  
-/// arise from the fact that a given local board deals with strips  
-/// located in different detelem. So a given strip (pad) can have several  
-/// "locations".
-/// Author: Laurent Aphecetche
+/// \author Laurent Aphecetche
 
 #ifndef ALI_MP_TRIGGER_H
 #define ALI_MP_TRIGGER_H
@@ -81,12 +75,12 @@ private:
     
   Bool_t IsLayerValid(int layer) const;
   
-  TString fId;
-  AliMpPlaneType fPlaneType;
-  TObjArray fSlats;
-  Int_t fMaxNofPadsY;
-  Double_t fDX;
-  Double_t fDY;
+  TString fId; //! name of that slat
+  AliMpPlaneType fPlaneType; //! bending or non-bending
+  TObjArray fSlats; //! virtual slat composing this trigger slat
+  Int_t fMaxNofPadsY; //! max number of pads in y direction
+  Double_t fDX; //! half-size in x (cm)
+  Double_t fDY; //! half-size in y (cm)
   
   ClassDef(AliMpTrigger,1) // Slat for trigger
 };
index 836e137..72fad43 100644 (file)
 #include <sstream>
 #include <cassert>
 
+/// 
+/// \class AliMpTriggerReader
+/// Read trigger slat ASCII files
+/// Basically provides 2 static methods:
+/// - AliMpTrigger* ReadSlat()
+/// - AliMpPCB* ReadPCB()
+///
+/// \author Laurent Aphecetche
+
 TMap AliMpTriggerReader::fgPCBMap;
 TMap AliMpTriggerReader::fgLocalBoardMap;
 
-namespace
-{
-  const TString KEYWORD_LAYER("LAYER");
-  const TString KEYWORD_SCALE("SCALE");
-  const TString KEYWORD_PCB("PCB");  
-  const TString KEYWORD_FLIPX("FLIP_X");
-  const TString KEYWORD_FLIPY("FLIP_Y");
-}
+const TString AliMpTriggerReader::fgkKeywordLayer("LAYER");
+const TString AliMpTriggerReader::fgkKeywordScale("SCALE");
+const TString AliMpTriggerReader::fgkKeywordPcb("PCB");  
+const TString AliMpTriggerReader::fgkKeywordFlipX("FLIP_X");
+const TString AliMpTriggerReader::fgkKeywordFlipY("FLIP_Y");
 
 ClassImp(AliMpTriggerReader)
 
@@ -79,6 +85,9 @@ AliMpTriggerReader::BuildSlat(const char* slatName,
                               const TList& lines,
                               Double_t scale)
 {
+  // Construct a slat from the list of lines, taking into account
+  // the scale factor
+
   AliMpSlat* slat = new AliMpSlat(slatName, planeType);
     
   TIter it(&lines);
@@ -92,7 +101,7 @@ AliMpTriggerReader::BuildSlat(const char* slatName,
     
     TString& keyword = ((TObjString*)tokens->At(0))->String();
     
-    if ( keyword == KEYWORD_PCB )
+    if ( keyword == fgkKeywordPcb )
     {
       if ( tokens->GetEntriesFast() != 3 )
       {
@@ -167,13 +176,14 @@ AliMpTriggerReader::BuildSlat(const char* slatName,
 TString
 AliMpTriggerReader::GetBoardNameFromPCBLine(const TString& s)
 {
+  // Decode the string to get the board name
   TString boardName;
   
   TObjArray* tokens = s.Tokenize(' ');
   
   TString& keyword = ((TObjString*)tokens->At(0))->String();
 
-  if ( keyword == KEYWORD_PCB &&
+  if ( keyword == fgkKeywordPcb &&
        tokens->GetEntriesFast() == 3 )
   {
     boardName = ((TObjString*)tokens->At(2))->String();
@@ -195,13 +205,11 @@ AliMpTriggerReader::FlipLines(TList& lines, Bool_t flipX, Bool_t flipY,
   // from top to bottom
   //
  
-//  cout << "--- Original lines (flipX=" << flipX << " flipY=" << flipY
-//  << " srcLine=" << srcLine << " destLine=" << destLine << " : " << endl;
-//  lines.Print();
-//
+
   if ( flipX )
   {
-    // Simply swaps R(ight) and L(eft) in the first character of local board names
+    // Simply swaps R(ight) and L(eft) in the first character of 
+    // local board names
 
     TObjString* oline;
     TIter it(&lines);
@@ -221,9 +229,6 @@ AliMpTriggerReader::FlipLines(TList& lines, Bool_t flipX, Bool_t flipY,
     }
   }
   
-//  cout << "*** After flipX :" << endl;
-//  lines.Print();
-
   if ( flipY )
   {
     // Change line number, according to parameters srcLine and destLine
@@ -243,7 +248,7 @@ AliMpTriggerReader::FlipLines(TList& lines, Bool_t flipX, Bool_t flipY,
         
         TString& s = oline->String();
         
-        if ( !s.Contains(KEYWORD_PCB) ) 
+        if ( !s.Contains(fgkKeywordPcb) )
         {
           // Only consider PCB lines.
           continue;
@@ -309,15 +314,15 @@ AliMpTriggerReader::FlipLines(TList& lines, Bool_t flipX, Bool_t flipY,
       }    
     }
   }
-//  cout << "*** After flipY :" << endl;
-//  lines.Print();
 }
 
 //___________________________________________________________________________
 Int_t
 AliMpTriggerReader::IsLayerLine(const TString& sline)
 {
-  if ( sline.BeginsWith(KEYWORD_LAYER) )
+  // Whether sline contains LAYER keyword
+
+  if ( sline.BeginsWith(fgkKeywordLayer) )
   {
     return 1;
   }
@@ -333,15 +338,17 @@ AliMpTriggerReader::DecodeFlipLine(const TString& sline,
                                    TString& slatType2,
                                    Bool_t& flipX, Bool_t& flipY)
 {
+  // Decode a line containing FLIP_X and/or FLIP_Y keywords
+
   Ssiz_t blankPos = sline.First(' ');
   if ( blankPos < 0 ) return 0;
   
   TString keyword(sline(0,blankPos));
   
-  if ( keyword == KEYWORD_FLIPX ) 
+  if ( keyword == fgkKeywordFlipX )
   {
     flipX = kTRUE;
-  } else if ( keyword == KEYWORD_FLIPY ) 
+  } else if ( keyword == fgkKeywordFlipY )
   {
     flipY = kTRUE;
   }
@@ -359,10 +366,12 @@ Int_t
 AliMpTriggerReader::DecodeScaleLine(const TString& sline, 
                                     Double_t& scale, TString& slatType)
 {
-  if ( sline(0,KEYWORD_SCALE.Length()) == KEYWORD_SCALE )
+  // Decode sline containing SCALE keyword
+
+  if ( sline(0,fgkKeywordScale.Length()) == fgkKeywordScale )
   {
-    TString tmp(sline(KEYWORD_SCALE.Length()+1,
-                      sline.Length()-KEYWORD_SCALE.Length()-1));
+    TString tmp(sline(fgkKeywordScale.Length()+1,
+                      sline.Length()-fgkKeywordScale.Length()-1));
     Ssiz_t blankPos = tmp.First(' ');
     if ( blankPos < 0 )
     {
@@ -404,6 +413,8 @@ AliMpTriggerReader::GetLine(const TString& slatType)
 int
 AliMpTriggerReader::LocalBoardNumber(const char* localBoardName)
 {
+  // From local board name to local board number
+
   if ( !fgLocalBoardMap.GetSize() ) 
   {
     ReadLocalBoardMapping();
@@ -451,6 +462,11 @@ AliMpTriggerReader::ReadLines(const char* slatType,
                               Bool_t& flipX, Bool_t& flipY,
                               Int_t& srcLine, Int_t& destLine)
 {
+  //
+  // Reads in lines from file for a given slat
+  // Returns the list of lines (lines), together with some global
+  // information as the scale, whether to flip the lines, etc...
+  //
   AliDebugClass(1,Form("SlatType %s Scale %e FlipX %d FlipY %d srcLine %d"
                        " destLine %d\n",slatType,scale,flipX,flipY,
                        srcLine,destLine));
@@ -472,10 +488,11 @@ AliMpTriggerReader::ReadLines(const char* slatType,
     if ( sline.Length() == 0 || sline[0] == '#' ) continue;
     
     Bool_t isKeywordThere = 
-      sline.Contains(KEYWORD_PCB) || 
-      sline.Contains(KEYWORD_LAYER) ||
-      sline.Contains(KEYWORD_SCALE) || 
-      sline.Contains(KEYWORD_FLIPY) || sline.Contains(KEYWORD_FLIPX);
+      sline.Contains(fgkKeywordPcb) || 
+      sline.Contains(fgkKeywordLayer) ||
+      sline.Contains(fgkKeywordScale) || 
+      sline.Contains(fgkKeywordFlipX) || 
+      sline.Contains(fgkKeywordFlipY);
     
     if ( !isKeywordThere ) 
     {
@@ -493,7 +510,7 @@ AliMpTriggerReader::ReadLines(const char* slatType,
 
     if ( isScaleLine < 0 )
     {
-      AliFatalClass(Form("Syntax error near %s keyword\n",KEYWORD_SCALE.Data()));
+      AliFatalClass(Form("Syntax error near %s keyword\n",fgkKeywordScale.Data()));
     }
     else if ( isScaleLine > 0 && slatType2 != slatType )
     {
@@ -529,6 +546,8 @@ AliMpTriggerReader::ReadLines(const char* slatType,
 void
 AliMpTriggerReader::ReadLocalBoardMapping()
 {
+  // Reads the file that contains the mapping local board name <-> number
+
   TString filename(AliMpFiles::LocalTriggerBoardMapping());
   
   AliDebugClass(1,Form("Reading from %s\n",filename.Data()));
@@ -687,7 +706,7 @@ AliMpTriggerReader::ReadSlat(const char* slatType, AliMpPlaneType planeType)
   if ( !IsLayerLine(firstLine) ) 
   {
     std::ostringstream s;
-    s << KEYWORD_LAYER;
+    s << fgkKeywordLayer;
     lines.AddFirst(new TObjString(s.str().c_str()));
   }
   
@@ -748,5 +767,6 @@ AliMpTriggerReader::ReadSlat(const char* slatType, AliMpPlaneType planeType)
 void
 AliMpTriggerReader::Reset()
 {
+  // Resets the PCB internal map
   fgPCBMap.Delete();
 }
index 8507b77..d2bcd93 100644 (file)
@@ -7,8 +7,7 @@
 /// \ingroup trigger
 /// \class AliMpTriggerReader
 /// \brief Read trigger slat ASCII files
-/// 
-/// Author: Laurent Aphecetche
+/// \author Laurent Aphecetche
 
 #ifndef ALI_MP_TRIGGER_READER_H
 #define ALI_MP_TRIGGER_READER_H
@@ -50,7 +49,7 @@ class AliMpTriggerReader : public TObject
   
   static void Reset();
   
-//private:
+private:
     
   static AliMpSlat* BuildSlat(const char* slatName, 
                               AliMpPlaneType planeType,
@@ -67,7 +66,7 @@ class AliMpTriggerReader : public TObject
   static void FlipLines(TList& lines, Bool_t flipX, Bool_t flipY, 
                         Int_t srcLine, Int_t destLine);
   
-  static TString GetBoardNameFromPCBLine(const TString&);
+  static TString GetBoardNameFromPCBLine(const TString& sline);
   
   static Int_t GetLine(const TString& slatType);
   
@@ -90,6 +89,12 @@ private:
   static TMap fgPCBMap; //! map of TObjString to AliMpPCB*
   
   static TMap fgLocalBoardMap; //! map of TObjString to TObjString
+
+  static const TString fgkKeywordLayer; //! Keyword: LAYER
+  static const TString fgkKeywordScale; //! Keyword: SCALE
+  static const TString fgkKeywordPcb; //! Keyword : PCB
+  static const TString fgkKeywordFlipX; //! Keyword : FLIPX
+  static const TString fgkKeywordFlipY; //! Keyword : FLIPY
   
   ClassDef(AliMpTriggerReader,1) // Reader for trigger slats mapping files 
 };
index f81c2b6..31ee1c0 100644 (file)
 #include "AliMpSlatSegmentation.h"
 #include "AliMpTrigger.h"
 
+/// 
+/// \class AliMpTriggerSegmentation
+///
+/// Implementation of AliMpVSegmentation for trigger slats.
+///
+/// \todo Implement CreateIterator method, if needed.
+///
+/// \author Laurent Aphecetche
+
 ClassImp(AliMpTriggerSegmentation)
 
 //_____________________________________________________________________________
@@ -131,6 +140,7 @@ AliMpTriggerSegmentation::GetAllElectronicCardIDs(TArrayI& ecn) const
 const char*
 AliMpTriggerSegmentation::GetName() const
 {
+  // Name of that segmentation = TriggerSegmentation + slatName
   TString name("TriggerSegmentation");
   if ( fkSlat) 
   {
@@ -194,17 +204,17 @@ AliMpTriggerSegmentation::PadByLocation(const AliMpIntPair& location,
   {
     const AliMpSlat* slat = fkSlat->GetLayer(i);
     AliMpSlatSegmentation seg(slat);
-    AliMpPad p_i = seg.PadByLocation(location,kFALSE);
-    if ( p_i.IsValid() ) 
+    AliMpPad pi = seg.PadByLocation(location,kFALSE);
+    if ( pi.IsValid() ) 
     {
       if ( !pad.IsValid() )
       {
-        pad = AliMpPad(invloc,p_i.GetIndices(),p_i.Position(),p_i.Dimensions());
-        pad.AddLocation(p_i.GetLocation());
+        pad = AliMpPad(invloc,pi.GetIndices(),pi.Position(),pi.Dimensions());
+        pad.AddLocation(pi.GetLocation());
       }
       else
       {
-        pad.AddLocation(p_i.GetLocation());
+        pad.AddLocation(pi.GetLocation());
       }  
     }
   }
@@ -237,17 +247,17 @@ AliMpTriggerSegmentation::PadByIndices(const AliMpIntPair& indices,
   {
     const AliMpSlat* slat = fkSlat->GetLayer(i);
     AliMpSlatSegmentation seg(slat);
-    AliMpPad p_i = seg.PadByIndices(indices,kFALSE);
-    if ( p_i.IsValid() ) 
+    AliMpPad pi = seg.PadByIndices(indices,kFALSE);
+    if ( pi.IsValid() ) 
     {      
       if ( !pad.IsValid() )
       {
-        pad = AliMpPad(invloc,p_i.GetIndices(),p_i.Position(),p_i.Dimensions());
-        pad.AddLocation(p_i.GetLocation());
+        pad = AliMpPad(invloc,pi.GetIndices(),pi.Position(),pi.Dimensions());
+        pad.AddLocation(pi.GetLocation());
       }
       else
       {
-        pad.AddLocation(p_i.GetLocation());
+        pad.AddLocation(pi.GetLocation());
       }  
     }
   }
@@ -279,17 +289,17 @@ AliMpTriggerSegmentation::PadByPosition(const TVector2& position,
   {
     const AliMpSlat* slat = fkSlat->GetLayer(i);
     AliMpSlatSegmentation seg(slat);
-    AliMpPad p_i = seg.PadByPosition(position,kFALSE);
-    if ( p_i.IsValid() ) 
+    AliMpPad pi = seg.PadByPosition(position,kFALSE);
+    if ( pi.IsValid() ) 
     {
       if ( !pad.IsValid() )
       {
-        pad = AliMpPad(invloc,p_i.GetIndices(),p_i.Position(),p_i.Dimensions());
-        pad.AddLocation(p_i.GetLocation());
+        pad = AliMpPad(invloc,pi.GetIndices(),pi.Position(),pi.Dimensions());
+        pad.AddLocation(pi.GetLocation());
       }
       else
       {
-        pad.AddLocation(p_i.GetLocation());
+        pad.AddLocation(pi.GetLocation());
       }  
     }
   }
index 888d8f6..922a3eb 100644 (file)
@@ -7,8 +7,7 @@
 /// \ingroup trigger
 /// \class AliMpTriggerSegmentation
 /// \brief Implementation of AliMpVSegmentation for trigger slats.
-/// 
-/// Author: Laurent Aphecetche
+/// \author Laurent Aphecetche
 
 #ifndef ALI_MP_TRIGGER_SEGMENTATION_H
 #define ALI_MP_TRIGGER_SEGMENTATION_H