Fix to avoid deleting cached CDB objects - modified fix by Peter.
[u/mrichter/AliRoot.git] / FMD / AliFMD.cxx
index 489cdad..0e35d5f 100644 (file)
  * about the suitability of this software for any purpose. It is          *
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
-
 /* $Id$ */
-
+/** @file    AliFMD.cxx
+    @author  Christian Holm Christensen <cholm@nbi.dk>
+    @date    Sun Mar 26 17:59:18 2006
+    @brief   Implementation of AliFMD base class 
+*/
 //____________________________________________________________________
 //                                                                          
 // Forward Multiplicity Detector based on Silicon wafers. This class
-// contains the base procedures for the Forward Multiplicity detector
-// Detector consists of 5 Si volumes covered pseudorapidity interval
-// from 1.7 to 5.1.
+// 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 geometry 
+// that handles the simulation
 //
 //
 //       +----------+   +----------+   
-//       | AliFMDv1 |  | AliFMDv1 |   
+//       | AliFMDv1 |  | AliFMDv0 |   
 //       +----------+   +----------+   
-//            |              |
-//       +----+--------------+
-//       |
-//       |           +------------+ 1  +---------------+
-//       |        +- | AliFMDRing |<>--| AliFMDPolygon | 
-//       V     2  |  +------------+    +---------------+   
-//  +--------+<>--+        |
-//  | AliFMD |             ^                       
-//  +--------+<>--+        V 1..2                     
-//            3  | +-------------------+ 
-//               +-| AliFMDSubDetector | 
-//                 +-------------------+
-//                           ^              
-//                           |
-//             +-------------+-------------+
-//             |             |             |         
-//        +---------+   +---------+   +---------+
-//        | AliFMD1 |   | AliFMD2 |   | AliFMD3 |
-//        +---------+   +---------+   +---------+
-//      
+//            |              |                    +-----------------+
+//       +----+--------------+                 +--| AliFMDDigitizer |
+//       |                                     |  +-----------------+
+//       |           +---------------------+   |
+//       |        +--| AliFMDBaseDigitizer |<--+
+//       V     1  |  +---------------------+   |
+//  +--------+<>--+                            |  +------------------+
+//  | AliFMD |                                 +--| AliFMDSDigitizer |    
+//  +--------+<>--+                               +------------------+       
+//            1  |  +---------------------+
+//               +--| AliFMDReconstructor |
+//                  +---------------------+
 //
 // *  AliFMD 
 //    This defines the interface for the various parts of AliROOT that
-//    uses the FMD, like AliFMDDigitizer, AliFMDReconstructor, and so
-//    on. 
+//    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. 
 //    geometry, process hits in the FMD, and serve hits and digits to
 //    the various clients. 
 //  
-//    It uses the objects of class AliFMDSubDetector to do the various
-//    stuff for FMD1, 2, and 3 
-//
-// *  AliFMDRing 
-//    This class contains all stuff needed to do with a ring.  It's
-//    used by the AliFMDSubDetector objects to instantise inner and
-//    outer rings.  The AliFMDRing objects are shared by the
-//    AliFMDSubDetector objects, and owned by the AliFMDv1 object. 
-//
-// *  AliFMDPolygon 
-//    The code I lifted from TGeoPolygon to help with the geometry of
-//    the modules, as well as to decide wether a hit is actually with
-//    in the real module shape.  The point is, that the shape of the
-//    various ring modules are really polygons (much like the lid of a
-//    coffin), but it's segmented at constant radius.  That is very
-//    hard to implement using GEANT 3.21 shapes, so instead the
-//    modules are implemented as TUBS (tube sections), and in the step
-//    procedure we do the test whether the track was inside the real
-//    shape of the module.  
-//
-// *  AliFMD1, AliFMD2, and AliFMD3 
-//    These are specialisation of AliFMDSubDetector, 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.                          
+// *  AliFMDSimulator
+//    This is the base class for the FMD simulation tasks.   The
+//    simulator tasks are responsible to implment the geoemtry, and
+//    process hits. 
 //                                                                          
-// The responsible person for this module is Alla Maevskaia
-// <Alla.Maevskaia@cern.ch>.
+// *  AliFMDReconstructor
+//    This is a concrete implementation of the AliReconstructor that
+//    reconstructs pseudo-inclusive-multiplicities from digits (raw or
+//    from simulation)
 //
-// Many modifications by Christian Holm Christensen <cholm@nbi.dk>
+// 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.
 //
 
-#include "TClonesArray.h"      // ROOT_TClonesArray
-#include "TGeometry.h"         // ROOT_TGeomtry
-#include "TNode.h"             // ROOT_TNode
-#include "TTUBE.h"             // ROOT_TTUBE
-#include "TTree.h"             // ROOT_TTree
-#include "TVirtualMC.h"                // ROOT_TVirtualMC
-#include "TBrowser.h"          // ROOT_TBrowser
-#include "TMath.h"             // ROOT_TMath
-
-#include "AliRunDigitizer.h"   // ALIRUNDIGITIZER_H
-#include "AliLoader.h"         // ALILOADER_H
-#include "AliRun.h"            // ALIRUN_H
-#include "AliMC.h"             // ALIMC_H
-#include "AliLog.h"            // ALILOG_H
-#include "AliMagF.h"           // ALIMAGF_H
+// These files are not in the same directory, so there's no reason to
+// ask the preprocessor to search in the current directory for these
+// files by including them with `#include "..."' 
+#include <TBrowser.h>          // ROOT_TBrowser
+#include <TClonesArray.h>      // ROOT_TClonesArray
+#include <TGeoGlobalMagField.h> // ROOT_TGeoGlobalMagField
+#include <TGeoManager.h>        // ROOT_TGeoManager
+#include <TRotMatrix.h>                // ROOT_TRotMatrix
+#include <TTree.h>             // ROOT_TTree
+#include <TVector2.h>           // ROOT_TVector2 
+#include <TVirtualMC.h>                // ROOT_TVirtualMC
+#include <cmath>                // __CMATH__
+
+#include <AliRunDigitizer.h>   // ALIRUNDIGITIZER_H
+#include <AliLoader.h>         // ALILOADER_H
+#include <AliRun.h>            // ALIRUN_H
+#include <AliMC.h>             // ALIMC_H
+#include <AliMagF.h>           // ALIMAGF_H
+// #include <AliLog.h>         // ALILOG_H
+#include "AliFMDDebug.h" // Better debug macros
 #include "AliFMD.h"            // ALIFMD_H
-#include "AliFMDDigit.h"       // ALIFMDDIGIG_H
+#include "AliFMDDigit.h"       // ALIFMDDIGIT_H
+#include "AliFMDSDigit.h"      // ALIFMDSDIGIT_H
 #include "AliFMDHit.h"         // ALIFMDHIT_H
+#include "AliFMDGeometry.h"    // ALIFMDGEOMETRY_H
+#include "AliFMDDetector.h"    // ALIFMDDETECTOR_H
+#include "AliFMDRing.h"                // ALIFMDRING_H
 #include "AliFMDDigitizer.h"   // ALIFMDDIGITIZER_H
-#include "AliFMD1.h"           // ALIFMD1_H
-#include "AliFMD2.h"           // ALIFMD2_H
-#include "AliFMD3.h"           // ALIFMD3_H
+#include "AliFMDHitDigitizer.h"        // ALIFMDSDIGITIZER_H
+// #define USE_SSDIGITIZER 
+//#ifdef USE_SSDIGITIZER
+//# include "AliFMDSSDigitizer.h"      // ALIFMDSDIGITIZER_H
+//#endif
+// #include "AliFMDGeometryBuilder.h"
 #include "AliFMDRawWriter.h"   // ALIFMDRAWWRITER_H
