X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=FMD%2FAliFMD.cxx;h=1e73d4904e2a77d4831d714b274ce9872d20dad1;hb=02a27b508bdd34a6febe776298cc20b18fdbb2ed;hp=bb616ef8028c7bbd9ba555402e41dfe5ca98acc6;hpb=e494a11a5ca45df8284ed3dd07a2bc2206af440f;p=u%2Fmrichter%2FAliRoot.git diff --git a/FMD/AliFMD.cxx b/FMD/AliFMD.cxx index bb616ef8028..1e73d4904e2 100644 --- a/FMD/AliFMD.cxx +++ b/FMD/AliFMD.cxx @@ -12,49 +12,52 @@ * 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 + @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. -// +// 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 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. @@ -62,153 +65,111 @@ // 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. +// * 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) // -// * 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. +// 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. // -// * 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. -// -//Begin_Html -/* - - -
-

- The responsible person for this module is - Alla Maevskaia. -

-

- Many modifications by Christian - Holm Christensen. -

- 
-*/
-//End_Html
-
-#ifndef ROOT_TClonesArray
-#include 
-#endif
-#ifndef ROOT_TGeomtry
-# include 
-#endif
-#ifndef ROOT_TNode
-# include 
-#endif
-#ifndef ROOT_TTUBE
-# include 
-#endif
-#ifndef ROOT_TTree
-# include 
-#endif
-#ifndef ROOT_TVirtualMC
-# include 
-#endif
-#ifndef ROOT_TBrowser
-# include 
-#endif
-#ifndef ROOT_TMath
-# include 
-#endif
 
-#ifndef ALIRUNDIGITIZER_H
-# include "AliRunDigitizer.h"
-#endif
-#ifndef ALILOADER_H
-# include "AliLoader.h"
-#endif
-#ifndef ALIRUN_H
-# include "AliRun.h"
-#endif
-#ifndef ALIMC_H
-# include "AliMC.h"
-#endif
-#ifndef ALILog_H
-# include "AliLog.h"
-#endif
-#ifndef ALIMAGF_H
-# include "AliMagF.h"
-#endif
-#ifndef ALIFMD_H
-# include "AliFMD.h"
-#endif
-#ifndef ALIFMDDIGIG_H
-# include "AliFMDDigit.h"
-#endif
-#ifndef ALIFMDHIT_H
-# include "AliFMDHit.h"
-#endif
-#ifndef ALIFMDDIGITIZER_H
-# include "AliFMDDigitizer.h"
-#endif
-#ifndef ALIFMD1_H
-# include "AliFMD1.h"
-#endif
-#ifndef ALIFMD2_H
-# include "AliFMD2.h"
-#endif
-#ifndef ALIFMD3_H
-# include "AliFMD3.h"
-#endif
-#ifndef ALIALTROBUFFER_H
-# include "AliAltroBuffer.h"
-#endif
+// 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                // __CMATH__
+#include 	// ROOT_TClonesArray
+#include 		// ROOT_TGeomtry
+#include 		// ROOT_TNode
+#include 		// ROOT_TXTRU
+#include 		// ROOT_TRotMatrix
+#include 		// ROOT_TTUBE
+#include 		// ROOT_TTree
+#include 		// ROOT_TBrowser
+// #include 	// ROOT_TVirtualMC
+#include            // ROOT_TVector2 
+
+#include 	// ALIRUNDIGITIZER_H
+#include 		// ALILOADER_H
+#include 		// ALIRUN_H
+#include 		// ALIMC_H
+#include 		// ALIMAGF_H
+#include 		// ALILOG_H
+#include "AliFMD.h"		// ALIFMD_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 "AliFMDSDigitizer.h"	// ALIFMDSDIGITIZER_H
+// #include "AliFMDGeometryBuilder.h"
+#include "AliFMDRawWriter.h"	// ALIFMDRAWWRITER_H
+#include "AliFMDPoints.h"       // ALIFMDPOINTS_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),
+    fDetailed(kTRUE),
+    fBad(0)
 {
   //
   // Default constructor for class AliFMD
   //
-  AliDebug(0, "Default CTOR");
-  fHits     = 0;
-  fDigits   = 0;
-  fSDigits  = 0;
-  fNsdigits = 0;
-  fIshunt   = 0;
+  AliDebug(10, "\tDefault CTOR");
+  fHits        = 0;
+  fDigits      = 0;
+  fIshunt      = 0;
+  fUseOld      = kFALSE;
+  fUseAssembly = kTRUE;
+  fBad         = new TClonesArray("AliFMDHit");
 }
 
 //____________________________________________________________________
