Fix to avoid deleting cached CDB objects - modified fix by Peter.
[u/mrichter/AliRoot.git] / FMD / AliFMD.cxx
index 98e5fa9..0e35d5f 100644 (file)
 // 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>                // __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 <TVirtualMC.h>                // ROOT_TVirtualMC
 #include <TVector2.h>           // ROOT_TVector2 
-#include <TGeoManager.h>        // ROOT_TGeoManager
+#include <TVirtualMC.h>                // ROOT_TVirtualMC
+#include <cmath>                // __CMATH__
 
 #include <AliRunDigitizer.h>   // ALIRUNDIGITIZER_H
 #include <AliLoader.h>         // ALILOADER_H
 #include "AliFMDDetector.h"    // ALIFMDDETECTOR_H
 #include "AliFMDRing.h"                // ALIFMDRING_H
 #include "AliFMDDigitizer.h"   // ALIFMDDIGITIZER_H
-#include "AliFMDSDigitizer.h"  // ALIFMDSDIGITIZER_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 "AliFMDPoints.h"       // ALIFMDPOINTS_H
+#include "AliFMDRawReader.h"   // ALIFMDRAWREADER_H
+#include "AliTrackReference.h" 
+#include "AliFMDStripIndex.h"
+#include "AliFMDParameters.h"
+#include "AliFMDReconstructor.h"
 
 //____________________________________________________________________
 ClassImp(AliFMD)
@@ -140,7 +145,7 @@ AliFMD::AliFMD()
   fHits        = 0;
   fDigits      = 0;
   fIshunt      = 0;
-  fBad         = new TClonesArray("AliFMDHit");
+  // fBad         = new TClonesArray("AliFMDHit");
 }
 
 //____________________________________________________________________
@@ -157,15 +162,15 @@ AliFMD::AliFMD(const char *name, const char *title)
   // Standard constructor for Forward Multiplicity Detector
   //
   AliFMDDebug(10, ("\tStandard CTOR"));
-  fBad         = new TClonesArray("AliFMDHit");
+  // 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;
@@ -260,8 +265,8 @@ void AliFMD::CreateMaterials()
   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
@@ -396,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 };
@@ -411,7 +427,62 @@ void AliFMD::CreateMaterials()
     AliMedium(kPlasticId, "Plastic$", id,0,fieldType,maxField,maxBending,
              maxStepSize,maxEnergyLoss,precision,minStepSize);
   }
+
+}
+
+#if 0
+//____________________________________________________________________
+void  
+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)
+{
+  // 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
 
 //____________________________________________________________________
 void  
@@ -422,9 +493,28 @@ AliFMD::Init()
   AliFMDDebug(1, ("Initialising FMD detector object"));
   TVirtualMC*      mc     = TVirtualMC::GetMC();
   AliFMDGeometry*  fmd    = AliFMDGeometry::Instance();
-  const TArrayI&   actGeo = fmd->ActiveIds();
+  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]));
@@ -447,7 +537,7 @@ AliFMD::FinishEvent()
   // 
   if (AliLog::GetDebugLevel("FMD", "AliFMD") < 10) return;
   if (fBad && fBad->GetEntries() > 0) {
-    AliWarning((Form("EndEvent", "got %d 'bad' hits", fBad->GetEntries())));
+    AliWarning(Form("got %d 'bad' hits", fBad->GetEntries()));
     TIter next(fBad);
     AliFMDHit* hit;
     while ((hit = static_cast<AliFMDHit*>(next()))) hit->Print("D");
@@ -456,227 +546,6 @@ AliFMD::FinishEvent()
 }
 
 
-//====================================================================
-//
-// Graphics and event display
-//
-//____________________________________________________________________
-void 
-AliFMD::BuildGeometry()
-{
-  //
-  // Build simple ROOT TNode geometry for event display. With the new
-  // geometry modeller, TGeoManager, this seems rather redundant. 
-  AliFMDDebug(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(kYellow); //PH kYellow is the default line color in FMD
-      
-      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(kYellow); //PH kYellow is the default line color in FMD
-       fNodes->Add(mnod);
-      } // for (Int_t k = 0 ; ...)
-    } // for (Int_t j = 0 ; ...)
-  } // for (Int_t i = 1 ; ...)
-}
-
-//____________________________________________________________________
-void 
-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. 
-  //
-  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<AliFMDHit*>(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, kRed); //PH kRed is the default marker color in FMD
-    // 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()));
-  }
-}
-
-//____________________________________________________________________
-void 
-AliFMD::DrawDetector()
-{
-  // Draw a shaded view of the Forward multiplicity detector.  This
-  // isn't really useful anymore. 
-  AliFMDDebug(10, ("\tDraw detector"));
-}
-
-//____________________________________________________________________
-Int_t 
-AliFMD::DistancetoPrimitive(Int_t, Int_t)
-{
-  // Calculate the distance from the mouse to the FMD on the screen
-  // Dummy routine.
-  //
-  return 9999;
-}
 
 //====================================================================
 //
@@ -744,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 
@@ -853,7 +729,21 @@ 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;
 }
 
@@ -879,18 +769,22 @@ 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,
+                        UShort_t       nrefs,
+                        Int_t*         refs)
 {
   // add a real digit - as coming from data
   // 
@@ -905,11 +799,14 @@ AliFMD::AddDigitByFields(UShort_t detector,
   //    count3    ADC count (a 10-bit word), or -1 if not used
   TClonesArray& a = *(DigitsArray());
   
-  new (a[fNdigits++]) 
-    AliFMDDigit(detector, ring, sector, strip, count1, count2, count3);
-  AliFMDDebug(15, ("Adding digit # %5d/%5d for FMD%d%c[%2d,%3d]=(%d,%d,%d)",
+  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));
+                  detector, ring, sector, strip, 
+                  count1, count2, count3, count4, nrefs));
+  new (a[fNdigits++]) 
+    AliFMDDigit(detector, ring, sector, strip, 
+               count1, count2, count3, count4, nrefs, refs);
   
 }
 
@@ -930,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 
   // 
-  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,
+                         Int_t*         refs)
 {
   // add a summable digit
   // 
@@ -965,9 +869,16 @@ 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));
   
+  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);
 }
 
 //____________________________________________________________________
@@ -989,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;
 }
@@ -1028,15 +941,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("");
 }
 
 //____________________________________________________________________
@@ -1046,9 +953,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("");
 }
 
   
@@ -1057,7 +964,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;
 }
 
@@ -1077,6 +997,46 @@ 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();
+  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;
+}
+
 
 //====================================================================
 //
@@ -1105,6 +1065,7 @@ AliFMD::AddAlignableVolumes() const
   // 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