+#include "AliFMDRawReader.h"   // ALIFMDRAWREADER_H
+#include "AliTrackReference.h" 
+#include "AliFMDStripIndex.h"
+#include "AliFMDParameters.h"
+#include "AliFMDReconstructor.h"
 
 //____________________________________________________________________
-ClassImp(AliFMD);
+ClassImp(AliFMD)
+#if 0
+  ; // This is to keep Emacs from indenting the next line 
+#endif 
 
 //____________________________________________________________________
 AliFMD::AliFMD()
-  : fInner(0), 
-    fOuter(0),
-    fFMD1(0),
-    fFMD2(0), 
-    fFMD3(0), 
+  : AliDetector(),
     fSDigits(0), 
     fNsdigits(0),
-    fSiDensity(0),
-    fPrintboardRotationId(0),
-    fIdentityRotationId(0),
-    fShortLegId(0),
-    fLongLegId(0),
-    fLegLength(0),
-    fLegRadius(0),
-    fModuleSpacing(0)
+    fDetailed(kTRUE),
+    fUseOld(kFALSE),
+    fUseAssembly(kTRUE),
+    fBad(0) 
 {
   //
   // Default constructor for class AliFMD
   //
-  AliDebug(0, "Default CTOR");
-  fHits     = 0;
-  fDigits   = 0;
-  fIshunt   = 0;
+  AliFMDDebug(10, ("\tDefault CTOR"));
+  fHits        = 0;
+  fDigits      = 0;
+  fIshunt      = 0;
+  // fBad         = new TClonesArray("AliFMDHit");
 }
 
 //____________________________________________________________________
-AliFMD::AliFMD(const char *name, const char *title, bool detailed)
+AliFMD::AliFMD(const char *name, const char *title)
   : AliDetector (name, title),
-    fInner(0), 
-    fOuter(0),
-    fFMD1(0),
-    fFMD2(0), 
-    fFMD3(0),
     fSDigits(0),
     fNsdigits(0),
-    fSiDensity(0),
-    fPrintboardRotationId(0),
-    fIdentityRotationId(0),
-    fShortLegId(0),
-    fLongLegId(0),
-    fLegLength(0),
-    fLegRadius(0),
-    fModuleSpacing(0)
+    fDetailed(kTRUE),
+    fUseOld(kFALSE),
+    fUseAssembly(kFALSE),
+    fBad(0)
 {
   //
   // Standard constructor for Forward Multiplicity Detector
   //
-  AliDebug(0, "Standard CTOR");
-
+  AliFMDDebug(10, ("\tStandard CTOR"));
+  // fBad         = new TClonesArray("AliFMDHit");
+  
   // Initialise Hit array
-  HitsArray();
-  gAlice->GetMCApp()->AddHitList(fHits);
+  // HitsArray();
+  // gAlice->GetMCApp()->AddHitList(fHits);
 
   // (S)Digits for the detectors disk
-  DigitsArray();
-  SDigitsArray();
+  // DigitsArray();
+  // SDigitsArray();
   
   // CHC: What is this?
   fIshunt = 0;
-  SetMarkerColor(kRed);
-  SetLineColor(kYellow);
-  SetSiDensity();
-
-  // Create sub-volume managers 
-  fInner = new AliFMDRing('I', detailed);
-  fOuter = new AliFMDRing('O', detailed);
-  fFMD1  = new AliFMD1();
-  fFMD2  = new AliFMD2();
-  fFMD3  = new AliFMD3();
-
-  // Specify parameters of sub-volume managers 
-  fFMD1->SetInner(fInner);
-  fFMD1->SetOuter(0);
-
-  fFMD2->SetInner(fInner);
-  fFMD2->SetOuter(fOuter);
-  
-  fFMD3->SetInner(fInner);
-  fFMD3->SetOuter(fOuter);
-
-  SetLegLength();
-  SetLegRadius();
-  SetLegOffset();
-  SetModuleSpacing();
-  
-  fInner->SetLowR(4.3);
-  fInner->SetHighR(17.2);
-  fInner->SetWaferRadius(13.4/2);
-  fInner->SetTheta(36/2);
-  fInner->SetNStrips(512);
-  fInner->SetSiThickness(.03);
-  fInner->SetPrintboardThickness(.11);
-  fInner->SetBondingWidth(.5);
-
-  fOuter->SetLowR(15.6);
-  fOuter->SetHighR(28.0);
-  fOuter->SetWaferRadius(13.4/2);
-  fOuter->SetTheta(18/2);
-  fOuter->SetNStrips( 256);
-  fOuter->SetSiThickness(.03);
-  fOuter->SetPrintboardThickness(.1);
-  fOuter->SetBondingWidth(.5);
-  
-  
-  fFMD1->SetHoneycombThickness(1);
-  fFMD1->SetInnerZ(340.0);
-  
-  fFMD2->SetHoneycombThickness(1);
-  fFMD2->SetInnerZ(83.4);
-  fFMD2->SetOuterZ(75.2);
-
-  fFMD3->SetHoneycombThickness(1);
-  fFMD3->SetInnerZ(-62.8);
-  fFMD3->SetOuterZ(-75.2);
+  //PH  SetMarkerColor(kRed);
+  //PH  SetLineColor(kYellow);
 }
 
 //____________________________________________________________________
@@ -260,8 +197,14 @@ AliFMD::~AliFMD ()
     delete fSDigits;
     fSDigits = 0;
   }
+  if (fBad) {
+    fBad->Delete();
+    delete fBad;
+    fBad = 0;
+  }
 }
 
+
 //====================================================================
 //
 // GEometry ANd Traking
@@ -272,96 +215,58 @@ 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:
+  // construction of the geometry is delegated to the class
+  // AliFMDGeometryBuilder, invoked by the singleton manager
+  // AliFMDGeometry. 
   //
