The present commit corresponds to an important change in the way the
[u/mrichter/AliRoot.git] / FMD / AliFMD.cxx
index 50d9ac8..37a2820 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 3 sub-detectors FMD1, FMD2, and FMD3, each of
-// which has 1 or 2 rings of silicon sensors. 
+// is the driver for especially simulation. 
+//
+// The Forward Multiplicity Detector consists of 3 sub-detectors FMD1,
+// FMD2, and FMD3, each of which has 1 or 2 rings of silicon sensors. 
 //                                                       
 // This is the base class for all FMD manager classes. 
 //                    
 //  +--------+<>--+                            |  +------------------+
 //  | AliFMD |                                 +--| AliFMDSDigitizer |    
 //  +--------+<>--+                               +------------------+       
-//            1  |  +-----------------+ 
-//               +--| AliFMDSimulator |
-//                  +-----------------+
-//                            ^              
-//                            |
-//              +-------------+-------------+
-//              |                           |        
-//     +--------------------+   +-------------------+
-//     | AliFMDGeoSimulator |   | AliFMDG3Simulator | 
-//     +--------------------+   +-------------------+
-//               ^                        ^
-//               |                        |
-//  +-----------------------+   +----------------------+
-//  | AliFMDGeoOldSimulator |   | AliFMDG3OldSimulator |
-//  +-----------------------+   +----------------------+
-//      
+//            1  |  +---------------------+
+//               +--| AliFMDReconstructor |
+//                  +---------------------+
 //
 // *  AliFMD 
 //    This defines the interface for the various parts of AliROOT that
 //    simulator tasks are responsible to implment the geoemtry, and
 //    process hits. 
 //                                                                          
-// *  AliFMDGeoSimulator
-//    This is a concrete implementation of the AliFMDSimulator that
-//    uses the TGeo classes directly only. 
+// *  AliFMDReconstructor
+//    This is a concrete implementation of the AliReconstructor that
+//    reconstructs pseudo-inclusive-multiplicities from digits (raw or
+//    from simulation)
 //
-// *  AliFMDG3Simulator
-//    This is a concrete implementation of the AliFMDSimulator that
-//    uses the TVirtualMC interface with GEANT 3.21-like messages.
+// Calibration and geometry parameters are managed by separate
+// singleton managers.  These are AliFMDGeometry and
+// AliFMDParameters.  Please refer to these classes for more
+// information on these.
 //
 
 // These files are not in the same directory, so there's no reason to
 // ask the preprocessor to search in the current directory for these
 // files by including them with `#include "..."' 
-#include <math.h>               // __CMATH__
+#include <TBrowser.h>          // ROOT_TBrowser
 #include <TClonesArray.h>      // ROOT_TClonesArray
-#include <TGeometry.h>         // ROOT_TGeomtry
-#include <TNode.h>             // ROOT_TNode
-#include <TXTRU.h>             // ROOT_TXTRU
+#include <TGeoGlobalMagField.h> // ROOT_TGeoGlobalMagField
+#include <TGeoManager.h>        // ROOT_TGeoManager
 #include <TRotMatrix.h>                // ROOT_TRotMatrix
-#include <TTUBE.h>             // ROOT_TTUBE
 #include <TTree.h>             // ROOT_TTree
-#include <TBrowser.h>          // ROOT_TBrowser
-#include <TMath.h>             // ROOT_TMath
-#include <TVirtualMC.h>                // ROOT_TVirtualMC
+#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 <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
-#ifdef USE_PRE_MOVE
-#include "AliFMDSimulator.h"   // ALIFMDSIMULATOR_H
-#include "AliFMDG3Simulator.h" // ALIFMDG3SIMULATOR_H
-#include "AliFMDGeoSimulator.h"        // ALIFMDGEOSIMULATOR_H
-#include "AliFMDG3OldSimulator.h"      // ALIFMDG3OLDSIMULATOR_H
-#include "AliFMDGeoOldSimulator.h"     // ALIFMDGEOOLDSIMULATOR_H
-#else
-#include "AliFMDGeometryBuilderSimple.h"
-#endif
+#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 <TVector2.h>
+#include "AliFMDRawReader.h"   // ALIFMDRAWREADER_H
+#include "AliTrackReference.h" 
+#include "AliFMDStripIndex.h"
+#include "AliFMDParameters.h"
+#include "AliFMDReconstructor.h"
 
 //____________________________________________________________________
 ClassImp(AliFMD)
