Changes suggested by Effective C++ (F.Carminati)
[u/mrichter/AliRoot.git] / STEER / AliReconstruction.cxx
index f1fd8fc..556c72a 100644 (file)
 //   rec.Run();                                                              //
 //                                                                           //
 // The Run method returns kTRUE in case of successful execution.             //
+//                                                                           //
+// If the input to the reconstruction are not simulated digits but raw data, //
+// this can be specified by an argument of the Run method or by the method   //
+//                                                                           //
+//   rec.SetInput("...");                                                    //
+//                                                                           //
+// The input formats and the corresponding argument are:                     //
+// - DDL raw data files: directory name, ends with "/"                       //
+// - raw data root file: root file name, extension ".root"                   //
+// - raw data DATE file: DATE file name, any other non-empty string          //
+// - MC root files     : empty string, default                               //
+//                                                                           //
+// By default all events are reconstructed. The reconstruction can be        //
+// limited to a range of events by giving the index of the first and the     //
+// last event as an argument to the Run method or by calling                 //
+//                                                                           //
+//   rec.SetEventRange(..., ...);                                            //
+//                                                                           //
+// The index -1 (default) can be used for the last event to indicate no      //
+// upper limit of the event range.                                           //
+//                                                                           //
 // The name of the galice file can be changed from the default               //
 // "galice.root" by passing it as argument to the AliReconstruction          //
 // constructor or by                                                         //
 // detectors separated by a space. The special string "ALL" selects all      //
 // available detectors. This is the default.                                 //
 //                                                                           //
-// The tracking in ITS, TPC and TRD and the creation of ESD tracks can be    //
-// switched off by                                                           //
+// The reconstruction of the primary vertex position can be switched off by  //
 //                                                                           //
-//   rec.SetRunTracking(kFALSE);                                             //
+//   rec.SetRunVertexFinder(kFALSE);                                         //
+//                                                                           //
+// The tracking and the creation of ESD tracks can be switched on for        //
+// selected detectors by                                                     //
+//                                                                           //
+//   rec.SetRunTracking("...");                                              //
 //                                                                           //
 // The filling of additional ESD information can be steered by               //
 //                                                                           //
 //   rec.SetFillESD("...");                                                  //
 //                                                                           //
-// Again, the string specifies the list of detectors. The default is "ALL".  //
+// Again, for both methods the string specifies the list of detectors.       //
+// The default is "ALL".                                                     //
+//                                                                           //
+// The call of the shortcut method                                           //
 //                                                                           //
-// The reconstruction requires digits as input. For the creation of digits   //
-// have a look at the class AliSimulation.                                   //
+//   rec.SetRunReconstruction("...");                                        //
+//                                                                           //
+// is equivalent to calling SetRunLocalReconstruction, SetRunTracking and    //
+// SetFillESD with the same detector selecting string as argument.           //
+//                                                                           //
+// The reconstruction requires digits or raw data as input. For the creation //
+// of digits and raw data have a look at the class AliSimulation.            //
 //                                                                           //
 // For debug purposes the method SetCheckPointLevel can be used. If the      //
 // argument is greater than 0, files with ESD events will be written after   //
 #include <TStopwatch.h>
 
 #include "AliReconstruction.h"
+#include "AliReconstructor.h"
+#include "AliLog.h"
 #include "AliRunLoader.h"
 #include "AliRun.h"
+#include "AliRawReaderFile.h"
+#include "AliRawReaderDate.h"
+#include "AliRawReaderRoot.h"
 #include "AliTracker.h"
 #include "AliESD.h"
 #include "AliESDVertex.h"
 #include "AliVertexer.h"
 #include "AliHeader.h"
 #include "AliGenEventHeader.h"
+#include "AliPID.h"
 #include "AliESDpid.h"
 #include "AliMagF.h"
 
@@ -100,28 +139,29 @@ AliReconstruction::AliReconstruction(const char* gAliceFilename,
 
   fRunLocalReconstruction("ALL"),
   fRunVertexFinder(kTRUE),
-  fRunTracking(kTRUE),
+  fRunTracking("ALL"),
   fFillESD("ALL"),
   fGAliceFileName(gAliceFilename),
+  fInput(""),
+  fFirstEvent(0),
+  fLastEvent(-1),
   fStopOnError(kFALSE),
   fCheckPointLevel(0),
+  fOptions(),
 
   fRunLoader(NULL),
-  fITSLoader(NULL),
-  fITSVertexer(NULL),
-  fITSTracker(NULL),
-  fTPCLoader(NULL),
-  fTPCTracker(NULL),
-  fTRDLoader(NULL),
-  fTRDTracker(NULL),
-  fTOFLoader(NULL),
-  fTOFTracker(NULL),
-
-  fReconstructors(),
-  fOptions()
+  fRawReader(NULL),
+
+  fVertexer(NULL)
 {
 // create reconstruction object with default parameters
-
+  
+  for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+    fReconstructor[iDet] = NULL;
+    fLoader[iDet] = NULL;
+    fTracker[iDet] = NULL;
+  }
+  //  AliPID::Init();
 }
 
 //_____________________________________________________________________________
@@ -133,28 +173,28 @@ AliReconstruction::AliReconstruction(const AliReconstruction& rec) :
   fRunTracking(rec.fRunTracking),
   fFillESD(rec.fFillESD),
   fGAliceFileName(rec.fGAliceFileName),
+  fInput(rec.fInput),
+  fFirstEvent(rec.fFirstEvent),
+  fLastEvent(rec.fLastEvent),
   fStopOnError(rec.fStopOnError),
   fCheckPointLevel(0),
+  fOptions(),
 
   fRunLoader(NULL),
-  fITSLoader(NULL),
-  fITSVertexer(NULL),
-  fITSTracker(NULL),
-  fTPCLoader(NULL),
-  fTPCTracker(NULL),
-  fTRDLoader(NULL),
-  fTRDTracker(NULL),
-  fTOFLoader(NULL),
-  fTOFTracker(NULL),
-
-  fReconstructors(),
-  fOptions()
+  fRawReader(NULL),
+
+  fVertexer(NULL)
 {
 // copy constructor
 
   for (Int_t i = 0; i < fOptions.GetEntriesFast(); i++) {
     if (rec.fOptions[i]) fOptions.Add(rec.fOptions[i]->Clone());
   }
+  for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+    fReconstructor[iDet] = NULL;
+    fLoader[iDet] = NULL;
+    fTracker[iDet] = NULL;
+  }
 }
 
 //_____________________________________________________________________________