-AliFMD::AliFMD(const char *name, const char *title, bool detailed)
+AliFMD::AliFMD(const AliFMD& other)
+  : AliDetector(other),
+    fSDigits(other.fSDigits), 
+    fNsdigits(other.fNsdigits),
+    fDetailed(other.fDetailed),
+    fBad(other.fBad)
+{
+  // Copy constructor 
+  fUseOld      = other.fUseOld;
+  fUseAssembly = other.fUseAssembly;
+}
+
+//____________________________________________________________________
+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),
+    fDetailed(kTRUE),
+    fBad(0)
 {
   //
   // Standard constructor for Forward Multiplicity Detector
   //
-  AliDebug(0, "Standard CTOR");
-
+  AliDebug(10, "\tStandard CTOR");
+  fUseOld      = kFALSE;
+  fUseAssembly = kFALSE;
+  fBad         = new TClonesArray("AliFMDHit");
+  
   // Initialise Hit array
   HitsArray();
   gAlice->GetMCApp()->AddHitList(fHits);
@@ -221,59 +182,6 @@ AliFMD::AliFMD(const char *name, const char *title, bool detailed)
   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);
 }
 
 //____________________________________________________________________
@@ -295,6 +203,24 @@ AliFMD::~AliFMD ()
     delete fSDigits;
     fSDigits = 0;
   }
+  if (fBad) {
+    fBad->Delete();
+    delete fBad;
+    fBad = 0;
+  }
+}
+
+//____________________________________________________________________
+AliFMD&
+AliFMD::operator=(const AliFMD& other)
+{
+  // Assignment operator
+  AliDetector::operator=(other);
+  fSDigits		= other.fSDigits; 
+  fNsdigits		= other.fNsdigits;
+  fDetailed		= other.fDetailed;
+  fBad                  = other.fBad;
+  return *this;
 }
 
 //====================================================================
@@ -305,67 +231,52 @@ AliFMD::~AliFMD ()
 void 
 AliFMD::CreateGeometry()
 {
- //
-  // Create the geometry of Forward Multiplicity Detector version 0
   //
-  // 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        =  "SLEG";
-  fShortLegId =  gMC->Gsvolu(name.Data(),"TUBE",(*fIdtmed)[kPlasticId],par,3);
-  
-  par[2]      += fModuleSpacing / 2;
-  name        = "LLEG";
-  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);    
+  // Create the geometry of Forward Multiplicity Detector.  The actual
+  // construction of the geometry is delegated to the class
+  // AliFMDGeometryBuilder, invoked by the singleton manager
+  // AliFMDGeometry. 
+  //
+  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. 
+  //
+  AliDebug(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;
@@ -383,17 +294,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;
@@ -405,32 +316,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.};
@@ -440,12 +372,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 };
@@ -457,8 +389,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);
   }
   
@@ -482,8 +414,8 @@ 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);
   }
   
@@ -498,37 +430,41 @@ 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);
 }
 
 //____________________________________________________________________
 void  
 AliFMD::Init()
 {
-  //
-  // Initialis the FMD after it has been built
-  Int_t i;
-  //
-  if (fDebug) {
-    std::cout << "\n" << ClassName() << ": " << std::flush;
-    for (i = 0; i < 35; i++) std::cout << "*";
-    std::cout << " FMD_INIT ";
-    for (i = 0; i < 35; i++) std::cout << "*";
-    std::cout << "\n" << ClassName() << ": " << std::flush;
-    //
-    // Here the FMD initialisation code (if any!)
-    for (i = 0; i < 80; i++) std::cout << "*";
-    std::cout << std::endl;
+  // Initialize the detector 
+  // 
+  AliDebug(1, "Initialising FMD detector object");
+  // AliFMDGeometry*  fmd = AliFMDGeometry::Instance();
+  // fmd->InitTransformations();
+}
+
+//____________________________________________________________________
+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())));
+    TIter next(fBad);
+    AliFMDHit* hit;
+    while ((hit = static_cast(next()))) hit->Print("D");
+    fBad->Clear();
   }
