Added a lot of Doxygen documentation
authorcholm <cholm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 24 Mar 2006 01:47:25 +0000 (01:47 +0000)
committercholm <cholm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 24 Mar 2006 01:47:25 +0000 (01:47 +0000)
39 files changed:
FMD/AliFMD.cxx
FMD/AliFMD.h
FMD/AliFMD1.h
FMD/AliFMD2.cxx
FMD/AliFMD2.h
FMD/AliFMD3.h
FMD/AliFMDAlignFaker.cxx
FMD/AliFMDAlignFaker.h
FMD/AliFMDAltroIO.h
FMD/AliFMDAltroMapping.cxx
FMD/AliFMDAltroMapping.h
FMD/AliFMDBoolMap.h
FMD/AliFMDCalibFaker.h
FMD/AliFMDCalibGain.h
FMD/AliFMDCalibPedestal.h
FMD/AliFMDCalibSampleRate.h
FMD/AliFMDDetector.h
FMD/AliFMDDigit.h
FMD/AliFMDDigitizer.h
FMD/AliFMDDisplay.h
FMD/AliFMDEdepMap.h
FMD/AliFMDGeometry.h
FMD/AliFMDGeometryBuilder.cxx
FMD/AliFMDGeometryBuilder.h
FMD/AliFMDHit.h
FMD/AliFMDInput.h
FMD/AliFMDParameters.h
FMD/AliFMDRawReader.h
FMD/AliFMDRawWriter.cxx
FMD/AliFMDRawWriter.h
FMD/AliFMDRecPoint.h
FMD/AliFMDReconstructor.cxx
FMD/AliFMDReconstructor.h
FMD/AliFMDRing.h
FMD/AliFMDUShortMap.h
FMD/AliFMDv0.h
FMD/AliFMDv1.h
FMD/Doxyfile [new file with mode: 0644]
FMD/FMDsimLinkDef.h

index 7b598c2..be02c1b 100644 (file)
 //____________________________________________________________________
 //                                                                          
 // Forward Multiplicity Detector based on Silicon wafers. This class
-// contains the base procedures for the Forward Multiplicity detector
-// Detector consists of 3 sub-detectors FMD1, FMD2, and FMD3, each of
-// which has 1 or 2 rings of silicon sensors. 
+// is the driver for especially simulation. 
+//
+// The Forward Multiplicity Detector consists of 3 sub-detectors FMD1,
+// FMD2, and FMD3, each of which has 1 or 2 rings of silicon sensors. 
 //                                                       
 // This is the base class for all FMD manager classes. 
 //                    
 //  +--------+<>--+                            |  +------------------+
 //  | AliFMD |                                 +--| AliFMDSDigitizer |    
 //  +--------+<>--+                               +------------------+       
-//            1  |  +-----------------+ 
-//               +--| AliFMDSimulator |
-//                  +-----------------+
-//                            ^              
-//                            |
-//              +-------------+-------------+
-//              |                           |        
-//     +--------------------+   +-------------------+
-//     | AliFMDGeoSimulator |   | AliFMDG3Simulator | 
-//     +--------------------+   +-------------------+
-//               ^                        ^
-//               |                        |
-//  +-----------------------+   +----------------------+
-//  | AliFMDGeoOldSimulator |   | AliFMDG3OldSimulator |
-//  +-----------------------+   +----------------------+
-//      
+//            1  |  +---------------------+
+//               +--| AliFMDReconstructor |
+//                  +---------------------+
 //
 // *  AliFMD 
 //    This defines the interface for the various parts of AliROOT that
 //    simulator tasks are responsible to implment the geoemtry, and
 //    process hits. 
 //                                                                          
-// *  AliFMDGeoSimulator
-//    This is a concrete implementation of the AliFMDSimulator that
-//    uses the TGeo classes directly only. 
+// *  AliFMDReconstructor
+//    This is a concrete implementation of the AliReconstructor that
+//    reconstructs pseudo-inclusive-multiplicities from digits (raw or
+//    from simulation)
 //