-  //   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
-  //   
-
-  // DebugGuard guard("AliFMD::CreateGeometry");
-  AliDebug(10, "Creating geometry");
-
-  fInner->Init();
-  fOuter->Init();
-
-  TString name;
-  Double_t par[3];
-
-  par[0]      =  fLegRadius - .1;
-  par[1]      =  fLegRadius;
-  par[2]      =  fLegLength / 2;
-  name        =  "FSL";
-  fShortLegId =  gMC->Gsvolu(name.Data(),"TUBE",(*fIdtmed)[kPlasticId],par,3);
-  
-  par[2]      += fModuleSpacing / 2;
-  name        = "FLL";
-  fLongLegId  =  gMC->Gsvolu(name.Data(),"TUBE",(*fIdtmed)[kPlasticId],par,3);
-
-  fInner->SetupGeometry((*fIdtmed)[kAirId], 
-                       (*fIdtmed)[kSiId], 
-                       (*fIdtmed)[kPcbId], 
-                       fPrintboardRotationId, 
-                       fIdentityRotationId);
-  fOuter->SetupGeometry((*fIdtmed)[kAirId], 
-                       (*fIdtmed)[kSiId], 
-                       (*fIdtmed)[kPcbId], 
-                       fPrintboardRotationId, 
-                       fIdentityRotationId);
-
-  fFMD1->SetupGeometry((*fIdtmed)[kAirId], (*fIdtmed)[kKaptionId]);
-  fFMD2->SetupGeometry((*fIdtmed)[kAirId], (*fIdtmed)[kKaptionId]);
-  fFMD3->SetupGeometry((*fIdtmed)[kAirId], (*fIdtmed)[kKaptionId]);
-  
-  fFMD1->Geometry("ALIC", fPrintboardRotationId, fIdentityRotationId);
-  fFMD2->Geometry("ALIC", fPrintboardRotationId, fIdentityRotationId);
-  fFMD3->Geometry("ALIC", fPrintboardRotationId, fIdentityRotationId);    
+  AliFMDGeometry*  fmd = AliFMDGeometry::Instance();
+  fmd->SetDetailed(fDetailed);
+  fmd->UseAssembly(fUseAssembly);
+  fmd->Build();
 }    
 
 //____________________________________________________________________
 void AliFMD::CreateMaterials() 
 {
-  // Register various materials and tracking mediums with the
-  // backend.   
-  // 
-  // Currently defined materials and mediums are 
-  // 
-  //    FMD Air                Normal air 
-  //    FMD Si          Active silicon of sensors 
-  //    FMD Carbon      Normal carbon used in support, etc. 
-  //    FMD Kapton      Carbon used in Honeycomb
-  //    FMD PCB         Printed circuit board material 
-  //    FMD Plastic     Material for support legs 
+  // Define the materials and tracking mediums needed by the FMD
+  // simulation.   These mediums are made by sending the messages
+  // AliMaterial, AliMixture, and AliMedium to the passed AliModule
+  // object module.   The defined mediums are 
   // 
-  // Also defined are two rotation matricies. 
+  //   FMD Si$         Silicon (active medium in sensors)
+  //   FMD C$          Carbon fibre (support cone for FMD3 and vacuum pipe)
+  //   FMD Al$         Aluminium (honeycomb support plates)
+  //   FMD PCB$        Printed Circuit Board (FEE board with VA1_3)
+  //   FMD Chip$       Electronics chips (currently not used)
+  //   FMD Air$        Air (Air in the FMD)
+  //   FMD Plastic$    Plastic (Support legs for the hybrid cards)
   //
-  // DebugGuard guard("AliFMD::CreateMaterials");
-  AliDebug(10, "Creating materials");
+  // 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. 
+  //
+  AliFMDDebug(10, ("\tCreating materials"));
+  // Get pointer to geometry singleton object. 
+  AliFMDGeometry* geometry = AliFMDGeometry::Instance();
+  geometry->Init();
+#if 0
+  if (gGeoManager && gGeoManager->GetMedium("FMD Si$")) {
+    // We need to figure out the some stuff about the geometry
+    fmd->ExtractGeomInfo();
+    return;
+  }
+#endif  
   Int_t    id;
   Double_t a                = 0;
   Double_t z                = 0;
   Double_t density          = 0;
   Double_t radiationLength  = 0;
   Double_t absorbtionLength = 999;
-  Int_t    fieldType        = gAlice->Field()->Integ();     // Field type 
-  Double_t maxField         = gAlice->Field()->Max();     // Field max.
+  Int_t    fieldType        = ((AliMagF*)TGeoGlobalMagField::Instance()->GetField())->Integ();     // Field type 
+  Double_t maxField         = ((AliMagF*)TGeoGlobalMagField::Instance()->GetField())->Max();     // Field max.
   Double_t maxBending       = 0;     // Max Angle
   Double_t maxStepSize      = 0.001; // Max step size 
   Double_t maxEnergyLoss    = 1;     // Max Delta E
@@ -371,17 +276,17 @@ void AliFMD::CreateMaterials()
   // Silicon 
   a                = 28.0855;
   z                = 14.;
-  density          = fSiDensity;
+  density          = geometry->GetSiDensity();
   radiationLength  = 9.36;
   maxBending       = 1;
   maxStepSize      = .001;
   precision        = .001;
   minStepSize      = .001;
   id               = kSiId;
-  AliMaterial(id, "FMD Si$", a, z, density, radiationLength, absorbtionLength);
-  AliMedium(kSiId, "FMD Si$",id,1,fieldType,maxField,maxBending,
+  AliMaterial(id, "Si$", a, z, density, radiationLength, absorbtionLength);
+  AliMedium(kSiId, "Si$", id,1,fieldType,maxField,maxBending,
            maxStepSize,maxEnergyLoss,precision,minStepSize);
-
+  
 
   // Carbon 
   a                = 12.011;
@@ -393,32 +298,53 @@ void AliFMD::CreateMaterials()
   precision        = .003;
   minStepSize      = .003;
   id               = kCarbonId;
-  AliMaterial(id, "FMD Carbon$", a, z, density, radiationLength, 
-             absorbtionLength);
-  AliMedium(kCarbonId, "FMD Carbon$",id,0,fieldType,maxField,maxBending,
-           maxStepSize,maxEnergyLoss,precision,minStepSize);
+  AliMaterial(id, "Carbon$", a, z, density, radiationLength, absorbtionLength);
+  AliMedium(kCarbonId, "Carbon$", id,0,fieldType,maxField,maxBending,
+                   maxStepSize,maxEnergyLoss,precision,minStepSize);
+
+  // Aluminum
+  a                = 26.981539;
+  z                = 13.;
+  density          = 2.7;
+  radiationLength  = 8.9;
+  id               = kAlId;
+  AliMaterial(id, "Aluminum$",a,z, density, radiationLength, absorbtionLength);
+  AliMedium(kAlId, "Aluminum$", id, 0, fieldType, maxField, maxBending,
+           maxStepSize, maxEnergyLoss, precision, minStepSize);
+  
+  
+  // Copper 
+  a                = 63.546;
+  z                = 29;
+  density          =  8.96;
+  radiationLength  =  1.43;
+  id               = kCopperId;
+  AliMaterial(id, "Copper$", 
+                     a, z, density, radiationLength, absorbtionLength);
+  AliMedium(kCopperId, "Copper$", id, 0, fieldType, maxField, maxBending,
+           maxStepSize, maxEnergyLoss, precision, minStepSize);
+  
 
   // Silicon chip 
   {
     Float_t as[] = { 12.0107,      14.0067,      15.9994,
-                    1.00794,      28.0855,     107.8682 };
+                     1.00794,     28.0855,     107.8682 };
     Float_t zs[] = {  6.,           7.,           8.,
                      1.,          14.,          47. };
     Float_t ws[] = {  0.039730642,  0.001396798,  0.01169634,
                      0.004367771,  0.844665,     0.09814344903 };
-    density = 2.36436;
+    density          = 2.36436;
     maxBending       = 10;
     maxStepSize      = .01;
     precision        = .003;
     minStepSize      = .003;
-    id = kSiChipId;
-    AliMixture(id, "FMD Si Chip$", as, zs, density, 6, ws);
-    AliMedium(kSiChipId, "FMD Si Chip$", id, 0, fieldType, maxField, 
-             maxBending, maxStepSize, maxEnergyLoss, precision, minStepSize);
+    id               = kSiChipId;
+    AliMixture(id, "Si Chip$", as, zs, density, 6, ws);
+    AliMedium(kSiChipId, "Si Chip$",  id, 0, fieldType, maxField, maxBending, 
+             maxStepSize, maxEnergyLoss, precision, minStepSize);
   }
   
-
-  // Kaption 
+  // Kaption
   {
     Float_t as[] = { 1.00794,  12.0107,  14.010,   15.9994};
     Float_t zs[] = { 1.,        6.,       7.,       8.};
@@ -428,12 +354,12 @@ void AliFMD::CreateMaterials()
     maxStepSize      = .001;
     precision        = .001;
     minStepSize      = .001;
-    id               = kKaptionId;
-    AliMixture(id, "FMD Kaption$", as, zs, density, 4, ws);
-    AliMedium(kKaptionId, "FMD Kaption$",id,0,fieldType,maxField,maxBending,
+    id               = kKaptonId;
+    AliMixture(id, "Kaption$", as, zs, density, 4, ws);
+    AliMedium(kKaptonId, "Kaption$", id,0,fieldType,maxField,maxBending,
              maxStepSize,maxEnergyLoss,precision,minStepSize);
   }
-  
+
   // Air
   {
     Float_t as[] = { 12.0107, 14.0067,   15.9994,  39.948 };
@@ -445,8 +371,8 @@ void AliFMD::CreateMaterials()
     precision    = .001;
     minStepSize  = .001;
     id           = kAirId;
-    AliMixture(id, "FMD Air$", as, zs, density, 4, ws);
-    AliMedium(kAirId, "FMD Air$", id,0,fieldType,maxField,maxBending,
+    AliMixture(id, "Air$", as, zs, density, 4, ws);
+    AliMedium(kAirId, "Air$", id,0,fieldType,maxField,maxBending,
              maxStepSize,maxEnergyLoss,precision,minStepSize);
   }
   
@@ -470,11 +396,22 @@ void AliFMD::CreateMaterials()
     precision    = .001;
     minStepSize  = .001;
     id           = kPcbId;
-    AliMixture(id, "FMD PCB$", as, zs, density, 14, ws);
-    AliMedium(kPcbId, "FMD PCB$", id,1,fieldType,maxField,maxBending,
+    AliMixture(id, "PCB$", as, zs, density, 14, ws);
+    AliMedium(kPcbId, "PCB$", id,0,fieldType,maxField,maxBending,
              maxStepSize,maxEnergyLoss,precision,minStepSize);
   }
   
+  // Stainless steel
+  {
+    Float_t as[] = { 55.847, 51.9961, 58.6934, 28.0855 };
+    Float_t zs[] = { 26.,    24.,     28.,     14.     };
+    Float_t ws[] = { .715,   .18,     .1,      .005    };
+    density      = 7.88;
+    id           = kSteelId;
+    AliMixture(id, "Steel$", as, zs, density, 4, ws);
+    AliMedium(kSteelId, "Steel$", id, 0, fieldType, maxField, maxBending, 
+             maxStepSize, maxEnergyLoss, precision, minStepSize);
+  }
   // Plastic 
   {
     Float_t as[] = { 1.01, 12.01 };
@@ -486,104 +423,129 @@ void AliFMD::CreateMaterials()
     precision    = .003;
     minStepSize  = .003;
     id           = kPlasticId;
-    AliMixture(id, "FMD Plastic$", as, zs, density, -2, ws);
-    AliMedium(kPlasticId, "FMD Plastic$", id,0,fieldType,maxField,maxBending,
-               maxStepSize,maxEnergyLoss,precision,minStepSize);
+    AliMixture(id, "Plastic$", as, zs, density, -2, ws);
+    AliMedium(kPlasticId, "Plastic$", id,0,fieldType,maxField,maxBending,
+             maxStepSize,maxEnergyLoss,precision,minStepSize);
   }
-  AliMatrix(fPrintboardRotationId, 90, 90, 0, 90, 90, 0);
-  AliMatrix(fIdentityRotationId, 90, 0, 90, 90, 0, 0);
+
 }
 
+#if 0
 //____________________________________________________________________
 void  
-AliFMD::Init()
+AliFMD::SetTrackingParameters(Int_t imed, 
+                             Float_t gamma,                 
+                             Float_t electron, 
+                             Float_t neutral_hadron, 
+                             Float_t charged_hadron, 
+                             Float_t muon,
+                             Float_t electron_bremstrahlung, 
+                             Float_t muon__bremstrahlung, 
+                             Float_t electron_delta,
+                             Float_t muon_delta,
+                             Float_t muon_pair,
+                             Int_t   annihilation, 
+                             Int_t   bremstrahlung, 
+                             Int_t   compton_scattering, 
+                             Int_t   decay,
+                             Int_t   delta_ray, 
+                             Int_t   hadronic, 
+                             Int_t   energy_loss, 
+                             Int_t   multiple_scattering, 
+                             Int_t   pair_production, 
+                             Int_t   photon_production, 
+                             Int_t   rayleigh_scattering)
 {
-  //
-  // Initialis the FMD after it has been built
-  Int_t i;
-  //
-  if (fDebug) {
-    cout << "\n" << ClassName() << ": " << flush;
-    for (i = 0; i < 35; i++) cout << "*";
-    cout << " FMD_INIT ";
-    for (i = 0; i < 35; i++) cout << "*";
-    cout << "\n" << ClassName() << ": " << flush;
-    //
-    // Here the FMD initialisation code (if any!)
-    for (i = 0; i < 80; i++) cout << "*";
-    cout << endl;
-  }
-  //
-  //
+  // Disabled by request of FCA, kept for reference only
+  if (!gMC) return;
+  TArrayI& idtmed = *(GetIdtmed());
+  Int_t    iimed  = idtmed[imed];
+  // gMC->Gstpar(iimed, "CUTGAM",      gamma);
+  // gMC->Gstpar(iimed, "CUTELE",      electron);
+  // gMC->Gstpar(iimed, "CUTNEU",      neutral_hadron);
+  // gMC->Gstpar(iimed, "CUTHAD",      charged_hadron);
+  // gMC->Gstpar(iimed, "CUTMUO",      muon);
+  // gMC->Gstpar(iimed, "BCUTE",       electron_bremstrahlung);
+  // gMC->Gstpar(iimed, "BCUTM",       muon__bremstrahlung);
+  // gMC->Gstpar(iimed, "DCUTE",       electron_delta);
+  // gMC->Gstpar(iimed, "DCUTM",       muon_delta);
+  // gMC->Gstpar(iimed, "PPCUTM",      muon_pair);
+  // gMC->Gstpar(iimed, "ANNI",        Float_t(annihilation));
+  // gMC->Gstpar(iimed, "BREM",        Float_t(bremstrahlung));
+  // gMC->Gstpar(iimed, "COMP",        Float_t(compton_scattering));
+  // gMC->Gstpar(iimed, "DCAY",        Float_t(decay));
+  // gMC->Gstpar(iimed, "DRAY",        Float_t(delta_ray));
+  // gMC->Gstpar(iimed, "HADR",        Float_t(hadronic));
+  // gMC->Gstpar(iimed, "LOSS",        Float_t(energy_loss));
+  // gMC->Gstpar(iimed, "MULS",        Float_t(multiple_scattering));
+  // gMC->Gstpar(iimed, "PAIR",        Float_t(pair_production));
+  // gMC->Gstpar(iimed, "PHOT",        Float_t(photon_production));
+  // gMC->Gstpar(iimed, "RAYL",        Float_t(rayleigh_scattering));
 }
+#endif
 
-//====================================================================
-//
-// Graphics and event display
-//
 //____________________________________________________________________
-void 
-AliFMD::BuildGeometry()
+void  
+AliFMD::Init()
 {
-  //
-  // Build simple ROOT TNode geometry for event display
-  //
-  // Build a simplified geometry of the FMD used for event display  
+  // Initialize the detector 
   // 
-  // The actual building of the TNodes is done by
-  // AliFMDSubDetector::SimpleGeometry. 
-  AliDebug(10, "Creating a simplified geometry");
-
-  TNode* top = gAlice->GetGeometry()->GetNode("alice");
-  
-  fFMD1->SimpleGeometry(fNodes, top, GetLineColor(), 0);
-  fFMD2->SimpleGeometry(fNodes, top, GetLineColor(), 0);
-  fFMD3->SimpleGeometry(fNodes, top, GetLineColor(), 0);
+  AliFMDDebug(1, ("Initialising FMD detector object"));
+  TVirtualMC*      mc     = TVirtualMC::GetMC();
+  AliFMDGeometry*  fmd    = AliFMDGeometry::Instance();
+  TArrayI          actGeo = fmd->ActiveIds();
+  bool             valid  = true;
+  if (actGeo.fN <= 0) valid = false;
+  else { 
+    for (int i = 0; i < actGeo.fN; i++) {
+      if (actGeo[i] < 0) { 
+       valid = false;
+       break;
+      }
+    }
+  }
+  if (!valid) { 
+    AliFMDDebug(1, ("Extracting geometry info from loaded geometry"));
+    fmd->ExtractGeomInfo();
+    actGeo = fmd->ActiveIds();
+  }
+  TArrayI          actVmc(actGeo.fN);
+  for (Int_t i = 0; i < actGeo.fN; i++) {
+    if (actGeo[i] < 0) { 
+      AliError(Form("Invalid id: %d", actGeo[i]));
+      continue;
+    }
+    TGeoVolume *sens = gGeoManager->GetVolume(actGeo[i]);
+    if (!sens) {
+      AliError(Form("No TGeo volume for sensitive volume ID=%d",actGeo[i]));
+      continue;
+    }   
+    actVmc[i] = mc->VolId(sens->GetName());
+    AliFMDDebug(1, ("Active vol id # %d: %d changed to %d", 
+                   i, actGeo[i], actVmc[i]));
+  }
+  fmd->SetActive(actVmc.fArray, actVmc.fN);
+  // fmd->InitTransformations();
 }
 
 //____________________________________________________________________
-void 
-AliFMD::DrawDetector()
+void
+AliFMD::FinishEvent()
 {
-  //
-  // Draw a shaded view of the Forward multiplicity detector
-  //
-  // DebugGuard guard("AliFMD::DrawDetector");
-  AliDebug(10, "Draw detector");
-  
-  //Set ALIC mother transparent
-  gMC->Gsatt("ALIC","SEEN",0);
-
-  //Set volumes visible
-  fFMD1->Gsatt();
-  fFMD2->Gsatt();
-  fFMD3->Gsatt();
-  fInner->Gsatt();
-  fOuter->Gsatt();
-
-  //
-  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");
+  // 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("got %d 'bad' hits", fBad->GetEntries()));
+    TIter next(fBad);
+    AliFMDHit* hit;
+    while ((hit = static_cast<AliFMDHit*>(next()))) hit->Print("D");
+    fBad->Clear();
+  }
 }
 
-//____________________________________________________________________
-Int_t 
-AliFMD::DistanceToPrimitive(Int_t, Int_t)
-{
-  //
-  // Calculate the distance from the mouse to the FMD on the screen
-  // Dummy routine
-  //
-  return 9999;
-}
+
 
 //====================================================================
 //
@@ -644,8 +606,6 @@ AliFMD::SetTreeAddress()
   }
 }
 