-  //
-  //
 }
 
+
 //====================================================================
 //
 // Graphics and event display
@@ -538,59 +474,215 @@ void
 AliFMD::BuildGeometry()
 {
   //
-  // Build simple ROOT TNode geometry for event display
-  //
-  // Build a simplified geometry of the FMD used for event display  
-  // 
-  AliDebug(10, "Creating a simplified geometry");
+  // 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();
+  
+  static TXTRU*     innerShape = 0;
+  static TXTRU*     outerShape = 0;
+  static TObjArray* innerRot   = 0;
+  static TObjArray* outerRot   = 0;
+
+  if (!innerShape || !outerShape) {
+    // Make the shapes for the modules 
+    for (Int_t i = 0; i < 2; i++) {
+      AliFMDRing* r = 0;
+      switch (i) {
+      case 0: r = fmd->GetRing('I'); break;
+      case 1: r = fmd->GetRing('O'); break;
+      }
+      if (!r) {
+	AliError(Form("no ring found for i=%d", i));
+	return;
+      }
+      Double_t    siThick  = r->GetSiThickness();
+      const Int_t knv      = r->GetNVerticies();
+      Double_t    theta    = r->GetTheta();
+      Int_t       nmod     = r->GetNModules();
+      
+      TXTRU* shape = new TXTRU(r->GetName(), r->GetTitle(), "void", knv, 2);
+      for (Int_t j = 0; j < knv; j++) {
+	TVector2* vv = r->GetVertex(knv - 1 - j);
+	shape->DefineVertex(j, vv->X(), vv->Y());
+      }
+      shape->DefineSection(0, -siThick / 2, 1, 0, 0);
+      shape->DefineSection(1, +siThick / 2, 1, 0, 0);
+      shape->SetLineColor(GetLineColor());
+      
+      TObjArray* rots = new TObjArray(nmod);
+      for (Int_t j = 0; j < nmod; j++) {
+	Double_t th = (j + .5) * theta * 2;
+	TString name(Form("FMD_ring_%c_rot_%02d", r->GetId(), j));
+	TString title(Form("FMD Ring %c Rotation # %d", r->GetId(), j));
+	TRotMatrix* rot = new TRotMatrix(name.Data(), title.Data(),
+					 90, th, 90, fmod(90+th,360), 0, 0);
+	rots->AddAt(rot, j);
+      }
+      
+      switch (r->GetId()) {
+      case 'i':
+      case 'I': innerShape = shape; innerRot = rots; break;
+      case 'o':
+      case 'O': outerShape = shape; outerRot = rots; break;
+      }
+    }
+  }
+  
   TNode* top = gAlice->GetGeometry()->GetNode("alice");
   
-  fFMD1->SimpleGeometry(fNodes, top, GetLineColor(), 0);
-  fFMD2->SimpleGeometry(fNodes, top, GetLineColor(), 0);
-  fFMD3->SimpleGeometry(fNodes, top, GetLineColor(), 0);
+  for (Int_t i = 1; i <= 3; i++) {
+    AliFMDDetector* det = fmd->GetDetector(i);
+    if (!det) {
+      Warning("BuildGeometry", "FMD%d seems to be disabled", i);
+      continue;
+    }
+    Double_t w  = 0;
+    Double_t rh = det->GetRing('I')->GetHighR();
+    Char_t   id = 'I';
+    if (det->GetRing('O')) {
+      w  = TMath::Abs(det->GetRingZ('O') - det->GetRingZ('I'));
+      id = (TMath::Abs(det->GetRingZ('O')) 
+	    > TMath::Abs(det->GetRingZ('I')) ? 'O' : 'I');
+      rh = det->GetRing('O')->GetHighR();
+    }
+    w += (det->GetRing(id)->GetModuleSpacing() +
+	  det->GetRing(id)->GetSiThickness());
+    TShape* shape = new TTUBE(det->GetName(), det->GetTitle(), "void",
+			      det->GetRing('I')->GetLowR(), rh, w / 2);
+    Double_t z = (det->GetRingZ('I') - w / 2);
+    if (z > 0) z += det->GetRing(id)->GetModuleSpacing();
+    top->cd();
+    TNode* node = new TNode(det->GetName(), det->GetTitle(), shape, 
+			    0, 0, z, 0);
+    fNodes->Add(node);
+    
+    for (Int_t j = 0; j < 2; j++) {
+      AliFMDRing* r      = 0;
+      TShape*     rshape = 0;
+      TObjArray*  rots   = 0;
+      switch (j) {
+      case 0: 
+	r = det->GetRing('I'); rshape = innerShape; rots = innerRot; break;
+      case 1: 
+	r = det->GetRing('O'); rshape = outerShape; rots = outerRot; break;
+      }
+      if (!r) continue;
+      
+      Double_t    siThick  = r->GetSiThickness();
+      Int_t       nmod     = r->GetNModules();
+      Double_t    modspace = r->GetModuleSpacing();
+      Double_t    rz       = - (z - det->GetRingZ(r->GetId()));
+      
+      for (Int_t k = 0; k < nmod; k++) {
+	node->cd();
+	Double_t    offz    = (k % 2 == 1 ? modspace : 0);
+	TRotMatrix* rot     = static_cast(rots->At(k));
+	TString name(Form("%s%c_module_%02d", det->GetName(), r->GetId(),k));
+	TString title(Form("%s%c Module %d", det->GetName(), r->GetId(),k));
+	TNode* mnod = new TNode(name.Data(), title.Data(), rshape, 
+				0, 0, rz - siThick / 2 
+				+ TMath::Sign(offz,z), rot);
+	mnod->SetLineColor(GetLineColor());
+	fNodes->Add(mnod);
+      } // for (Int_t k = 0 ; ...)
+    } // for (Int_t j = 0 ; ...)
+  } // for (Int_t i = 1 ; ...)
 }
 
 //____________________________________________________________________
 void 