@@ -140,56 +134,34 @@ AliFMD::AliFMD()
     fSDigits(0), 
     fNsdigits(0),
     fDetailed(kTRUE),
-#ifdef USE_PRE_MOVE
-    fSimulator(0), 
-#endif
-    fBad(0)
+    fUseOld(kFALSE),
+    fUseAssembly(kTRUE),
+    fBad(0) 
 {
   //
   // Default constructor for class AliFMD
   //
-  AliDebug(10, "\tDefault CTOR");
+  AliFMDDebug(10, ("\tDefault CTOR"));
   fHits        = 0;
   fDigits      = 0;
   fIshunt      = 0;
-  fUseOld      = kFALSE;
-  fUseAssembly = kTRUE;
   fBad         = new TClonesArray("AliFMDHit");
 }
 
 //____________________________________________________________________
-AliFMD::AliFMD(const AliFMD& other)
-  : AliDetector(other),
-    fSDigits(other.fSDigits), 
-    fNsdigits(other.fNsdigits),
-    fDetailed(other.fDetailed),
-#ifdef USE_PRE_MOVE
-    fSimulator(other.fSimulator),
-#endif
-    fBad(other.fBad)
-{
-  // Copy constructor 
-  fUseOld      = other.fUseOld;
-  fUseAssembly = other.fUseAssembly;
-}
-
-//____________________________________________________________________
 AliFMD::AliFMD(const char *name, const char *title)
   : AliDetector (name, title),
     fSDigits(0),
     fNsdigits(0),
     fDetailed(kTRUE),
-#ifdef USE_PRE_MOVE
-    fSimulator(0), 
-#endif
+    fUseOld(kFALSE),
+    fUseAssembly(kFALSE),
     fBad(0)
 {
   //
   // Standard constructor for Forward Multiplicity Detector
   //
-  AliDebug(10, "\tStandard CTOR");
-  fUseOld      = kFALSE;
-  fUseAssembly = kFALSE;
+  AliFMDDebug(10, ("\tStandard CTOR"));
   fBad         = new TClonesArray("AliFMDHit");
   
   // Initialise Hit array
@@ -202,8 +174,8 @@ AliFMD::AliFMD(const char *name, const char *title)
   
   // CHC: What is this?
   fIshunt = 0;
-  SetMarkerColor(kRed);
-  SetLineColor(kYellow);
+  //PH  SetMarkerColor(kRed);
+  //PH  SetLineColor(kYellow);
 }
 
 //____________________________________________________________________
@@ -232,21 +204,6 @@ AliFMD::~AliFMD ()
   }
 }
 
-//____________________________________________________________________
-AliFMD&
-AliFMD::operator=(const AliFMD& other)
-{
-  // Assignment operator
-  AliDetector::operator=(other);
-  fSDigits             = other.fSDigits; 
-  fNsdigits            = other.fNsdigits;
-  fDetailed            = other.fDetailed;
-#ifdef USE_PRE_MOVE
-  fSimulator            = other.fSimulator;
-#endif
-  fBad                  = other.fBad;
-  return *this;
-}
 
 //====================================================================
 //
@@ -258,42 +215,14 @@ 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
-  //
-#ifndef USE_PRE_MOVE
   AliFMDGeometry*  fmd = AliFMDGeometry::Instance();
-  if (fUseOld) fmd->SetBuilder(new AliFMDGeometryBuilderSimple(fDetailed));
   fmd->SetDetailed(fDetailed);
   fmd->UseAssembly(fUseAssembly);
   fmd->Build();
-#else
-  if (!fSimulator) {
-    AliFatal("Simulator object not made yet!");
-    return;
-  }
-  fSimulator->DefineGeometry();
-#endif
 }    
 
 //____________________________________________________________________
@@ -312,10 +241,14 @@ void AliFMD::CreateMaterials()
   //   FMD Air$        Air (Air in the FMD)
   //   FMD Plastic$    Plastic (Support legs for the hybrid cards)
   //