-
-
 //____________________________________________________________________
 void 
 AliFMD::SetHitsAddressBranch(TBranch *b)
@@ -653,6 +613,13 @@ AliFMD::SetHitsAddressBranch(TBranch *b)
   // Set the TClonesArray to read hits into. 
   b->SetAddress(&fHits);
 }
+//____________________________________________________________________
+void 
+AliFMD::SetSDigitsAddressBranch(TBranch *b)
+{
+  // Set the TClonesArray to read hits into. 
+  b->SetAddress(&fSDigits);
+}
 
 //____________________________________________________________________
 void 
@@ -679,40 +646,41 @@ AliFMD::AddHit(Int_t track, Int_t *vol, Float_t *hits)
   //    hits[9]         [Float_t  ] Time when the track hit
   // 
   // 
-  AddHit(track, 
-        UShort_t(vol[0]),  // Detector # 
-        Char_t(vol[1]),    // Ring ID
-        UShort_t(vol[2]),  // Sector # 
-        UShort_t(vol[3]),  // Strip # 
-        hits[0],           // X
-        hits[1],           // Y
-        hits[2],           // Z
-        hits[3],           // Px
-        hits[4],           // Py
-        hits[5],           // Pz
-        hits[6],           // Energy loss 
-        Int_t(hits[7]),    // PDG 
-        hits[8]);          // Time
+  AddHitByFields(track, 
+                UShort_t(vol[0]),  // Detector # 
+                Char_t(vol[1]),    // Ring ID
+                UShort_t(vol[2]),  // Sector # 
+                UShort_t(vol[3]),  // Strip # 
+                hits[0],           // X
+                hits[1],           // Y
+                hits[2],           // Z
+                hits[3],           // Px
+                hits[4],           // Py
+                hits[5],           // Pz
+                hits[6],           // Energy loss 
+                Int_t(hits[7]),    // PDG 
+                hits[8]);          // Time
 }
 
 //____________________________________________________________________