@@ -197,69 +237,25 @@ void AliReconstruction::SetOption(const char* detector, const char* option)
 
 
 //_____________________________________________________________________________
-Bool_t AliReconstruction::Run()
+Bool_t AliReconstruction::Run(const char* input,
+                             Int_t firstEvent, Int_t lastEvent)
 {
 // run the reconstruction
 
-  // open the run loader
-  fRunLoader = AliRunLoader::Open(fGAliceFileName.Data());
-  if (!fRunLoader) {
-    Error("Run", "no run loader found in file %s", 
-         fGAliceFileName.Data());
-    CleanUp();
-    return kFALSE;
-  }
-  fRunLoader->LoadgAlice();
-  AliRun* aliRun = fRunLoader->GetAliRun();
-  if (!aliRun) {
-    Error("Run", "no gAlice object found in file %s", 
-         fGAliceFileName.Data());
-    CleanUp();
-    return kFALSE;
+  // set the input
+  if (!input) input = fInput.Data();
+  TString fileName(input);
+  if (fileName.EndsWith("/")) {
+    fRawReader = new AliRawReaderFile(fileName);
+  } else if (fileName.EndsWith(".root")) {
+    fRawReader = new AliRawReaderRoot(fileName);
+  } else if (!fileName.IsNull()) {
+    fRawReader = new AliRawReaderDate(fileName);
+    fRawReader->SelectEvents(7);
   }
-  gAlice = aliRun;
-
-  // load the reconstructor objects
-  TPluginManager* pluginManager = gROOT->GetPluginManager();
-  for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
-    TString detName = fgkDetectorName[iDet];
-    TString recName = "Ali" + detName + "Reconstructor";
-    if (!gAlice->GetDetector(detName) && detName != "HLT") continue;
-
-    if(detName == "HLT") {
-      if (!gROOT->GetClass("AliLevel3")) {
-       gSystem->Load("libAliL3Src.so");
-       gSystem->Load("libAliL3Misc.so");
-       gSystem->Load("libAliL3Hough.so");
-       gSystem->Load("libAliL3Comp.so");
-      }
-    }
 
-    AliReconstructor* reconstructor = NULL;
-    // first check if a plugin is defined for the reconstructor
-    TPluginHandler* pluginHandler = 
-      pluginManager->FindHandler("AliReconstructor", detName);
-    // if not, but the reconstructor class is implemented, add a plugin for it
-    if (!pluginHandler && gROOT->GetClass(recName.Data())) {
-      Info("Run", "defining plugin for %s", recName.Data());
-      pluginManager->AddHandler("AliReconstructor", detName, 
-                               recName, detName, recName + "()");
-      pluginHandler = pluginManager->FindHandler("AliReconstructor", detName);
-    }
-    if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
-      reconstructor = (AliReconstructor*) pluginHandler->ExecPlugin(0);
-    }
-    // if there is no reconstructor class for the detector use the dummy one
-    if (!reconstructor && gAlice->GetDetector(detName)) {
-      Info("Run", "using dummy reconstructor for %s", detName.Data());
-      reconstructor = new AliDummyReconstructor(gAlice->GetDetector(detName));
-    }
-    if (reconstructor) {
-      TObject* obj = fOptions.FindObject(detName.Data());
-      if (obj) reconstructor->SetOption(obj->GetTitle());
-      fReconstructors.Add(reconstructor);
-    }
-  }
+  // get the run loader
+  if (!InitRunLoader()) return kFALSE;
 
   // local reconstruction
   if (!fRunLocalReconstruction.IsNull()) {
@@ -267,7 +263,8 @@ Bool_t AliReconstruction::Run()
       if (fStopOnError) {CleanUp(); return kFALSE;}
     }
   }
-  if (!fRunVertexFinder && !fRunTracking && fFillESD.IsNull()) return kTRUE;
+//  if (!fRunVertexFinder && fRunTracking.IsNull() && 
+//      fFillESD.IsNull()) return kTRUE;
 
   // get vertexer
   if (fRunVertexFinder && !CreateVertexer()) {
@@ -277,56 +274,94 @@ Bool_t AliReconstruction::Run()
     }
   }
 
-  // get loaders and trackers
-  if (fRunTracking && !CreateTrackers()) {
+  // get trackers
+  if (!fRunTracking.IsNull() && !CreateTrackers(fRunTracking)) {
     if (fStopOnError) {
       CleanUp(); 
       return kFALSE;
     }      
   }
 
+  // get the possibly already existing ESD file and tree
+  AliESD* esd = new AliESD;
+  TFile* fileOld = NULL;
+  TTree* treeOld = NULL;
+  if (!gSystem->AccessPathName("AliESDs.root")){
+    gSystem->CopyFile("AliESDs.root", "AliESDs.old.root", kTRUE);
+    fileOld = TFile::Open("AliESDs.old.root");
+    if (fileOld && fileOld->IsOpen()) {
+      treeOld = (TTree*) fileOld->Get("esdTree");
+      if (treeOld) treeOld->SetBranchAddress("ESD", &esd);
+    }
+  }
+
   // create the ESD output file and tree
   TFile* file = TFile::Open("AliESDs.root", "RECREATE");
   if (!file->IsOpen()) {
-    Error("Run", "opening AliESDs.root failed");
-    if (fStopOnError) {CleanUp(file); return kFALSE;}    
+    AliError("opening AliESDs.root failed");
+    if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}    
   }
-  AliESD* esd = new AliESD;
   TTree* tree = new TTree("esdTree", "Tree with ESD objects");
   tree->Branch("ESD", "AliESD", &esd);
   delete esd;
+  esd = NULL;
   gROOT->cd();
 
   // loop over events