-AliFMD::DrawDetector()
+AliFMD::LoadPoints(Int_t /* track */) 
 {
+  // 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. 
   //
-  // Draw a shaded view of the Forward multiplicity detector version 0
-  //
-  // 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();
+  if (!fHits) {
+    AliError(Form("fHits == 0. Name is %s",GetName()));
+    return;
+  }
+  Int_t nHits = fHits->GetEntriesFast();
+  if (nHits == 0) {
+    return;
+  }
+  Int_t tracks = gAlice->GetMCApp()->GetNtrack();
+  if (fPoints == 0) fPoints = new TObjArray(2 * tracks);
+
+  // Get geometry 
+  AliFMDGeometry* geom = AliFMDGeometry::Instance();
+  geom->Init();
+  geom->InitTransformations();
+
+  // Now make markers for each hit  
+  // AliInfo(Form("Drawing %d hits (have %d points) for track %d", 
+  //              nHits, fPoints->GetEntriesFast(), track));
+  for (Int_t ihit = 0; ihit < nHits; ihit++) {
+    AliFMDHit* hit = static_cast(fHits->At(ihit));
+    if (!hit) continue;
+    Double_t edep    = hit->Edep();
+    Double_t m       = hit->M();
+    Double_t poverm  = (m == 0 ? 0 : hit->P());
+    Double_t absQ    = TMath::Abs(hit->Q());
+    Bool_t   bad     = kFALSE;
+    // This `if' is to debug abnormal energy depositions.  We trigger on
+    // p/m approx larger than or equal to a MIP, and a large edep - more 
+    // than 1 keV - a MIP is 100 eV. 
+    if (edep > absQ * absQ && poverm > 1) bad = kTRUE;
+
+    AliFMDPoints* p1 = new AliFMDPoints(hit, GetMarkerColor());
+    // AliPoints* p1 = new AliPoints();
+    // p1->SetMarkerColor(GetMarkerColor());
+    // p1->SetMarkerSize(GetMarkerSize());
+    // p1->SetPoint(0, hit->X(), hit->Y(), hit->Z());
+    p1->SetDetector(this);
+    p1->SetParticle(hit->GetTrack());
+    fPoints->AddAt(p1, hit->GetTrack());
+    if (bad) {
+      p1->SetMarkerColor(4);
+      // p1->SetMarkerSize(2 * GetMarkerSize());
+    }
+    
+    Double_t x, y, z;
+    geom->Detector2XYZ(hit->Detector(), hit->Ring(), hit->Sector(), 
+		       hit->Strip(), x, y, z);
+    AliFMDPoints* p = new AliFMDPoints(hit, 3);
+    // AliPoints* p = new AliPoints();
+    // p->SetMarkerColor(3);
+    // p->SetMarkerSize(GetMarkerSize());
+    // p->SetPoint(0, x, y, z);
+    p->SetDetector(this);
+    p->SetParticle(hit->GetTrack());
+    p->SetXYZ(x, y, z);
+    p->SetMarkerColor(3);
+    fPoints->AddAt(p, tracks+hit->GetTrack());
+    if (bad) {
+      p->SetMarkerColor(5);
+      // p->SetMarkerSize(2 * GetMarkerSize());
+    }
+    // AliInfo(Form("Adding point at %d", tracks+hit->GetTrack()));
+  }
+}
 