-void 
-AliFMD::AddHit(Int_t    track, 
-              UShort_t detector, 
-              Char_t   ring, 
-              UShort_t sector, 
-              UShort_t strip, 
-              Float_t  x, 
-              Float_t  y, 
-              Float_t  z,
-              Float_t  px, 
-              Float_t  py, 
-              Float_t  pz,
-              Float_t  edep,
-              Int_t    pdg,
-              Float_t  t)
+AliFMDHit*
+AliFMD::AddHitByFields(Int_t    track, 
+                      UShort_t detector, 
+                      Char_t   ring, 
+                      UShort_t sector, 
+                      UShort_t strip, 
+                      Float_t  x, 
+                      Float_t  y, 
+                      Float_t  z,
+                      Float_t  px, 
+                      Float_t  py, 
+                      Float_t  pz,
+                      Float_t  edep,
+                      Int_t    pdg,
+                      Float_t  t, 
+                      Float_t  l, 
+                      Bool_t   stop)
 {
-  //
   // Add a hit to the list
   //
   // Parameters:
@@ -731,6 +699,8 @@ AliFMD::AddHit(Int_t    track,
   //    edep     Energy deposited by track
   //    pdg      Track's particle Id #
   //    t        Time when the track hit 
+  //    l         Track length through the material. 
+  //    stop      Whether track was stopped or disappeared
   // 
   TClonesArray& a = *(HitsArray());
   // Search through the list of already registered hits, and see if we
@@ -738,31 +708,48 @@ AliFMD::AddHit(Int_t    track,
   // a new hit, but rather update the energy deposited in the hit.
   // This is done, so that a FLUKA based simulation will get the
   // number of hits right, not just the enerrgy deposition. 
+  AliFMDHit* hit = 0;
   for (Int_t i = 0; i < fNhits; i++) {
     if (!a.At(i)) continue;
-    AliFMDHit* hit = static_cast<AliFMDHit*>(a.At(i));
+    hit = static_cast<AliFMDHit*>(a.At(i));
     if (hit->Detector() == detector 
        && hit->Ring() == ring
        && hit->Sector() == sector 
        && hit->Strip() == strip
        && hit->Track() == track) {
-      Warning("AddHit", "already had a hit in FMD%d%c[%2d,%3d] for track # %d,"
-             " adding energy (%f) to that hit (%f) -> %f", 
-             detector, ring, sector, strip, track, edep, hit->Edep(),
-             hit->Edep() + edep);
+      AliFMDDebug(1, ("already had a hit in FMD%d%c[%2d,%3d] for track # %d,"
+                      " adding energy (%f) to that hit (%f) -> %f", 
+                      detector, ring, sector, strip, track, edep, hit->Edep(),
+                      hit->Edep() + edep));
       hit->SetEdep(hit->Edep() + edep);
-      return;
+      return hit;
     }
   }
   // If hit wasn't already registered, do so know. 
-  new (a[fNhits]) AliFMDHit(fIshunt, track, detector, ring, sector, strip, 
-                           x, y, z, px, py, pz, edep, pdg, t);
+  hit = new (a[fNhits]) AliFMDHit(fIshunt, track, detector, ring, sector, 
+                                 strip, x, y, z, px, py, pz, edep, pdg, t, 
+                                 l, stop);
+  // gMC->AddTrackReference(track, 12);
   fNhits++;
+  
+  //Reference track
+
+  AliMC *mcApplication = (AliMC*)gAlice->GetMCApp();
+  
+  AliTrackReference* trackRef = 
+    AddTrackReference(mcApplication->GetCurrentTrackNumber(), 
+                     AliTrackReference::kFMD); 
+  UInt_t stripId = AliFMDStripIndex::Pack(detector,ring,sector,strip);
+  trackRef->SetUserId(stripId);
+  
+  
+  
+  return hit;
 }
 
 //____________________________________________________________________
 void 
-AliFMD::AddDigit(Int_t* digits)
+AliFMD::AddDigit(Int_t* digits, Int_t*)
 {
   // Add a digit to the Digit tree 
   // 
@@ -776,24 +763,28 @@ AliFMD::AddDigit(Int_t* digits)
   //    digits[5]  [Short_t]  ADC Count, -1 if not used
   //    digits[6]  [Short_t]  ADC Count, -1 if not used 
   // 
-  AddDigit(UShort_t(digits[0]),  // Detector #
-          Char_t(digits[1]),    // Ring ID
-          UShort_t(digits[2]),  // Sector #
-          UShort_t(digits[3]),  // Strip #
-          UShort_t(digits[4]),  // ADC Count1 
-          Short_t(digits[5]),   // ADC Count2 
-          Short_t(digits[6]));  // ADC Count3 
+  AddDigitByFields(UShort_t(digits[0]),  // Detector #
+                  Char_t(digits[1]),    // Ring ID
+                  UShort_t(digits[2]),  // Sector #
+                  UShort_t(digits[3]),  // Strip #
+                  UShort_t(digits[4]),  // ADC Count1 
+                  Short_t(digits[5]),   // ADC Count2 
+                  Short_t(digits[6]),   // ADC Count3 
+                  Short_t(digits[7])); 
 }
 
 //____________________________________________________________________
 void 
-AliFMD::AddDigit(UShort_t detector, 
-                Char_t   ring, 
-                UShort_t sector, 
-                UShort_t strip, 
-                UShort_t count1, 
-                Short_t  count2,
-                Short_t  count3)
+AliFMD::AddDigitByFields(UShort_t       detector, 
+                        Char_t         ring, 
+                        UShort_t       sector, 
+                        UShort_t       strip, 
+                        UShort_t       count1, 
+                        Short_t        count2,
+                        Short_t        count3, 
+                        Short_t        count4,
+                        UShort_t       nrefs,
+                        Int_t*         refs)
 {
   // add a real digit - as coming from data
   // 
@@ -808,8 +799,15 @@ AliFMD::AddDigit(UShort_t detector,
   //    count3    ADC count (a 10-bit word), or -1 if not used
   TClonesArray& a = *(DigitsArray());
   
+  AliFMDDebug(15, ("Adding digit # %5d/%5d for FMD%d%c[%2d,%3d]"
+                  "=(%d,%d,%d,%d) with %d tracks",
+                  fNdigits-1, a.GetEntriesFast(),
+                  detector, ring, sector, strip, 
+                  count1, count2, count3, count4, nrefs));
   new (a[fNdigits++]) 
-    AliFMDDigit(detector, ring, sector, strip, count1, count2, count3);
+    AliFMDDigit(detector, ring, sector, strip, 
+               count1, count2, count3, count4, nrefs, refs);
+  
 }
 
 //____________________________________________________________________
@@ -829,26 +827,33 @@ AliFMD::AddSDigit(Int_t* digits)
   //    digits[6]  [Short_t]  ADC Count, -1 if not used
   //    digits[7]  [Short_t]  ADC Count, -1 if not used 
   // 
-  AddSDigit(UShort_t(digits[0]),  // Detector #
-           Char_t(digits[1]),    // Ring ID
-           UShort_t(digits[2]),  // Sector #
-           UShort_t(digits[3]),  // Strip #
-           Float_t(digits[4]),   // Edep
-           UShort_t(digits[5]),  // ADC Count1 
-           Short_t(digits[6]),   // ADC Count2 
-           Short_t(digits[7]));  // ADC Count3 
+  AddSDigitByFields(UShort_t(digits[0]),   // Detector #
+                   Char_t(digits[1]),     // Ring ID
+                   UShort_t(digits[2]),   // Sector #
+                   UShort_t(digits[3]),   // Strip #
+                   Float_t(digits[4]),    // Edep
+                   UShort_t(digits[5]),   // ADC Count1 
+                   Short_t(digits[6]),    // ADC Count2 
+                   Short_t(digits[7]),    // ADC Count3 
+                   Short_t(digits[8]),    // ADC Count4
+                   UShort_t(digits[9]),   // N particles
+                   UShort_t(digits[10])); // N primaries
 }
 
 //____________________________________________________________________
 void 
-AliFMD::AddSDigit(UShort_t detector, 
-                 Char_t   ring, 
-                 UShort_t sector, 
-                 UShort_t strip, 
-                 Float_t  edep,
-                 UShort_t count1, 
-                 Short_t  count2,
-                 Short_t  count3)
+AliFMD::AddSDigitByFields(UShort_t       detector, 
+                         Char_t         ring, 
+                         UShort_t       sector, 
+                         UShort_t       strip, 
+                         Float_t        edep,
+                         UShort_t       count1, 
+                         Short_t        count2,
+                         Short_t        count3, 
+                         Short_t        count4, 
+                         UShort_t       ntot, 
+                         UShort_t       nprim,
+                         Int_t*         refs)
 {
   // add a summable digit
   // 
@@ -864,17 +869,23 @@ AliFMD::AddSDigit(UShort_t detector,
   //    count3    ADC count (a 10-bit word), or -1 if not used
   //
   TClonesArray& a = *(SDigitsArray());
+  // AliFMDDebug(0, ("Adding sdigit # %d", fNsdigits));
   
+  AliFMDDebug(15, ("Adding sdigit # %5d/%5d for FMD%d%c[%2d,%3d]"
+                  "=(%d,%d,%d,%d) with %d tracks %d primaries (%p)",
+                  fNsdigits-1, a.GetEntriesFast(),
+                  detector, ring, sector, strip, 
+                  count1, count2, count3, count4, ntot, nprim, refs));
   new (a[fNsdigits++]) 
-    AliFMDSDigit(detector, ring, sector, strip, edep, count1, count2, count3);
+    AliFMDSDigit(detector, ring, sector, strip, edep, 
+                count1, count2, count3, count4, ntot, nprim, refs);
 }
 
 //____________________________________________________________________
 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();
@@ -889,6 +900,8 @@ AliFMD::HitsArray()
   if (!fHits) { 
     fHits = new TClonesArray("AliFMDHit", 1000);
     fNhits = 0;
+    if (gAlice && gAlice->GetMCApp() && gAlice->GetMCApp()->GetHitLists()) 
+      gAlice->GetMCApp()->AddHitList(fHits);
   }
   return fHits;
 }
@@ -928,12 +941,9 @@ AliFMD::Hits2Digits()
   // Create AliFMDDigit's from AliFMDHit's.  This is done by making a
   // AliFMDDigitizer, and executing that code.
   // 
-  AliRunDigitizer* manager = new AliRunDigitizer(1, 1);
-  manager->SetInputStream(0, "galice.root");
-  manager->SetOutputFile("H2Dfile");
-  
-  /* AliDigitizer* dig =*/ CreateDigitizer(manager);
-  manager->Exec("");
+  AliFMDHitDigitizer digitizer(this, AliFMDHitDigitizer::kDigits);
+  digitizer.Init();
+  digitizer.Exec("");
 }
 
 //____________________________________________________________________
@@ -943,8 +953,9 @@ AliFMD::Hits2SDigits()
   // Create AliFMDSDigit's from AliFMDHit's.  This is done by creating
   // an AliFMDSDigitizer object, and executing it. 
   // 
-  AliDigitizer* sdig = new AliFMDSDigitizer("galice.root");
-  sdig->Exec("");
+  AliFMDHitDigitizer digitizer(this, AliFMDHitDigitizer::kSDigits);
+  digitizer.Init();
+  digitizer.Exec("");
 }
 
   