+  if (fRawReader) fRawReader->RewindEvents();
+  
   for (Int_t iEvent = 0; iEvent < fRunLoader->GetNumberOfEvents(); iEvent++) {
-    Info("Run", "processing event %d", iEvent);
+    if (fRawReader) fRawReader->NextEvent();
+    if ((iEvent < firstEvent) || ((lastEvent >= 0) && (iEvent > lastEvent))) {
+      // copy old ESD to the new one
+      if (treeOld) {
+       treeOld->SetBranchAddress("ESD", &esd);
+       treeOld->GetEntry(iEvent);
+      }
+      tree->Fill();
+      continue;
+    }
+
+    AliInfo(Form("processing event %d", iEvent));
     fRunLoader->GetEvent(iEvent);
 
     char fileName[256];
     sprintf(fileName, "ESD_%d.%d_final.root", 
-           aliRun->GetRunNumber(), aliRun->GetEvNumber());
+           fRunLoader->GetHeader()->GetRun(), 
+           fRunLoader->GetHeader()->GetEventNrInRun());
     if (!gSystem->AccessPathName(fileName)) continue;
 
+    // local reconstruction
+    if (!fRunLocalReconstruction.IsNull()) {
+      if (!RunLocalEventReconstruction(fRunLocalReconstruction)) {
+       if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
+      }
+    }
+
     esd = new AliESD;
-    esd->SetRunNumber(aliRun->GetRunNumber());
-    esd->SetEventNumber(aliRun->GetEvNumber());
-    esd->SetMagneticField(aliRun->Field()->SolenoidField());
+    esd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
+    esd->SetEventNumber(fRunLoader->GetHeader()->GetEventNrInRun());
+    if (gAlice) {
+      esd->SetMagneticField(gAlice->Field()->SolenoidField());
+    } else {
+      // ???
+    }
 
     // vertex finder
     if (fRunVertexFinder) {
       if (!ReadESD(esd, "vertex")) {
        if (!RunVertexFinder(esd)) {
-         if (fStopOnError) {CleanUp(file); return kFALSE;}
+         if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
        }
        if (fCheckPointLevel > 0) WriteESD(esd, "vertex");
       }
     }
 
     // barrel tracking
-    if (fRunTracking) {
+    if (!fRunTracking.IsNull()) {
       if (!ReadESD(esd, "tracking")) {
        if (!RunTracking(esd)) {
-         if (fStopOnError) {CleanUp(file); return kFALSE;}
+         if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
        }
        if (fCheckPointLevel > 0) WriteESD(esd, "tracking");
       }
@@ -335,7 +370,7 @@ Bool_t AliReconstruction::Run()
     // fill ESD
     if (!fFillESD.IsNull()) {
       if (!FillESD(esd, fFillESD)) {
-       if (fStopOnError) {CleanUp(file); return kFALSE;}
+       if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
       }
     }
 
@@ -348,11 +383,12 @@ Bool_t AliReconstruction::Run()
 
     if (fCheckPointLevel > 0) WriteESD(esd, "final");
     delete esd;
+    esd = NULL;
   }
 
   file->cd();
   tree->Write();
-  CleanUp(file);
+  CleanUp(file, fileOld);
 
   return kTRUE;
 }
@@ -367,29 +403,105 @@ Bool_t AliReconstruction::RunLocalReconstruction(const TString& detectors)
   stopwatch.Start();
 
   TString detStr = detectors;
-  for (Int_t iDet = 0; iDet < fReconstructors.GetEntriesFast(); iDet++) {
-    AliReconstructor* reconstructor = 
-      (AliReconstructor*) fReconstructors[iDet];
-    TString detName = reconstructor->GetDetectorName();
-    if (IsSelected(detName, detStr)) {
-      Info("RunReconstruction", "running reconstruction for %s", 
-          detName.Data());
+  for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+    if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
+    AliReconstructor* reconstructor = GetReconstructor(iDet);
+    if (!reconstructor) continue;
+    if (reconstructor->HasLocalReconstruction()) continue;
+
+    AliInfo(Form("running reconstruction for %s", fgkDetectorName[iDet]));
+    TStopwatch stopwatchDet;
+    stopwatchDet.Start();
+    if (fRawReader) {
+      fRawReader->RewindEvents();
+      reconstructor->Reconstruct(fRunLoader, fRawReader);
+    } else {
+      reconstructor->Reconstruct(fRunLoader);
+    }
+    AliInfo(Form("execution time for %s:", fgkDetectorName[iDet]));
+    ToAliInfo(stopwatchDet.Print());
+  }
+
+  if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
+    AliError(Form("the following detectors were not found: %s",
+                  detStr.Data()));
+    if (fStopOnError) return kFALSE;
+  }
+
+  AliInfo("execution time:");
+  ToAliInfo(stopwatch.Print());
+
+  return kTRUE;
+}
+
+//_____________________________________________________________________________
+Bool_t AliReconstruction::RunLocalEventReconstruction(const TString& detectors)
+{
+// run the local reconstruction
+
+  TStopwatch stopwatch;
+  stopwatch.Start();
+
+  TString detStr = detectors;
+  for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+    if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
+    AliReconstructor* reconstructor = GetReconstructor(iDet);
+    if (!reconstructor) continue;
+    AliLoader* loader = fLoader[iDet];
+
+    // conversion of digits
+    if (fRawReader && reconstructor->HasDigitConversion()) {
+      AliInfo(Form("converting raw data digits into root objects for %s", 
+                  fgkDetectorName[iDet]));
       TStopwatch stopwatchDet;
       stopwatchDet.Start();
-      reconstructor->Reconstruct(fRunLoader);
-      Info("RunReconstruction", "execution time for %s:", detName.Data());
-      stopwatchDet.Print();
+      loader->LoadDigits("update");
+      loader->CleanDigits();
+      loader->MakeDigitsContainer();
+      TTree* digitsTree = loader->TreeD();
+      reconstructor->ConvertDigits(fRawReader, digitsTree);
+      loader->WriteDigits("OVERWRITE");
+      loader->UnloadDigits();
+      AliDebug(1, Form("execution time for %s:", fgkDetectorName[iDet]));
+      ToAliDebug(1, stopwatchDet.Print());
     }
+
+    // local reconstruction
+    if (!reconstructor->HasLocalReconstruction()) continue;
+    AliInfo(Form("running reconstruction for %s", fgkDetectorName[iDet]));
+    TStopwatch stopwatchDet;
+    stopwatchDet.Start();
+    loader->LoadRecPoints("update");
+    loader->CleanRecPoints();
+    loader->MakeRecPointsContainer();
+    TTree* clustersTree = loader->TreeR();
+    if (fRawReader && !reconstructor->HasDigitConversion()) {
+      reconstructor->Reconstruct(fRawReader, clustersTree);
+    } else {
+      loader->LoadDigits("read");
+      TTree* digitsTree = loader->TreeD();
+      if (!digitsTree) {
+       AliError(Form("Can't get the %s digits tree", fgkDetectorName[iDet]));
+       if (fStopOnError) return kFALSE;
+      } else {
+       reconstructor->Reconstruct(digitsTree, clustersTree);
+      }
+      loader->UnloadDigits();
+    }
+    loader->WriteRecPoints("OVERWRITE");
+    loader->UnloadRecPoints();
+    AliDebug(1, Form("execution time for %s:", fgkDetectorName[iDet]));
+    ToAliDebug(1, stopwatchDet.Print());
   }
 
   if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