-  //
-  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");
+//____________________________________________________________________
+void 
+AliFMD::DrawDetector()
+{
+  // Draw a shaded view of the Forward multiplicity detector.  This
+  // isn't really useful anymore. 
+  AliDebug(10, "\tDraw detector");
 }
 
 //____________________________________________________________________
-const Int_t 
-AliFMD::DistanceToPrimitive(Int_t, Int_t)
+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;
 }
@@ -604,6 +696,13 @@ void
 AliFMD::MakeBranch(Option_t * option)
 {
   // Create Tree branches for the FMD.
+  //
+  // Options:
+  //
+  //    H          Make a branch of TClonesArray of AliFMDHit's
+  //    D          Make a branch of TClonesArray of AliFMDDigit's
+  //    S          Make a branch of TClonesArray of AliFMDSDigit's
+  // 
   const Int_t kBufferSize = 16000;
   TString branchname(GetName());
   TString opt(option);
@@ -628,8 +727,7 @@ AliFMD::MakeBranch(Option_t * option)
 void 
 AliFMD::SetTreeAddress()
 {
-  // Set branch address for the Hits and Digits Tree.
-
+  // Set branch address for the Hits, Digits, and SDigits Tree.
   if (fLoader->TreeH()) HitsArray();
   AliDetector::SetTreeAddress();
 
@@ -648,12 +746,11 @@ AliFMD::SetTreeAddress()
   }
 }
 
-
-
 //____________________________________________________________________
 void 
 AliFMD::SetHitsAddressBranch(TBranch *b)
 {
+  // Set the TClonesArray to read hits into. 
   b->SetAddress(&fHits);
 }
 
@@ -679,41 +776,44 @@ AliFMD::AddHit(Int_t track, Int_t *vol, Float_t *hits)
   //    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 		       	