@@ -953,7 +964,21 @@ AliDigitizer*
 AliFMD::CreateDigitizer(AliRunDigitizer* manager) const
 {
   // Create a digitizer object 
-  return new AliFMDDigitizer(manager);
+  
+  /* This is what we probably _should_ do */
+  AliFMDBaseDigitizer* digitizer = 0;
+  
+#ifdef USE_SSDIGITIZER
+  digitizer = new AliFMDSSDigitizer(manager);
+#else 
+  /* This is what we actually do, and will work */
+#if 0
+  AliInfo("SDigit->Digit conversion not really supported, "
+         "doing Hit->Digit conversion instead");
+#endif
+  digitizer = new AliFMDDigitizer(manager);
+#endif
+  return digitizer;
 }
 
 //====================================================================
@@ -970,280 +995,48 @@ AliFMD::Digits2Raw()
   // to that class for more information. 
   AliFMDRawWriter writer(this);
   writer.Exec();
-  
-#if 0
-  // Digits are read from the Digit branch, and processed to make
-  // three DDL files, one for each of the sub-detectors FMD1, FMD2,
-  // and FMD3. 
-  //
-  // The raw data files consists of a header, followed by ALTRO
-  // formatted blocks.  
-  // 
-  //          +-------------+
-  //          | Header      |
-  //          +-------------+
-  //          | ALTRO Block |
-  //          | ...         |
-  //          +-------------+
-  //          DDL file 
-  // 
-  // An ALTRO formatted block, in the FMD context, consists of a
-  // number of counts followed by a trailer. 
-  // 
-  //          +------------------+
-  //          | Count            |
-  //          | ...              |
-  //          | possible fillers |
-  //          +------------------+
-  //          | Trailer          |
-  //          +------------------+
-  //          ALTRO block 
-  // 
-  // The counts are listed backwards, that is, starting with the
-  // latest count, and ending in the first. 
-  // 
-  // Each count consist of 1 or more ADC samples of the VA1_ALICE
-  // pre-amp. signal.  Just how many samples are used depends on
-  // whether the ALTRO over samples the pre-amp.  Each sample is a
-  // 10-bit word, and the samples are grouped into 40-bit blocks 
-  //
-  //          +------------------------------------+
-  //          |  S(n)   | S(n-1) | S(n-2) | S(n-3) |
-  //          |  ...    | ...    | ...    | ...    |
-  //          |  S(2)   | S(1)   | AA     | AA     |
-  //          +------------------------------------+
-  //          Counts + possible filler 
-  //
-  // The trailer of the number of words of signales, the starting
-  // strip number, the sector number, and the ring ID; each 10-bit
-  // words,  packed into 40-bits. 
-  // 
-  //          +------------------------------------+
-  //          | # words | start  | sector | ring   |
-  //          +------------------------------------+
-  //          Trailer
-  // 
-  // Note, that this method assumes that the digits are ordered. 
-  //
-  AliFMD* fmd = static_cast<AliFMD*>(gAlice->GetDetector(GetName()));
-  fLoader->LoadDigits();
-  TTree* digitTree = fLoader->TreeD();
-  if (!digitTree) {
-    Error("Digits2Raw", "no digit tree");
-    return;
-  }
-  
-  TClonesArray* digits = new TClonesArray("AliFMDDigit", 1000);
-  fmd->SetTreeAddress();
-  TBranch* digitBranch = digitTree->GetBranch(GetName());
-  if (!digitBranch) {
-    Error("Digits2Raw", "no branch for %s", GetName());
-    return;
-  }
-  digitBranch->SetAddress(&digits);
-  
-  Int_t nEvents = Int_t(digitTree->GetEntries());
-  for (Int_t event = 0; event < nEvents; event++) {
-    fmd->ResetDigits();
-    digitTree->GetEvent(event);
-    
-    Int_t nDigits = digits->GetEntries();
-    if (nDigits < 1) continue;
-
-
-    UShort_t prevDetector = 0;
-    Char_t   prevRing     = '\0';
-    UShort_t prevSector   = 0;
-    // UShort_t prevStrip    = 0;
-
-    // The first seen strip number for a channel 
-    UShort_t startStrip   = 0;
-    
-    // Which channel number in the ALTRO channel we're at 
-    UShort_t offset       = 0;
-
-    // How many times the ALTRO Samples one VA1_ALICE channel 
-    Int_t sampleRate = 1;
-
-    // A buffer to hold 1 ALTRO channel - Normally, one ALTRO channel
-    // holds 128 VA1_ALICE channels, sampled at a rate of `sampleRate' 
-    TArrayI channel(128 * sampleRate);
-    
-    // The Altro buffer 
-    AliAltroBuffer* altro = 0;
-    
-    // Loop over the digits in the event.  Note, that we assume the
-    // the digits are in order in the branch.   If they were not, we'd
-    // have to cache all channels before we could write the data to
-    // the ALTRO buffer, or we'd have to set up a map of the digits. 
-    for (Int_t i = 0; i < nDigits; i++) {
-      // Get the digit
-      AliFMDDigit* digit = static_cast<AliFMDDigit*>(digits->At(i));
-
-      UShort_t det    = digit->Detector();
-      Char_t   ring   = digit->Ring();
-      UShort_t sector = digit->Sector();
-      UShort_t strip  = digit->Strip();
-      if (det != prevDetector) {
-       AliDebug(10, Form("FMD: New DDL, was %d, now %d",
-                         kBaseDDL + prevDetector - 1,
-                         kBaseDDL + det - 1));
-       // If an altro exists, delete the object, flushing the data to
-       // disk, and closing the file. 
-       if (altro) { 
-         // When the first argument is false, we write the real
-         // header. 
-         AliDebug(10, Form("New altro: Write channel at %d Strip: %d "
-                           "Sector: %d  Ring: %d", 
-                           i, startStrip, prevSector, prevRing));
-         // TPC to FMD translations 
-         // 
-         //    TPC                FMD
-         //    ----------+-----------
-         //    pad       |      strip
-         //    row       |     sector
-         //    sector    |       ring
-         // 
-         altro->WriteChannel(Int_t(startStrip), 
-                             Int_t(prevSector), 
-                             Int_t((prevRing == 'I' ? 0 : 1)), 
-                             channel.fN, channel.fArray, 0);
-         altro->Flush();
-         altro->WriteDataHeader(kFALSE, kFALSE);
-         delete altro;
-         altro = 0;
-       }
-
-       prevDetector = det;
-       // Need to open a new DDL! 
-       Int_t ddlId = kBaseDDL + det - 1;
-       TString filename(Form("%s_%d.ddl", GetName(),  ddlId));
-
-       AliDebug(10, Form("New altro buffer with DDL file %s", 
-                         filename.Data()));
-       AliDebug(10, Form("New altro at %d", i));
-       // Create a new altro buffer - a `1' as the second argument
-       // means `write mode' 
-       altro = new AliAltroBuffer(filename.Data(), 1);
-       
-       // Write a dummy (first argument is true) header to the DDL
-       // file - later on, when we close the file, we write the real
-       // header
-       altro->WriteDataHeader(kTRUE, kFALSE);
-
-       // Figure out the sample rate 
-       if (digit->Count2() > 0) sampleRate = 2;
-       if (digit->Count3() > 0) sampleRate = 3;
-
-       channel.Set(128 * sampleRate);
-       offset     = 0;
-       prevRing   = ring;
-       prevSector = sector;
-       startStrip = strip;
-      }
-      else if (offset == 128                        
-              || digit->Ring() != prevRing 
-              || digit->Sector() != prevSector) {
-       // Force a new Altro channel
-       AliDebug(10, Form("Flushing channel to disk because %s",
-                         (offset == 128 ? "channel is full" :
-                          (ring != prevRing ? "new ring up" :
-                           "new sector up"))));
-       AliDebug(10, Form("New Channel: Write channel at %d Strip: %d "
-                         "Sector: %d  Ring: %d", 
-                         i, startStrip, prevSector, prevRing));
-       altro->WriteChannel(Int_t(startStrip), 
-                           Int_t(prevSector), 
-                           Int_t((prevRing == 'I' ? 0 : 1)), 
-                           channel.fN, channel.fArray, 0);
-       // Reset and update channel variables 
-       channel.Reset(0);
-       offset     = 0; 
-       startStrip = strip;
-       prevRing   = ring;
-       prevSector = sector;
-      }
-
-      // Store the counts of the ADC in the channel buffer 
-      channel[offset * sampleRate] = digit->Count1();
-      if (sampleRate > 1) 
-       channel[offset * sampleRate + 1] = digit->Count2();
-      if (sampleRate > 2) 
-       channel[offset * sampleRate + 2] = digit->Count3();
-      offset++;
-    }
-    // Finally, we need to close the final ALTRO buffer if it wasn't
-    // already 
-    if (altro) {
-      altro->Flush();
-      altro->WriteDataHeader(kFALSE, kFALSE);
-      delete altro;
-    }
-  }
-  fLoader->UnloadDigits();
-#endif
 }
 