-    Error("RunReconstruction", "the following detectors were not found: %s", 
-         detStr.Data());
+    AliError(Form("the following detectors were not found: %s",
+                  detStr.Data()));
     if (fStopOnError) return kFALSE;
   }
 
-  Info("RunReconstruction", "execution time:");
-  stopwatch.Print();
+  AliInfo("execution time:");
+  ToAliInfo(stopwatch.Print());
 
   return kTRUE;
 }
@@ -411,12 +523,13 @@ Bool_t AliReconstruction::RunVertexFinder(AliESD*& esd)
     for (Int_t i = 0; i < 3; i++) vtxPos[i] = mcVertex[i];
   }
 
-  if (fITSVertexer) {
-    Info("RunVertexFinder", "running the ITS vertex finder");
-    fITSVertexer->SetDebug(1);
-    vertex = fITSVertexer->FindVertexForCurrentEvent(fRunLoader->GetEventNumber());
+  if (fVertexer) {
+    AliInfo("running the ITS vertex finder");
+    if (fLoader[0]) fLoader[0]->LoadRecPoints();
+    vertex = fVertexer->FindVertexForCurrentEvent(fRunLoader->GetEventNumber());
+    if (fLoader[0]) fLoader[0]->UnloadRecPoints();
     if(!vertex){
-      Warning("RunVertexFinder","Vertex not found \n");
+      AliWarning("Vertex not found");
       vertex = new AliESDVertex();
     }
     else {
@@ -424,7 +537,7 @@ Bool_t AliReconstruction::RunVertexFinder(AliESD*& esd)
     }
 
   } else {
-    Info("RunVertexFinder", "getting the primary vertex from MC");
+    AliInfo("getting the primary vertex from MC");
     vertex = new AliESDVertex(vtxPos, vtxErr);
   }
 
@@ -432,17 +545,17 @@ Bool_t AliReconstruction::RunVertexFinder(AliESD*& esd)
     vertex->GetXYZ(vtxPos);
     vertex->GetSigmaXYZ(vtxErr);
   } else {
-    Warning("RunVertexFinder", "no vertex reconstructed");
+    AliWarning("no vertex reconstructed");
     vertex = new AliESDVertex(vtxPos, vtxErr);
   }
   esd->SetVertex(vertex);
-  if (fITSTracker) fITSTracker->SetVertex(vtxPos, vtxErr);
-  if (fTPCTracker) fTPCTracker->SetVertex(vtxPos, vtxErr);
-  if (fTRDTracker) fTRDTracker->SetVertex(vtxPos, vtxErr);
+  for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+    if (fTracker[iDet]) fTracker[iDet]->SetVertex(vtxPos, vtxErr);
+  }  
   delete vertex;
 
-  Info("RunVertexFinder", "execution time:");
-  stopwatch.Print();
+  AliInfo("execution time:");
+  ToAliInfo(stopwatch.Print());
 
   return kTRUE;
 }
@@ -455,139 +568,101 @@ Bool_t AliReconstruction::RunTracking(AliESD*& esd)
   TStopwatch stopwatch;
   stopwatch.Start();
 