-// *  AliFMDG3Simulator
-//    This is a concrete implementation of the AliFMDSimulator that
-//    uses the TVirtualMC interface with GEANT 3.21-like messages.
+// Calibration and geometry parameters are managed by separate
+// singleton managers.  These are AliFMDGeometry and
+// AliFMDParameters.  Please refer to these classes for more
+// information on these.
 //
 
 // These files are not in the same directory, so there's no reason to
 class AliFMDPoints : public AliPoints 
 {
 public:
+  /** Constructor 
+      @param hit   Hit to draw
+      @param color Color of hit */
   AliFMDPoints(AliFMDHit* hit, UInt_t color) 
     : AliPoints(1), fMarker(0)
   {
@@ -141,6 +134,7 @@ public:
     fP[1] = hit->Y();
     fP[2] = hit->Z();
   }
+  /** Destructor  */
   ~AliFMDPoints() 
   {
     // if (fMarker) delete  fMarker;
@@ -288,28 +282,9 @@ AliFMD::CreateGeometry()
 {
   //
   // Create the geometry of Forward Multiplicity Detector.  The actual
-  // construction of the geometry is delegated to the class AliFMDRing
-  // and AliFMDSubDetector and the relevant derived classes. 
-  //
-  // The flow of this member function is:
-  //
-  //   FOR rings fInner and fOuter DO  
-  //     AliFMDRing::Init();
-  //   END FOR
-  // 
-  //   Set up hybrud card support (leg) volume shapes  
-  // 
-  //   FOR rings fInner and fOuter DO  
-  //     AliFMDRing::SetupGeometry();
-  //   END FOR
-  // 
-  //   FOR subdetectors fFMD1, fFMD2, and fFMD3 DO 
-  //     AliFMDSubDetector::SetupGeomtry();
-  //   END FOR
-  // 
-  //   FOR subdetectors fFMD1, fFMD2, and fFMD3 DO 
-  //     AliFMDSubDetector::Geomtry();
-  //   END FOR
+  // construction of the geometry is delegated to the class
+  // AliFMDGeometryBuilder, invoked by the singleton manager
+  // AliFMDGeometry. 
   //
   AliFMDGeometry*  fmd = AliFMDGeometry::Instance();
   fmd->SetDetailed(fDetailed);
@@ -333,9 +308,13 @@ void AliFMD::CreateMaterials()
   //   FMD Air$        Air (Air in the FMD)
   //   FMD Plastic$    Plastic (Support legs for the hybrid cards)
   //
-  // Pointers to TGeoMedium objects are retrived from the TGeoManager
-  // singleton.  These pointers are later used when setting up the
-  // geometry 
+  // The geometry builder should really be the one that creates the
+  // materials, but the architecture of AliROOT makes that design
+  // akward.  What should happen, was that the AliFMDGeometryBuilder
+  // made the mediums, and that this class retrives pointers from the
+  // TGeoManager, and registers the mediums here.  Alas, it's not
+  // really that easy. 
+  //
   AliDebug(10, "\tCreating materials");
   // Get pointer to geometry singleton object. 
   AliFMDGeometry* geometry = AliFMDGeometry::Instance();
@@ -510,6 +489,8 @@ void AliFMD::CreateMaterials()
 void  
 AliFMD::Init()
 {
+  // Initialize the detector 
+  // 
   AliDebug(1, "Initialising FMD detector object");
   // AliFMDGeometry*  fmd = AliFMDGeometry::Instance();
   // fmd->InitTransformations();
@@ -519,6 +500,9 @@ AliFMD::Init()
 void
 AliFMD::FinishEvent()
 {
+  // Called at the end of the an event in simulations.  If the debug
+  // level is high enough, then the `bad' hits are printed.
+  // 
   if (AliLog::GetDebugLevel("FMD", "AliFMD") < 10) return;
   if (fBad && fBad->GetEntries() > 0) {
     AliWarning((Form("EndEvent", "got %d 'bad' hits", fBad->GetEntries())));
@@ -539,12 +523,8 @@ void
 AliFMD::BuildGeometry()
 {
   //
-  // Build simple ROOT TNode geometry for event display
-  //
-  // Build a simplified geometry of the FMD used for event display  
-  // 
-  // The actual building of the TNodes is done by
-  // AliFMDSubDetector::SimpleGeometry. 
+  // Build simple ROOT TNode geometry for event display. With the new
+  // geometry modeller, TGeoManager, this seems rather redundant. 
   AliDebug(10, "\tCreating a simplified geometry");
 
   AliFMDGeometry* fmd = AliFMDGeometry::Instance();
@@ -664,8 +644,12 @@ AliFMD::BuildGeometry()
 void 
 AliFMD::LoadPoints(Int_t /* track */) 
 {
-  //
-  // Store x, y, z of all hits in memory
+  // Store x, y, z of all hits in memory for display. 
+  // 
+  // Normally, the hits are drawn using TPolyMarker3D - however, that
+  // is not very useful for the FMD.  Therefor, this member function
+  // is overloaded to make TMarker3D, via the class AliFMDPoints.
+  // AliFMDPoints is a local class. 
   //
   if (!fHits) {
     AliError(Form("fHits == 0. Name is %s",GetName()));
@@ -737,36 +721,17 @@ AliFMD::LoadPoints(Int_t /* track */)
 void 
 AliFMD::DrawDetector()
 {
-  //
-  // Draw a shaded view of the Forward multiplicity detector
-  //
-  // DebugGuard guard("AliFMD::DrawDetector");
+  // Draw a shaded view of the Forward multiplicity detector.  This
+  // isn't really useful anymore. 
   AliDebug(10, "\tDraw detector");
-  
-#if 0
-  //Set ALIC mother transparent
-  gMC->Gsatt("ALIC","SEEN",0);
-  //
-  gMC->Gdopt("hide", "on");
-  gMC->Gdopt("shad", "on");
-  gMC->Gsatt("*", "fill", 7);
-  gMC->SetClipBox(".");
-  gMC->SetClipBox("*", 0, 1000, -1000, 1000, -1000, 1000);
-  gMC->DefaultRange();
-  gMC->Gdraw("alic", 40, 30, 0, 12, 12, .055, .055);
-  gMC->Gdhead(1111, "Forward Multiplicity Detector");
-  gMC->Gdman(16, 10, "MAN");
-  gMC->Gdopt("hide", "off");
-#endif
 }
 
 //____________________________________________________________________
 Int_t 
 AliFMD::DistanceToPrimitive(Int_t, Int_t)
 {
-  //
   // Calculate the distance from the mouse to the FMD on the screen
-  // Dummy routine
+  // Dummy routine.
   //
   return 9999;
 }
@@ -830,8 +795,6 @@ AliFMD::SetTreeAddress()
   }
 }
 
-
-
 //____________________________________________________________________
 void 
 AliFMD::SetHitsAddressBranch(TBranch *b)
@@ -900,7 +863,6 @@ AliFMD::AddHitByFields(Int_t    track,
                       Float_t  l, 
                       Bool_t   stop)
 {
-  //
   // Add a hit to the list
   //
   // Parameters:
@@ -1066,8 +1028,7 @@ AliFMD::AddSDigitByFields(UShort_t detector,
 void 
 AliFMD::ResetSDigits()
 {
-  //
-  // Reset number of digits and the digits array for this detector
+  // Reset number of digits and the digits array for this detector. 
   //
   fNsdigits   = 0;
   if (fSDigits) fSDigits->Clear();
index b3d3899..6334183 100644 (file)
@@ -7,6 +7,136 @@
  *
  * See cxx source for full Copyright notice                               
  */
+/** @mainpage ALICE FMD Off-line code 
+
+    @section intro Introduction:
+
+    This file contains a short overview of the FMD code.   It is by no 
+    means authoritative  - only the code is good for that.  However,
+    I'll try to explain things a bit here. 
+
+    @section structure Structure:
+
+    There are 4 libraries build for the FMD.  These are 
+
+    - libFMDbase: This contains the basic stuff, like data classes and
+      managers.
+    - libFMDsim: This contains code used by the simulation only.  That
+      includes the detector class AliFMD and it's derivatives.  It
+      also contains the code for building the geometry, as well as the
+      digitisers and raw data writer.
+    - libFMDrec: Code needed for the reconstruction.  This include the
+      reconstruction code itself, as well as a raw data reader.
+    - libFMDutil: This is a special library that contains various
+      utility classes for the FMD expert/developer/tester.  It
+      includes code to read all data produced by the FMD, a simple
+      event display, and code to make fake calibration and alignment
+      data.  This library is @e not loaded by aliroot
+      automatically. The user has to load it herself:
+      @code 
+      gSystem->Load("libFMDutil.so");
+      @endcode
+    The content of these libraries is detailed more below. 
+
+    @subsection base libFMDbase:
+
+    This currently (18th or March 2006) contains the classes 
+
+    - AliFMDBaseDigit, AliFMDDigit, AliFMDSDigit: Base class for
+      digits, real digits, and summable digits.  The are all data
+      classes that holds the ADC value(s) for a single strip.
+    - AliFMDBoolMap: A map of booleans, one for each strip.
+    - AliFMDUShortMap: A map of unsigned short integers, one for each
+      strip.
+    - AliFMDDetector, AliFMD1, AliFMD2, AliFMD3: 3 classes that holds
+      the parameters for each of the 3 FMD sub-detectors.  These
+      derive from AliFMDDetector, and are managed by AliFMDGeometry.
+      Each of these also contains the translation from sensor
+      reference frame to global reference frame.
+    - AliFMDRing: Parameters for the FMD rings (inner and outer type).
+      These are managed by AliFMDGeometry.
+    - AliFMDGeometry: Manager of FMD geometry data. All code queries
+      this manager for geometry parameters, so that the data is always
+      consistent.  
+    - AliFMDParameters: Manager of FMD parameters, like calibration
+      parameters.  This class fetches data from CDB if necessary.
+      All code queries this manager for parameters, so that the data
+      is always consistent. 
+    - AliFMDCalibPedestal, AliFMDCalibGain, AliFMDCalibSampleRate,
+      AliFMDAltroMapping: Containers of calibration parameters.  These
+      correspond to the pedestal and its width, the gain of each
+      strip, the oversampling rate used in read-out, and the map from
+      hardware address to detector.
+    - AliFMDAltroIO, AliFMDAltroReader, AliFMDAltroWriter: Low-level
+      classes to do input/output on ALTRO formated buffers. 
+
+  
+
+    @subsection sim libFMDsim:
+
+    This currently (18th or March 2006) contains the classes 
+
+    - AliFMDEdepMap: Cache of energy deposited and total number of
+      hits for each strip.  The digitiser AliFMDDigitizer uses this to
+      store simulation data before making digits.
+    - AliFMDHit: A hit in the FMD active elements, as described by the
+      simulation back-end during transport.
+    - AliFMD, AliFMDv0, AliFMDv1: Simulation drivers for the FMD.
+      AliFMD is the base class. AliFMDv0 corresponds to a simulation
+      where no hits are created, but the material distribution is
+      right.  AliFMDv1 is like AliFMDv0, except that hits are
+      produced.
+    - AliFMDGeometryBuilder: Build the FMD geometry in terms of TGeo
+      objects.  The information for building the geometry is retrieved
+      from AliFMDGeometry.
+    - AliFMDBaseDigitizer, AliFMDDigitizer, AliFMDSDigitizer: Base
+      class for the digitisers.  AliFMDDigitizer makes `real' digits
+      (AliFMDDigit) from hits, and AliFMDSDigitizer makes summable
+      digits from hits.
+    - AliFMDRawWriter: Writes a pseudo raw data file from the digits
+      created by the digitisers.  It uses the AliFMDAltroMapping from
+      AliFMDParameters to make the mapping from detector coordinates
+      to hardware addresses.
+
+    @subsection rec libFMDrec:
+
+    This currently (18th or March 2006) contains the classes 
+
+    - AliFMDReconstructor: Reconstruct (in a naiive way) the charged
+      particle multiplicity in the FMD strips.  This also writes an
+      AliESDFMD object to the ESD files (that class is in libESD).
+
+    - AliFMDRecPoint: Reconstructed point in the FMD.  These objects
+      are made AliFMDReconstructor. 
+
+    - AliFMDRawReader: Classes to read raw data files. 
+
+    @subsection util libFMDutil:
+
+    This currently (18th or March 2006) contains the classes 
+
+    - AliFMDInput, AliFMDInputHits, AliFMDInputDigits,
+      AliFMDInputSDigits, AliFMDInputRecPoints: Base class, and
+      concrete classes to read in FMD generated data.  These provide a
+      simple and unified way of getting the data.  Hooks are defined
+      to process hits, tracks, digits, and reconstructed points, as
+      well as geometry and ESD data.   See for example the scripts
+      @c DrawHits.C, @c DrawHitsDigits.C, @c DrawHitsRecs.C, @c
+      DrawDigitsRecs.C in the @c FMD/scripts sub-directory.
+
+    - AliFMDDisplay: Simple event display for FMD data, including
+      hits, digits, reconstructed points and ESD data. 
+
+    - AliFMDCalibFaker, AliFMDAlignFaker: Classes to write fake (or
+      dummy) calibration and alignment         data.  These derive from
+      TTask.  
+
+    @section authors Authors:
+
+    - Alla Maevskaya           <Alla.Maevskaia@cern.ch>        
+    - Christian Holm Christensen       <cholm@nbi.dk>
+*/
+/** @defgroup FMD_sim Simulation */
 
 //____________________________________________________________________
 //
 //  provides concrete implementations. 
 //  This class is sooooo crowded
 //
-#ifndef ALIDETECTOR_H 
+#ifndef ALIDETECTOR_H  
 # include <AliDetector.h>
 #endif
 #ifndef ROOT_TBranch
@@ -29,39 +159,192 @@ class AliDigitizer;
 class AliFMDHit;
 
 //____________________________________________________________________
+/** @class AliFMD AliFMD.h <FMD/AliFMD.h>
+    @brief Forward Multiplicity Detector based on Silicon wafers. 
+    This class is the driver for especially simulation. 
+
+    The Forward Multiplicity Detector consists of 3 sub-detectors FMD1,
+    FMD2, and FMD3, each of which has 1 or 2 rings of silicon sensors. 
+                                                          
+    This is the base class for all FMD manager classes. 
+                       
+    The actual code is done by various separate classes.   Below is
+    diagram showing the relationship between the various FMD classes
+    that handles the simulation
+
+    @verbatim
+          +----------+   +----------+   
+          | AliFMDv1 |   | AliFMDv0 |   
+          +----------+   +----------+   
+               |              |                    +-----------------+
+          +----+--------------+                 +--| AliFMDDigitizer |
+          |                                     |  +-----------------+
+          |           +---------------------+   |
+          |        +--| AliFMDBaseDigitizer |<--+
+          V     1  |  +---------------------+   |
+     +--------+<>--+                            |  +------------------+
+     | AliFMD |                                 +--| AliFMDSDigitizer |    
+     +--------+<>--+                               +------------------+       
+              1  |  +---------------------+
+                 +--| AliFMDReconstructor |
+                    +---------------------+
+    @endverbatim
+                    
+    -  AliFMD 
+       This defines the interface for the various parts of AliROOT that
+       uses the FMD, like AliFMDSimulator, AliFMDDigitizer, 
+       AliFMDReconstructor, and so on. 
+    -  AliFMDv0
+       This is a concrete implementation of the AliFMD interface. 
+       It is the responsibility of this class to create the FMD
+       geometry.
+    -  AliFMDv1 
+       This is a concrete implementation of the AliFMD interface. 
+       It is the responsibility of this class to create the FMD
+       geometry, process hits in the FMD, and serve hits and digits to
+       the various clients. 
+    -  AliFMDSimulator
+       This is the base class for the FMD simulation tasks.   The
+       simulator tasks are responsible to implment the geoemtry, and
+       process hits. 
+    -  AliFMDReconstructor
+       This is a concrete implementation of the AliReconstructor that
+       reconstructs pseudo-inclusive-multiplicities from digits (raw or
+       from simulation)
+
+    Calibration and geometry parameters are managed by separate
+    singleton managers.  These are AliFMDGeometry and
+    AliFMDParameters.  Please refer to these classes for more
+    information on these.    
+ */
 class AliFMD : public AliDetector 
 {
 public:
+  /** Default constructor.  Do not use. */
   AliFMD();
+  /** Normal constructor 
+      @param name  Name of object.
+      @param title Title of object. */
   AliFMD(const char *name, const char *title);
+  /** Copy constructor 
+      @param other Object to copy from */
   AliFMD(const AliFMD& other);
+  /** Destructor */
   virtual ~AliFMD(); 
+  /** Assignment operator 
+      @param other Object to assign from
+      @return Reference to this object  */
   AliFMD& operator=(const AliFMD& other);
-  // Use old implementation
-  void UseOld(Bool_t use=kTRUE) { fUseOld = use;  }
-  void UseAssembly(Bool_t use=kTRUE) { fUseAssembly = use; }
+  /** Wheter to make a detailed geometry
+      @param use If true, make detailed geometry  */
   void UseDetailed(Bool_t use=kTRUE) { fDetailed = use; }
   
-  // GEometry ANd Tracking (GEANT :-)
+  /** @{*/
+  /** @name GEometry ANd Tracking (GEANT :-) */
+  /** Define the geometry.  This is done by asking the manager
+      AliFMDGeometry to construct the geometry.  This in turn calls
+      AliFMDGeometryBuilder.   */
   virtual void   CreateGeometry();
+  /** Create the tracking mediums used by the FMD.  This associates
+      the tracking mediums defined with the FMD in the
+      TVirtualMCApplication (AliMC). 
+      
+      The defined mediums are 
+      -        @c FMD @c Si$   Silicon (active medium in sensors)
+      -        @c FMD @c C$    Carbon fibre (support cone for FMD3 and vacuum pipe)
+      -        @c FMD @c Al$   Aluminium (honeycomb support plates)
+      -        @c FMD @c PCB$  Printed Circuit Board (FEE board with VA1_3)
+      -        @c FMD @c Chip$ Electronics chips (currently not used)
+      -        @c FMD @c Air$  Air (Air in the FMD)
+      -        @c FMD @c Plastic$ Plastic (Support legs for the hybrid cards)
+  */
   virtual void   CreateMaterials(); 
+  /** Initialize this detector */
   virtual void   Init();
+  /** This member function is called when ever a track deposites
+      energy (or similar) in an FMD tracking medium.  In this base
+      class this member function is pure abstract.   In concrete
+      sub-classes, the member function may make hits or other
+      stuff. */ 
   virtual void   StepManager() = 0;
+  /** Called at the end of each simulation event.  If the debug level
+      is high enough a list of @e bad hits is printed. */
   virtual void   FinishEvent();
+  /** @}*/
   
-  // Graphics and event display 
+  /** @{*/
+  /** @name Graphics and event display */
+  /** Build simple ROOT TNode geometry for event display. With the new
+      geometry modeller, TGeoManager, this seems rather redundant. */
   virtual        void   BuildGeometry();
+  /** Draw a shaded view of the Forward multiplicity detector.  This 
+      isn't really useful anymore. */
   virtual        void   DrawDetector();
+  /** Calculate the distance from the mouse to the FMD on the screen
+      Dummy routine */
   virtual        Int_t  DistanceToPrimitive(Int_t px, Int_t py);
+  /** Store x, y, z of all hits in memory for display. 
+      Normally, the hits are drawn using TPolyMarker3D - however, that
+      is not very useful for the FMD.  Therefor, this member function
+      is overloaded to make TMarker3D, via the class AliFMDPoints.
+      AliFMDPoints is a local class. 
+      @param track the track number to load the hits for */
   virtual        void   LoadPoints(Int_t track);
+  /** @}*/
   
-  // Hit and digit management 
+  /** @{ */
+  /** @name Hit and digit management */
+  /* Create Tree branches for the FMD.
+     @param opt  One of 
+     - @c H Make a branch of TClonesArray of AliFMDHit's
+     - @c D Make a branch of TClonesArray of AliFMDDigit's
+     - @c S Make a branch of TClonesArray of AliFMDSDigit's */
   virtual void          MakeBranch(Option_t *opt=" ");
+  /** Set the TClonesArray to read hits into.
+      @param b The branch to containn the hits */
   virtual void          SetHitsAddressBranch(TBranch *b);
+  /** Set branch address for the Hits, Digits, and SDigits Tree. */
   virtual void          SetTreeAddress();
+  /** Get the array of summable digits
+      @return summable digits */
   virtual TClonesArray* SDigits() { return fSDigits; }        
+  /** Reset the array of summable digits */
   virtual void          ResetSDigits();
+  /** Add a hit to the hits tree 
+      @param  track  Track #
+      @param  ivol Volume parameters, interpreted as 
+      - ivol[0]  [UShort_t ] Detector # 
+      - ivol[1]         [Char_t   ] Ring ID 
+      - ivol[2]         [UShort_t ] Sector #
+      - ivol[3]         [UShort_t ] Strip # 
+      @param hits Hit information 
+      - hits[0]         [Float_t  ] Track's X-coordinate at hit 
+      - hits[1]         [Float_t  ] Track's Y-coordinate at hit
+      - hits[3]  [Float_t  ] Track's Z-coordinate at hit
+      - hits[4]  [Float_t  ] X-component of track's momentum            
+      - hits[5]         [Float_t  ] Y-component of track's momentum             
+      - hits[6]         [Float_t  ] Z-component of track's momentum            
+      - hits[7]         [Float_t  ] Energy deposited by track                  
+      - hits[8]         [Int_t    ] Track's particle Id # 
+      - hits[9]         [Float_t  ] Time when the track hit */
   virtual void          AddHit(Int_t track, Int_t *vol, Float_t *hits);
+  /** Add a hit to the list
+      @param track     Track #
+      @param detector  Detector # (1, 2, or 3)                      
+      @param ring      Ring ID ('I' or 'O')
+      @param sector    Sector # (For inner/outer rings: 0-19/0-39)
+      @param strip     Strip # (For inner/outer rings: 0-511/0-255)
+      @param x        Track's X-coordinate at hit
+      @param y        Track's Y-coordinate at hit
+      @param z        Track's Z-coordinate at hit
+      @param px               X-component of track's momentum 
+      @param py               Y-component of track's momentum
+      @param pz               Z-component of track's momentum
+      @param edep      Energy deposited by track
+      @param pdg       Track's particle Id #
+      @param t        Time when the track hit 
+      @param l         Track length through the material. 
+      @param stop      Whether track was stopped or disappeared */
   virtual AliFMDHit*    AddHitByFields(Int_t    track, 
                                       UShort_t detector, 
                                       Char_t   ring, 
@@ -78,7 +361,25 @@ public:
                                       Float_t  t=0, 
                                       Float_t  len=0, 
                                       Bool_t   stopped=kFALSE);
+  /** Add a digit to the Digit tree 
+      @param digits
+      - digits[0]  [UShort_t] Detector #
+      - digits[1]  [Char_t]   Ring ID
+      - digits[2]  [UShort_t] Sector #
+      - digits[3]  [UShort_t] Strip #
+      - digits[4]  [UShort_t] ADC Count 
+      - digits[5]  [Short_t]  ADC Count, -1 if not used
+      - digits[6]  [Short_t]  ADC Count, -1 if not used 
+      @param notused Not used */
   virtual        void   AddDigit(Int_t *digits, Int_t* notused=0);
+  /** add a real digit
+      @param detector  Detector # (1, 2, or 3)                      
+      @param ring        Ring ID ('I' or 'O')
+      @param sector      Sector # (For inner/outer rings: 0-19/0-39)
+      @param strip       Strip # (For inner/outer rings: 0-511/0-255)
+      @param count1    ADC count (a 10-bit word)
+      @param count2    ADC count (a 10-bit word), or -1 if not used
+      @param count3    ADC count (a 10-bit word), or -1 if not used */
   virtual        void   AddDigitByFields(UShort_t detector=0, 
                                         Char_t   ring='\0', 
                                         UShort_t sector=0, 
@@ -86,7 +387,23 @@ public:
                                         UShort_t count1=0, 
                                         Short_t  count2=-1, 
                                         Short_t  count3=-1);
+  /** Add a digit to the Digit tree 
+      @param digits
+      - digits[0]  [UShort_t] Detector #
+      - digits[1]  [Char_t]   Ring ID
+      - digits[2]  [UShort_t] Sector #
+      - digits[3]  [UShort_t] Strip #
+      - digits[4]  [UShort_t] ADC Count 
+      - digits[5]  [Short_t]  ADC Count, -1 if not used
+      - digits[6]  [Short_t]  ADC Count, -1 if not used  */
   virtual        void   AddSDigit(Int_t *digits);
+  /** add a summable digit - as coming from data
+      @param detector  Detector # (1, 2, or 3)                      
+      @param ring        Ring ID ('I' or 'O')
+      @param sector      Sector # (For inner/outer rings: 0-19/0-39)
+      @param strip       Strip # (For inner/outer rings: 0-511/0-255)
+      @param count1    ADC count (a 10-bit word)
+      @param count2    ADC count (a 10-bit word), or -1 if not used */
   virtual        void   AddSDigitByFields(UShort_t detector=0, 
                                          Char_t   ring='\0', 
                                          UShort_t sector=0, 
@@ -95,20 +412,46 @@ public:
                                          UShort_t count1=0, 
                                          Short_t  count2=-1, 
                                          Short_t  count3=-1);
+  /** @}*/
 
-  // Digitisation
+  /** @{ */
+  /** @name Digitisation */
+  /** Create a digitizer object
+      @param manager Digitization manager
+      @return a newly allocated AliFMDDigitizer */
   virtual AliDigitizer* CreateDigitizer(AliRunDigitizer* manager) const;
+  /** Create AliFMDDigit's from AliFMDHit's.  This is done by creating
+      an AliFMDDigitizer object, and executing it.  */
   virtual        void   Hits2Digits();
+  /** Create AliFMDSDigit's from AliFMDHit's.  This is done by creating
+      an AliFMDSDigitizer object, and executing it.  */
   virtual        void   Hits2SDigits();
+  /** @}*/
 
-  // Raw data 
+  /** @{ */
+  /** @name Raw data */
+  /** Turn digits into raw data. This uses the class AliFMDRawWriter
+      to do the job.   Please refer to that class for more
+      information. */
   virtual        void   Digits2Raw();
+  /** @}*/
 
-  // Utility
+  /** @{ */
+  /** @name Utility */
+  /** Browse this object 
+      @param b Browser to show this object in */
   void   Browse(TBrowser* b);
+  /** @}*/
 protected:
+  /** Initialize hit array if not already done, and return pointert. 
+      @return Hit array */
   TClonesArray*      HitsArray();
+  /** Initialize digit array if not already done, and return pointert. 
+      @return Digit array */
   TClonesArray*      DigitsArray();
+  /** Initialize summable digit array if not already done, and return
+      pointert.  
+      @return Summable digit array */
   TClonesArray*      SDigitsArray();
 
   TClonesArray*      fSDigits;              // Summable digits
index 79a798c..9c8f633 100644 (file)
@@ -9,16 +9,20 @@
 class AliFMDRing;
 
 //__________________________________________________________________
-// Geometry description and parameters of the FMD1
-// detector. 
-//
-// The FMD1 only has one ring.     
-//
+/** @class AliFMD1 AliFMD1.h <FMD/AliFMD1.h>
+    Geometry description and parameters of the FMD1 detector. 
+    The FMD1 has only one ring.     
+    @ingroup FMD_base
+*/
 class AliFMD1 : public AliFMDDetector 
 {
 public:
+  /** Constructor 
+      @param inner Pointer to inner ring description  */
   AliFMD1(AliFMDRing* inner);
+  /** Destructor */
   virtual ~AliFMD1() {}
+  /** Initialize */
   virtual void Init() { AliFMDDetector::Init(); }
   ClassDef(AliFMD1,1)
 };
index dcf5967..6f355dc 100644 (file)
@@ -37,6 +37,7 @@ ClassImp(AliFMD2)
 AliFMD2::AliFMD2(AliFMDRing* inner, AliFMDRing* outer) 
   : AliFMDDetector(2, inner, outer)
 {
+  // Constructor 
   SetInnerZ(83.4);
   SetOuterZ(75.2);
 }
@@ -46,6 +47,7 @@ AliFMD2::AliFMD2(AliFMDRing* inner, AliFMDRing* outer)
 void
 AliFMD2::Init() 
 {
+  // Initialize 
   AliFMDDetector::Init();
   SetInnerHoneyHighR(GetOuterHoneyHighR());
 }
index 138c26b..bccb449 100644 (file)
@@ -8,13 +8,18 @@
 # include "AliFMDDetector.h"
 #endif
 
-// Geometry description and parameters of the FMD2
-// detector. 
-// This has two rings. 
+//____________________________________________________________________
+/** @class AliFMD2 AliFMD2.h <FMD/AliFMD2.h>
+    Geometry parameters of the FMD2 detector. This has two rings. 
+    @ingroup FMD_base
+*/
 class AliFMD2 : public AliFMDDetector 
 {
 protected: 
 public: 
+  /** Constructor 
+      @param inner Pointer to inner ring description 
+      @param outer Pointer to outer ring description */
   AliFMD2(AliFMDRing* inner, AliFMDRing* outer);
   /** Initialize the geometry */
   virtual void Init();
index e229257..ee3da7e 100644 (file)
@@ -8,14 +8,20 @@
 # include "AliFMDDetector.h"
 #endif
 
-// Geometry description and parameters of the FMD3 detector.
-// FMD3 has a fairly complicated support structure. 
-// The cone also supports the beam-pipe.
-//
+/** @class AliFMD3 AliFMD3.h <FMD/AliFMD3.h> 
+    Geometry parameters of the FMD3 detector. FMD3 has a fairly
+    complicated support structure.  The cone also supports the
+    beam-pipe. 
+    @ingroup FMD_base
+*/
 class AliFMD3 : public AliFMDDetector 
 {
 public: 
+  /** Constructor 
+      @param inner Pointer to inner ring description 
+      @param outer Pointer to outer ring description */
   AliFMD3(AliFMDRing* inner, AliFMDRing* outer);
+  /** Destructor */
   virtual ~AliFMD3(){}
 
   /** Initialize the geometry */
index ec63bfc..49822e9 100644 (file)
 //                                                                          
 // Forward Multiplicity Detector based on Silicon wafers. 
 //
-// This task creates fake alignrations. Which alignration, depends on
+// This task creates fake alignment. Which alignment, depends on
 // the bit mask passed to the constructor, or added by `AddAlign'.
 //
-// The default is to write all alignration parameters to a local
+// The default is to write all alignment parameters to a local
 // storage `local://cdb' which is a directory in the current
 // directory. 
 //                                                       
index dfd1ea0..e9ffe8e 100644 (file)
 class TClonesArray;
 class TString;
 
+/** @class AliFMDAlignFaker 
+    This task creates fake alignment. Which alignment, depends on the
+    bit mask passed to the constructor, or added by `AddAlign'.
+
+    The default is to write all alignment parameters to a local
+    storage @c local://cdb which is a directory in the current
+    directory.
+    @ingroup FMD_util
+*/
 class AliFMDAlignFaker : public TTask
 {
 public:
+  /** What to make alignments for */
   enum EWhat {
+    /** MAke alignment for sensors */
     kSensors =  1, 
+    /** Make alignment for half-rings */
     kHalves
   };
   enum {
+    /** All types of alignment */
     kAll             = (1<<kHalves|1<<kSensors)
   };
+  /** Constructor 
+      @param mask Bit mask of what to make alignments for 
+      @param geo  File to read geometry from, if needed
+      @param loc  Where to store the result */
   AliFMDAlignFaker(Int_t mask=kAll, 
                   const char* geo="geometry.root",
                   const char* loc="local://cdb");
+  /** Destructor */
   virtual ~AliFMDAlignFaker() {}
+  /** Add something to make alignment for 
+      @param w Bit of alignment mask */
   void AddAlign(EWhat w) { SETBIT(fMask, w); }
+  /** Remove something to make alignment for 
+      @param w Bit of alignment mask */
   void RemoveAlign(EWhat w) { CLRBIT(fMask, w); }
+  /** Set alignment select mask 
+      @param mask Bit mask */
   void SetAlign(Int_t mask) { fMask = mask; }
+  /** Set the displacement (translation) of sensors.  The displacement
+      is selected random uniformly between the corresponding minimum
+      and maximum. 
+      @param x1 Minimum X displacement (in centimeters)
+      @param y1 Minimum Y displacement (in centimeters)
+      @param z1 Minimum Z displacement (in centimeters)
+      @param x2 Maximum X displacement (in centimeters)
+      @param y2 Maximum Y displacement (in centimeters)
+      @param z2 Maximum Z displacement (in centimeters) */
   void SetSensorDisplacement(Double_t x1=0,   Double_t y1=0,   Double_t z1=0,
                             Double_t x2=.01, Double_t y2=.01, Double_t z2=0);
+  /** Set the rotation of sensors.  The displacement is selected
+      random uniformly between the corresponding minimum and maximum.
+      @param x1 Minimum X rotation (in degrees)
+      @param y1 Minimum Y rotation (in degrees)
+      @param z1 Minimum Z rotation (in degrees)
+      @param x2 Maximum X rotation (in degrees)
+      @param y2 Maximum Y rotation (in degrees)
+      @param z2 Maximum Z rotation (in degrees) */
   void SetSensorRotation(Double_t x1=0,  Double_t y1=0,  Double_t z1=0,
                         Double_t x2=.5, Double_t y2=.5, Double_t z2=.5);
+  /** Set the displacement (translation) of half-rings.  The
+      displacement is selected random uniformly between the
+      corresponding minimum and maximum.
+      @param x1 Minimum X displacement
+      @param y1 Minimum Y displacement
+      @param z1 Minimum Z displacement
+      @param x2 Maximum X displacement
+      @param y2 Maximum Y displacement
+      @param z2 Maximum Z displacement */
   void SetHalfDisplacement(Double_t x1=0,   Double_t y1=0,   Double_t z1=0,
                           Double_t x2=.05, Double_t y2=.05, Double_t z2=.05);
+  /** Set the rotation of half-rings.  The displacement is selected
+      random uniformly between the corresponding minimum and maximum.
+      @param x1 Minimum X rotation (in degrees)
+      @param y1 Minimum Y rotation (in degrees)
+      @param z1 Minimum Z rotation (in degrees)
+      @param x2 Maximum X rotation (in degrees)
+      @param y2 Maximum Y rotation (in degrees)
+      @param z2 Maximum Z rotation (in degrees) */
   void SetHalfRotation(Double_t x1=0, Double_t y1=0, Double_t z1=0,
                       Double_t x2=0, Double_t y2=0, Double_t z2=0);
+  /** Set the output file name.  Should be a valid CDB URL.
+      @param file CDB URL */
   void SetOutput(const char* file) { SetTitle(file); }
+  /** Set the file to read the geometry from. 
+      @param file File name */
   void SetGeometryFile(const char* file) { SetName(file); }
+  /** Make the alignment objects. 
+      @param option Not used. */
   void Exec(Option_t* option="");
 protected:
+  /** Make the alignment object for a path
+      @param path   Node path.
+      @param volID  Volume identifier 
+      @param transX Translation in X
+      @param transY Translation in Y
+      @param transZ Translation in Z
+      @param rotX   Rotation around X axis
+      @param rotY   Rotation around Y axis
+      @param rotZ   Rotation around Z axis
+      @return @c true on success */
   Bool_t MakeAlign(const TString& path, Int_t volID, 
                   Double_t transX, Double_t transY, Double_t transZ,
                   Double_t rotX, Double_t rotY, Double_t rotZ);
+  /** Align a sensor 
+      @param path of a sensor 
+      @param id Volume id */
   Bool_t MakeAlignSensor(const TString& path, Int_t id);
+  /** Align a half-ring
+      @param path of a sensor 
+      @param id Volume id */
   Bool_t MakeAlignHalf(const TString& path, Int_t id);
+  /** Write to CDB */
   void   WriteToCDB();
+  /** Write to file */
   void   WriteToFile();
   
   Long_t        fMask;            // What to write 
-  TVector3      fSensorTransMin;
-  TVector3      fSensorTransMax;
-  TVector3      fSensorRotMin;
-  TVector3      fSensorRotMax;
-  TVector3      fHalfTransMin;
-  TVector3      fHalfTransMax;
-  TVector3      fHalfRotMin;
-  TVector3      fHalfRotMax;
-  Int_t         fRunMin;
-  Int_t         fRunMax;
-  TClonesArray* fArray;
+  TVector3      fSensorTransMin;  // Minimum translations of a sensor
+  TVector3      fSensorTransMax;  // Maximum translations of a sensor
+  TVector3      fSensorRotMin;    // Minimum rotation of a sensor
+  TVector3      fSensorRotMax;    // Maximum rotation of a sensor
+  TVector3      fHalfTransMin;    // Minimum translations of a half-ring
+  TVector3      fHalfTransMax;   // Maximum translations of a half-ring
+  TVector3      fHalfRotMin;     // Minimum rotation of a half-ring    
+  TVector3      fHalfRotMax;     // Maximum rotation of a half-ring 
+  Int_t         fRunMin;          // Run validity start 
+  Int_t         fRunMax;          // Run validity end
+  TClonesArray* fArray;           // Cache
   
   ClassDef(AliFMDAlignFaker,0)
 };
index bd57928..9db9b04 100644 (file)
 #include <TObject.h>
 
 //____________________________________________________________________
+/** @class AliFMDAltroIO AliFMDAltroIO.h <FMD/AliFMDAltroIO.h>
+    @brief Base class for ALTRO Input/Output classes.
+    @ingroup FMD_base
+ */
 class AliFMDAltroIO  : public TObject
 {
- public:
+public:
   /** Type of 40 bit words (signed) */
   typedef long long W40_t;
   /** Type of 10 bit words (signed) */
@@ -70,6 +74,16 @@ protected:
 };
 
 //____________________________________________________________________
+/** @class AliFMDAltroReader AliFMDAltroIO.h <FMD/AliFMDAltroIO.h>
+    @brief Class to read ALTRO formated raw data from an AliRawReader
+    object. 
+    @code 
+    AliRawReader*    reader    = new AliRawReaderFile(0);
+    AliFMDRawReader* fmdReader = new AliFMDRawReader(reader);
+    TClonesArray*    array     = new TClonesArray("AliFMDDigit");
+    fmdReader->ReadAdcs(array);
+    @endcode 
+*/
 class AliFMDAltroReader : public AliFMDAltroIO
 {
 public:
@@ -152,6 +166,15 @@ protected:
 };
 
 //____________________________________________________________________
+/** @class AliFMDAltroWriter AliFMDAltroIO.h <FMD/AliFMDAltroIO.h>
+    @brief Class to write ALTRO formated raw data from an array of
+    AliFMDDigit objects.
+    @code 
+    AliFMDRawWriter* fmdWriter = new AliFMDRawWriter(0);
+    TClonesArray*    array     = fmd->DigitArray();
+    fmdWriter->WriteDigits(array);
+    @endcode 
+ */
 class AliFMDAltroWriter : public AliFMDAltroIO
 {
 public:
index cbdf971..d474d3c 100644 (file)
@@ -31,20 +31,25 @@ ClassImp(AliFMDAltroMapping)
 
 //_____________________________________________________________________________
 AliFMDAltroMapping::AliFMDAltroMapping()
-{}
+{
+  // Constructor 
+}
 
 
 //_____________________________________________________________________________
 Bool_t
 AliFMDAltroMapping::ReadMapping()
 {
+  // Read map from file - not used
   return kTRUE;
 }
 
 //_____________________________________________________________________________
 void
 AliFMDAltroMapping::DeleteMappingArrays()
-{}
+{
+  // Clear map in memory 
+}
 
 //____________________________________________________________________
 Bool_t 
index 0ad1ddf..94bc99d 100644 (file)
 # include <TArrayI.h>
 #endif
 
+//____________________________________________________________________
+/** @class AliFMDAltroMapping 
+    @brief Class that encodes a map to/from ALTRO hardware address to
+    FMD detector coordinates.  
+    
+    The hardware address consist of a DDL number and 12bits of ALTRO
+    addresses.  The ALTRO address are formatted as follows. 
+    @verbatim 
+    12              7         4            0
+    |---------------|---------|------------|
+    | Board #       | ALTRO # | Channel #  |
+    +---------------+---------+------------+
+    @endverbatim 
+
+    @ingroup FMD_base
+ */
 class AliFMDAltroMapping : public AliAltroMapping
 {
 public:
+  /** Constructor */
   AliFMDAltroMapping();
+  /** Map a hardware address into a detector index. 
+      @param ddl    Hardware DDL number 
+      @param hwaddr Hardware address.  
+      @param det    On return, the detector #
+      @param ring   On return, the ring ID
+      @param sec    On return, the sector #
+      @param str    On return, the strip #
+      @return @c true on success, false otherwise */
   Bool_t Hardware2Detector(UInt_t    ddl, UInt_t    hwaddr, 
                           UShort_t& det, Char_t&   ring, 
                           UShort_t& sec, UShort_t& str) const;
+  /** Map a detector index into a hardware address. 
+      @param det    The detector #
+      @param ring   The ring ID
+      @param sec    The sector #
+      @param str    The strip #
+      @param ddl    On return, hardware DDL number 
+      @param hwaddr On return, hardware address.  
+      @return @c true on success, false otherwise */
   Bool_t Detector2Hardware(UShort_t  det, Char_t    ring, 
                           UShort_t  sec, UShort_t  str,
                           UInt_t&   ddl, UInt_t&   hwaddr) const;
+  /** Here to take care of a a misspelling in base class 
+      @param sector Sector number
+      @param str    Strip number
+      @param ring   Ring ID as an integer 
+      @return Hardware address */
   Int_t  GetHWAdress(Int_t sector, Int_t str, Int_t ring) const
   {
     return GetHWAddress(sector, str, ring);
   }
+  /** convert a partial detector index into a hardware address
+      @param sector Sector number
+      @param str    Strip number
+      @param ring   Ring ID as an integer 
+      @return Hardware address */
   Int_t  GetHWAddress(Int_t sector, Int_t str, Int_t ring) const;
+  /** Get the pad-row (or sector) corresponding to hardware address
+      @param hwaddr hardware address
+      @return Sector number */
   Int_t  GetPadRow(Int_t hwaddr) const;
+  /** Get the pad (or strip) corresponding to hardware address
+      @param hwaddr hardware address
+      @return Strip number */
   Int_t  GetPad(Int_t hwaddr) const;
+  /** Get the sector (or ring) corresponding to hardware address
+      @param hwaddr hardware address
+      @return Ring ID as an integer */
   Int_t  GetSector(Int_t hwaddr) const;
 protected:
+  /** Read map from file - not used 
+      @return @c true on success */
   virtual Bool_t ReadMapping();
+  /** Clear map in memory */
   virtual void   DeleteMappingArrays();
   
   ClassDef(AliFMDAltroMapping, 1) // Read raw FMD Altro data 
index 4227dd0..2ceb3d1 100644 (file)
 # include <AliFMDMap.h>
 #endif
 
+/** @class AliFMDBoolMap 
+    @brief MAp of per strip boolean values. 
+    @ingroup FMD_base
+ */
 class AliFMDBoolMap : public AliFMDMap
 {
 public:
+  /** Copy constructor 
+      @param other Object to copy from. */
   AliFMDBoolMap(const AliFMDBoolMap& other);
+  /** Constructor 
+      @param maxDet  Number of detectors (3)
+      @param maxRing Number of rings (2)
+      @param maxSec  Number of sectors (40)
+      @param maxStr  Number of strips (20) */
   AliFMDBoolMap(size_t maxDet  = kMaxDetectors,
                size_t maxRing = kMaxRings,
                size_t maxSec  = kMaxSectors,
                size_t maxStr  = kMaxStrips);
+  /** Destructor */
   virtual ~AliFMDBoolMap() { delete [] fData; }
+  /** Assignment operator 
+      @param other Object to assign from 
+      @return reference to this object.  */
   AliFMDBoolMap& operator=(const AliFMDBoolMap& other);
+  /** Reset to value 
+      @param v Value to reset from */
   virtual void Reset(const Bool_t& v=Bool_t());
+  /** Access operator 
+      @param det   Detector 
+      @param ring  Ring 
+      @param sec   Sector  
+      @param str   Strip
+      @return  reference value stored for the strip */
   virtual Bool_t& operator()(UShort_t det,
                             Char_t   ring,
                             UShort_t sec,
                             UShort_t str);
+  /** Access operator 
+      @param det   Detector 
+      @param ring  Ring 
+      @param sec   Sector  
+      @param str   Strip
+      @return  value stored for the strip */
   virtual const Bool_t& operator()(UShort_t det,
                                   Char_t   ring,
                                   UShort_t sec,
index 389b1f5..1f8ab42 100644 (file)
 #endif
 #include "AliFMDParameters.h"     // ALIFMDPARAMETERS_H
 
+/** @class AliFMDCalibFaker
+    @brief Class to make fake calibration parameters. 
+    @code 
+    AliFMDCalibFaker f(0);
+    f.AddCalib(kPedestal);
+    f.AddCalib(kGain);
+    f.Exec();
+    @endcode 
+    @ingroup FMD_util
+ */
 class AliFMDCalibFaker : public TTask
 {
 public:
+  /** What to make */
   enum EWhat {
+    /** Zero suppressio threshold */
     kZeroSuppression =  1, 
+    /** Sample rate */
     kSampleRate,
+    /** Pedestals */
     kPedestal,
+    /** Gain */
     kPulseGain,
+    /** Dead map */
     kDeadMap,
+    /** Hardware map */
     kAltroMap
   };
   enum {
+    /** All parameters */
     kAll             = (1<<kZeroSuppression|1<<kSampleRate|1<<kPedestal|
                        1<<kPulseGain|1<<kDeadMap|1<<kAltroMap)
   };
+  /** Constructor 
+      @param mask Bit mask of what to make 
+      @param loc  Where to store the results */
   AliFMDCalibFaker(Int_t mask=kAll, const char* loc="local://cdb");
+  /** Destructor */
   virtual ~AliFMDCalibFaker() {}
+  /** Add a parameter to output 
+      @param w Bit of parameter */
   void AddCalib(EWhat w) { SETBIT(fMask, w); }
+  /** Remove a parameter from output 
+      @param w Bit of parameter */
   void RemoveCalib(EWhat w) { SETBIT(fMask, w); }
+  /** Set the bit mask of what to make 
+      @param mask bit mask */
   void SetCalib(Int_t mask) { fMask = mask; }
+  /** Set seed for random gain.  The gain is distributed flatly from
+      90 to 110 percent of the seed. 
+      @param g Seed for gain */
   void SetGainSeed(Float_t g) { fGain = g; }
+  /** Set the threshold factor.  The actual threshold is the gain seed
+      times the factor 
+      @param t Factor */
   void SetThresholdFactor(Float_t t) { fThresholdFactor = t; }
+  /** Set the limits for the random pedestal.  The pedestal values are
+      randomly distributed in the range 
+      @param min Minimum of range 
+      @param max Maximum of range */
   void SetPedestalRange(Float_t min, Float_t max) 
   {
     fPedestalMin = min;
     fPedestalMax = (max < min ? min : max);
   }
+  /** Set run validty range 
+      @param min Minimum run number
+      @param max Maximum run number */
   void SetRunRange(Int_t min, Int_t max) 
   {
     fRunMin = min;
     fRunMax = (max < min ? min : max);
   }
+  /** Set the likelyness that a strip is dead. 
+      @param chance Chance of dead channel. */
   void SetDeadChance(Float_t chance) { fDeadChance = chance; }
+  /** Set Sample rate 
+      @param rate Rate */
   void SetRate(UShort_t rate) { fRate = rate; }
+  /** Set the zero suppression threshold 
+      @param t Threshold (in ADC counts) */
   void SetZeroThreshold(UShort_t t) { fZeroThreshold = t; }
+  /** Set the default output storage.  It must be a CDB URL. 
+      @param url CDB URL. */
   void SetDefaultStorage(const char* url) { SetTitle(url); }
+  /** Make the fake calibration parameters 
+      @param option Not used */
   void Exec(Option_t* option="");
 protected:
+  /** Make zero suppression parameters 
+      @return Map of zero suppression */
   virtual AliFMDCalibZeroSuppression* MakeZeroSuppression();
+  /** Make sample rate parameters 
+      @return Map of sample rate */
   virtual AliFMDCalibSampleRate*      MakeSampleRate();
+  /** Make pedestal parameters 
+      @return Map of pedestal */
   virtual AliFMDCalibPedestal*        MakePedestal();
+  /** Make gain parameters 
+      @return Map of gain */
   virtual AliFMDCalibGain*            MakePulseGain();
+  /** Make dead channel parameters 
+      @return Map of dead channel */
   virtual AliFMDCalibDeadMap*         MakeDeadMap();
+  /** Make a hardware map
+      @return hardware map */
   virtual AliFMDAltroMapping*         MakeAltroMap();
 
   Long_t   fMask;            // What to write 
index e0c030d..76cdaaa 100644 (file)
@@ -9,23 +9,45 @@
 # include <AliFMDFloatMap.h>
 #endif
 //____________________________________________________________________
-//
-// Gain value and width for each strip in the FMD
-//
+/** Gain value and width for each strip in the FMD 
+    @ingroup FMD_base
+*/
 class AliFMDCalibGain : public TObject 
 {
 public:
+  /** Constructor */
   AliFMDCalibGain();
+  /** Destructor */
   ~AliFMDCalibGain() {}
+  /** Copy constructor 
+      @param o object to copy from */
   AliFMDCalibGain(const AliFMDCalibGain& o);
+  /** Assignment operator 
+      @param o Object to assign from */
   AliFMDCalibGain& operator=(const AliFMDCalibGain& o);
+  /** Set the values for a strip. 
+      @param det  Detector 
+      @param ring Ring 
+      @param sec  Sector 
+      @param str  Strip
+      @param val  Value of gain */
   void Set(UShort_t det, Char_t ring, UShort_t sec, UShort_t str, Float_t val);
+  /** Set the global threshold 
+      @param thres Threshold */
   void Set(Float_t thres) { fThreshold = thres; }
+  /** Get gain for a strip. 
+      @param det  Detector 
+      @param ring Ring 
+      @param sec  Sector 
+      @param str  Strip
+      @param val  Value of gain 
+      @return Gain for strip */
   Float_t Value(UShort_t det, Char_t ring, UShort_t sec, UShort_t str);
+  /** @return threshold */
   Float_t Threshold() const { return fThreshold; }
 private:
-  AliFMDFloatMap fValue;
-  Float_t        fThreshold;
+  AliFMDFloatMap fValue;       // Map
+  Float_t        fThreshold;   // Global threshold
   ClassDef(AliFMDCalibGain, 1) // Gain data for the FMD 
 };
 
index 202adff..1a43502 100644 (file)
@@ -9,23 +9,51 @@
 # include <AliFMDFloatMap.h>
 #endif
 //____________________________________________________________________
-//
-// Pedestal value and width for each strip in the FMD
-//
+/** Pedestal value and width for each strip in the FMD 
+    @ingroup FMD_base
+*/
 class AliFMDCalibPedestal : public TObject 
 {
 public:
+  /** CTOR */
   AliFMDCalibPedestal();
+  /** DTOR */
   ~AliFMDCalibPedestal() {}
+  /** Copy ctor 
+      @param o Object to copy from  */
   AliFMDCalibPedestal(const AliFMDCalibPedestal& o);
+  /** Assignment 
+      @param o Object to assign from
+      @return Reference to this object   */
   AliFMDCalibPedestal& operator=(const AliFMDCalibPedestal& o);
+  /** Set the values for a strip. 
+      @param det  Detector 
+      @param ring Ring 
+      @param sec  Sector 
+      @param str  Strip
+      @param ped  Value of pedestal 
+      @param pedW Width of pedestal */
   void Set(UShort_t det, Char_t ring, UShort_t sec, UShort_t str, 
           Float_t ped, Float_t pedW);
+  /** Get pedestal for a strip. 
+      @param det  Detector 
+      @param ring Ring 
+      @param sec  Sector 
+      @param str  Strip
+      @param val  Value of gain 
+      @return Pedestal for strip */  
   Float_t Value(UShort_t det, Char_t ring, UShort_t sec, UShort_t str);
+  /** Get pedestal width for a strip. 
+      @param det  Detector 
+      @param ring Ring 
+      @param sec  Sector 
+      @param str  Strip
+      @param val  Value of gain 
+      @return Pedestal width for strip */  
   Float_t Width(UShort_t det, Char_t ring, UShort_t sec, UShort_t str);
 private:
-  AliFMDFloatMap fValue;
-  AliFMDFloatMap fWidth;
+  AliFMDFloatMap fValue; /** Pedestal */
+  AliFMDFloatMap fWidth; /** Pedestal width */
   ClassDef(AliFMDCalibPedestal, 1) // Pedestal data for the FMD 
 };
 
index 0d12399..7e2ac7b 100644 (file)
 # include <TArrayI.h>
 #endif
 //____________________________________________________________________
-//
-// Gain value and width for each strip in the FMD
-//
+/** Gain value and width for each strip in the FMD
+    @ingroup FMD_base
+*/
 class AliFMDCalibSampleRate : public TObject
 {
 public:
+  /** CTOR */
   AliFMDCalibSampleRate();
+  /** Copy CTOR
+      @param o Object to copy from  */
   AliFMDCalibSampleRate(const AliFMDCalibSampleRate& o);
+  /** Assignment operator 
+      @param o Object to assign from 
+      @return Reference to assign from  */
   AliFMDCalibSampleRate& operator=(const AliFMDCalibSampleRate& o);
+  /** Set sample for a DDL
+      @param ddl   DDL (detector)
+      @param rate  Sample rate */
   void Set(UShort_t ddl, UShort_t rate);
+  /** Get sample rate for a detector 
+      @param ddl Detector (DDL) identifier
+      @return Sample rate */
   UShort_t Rate(UShort_t ddl) const;
 protected:
   TArrayI fRates; // Sample rates 
index 4891666..90a2f6f 100644 (file)
 class AliFMDRing;
 class TGeoMatrix;
 
-
+/** @defgroup FMD_base Basic classes */
 //__________________________________________________________________
 /** Base class for the geometry description and parameters of the FMD
     sub detectors FMD1, FMD2, and FMD3.
 
     This class hold common parameters of the specific FMD detectors.
+    @ingroup FMD_base
 */
 class AliFMDDetector : public TNamed 
 {
 public:
+  /** Constructor
+      @param id    Detector number
+      @param inner Pointer to inner ring geometry
+      @param outer Pointer to inner outer geometry
+      @return  */
   AliFMDDetector(Int_t id, AliFMDRing* inner, AliFMDRing* outer);
+  /** Copy CTOR 
+      @param other Object to copy from. */
   AliFMDDetector(const AliFMDDetector& other);
+  /** Assignment operator 
+      @param other Object to assign from
+      @return reference to this object  */
   AliFMDDetector& operator=(const AliFMDDetector& other);
   virtual ~AliFMDDetector() {}
   /** Initialize the geometry */
@@ -82,12 +93,46 @@ public:
       @return Z position of ring or 0 on failure */
   Double_t GetRingZ(Char_t id) const;
   
+  /** Translate detector coordinates (detector, ring, sector, strip)
+      to spatial coordinates (x, y, z) in the master reference frame
+      of ALICE.  The member function uses the transformations
+      previously obtained from the TGeoManager.
+      @param ring   Ring id
+      @param sector Sector number
+      @param strip  Strip number
+      @param x      On return, X coordinate 
+      @param y      On return, Y coordinate 
+      @param z      On return, Z coordinate  */
   void Detector2XYZ(Char_t ring, UShort_t sector, UShort_t strip, 
                    Double_t& x, Double_t& y, Double_t& z) const;
+  /** Translate spatial coordinates (x,y,z) in the master reference
+      frame of ALICE to the detector coordinates (detector, ring,
+      sector, strip).  Note, that if this method is to be used in
+      reconstruction or the like, then the input z-coordinate should
+      be corrected for the events interactions points z-coordinate,
+      like  
+      @code 
+      geom->XYZ2Detector(x,y,z-ipz,d,r,s,t);
+      @endverbatim
+      @param x       X coordinate
+      @param y              Y coordinate
+      @param z              Z coordinate
+      @param ring    On return, Ring id                   
+      @param sector  On return, Sector number     
+      @param strip   On return, Strip number      
+      @return @c  false of (@a x, @a y, @a z) is not within this
+      detector.  */
   Bool_t XYZ2Detector(Double_t x, Double_t y, Double_t z, 
                      Char_t& ring, UShort_t& sector, UShort_t& strip) const;
 protected:
+  /** Check if we have all transformations for a ring 
+      @param ring Ring to check for 
+      @return @c true if we got all transforms  */
   Bool_t        HasAllTransforms(Char_t ring) const;
+  /** Get transformation matrix for a sector in a ring 
+      @param ring   Ring id
+      @param sector Sector numberr 
+      @return Matrix on success, 0 otherwise */
   TGeoMatrix*   FindTransform(Char_t ring, UShort_t sector) const;
   Int_t                fId;                    // Detector number
   Double_t     fInnerZ;                // Position of outer ring along z
@@ -100,8 +145,8 @@ protected:
   Double_t     fOuterHoneyHighR;       // Outer radius of outer honeycomb
   AliFMDRing*  fInner;                 // Pointer to inner ring information
   AliFMDRing*  fOuter;                 // Pointer to outer ring information
-  TObjArray*    fInnerTransforms;       // List of inner module <-> global
-  TObjArray*    fOuterTransforms;       // List of outer module <-> global
+  TObjArray*    fInnerTransforms;       // List of inner module global
+  TObjArray*    fOuterTransforms;       // List of outer module global
 
   ClassDef(AliFMDDetector, 1); // 
 };
index d40c3a5..e077937 100644 (file)
 #endif
 
 //____________________________________________________________________
+/** @class AliFMDBaseDigit AliFMDDigit.h <FMD/AliFMDDigit.h>
+    @brief base class for digits 
+    @ingroup FMD_base
+ */
 class AliFMDBaseDigit : public TObject 
 {
 public: 
+  /** CTOR */
   AliFMDBaseDigit();
+  /** Constrctor 
+      @param detector Detector 
+      @param ring     Ring
+      @param sector   Sector
+      @param strip    Strip */
   AliFMDBaseDigit(UShort_t detector, 
                  Char_t   ring='\0', 
                  UShort_t sector=0, 
                  UShort_t strip=0);
+  /** DTOR */
   virtual ~AliFMDBaseDigit() {}
+  /** @return Detector # */
   UShort_t     Detector()         const { return fDetector; }
+  /** @return Ring ID */
   Char_t       Ring()             const { return fRing;     }
+  /** @return sector # */
   UShort_t     Sector()                   const { return fSector;   }
+  /** @return strip # */
   UShort_t     Strip()            const { return fStrip;    }
+  /** Print information 
+      @param opt Not used */
   virtual void Print(Option_t* opt="") const;
+  /** @return Name */
   const char*  GetName() const;
 protected:
   UShort_t fDetector;  // (Sub) Detector # (1,2, or 3)
@@ -36,10 +54,23 @@ protected:
 };
 
 //____________________________________________________________________
+/** @class AliFMDDigit AliFMDDigit.h <FMD/AliFMDDigit.h>
+    @brief class for digits 
+    @ingroup FMD_base
+ */
 class AliFMDDigit : public AliFMDBaseDigit
 {
 public:
+  /** CTOR */
   AliFMDDigit();
+  /** Constrctor 
+      @param detector Detector 
+      @param ring     Ring
+      @param sector   Sector
+      @param strip    Strip 
+      @param count1   ADC (first sample)
+      @param count2   ADC (second sample, or -1 if not used)
+      @param count3   ADC (third sample, or -1 if not used) */
   AliFMDDigit(UShort_t detector, 
              Char_t   ring='\0', 
              UShort_t sector=0, 
@@ -47,12 +78,20 @@ public:
              UShort_t count=0, 
              Short_t  count2=-1, 
              Short_t  count3=-1);
+  /** DTOR */
   virtual ~AliFMDDigit() {}
+  /** @return ADC count (first sample) */
   UShort_t Count1()                const { return fCount1;   }
+  /** @return ADC count (second sample, or -1 if not used) */
   Short_t  Count2()                const { return fCount2;   }
+  /** @return ADC count (third sample, or -1 if not used) */
   Short_t  Count3()                const { return fCount3;   }
+  /** @return Canonical ADC counts */
   UShort_t Counts()                const;
+  /** Print info 
+      @param opt Not used */
   void     Print(Option_t* opt="") const;
+  /** @return Title */
   const char* GetTitle() const;
 protected:
   UShort_t fCount1;     // Digital signal 
@@ -70,10 +109,23 @@ AliFMDDigit::Counts() const
 }
 
 //____________________________________________________________________
+/** @class AliFMDSDigit AliFMDDigit.h <FMD/AliFMDDigit.h>
+    @brief class for summable digits 
+    @ingroup FMD_base
+ */
 class AliFMDSDigit : public AliFMDBaseDigit
 {
 public:
+  /** CTOR */
   AliFMDSDigit();
+  /** Constrctor 
+      @param detector Detector 
+      @param ring     Ring
+      @param sector   Sector
+      @param strip    Strip 
+      @param count1   ADC (first sample)
+      @param count2   ADC (second sample, or -1 if not used)
+      @param count3   ADC (third sample, or -1 if not used) */
   AliFMDSDigit(UShort_t detector, 
               Char_t   ring='\0', 
               UShort_t sector=0, 
@@ -82,12 +134,20 @@ public:
               UShort_t count=0, 
               Short_t  count2=-1, 
               Short_t  count3=-1);
+  /** DTOR */
   virtual ~AliFMDSDigit() {}
+  /** @return ADC count (first sample) */
   UShort_t Count1()                const { return fCount1;   }
+  /** @return ADC count (second sample, or -1 if not used) */
   Short_t  Count2()                const { return fCount2;   }
+  /** @return ADC count (third sample, or -1 if not used) */
   Short_t  Count3()                const { return fCount3;   }
-  Float_t  Edep()                  const { return fEdep;     }
+  /** @return Canonical ADC counts */
   UShort_t Counts()                const;
+  /** @return Energy deposited */
+  Float_t  Edep()                  const { return fEdep;     }
+  /** Print info 
+      @param opt Not used */
   void     Print(Option_t* opt="") const;
 protected:
   Float_t  fEdep;       // Energy deposited 
index c15839c..092360c 100644 (file)
@@ -30,23 +30,162 @@ class AliFMDDigit;
 
 
 //====================================================================
+/** @class AliFMDBaseDigitizer AliFMDDigitizer.h <FMD/AliFMDDigitizer>
+    @brief Base class for digitizers.
+
+    This class contains the procedures simulation ADC  signal for the
+    Forward Multiplicity detector  : Hits->Digits and Hits->SDigits
+    
+    Digits consists of
+    - Detector #
+    - Ring ID                                             
+    - Sector #     
+    - Strip #
+    - ADC count in this channel                                  
+
+    Summable digits consists of        
+    - Detector #
+    - Ring ID                                             
+    - Sector #     
+    - Strip #
+    - Total energy deposited in the strip
+    - ADC count in this channel                                  
+
+    As the Digits and SDigits have so much in common, the classes
+    AliFMDDigitizer and AliFMDSDigitizer are implemented via a base
+    class AliFMDBaseDigitizer.
+    @verbatim
+                    +---------------------+
+                    | AliFMDBaseDigitizer |
+                    +---------------------+
+                              ^
+                              |
+                   +----------+---------+
+                   |                    |
+         +-----------------+     +------------------+
+         | AliFMDDigitizer |   | AliFMDSDigitizer |
+         +-----------------+   +------------------+
+    @endverbatim
+    These classes uses parameters fetched from the AliFMDParameters
+    manager. 
+
+    The shaping function of the VA1 is generally given by 
+    @f[
+    f(x) = A(1 - \exp(-Bx))
+    @f]
+    where A is the total charge collected in the pre-amp., and B is a
+    paramter that depends on the shaping time of the VA1 circut.
+    
+    When simulating the shaping function of the VA1 pre-amp. chip, we
+    have to take into account, that the shaping function depends on
+    the previous value of read from the pre-amp.  
+
+    That results in the following algorithm:
+    @code
+    last = 0;
+    for (i=0; i < n_pre_amp_charge; i++) {
+      charge = GetCharge(i);
+      if (last < charge) 
+        f(t) = (charge - last) * (1 - exp(-B * t)) + last
+      else
+        f(t) = (last - charge) * exp(-B * t) + charge)
+      for (j=0; j < sample_rate; j++) 
+        adc[j] = f(i / (# samples))
+      last = charge
+    }
+    @endcode
+    Here, the first loop is over all charges collected by the VA1
+    chip, and the @c sample_rate is how many times the ALTRO ADC
+    samples each of the 128  charges from the pre-amp. 
+
+    The @c charge is the total charge @f$ Q@f$ collected by the VA1
+    pre-amplifier for a strip.   @f$ Q@f$ is then given by 
+    @f[
+    Q = \frac{E}{e}\frac{S}{r}
+    @f]
+    where @f$ E@f$ is the total energy deposited in a silicon strip, 
+    @f$ R@f$ is the dynamic range of the VA1 pre-amp, @f$ e@f$ is the 
+    energy deposited by a single MIP, and @f$ S@f$ ALTRO channel size
+    in each time step.
+
+    The energy deposited per MIP is given by 
+    @f$ 
+    e = M \rho w 
+    @f$
+    where @f$ M@f$ is the universal number 
+    @f$ 1.664 \mbox{keV}\mbox{cm}^{2}\mbox{g}^{-1}@f$, @f$ \rho@f$ is
+    the density of silicon, and @f$ w@f$ is the depth of the silicon
+    sensor.  
+
+    The final ADC count is given by 
+    @f[
+    C' = C + P
+    @f]
+    where @f$ P@f$ is the (randomized) pedestal.
+
+    This class uses the class template AliFMDEdepMap to make an
+    internal cache of the energy deposted of the hits.  The class
+    template is instantasized as 
+
+    The first member of the values is the summed energy deposition in a
+    given strip, while the second member of the values is the number of
+    hits in a given strip.  Using the second member, it's possible to
+    do some checks on just how many times a strip got hit, and what
+    kind of error we get in our reconstructed hits.  Note, that this
+    information is currently not written to the digits tree.  I think a
+    QA (Quality Assurance) digit tree is better suited for that task.
+    However, the information is there to be used in the future. 
+    @ingroup FMD_sim
+ */
 class AliFMDBaseDigitizer : public AliDigitizer 
 {
 public:
+  /** CTOR */
   AliFMDBaseDigitizer();
+  /** Normal CTOR 
+      @param manager Manager of digitization */
   AliFMDBaseDigitizer(AliRunDigitizer * manager);
+  /** Normal ctor 
+      @param name Name 
+      @param title Title */
   AliFMDBaseDigitizer(const Char_t* name, const Char_t* title);
+  /** DTOR */
   virtual ~AliFMDBaseDigitizer();
    
-  // Do the main work
+  /** Initialize */
   virtual Bool_t Init();
 
-  // Extra member functions 
-  void     SetShapingTime(Float_t t=10) { fShapingTime = t;  }  
+  /** The response shape of the VA1 shaping circuit is approximently
+      given by 
+      @f[
+      f(x) = A(1 - \exp(-Bx))
+      @f]
+      where @f$ A@f$ is the total charge collected by the pre-amp.,
+      and @f$ B@f$ is parameter that depends on the shaping time of
+      the @b VA1 pre-amp.  This member function sets the parameter @f$
+      B@f$ 
+      @param B */
+  void     SetShapingTime(Float_t B=10) { fShapingTime = B;  }  
+  /** @return Get the shaping time */
   Float_t  GetShapingTime()      const { return fShapingTime; }
 protected:
+  /** Sum energy deposited contributions from each hit in a cache
+      @param fmd Pointer to detector */
   virtual void     SumContributions(AliFMD* fmd);
+  /** For the stored energy contributions in the cache, convert the
+      energy signal to ADC counts, and store the created digit in  
+      the digits array
+      @param fmd Pointer to detector */
   virtual void     DigitizeHits(AliFMD* fmd) const;
+  /** Convert the total energy deposited to a (set of) ADC count(s).
+      See also the class description for more details. 
+      @param edep     Total energy deposited in detector
+      @param last     Last charge collected in previous VA1 channnel
+      @param detector Detector #
+      @param ring     Ring ID
+      @param sector   Sector #
+      @param strip    Strip #
+      @param counts   Array holding the counts on return */
   virtual void     ConvertToCount(Float_t   edep, 
                                  Float_t   last,
                                  UShort_t  detector, 
@@ -54,11 +193,19 @@ protected:
                                  UShort_t  sector, 
                                  UShort_t  strip,
                                  TArrayI&  counts) const;
+  /** Make a pedestal 
+      @param detector Detector #
+      @param ring     Ring ID
+      @param sector   Sector #
+      @param strip    Strip #
+      @return Pedestal value */
   virtual UShort_t MakePedestal(UShort_t  detector, 
                                Char_t    ring, 
                                UShort_t  sector, 
                                UShort_t  strip) const;
+  /** Add noise to each sample */
   virtual void     AddNoise(TArrayI&) const {}
+  /** Add a digit to output */
   virtual void     AddDigit(AliFMD*  /* fmd      */,
                            UShort_t /* detector */, 
                            Char_t   /* ring     */,
@@ -73,21 +220,46 @@ protected:
   AliFMDEdepMap fEdep;             // Cache of Energy from hits 
   Float_t       fShapingTime;      // Shaping profile parameter
   
+  /** Copy CTOR 
+      @param o object to copy from  */
   AliFMDBaseDigitizer(const AliFMDBaseDigitizer& o) 
     : AliDigitizer(o) {}
+  /** Assignment operator
+      @return Reference to this object */
   AliFMDBaseDigitizer& operator=(const AliFMDBaseDigitizer&) { return *this; }
   ClassDef(AliFMDBaseDigitizer,2) // Base class for FMD digitizers
 };
 
 //====================================================================
+/** @class AliFMDDigitizer
+    @brief Concrete digitizer to make digits from hits.  See also
+    AliFMDBaseDigitizer documentation.  
+    @ingroup FMD_sim
+ */
 class AliFMDDigitizer : public AliFMDBaseDigitizer 
 {
 public:
+  /** CTOR */
   AliFMDDigitizer();
+  /** CTOR 
+      @param manager Manager of digitization */
   AliFMDDigitizer(AliRunDigitizer * manager);
+  /** DTOR */
   virtual ~AliFMDDigitizer() {}
+  /** Do everything
+      @param option Not used */
   virtual void  Exec(Option_t* option=0);
 protected:
+  /** Add a digit to output.
+      @param fmd      Pointer to detector object
+      @param detector Detector #
+      @param ring     Ring ID
+      @param sector   Sector number
+      @param strip    Strip number
+      @param edep     Energy deposited (not used)
+      @param count1   ADC count 1
+      @param count2   ADC count 2 (-1 if not used)
+      @param count3   ADC count 3 (-1 if not used) */
   virtual void     AddDigit(AliFMD*  fmd,
                            UShort_t detector, 
                            Char_t   ring,
@@ -97,10 +269,20 @@ protected:
                            UShort_t count1, 
                            Short_t  count2, 
                            Short_t  count3) const;
+  /** MAke a pedestal
+      @param detector Detector #
+      @param ring     Ring ID
+      @param sector   Sector number
+      @param strip    Strip number
+      @return Random noise */
   virtual UShort_t MakePedestal(UShort_t  detector, 
                                Char_t    ring, 
                                UShort_t  sector, 
                                UShort_t  strip) const;
+  /** Check that digit data is consistent
+      @param digit   Digit
+      @param nhits   Number of hits
+      @param counts  ADC counts */
   virtual void     CheckDigit(AliFMDDigit*    digit,
                              UShort_t        nhits,
                              const TArrayI&  counts);
@@ -108,14 +290,36 @@ protected:
 };
 
 //====================================================================
+/** @class AliFMDSDigitizer AliFMDDigitizer.h <FMD/AliFMDDigitizer.h>
+    @brief Concrete implementation to make summable digits. 
+    See also class documentation of AliFMDBaseDigitizer 
+    @ingroup FMD_sim
+ */
 class AliFMDSDigitizer : public AliFMDBaseDigitizer 
 {
 public:
+  /** CTOR */
   AliFMDSDigitizer();
+  /** CTOR
+      @param headerFile Where to write headings
+      @param sdigFile   Where to write digits. */
   AliFMDSDigitizer(const Char_t* headerFile, const Char_t* sdigFile="");
+  /** DTOR */
   virtual ~AliFMDSDigitizer();
+  /** Do it all 
+      @param option Not used */
   virtual void  Exec(Option_t* option=0);
 protected:
+  /** Add a digit to output.
+      @param fmd      Pointer to detector object
+      @param detector Detector #
+      @param ring     Ring ID
+      @param sector   Sector number
+      @param strip    Strip number
+      @param edep     Energy deposited (not used)
+      @param count1   ADC count 1
+      @param count2   ADC count 2 (-1 if not used)
+      @param count3   ADC count 3 (-1 if not used) */
   virtual void     AddDigit(AliFMD*  fmd,
                            UShort_t detector, 
                            Char_t   ring,
index 4b87aa4..455533f 100644 (file)
@@ -20,27 +20,74 @@ class TPad;
 class TButton;
 
 //___________________________________________________________________
+/** @class AliFMDDisplay 
+    @brief Utility class to visualize FMD data in geometry. 
+    @ingroup FMD_util
+ */
 class AliFMDDisplay : public AliFMDInput
 {
 public:
+  /** Constructor
+      @param gAliceFile galice file*/
   AliFMDDisplay(const char* gAliceFile="galice.root");
+  /** DTOR */
   virtual ~AliFMDDisplay() {}
+  /** Singleton access function
+      @return Singleton object. */
   static AliFMDDisplay* Instance();
 
+  /** Continue to next event */
   void  Continue() { fWait = kFALSE; }
+  /** Zoom mode */
   void  Zoom() { fZoomMode = kTRUE; }
+  /** Pick mode */
   void  Pick() { fZoomMode = kFALSE; }
+  /** Called when a mouse or similar event happens in the display. 
+      @param event Event type
+      @param px    where the event happened in pixels along X
+      @param py    where the event happened in pixels along Y */
   void  ExecuteEvent(Int_t event, Int_t px, Int_t py);
+  /** Calculate distance from point @f$ (p_x,p_y)@f$ to this object. 
+      @param px Pixel X coordinate 
+      @param py Pixel Y coordinate 
+      @return distance. */
   Int_t DistancetoPrimitive(Int_t px, Int_t py);
+  /** Paint into canvas 
+      @param option Not used */
   void  Paint(Option_t* option="") { (void)option; }
 
+  /** Initialize
+      @return  @c false on error */
   virtual Bool_t Init();
+  /** Called at beginning of an event 
+      @param event Event number
+      @return @c false on error  */
   virtual Bool_t Begin(Int_t event);
+  /** Called at end of an event 
+      @return @c false on error  */
   virtual Bool_t End();
+  /** Visualize a hit
+      @param hit Hit
+      @param p   Track
+      @return @c false on error  */
   virtual Bool_t ProcessHit(AliFMDHit* hit, TParticle* p);
+  /** Visualize a digit
+      @param digit Digit to draw
+      @return @c false on error  */
   virtual Bool_t ProcessDigit(AliFMDDigit* digit);
+  /** Visualize a raw digit
+      @param digit Raw digit.
+      @return @c false on error  */
   virtual Bool_t ProcessRaw(AliFMDDigit* digit);
+  /** Visualize a reconstructed point.
+      @param recpoint Reconstructed point
+      @return @c false on error  */
   virtual Bool_t ProcessRecPoint(AliFMDRecPoint* recpoint);
+  /** Look up a color index, based on the value @a x and the maximum
+      value of @a x
+      @param x   Value 
+      @param max Maximum (for example 1023 for digits)
+      @return @c false on error  */
   virtual Int_t  LookupColor(Float_t x, Float_t max)  const;
 protected:
   static AliFMDDisplay* fgInstance; // Static instance 
index 4a634ce..645b81c 100644 (file)
@@ -9,47 +9,83 @@
 # include "AliFMDMap.h"
 #endif 
 //____________________________________________________________________
-//
-// Cache of Energy deposited, hit information per strip.
-// Contains a pair of fEdep and fN
-// fEdep is the summed energy deposition, and fN is the number of hits
-//
-
-//____________________________________________________________________
+/** Cache of Energy deposited, hit information per strip.
+    Contains a pair of energy deposited @c fEdep and 
+    number of hits @c fN, @c fEdep is the summed energy deposition,
+    and @c fN is the number of hits 
+    @ingroup FMD_sim
+*/
 class AliFMDEdepHitPair 
 {
 public:
   Float_t  fEdep; // summed energy deposition
   UShort_t fN;    // Number of hits
+  /** CTOR  */
   AliFMDEdepHitPair() : fEdep(0), fN(0) {}
+  /** DTOR */
+  virtual ~AliFMDEdepHitPair() {}
+  /** Assignment operator 
+      @param o Object to assign from 
+      @return Reference to this object */
   AliFMDEdepHitPair& operator=(const AliFMDEdepHitPair& o) 
   { fEdep = o.fEdep; fN    = o.fN; return *this; }
+  /** Copy CTOR 
+      @param o Object to copy from */
   AliFMDEdepHitPair(const AliFMDEdepHitPair& o) : fEdep(o.fEdep), fN(o.fN) {}
+  ClassDef(AliFMDEdepHitPair, 1)
 };
 
 //____________________________________________________________________
+/** Map of Energy deposited, hit information per strip.
+    Contains a pair of energy deposited @c fEdep and 
+    number of hits @c fN, @c fEdep is the summed energy deposition,
+    and @c fN is the number of hits */
 class AliFMDEdepMap : public AliFMDMap
 {
 public:
+  /** Copy constructor 
+      @param other Object to copy from. 
+      @return  */
   AliFMDEdepMap(const AliFMDEdepMap& other);
+  /** Constructor 
+      @param maxDet  Number of detectors (3)
+      @param maxRing Number of rings (2)
+      @param maxSec  Number of sectors (40)
+      @param maxStr  Number of strips (20) */
   AliFMDEdepMap(size_t maxDet = kMaxDetectors, 
                size_t maxRing= kMaxRings, 
                size_t maxSec = kMaxSectors, 
                size_t maxStr = kMaxStrips);
+  /** DTOR */
   virtual ~AliFMDEdepMap() { delete [] fData; }
   AliFMDEdepMap& operator=(const AliFMDEdepMap& other);
+  /** Reset to default */
   virtual void Reset();
+  /** Reset to value 
+      @param v Value to reset from */
   virtual void Reset(const AliFMDEdepHitPair& val);
+  /** Access operator 
+      @param det   Detector 
+      @param ring  Ring 
+      @param sec   Sector  
+      @param str   Strip
+      @return  reference value stored for the strip */
   virtual AliFMDEdepHitPair& operator()(UShort_t detector, 
                                     Char_t   ring, 
                                     UShort_t sector, 
                                     UShort_t strip);
+  /** Access operator 
+      @param det   Detector 
+      @param ring  Ring 
+      @param sec   Sector  
+      @param str   Strip
+      @return value stored for the strip */
   virtual const AliFMDEdepHitPair& operator()(UShort_t detector, 
                                           Char_t   ring, 
                                           UShort_t sector, 
                                           UShort_t strip) const;
 protected:
-  size_t             fTotal; //  
+  size_t             fTotal; //  Total number of entries
   AliFMDEdepHitPair* fData;  //[fTotal] The data 
   ClassDef(AliFMDEdepMap, 2) // Cache of edep,hit information per strip
 };
index f389366..ca7db1f 100644 (file)
@@ -36,51 +36,168 @@ class AliFMDGeometryBuilder;
 
 //__________________________________________________________________
 /** Singleton object of FMD geometry descriptions and parameters.
+    This class is a singleton that handles the geometry parameters of
+    the FMD detectors.  
+                                                          
+    The actual code is done by various separate classes.   Below is
+    diagram showing the relationship between the various FMD classes
+    that handles the geometry 
+    @verbatim
+                                  +------------+ 
+                               +- | AliFMDRing |
+                          2   |  +------------+
+         +----------------+<>--+        |                              
+         | AliFMDGeometry |             ^                              
+         +----------------+<>--+        V 1..2                         
+                          3   | +----------------+             
+                                      +-| AliFMDDetector |             
+                                +----------------+             
+                                        ^
+                                        |
+                          +-------------+-------------+
+                          |             |             |              
+                     +---------+   +---------+   +---------+
+                     | AliFMD1 |   | AliFMD2 |   | AliFMD3 |
+                     +---------+   +---------+   +---------+
+         
+    @endverbatim
+    -  AliFMDRing 
+       This class contains all stuff needed to do with a ring.  It's
+       used by the AliFMDDetector objects to instantise inner and
+       outer rings.  The AliFMDRing objects are shared by the
+       AliFMDDetector objects, and owned by the AliFMDv1 object. 
+    -  AliFMD1, AliFMD2, and AliFMD3 
+       These are specialisation of AliFMDDetector, that contains the
+       particularities of each of the sub-detector system.  It is
+       envisioned that the classes should also define the support
+       volumes and material for each of the detectors.
+
+    @ingroup FMD_base
  */
 class AliFMDGeometry : public AliGeometry
 {
 public:
+  /** @return Singleton */
   static AliFMDGeometry* Instance();
+  /** Initialize */
   virtual void Init();
+  /** Initialize transforms */
   virtual void InitTransformations();
+  /** @return Get inner description */
   AliFMDRing*     GetInner() const { return fInner; }
+  /** @return Get outer description */
   AliFMDRing*     GetOuter() const { return fOuter; }
+  /** @return Get FMD1 description */
   AliFMD1*        GetFMD1()  const { return (fUseFMD1 ? fFMD1 : 0); }
+  /** @return Get FMD2 description */
   AliFMD2*        GetFMD2()  const { return (fUseFMD2 ? fFMD2 : 0); }
+  /** @return Get FMD3 description */
   AliFMD3*        GetFMD3()  const { return (fUseFMD3 ? fFMD3 : 0); }
+  /** Get description of a sub-detector
+      @param i Sub-detector #
+      @return Description of sub-detector, or 0 */
   AliFMDDetector* GetDetector(Int_t i) const;
+  /** Get description of a ring
+      @param i Ring id
+      @return Description of ring, or 0 */
   AliFMDRing*     GetRing(Char_t i) const;
+  /** @param i IF true, disable sub-detector @a i */
   void            Disable(Int_t i);
+  /** @param i IF true, enable sub-detector @a i */
   void            Enable(Int_t i);
+  /** @return Density @f$ \rho@f$ of silicon */
   Double_t        GetSiDensity() const { return 2.33; }
+  /** Translate detector coordinates (detector, ring, sector, strip)
+      to spatial coordinates (x, y, z) in the master reference frame
+      of ALICE.  The member function uses the transformations
+      previously obtained from the TGeoManager.
+      @param detector Detector number
+      @param ring     Ring id
+      @param sector   Sector number
+      @param strip    Strip number
+      @param x        On return, X coordinate 
+      @param y        On return, Y coordinate 
+      @param z        On return, Z coordinate  */
   void            Detector2XYZ(UShort_t detector, Char_t ring, 
                               UShort_t sector, UShort_t strip, 
                               Double_t& x, Double_t& y, Double_t& z) const;
+  /** Translate spatial coordinates (x,y,z) in the master reference
+      frame of ALICE to the detector coordinates (detector, ring,
+      sector, strip).  Note, that if this method is to be used in
+      reconstruction or the like, then the input z-coordinate should
+      be corrected for the events interactions points z-coordinate,
+      like  
+      @code 
+      geom->XYZ2Detector(x,y,z-ipz,d,r,s,t);
+      @endverbatim
+      @param x        X coordinate
+      @param y               Y coordinate
+      @param z               Z coordinate
+      @param detector On return, Detector number
+      @param ring     On return, Ring id                  
+      @param sector   On return, Sector number    
+      @param strip    On return, Strip number     
+      @return @c  false of (@a x, @a y, @a z) is not within this
+      detector.  */
   Bool_t          XYZ2Detector(Double_t x, Double_t y, Double_t z, 
                               UShort_t& detector, Char_t& ring, 
                               UShort_t& sector, UShort_t& strip) const;
+  /** Make the geometry.  This delegates to AliFMDGeometryBuilder */
   void   Build();
+  /** @return Get detector offset in paths */
   Int_t  GetDetectorOff() const    { return fDetectorOff; }
+  /** @return Get sensor offset in paths */
   Int_t  GetModuleOff() const      { return fModuleOff;   }
+  /** @return Get ring offset in paths */
   Int_t  GetRingOff() const        { return fRingOff;     }
+  /** @return Get ring sector in paths */
   Int_t  GetSectorOff() const      { return fSectorOff;   }
+  /** @param off Detector off-set set in geometry path */
   void   SetDetectorOff(Int_t off) { fDetectorOff = off; }
+  /** @param off Module off-set set in geometry path */
   void   SetModuleOff(Int_t off)   { fModuleOff   = off; }
+  /** @param off Ring off-set set in geometry path */
   void   SetRingOff(Int_t off)     { fRingOff     = off; }
+  /** @param off Sectord off-set set in geometry path */
   void   SetSectorOff(Int_t off)   { fSectorOff   = off; }
+  /** Check if volume @a vol is marked as active 
+      @param vol Volume ID
+      @return  @c true if @a vol is declared active */
   Bool_t IsActive(Int_t vol) const;
+  /** Set active volumes 
+      @param active Active volume id array 
+      @param n elements of @a active */
   void   SetActive(Int_t* active, Int_t n);
+  /** @param id Register volume @a id to be active */
   void   AddActive(Int_t id);
+  /** Set an external geometry builder
+      @param b Geometry builder */
   void   SetBuilder(AliFMDGeometryBuilder* b) { fBuilder = b; }
+  /** Extract informaton from TGeoManager */
   void   ExtractGeomInfo();
+  /** Whether we are to use a detailed geometry or not
+      @param det if @c true, make a detailed geometry. */
   void   SetDetailed(Bool_t det) { fDetailed = det; }
+  /** @return @c true if geometry is detailed */
   Bool_t IsDetailed() const { return fDetailed; }
+  /** @param ass Whether to use assemblies or not */
   void   UseAssembly(Bool_t ass)  { fUseAssembly = ass; }
 
   // AliGeometry member functions 
+  /** Get global coordinates cooresponding to a rec point. 
+      @param p   Reconstructed point.
+      @param pos On return, the position
+      @param mat On return, the material at @a post */
   virtual void GetGlobal(const AliRecPoint* p, TVector3& pos, 
                         TMatrixF& mat) const;
+  /** Get global coordinates cooresponding to a rec point. 
+      @param p   Reconstructed point.
+      @param pos On return, the position */
   virtual void GetGlobal(const AliRecPoint* p, TVector3& pos) const;
+  /** Check if particle will hit an active detector element.  Note
+      done yet. 
+      @param particle Track 
+      @return @c true if @a particle will hit this detector */
   virtual Bool_t Impact(const TParticle* particle) const;
 protected:
   Bool_t        fIsInitialized; // Whether singleton is initalized
@@ -93,8 +210,14 @@ protected:
   Bool_t       fUseFMD2;       // Wheter to Use FMD2 or not
   Bool_t       fUseFMD3;       // Wheter to Use FMD3 or not
   static AliFMDGeometry* fgInstance; // Singleton instance 
+  /** CTOR */
   AliFMDGeometry();
+  /** Copy CTOR
+      @param other To copy from  */
   AliFMDGeometry(const AliFMDGeometry& other);
+  /** Assignment operator 
+      @param other To assig from
+      @return reference to this.  */
   AliFMDGeometry& operator=(const AliFMDGeometry& other);
   virtual ~AliFMDGeometry() {}
   
index 138e06c..1ebe19a 100644 (file)
 // Detector consists of 3 sub-detectors FMD1, FMD2, and FMD3, each of
 // which has 1 or 2 rings of silicon sensors. 
 //                                                       
-// This is the base class for all FMD manager classes. 
-//                    
-// The actual code is done by various separate classes.   Below is
-// diagram showing the relationship between the various FMD classes
-// that handles the simulation
-//
-//      +--------+ 1     +-----------------+ 
-//      | AliFMD |<>-----| AliFMDGeometryBuilder |
-//      +--------+      +-----------------+
-//                               ^              
-//                               |
-//                 +-------------+-------------+
-//                 |                           |             
-//        +--------------------+   +-------------------+
-//        | AliFMDGeometryBuilder |   | AliFMDG3Simulator | 
-//        +--------------------+   +---------+---------+
-//                                           ^
-//                                           |
-//                                +--------------------+
-//                               | AliFMDOldSimulator |
-//                               +--------------------+
-//      
-// *  AliFMD 
-//    This defines the interface for the various parts of AliROOT that
-//    uses the FMD, like AliFMDGeometryBuilder, AliFMDDigitizer, 
-//    AliFMDReconstructor, and so on. 
-//
-// *  AliFMDGeometryBuilder
-//    This is the base class for the FMD simulation tasks.   The
-//    simulator tasks are responsible to implment the geoemtry, and
-//    process hits. 
-//                                                                          
-// *  AliFMDGeometryBuilder
-//    This is a concrete implementation of the AliFMDGeometryBuilder that
-//    uses the TGeo classes directly only.  This defines the active
-//    volume as an ONLY XTRU shape with a divided MANY TUBS shape
-//    inside to implement the particular shape of the silicon
-//    sensors. 
-//
-// *  AliFMDG3Simulator
-//    This is a concrete implementation of the AliFMDGeometryBuilder that
-//    uses the TVirtualMC interface with GEANT 3.21-like messages.
-//    This implements the active volume as a divided TUBS shape.  Hits
-//    in the corners should be cut away at run time (but currently
-//    isn't). 
-//
-// *  AliFMDOldSimulator
-//    This is a concrete implementation of AliFMDGeometryBuilder.   It
-//    approximates the of the rings as segmented disks. 
 // 
 #include "AliFMDGeometryBuilder.h"     // ALIFMDGEOSIMULATOR_H
 #include "AliFMDGeometry.h"    // ALIFMDGEOMETRY_H
index f2b4940..85ef75d 100644 (file)
@@ -23,11 +23,20 @@ class AliFMD2;
 class AliFMD3;
 
 //____________________________________________________________________
+/** @class AliFMDGeometryBuilder 
+    @brief Builder of FMD geometry. 
+    This class takes care of actually building the geometry using the
+    @b TGeo classes.  Various parameters are fecthed from the
+    AliFMDGeometry manager. 
+    @ingroup FMD_sim
+ */
 class AliFMDGeometryBuilder : public TTask
 {
 public:
-  AliFMDGeometryBuilder();
   /** CTOR */
+  AliFMDGeometryBuilder();
+  /** CTOR 
+      @param detailed Whether to make a detailed geometry. */
   AliFMDGeometryBuilder(Bool_t detailed);
   virtual ~AliFMDGeometryBuilder() {}
   /** Register */
index e885088..9a3b488 100644 (file)
@@ -7,20 +7,38 @@
  */
 //___________________________________________________________________
 //
-// AliFMDhit is the hit class for the FMD. Hits are the information
-// that comes from a Monte Carlo at each step as a particle mass
-// through sensitive detector elements as particles are transported
-// through a detector.
-//
 #ifndef ALIHIT_H
 # include <AliHit.h>
 #endif
 
 //___________________________________________________________________
+/** AliFMDhit is the hit class for the FMD. Hits are the information
+    that comes from a Monte Carlo at each step as a particle mass
+    through sensitive detector elements as particles are transported
+    through a detector. 
+    @ingroup FMD_sim
+*/
 class AliFMDHit : public AliHit 
 {
 public:
+  /** Default CTOR */
   AliFMDHit();
+  /** Normal FMD hit ctor
+      @param shunt     ???
+      @param track       Track #
+      @param detector  Detector # (1, 2, or 3)                      
+      @param ring        Ring ID ('I' or 'O')
+      @param sector      Sector # (For inner/outer rings: 0-19/0-39)
+      @param strip       Strip # (For inner/outer rings: 0-511/0-255)
+      @param x   Track's X-coordinate at hit
+      @param y   Track's Y-coordinate at hit
+      @param z   Track's Z-coordinate at hit
+      @param px          X-component of track's momentum 
+      @param py          Y-component of track's momentum
+      @param pz          Z-component of track's momentum
+      @param edep        Energy deposited by track
+      @param pdg         Track's particle Id #
+      @param t   Time when the track hit */
   AliFMDHit(Int_t    shunt, 
            Int_t    track, 
            UShort_t detector, 
@@ -38,28 +56,50 @@ public:
            Float_t  t=0, 
            Float_t  l=0, 
            Bool_t   stop=kFALSE);
+  /** DTOR  */
   virtual ~AliFMDHit() {}
   
+  /** @return Detector # */
   UShort_t Detector()  const { return fDetector; }
+  /** @return Ring ID */
   Char_t   Ring()      const { return fRing;     }
+  /** @return Sector # */
   UShort_t Sector()    const { return fSector;   }
+  /** @return Strip # */
   UShort_t Strip()     const { return fStrip;    }
+  /** @return Energy deposited (MeV) */
   Float_t  Edep()       const { return fEdep;     }
+  /** @return Track @f$ p_x@f$ - momentum in @f$ x@f$ (GeV) */
   Float_t  Px()         const { return fPx;       }
+  /** @return Track @f$ p_y@f$ - momentum in @f$ y@f$ (GeV) */
   Float_t  Py()         const { return fPy;       }
+  /** @return Track @f$ p_z@f$ - momentum in @f$ z@f$ (GeV) */
   Float_t  Pz()         const { return fPz;       } 
+  /** @return Track @f$ |p|@f$ - momentum (GeV) */
   Float_t  P()          const;
+  /** @return Track @f$ m@f$ - mass (GeV) */
   Float_t  M()          const;
+  /** @return Track @f$ q@f$ - charge (1/3) */
   Float_t  Q()          const;
+  /** @return Track PDG id number */
   Int_t    Pdg()        const { return fPdg;      }
+  /** @return Time of hit in seconds */
   Float_t  Time()       const { return fTime;     }
+  /** @return Path length through silicon */
   Float_t  Length()     const { return fLength;   }
+  /** @return Whether track was stopped in silicon */
   Bool_t   IsStop()     const { return fStop;     }
 
+  /** Print info 
+      @param opt Not used */
   void        Print(Option_t* opt="") const;
+  /** @return Get Name */
   const char* GetName()               const;
+  /** @return Get title */
   const char* GetTitle()              const;
 
+  /** Set enenrgy deposited
+      @param edep Energy deposited */
   void     SetEdep(Float_t edep) { fEdep = edep; }
 protected:
   UShort_t fDetector;  // (Sub) Detector # (1,2, or 3)
index 3dec389..7434a3b 100644 (file)
@@ -6,13 +6,14 @@
  * See cxx source for full Copyright notice                               
  */
 //___________________________________________________________________
-//
-// The classes defined here, are utility classes for reading in data
-// for the FMD.  They are  put in a seperate library to not polute the
-// normal libraries.  The classes are intended to be used as base
-// classes for customized class that do some sort of analysis on the
-// various types of data produced by the FMD. 
-//
+/** @defgroup FMD_util Utility classes. 
+
+    The classes defined here, are utility classes for reading in data
+    for the FMD.  They are put in a seperate library to not polute the
+    normal libraries.  The classes are intended to be used as base
+    classes for customized class that do some sort of analysis on the
+    various types of data produced by the FMD.
+*/
 #include <TObject.h>
 #ifndef ROOT_TString
 # include <TString.h>
@@ -37,9 +38,54 @@ class TParticle;
 class TChain;
 
 //___________________________________________________________________
+/** @class AliFMDInput 
+    @brief Base class for reading in various FMD data. 
+    The class loops over all found events.  For each event the
+    specified data is read in.   The class then loops over all
+    elements of the read data, and process these with user defined
+    code. 
+    @code 
+    struct DigitInput : public AliFMDInput 
+    { 
+      DigitInput() 
+      { 
+         // Load digits 
+         AddLoad(kDigits);
+        // Make a histogram 
+         fHist = new TH1F("adc", "ADC spectra", 1024, -.5, 1023.5);
+      }
+      // Process one digit. 
+      Bool_t ProcessDigit(AliFMDDigit* d)
+      { 
+         fHist->Fill(d->Counts());
+        return kTRUE;
+      }
+      // After processing all events, display spectrum
+      Bool_t Finish()
+      {
+        fHist->Draw();
+      }
+      TH1F* fHist;
+    };
+
+    void AdcSpectrum()
+    { 
+       DigitInput di;
+       di.Run();
+    }
+    @endcode
+    This class allows for writing small scripts, that can be compiled
+    with AcLIC, to do all sorts of tests, quick prototyping, and so
+    on.  It has proven to be quiet useful.   One can load more than
+    one type of data in one derived class, to for example to make
+    comparisons between hits and reconstructed points.   See also the
+    various scripts in @c FMD/scripts. 
+    @ingroup FMD_util
+ */
 class AliFMDInput : public TObject
 {
 public:
+  /** The kinds of data that can be read in. */
   enum ETrees {
     kHits       = 1,  // Hits
     kKinematics,      // Kinematics (from sim)
@@ -51,32 +97,90 @@ public:
     kRaw,             // Read raw data 
     kGeometry         // Not really a tree 
   };
+  /** CTOR  */
   AliFMDInput();
+  /** CTOR
+      @param gAliceFile galice file  */
   AliFMDInput(const char* gAliceFile);
+  /** DTOR */
   virtual ~AliFMDInput() {}
 
+  /** Add a data type to load 
+      @param tree Data to load */
   virtual void   AddLoad(ETrees tree)     { SETBIT(fTreeMask, tree); }
+  /** Remove a data type to load 
+      @param tree Data to @e not load */
   virtual void   RemoveLoad(ETrees tree)  { CLRBIT(fTreeMask, tree); }
+  /** @return # of available events */
   virtual Int_t  NEvents() const;
 
+  /** Initialize the class.  If a user class overloads this member
+      function, then this @e must be explicitly called
+      @return @c false on error */
   virtual Bool_t Init();
+  /** Callled at the beginning of each event. If a user class
+      overloads this member  function, then this @e must be explicitly
+      called. 
+      @param event Event number
+      @return @c false on error */
   virtual Bool_t Begin(Int_t event);
+  /** Process one event.  This loops over all the loaded data.   Users
+      can overload this member function, but then it's @e strongly
+      recommended to explicitly call this classes version. 
+      @return @c false on error  */
   virtual Bool_t Event();
+  /** Called at the end of each event. 
+      @return @c false on error  */
   virtual Bool_t End();
+  /** Called at the end of the run.
+      @return  @c false on error */
   virtual Bool_t Finish() { return kTRUE; }
+  /** Run a full job. 
+      @return @c false on error  */
   virtual Bool_t Run();
 
+  /** Loop over all hits, and call ProcessHit with that hit, and
+      optionally the corresponding kinematics track. 
+      @return @c false on error  */
   virtual Bool_t ProcessHits();
+  /** Loop over all digits, and call ProcessDigit for each digit.
+      @return @c false on error  */
   virtual Bool_t ProcessDigits();
+  /** Loop over all summable digits, and call ProcessSDigit for each
+      digit. 
+      @return @c false on error  */
   virtual Bool_t ProcessSDigits();
+  /** Loop over all digits read from raw data files, and call
+      ProcessRawDigit for each digit. 
+      @return @c false on error  */
   virtual Bool_t ProcessRawDigits();
+  /** Loop over all reconstructed points, and call ProcessRecPoint for
+      each reconstructed point. 
+      @return @c false on error  */
   virtual Bool_t ProcessRecPoints();
 
+  /** Process one hit, and optionally it's corresponding kinematics
+      track.  Users should over this to process each hit. 
+      @return  @c false on error   */
   virtual Bool_t ProcessHit(AliFMDHit*, TParticle*)  { return kTRUE; }
+  /** Process one digit.  Users should over this to process each digit. 
+      @return  @c false on error   */
   virtual Bool_t ProcessDigit(AliFMDDigit*)          { return kTRUE; }
+  /** Process one summable digit.  Users should over this to process
+      each summable digit.  
+      @return  @c false on error   */
   virtual Bool_t ProcessSDigit(AliFMDSDigit*)        { return kTRUE; }
+  /** Process one digit from raw data files.  Users should over this
+      to process each raw digit.  
+      @return  @c false on error   */
   virtual Bool_t ProcessRawDigit(AliFMDDigit*)       { return kTRUE; }
+  /** Process one reconstructed point.  Users should over this to
+      process each reconstructed point.  
+      @return  @c false on error   */
   virtual Bool_t ProcessRecPoint(AliFMDRecPoint*)    { return kTRUE; }
+  /** Process ESD data for the FMD.  Users should overload this to
+      deal with ESD data. 
+      @return  @c false on error  */
   virtual Bool_t ProcessESD(AliESDFMD*)              { return kTRUE; }
   
 protected:
index 94ee0dd..423bd26 100644 (file)
@@ -33,34 +33,73 @@ class AliFMDCalibGain;
 class AliFMDCalibSampleRate;
 class AliFMDAltroMapping;
 
+/** This class is a singleton that handles various parameters of the
+    FMD detectors.  This class reads from the Conditions DB to get the
+    various parameters, which code can then request from here. In that
+    way, all code uses the same data, and the interface is consistent.
+     
+    Some of the parameter managed are 
+    - @c fPedestal, @c fPedestalWidth
+      Mean and width of the pedestal.  The pedestal is simulated
+      by a Guassian, but derived classes my override MakePedestal
+      to simulate it differently (or pick it up from a database).
+    - @c fVA1MipRange
+      The dymamic MIP range of the VA1_ALICE pre-amplifier chip 
+    - @c fAltroChannelSize
+      The largest number plus one that can be stored in one
+      channel in one time step in the ALTRO ADC chip. 
+    - @c fSampleRate
+      How many times the ALTRO ADC chip samples the VA1_ALICE
+      pre-amplifier signal.   The VA1_ALICE chip is read-out at
+      10MHz, while it's possible to drive the ALTRO chip at
+      25MHz.  That means, that the ALTRO chip can have time to
+      sample each VA1_ALICE signal up to 2 times.  Although it's
+      not certain this feature will be used in the production,
+      we'd like have the option, and so it should be reflected in
+      the code.
+
+    @ingroup FMD_base
+*/
 class AliFMDParameters : public TNamed
 {
 public:
+  /** Singleton access
+      @return  single to */
   static AliFMDParameters* Instance();
 
+  /** Initialize the manager.  This tries to read the parameters from
+      CDB.  If that fails, the class uses the hard-coded parameters. 
+   */
   void Init();
   
-  // Set various `Fixed' parameters 
+  /** @{ */
+  /** @name Set various `Fixed' parameters */
   void SetVA1MipRange(UShort_t r=20)          { fVA1MipRange = r; }
   void SetAltroChannelSize(UShort_t s=1024)   { fAltroChannelSize = s;}
   void SetChannelsPerAltro(UShort_t size=128) { fChannelsPerAltro = size; }
   void SetPedestalFactor(Float_t f=3)         { fPedestalFactor = f; }
+  /** @} */
 
-  // Set various variable parameter defaults
+  /** @{ */
+  /** @name Set various variable parameter defaults */
   void SetZeroSuppression(UShort_t s=0)       { fFixedZeroSuppression = s; }
   void SetSampleRate(UShort_t r=1)            { fFixedSampleRate = (r>2?2:r);}
   void SetPedestal(Float_t p=10)              { fFixedPedestal = p; }
   void SetPedestalWidth(Float_t w=1)          { fFixedPedestalWidth = w; }
   void SetThreshold(Float_t t=0)              { fFixedThreshold = t; }
+  /** @} */
 
-  // Get `Fixed' various parameters
+  /** @{ */
+  /** @name Get `Fixed' various parameters */
   UShort_t GetVA1MipRange()          const { return fVA1MipRange; }
   UShort_t GetAltroChannelSize()     const { return fAltroChannelSize; }
   UShort_t GetChannelsPerAltro()     const { return fChannelsPerAltro; }
   Float_t  GetEdepMip()              const;
   Float_t  GetPedestalFactor()      const { return fPedestalFactor; }
+  /** @} */
 
-  // Get variable parameters 
+  /** @{ */
+  /** @name Get variable parameters */
   Bool_t   IsDead(UShort_t detector, 
                  Char_t ring, 
                  UShort_t sector, 
@@ -89,6 +128,8 @@ public:
   Bool_t   Detector2Hardware(UShort_t det, Char_t ring, UShort_t sec, 
                             UShort_t str, UInt_t& ddl, UInt_t& addr) const;
   AliFMDAltroMapping* GetAltroMap() const;
+  /** @} */
+
   enum { 
     kBaseDDL = 0x1000 // DDL offset for the FMD
   };
@@ -99,14 +140,23 @@ public:
   static const char* fgkAltroMap;       // Path to AltroMap calib object
   static const char* fgkZeroSuppression; // Path to ZeroSuppression cal object
 protected:
+  /** CTOR  */
   AliFMDParameters();
+  /** DTOR */
   virtual ~AliFMDParameters() {}
+  /** Singleton instance  */
   static AliFMDParameters* fgInstance;   // Static singleton instance
+  /** Initialize gains.  Try to get them from CDB */
   void InitPulseGain();
+  /** Initialize pedestals.  Try to get them from CDB */
   void InitPedestal();
+  /** Initialize dead map.  Try to get it from CDB */
   void InitDeadMap();
+  /** Initialize sample rates.  Try to get them from CDB */
   void InitSampleRate();
+  /** Initialize zero suppression thresholds.  Try to get them from CDB */
   void InitZeroSuppression();
+  /** Initialize hardware map.  Try to get it from CDB */
   void InitAltroMap();
 
   Bool_t          fIsInit;               // Whether we've been initialised  
index aad6491..e827539 100644 (file)
@@ -25,12 +25,31 @@ class TClonesArray;
 
 
 //____________________________________________________________________
+/** @brief Class to read ALTRO formated raw data from an AliRawReader
+    object. 
+    @code 
+    AliRawReader*    reader    = new AliRawReaderFile(0);
+    AliFMDRawReader* fmdReader = new AliFMDRawReader(reader);
+    TClonesArray*    array     = new TClonesArray("AliFMDDigit");
+    fmdReader->ReadAdcs(array);
+    @endcode 
+    @ingroup FMD_rec
+*/
 class AliFMDRawReader : public TTask 
 {
 public:
+  /** CTOR 
+      @param reader Raw reader
+      @param array  Output tree */
   AliFMDRawReader(AliRawReader* reader, TTree* array);
+  /** DTOR */
   virtual ~AliFMDRawReader() {}
+  /** Read in, and store in output tree 
+      @param option Not used */
   virtual void   Exec(Option_t* option="");
+  /** Read ADC's into a TClonesArray of AliFMDDigit objects. 
+      @param array Array to read into 
+      @return @c true on success */
   virtual Bool_t ReadAdcs(TClonesArray* array);
 protected:
   TTree*        fTree;       //! Pointer to tree to read into 
index fcb7d44..e0aa48a 100644 (file)
@@ -370,7 +370,6 @@ AliFMDRawWriter::WriteDigits(TClonesArray* digits)
     delete altro;
   }
 }
-#endif
 
 //____________________________________________________________________
 void
@@ -387,6 +386,7 @@ AliFMDRawWriter::WriteChannel(AliAltroBuffer* altro,
                      Int_t((ring == 'I' ? 0 : 1)), 
                      data.fN, data.fArray, fThreshold);
 }
+#endif
 
   
 
index 8191456..af2655e 100644 (file)
@@ -25,18 +25,36 @@ class TArrayI;
 class TClonesArray;
 
 //____________________________________________________________________
+/** @class AliFMDRawWriter
+    @brief Class to write ALTRO formated raw data from an array of
+    AliFMDDigit objects.
+    @code 
+    AliFMDRawWriter* fmdWriter = new AliFMDRawWriter(0);
+    TClonesArray*    array     = fmd->DigitArray();
+    fmdWriter->WriteDigits(array);
+    @endcode 
+    @ingroup FMD_sim
+*/
 class AliFMDRawWriter : public TTask 
 {
 public:
+  /** Constructor 
+      @param fmd Pointer to detector object. */
   AliFMDRawWriter(AliFMD* fmd);
+  /** Destructor */
   virtual ~AliFMDRawWriter() {}
 
+  /** Write the output from AliFMD object. 
+      @param option Not used */
   virtual void Exec(Option_t* option="");
-protected:
+  /** Write an array of AliFMDDigit objects as raw ALTRO data. 
+      @param digits Array of AliFMDDigit objects to convert to raw
+      ALTRO data. */
   virtual void WriteDigits(TClonesArray* digits);
-  virtual void WriteChannel(AliAltroBuffer* altro, 
-                           UShort_t strip, UShort_t sector, Char_t ring, 
-                           const TArrayI& data);
+protected:
+  /* Write a single channel.  This member function is obsolete. */
+  // virtual void WriteChannel(AliAltroBuffer* altro, UShort_t strip, 
+  //                           UShort_t sector, Char_t ring, const TArrayI& d);
   AliFMD*       fFMD;              //! Pointer to detector description 
   UShort_t      fSampleRate;       // The sample rate (0 -> inferred from data)
   UShort_t      fChannelsPerAltro; // Number of pre-amp. channels/adc channel 
index 5f8c9d3..ece49d1 100644 (file)
@@ -9,26 +9,53 @@
 # include <TObject.h>
 #endif
 
+/** Reconstructed FMD points.  It contains the pseudo-inclusive
+    multiplicity 
+    @ingroup FMD_rec
+ */
 class AliFMDRecPoint: public TObject
 {
 public:
+  /** CTOR */
   AliFMDRecPoint();
+  /** Constrctor 
+      @param detector Detector 
+      @param ring     Ring
+      @param sector   Sector
+      @param strip    Strip 
+      @param eta      Psuedo-rapidity @f$ \eta@f$ 
+      @param phi      Azimuthal angle @f$ \varphi@f$ 
+      @param edep     Energy deposited 
+      @param particles Psuedo-inclusive multiplicity */
   AliFMDRecPoint(UShort_t detector,  Char_t   ring, 
-            UShort_t sector,    UShort_t strip, 
-            Float_t  eta,       Float_t  phi,
-            Float_t  edep,      Float_t  particles);
+                UShort_t sector,    UShort_t strip, 
+                Float_t  eta,       Float_t  phi,
+                Float_t  edep,      Float_t  particles);
+  /** DTOR */
   virtual ~AliFMDRecPoint() {};
 
-  UShort_t     Detector() const        { return fDetector; }
-  Char_t       Ring() const            { return fRing; }
-  UShort_t     Sector() const          { return fSector; }
-  UShort_t     Strip() const           { return fStrip; }
+  /** @return Detector # */
+  UShort_t     Detector()         const { return fDetector; }
+  /** @return Ring ID */
+  Char_t       Ring()             const { return fRing;     }
+  /** @return sector # */
+  UShort_t     Sector()                   const { return fSector;   }
+  /** @return strip # */
+  UShort_t     Strip()            const { return fStrip;    }
+  /** @return Psuedo-rapidity @f$ \eta@f$ */
   Float_t      Eta() const             { return fEta; }
+  /** @return phi      Azimuthal angle @f$ \varphi@f$ */
   Float_t      Phi() const             { return fPhi; }
+  /** @return edep     Energy deposited */
   Float_t      Edep() const            { return fEdep; }
+  /** @return particles Psuedo-inclusive multiplicity */
   Float_t      Particles() const       { return fParticles; }
+  /** Print information 
+      @param opt Not used */
   virtual void Print(Option_t* opt="D") const;
+  /** @return Name */
   const char*  GetName()                const;
+  /** @return Title */
   const char*  GetTitle()               const;
 protected:
   UShort_t fDetector;        // Detector #
index c30a7c8..8e2497a 100644 (file)
 // a DDL file (or similar), and stores the read ADC counts in an
 // internal cache (fAdcs). 
 //
-// From the cached values it then calculates the number of particles
-// that hit a region of the FMDs, as specified by the user. 
-//
-// The reconstruction can be done in two ways: Either via counting the
-// number of empty strips (Poisson method), or by converting the ADC
-// signal to an energy deposition, and then dividing by the typical
-// energy loss of a particle.
-// 
-//      +---------------------+       +---------------------+
-//      | AliFMDReconstructor |<>-----| AliFMDMultAlgorithm |
-//      +---------------------+       +---------------------+
-//                                               ^
-//                                               |
-//                                   +-----------+---------+
-//                                   |                     |
-//                         +-------------------+   +------------------+
-//                         | AliFMDMultPoisson |   | AliFMDMultNaiive |
-//                         +-------------------+   +------------------+
-//
-// AliFMDReconstructor acts as a manager class.  It contains a list of
-// AliFMDMultAlgorithm objects.  The call graph looks something like 
-//
-//
-//       +----------------------+            +----------------------+
-//       | :AliFMDReconstructor |            | :AliFMDMultAlgorithm |
-//       +----------------------+            +----------------------+
-//                  |                                  |
-//    Reconstruct  +-+                                 |
-//    ------------>| |                         PreRun +-+
-//                 | |------------------------------->| |   
-//                 | |                                +-+
-//                 | |-----+ (for each event)          |
-//                 | |     | *ProcessEvent             |
-//                 |+-+    |                           |
-//                 || |<---+                 PreEvent +-+
-//                 || |------------------------------>| |      
-//                 || |                               +-+
-//                 || |-----+                          |
-//                 || |     | ProcessDigits            |
-//                 ||+-+    |                          |
-//                 ||| |<---+                          |
-//                 ||| |         *ProcessDigit(digit) +-+
-//                 ||| |----------------------------->| |
-//                 ||| |                              +-+
-//                 ||+-+                               |
-//                 || |                     PostEvent +-+
-//                 || |------------------------------>| |
-//                 || |                               +-+
-//                 |+-+                                |
-//                 | |                        PostRun +-+
-//                 | |------------------------------->| |
-//                 | |                                +-+
-//                 +-+                                 |
-//                  |                                  |
-//
-//
-// 
 //-- Authors: Evgeny Karpechev(INR) and Alla Maevsksia
 //  Latest changes by Christian Holm Christensen <cholm@nbi.dk>
 //
index 51b9f0b..ad62e81 100644 (file)
 //
 //-- Authors: Evgeny Karpechev (INR) and Alla Maevskaia (INR)
 //   Latest changes by Christian Holm Christensen <cholm@nbi.dk>
-/*
-    Reconstruct nember of particles in given group of pads for given
-    FMDvolume determine by numberOfVolume ,
-    numberOfMinSector,numberOfMaxSector, numberOfMinRing,
-    numberOfMaxRing Reconstruction method choose dependence on number
-    of empty pads
-  */
 /* $Id$ */
 
 //____________________________________________________________________
-//
-// Class to do reconstruction of events based on the FMD data.  The
-// class will do two kinds of reconstruction, one based on energy
-// deposition, and one using hit patterns. 
-//
-
 // Header guards in the header files speeds up the compilation
 // considerably.  Please leave them in. 
 #ifndef ALIRECONSTRUCTOR_H
@@ -42,38 +29,129 @@ class AliRunLoader;
 class AliESD;
 class AliESDFMD;
 
+/** @defgroup FMD_rec Reconstruction */
 //____________________________________________________________________
+/** This is a class that reconstructs AliFMDRecPoint objects from of
+    Digits.  This class reads either digits from a TClonesArray or raw
+    data from a DDL file (or similar), and applies calibrations to get
+    psuedo-inclusive multiplicities per strip.
+    @ingroup FMD_rec
+ */
 class AliFMDReconstructor: public AliReconstructor 
 {
 public:
+  /** CTOR */
   AliFMDReconstructor();
+  /** Copy CTOR 
+      @param other Object to copy from. */
   AliFMDReconstructor(const AliFMDReconstructor& other);
+  /** DTOR */
   virtual ~AliFMDReconstructor();
+  /** Assignment operator 
+      @param other Object to assign from
+      @return reference to this object */
   AliFMDReconstructor& operator=(const AliFMDReconstructor& other);
 
+  /** Initialize the reconstructor.  Here, we initialize the geometry
+      manager, and finds the local to global transformations from the
+      geometry.   The calibration parameter manager is also
+      initialized (meaning that the calibration parameters is read
+      from CDB).   Next, we try to get some information about the run
+      from the run loader passed. 
+      @param runLoader Run loader to use to load and store data. 
+  */
   virtual void   Init(AliRunLoader* runLoader);
+  /** Flag that we can convert raw data into digits. 
+      @return always @c true */
   virtual Bool_t HasDigitConversion() const { return kTRUE; }
+  /** Convert raw data read from the AliRawReader @a reader into
+      digits.  This is done using AliFMDRawReader and
+      AliFMDAltroReader.  The digits are put in the passed TTree @a
+      digitsTree. 
+      @param reader     Raw reader. 
+      @param digitsTree Tree to store read digits in. */
   virtual void   ConvertDigits(AliRawReader* reader, TTree* digitsTree) const;
+  /** Flag that we can do one-event reconstruction. 
+      @return always @c true  */
   virtual Bool_t HasLocalReconstruction() const { return kTRUE; }
+  /** Reconstruct one event from the digits passed in @a digitsTree.
+      The member function creates AliFMDRecPoint objects and stores
+      them on the output tree @a clusterTree.  An FMD ESD object is
+      created in parallel. 
+      @todo Make sure we get a vertex. 
+      @param digitsTree  Tree holding the digits of this event
+      @param clusterTree Tree to store AliFMDRecPoint objects in. */
   virtual void   Reconstruct(TTree* digitsTree, TTree* clusterTree) const;
+  /** Put in the ESD data, the FMD ESD data.  The object created by
+      the Reconstruct member function is copied to the ESD object. 
+      @param digitsTree   Tree of digits for this event - not used
+      @param clusterTree  Tree of reconstructed points for this event
+      - not used. 
+      @param esd ESD object to store data in. 
+  */
   virtual void   FillESD(TTree* digitsTree, TTree* clusterTree, 
                         AliESD* esd) const;
+  /** Not used */
   virtual void   SetESD(AliESD* esd) { fESD = esd; }
      
 private:
+  /** Hide base classes unused function */
   void Reconstruct(AliRawReader*, TTree*) const;
+  /** Hide base classes unused function */
   void Reconstruct(AliRunLoader*) const;
+  /** Hide base classes unused function */
   void Reconstruct(AliRunLoader*, AliRawReader*) const;
+  /** Hide base classes unused function */
   void FillESD(AliRawReader*, TTree*, AliESD*) const;
+  /** Hide base classes unused function */
   void FillESD(AliRunLoader*, AliESD*) const;
+  /** Hide base classes unused function */
   void FillESD(AliRunLoader*, AliRawReader*, AliESD*) const;
   
 protected:
+  /** Process AliFMDDigit objects in @a digits.  For each digit, find
+      the psuedo-rapidity @f$ \eta@f$, azimuthal angle @f$ \varphi@f$,
+      energy deposited @f$ E@f$, and psuedo-inclusive multiplicity @f$
+      M@f$.
+      @param digits Array of digits. */
   virtual void     ProcessDigits(TClonesArray* digits) const;
+  /** Substract pedestals from raw ADC in @a digit
+      @param digit Digit data
+      @return Pedestal subtracted ADC count. */
   virtual UShort_t SubtractPedestal(AliFMDDigit* digit) const;
+  /** Converts number of ADC counts to energy deposited.   This is
+      done by 
+      @f[
+      E_i = A_i g_i
+      @f]
+      where @f$ A_i@f$ is the pedestal subtracted ADC counts, and @f$
+      g_i@f$ is the gain for the @f$ i^{\mbox{th}}@f$ strip. 
+      @param digit Raw data
+      @param eta   Psuedo-rapidity of digit.
+      @param count Pedestal subtracted ADC counts
+      @return Energy deposited @f$ E_i@f$ */
   virtual Float_t  Adc2Energy(AliFMDDigit* digit, Float_t eta, 
                              UShort_t count) const;
+  /** Converts an energy signal to number of particles. In this
+      implementation, it's done by 
+      @f[
+      M_i = E_i / E_{\mbox{MIP}}
+      @f]
+      where @f$ E_i@f$ is the energy deposited, and @f$
+      E_{\mbox{MIP}}@f$ is the average energy deposited by a minimum
+      ionizing particle
+      @param digit Raw data
+      @param edep Energy deposited @f$ E_i@f$
+      @return Psuedo-inclusive multiplicity @f$ M@f$ */
   virtual Float_t  Energy2Multiplicity(AliFMDDigit* digit, Float_t edep) const;
+  /** Calculate the physical coordinates psuedo-rapidity @f$ \eta@f$,
+      azimuthal angle @f$ \varphi@f$ of the strip corresponding to
+      the digit @a digit.   This is done by using the information
+      obtained, and previously cached by AliFMDGeometry, from the
+      TGeoManager. 
+      @param digit Digit.
+      @param eta   On return, psuedo-rapidity @f$ \eta@f$
+      @param phi   On return, azimuthal angle @f$ \varphi@f$ */
   virtual void     PhysicalCoordinates(AliFMDDigit* digit, Float_t& eta, 
                                       Float_t& phi) const;
   
index c61f010..800aca1 100644 (file)
@@ -31,11 +31,15 @@ class TVector2;
     Outer (@c 'O') the two objects of this class is owned by the
     Geometry::FMD singleton object.  The 3 Geometry::FMDDetector
     objects shares these two instances as needed. 
+    @ingroup FMD_base
 */
 class AliFMDRing : public TNamed
 {
 public:
+  /** CTOR
+      @param fId Ring ID  */
   AliFMDRing(Char_t fId);
+  /** DTOR  */
   virtual ~AliFMDRing() {}
   /** Initialize the ring geometry */
   virtual void Init();
@@ -130,8 +134,10 @@ public:
       @return the ith vertex */
   TVector2* GetVertex(Int_t i) const;
      
+  /** Not used */
   void Detector2XYZ(UShort_t sector, UShort_t strip, 
                    Double_t& x, Double_t& y, Double_t& z) const;
+  /** Not used */
   Bool_t XYZ2Detector(Double_t x, Double_t y, Double_t z, 
                      UShort_t& sector, UShort_t& strip) const;
 private: 
index 22787c1..1ee4a28 100644 (file)
@@ -9,26 +9,50 @@
 # include "AliFMDMap.h"
 #endif 
 //____________________________________________________________________
-//
-// Cache of Energy deposited, hit information perr strip
-//
-
-//____________________________________________________________________
+/** @class AliFMDUShortMap 
+    @brief Map of an integer per strip
+    @ingroup FMD_base
+ */
 class AliFMDUShortMap : public AliFMDMap
 {
 public:
+  /** Copy constructor 
+      @param other Object to copy from.  */
   AliFMDUShortMap(const AliFMDUShortMap& other);
+  /** Constructor 
+      @param maxDet  Number of detectors (3)
+      @param maxRing Number of rings (2)
+      @param maxSec  Number of sectors (40)
+      @param maxStr  Number of strips (20) */
   AliFMDUShortMap(size_t maxDet = kMaxDetectors, 
                  size_t maxRing= kMaxRings, 
                  size_t maxSec = kMaxSectors, 
                  size_t maxStr = kMaxStrips);
+  /** Destructor */
   virtual ~AliFMDUShortMap() { delete [] fData; }
+  /** Assignment operator 
+      @param other Object to assign from 
+      @return reference to this object.  */
   AliFMDUShortMap& operator=(const AliFMDUShortMap& other);
+  /** Reset to value 
+      @param v Value to reset from */
   virtual void Reset(const UShort_t& val=UShort_t());
+  /** Access operator 
+      @param det   Detector 
+      @param ring  Ring 
+      @param sec   Sector  
+      @param str   Strip
+      @return  reference value stored for the strip */
   virtual UShort_t& operator()(UShort_t detector, 
                               Char_t   ring, 
                               UShort_t sector, 
                               UShort_t strip);
+  /** Access operator 
+      @param det   Detector 
+      @param ring  Ring 
+      @param sec   Sector  
+      @param str   Strip
+      @return  value stored for the strip */
   virtual const UShort_t& operator()(UShort_t detector, 
                                     Char_t   ring, 
                                     UShort_t sector, 
index f29ad55..a67d23d 100644 (file)
 #endif
 
 //____________________________________________________________________
+/** Forward Multiplicity Detector based on Silicon wafers. This class 
+    contains the base procedures for the Forward Multiplicity detector
+    Detector consists of 3 sub-detectors FMD1, FMD2, and FMD3, each of 
+    which has 1 or 2 rings of silicon sensors.  
+                                                           
+    This contains the coarse version of the FMD - that is, the
+    simulation produces no hits in the FMD volumes, and the sensors
+    are not divided into strips and sectors.   Useful for material
+    budget calculations
+    @ingroup FMD_sim
+ */
 class AliFMDv0 : public AliFMD 
 {
 public:
+  /** CTOR */
   AliFMDv0() {}
+  /** CTOR
+      @param name Name
+      @param title Title  */
   AliFMDv0(const char *name, const char *title="Coarse geometry") 
     : AliFMD(name, title)
   {}
-  virtual ~AliFMDv0() 
-  {}
+  /** DTOR */
+  virtual ~AliFMDv0() {}
 
   // Required member functions 
+  /** @return Version number - always 0 */
   virtual Int_t  IsVersion() const {return 0;}
+  /** Function called at each hit.  Empty */
   virtual void   StepManager() {}
 
   ClassDef(AliFMDv0,1) // Coarse FMD geometry 
index b45e014..98068a2 100644 (file)
 #endif
  
 //____________________________________________________________________
+/** Forward Multiplicity Detector based on Silicon wafers. This class
+    contains the base procedures for the Forward Multiplicity detector
+    Detector consists of 3 sub-detectors FMD1, FMD2, and FMD3, each of
+    which has 1 or 2 rings of silicon sensors. 
+                                                           
+    This class contains the detailed version of the FMD - that is,
+    hits are produced during simulation. 
+    @ingroup FMD_sim
+*/
 class AliFMDv1 : public AliFMD 
 {
 public:
+  /** CTOR */
   AliFMDv1()
     : AliFMD(),
       fCurrentDeltaE(0),
       fCurrentV(),
       fCurrentP(),
       fCurrentPdg(0) { fDetailed = kTRUE; }
+  /** CTOR 
+      @param name Name 
+      @param title Title */
   AliFMDv1(const char *name, const char *title="Detailed geometry") 
     : AliFMD(name, title),
       fCurrentDeltaE(0),
       fCurrentV(),
       fCurrentP(),
       fCurrentPdg(0) { fDetailed = kTRUE; }
+  /** DTOR */
   virtual ~AliFMDv1() {}
 
   // Required member functions 
+  /** Get version number 
+      @return always 1 */
   virtual Int_t  IsVersion() const {return 1;}
+  /** Member function that is executed each time a hit is made in the 
+      FMD.  None-charged particles are ignored.   Dead tracks  are
+      ignored.  
+      
+      The procedure is as follows: 
+      - IF NOT track is alive THEN RETURN ENDIF
+      - IF NOT particle is charged THEN RETURN ENDIF
+      - IF NOT volume name is "STRI" or "STRO" THEN RETURN ENDIF 
+      - Get strip number (volume copy # minus 1)
+      - Get phi division number (mother volume copy #)
+      - Get module number (grand-mother volume copy #)
+      - section # = 2 * module # + phi division # - 1
+      - Get ring Id from volume name 
+      - Get detector # from grand-grand-grand-mother volume name 
+      - Get pointer to sub-detector object. 
+      - Get track position 
+      - IF track is entering volume AND track is inside real shape THEN
+      -   Reset energy deposited 
+      -   Get track momentum 
+      -   Get particle ID # 
+      - ENDIF
+      - IF track is inside volume AND inside real shape THEN 
+      -   Update energy deposited 
+      - ENDIF 
+      - IF track is inside real shape AND (track is leaving volume,
+           or it died, or it is stopped  THEN
+      -   Create a hit 
+      - ENDIF 
+  */
   virtual void   StepManager();
 protected:
+  /** Translate VMC coordinates to detector coordinates
+      @param v        On output, Current position
+      @param detector On output, detector #
+      @param ring     On output, ring id
+      @param sector   On output, sector #
+      @param strip    On output, strip #
+      @return @c true on success */
   Bool_t VMC2FMD(TLorentzVector& v, UShort_t& detector,
                 Char_t& ring, UShort_t& sector, UShort_t& strip) const;
+  /** Translate VMC coordinates to detector coordinates
+      @param copy     Volume copy number 
+      @param v        On output, Current position
+      @param detector On output, detector #
+      @param ring     On output, ring id
+      @param sector   On output, sector #
+      @param strip    On output, strip #
+      @return @c true on success */
   Bool_t VMC2FMD(Int_t copy, TLorentzVector& v,
                 UShort_t& detector, Char_t& ring,
                 UShort_t& sector, UShort_t& strip) const;
+  /** Check if hit is bad.  A hit is bad if 
+      @f[
+      \Delta E > |Q|^2 p / m > 1 
+      @f]
+      holds, where @f$ \Delta E@f$ is the energy loss in this step, 
+      @f$ Q@f$ is the particle charge, @f$ p@f$ is the track momentum,
+      and @f$ m@f$ is the particle mass.   If a track is marked as
+      bad, it's kept in a cache, and can be printed at the end of the
+      event. 
+      @param trackno Track number 
+      @param pdg     PDG particle type ID
+      @param absQ    Absolute value of particle charge
+      @param p       Track momentum
+      @param edep    Energy loss in this step.
+      @return @c true if hit is `bad' */
   Bool_t CheckHit(Int_t trackno, Int_t pdg, Float_t absQ, 
                  const TLorentzVector& p, Float_t edep) const;
 
diff --git a/FMD/Doxyfile b/FMD/Doxyfile
new file mode 100644 (file)
index 0000000..24d87cf
--- /dev/null
@@ -0,0 +1,233 @@
+# Doxyfile 1.4.6
+
+#---------------------------------------------------------------------------
+# Project related configuration options
+#---------------------------------------------------------------------------
+PROJECT_NAME           = "ALICE FMD Off-line"
+PROJECT_NUMBER         = 0.1
+OUTPUT_DIRECTORY       = 
+CREATE_SUBDIRS         = NO
+OUTPUT_LANGUAGE        = English
+USE_WINDOWS_ENCODING   = NO
+BRIEF_MEMBER_DESC      = NO
+REPEAT_BRIEF           = YES
+ABBREVIATE_BRIEF       = "The $name class" \
+                         "The $name widget" \
+                         "The $name file" \
+                         is \
+                         provides \
+                         specifies \
+                         contains \
+                         represents \
+                         a \
+                         an \
+                         the
+ALWAYS_DETAILED_SEC    = YES
+INLINE_INHERITED_MEMB  = NO
+FULL_PATH_NAMES        = YES
+STRIP_FROM_PATH        = /home/hehi/cholm/work/alice/aliroot/FMD/
+STRIP_FROM_INC_PATH    = 
+SHORT_NAMES            = NO
+JAVADOC_AUTOBRIEF      = NO
+MULTILINE_CPP_IS_BRIEF = NO
+DETAILS_AT_TOP         = YES
+INHERIT_DOCS           = YES
+SEPARATE_MEMBER_PAGES  = NO
+TAB_SIZE               = 8
+ALIASES                = 
+OPTIMIZE_OUTPUT_FOR_C  = NO
+OPTIMIZE_OUTPUT_JAVA   = NO
+BUILTIN_STL_SUPPORT    = NO
+DISTRIBUTE_GROUP_DOC   = NO
+SUBGROUPING            = YES
+#---------------------------------------------------------------------------
+# Build related configuration options
+#---------------------------------------------------------------------------
+EXTRACT_ALL            = YES
+EXTRACT_PRIVATE        = YES
+EXTRACT_STATIC         = YES
+EXTRACT_LOCAL_CLASSES  = YES
+EXTRACT_LOCAL_METHODS  = NO
+HIDE_UNDOC_MEMBERS     = NO
+HIDE_UNDOC_CLASSES     = NO
+HIDE_FRIEND_COMPOUNDS  = NO
+HIDE_IN_BODY_DOCS      = NO
+INTERNAL_DOCS          = NO
+CASE_SENSE_NAMES       = YES
+HIDE_SCOPE_NAMES       = NO
+SHOW_INCLUDE_FILES     = YES
+INLINE_INFO            = YES
+SORT_MEMBER_DOCS       = YES
+SORT_BRIEF_DOCS        = NO
+SORT_BY_SCOPE_NAME     = NO
+GENERATE_TODOLIST      = YES
+GENERATE_TESTLIST      = YES
+GENERATE_BUGLIST       = YES
+GENERATE_DEPRECATEDLIST= YES
+ENABLED_SECTIONS       = 
+MAX_INITIALIZER_LINES  = 30
+SHOW_USED_FILES        = YES
+SHOW_DIRECTORIES       = NO
+FILE_VERSION_FILTER    = 
+#---------------------------------------------------------------------------
+# configuration options related to warning and progress messages
+#---------------------------------------------------------------------------
+QUIET                  = YES
+WARNINGS               = YES
+WARN_IF_UNDOCUMENTED   = YES
+WARN_IF_DOC_ERROR      = YES
+WARN_NO_PARAMDOC       = YES
+WARN_FORMAT            = "$file:$line: $text"
+WARN_LOGFILE           = 
+#---------------------------------------------------------------------------
+# configuration options related to the input files
+#---------------------------------------------------------------------------
+INPUT                  = /home/hehi/cholm/work/alice/aliroot/FMD
+FILE_PATTERNS          = *.h
+RECURSIVE              = NO
+EXCLUDE                = 
+EXCLUDE_SYMLINKS       = NO
+EXCLUDE_PATTERNS       = 
+EXAMPLE_PATH           = /home/hehi/cholm/work/alice/aliroot/FMD/scripts/
+EXAMPLE_PATTERNS       = *.C
+EXAMPLE_RECURSIVE      = NO
+IMAGE_PATH             = 
+INPUT_FILTER           = 
+FILTER_PATTERNS        = 
+FILTER_SOURCE_FILES    = NO
+#---------------------------------------------------------------------------
+# configuration options related to source browsing
+#---------------------------------------------------------------------------
+SOURCE_BROWSER         = NO
+INLINE_SOURCES         = NO
+STRIP_CODE_COMMENTS    = YES
+REFERENCED_BY_RELATION = NO
+REFERENCES_RELATION    = NO
+USE_HTAGS              = NO
+VERBATIM_HEADERS       = NO
+#---------------------------------------------------------------------------
+# configuration options related to the alphabetical class index
+#---------------------------------------------------------------------------
+ALPHABETICAL_INDEX     = YES
+COLS_IN_ALPHA_INDEX    = 5
+IGNORE_PREFIX          = 
+#---------------------------------------------------------------------------
+# configuration options related to the HTML output
+#---------------------------------------------------------------------------
+GENERATE_HTML          = YES
+HTML_OUTPUT            = html
+HTML_FILE_EXTENSION    = .html
+HTML_HEADER            = 
+HTML_FOOTER            = 
+HTML_STYLESHEET        = 
+HTML_ALIGN_MEMBERS     = YES
+GENERATE_HTMLHELP      = NO
+CHM_FILE               = 
+HHC_LOCATION           = 
+GENERATE_CHI           = NO
+BINARY_TOC             = NO
+TOC_EXPAND             = NO
+DISABLE_INDEX          = NO
+ENUM_VALUES_PER_LINE   = 4
+GENERATE_TREEVIEW      = NO
+TREEVIEW_WIDTH         = 250
+#---------------------------------------------------------------------------
+# configuration options related to the LaTeX output
+#---------------------------------------------------------------------------
+GENERATE_LATEX         = NO
+LATEX_OUTPUT           = latex
+LATEX_CMD_NAME         = latex
+MAKEINDEX_CMD_NAME     = makeindex
+COMPACT_LATEX          = NO
+PAPER_TYPE             = a4wide
+EXTRA_PACKAGES         = 
+LATEX_HEADER           = 
+PDF_HYPERLINKS         = NO
+USE_PDFLATEX           = NO
+LATEX_BATCHMODE        = NO
+LATEX_HIDE_INDICES     = NO
+#---------------------------------------------------------------------------
+# configuration options related to the RTF output
+#---------------------------------------------------------------------------
+GENERATE_RTF           = NO
+RTF_OUTPUT             = rtf
+COMPACT_RTF            = NO
+RTF_HYPERLINKS         = NO
+RTF_STYLESHEET_FILE    = 
+RTF_EXTENSIONS_FILE    = 
+#---------------------------------------------------------------------------
+# configuration options related to the man page output
+#---------------------------------------------------------------------------
+GENERATE_MAN           = NO
+MAN_OUTPUT             = man
+MAN_EXTENSION          = .3
+MAN_LINKS              = NO
+#---------------------------------------------------------------------------
+# configuration options related to the XML output
+#---------------------------------------------------------------------------
+GENERATE_XML           = NO
+XML_OUTPUT             = xml
+XML_SCHEMA             = 
+XML_DTD                = 
+XML_PROGRAMLISTING     = YES
+#---------------------------------------------------------------------------
+# configuration options for the AutoGen Definitions output
+#---------------------------------------------------------------------------
+GENERATE_AUTOGEN_DEF   = NO
+#---------------------------------------------------------------------------
+# configuration options related to the Perl module output
+#---------------------------------------------------------------------------
+GENERATE_PERLMOD       = NO
+PERLMOD_LATEX          = NO
+PERLMOD_PRETTY         = YES
+PERLMOD_MAKEVAR_PREFIX = 
+#---------------------------------------------------------------------------
+# Configuration options related to the preprocessor   
+#---------------------------------------------------------------------------
+ENABLE_PREPROCESSING   = YES
+MACRO_EXPANSION        = YES
+EXPAND_ONLY_PREDEF     = NO
+SEARCH_INCLUDES        = YES
+INCLUDE_PATH           = 
+INCLUDE_FILE_PATTERNS  = 
+PREDEFINED             = 
+EXPAND_AS_DEFINED      = 
+SKIP_FUNCTION_MACROS   = YES
+#---------------------------------------------------------------------------
+# Configuration::additions related to external references   
+#---------------------------------------------------------------------------
+TAGFILES               = 
+GENERATE_TAGFILE       = 
+ALLEXTERNALS           = NO
+EXTERNAL_GROUPS        = YES
+PERL_PATH              = /usr/bin/perl
+#---------------------------------------------------------------------------
+# Configuration options related to the dot tool   
+#---------------------------------------------------------------------------
+CLASS_DIAGRAMS         = YES
+HIDE_UNDOC_RELATIONS   = YES
+HAVE_DOT               = YES
+CLASS_GRAPH            = YES
+COLLABORATION_GRAPH    = YES
+GROUP_GRAPHS           = YES
+UML_LOOK               = YES
+TEMPLATE_RELATIONS     = NO
+INCLUDE_GRAPH          = YES
+INCLUDED_BY_GRAPH      = YES
+CALL_GRAPH             = NO
+GRAPHICAL_HIERARCHY    = YES
+DIRECTORY_GRAPH        = YES
+DOT_IMAGE_FORMAT       = png
+DOT_PATH               = 
+DOTFILE_DIRS           = 
+MAX_DOT_GRAPH_WIDTH    = 1024
+MAX_DOT_GRAPH_HEIGHT   = 1024
+MAX_DOT_GRAPH_DEPTH    = 1000
+DOT_TRANSPARENT        = NO
+DOT_MULTI_TARGETS      = YES
+GENERATE_LEGEND        = YES
+DOT_CLEANUP            = YES
+#---------------------------------------------------------------------------
+# Configuration::additions related to the search engine   
+#---------------------------------------------------------------------------
+SEARCHENGINE           = NO
index a3c1b02..8569b45 100644 (file)
@@ -16,6 +16,7 @@
 // #pragma link C++ class  AliFMDMap<std::pair<Float_t,UShort_t> >;
 // #pragma link C++ typedef  AliFMDEdepMap;
 #pragma link C++ class  AliFMDEdepMap+;
+#pragma link C++ class  AliFMDEdepHitPair+;
 #pragma link C++ class  AliFMDHit+;
 #pragma link C++ class  AliFMD+;
 #pragma link C++ class  AliFMDv0+;