Moving the FMD offline trigger to its own class, AliFMDOfflineTrigger
[u/mrichter/AliRoot.git] / FMD / AliFMDInput.cxx
index d376f8e..d1c8daa 100644 (file)
@@ -35,6 +35,9 @@
 #include "AliRun.h"             // ALIRUN_H
 #include "AliStack.h"           // ALISTACK_H
 #include "AliRawReaderFile.h"   // ALIRAWREADERFILE_H
+#include "AliRawReaderRoot.h"   // ALIRAWREADERROOT_H
+#include "AliRawReaderDate.h"   // ALIRAWREADERDATE_H
+#include "AliRawEventHeaderBase.h" 
 #include "AliFMD.h"             // ALIFMD_H
 #include "AliFMDHit.h"         // ALIFMDHIT_H
 #include "AliFMDDigit.h"       // ALIFMDDigit_H
@@ -47,6 +50,7 @@
 #include <AliCDBManager.h>
 #include <AliCDBEntry.h>
 #include <AliAlignObjParams.h>
+#include <AliTrackReference.h>
 #include <TTree.h>              // ROOT_TTree
 #include <TChain.h>             // ROOT_TChain
 #include <TParticle.h>          // ROOT_TParticle
@@ -58,6 +62,8 @@
 #include <Riostream.h>         // ROOT_Riostream
 #include <TFile.h>              // ROOT_TFile
 #include <TStreamerInfo.h>
+#include <TArrayF.h>
+
 //____________________________________________________________________
 ClassImp(AliFMDInput)
 #if 0
@@ -67,17 +73,20 @@ ClassImp(AliFMDInput)
 
 //____________________________________________________________________
 AliFMDInput::AliFMDInput()
-  : fGAliceFile(""), 
+  : TNamed("AliFMDInput", "Input handler for various FMD data"), 
+    fGAliceFile(""), 
     fLoader(0),
     fRun(0), 
     fStack(0),
     fFMDLoader(0), 
     fReader(0),
+    fFMDReader(0),
     fFMD(0),
     fESD(0),
     fESDEvent(0),
     fTreeE(0),
     fTreeH(0),
+    fTreeTR(0),
     fTreeD(0),
     fTreeS(0),
     fTreeR(0), 
@@ -85,13 +94,17 @@ AliFMDInput::AliFMDInput()
     fChainE(0),
     fArrayE(0),
     fArrayH(0),
+    fArrayTR(0), 
     fArrayD(0),
     fArrayS(0), 
     fArrayR(0), 
     fArrayA(0), 
+    fHeader(0),
     fGeoManager(0),
     fTreeMask(0), 