-  if (!fTPCTracker) {
-    Error("RunTracking", "no TPC tracker");
-    return kFALSE;
-  }
-
-  // TPC tracking
-  Info("RunTracking", "TPC tracking");
-  fTPCLoader->LoadRecPoints("read");
-  TTree* tpcTree = fTPCLoader->TreeR();
-  if (!tpcTree) {
-    Error("RunTracking", "Can't get the TPC cluster tree");
-    return kFALSE;
-  }
-  fTPCTracker->LoadClusters(tpcTree);
-  if (fTPCTracker->Clusters2Tracks(esd) != 0) {
-    Error("RunTracking", "TPC Clusters2Tracks failed");
-    return kFALSE;
-  }
-  if (fCheckPointLevel > 1) WriteESD(esd, "TPC.tracking");
-
-  if (!fITSTracker) {
-    Warning("RunTracking", "no ITS tracker");
-  } else {
+  AliInfo("running tracking");
 
-    GetReconstructor("TPC")->FillESD(fRunLoader, esd); // preliminary
-    AliESDpid::MakePID(esd);                  // PID for the ITS tracker
+  // pass 1: TPC + ITS inwards
+  for (Int_t iDet = 1; iDet >= 0; iDet--) {
+    if (!fTracker[iDet]) continue;
+    AliDebug(1, Form("%s tracking", fgkDetectorName[iDet]));
 
-    // ITS tracking
-    Info("RunTracking", "ITS tracking");
-    fITSLoader->LoadRecPoints("read");
-    TTree* itsTree = fITSLoader->TreeR();
-    if (!itsTree) {
-      Error("RunTracking", "Can't get the ITS cluster tree");
+    // load clusters
+    fLoader[iDet]->LoadRecPoints("read");
+    TTree* tree = fLoader[iDet]->TreeR();
+    if (!tree) {
+      AliError(Form("Can't get the %s cluster tree", fgkDetectorName[iDet]));
       return kFALSE;
     }
-    fITSTracker->LoadClusters(itsTree);
-    if (fITSTracker->Clusters2Tracks(esd) != 0) {
-      Error("RunTracking", "ITS Clusters2Tracks failed");
+    fTracker[iDet]->LoadClusters(tree);
+
+    // run tracking
+    if (fTracker[iDet]->Clusters2Tracks(esd) != 0) {
+      AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
       return kFALSE;
     }
-    if (fCheckPointLevel > 1) WriteESD(esd, "ITS.tracking");
-
-    if (!fTRDTracker) {
-      Warning("RunTracking", "no TRD tracker");
-    } else {
-      // ITS back propagation
-      Info("RunTracking", "ITS back propagation");
-      if (fITSTracker->PropagateBack(esd) != 0) {
-       Error("RunTracking", "ITS backward propagation failed");
-       return kFALSE;
-      }
-      if (fCheckPointLevel > 1) WriteESD(esd, "ITS.back");
+    if (fCheckPointLevel > 1) {
+      WriteESD(esd, Form("%s.tracking", fgkDetectorName[iDet]));
+    }
+    // preliminary PID in TPC needed by the ITS tracker
+    if (iDet == 1) {
+      GetReconstructor(1)->FillESD(fRunLoader, esd);
+      GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
+      AliESDpid::MakePID(esd);
+    }
+  }
 
-      // TPC back propagation
-      Info("RunTracking", "TPC back propagation");
-      if (fTPCTracker->PropagateBack(esd) != 0) {
-       Error("RunTracking", "TPC backward propagation failed");
-       return kFALSE;
-      }
-      if (fCheckPointLevel > 1) WriteESD(esd, "TPC.back");
-
-      // TRD back propagation
-      Info("RunTracking", "TRD back propagation");
-      fTRDLoader->LoadRecPoints("read");
-      TTree* trdTree = fTRDLoader->TreeR();
-      if (!trdTree) {
-       Error("RunTracking", "Can't get the TRD cluster tree");
-       return kFALSE;
+  // pass 2: ALL backwards
+  for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+    if (!fTracker[iDet]) continue;
+    AliDebug(1, Form("%s back propagation", fgkDetectorName[iDet]));
+
+    // load clusters
+    if (iDet > 1) {     // all except ITS, TPC
+      TTree* tree = NULL;
+      if (iDet == 3) {   // TOF
+       fLoader[iDet]->LoadDigits("read");
+       tree = fLoader[iDet]->TreeD();
+      } else {
+       fLoader[iDet]->LoadRecPoints("read");
+       tree = fLoader[iDet]->TreeR();
       }
-      fTRDTracker->LoadClusters(trdTree);
-      if (fTRDTracker->PropagateBack(esd) != 0) {
-       Error("RunTracking", "TRD backward propagation failed");
+      if (!tree) {
+       AliError(Form("Can't get the %s cluster tree", fgkDetectorName[iDet]));
        return kFALSE;
       }
-      if (fCheckPointLevel > 1) WriteESD(esd, "TRD.back");
+      fTracker[iDet]->LoadClusters(tree);
+    }
 
-      if (!fTOFTracker) {
-       Warning("RunTracking", "no TOF tracker");
+    // run tracking
+    if (fTracker[iDet]->PropagateBack(esd) != 0) {
+      AliError(Form("%s backward propagation failed", fgkDetectorName[iDet]));
+      return kFALSE;
+    }
+    if (fCheckPointLevel > 1) {
+      WriteESD(esd, Form("%s.back", fgkDetectorName[iDet]));
+    }
+
+    // unload clusters
+    if (iDet > 2) {     // all except ITS, TPC, TRD
+      fTracker[iDet]->UnloadClusters();
+      if (iDet == 3) {   // TOF
+       fLoader[iDet]->UnloadDigits();
       } else {
-       // TOF back propagation
-       Info("RunTracking", "TOF back propagation");
-       fTOFLoader->LoadDigits("read");
-       TTree* tofTree = fTOFLoader->TreeD();
-       if (!tofTree) {
-         Error("RunTracking", "Can't get the TOF digits tree");
-         return kFALSE;
-       }
-       fTOFTracker->LoadClusters(tofTree);
-       if (fTOFTracker->PropagateBack(esd) != 0) {
-         Error("RunTracking", "TOF backward propagation failed");
-         return kFALSE;
-       }
-       if (fCheckPointLevel > 1) WriteESD(esd, "TOF.back");
-       fTOFTracker->UnloadClusters();
-       fTOFLoader->UnloadDigits();
+       fLoader[iDet]->UnloadRecPoints();
       }
+    }
+  }
 
-      // TRD inward refit
-      Info("RunTracking", "TRD inward refit");
-      if (fTRDTracker->RefitInward(esd) != 0) {
-       Error("RunTracking", "TRD inward refit failed");
-       return kFALSE;
-      }
-      if (fCheckPointLevel > 1) WriteESD(esd, "TRD.refit");
-      fTRDTracker->UnloadClusters();
-      fTRDLoader->UnloadRecPoints();
-    
-      // TPC inward refit
-      Info("RunTracking", "TPC inward refit");
-      if (fTPCTracker->RefitInward(esd) != 0) {
-       Error("RunTracking", "TPC inward refit failed");
-       return kFALSE;
-      }
-      if (fCheckPointLevel > 1) WriteESD(esd, "TPC.refit");
-    
-      // ITS inward refit
-      Info("RunTracking", "ITS inward refit");
-      if (fITSTracker->RefitInward(esd) != 0) {
-       Error("RunTracking", "ITS inward refit failed");
-       return kFALSE;
-      }
-      if (fCheckPointLevel > 1) WriteESD(esd, "ITS.refit");
+  // pass 3: TRD + TPC + ITS refit inwards
+  for (Int_t iDet = 2; iDet >= 0; iDet--) {
+    if (!fTracker[iDet]) continue;
+    AliDebug(1, Form("%s inward refit", fgkDetectorName[iDet]));
 
-    }  // if TRD tracker
-    fITSTracker->UnloadClusters();
-    fITSLoader->UnloadRecPoints();
+    // run tracking
+    if (fTracker[iDet]->RefitInward(esd) != 0) {
+      AliError(Form("%s inward refit failed", fgkDetectorName[iDet]));
+      return kFALSE;
+    }
+    if (fCheckPointLevel > 1) {
+      WriteESD(esd, Form("%s.refit", fgkDetectorName[iDet]));
+    }
 
-  }  // if ITS tracker
-  fTPCTracker->UnloadClusters();
-  fTPCLoader->UnloadRecPoints();
+    // unload clusters
+    fTracker[iDet]->UnloadClusters();
+    fLoader[iDet]->UnloadRecPoints();
+  }
 
-  Info("RunTracking", "execution time:");
-  stopwatch.Print();
+  AliInfo("execution time:");
+  ToAliInfo(stopwatch.Print());
 
   return kTRUE;
 }
@@ -599,29 +674,63 @@ Bool_t AliReconstruction::FillESD(AliESD*& esd, const TString& detectors)
 
   TStopwatch stopwatch;
   stopwatch.Start();
+  AliInfo("filling ESD");
 
   TString detStr = detectors;
-  for (Int_t iDet = 0; iDet < fReconstructors.GetEntriesFast(); iDet++) {
-    AliReconstructor* reconstructor = 
-      (AliReconstructor*) fReconstructors[iDet];
-    TString detName = reconstructor->GetDetectorName();
-    if (IsSelected(detName, detStr)) {
-      if (!ReadESD(esd, detName.Data())) {
-       Info("FillESD", "filling ESD for %s", detName.Data());
-       reconstructor->FillESD(fRunLoader, esd);
-       if (fCheckPointLevel > 2) WriteESD(esd, detName.Data());
+  for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+    if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
+    AliReconstructor* reconstructor = GetReconstructor(iDet);
+    if (!reconstructor) continue;
+
+    if (!ReadESD(esd, fgkDetectorName[iDet])) {
+      AliDebug(1, Form("filling ESD for %s", fgkDetectorName[iDet]));
+      TTree* clustersTree = NULL;
+      if (reconstructor->HasLocalReconstruction() && fLoader[iDet]) {
+       fLoader[iDet]->LoadRecPoints("read");
+       clustersTree = fLoader[iDet]->TreeR();
+       if (!clustersTree) {
+         AliError(Form("Can't get the %s clusters tree", 
+                       fgkDetectorName[iDet]));
+         if (fStopOnError) return kFALSE;
+       }
+      }
+      if (fRawReader && !reconstructor->HasDigitConversion()) {
+        reconstructor->FillESD(fRawReader, clustersTree, esd);
+      } else {
+       TTree* digitsTree = NULL;
+       if (fLoader[iDet]) {
+         fLoader[iDet]->LoadDigits("read");
+         digitsTree = fLoader[iDet]->TreeD();
+         if (!digitsTree) {
+           AliError(Form("Can't get the %s digits tree", 
+                         fgkDetectorName[iDet]));
+           if (fStopOnError) return kFALSE;
+         }
+       }
+       reconstructor->FillESD(digitsTree, clustersTree, esd);
+       if (fLoader[iDet]) fLoader[iDet]->UnloadDigits();
       }
+      if (reconstructor->HasLocalReconstruction() && fLoader[iDet]) {
+       fLoader[iDet]->UnloadRecPoints();
+      }
+
+      if (fRawReader) {
+        reconstructor->FillESD(fRunLoader, fRawReader, esd);
+      } else {
+        reconstructor->FillESD(fRunLoader, esd);
+      }
+      if (fCheckPointLevel > 2) WriteESD(esd, fgkDetectorName[iDet]);
     }
   }
 
   if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
-    Error("FillESD", "the following detectors were not found: %s", 
-         detStr.Data());
+    AliError(Form("the following detectors were not found: %s", 
+                  detStr.Data()));
     if (fStopOnError) return kFALSE;
   }
 
-  Info("FillESD", "execution time:");
-  stopwatch.Print();
+  AliInfo("execution time:");
+  ToAliInfo(stopwatch.Print());
 
   return kTRUE;
 }
@@ -661,18 +770,167 @@ Bool_t AliReconstruction::IsSelected(TString detName, TString& detectors) const
 }
 
 //_____________________________________________________________________________
-AliReconstructor* AliReconstruction::GetReconstructor(const char* detName) const
+Bool_t AliReconstruction::InitRunLoader()
+{
+// get or create the run loader
+
+  if (gAlice) delete gAlice;
+  gAlice = NULL;
+
+  if (!gSystem->AccessPathName(fGAliceFileName.Data())) { // galice.root exists
+    // load all base libraries to get the loader classes
+    TString libs = gSystem->GetLibraries();
+    for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+      TString detName = fgkDetectorName[iDet];
+      if (detName == "HLT") continue;
+      if (libs.Contains("lib" + detName + "base.so")) continue;
+      gSystem->Load("lib" + detName + "base.so");
+    }
+    fRunLoader = AliRunLoader::Open(fGAliceFileName.Data());
+    if (!fRunLoader) {
+      AliError(Form("no run loader found in file %s", fGAliceFileName.Data()));
+      CleanUp();
+      return kFALSE;
+    }
+    fRunLoader->CdGAFile();
+    if (gFile->GetKey(AliRunLoader::GetGAliceName())) {
+      if (fRunLoader->LoadgAlice() == 0) {
+       gAlice = fRunLoader->GetAliRun();
+       AliTracker::SetFieldMap(gAlice->Field());
+      }
+    }
+    if (!gAlice && !fRawReader) {
+      AliError(Form("no gAlice object found in file %s",
+                   fGAliceFileName.Data()));
+      CleanUp();
+      return kFALSE;
+    }
+
+  } else {               // galice.root does not exist
+    if (!fRawReader) {
+      AliError(Form("the file %s does not exist", fGAliceFileName.Data()));
+      CleanUp();
+      return kFALSE;
+    }
+    fRunLoader = AliRunLoader::Open(fGAliceFileName.Data(),
+                                   AliConfig::GetDefaultEventFolderName(),
+                                   "recreate");
+    if (!fRunLoader) {
+      AliError(Form("could not create run loader in file %s", 
+                   fGAliceFileName.Data()));
+      CleanUp();
+      return kFALSE;
+    }
+    fRunLoader->MakeTree("E");
+    Int_t iEvent = 0;
+    while (fRawReader->NextEvent()) {
+      fRunLoader->SetEventNumber(iEvent);
+      fRunLoader->GetHeader()->Reset(fRawReader->GetRunNumber(), 
+                                    iEvent, iEvent);
+      fRunLoader->MakeTree("H");
+      fRunLoader->TreeE()->Fill();
+      iEvent++;
+    }
+    fRawReader->RewindEvents();
+    fRunLoader->WriteHeader("OVERWRITE");
+    fRunLoader->CdGAFile();
+    fRunLoader->Write(0, TObject::kOverwrite);
+//    AliTracker::SetFieldMap(???);
+  }
+
+  return kTRUE;
+}
+
+//_____________________________________________________________________________
+AliReconstructor* AliReconstruction::GetReconstructor(Int_t iDet)
 {
-// get the reconstructor object for a detector
+// get the reconstructor object and the loader for a detector
 
-  for (Int_t iDet = 0; iDet < fReconstructors.GetEntriesFast(); iDet++) {
-    AliReconstructor* reconstructor = 
-      (AliReconstructor*) fReconstructors[iDet];
-    if (strcmp(reconstructor->GetDetectorName(), detName) == 0) {
-      return reconstructor;
+  if (fReconstructor[iDet]) return fReconstructor[iDet];
+
+  // load the reconstructor object
+  TPluginManager* pluginManager = gROOT->GetPluginManager();
+  TString detName = fgkDetectorName[iDet];
+  TString recName = "Ali" + detName + "Reconstructor";
+  if (gAlice && !gAlice->GetDetector(detName) && (detName != "HLT")) return NULL;
+
+  if (detName == "HLT") {
+    if (!gROOT->GetClass("AliLevel3")) {
+      gSystem->Load("libAliL3Src.so");
+      gSystem->Load("libAliL3Misc.so");
+      gSystem->Load("libAliL3Hough.so");
+      gSystem->Load("libAliL3Comp.so");
     }
   }
-  return NULL;
+
+  AliReconstructor* reconstructor = NULL;
+  // first check if a plugin is defined for the reconstructor
+  TPluginHandler* pluginHandler = 
+    pluginManager->FindHandler("AliReconstructor", detName);
+  // if not, add a plugin for it
+  if (!pluginHandler) {
+    AliDebug(1, Form("defining plugin for %s", recName.Data()));
+    TString libs = gSystem->GetLibraries();
+    if (libs.Contains("lib" + detName + "base.so") ||
+       (gSystem->Load("lib" + detName + "base.so") >= 0)) {
+      pluginManager->AddHandler("AliReconstructor", detName, 
+                               recName, detName + "rec", recName + "()");
+    } else {
+      pluginManager->AddHandler("AliReconstructor", detName, 
+                               recName, detName, recName + "()");
+    }
+    pluginHandler = pluginManager->FindHandler("AliReconstructor", detName);
+  }
+  if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
+    reconstructor = (AliReconstructor*) pluginHandler->ExecPlugin(0);
+  }
+  if (reconstructor) {
+    TObject* obj = fOptions.FindObject(detName.Data());
+    if (obj) reconstructor->SetOption(obj->GetTitle());
+    reconstructor->Init(fRunLoader);
+    fReconstructor[iDet] = reconstructor;
+  }
+
+  // get or create the loader
+  if (detName != "HLT") {
+    fLoader[iDet] = fRunLoader->GetLoader(detName + "Loader");
+    if (!fLoader[iDet]) {
+      AliConfig::Instance()
+       ->CreateDetectorFolders(fRunLoader->GetEventFolder(), 
+                               detName, detName);
+      // first check if a plugin is defined for the loader
+      TPluginHandler* pluginHandler = 
+       pluginManager->FindHandler("AliLoader", detName);
+      // if not, add a plugin for it
+      if (!pluginHandler) {
+       TString loaderName = "Ali" + detName + "Loader";
+       AliDebug(1, Form("defining plugin for %s", loaderName.Data()));
+       pluginManager->AddHandler("AliLoader", detName, 
+                                 loaderName, detName + "base", 
+                                 loaderName + "(const char*, TFolder*)");
+       pluginHandler = pluginManager->FindHandler("AliLoader", detName);
+      }
+      if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
+       fLoader[iDet] = 
+         (AliLoader*) pluginHandler->ExecPlugin(2, detName.Data(), 
+                                                fRunLoader->GetEventFolder());
+      }
+      if (!fLoader[iDet]) {   // use default loader
+       fLoader[iDet] = new AliLoader(detName, fRunLoader->GetEventFolder());
+      }
+      if (!fLoader[iDet]) {
+       AliWarning(Form("couldn't get loader for %s", detName.Data()));
+       if (fStopOnError) return NULL;
+      } else {
+       fRunLoader->AddLoader(fLoader[iDet]);
+       fRunLoader->CdGAFile();
+       if (gFile && !gFile->IsWritable()) gFile->ReOpen("UPDATE");
+       fRunLoader->Write(0, TObject::kOverwrite);
+      }
+    }
+  }
+      
+  return reconstructor;
 }
 
 //_____________________________________________________________________________
@@ -680,13 +938,13 @@ Bool_t AliReconstruction::CreateVertexer()
 {
 // create the vertexer
 
-  fITSVertexer = NULL;
-  AliReconstructor* itsReconstructor = GetReconstructor("ITS");
+  fVertexer = NULL;
+  AliReconstructor* itsReconstructor = GetReconstructor(0);
   if (itsReconstructor) {
-    fITSVertexer = itsReconstructor->CreateVertexer(fRunLoader);
+    fVertexer = itsReconstructor->CreateVertexer(fRunLoader);
   }
-  if (!fITSVertexer) {
-    Warning("CreateVertexer", "couldn't create a vertexer for ITS");
+  if (!fVertexer) {
+    AliWarning("couldn't create a vertexer for ITS");
     if (fStopOnError) return kFALSE;
   }
 
@@ -694,70 +952,21 @@ Bool_t AliReconstruction::CreateVertexer()
 }
 
 //_____________________________________________________________________________
-Bool_t AliReconstruction::CreateTrackers()
+Bool_t AliReconstruction::CreateTrackers(const TString& detectors)
 {
-// get the loaders and create the trackers
+// create the trackers
 
-  fITSTracker = NULL;
-  fITSLoader = fRunLoader->GetLoader("ITSLoader");
-  if (!fITSLoader) {
-    Warning("CreateTrackers", "no ITS loader found");
-    if (fStopOnError) return kFALSE;
-  } else {
-    AliReconstructor* itsReconstructor = GetReconstructor("ITS");
-    if (itsReconstructor) {
-      fITSTracker = itsReconstructor->CreateTracker(fRunLoader);
-    }
-    if (!fITSTracker) {
-      Warning("CreateTrackers", "couldn't create a tracker for ITS");
-      if (fStopOnError) return kFALSE;
-    }
-  }
-    
-  fTPCTracker = NULL;
-  fTPCLoader = fRunLoader->GetLoader("TPCLoader");
-  if (!fTPCLoader) {
-    Error("CreateTrackers", "no TPC loader found");
-    if (fStopOnError) return kFALSE;
-  } else {
-    AliReconstructor* tpcReconstructor = GetReconstructor("TPC");
-    if (tpcReconstructor) {
-      fTPCTracker = tpcReconstructor->CreateTracker(fRunLoader);
-    }
-    if (!fTPCTracker) {
-      Error("CreateTrackers", "couldn't create a tracker for TPC");
-      if (fStopOnError) return kFALSE;
-    }
-  }
-    
-  fTRDTracker = NULL;
-  fTRDLoader = fRunLoader->GetLoader("TRDLoader");
-  if (!fTRDLoader) {
-    Warning("CreateTrackers", "no TRD loader found");
-    if (fStopOnError) return kFALSE;
-  } else {
-    AliReconstructor* trdReconstructor = GetReconstructor("TRD");
-    if (trdReconstructor) {
-      fTRDTracker = trdReconstructor->CreateTracker(fRunLoader);
-    }
-    if (!fTRDTracker) {
-      Warning("CreateTrackers", "couldn't create a tracker for TRD");
-      if (fStopOnError) return kFALSE;
-    }
-  }
-    
-  fTOFTracker = NULL;
-  fTOFLoader = fRunLoader->GetLoader("TOFLoader");
-  if (!fTOFLoader) {
-    Warning("CreateTrackers", "no TOF loader found");
-    if (fStopOnError) return kFALSE;
-  } else {
-    AliReconstructor* tofReconstructor = GetReconstructor("TOF");
-    if (tofReconstructor) {
-      fTOFTracker = tofReconstructor->CreateTracker(fRunLoader);
-    }
-    if (!fTOFTracker) {
-      Warning("CreateTrackers", "couldn't create a tracker for TOF");
+  TString detStr = detectors;
+  for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+    if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
+    AliReconstructor* reconstructor = GetReconstructor(iDet);
+    if (!reconstructor) continue;
+    TString detName = fgkDetectorName[iDet];
+    if (detName == "HLT") continue;
+
+    fTracker[iDet] = reconstructor->CreateTracker(fRunLoader);
+    if (!fTracker[iDet] && (iDet < 7)) {
+      AliWarning(Form("couldn't create a tracker for %s", detName.Data()));
       if (fStopOnError) return kFALSE;
     }
   }
@@ -766,30 +975,35 @@ Bool_t AliReconstruction::CreateTrackers()
 }
 
 //_____________________________________________________________________________
-void AliReconstruction::CleanUp(TFile* file)
+void AliReconstruction::CleanUp(TFile* file, TFile* fileOld)
 {
 // delete trackers and the run loader and close and delete the file
 
-  fReconstructors.Delete();
-
-  delete fITSVertexer;
-  fITSVertexer = NULL;
-  delete fITSTracker;
-  fITSTracker = NULL;
-  delete fTPCTracker;
-  fTPCTracker = NULL;
-  delete fTRDTracker;
-  fTRDTracker = NULL;
-  delete fTOFTracker;
-  fTOFTracker = NULL;
+  for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+    delete fReconstructor[iDet];
+    fReconstructor[iDet] = NULL;
+    fLoader[iDet] = NULL;
+    delete fTracker[iDet];
+    fTracker[iDet] = NULL;
+  }
+  delete fVertexer;
+  fVertexer = NULL;
 
   delete fRunLoader;
   fRunLoader = NULL;
+  delete fRawReader;
+  fRawReader = NULL;
 
   if (file) {
     file->Close();
     delete file;
   }
+
+  if (fileOld) {
+    fileOld->Close();
+    delete fileOld;
+    gSystem->Unlink("AliESDs.old.root");
+  }
 }
 
 
@@ -804,10 +1018,10 @@ Bool_t AliReconstruction::ReadESD(AliESD*& esd, const char* recStep) const
          esd->GetRunNumber(), esd->GetEventNumber(), recStep);
   if (gSystem->AccessPathName(fileName)) return kFALSE;
 
-  Info("ReadESD", "reading ESD from file %s", fileName);
+  AliDebug(1, Form("reading ESD from file %s", fileName));
   TFile* file = TFile::Open(fileName);
   if (!file || !file->IsOpen()) {
-    Error("ReadESD", "opening %s failed", fileName);
+    AliError(Form("opening %s failed", fileName));
     delete file;
     return kFALSE;
   }
@@ -830,10 +1044,10 @@ void AliReconstruction::WriteESD(AliESD* esd, const char* recStep) const
   sprintf(fileName, "ESD_%d.%d_%s.root", 
          esd->GetRunNumber(), esd->GetEventNumber(), recStep);
 
-  Info("WriteESD", "writing ESD to file %s", fileName);
+  AliDebug(1, Form("writing ESD to file %s", fileName));
   TFile* file = TFile::Open(fileName, "recreate");
   if (!file || !file->IsOpen()) {
-    Error("WriteESD", "opening %s failed", fileName);
+    AliError(Form("opening %s failed", fileName));
   } else {
     esd->Write("ESD");
     file->Close();