-  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
+  //    hits[9]	 [Float_t  ] Time when the track hit
+  // 
+  // 
+  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:
@@ -732,6 +832,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
@@ -739,27 +841,34 @@ 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(a.At(i));
+    hit = static_cast(a.At(i));
     if (hit->Detector() == detector 
 	&& hit->Ring() == ring
 	&& hit->Sector() == sector 
 	&& hit->Strip() == strip
 	&& hit->Track() == track) {
+      AliDebug(1, Form("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);
   fNhits++;
+  return hit;
 }
 
 //____________________________________________________________________
 void 
-AliFMD::AddDigit(Int_t* digits)
+AliFMD::AddDigit(Int_t* digits, Int_t*)
 {
   // Add a digit to the Digit tree 
   // 
@@ -773,24 +882,24 @@ 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 
 }
 
 //____________________________________________________________________
 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)
 {
   // add a real digit - as coming from data
   // 
@@ -826,26 +935,26 @@ 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 
 }
 
 //____________________________________________________________________
 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)
 {
   // add a summable digit
   // 
@@ -859,6 +968,7 @@ AliFMD::AddSDigit(UShort_t detector,
   //    count1    ADC count (a 10-bit word)
   //    count2    ADC count (a 10-bit word), or -1 if not used
   //    count3    ADC count (a 10-bit word), or -1 if not used
+  //
   TClonesArray& a = *(SDigitsArray());
   
   new (a[fNsdigits++]) 
@@ -869,8 +979,7 @@ AliFMD::AddSDigit(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();
@@ -921,20 +1030,30 @@ AliFMD::SDigitsArray()
 void 
 AliFMD::Hits2Digits() 
 {
+  // Create AliFMDDigit's from AliFMDHit's.  This is done by making a
+  // AliFMDDigitizer, and executing that code.
+  // 
+  Warning("Hits2Digits", "Try not to use this method.\n"
+	  "Instead, use AliSimulator");
   AliRunDigitizer* manager = new AliRunDigitizer(1, 1);
   manager->SetInputStream(0, "galice.root");
   manager->SetOutputFile("H2Dfile");
   
   /* AliDigitizer* dig =*/ CreateDigitizer(manager);
   manager->Exec("");
+  delete manager;
 }
 
 //____________________________________________________________________
 void 
 AliFMD::Hits2SDigits() 
 {
-  AliDigitizer* sdig = new AliFMDSDigitizer("galice.root");
-  sdig->Exec("");
+  // Create AliFMDSDigit's from AliFMDHit's.  This is done by creating
+  // an AliFMDSDigitizer object, and executing it. 
+  // 
+  AliFMDSDigitizer* digitizer = new AliFMDSDigitizer("galice.root");
+  digitizer->Exec("");
+  delete digitizer;
 }
 
   
@@ -943,7 +1062,8 @@ AliDigitizer*
 AliFMD::CreateDigitizer(AliRunDigitizer* manager) const
 {
   // Create a digitizer object 
-  return new AliFMDDigitizer(manager);
+  AliFMDDigitizer* digitizer = new AliFMDDigitizer(manager);
+  return digitizer;
 }
 
 //====================================================================
@@ -954,224 +1074,14 @@ AliFMD::CreateDigitizer(AliRunDigitizer* manager) const
 void 
 AliFMD::Digits2Raw() 
 {
-  AliFMD* fmd = static_cast(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(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();
-}
-
-//==================================================================
-//
-// Various setter functions for the common paramters 
-//
-
-//__________________________________________________________________
-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) 
-{
-  // 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. 
+  AliFMDRawWriter writer(this);
+  writer.Exec();
 }
 
-//__________________________________________________________________
-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);
-}
 
 //====================================================================
 //
@@ -1181,165 +1091,13 @@ AliFMD::SetModuleSpacing(Double_t spacing)
 void 
 AliFMD::Browse(TBrowser* b) 
 {
-  AliDebug(10, "AliFMD::Browse");
+  // Browse this object. 
+  //
+  AliDebug(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());
 }
 
-
-//********************************************************************
-//
-// AliFMDv0
-//
-//__________________________________________________________________
-
-ClassImp(AliFMDv0);
-
-//********************************************************************
-//
-// AliFMDv1
-//
-//__________________________________________________________________
-
-ClassImp(AliFMDv1);
-
-
-//_//____________________________________________________________________
-void 
-AliFMDv1::StepManager()
-{
-  //
-  // Called for every step in the Forward Multiplicity Detector
-  //
-  // 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
-  //     
-  //
-  // DebugGuard guard("AliFMDv1::StepManager");
-  AliDebug(10, "AliFMDv1::StepManager");
-  // return;
-
-  // If the track is gone, return
-  if (!gMC->IsTrackAlive()) return;
-  
-  // Only process charged particles 
-  if(TMath::Abs(gMC->TrackCharge()) <= 0) return; 
-
-  // Only do stuff is the track is in one of the strips. 
-  TString vol(gMC->CurrentVolName());
-  if (!vol.Contains("STR")) return;
-
-
-  // Get the strip number.  Note, that GEANT numbers divisions from 1,
-  // so we subtract one 
-  Int_t strip;             
-  gMC->CurrentVolID(strip);
-  strip--;                 
-
-  // Get the phi division of the module 
-  Int_t phiDiv;                         // * The phi division number (1 or 2)
-  gMC->CurrentVolOffID(1, phiDiv);      //   in the module  
-
-  // Active volume number - not used. 
-  // Int_t active;                         
-  // gMC->CurrentVolOffID(2, active);      
-
-  // Get the module number in the ring. 
-  Int_t module;                    
-  gMC->CurrentVolOffID(3, module); 
-  
-  // Ring copy number - the same as the detector number - not used
-  // Int_t ringCopy;                       // * Ring copy number
-  // gMC->CurrentVolOffID(4, ringCopy);    //   Same as detector number 
-  
-  // Get the detector number from the path name 
-  Int_t detector = Int_t((gMC->CurrentVolOffName(5)[3]) - 48);
-
-  // The sector number, calculated from module and phi division # 
-  Int_t  sector =  2 * module + phiDiv - 1;
-
-  // The ring ID is encoded in the volume name 
-  Char_t ring = vol[3];
-
-  // Get a pointer to the sub detector structure 
-  AliFMDSubDetector* det = 0;
-  switch (detector) {
-  case 1: det = fFMD1; break;
-  case 2: det = fFMD2; break;
-  case 3: det = fFMD3; break;
-  }
-  if (!det) return;
-
-  // Get the current track position 
-  TLorentzVector v;
-  gMC->TrackPosition(v);
-  // Check that the track is actually within the active area 
-  Bool_t isWithin = det->CheckHit(ring, module, v.X(), v.Y());
-  Bool_t entering = gMC->IsTrackEntering() && isWithin;
-  Bool_t inside   = gMC->IsTrackInside()   && isWithin;
-  Bool_t out      = (gMC->IsTrackExiting() 
-		     || gMC->IsTrackDisappeared() 
-		     || gMC->IsTrackStop() 
-		     || !isWithin);
-// Reset the energy deposition for this track, and update some of
-  // our parameters.
-  if (entering) {
-    fCurrentDeltaE = 0;
-
-    // Get production vertex and momentum of the track 
-    fCurrentV = v;
-    gMC->TrackMomentum(fCurrentP);
-    fCurrentPdg = gMC->IdFromPDG(gMC->TrackPid());
-
-    // if (fAnalyser) 
-    //   fAnalyser->Update(detector, ring, isWithin, v.X(), v.Y());
-  }
-  
-  // If the track is inside, then update the energy deposition
-  if (inside && fCurrentDeltaE >= 0) 
-    fCurrentDeltaE += 1000 * gMC->Edep();
-
-  // The track exits the volume, or it disappeared in the volume, or
-  // the track is stopped because it no longer fulfills the cuts
-  // defined, then we create a hit. 
-  if (out && fCurrentDeltaE >= 0) {
-    fCurrentDeltaE += 1000 * gMC->Edep();
-
-    AddHit(gAlice->GetMCApp()->GetCurrentTrackNumber(),
-	   detector, ring,  sector, strip,
-	   fCurrentV.X(), fCurrentV.Y(), fCurrentV.Z(),
-	   fCurrentP.X(), fCurrentP.Y(), fCurrentP.Z(), 
-	   fCurrentDeltaE, fCurrentPdg, fCurrentV.T());
-    fCurrentDeltaE = -1;
-  }
-}
 //___________________________________________________________________
 //
 // EOF