-    fIsInit(kFALSE)
+    fRawFile(""),
+    fIsInit(kFALSE),
+    fEventCount(0)
 {
 
   // Constructor of an FMD input object.  Specify what data to read in
@@ -104,17 +117,20 @@ AliFMDInput::AliFMDInput()
 
 //____________________________________________________________________
 AliFMDInput::AliFMDInput(const char* gAliceFile)
-  : fGAliceFile(gAliceFile),
+  : TNamed("AliFMDInput", "Input handler for various FMD data"), 
+    fGAliceFile(gAliceFile),
     fLoader(0),
     fRun(0), 
     fStack(0),
     fFMDLoader(0), 
     fReader(0),
+    fFMDReader(0),
     fFMD(0),
     fESD(0),
     fESDEvent(0),
     fTreeE(0),
     fTreeH(0),
+    fTreeTR(0),
     fTreeD(0),
     fTreeS(0),
     fTreeR(0), 
@@ -122,13 +138,17 @@ AliFMDInput::AliFMDInput(const char* gAliceFile)
     fChainE(0),
     fArrayE(0),
     fArrayH(0),
+    fArrayTR(0), 
     fArrayD(0),
     fArrayS(0), 
     fArrayR(0), 
     fArrayA(0), 
+    fHeader(0),
     fGeoManager(0),
     fTreeMask(0), 
-    fIsInit(kFALSE)
+    fRawFile(""),
+    fIsInit(kFALSE),
+    fEventCount(0)
 {
   
   // Constructor of an FMD input object.  Specify what data to read in
@@ -142,6 +162,9 @@ Int_t
 AliFMDInput::NEvents() const 
 {
   // Get number of events
+  if (TESTBIT(fTreeMask, kRaw) || 
+      TESTBIT(fTreeMask, kRawCalib)) return fReader->GetNumberOfEvents();
+  if (fChainE) return fChainE->GetEntriesFast();
   if (fTreeE) return fTreeE->GetEntries();
   return -1;
 }
@@ -157,36 +180,74 @@ AliFMDInput::Init()
     AliWarning("Already initialized");
     return fIsInit;
   }
-  if (fGAliceFile.IsNull()) fGAliceFile = "galice.root";
-  // Get the loader
-  fLoader = AliRunLoader::Open(fGAliceFile.Data(), "Alice", "read");
-  if (!fLoader) {
-    AliError(Form("Coulnd't read the file %s", fGAliceFile.Data()));
-    return kFALSE;
-  }
-  
+  Info("Init","Initialising w/mask 0x%04x\n"
+       "\tHits:          %d\n"
+       "\tKinematics:    %d\n"
+       "\tDigits:        %d\n"
+       "\tSDigits:       %d\n"
+       "\tHeader:        %d\n"
+       "\tRecPoints:     %d\n"
+       "\tESD:           %d\n"
+       "\tRaw:           %d\n"
+       "\tRawCalib:      %d\n"
+       "\tGeometry:      %d\n"
+       "\tTracks:        %d\n"
+       "\tTracksRefs:    %d",
+       fTreeMask,
+       TESTBIT(fTreeMask, kHits),
+       TESTBIT(fTreeMask, kKinematics),
+       TESTBIT(fTreeMask, kDigits),
+       TESTBIT(fTreeMask, kSDigits),
+       TESTBIT(fTreeMask, kHeader),
+       TESTBIT(fTreeMask, kRecPoints),
+       TESTBIT(fTreeMask, kESD),
+       TESTBIT(fTreeMask, kRaw),
+       TESTBIT(fTreeMask, kRawCalib),
+       TESTBIT(fTreeMask, kGeometry),
+       TESTBIT(fTreeMask, kTracks),
+       TESTBIT(fTreeMask, kTrackRefs));
   // Get the run 
-  if  (fLoader->LoadgAlice()) return kFALSE;
-  fRun = fLoader->GetAliRun();
-  
-  // Get the FMD 
-  fFMD = static_cast<AliFMD*>(fRun->GetDetector("FMD"));
-  if (!fFMD) {
-    AliError("Failed to get detector FMD from loader");
-    return kFALSE;
-  }
-  
-  // Get the FMD loader
-  fFMDLoader = fLoader->GetLoader("FMDLoader");
-  if (!fFMDLoader) {
-    AliError("Failed to get detector FMD loader from loader");
-    return kFALSE;
-  }
-  if (fLoader->LoadHeader()) { 
-    AliError("Failed to get event header information from loader");
-    return kFALSE;
+  if (TESTBIT(fTreeMask, kDigits)     ||
+      TESTBIT(fTreeMask, kSDigits)    || 
+      TESTBIT(fTreeMask, kKinematics) || 
+      TESTBIT(fTreeMask, kTrackRefs)  || 
+      TESTBIT(fTreeMask, kTracks)     || 
+      TESTBIT(fTreeMask, kHeader)) {
+    if (!gSystem->FindFile(".:/", fGAliceFile)) {
+      AliWarning(Form("Cannot find file %s in .:/", fGAliceFile.Data()));
+    }
+    else {
+      fLoader = AliRunLoader::Open(fGAliceFile.Data(), "Alice", "read");
+      if (!fLoader) {
+       AliError(Form("Coulnd't read the file %s", fGAliceFile.Data()));
+       return kFALSE;
+      }
+      AliInfo(Form("Opened GAlice file %s", fGAliceFile.Data()));
+
+      if  (fLoader->LoadgAlice()) return kFALSE;
+      
+      fRun = fLoader->GetAliRun();
+      
+      // Get the FMD 
+      fFMD = static_cast<AliFMD*>(fRun->GetDetector("FMD"));
+      if (!fFMD) {
+       AliError("Failed to get detector FMD from loader");
+       return kFALSE;
+      }
+      
+      // Get the FMD loader
+      fFMDLoader = fLoader->GetLoader("FMDLoader");
+      if (!fFMDLoader) {
+       AliError("Failed to get detector FMD loader from loader");
+       return kFALSE;
+      }
+      if (fLoader->LoadHeader()) { 
+       AliError("Failed to get event header information from loader");
+       return kFALSE;
+      }
+      fTreeE = fLoader->TreeE();
+    }
   }
-  fTreeE = fLoader->TreeE();
 
   // Optionally, get the ESD files
   if (TESTBIT(fTreeMask, kESD)) {
@@ -210,24 +271,43 @@ AliFMDInput::Init()
     
   }
     
-  if (TESTBIT(fTreeMask, kRaw)) {
+  if (TESTBIT(fTreeMask, kRaw) || 
+      TESTBIT(fTreeMask, kRawCalib)) {
     AliInfo("Getting FMD raw data digits");
     fArrayA = new TClonesArray("AliFMDDigit");
-    fReader = new AliRawReaderFile(-1);
+#if 0
+    if (!fRawFile.IsNull() && fRawFile.EndsWith(".root"))
+      fReader = new AliRawReaderRoot(fRawFile.Data());
+    else if (!fRawFile.IsNull() && fRawFile.EndsWith(".raw"))
+      fReader = new AliRawReaderDate(fRawFile.Data());
+    else
+      fReader = new AliRawReaderFile(-1);
+#else
+    if(!fRawFile.IsNull()) 
+      fReader = AliRawReader::Create(fRawFile.Data());
+    else 
+      fReader = new AliRawReaderFile(-1);
+#endif
+    fFMDReader = new AliFMDRawReader(fReader, 0);
   }
   
   // Optionally, get the geometry 
   if (TESTBIT(fTreeMask, kGeometry)) {
-    TString fname(fRun->GetGeometryFileName());
-    if (fname.IsNull()) {
-      Warning("Init", "No file name for the geometry from AliRun");
-      fname = gSystem->DirName(fGAliceFile);
-      fname.Append("/geometry.root");
+    if (fRun) {
+      TString fname(fRun->GetGeometryFileName());
+      if (fname.IsNull()) {
+       Warning("Init", "No file name for the geometry from AliRun");
+       fname = gSystem->DirName(fGAliceFile);
+       fname.Append("/geometry.root");
+      }
+      fGeoManager = TGeoManager::Import(fname.Data());
+      if (!fGeoManager) {
+       Fatal("Init", "No geometry manager found");
+       return kFALSE;
+      }
     }
-    fGeoManager = TGeoManager::Import(fname.Data());
-    if (!fGeoManager) {
-      Fatal("Init", "No geometry manager found");
-      return kFALSE;
+    else { 
+      AliGeomManager::LoadGeometry();
     }
     AliCDBManager* cdb   = AliCDBManager::Instance();
     AliCDBEntry*   align = cdb->Get("FMD/Align/Data");
@@ -269,27 +349,46 @@ AliFMDInput::Begin(Int_t event)
     AliError("Not initialized");
     return fIsInit;
   }
+
   // Get the event 
-  if (fLoader->GetEvent(event)) return kFALSE;
+  if (fLoader && fLoader->GetEvent(event)) return kFALSE;
   AliInfo(Form("Now in event %8d/%8d", event, NEvents()));
 
   // Possibly load global kinematics information 
   if (TESTBIT(fTreeMask, kKinematics) || TESTBIT(fTreeMask, kTracks)) {
     // AliInfo("Getting kinematics");
-    if (fLoader->LoadKinematics()) return kFALSE;
+    if (fLoader->LoadKinematics("READ")) return kFALSE;
     fStack = fLoader->Stack();
   }
+
   // Possibly load FMD Hit information 
   if (TESTBIT(fTreeMask, kHits) || TESTBIT(fTreeMask, kTracks)) {
     // AliInfo("Getting FMD hits");
-    if (!fFMDLoader || fFMDLoader->LoadHits()) return kFALSE;
+    if (!fFMDLoader || fFMDLoader->LoadHits("READ")) return kFALSE;
     fTreeH = fFMDLoader->TreeH();
     if (!fArrayH) fArrayH = fFMD->Hits(); 
   }
+  
+  // Possibly load FMD TrackReference information 
+  if (TESTBIT(fTreeMask, kTrackRefs) || TESTBIT(fTreeMask, kTracks)) {
+    // AliInfo("Getting FMD hits");
+    if (!fLoader || fLoader->LoadTrackRefs("READ")) return kFALSE;
+    fTreeTR = fLoader->TreeTR();
+    if (!fArrayTR) fArrayTR = new TClonesArray("AliTrackReference");
+    fTreeTR->SetBranchAddress("TrackReferences",  &fArrayTR);
+  }
+  
+  // Possibly load heaedr information 
+  if (TESTBIT(fTreeMask, kHeader)) {
+    // AliInfo("Getting FMD hits");
+    if (!fLoader /* || fLoader->LoadHeader()*/) return kFALSE;
+    fHeader = fLoader->GetHeader();
+  }
+
   // Possibly load FMD Digit information 
   if (TESTBIT(fTreeMask, kDigits)) {
     // AliInfo("Getting FMD digits");
-    if (!fFMDLoader || fFMDLoader->LoadDigits()) return kFALSE;
+    if (!fFMDLoader || fFMDLoader->LoadDigits("READ")) return kFALSE;
     fTreeD = fFMDLoader->TreeD();
     if (fTreeD) {
       if (!fArrayD) fArrayD = fFMD->Digits();
@@ -299,27 +398,35 @@ AliFMDInput::Begin(Int_t event)
       AliWarning(Form("Failed to load FMD Digits"));
     } 
   }
+
   // Possibly load FMD Sdigit information 
   if (TESTBIT(fTreeMask, kSDigits)) {
     // AliInfo("Getting FMD summable digits");
-    if (!fFMDLoader || fFMDLoader->LoadSDigits()) return kFALSE;
+    if (!fFMDLoader || fFMDLoader->LoadSDigits("READ")) { 
+      AliWarning("Failed to load SDigits!");
+      return kFALSE;
+    }
     fTreeS = fFMDLoader->TreeS();
     if (!fArrayS) fArrayS = fFMD->SDigits();
   }
+
   // Possibly load FMD RecPoints information 
   if (TESTBIT(fTreeMask, kRecPoints)) {
     // AliInfo("Getting FMD reconstructed points");
-    if (!fFMDLoader || fFMDLoader->LoadRecPoints()) return kFALSE;
+    if (!fFMDLoader || fFMDLoader->LoadRecPoints("READ")) return kFALSE;
     fTreeR = fFMDLoader->TreeR();
     if (!fArrayR) fArrayR = new TClonesArray("AliFMDRecPoint");
     fTreeR->SetBranchAddress("FMD",  &fArrayR);
-  }  // Possibly load FMD ESD information 
+  }  
+
+  // Possibly load FMD ESD information 
   if (TESTBIT(fTreeMask, kESD)) {
     // AliInfo("Getting FMD event summary data");
     Int_t read = fChainE->GetEntry(event);
     if (read <= 0) return kFALSE;
     fESD = fESDEvent->GetFMDData();
     if (!fESD) return kFALSE;
+#if 0
     TFile* f = fChainE->GetFile();
     if (f) {
       TObject* o = f->GetStreamerInfoList()->FindObject("AliFMDMap");
@@ -330,14 +437,32 @@ AliFMDInput::Begin(Int_t event)
       }
     }
     // fESD->CheckNeedUShort(fChainE->GetFile());
+#endif
   }
+
   // Possibly load FMD Digit information 
-  if (TESTBIT(fTreeMask, kRaw)) {
+  if (TESTBIT(fTreeMask, kRaw) || TESTBIT(fTreeMask, kRawCalib)) {
+    Bool_t mon = fRawFile.Contains("mem://");
     // AliInfo("Getting FMD raw data digits");
-    if (!fReader->NextEvent()) return kFALSE;
-    AliFMDRawReader r(fReader, 0);
+    if (mon) std::cout << "Waiting for event ..." << std::flush;
+    do { 
+      if (!fReader->NextEvent()) { 
+       if (mon) { 
+         gSystem->Sleep(3);
+         continue;
+       }
+       return kFALSE;
+      }
+      UInt_t eventType = fReader->GetType();
+      if(eventType == AliRawEventHeaderBase::kPhysicsEvent ||
+        eventType == AliRawEventHeaderBase::kCalibrationEvent) 
+       break;
+    } while (true);
+    if (mon) std::cout << "got it" << std::endl;
+    // AliFMDRawReader r(fReader, 0);
     fArrayA->Clear();
-    r.ReadAdcs(fArrayA);
+    fFMDReader->ReadAdcs(fArrayA);
+    AliFMDDebug(1, ("Got a total of %d digits", fArrayA->GetEntriesFast()));
   }
   fEventCount++;
   return kTRUE;
@@ -358,18 +483,24 @@ AliFMDInput::Event()
   // 
   if (TESTBIT(fTreeMask, kHits)) 
     if (!ProcessHits()) return kFALSE; 
+  if (TESTBIT(fTreeMask, kTrackRefs)) 
+    if (!ProcessTrackRefs()) return kFALSE; 
   if (TESTBIT(fTreeMask, kTracks)) 
     if (!ProcessTracks()) return kFALSE; 
-  if (TESTBIT(fTreeMask, kDigits)) 
-    if (!ProcessDigits()) return kFALSE;
   if (TESTBIT(fTreeMask, kSDigits)) 
     if (!ProcessSDigits()) return kFALSE;
+  if (TESTBIT(fTreeMask, kDigits)) 
+    if (!ProcessDigits()) return kFALSE;
   if (TESTBIT(fTreeMask, kRaw)) 
     if (!ProcessRawDigits()) return kFALSE;
+  if (TESTBIT(fTreeMask, kRawCalib)) 
+    if (!ProcessRawCalibDigits()) return kFALSE;
   if (TESTBIT(fTreeMask, kRecPoints)) 
     if (!ProcessRecPoints()) return kFALSE;
   if (TESTBIT(fTreeMask, kESD))
     if (!ProcessESDs()) return kFALSE;
+  if (TESTBIT(fTreeMask, kUser))
+    if (!ProcessUsers()) return kFALSE;
   
   return kTRUE;
 }
@@ -384,19 +515,23 @@ AliFMDInput::ProcessHits()
     AliError("No hit tree defined");
     return kFALSE;
   }
+  if (!fArrayH) {
+    AliError("No hit array defined");
+    return kFALSE;
+  }
+
   Int_t nTracks = fTreeH->GetEntries();
   for (Int_t i = 0; i < nTracks; i++) {
     Int_t hitRead  = fTreeH->GetEntry(i);
     if (hitRead <= 0) continue;
-    if (!fArrayH) {
-      AliError("No hit array defined");
-      return kFALSE;
-    }
+
     Int_t nHit = fArrayH->GetEntries();
     if (nHit <= 0) continue;
+  
     for (Int_t j = 0; j < nHit; j++) {
       AliFMDHit* hit = static_cast<AliFMDHit*>(fArrayH->At(j));
       if (!hit) continue;
+
       TParticle* track = 0;
       if (TESTBIT(fTreeMask, kKinematics) && fStack) {
        Int_t trackno = hit->Track();
@@ -407,13 +542,46 @@ AliFMDInput::ProcessHits()
   }
   return kTRUE;
 }
+//____________________________________________________________________
+Bool_t 
+AliFMDInput::ProcessTrackRefs()
+{
+  // Read the reconstrcted points tree, and pass each reconstruction
+  // object (AliFMDRecPoint) to either ProcessRecPoint.
+  if (!fTreeTR) {
+    AliError("No track reference tree defined");
+    return kFALSE;
+  }
+  if (!fArrayTR) {
+    AliError("No track reference array defined");
+    return kFALSE;
+  }
 
+  Int_t nEv = fTreeTR->GetEntries();
+  for (Int_t i = 0; i < nEv; i++) {
+    Int_t trRead  = fTreeTR->GetEntry(i);
+    if (trRead <= 0) continue;
+    Int_t nTrackRefs = fArrayTR->GetEntries();
+    for (Int_t j = 0; j < nTrackRefs; j++) {
+      AliTrackReference* trackRef = static_cast<AliTrackReference*>(fArrayTR->At(j));
+      if (!trackRef) continue;
+      if (trackRef->DetectorId() != AliTrackReference::kFMD) continue;
+      TParticle* track = 0;
+      if (TESTBIT(fTreeMask, kKinematics) && fStack) {
+       Int_t trackno = trackRef->GetTrack();
+       track = fStack->Particle(trackno);
+      }
+      if (!ProcessTrackRef(trackRef,track)) return kFALSE;
+    }    
+  }
+  return kTRUE;
+}
 //____________________________________________________________________
 Bool_t 
 AliFMDInput::ProcessTracks()
 {
   // Read the hit tree, and pass each hit to the member function
-  // ProcessHit.
+  // ProcessTrack.
   if (!fStack) {
     AliError("No track tree defined");
     return kFALSE;
@@ -422,25 +590,32 @@ AliFMDInput::ProcessTracks()
     AliError("No hit tree defined");
     return kFALSE;
   }
+  if (!fArrayH) {
+    AliError("No hit array defined");
+    return kFALSE;
+  }
+
+  // Int_t nTracks = fStack->GetNtrack();
   Int_t nTracks = fTreeH->GetEntries();
   for (Int_t i = 0; i < nTracks; i++) {
-    TParticle* track = fStack->Particle(i);
+    Int_t      trackno = nTracks - i - 1;
+    TParticle* track   = fStack->Particle(trackno);
     if (!track) continue;
+
+    // Get the hits for this track. 
     Int_t hitRead  = fTreeH->GetEntry(i);
-    if (hitRead <= 0) continue;
-    if (!fArrayH) {
-      AliError("No hit array defined");
-      return kFALSE;
+    Int_t nHit     = fArrayH->GetEntries();
+    if (nHit == 0 || hitRead <= 0) { 
+      // Let user code see the track, even if there's no hits. 
+      if (!ProcessTrack(trackno, track, 0)) return kFALSE;
+      continue;
     }
-    Int_t nHit = fArrayH->GetEntries();
-    if (nHit <= 0) continue;
 
+    // Loop over the hits corresponding to this track.
     for (Int_t j = 0; j < nHit; j++) {
       AliFMDHit* hit = static_cast<AliFMDHit*>(fArrayH->At(j));
-      if (!hit) continue;
-      if (!ProcessTrack(i, track, hit)) return kFALSE;
-    }    
-    // if (!ProcessTrack(i, track, fArrayH)) return kFALSE;
+      if (!ProcessTrack(trackno, track, hit)) return kFALSE;
+    }   
   }
   return kTRUE;
 }
@@ -451,11 +626,21 @@ AliFMDInput::ProcessDigits()
 {
   // Read the digit tree, and pass each digit to the member function
   // ProcessDigit.
+  if (!fTreeD) {
+    AliError("No digit tree defined");
+    return kFALSE;
+  }
+  if (!fArrayD) {
+    AliError("No digit array defined");
+    return kFALSE;
+  }
+
   Int_t nEv = fTreeD->GetEntries();
   for (Int_t i = 0; i < nEv; i++) {
     Int_t digitRead  = fTreeD->GetEntry(i);
     if (digitRead <= 0) continue;
     Int_t nDigit = fArrayD->GetEntries();
+    AliFMDDebug(0, ("Got %5d digits for this event", nDigit));
     if (nDigit <= 0) continue;
     for (Int_t j = 0; j < nDigit; j++) {
       AliFMDDigit* digit = static_cast<AliFMDDigit*>(fArrayD->At(j));
@@ -472,11 +657,25 @@ AliFMDInput::ProcessSDigits()
 {
   // Read the summable digit tree, and pass each sumable digit to the
   // member function ProcessSdigit.
-  Int_t nEv = fTreeD->GetEntries();
+  if (!fTreeS) {
+    AliWarning("No sdigit tree defined");
+    return kTRUE; // Empty SDigits is fine
+  }
+  if (!fArrayS) {
+    AliWarning("No sdigit array defined");
+    return kTRUE; // Empty SDigits is fine
+  }
+
+  Int_t nEv = fTreeS->GetEntries();
   for (Int_t i = 0; i < nEv; i++) {
     Int_t sdigitRead  = fTreeS->GetEntry(i);
-    if (sdigitRead <= 0) continue;
-    Int_t nSdigit = fArrayS->GetEntries();
+    if (sdigitRead <= 0) { 
+      AliInfo(Form("Read nothing from tree"));
+      continue;
+    }
+    Int_t nSdigit = fArrayS->GetEntriesFast();
+    AliFMDDebug(0, ("Got %5d digits for this event", nSdigit));
+    AliInfo(Form("Got %5d digits for this event", nSdigit));
     if (nSdigit <= 0) continue;
     for (Int_t j = 0; j < nSdigit; j++) {
       AliFMDSDigit* sdigit = static_cast<AliFMDSDigit*>(fArrayS->At(j));
@@ -493,11 +692,18 @@ AliFMDInput::ProcessRawDigits()
 {
   // Read the digit tree, and pass each digit to the member function
   // ProcessDigit.
+  if (!fArrayA) {
+    AliError("No raw digit array defined");
+    return kFALSE;
+  }
+
   Int_t nDigit = fArrayA->GetEntries();
   if (nDigit <= 0) return kTRUE;
   for (Int_t j = 0; j < nDigit; j++) {
     AliFMDDigit* digit = static_cast<AliFMDDigit*>(fArrayA->At(j));
     if (!digit) continue;
+    if (AliLog::GetDebugLevel("FMD","") >= 40 && j < 30) 
+      digit->Print();
     if (!ProcessRawDigit(digit)) return kFALSE;
   }    
   return kTRUE;
@@ -505,10 +711,42 @@ AliFMDInput::ProcessRawDigits()
 
 //____________________________________________________________________
 Bool_t 
+AliFMDInput::ProcessRawCalibDigits()
+{
+  // Read the digit tree, and pass each digit to the member function
+  // ProcessDigit.
+  if (!fArrayA) {
+    AliError("No raw digit array defined");
+    return kFALSE;
+  }
+
+  Int_t nDigit = fArrayA->GetEntries();
+  if (nDigit <= 0) return kTRUE;
+  for (Int_t j = 0; j < nDigit; j++) {
+    AliFMDDigit* digit = static_cast<AliFMDDigit*>(fArrayA->At(j));
+    if (!digit) continue;
+    if (AliLog::GetDebugLevel("FMD","") >= 40 && j < 30) 
+      digit->Print();
+    if (!ProcessRawCalibDigit(digit)) return kFALSE;
+  }    
+  return kTRUE;
+}
+
+//____________________________________________________________________
+Bool_t 
 AliFMDInput::ProcessRecPoints()
 {
   // Read the reconstrcted points tree, and pass each reconstruction
   // object (AliFMDRecPoint) to either ProcessRecPoint.
+  if (!fTreeR) {
+    AliError("No recpoint tree defined");
+    return kFALSE;
+  }
+  if (!fArrayR) {
+    AliError("No recpoints array defined");
+    return kFALSE;
+  }
+
   Int_t nEv = fTreeR->GetEntries();
   for (Int_t i = 0; i < nEv; i++) {
     Int_t recRead  = fTreeR->GetEntry(i);
@@ -549,6 +787,27 @@ AliFMDInput::ProcessESDs()
 }
 
 //____________________________________________________________________
+Bool_t 
+AliFMDInput::ProcessUsers()
+{
+  // Process event summary data
+  for (UShort_t det = 1; det <= 3; det++) {
+    Char_t rings[] = { 'I', (det == 1 ? '\0' : 'O'), '\0' };
+    for (Char_t* rng = rings; *rng != '\0'; rng++) {
+      UShort_t nsec = (*rng == 'I' ?  20 :  40);
+      UShort_t nstr = (*rng == 'I' ? 512 : 256);
+      for (UShort_t sec = 0; sec < nsec; sec++) {
+       for (UShort_t str = 0; str < nstr; str++) {
+         Float_t v  = GetSignal(det,*rng,sec,str);
+         if (!ProcessUser(det, *rng, sec, str, v)) continue;
+       }
+      }
+    }
+  }
+  return kTRUE;
+}
+
+//____________________________________________________________________
 Bool_t
 AliFMDInput::End()
 {
@@ -588,7 +847,7 @@ AliFMDInput::End()
     fFMDLoader->UnloadRecPoints();
     fTreeR = 0;
   }
-  AliInfo("Now out event");
+  // AliInfo("Now out event");
   return kTRUE;
 }
 
@@ -602,7 +861,7 @@ AliFMDInput::Run()
   if (!(retval = Init())) return retval;
 
   Int_t nEvents = NEvents();
-  for (Int_t event = 0; event < nEvents; event++) {
+  for (Int_t event = 0; nEvents < 0 || event < nEvents; event++) {
     if (!(retval = Begin(event))) break;
     if (!(retval = Event())) break;
     if (!(retval = End())) break;