-//==================================================================
+//====================================================================
 //
-// Various setter functions for the common paramters 
+// Raw data reading 
 //
-
 //__________________________________________________________________
-void 
-AliFMD::SetLegLength(Double_t length) 
-{
-  // Set lenght of plastic legs that hold the hybrid (print board and
-  // silicon sensor) onto the honeycomp support
-  //
-  // DebugGuard guard("AliFMD::SetLegLength");
-  AliDebug(10, "AliFMD::SetLegLength");
-  fLegLength = length;
-  fInner->SetLegLength(fLegLength);
-  fOuter->SetLegLength(fLegLength);
-}
-
-//__________________________________________________________________
-void 
-AliFMD::SetLegOffset(Double_t offset) 
-{
-  // Set offset from edge of hybrid to plastic legs that hold the
-  // hybrid (print board and silicon sensor) onto the honeycomp
-  // support 
-  //
-  // DebugGuard guard("AliFMD::SetLegOffset");
-  AliDebug(10, "AliFMD::SetLegOffset");
-  fInner->SetLegOffset(offset);
-  fOuter->SetLegOffset(offset);
-}
-
-//__________________________________________________________________
-void 
-AliFMD::SetLegRadius(Double_t radius) 
+Bool_t
+AliFMD::Raw2SDigits(AliRawReader* reader) 
 {
-  // Set the diameter of the plastic legs that hold the hybrid (print
-  // board and silicon sensor) onto the honeycomp support
-  //
-  // DebugGuard guard("AliFMD::SetLegRadius");
-  AliDebug(10, "AliFMD::SetLegRadius");
-  fLegRadius = radius;
-  fInner->SetLegRadius(fLegRadius);
-  fOuter->SetLegRadius(fLegRadius);
+  // Turn digits into raw data. 
+  // 
+  // This uses the class AliFMDRawWriter to do the job.   Please refer
+  // to that class for more information. 
+  AliFMDParameters::Instance()->Init();
+  MakeTree("S");
+  MakeBranch("S");
+  
+  TClonesArray*       sdigits = SDigits();
+  AliFMDReconstructor rec;
+  
+  // The two boolean arguments
+  //   Make sdigits instead of digits 
+  //   Subtract the pedestal off the signal
+  rec.Digitize(reader, sdigits);
+  // 
+  // Bool_t ret = fmdReader.ReadAdcs(sdigits, kTRUE, kTRUE);
+  // sdigits->ls();
+  UShort_t ns = sdigits->GetEntriesFast();
+  if (AliLog::GetDebugLevel("FMD", 0) > 5) {
+    for (UShort_t i = 0; i < ns; i++) 
+      sdigits->At(i)->Print("pl");
+  } 
+  AliFMDDebug(1, ("Got a total of %d SDigits", ns));
+
+  fLoader->TreeS()->Fill();
+  ResetSDigits();
+  fLoader->WriteSDigits("OVERWRITE");
+
+  return kTRUE;
 }
 