-  // Pointers to TGeoMedium objects are retrived from the TGeoManager
-  // singleton.  These pointers are later used when setting up the
-  // geometry 
-  AliDebug(10, "\tCreating 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();
@@ -326,15 +259,14 @@ void AliFMD::CreateMaterials()
     return;
   }
 #endif  
-#ifndef USE_PRE_MOVE     
   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
@@ -469,6 +401,17 @@ void AliFMD::CreateMaterials()
              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 };
@@ -484,227 +427,52 @@ void AliFMD::CreateMaterials()
     AliMedium(kPlasticId, "Plastic$", id,0,fieldType,maxField,maxBending,
              maxStepSize,maxEnergyLoss,precision,minStepSize);
   }
-#else
-  AliDebug(10, "\tCreating materials");
-
-  if (fSimulator) {
-    AliFatal("Simulator object already instantised!");
-    return;
-  }
-  TVirtualMC* mc = TVirtualMC::GetMC();
 
-  Bool_t geo = mc->IsRootGeometrySupported();
-  if (geo) {
-    if (fUseOld) 
-      fSimulator = new AliFMDGeoOldSimulator(this, fDetailed);
-    else 
-      fSimulator = new AliFMDGeoSimulator(this, fDetailed);
-  }
-  else {
-    if (fUseOld) 
-      fSimulator = new AliFMDG3OldSimulator(this, fDetailed);
-    else    
-      fSimulator = new AliFMDG3Simulator(this, fDetailed);
-  }
-  AliDebug(1, Form("using a %s as simulation backend", 
-                  fSimulator->IsA()->GetName()));
-  fSimulator->SetDetailed(fDetailed);
-  fSimulator->UseAssembly(fUseAssembly);
-  fSimulator->DefineMaterials();
-#endif
 }
 
 //____________________________________________________________________
 void  
 AliFMD::Init()
-{}
+{
+  // Initialize the detector 
+  // 
+  AliFMDDebug(1, ("Initialising FMD detector object"));
+  TVirtualMC*      mc     = TVirtualMC::GetMC();
+  AliFMDGeometry*  fmd    = AliFMDGeometry::Instance();
+  const TArrayI&   actGeo = fmd->ActiveIds();
+  TArrayI          actVmc(actGeo.fN);
+  for (Int_t i = 0; i < actGeo.fN; i++) {
+    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::FinishEvent()
 {
-#ifndef USE_PRE_MOVE
+  // 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<AliFMDHit*>(next()))) 
-      hit->Print("D");
+    while ((hit = static_cast<AliFMDHit*>(next()))) hit->Print("D");
     fBad->Clear();
   }
-#else
-  if (fSimulator) fSimulator->EndEvent();
-#endif
-}
-
-
-//====================================================================
-//
-// Graphics and event display
-//
-//____________________________________________________________________
-void 
-AliFMD::BuildGeometry()
-{
-  //
-  // Build simple ROOT TNode geometry for event display
-  //
-  // Build a simplified geometry of the FMD used for event display  
-  // 
-  // The actual building of the TNodes is done by
-  // AliFMDSubDetector::SimpleGeometry. 
-  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 nv       = r->GetNVerticies();
-      Double_t    theta    = r->GetTheta();
-      Int_t       nmod     = r->GetNModules();
-      
-      TXTRU* shape = new TXTRU(r->GetName(), r->GetTitle(), "void", nv, 2);
-      for (Int_t j = 0; j < nv; j++) {
-       TVector2* vv = r->GetVertex(nv - 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");
-  
-  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<TRotMatrix*>(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()
-{
-  //
-  // Draw a shaded view of the Forward multiplicity detector
-  //
-  // DebugGuard guard("AliFMD::DrawDetector");
-  AliDebug(10, "\tDraw detector");
-  
-#if 0
-  //Set ALIC mother transparent
-  gMC->Gsatt("ALIC","SEEN",0);
-  //
-  gMC->Gdopt("hide", "on");
-  gMC->Gdopt("shad", "on");
-  gMC->Gsatt("*", "fill", 7);
-  gMC->SetClipBox(".");
-  gMC->SetClipBox("*", 0, 1000, -1000, 1000, -1000, 1000);
-  gMC->DefaultRange();
-  gMC->Gdraw("alic", 40, 30, 0, 12, 12, .055, .055);
-  gMC->Gdhead(1111, "Forward Multiplicity Detector");
-  gMC->Gdman(16, 10, "MAN");
-  gMC->Gdopt("hide", "off");
-#endif
-}
 
-//____________________________________________________________________
-Int_t 
-AliFMD::DistanceToPrimitive(Int_t, Int_t)
-{
-  //
-  // Calculate the distance from the mouse to the FMD on the screen
-  // Dummy routine
-  //
-  return 9999;
-}
 
 //====================================================================
 //
@@ -765,8 +533,6 @@ AliFMD::SetTreeAddress()
   }
 }
 
-
-
 //____________________________________________________________________
 void 
 AliFMD::SetHitsAddressBranch(TBranch *b)
@@ -774,6 +540,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 
@@ -835,7 +608,6 @@ AliFMD::AddHitByFields(Int_t    track,
                       Float_t  l, 
                       Bool_t   stop)
 {
-  //
   // Add a hit to the list
   //
   // Parameters:
@@ -872,10 +644,10 @@ AliFMD::AddHitByFields(Int_t    track,
        && 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 hit;
     }
@@ -884,7 +656,19 @@ AliFMD::AddHitByFields(Int_t    track,
   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;
 }
 
@@ -910,18 +694,21 @@ AliFMD::AddDigit(Int_t* digits, Int_t*)
                   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[6]),   // ADC Count3 
+                  Short_t(digits[7])); 
 }
 
 //____________________________________________________________________
 void 
-AliFMD::AddDigitByFields(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,
+                        const TArrayI& refs)
 {
   // add a real digit - as coming from data
   // 
@@ -937,7 +724,14 @@ AliFMD::AddDigitByFields(UShort_t detector,
   TClonesArray& a = *(DigitsArray());
   
   new (a[fNdigits++]) 
-    AliFMDDigit(detector, ring, sector, strip, count1, count2, count3);
+    AliFMDDigit(detector, ring, sector, strip, 
+               count1, count2, count3, count4, refs);
+  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, refs.fN));
+  
 }
 
 //____________________________________________________________________
@@ -957,26 +751,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 
   // 
-  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 
+  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::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)
+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,
+                         const TArrayI& refs)
 {
   // add a summable digit
   // 
@@ -992,17 +793,18 @@ AliFMD::AddSDigitByFields(UShort_t detector,
   //    count3    ADC count (a 10-bit word), or -1 if not used
   //
   TClonesArray& a = *(SDigitsArray());
+  // AliFMDDebug(0, ("Adding sdigit # %d", fNsdigits));
   
   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();
@@ -1056,15 +858,9 @@ 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;
+  AliFMDHitDigitizer digitizer(this, AliFMDHitDigitizer::kDigits);
+  digitizer.Init();
+  digitizer.Exec("");
 }
 
 //____________________________________________________________________
@@ -1074,9 +870,9 @@ AliFMD::Hits2SDigits()
   // 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;
+  AliFMDHitDigitizer digitizer(this, AliFMDHitDigitizer::kSDigits);
+  digitizer.Init();
+  digitizer.Exec("");
 }
 
   
@@ -1085,7 +881,20 @@ AliDigitizer*
 AliFMD::CreateDigitizer(AliRunDigitizer* manager) const
 {
   // Create a digitizer object 
-  AliFMDDigitizer* digitizer = 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;
 }
 
@@ -1105,6 +914,45 @@ AliFMD::Digits2Raw()
   writer.Exec();
 }
 
+//====================================================================
+//
+// Raw data reading 
+//
+//__________________________________________________________________
+Bool_t
+AliFMD::Raw2SDigits(AliRawReader* reader) 
+{
+  // 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();
+  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;
+}
+
 
 //====================================================================
 //
@@ -1116,14 +964,58 @@ AliFMD::Browse(TBrowser* b)
 {
   // Browse this object. 
   //
-  AliDebug(30, "\tBrowsing the FMD");
+  AliFMDDebug(30, ("\tBrowsing the FMD"));
   AliDetector::Browse(b);
-#ifdef USE_PRE_MOVE
-  if (fSimulator) b->Add(fSimulator);
-#endif
   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