-//__________________________________________________________________
-void 
-AliFMD::SetModuleSpacing(Double_t spacing) 
-{
-  // Set the distance between the front and back sensor modules
-  // (module staggering). 
-  //
-  // DebugGuard guard("AliFMD::SetModuleSpacing");
-  AliDebug(10, "AliFMD::SetModuleSpacing");  
-  fModuleSpacing = spacing;
-  fInner->SetModuleSpacing(fModuleSpacing);
-  fOuter->SetModuleSpacing(fModuleSpacing);
-}
 
 //====================================================================
 //
@@ -1255,16 +1048,58 @@ AliFMD::Browse(TBrowser* b)
 {
   // Browse this object. 
   //
-  AliDebug(10, "AliFMD::Browse");
+  AliFMDDebug(30, ("\tBrowsing the FMD"));
   AliDetector::Browse(b);
-  if (fInner) b->Add(fInner, "Inner Ring");
-  if (fOuter) b->Add(fOuter, "Outer Ring");
-  if (fFMD1)  b->Add(fFMD1,  "FMD1 SubDetector");
-  if (fFMD2)  b->Add(fFMD2,  "FMD2 SubDetector");
-  if (fFMD3)  b->Add(fFMD3,  "FMD3 SubDetector");
+  b->Add(AliFMDGeometry::Instance());
 }
 
-
+//____________________________________________________________________ 
+void
+AliFMD::AddAlignableVolumes() const
+{
+  //
+  // Create entries for alignable volumes associating the symbolic volume
+  // name with the corresponding volume path. Needs to be syncronized with
+  // eventual changes in the geometry.
+  // 
+  // This code was made by Raffaele Grosso <rgrosso@mail.cern.ch>.  I
+  // (cholm) will probably want to change it.   For one, I think it
+  // should be the job of the geometry manager to deal with this. 
+  AliInfo("Add FMD alignable volumes");
+  AliFMDGeometry::Instance()->SetAlignableVolumes();
+#if 0  
+  for(size_t f = 1; f <= 3; f++){ // Detector 1,2,3
+    for(size_t tb =  0; tb <2 ; tb++){ // Top/Bottom 
+      char     stb = tb == 0 ? 'T' : 'B';
+      unsigned min = tb == 0 ? 0   : 5;
+
+      TString halfVol(Form("/ALIC_1/F%dM%c_%d", f, stb, f));
+      TString halfSym(halfVol);
+      if(!gGeoManager->SetAlignableEntry(halfSym.Data(),halfVol.Data()))
+       AliFatal(Form("Alignable entry %s not created. "
+                     "Volume path %s not valid", 
+                     halfSym.Data(),halfVol.Data()));
+      for(size_t io = 0; io < 2; io++){ // inner, outer 
+       if (f==1 && io==1) continue; // Only one ring in FMD1 
+       if(tb == 1 && io==1) min=10;
+       char     sio = (io == 0 ? 'I' : 'O');
+       unsigned nio = (io == 0 ? 3   : 9);
+       unsigned max = (io == 0 ? 5   : 10) + min;
+       
+       for(size_t i = min; i < max; i++) { // Modules
+         TString modVol(Form("%s/F%c%cV_7%d/F%cSE_%d", halfVol.Data(), 
+                             sio, stb, nio, sio, i));
+         TString modSym(modVol);
+         if(!gGeoManager->SetAlignableEntry(modSym.Data(),modVol.Data()))
+           AliFatal(Form("Alignable entry %s not created. "
+                         "Volume path %s not valid", 
+                         modSym.Data(), modVol.Data()));
+       }
+      }
+    }
+  }
+#endif
+}
 //___________________________________________________________________
 //
 // EOF