Fix from Salvatore for new framework
[u/mrichter/AliRoot.git] / ANALYSIS / AliAnalysisManager.cxx
index 7e372cc..b47f3a0 100644 (file)
 #include <cerrno>
 #include <Riostream.h>
 #include <TError.h>
+#include <TMap.h>
 #include <TClass.h>
 #include <TFile.h>
+#include <TTreeCache.h>
+#include <TEnv.h>
 #include <TMath.h>
 #include <TH1.h>
 #include <TMethodCall.h>
@@ -41,6 +44,7 @@
 #include <TCanvas.h>
 #include <TStopwatch.h>
 
+#include "AliLog.h"
 #include "AliAnalysisSelector.h"
 #include "AliAnalysisGrid.h"
 #include "AliAnalysisTask.h"
 #include "AliSysInfo.h"
 #include "AliAnalysisStatistics.h"
 
+using std::ofstream;
+using std::ios;
+using std::cout;
+using std::endl;
 ClassImp(AliAnalysisManager)
 
 AliAnalysisManager *AliAnalysisManager::fgAnalysisManager = NULL;
 TString AliAnalysisManager::fgCommonFileName = "";
+TString AliAnalysisManager::fgMacroNames = "";
 Int_t AliAnalysisManager::fPBUpdateFreq = 1;
 
 //______________________________________________________________________________
 AliAnalysisManager::AliAnalysisManager(const char *name, const char *title)
                    :TNamed(name,title),
-                    fTree(NULL),
-                    fInputEventHandler(NULL),
-                    fOutputEventHandler(NULL),
-                    fMCtruthEventHandler(NULL),
-                    fEventPool(NULL),
+                    fTree(0),
+                    fInputEventHandler(0),
+                    fOutputEventHandler(0),
+                    fMCtruthEventHandler(0),
+                    fEventPool(0),
                     fCurrentEntry(-1),
                     fNSysInfo(0),
                     fMode(kLocalAnalysis),
                     fInitOK(kFALSE),
+                    fMustClean(kFALSE),
                     fIsRemote(kFALSE),
+                    fLocked(kFALSE),
                     fDebug(0),
                     fSpecialOutputLocation(""), 
-                    fTasks(NULL),
-                    fTopTasks(NULL),
-                    fZombies(NULL),
-                    fContainers(NULL),
-                    fInputs(NULL),
-                    fOutputs(NULL),
-                    fParamCont(NULL),
-                    fCommonInput(NULL),
-                    fCommonOutput(NULL),
-                    fSelector(NULL),
-                    fGridHandler(NULL),
-                    fExtraFiles(""),
+                    fTasks(0),
+                    fTopTasks(0),
+                    fZombies(0),
+                    fContainers(0),
+                    fInputs(0),
+                    fOutputs(0),
+                    fParamCont(0),
+                    fDebugOptions(0),
+                    fFileDescriptors(new TObjArray()),
+                    fCurrentDescriptor(0),
+                    fCommonInput(0),
+                    fCommonOutput(0),
+                    fSelector(0),
+                    fGridHandler(0),
+                    fExtraFiles(),
+                    fFileInfoLog(),
                     fAutoBranchHandling(kTRUE), 
+                    fAsyncReading(kTRUE), // default prefetching on
                     fTable(),
                     fRunFromPath(0),
                     fNcalls(0),
                     fMaxEntries(0),
+                    fCacheSize(100000000), // default 100 MB
                     fStatisticsMsg(),
                     fRequestedBranches(),
-                    fStatistics(0)
+                    fStatistics(0),
+                    fGlobals(0),
+                    fIOTimer(0),
+                    fCPUTimer(0),
+                    fInitTimer(0),
+                    fIOTime(0),
+                    fCPUTime(0),
+                    fInitTime(0)
 {
 // Default constructor.
    fgAnalysisManager = this;
    fgCommonFileName  = "AnalysisResults.root";
-   fTasks      = new TObjArray();
-   fTopTasks   = new TObjArray();
-   fZombies    = new TObjArray();
-   fContainers = new TObjArray();
-   fInputs     = new TObjArray();
-   fOutputs    = new TObjArray();
-   fParamCont  = new TObjArray();
+   if (TClass::IsCallingNew() != TClass::kDummyNew) {
+     fTasks      = new TObjArray();
+     fTopTasks   = new TObjArray();
+     fZombies    = new TObjArray();
+     fContainers = new TObjArray();
+     fInputs     = new TObjArray();
+     fOutputs    = new TObjArray();
+     fParamCont  = new TObjArray();
+     fGlobals    = new TMap();
+   }
+   fIOTimer = new TStopwatch();
+   fCPUTimer = new TStopwatch();
+   fInitTimer = new TStopwatch();
    SetEventLoop(kTRUE);
-   TObject::SetObjectStat(kFALSE);
 }
 
 //______________________________________________________________________________
@@ -119,7 +148,9 @@ AliAnalysisManager::AliAnalysisManager(const AliAnalysisManager& other)
                     fNSysInfo(0),
                     fMode(other.fMode),
                     fInitOK(other.fInitOK),
+                    fMustClean(other.fMustClean),
                     fIsRemote(other.fIsRemote),
+                    fLocked(other.fLocked),
                     fDebug(other.fDebug),
                     fSpecialOutputLocation(""), 
                     fTasks(NULL),
@@ -129,19 +160,32 @@ AliAnalysisManager::AliAnalysisManager(const AliAnalysisManager& other)
                     fInputs(NULL),
                     fOutputs(NULL),
                     fParamCont(NULL),
+                    fDebugOptions(NULL),
+                    fFileDescriptors(new TObjArray()),
+                    fCurrentDescriptor(0),
                     fCommonInput(NULL),
                     fCommonOutput(NULL),
                     fSelector(NULL),
                     fGridHandler(NULL),
-                    fExtraFiles(),
+                    fExtraFiles(other.fExtraFiles),
+                    fFileInfoLog(other.fFileInfoLog),
                     fAutoBranchHandling(other.fAutoBranchHandling), 
+                    fAsyncReading(other.fAsyncReading),
                     fTable(),
                     fRunFromPath(0),
                     fNcalls(other.fNcalls),
                     fMaxEntries(other.fMaxEntries),
+                    fCacheSize(other.fCacheSize),
                     fStatisticsMsg(other.fStatisticsMsg),
                     fRequestedBranches(other.fRequestedBranches),
-                    fStatistics(other.fStatistics)
+                    fStatistics(other.fStatistics),
+                    fGlobals(other.fGlobals),
+                    fIOTimer(new TStopwatch()),
+                    fCPUTimer(new TStopwatch()),
+                    fInitTimer(new TStopwatch()),
+                    fIOTime(0),
+                    fCPUTime(0),
+                    fInitTime(0)
 {
 // Copy constructor.
    fTasks      = new TObjArray(*other.fTasks);
@@ -153,7 +197,6 @@ AliAnalysisManager::AliAnalysisManager(const AliAnalysisManager& other)
    fParamCont  = new TObjArray(*other.fParamCont);
    fgCommonFileName  = "AnalysisResults.root";
    fgAnalysisManager = this;
-   TObject::SetObjectStat(kFALSE);
 }
    
 //______________________________________________________________________________
@@ -172,6 +215,7 @@ AliAnalysisManager& AliAnalysisManager::operator=(const AliAnalysisManager& othe
       fMode       = other.fMode;
       fInitOK     = other.fInitOK;
       fIsRemote   = other.fIsRemote;
+      fLocked     = other.fLocked;
       fDebug      = other.fDebug;
       fTasks      = new TObjArray(*other.fTasks);
       fTopTasks   = new TObjArray(*other.fTopTasks);
@@ -180,21 +224,34 @@ AliAnalysisManager& AliAnalysisManager::operator=(const AliAnalysisManager& othe
       fInputs     = new TObjArray(*other.fInputs);
       fOutputs    = new TObjArray(*other.fOutputs);
       fParamCont  = new TObjArray(*other.fParamCont);
+      fDebugOptions = NULL;
+      fFileDescriptors = new TObjArray();
+      fCurrentDescriptor = 0;
       fCommonInput = NULL;
       fCommonOutput = NULL;
       fSelector   = NULL;
       fGridHandler = NULL;
       fExtraFiles = other.fExtraFiles;
+      fFileInfoLog = other.fFileInfoLog;
       fgCommonFileName = "AnalysisResults.root";
       fgAnalysisManager = this;
       fAutoBranchHandling = other.fAutoBranchHandling;
+      fAsyncReading = other.fAsyncReading;
       fTable.Clear("nodelete");
       fRunFromPath = other.fRunFromPath;
       fNcalls     = other. fNcalls;
       fMaxEntries = other.fMaxEntries;
+      fCacheSize = other.fCacheSize;
       fStatisticsMsg = other.fStatisticsMsg;
       fRequestedBranches = other.fRequestedBranches;
       fStatistics = other.fStatistics;
+      fGlobals = new TMap();
+      fIOTimer = new TStopwatch();
+      fCPUTimer = new TStopwatch();
+      fInitTimer = new TStopwatch();
+      fIOTime = 0.;
+      fCPUTime = 0.;
+      fInitTime = 0.;
    }
    return *this;
 }
@@ -210,23 +267,57 @@ AliAnalysisManager::~AliAnalysisManager()
    if (fInputs) delete fInputs;
    if (fOutputs) delete fOutputs;
    if (fParamCont) delete fParamCont;
+   if (fDebugOptions) delete fDebugOptions;
    if (fGridHandler) delete fGridHandler;
    if (fInputEventHandler) delete fInputEventHandler;
    if (fOutputEventHandler) delete fOutputEventHandler;
    if (fMCtruthEventHandler) delete fMCtruthEventHandler;
    if (fEventPool) delete fEventPool;
    if (fgAnalysisManager==this) fgAnalysisManager = NULL;
-   TObject::SetObjectStat(kTRUE);
+   if (fGlobals) {fGlobals->DeleteAll(); delete fGlobals;}
+   if (fFileDescriptors) {fFileDescriptors->Delete(); delete fFileDescriptors;}
+   delete fIOTimer;
+   delete fCPUTimer;
+   delete fInitTimer;
 }
 
 //______________________________________________________________________________
+void AliAnalysisManager::CreateReadCache()
+{
+// Create cache for reading according fCacheSize and fAsyncReading.
+   if (!fTree || !fTree->GetCurrentFile()) {
+      Error("CreateReadCache","Current tree or tree file not yet defined");
+      return;
+   }   
+   if (!fCacheSize) {
+      if (fDebug) Info("CreateReadCache","=== Read caching disabled ===");
+      return;
+   }
+//   gEnv->SetValue("TFile.AsyncPrefetching",(Int_t)fAsyncReading);
+//   if (fAsyncReading) gEnv->SetValue("Cache.Directory",Form("file://%s/cache", gSystem->WorkingDirectory()));
+//   if (fAsyncReading) gEnv->SetValue("TFile.AsyncReading",1);
+   fTree->SetCacheSize(fCacheSize);
+   TTreeCache::SetLearnEntries(1);  //<<< we can take the decision after 1 entry
+   fTree->AddBranchToCache("*",kTRUE);    //<<< add all branches to the cache
+   if (fDebug) {
+      Info("CreateReadCache","Read cache enabled %lld bytes with async reading=%d",fCacheSize, (Int_t)fAsyncReading);
+   }
+   return;
+}   
+      
+//______________________________________________________________________________
 Int_t AliAnalysisManager::GetEntry(Long64_t entry, Int_t getall)
 {
 // Read one entry of the tree or a whole branch.
    fCurrentEntry = entry;
    if (!fAutoBranchHandling)
      return 123456789;
-   return fTree ? fTree->GetTree()->GetEntry(entry, getall) : -1;
+   if (!fTree || !fTree->GetTree()) return -1;
+   fIOTimer->Start(kTRUE); 
+   Long64_t readbytes = fTree->GetTree()->GetEntry(entry, getall);
+   fIOTimer->Stop();
+   fIOTime += fIOTimer->RealTime();
+   return (Int_t)readbytes;
 }
 
 //______________________________________________________________________________
@@ -236,27 +327,29 @@ Int_t AliAnalysisManager::GetRunFromAlienPath(const char *path)
 // alice data in alien.
 //    sim:  /alice/sim/<production>/run_no/...
 //    data: /alice/data/year/period/000run_no/... (ESD or AOD)
+   TString type = "unknown";
    TString s(path);
+   if (s.Contains("/alice/data")) type = "real";
+   else if (s.Contains("/alice/sim")) type = "simulated";
    TString srun;
-   Int_t run = 0;
-   Int_t index = s.Index("/alice/sim");
-   if (index >= 0) {
-      for (Int_t i=0; i<3; i++) {
-         index = s.Index("/", index+1);
-         if (index<0) return 0;
-      }
-      srun = s(index+1,6);
-      run = atoi(srun);
-   }
-   index = s.Index("/alice/data");
-   if (index >= 0) {
-      for (Int_t i=0; i<4; i++) {
-         index = s.Index("/", index+1);
-         if (index<0) return 0;
+   Int_t ind1, ind2;
+   ind1 = s.Index("/00");
+   if (ind1>0) {
+      ind2 = s.Index("/",ind1+1);
+      if (ind2-ind1>8) srun = s(ind1+1, ind2-ind1-1);
+   }   
+   if (srun.IsNull()) {
+      ind1 = s.Index("/LHC");
+      if (ind1>0) {
+         ind1 = s.Index("/",ind1+1);
+         if (ind1>0) {
+            ind2 = s.Index("/",ind1+1);
+            if (ind2>0) srun = s(ind1+1, ind2-ind1-1);
+         }
       }
-      srun = s(index+1,9);
-      run = atoi(srun);
-   }
+   }         
+   Int_t run = srun.Atoi();
+   if (run>0) printf("=== GetRunFromAlienPath: run %d of %s data ===\n", run, type.Data());
    return run;
 }   
 
@@ -323,6 +416,7 @@ Bool_t AliAnalysisManager::Init(TTree *tree)
    if (!fInitOK) InitAnalysis();
    if (!fInitOK) return kFALSE;
    fTree = tree;
+   if (fMode != kProofAnalysis) CreateReadCache();
    fTable.Rehash(100);
    AliAnalysisDataContainer *top = fCommonInput;
    if (!top) top = (AliAnalysisDataContainer*)fInputs->At(0);
@@ -345,6 +439,12 @@ void AliAnalysisManager::SlaveBegin(TTree *tree)
   // When running with PROOF SlaveBegin() is called on each slave server.
   // The tree argument is deprecated (on PROOF 0 is passed).
    if (fDebug > 1) printf("->AliAnalysisManager::SlaveBegin()\n");
+   // Init timer should be already started
+   // Apply debug options
+   ApplyDebugOptions();
+   if (fCacheSize && 
+       fMCtruthEventHandler &&
+       (fMode != kProofAnalysis)) fMCtruthEventHandler->SetCacheSize(fCacheSize);
    if (!CheckTasks()) Fatal("SlaveBegin", "Not all needed libraries were loaded");
    static Bool_t isCalled = kFALSE;
    Bool_t init = kFALSE;
@@ -420,6 +520,10 @@ void AliAnalysisManager::SlaveBegin(TTree *tree)
    }
    TH1::AddDirectory(dirStatus);
    if (curdir) curdir->cd();
+   fInitTimer->Stop();
+   fInitTime += fInitTimer->RealTime();
+   fInitTimer->Continue();
+   printf("Initialization time: %g [sec]\n", fInitTime);
    if (fDebug > 1) printf("<-AliAnalysisManager::SlaveBegin()\n");
 }
 
@@ -431,7 +535,9 @@ Bool_t AliAnalysisManager::Notify()
    // is started when using PROOF. It is normaly not necessary to make changes
    // to the generated code, but the routine can be extended by the
    // user if needed. The return value is currently not used.
+   fIOTimer->Start(kTRUE); 
    if (!fTree) return kFALSE;
+   if (!TObject::TestBit(AliAnalysisManager::kTrueNotify)) return kFALSE;
 
    fTable.Clear("nodelete"); // clearing the hash table may not be needed -> C.L.
    if (fMode == kProofAnalysis) fIsRemote = kTRUE;
@@ -440,12 +546,19 @@ Bool_t AliAnalysisManager::Notify()
    if (!curfile) {
       Error("Notify","No current file");
       return kFALSE;
+   }  
+   if (IsCollectThroughput()) {
+      if (fCurrentDescriptor) fCurrentDescriptor->Done();
+      fCurrentDescriptor = new AliAnalysisFileDescriptor(curfile);
+      fFileDescriptors->Add(fCurrentDescriptor);
    }   
    
    if (fDebug > 1) printf("->AliAnalysisManager::Notify() file: %s\n", curfile->GetName());
    Int_t run = AliAnalysisManager::GetRunFromAlienPath(curfile->GetName());
-   if (run) SetRunFromPath(run);
-   if (fDebug > 1) printf("   ### run found from path: %d\n", run); 
+   if (run && (run != fRunFromPath)) {
+      fRunFromPath = run;
+      if (fDebug > 1) printf("   ### run found from path: %d\n", run);
+   }
    TIter next(fTasks);
    AliAnalysisTask *task;
        
@@ -467,11 +580,13 @@ Bool_t AliAnalysisManager::Notify()
       task->Notify();
 
    if (fDebug > 1) printf("<-AliAnalysisManager::Notify()\n");
+   fIOTimer->Stop();
+   fIOTime += fIOTimer->RealTime();
    return kTRUE;
 }    
 
 //______________________________________________________________________________
-Bool_t AliAnalysisManager::Process(Long64_t entry)
+Bool_t AliAnalysisManager::Process(Long64_t)
 {
   // The Process() function is called for each entry in the tree (or possibly
   // keyed object in the case of PROOF) to be processed. The entry argument
@@ -490,18 +605,8 @@ Bool_t AliAnalysisManager::Process(Long64_t entry)
   //  The entry is always the local entry number in the current tree.
   //  Assuming that fChain is the pointer to the TChain being processed,
   //  use fChain->GetTree()->GetEntry(entry).
-   if (fDebug > 1) printf("->AliAnalysisManager::Process(%lld)\n", entry);
-
-   if (fInputEventHandler)   fInputEventHandler  ->BeginEvent(entry);
-   if (fOutputEventHandler)  fOutputEventHandler ->BeginEvent(entry);
-   if (fMCtruthEventHandler) fMCtruthEventHandler->BeginEvent(entry);
-   
-   GetEntry(entry);
 
-   if (fInputEventHandler)   fInputEventHandler  ->GetEntry();
-
-   ExecAnalysis();
-   if (fDebug > 1) printf("<-AliAnalysisManager::Process()\n");
+   // This method is obsolete. ExecAnalysis is called instead.
    return kTRUE;
 }
 
@@ -511,6 +616,20 @@ void AliAnalysisManager::PackOutput(TList *target)
   // Pack all output data containers in the output list. Called at SlaveTerminate
   // stage in PROOF case for each slave.
    if (fDebug > 1) printf("->AliAnalysisManager::PackOutput()\n");
+   fIOTimer->Start(kTRUE);
+   std::ofstream out;
+   if (IsCollectThroughput()) {
+      if (fCurrentDescriptor) fCurrentDescriptor->Done();
+      fFileDescriptors->Print();
+      if (fFileInfoLog.IsNull()) fFileInfoLog = "fileinfo.log";
+      out.open(fFileInfoLog, std::ios::app);
+      if (out.bad()) Error("SavePrimitive", "Bad file name: %s", fFileInfoLog.Data());
+      else {
+         TIter nextflog(fFileDescriptors);
+         TObject *log;
+         while ((log=nextflog())) log->SavePrimitive(out,"");
+      }
+   }   
    if (!target) {
       Error("PackOutput", "No target. Exiting.");
       return;
@@ -717,7 +836,37 @@ void AliAnalysisManager::PackOutput(TList *target)
          }      
       }
    } 
-   cdir->cd();
+   fIOTime += fIOTimer->RealTime();
+   if ((fDebug || IsCollectThroughput())) {
+      fInitTimer->Stop();
+      fInitTime = fInitTimer->RealTime()-fIOTime-fCPUTime;
+      printf("=Analysis %s= init time:       %g[sec]\
+            \n              I/O & data mng.: %g [sec]\
+            \n              task execution: %g [sec]\
+            \n              total time:     CPU=%g [sec]  REAL=%g[sec]\n",
+            GetName(), fInitTime, fIOTime, fCPUTime, fInitTimer->CpuTime(), fInitTimer->RealTime());
+      if (IsCollectThroughput()) {
+         out << "#summary#########################################################" << endl;
+         out << "train_name   " << GetName() << endl;
+         out << "root_time    " << fInitTimer->RealTime() << endl;
+         out << "root_cpu     " << fInitTimer->CpuTime() << endl;
+         out << "init_time    " << fInitTime << endl;
+         out << "io_mng_time  " << fIOTime << endl;
+         out << "exec_time    " << fCPUTime << endl;
+         TString aliensite = gSystem->Getenv("ALIEN_SITE");
+         out << "alien_site   " << aliensite << endl;
+         out << "host_name    ";
+         TString hostname = gSystem->Getenv("ALIEN_HOSTNAME");
+         if (hostname.IsNull()) {
+            out.close();
+            gSystem->Exec(Form("hostname -f >> %s", fFileInfoLog.Data()));
+         } else {
+            out << hostname << endl;
+         }   
+      }
+   }
+              
+   if (cdir) cdir->cd();
    if (fDebug > 1) printf("<-AliAnalysisManager::PackOutput: output list contains %d containers\n", target->GetSize());
 }
 
@@ -726,6 +875,7 @@ void AliAnalysisManager::ImportWrappers(TList *source)
 {
 // Import data in output containers from wrappers coming in source.
    if (fDebug > 1) printf("->AliAnalysisManager::ImportWrappers()\n");
+   fIOTimer->Start(kTRUE);
    TIter next(fOutputs);
    AliAnalysisDataContainer *cont;
    AliAnalysisDataWrapper   *wrap;
@@ -766,6 +916,7 @@ void AliAnalysisManager::ImportWrappers(TList *source)
             Error("ImportWrappers", "Cannot open file %s in read-only mode", filename);
             continue;
          }   
+         f->cd();
          TObject *obj = 0;
          // Cd to the directory pointed by the container
          TString folder = cont->GetFolderName();
@@ -794,6 +945,8 @@ void AliAnalysisManager::ImportWrappers(TList *source)
       cont->ImportData(wrap);
    }
    if (cdir) cdir->cd();
+   fIOTimer->Stop();
+   fIOTime += fIOTimer->RealTime();
    if (fDebug > 1) printf("<-AliAnalysisManager::ImportWrappers(): %d containers imported\n", icont);
 }
 
@@ -801,6 +954,7 @@ void AliAnalysisManager::ImportWrappers(TList *source)
 void AliAnalysisManager::UnpackOutput(TList *source)
 {
   // Called by AliAnalysisSelector::Terminate only on the client.
+   fIOTimer->Start(kTRUE);
    if (fDebug > 1) printf("->AliAnalysisManager::UnpackOutput()\n");
    if (!source) {
       Error("UnpackOutput", "No target. Exiting.");
@@ -826,11 +980,15 @@ void AliAnalysisManager::UnpackOutput(TList *source)
             // If task is active, execute it
             if (task->IsPostEventLoop() && task->IsActive()) {
                if (fDebug > 1) printf("== Executing post event loop task %s\n", task->GetName());
+               if (fStatistics) fStatistics->StartTimer(GetTaskIndex(task), task->GetName(), task->ClassName());
                task->ExecuteTask();
             }   
          }
+         if (fStatistics) fStatistics->StopTimer();
       }   
    }
+   fIOTimer->Stop();
+   fIOTime += fIOTimer->RealTime();
    if (fDebug > 1) printf("<-AliAnalysisManager::UnpackOutput()\n");
 }
 
@@ -841,6 +999,7 @@ void AliAnalysisManager::Terminate()
   // a query. It always runs on the client, it can be used to present
   // the results graphically.
    if (fDebug > 1) printf("->AliAnalysisManager::Terminate()\n");
+   fInitTimer->Start(kTRUE);
    TDirectory *cdir = gDirectory;
    gROOT->cd();
    AliAnalysisTask *task;
@@ -861,8 +1020,8 @@ void AliAnalysisManager::Terminate()
       if (TObject::TestBit(kSaveCanvases)) {
          if (!gROOT->IsBatch()) {
             if (fDebug>1) printf("Waiting 5 sec for %s::Terminate() to finish drawing ...\n", task->ClassName());
-            timer.Start();
-            while (timer.CpuTime()<5) {
+            timer.Start(kTRUE);
+            while (timer.RealTime()<5) {
                timer.Continue();
                gSystem->ProcessEvents();
             }
@@ -963,6 +1122,7 @@ void AliAnalysisManager::Terminate()
    }
    gROOT->cd();
    next1.Reset();
+   TString copiedFiles;
    while ((output=(AliAnalysisDataContainer*)next1())) {
       // Close all files at output
       TDirectory *opwd = gDirectory;
@@ -970,14 +1130,20 @@ void AliAnalysisManager::Terminate()
          // Clear file list to release object ownership to user.
 //         output->GetFile()->Clear();
          output->GetFile()->Close();
-         output->SetFile(NULL);
          // Copy merged outputs in alien if requested
-         if (fSpecialOutputLocation.Length() && 
-             fSpecialOutputLocation.BeginsWith("alien://")) {
+         if (fSpecialOutputLocation.BeginsWith("alien://")) {
+            if (copiedFiles.Contains(output->GetFile()->GetName())) {
+               if (opwd) opwd->cd();
+               output->SetFile(NULL);
+               continue;
+            } 
             Info("Terminate", "Copy file %s to %s", output->GetFile()->GetName(),fSpecialOutputLocation.Data()); 
+            gROOT->ProcessLine("if (!gGrid) TGrid::Connect(\"alien:\");");
             TFile::Cp(output->GetFile()->GetName(), 
                       Form("%s/%s", fSpecialOutputLocation.Data(), output->GetFile()->GetName()));
+            copiedFiles += output->GetFile()->GetName();
          }             
+         output->SetFile(NULL);
       }   
       if (opwd) opwd->cd();
    }   
@@ -1024,7 +1190,7 @@ void AliAnalysisManager::Terminate()
                tree->Draw("deltaVM:event",cut,"", 1234567890, 0);
                hist = (TH1*)gPad->GetListOfPrimitives()->FindObject("htemp");            
                if (hist) {
-                  hist->SetTitle(Form("%s: Exec dVM[kB]/event", task->GetName()));
+                  hist->SetTitle(Form("%s: Exec dVM[MB]/event", task->GetName()));
                   hist->GetYaxis()->SetTitle("deltaVM [MB]");
                }   
             }
@@ -1081,7 +1247,11 @@ void AliAnalysisManager::Terminate()
       out.open("outputs_valid", ios::out);
       out.close();
    }
-   cdir->cd();      
+   if (cdir) cdir->cd();  
+   fInitTimer->Stop();
+   if (fDebug || IsCollectThroughput()) {
+      printf("=Analysis %s= Terminate time:  %g[sec]\n", GetName(), fInitTimer->RealTime());
+   }
    if (fDebug > 1) printf("<-AliAnalysisManager::Terminate()\n");
 }
 //______________________________________________________________________________
@@ -1133,8 +1303,8 @@ void AliAnalysisManager::ProfileTask(const char *name, const char */*option*/) c
    tree->Draw("deltaVM:sname",cut,"", 1234567890, 0);
    hist = (TH1*)gPad->GetListOfPrimitives()->FindObject("htemp");
    if (hist) {
-      hist->SetTitle("Alocated VM[kB] for COO and Terminate");
-      hist->GetYaxis()->SetTitle("deltaVM [kB]");
+      hist->SetTitle("Alocated VM[MB] for COO and Terminate");
+      hist->GetYaxis()->SetTitle("deltaVM [MB]");
       hist->GetXaxis()->SetTitle("method");
    }   
    // CPU profile per event
@@ -1152,8 +1322,8 @@ void AliAnalysisManager::ProfileTask(const char *name, const char */*option*/) c
    tree->Draw("deltaVM:event",cut,"", 1234567890, 0);
    hist = (TH1*)gPad->GetListOfPrimitives()->FindObject("htemp");
    if (hist) {
-      hist->SetTitle("Alocated VM[kB] per event");
-      hist->GetYaxis()->SetTitle("deltaVM [kB]");
+      hist->SetTitle("Alocated VM[MB] per event");
+      hist->GetYaxis()->SetTitle("deltaVM [MB]");
    }   
    canvas->Modified();
    delete tree;
@@ -1165,6 +1335,11 @@ void AliAnalysisManager::ProfileTask(const char *name, const char */*option*/) c
 void AliAnalysisManager::AddTask(AliAnalysisTask *task)
 {
 // Adds a user task to the global list of tasks.
+   if (fInitOK) {
+      Error("AddTask", "Cannot add task %s since InitAnalysis was already called", task->GetName());
+      return;
+   }   
+      
    if (fTasks->FindObject(task)) {
       Warning("AddTask", "Task %s: the same object already added to the analysis manager. Not adding.", task->GetName());
       return;
@@ -1182,6 +1357,14 @@ AliAnalysisTask *AliAnalysisManager::GetTask(const char *name) const
 }
 
 //______________________________________________________________________________
+Int_t AliAnalysisManager::GetTaskIndex(const AliAnalysisTask *task) const
+{
+// Returns task inded in the manager's list, -1 if not registered.
+   if (!fTasks) return -1;
+   return fTasks->IndexOf(task);
+}  
+
+//______________________________________________________________________________
 AliAnalysisDataContainer *AliAnalysisManager::CreateContainer(const char *name, 
                                 TClass *datatype, EAliAnalysisContType type, const char *filename)
 {
@@ -1274,7 +1457,7 @@ Bool_t AliAnalysisManager::InitAnalysis()
 // Initialization of analysis chain of tasks. Should be called after all tasks
 // and data containers are properly connected
    // Reset flag and remove valid_outputs file if exists
-   fInitOK = kFALSE;
+   if (fInitOK) return kTRUE;
    if (!gSystem->AccessPathName("outputs_valid"))
       gSystem->Unlink("outputs_valid");
    // Check for top tasks (depending only on input data containers)
@@ -1429,7 +1612,9 @@ void AliAnalysisManager::CheckBranches(Bool_t load)
          }
       }   
       fTable.Add(br);
-      if (load && br->GetReadEntry()!=GetCurrentEntry()) br->GetEntry(GetCurrentEntry());
+      if (load && br->GetReadEntry()!=GetCurrentEntry()) {
+         br->GetEntry(GetCurrentEntry());
+      }      
    }
   delete arr;
 }
@@ -1499,6 +1684,41 @@ void AliAnalysisManager::ResetAnalysis()
 }
 
 //______________________________________________________________________________
+void AliAnalysisManager::RunLocalInit()
+{
+// Run LocalInit method for all tasks.
+   TDirectory *cdir = gDirectory;
+   if (IsTrainInitialized()) return;
+   TIter nextTask(fTasks);
+   AliAnalysisTask *task;
+   while ((task=(AliAnalysisTask*)nextTask())) {
+      gROOT->cd();
+      task->LocalInit();
+   }
+   if (cdir) cdir->cd();
+   TObject::SetBit(kTasksInitialized, kTRUE);
+}   
+
+//______________________________________________________________________________
+void AliAnalysisManager::InputFileFromTree(TTree * const tree, TString &fname)
+{
+// Retrieves name of the file from tree
+   fname = "";
+   if (!tree) return;
+   TFile *file = tree->GetCurrentFile();
+   TString basename;
+   if (!file) {
+      TChain *chain = dynamic_cast<TChain*>(tree);
+      if (!chain || !chain->GetNtrees()) return;
+      basename = gSystem->BaseName(chain->GetListOfFiles()->First()->GetTitle());
+   } else {   
+      basename = gSystem->BaseName(file->GetName());
+   }   
+   Int_t index = basename.Index("#");
+   fname = basename(index+1, basename.Length());
+}   
+
+//______________________________________________________________________________
 Long64_t AliAnalysisManager::StartAnalysis(const char *type, Long64_t nentries, Long64_t firstentry)
 {
 // Start analysis having a grid handler.
@@ -1522,24 +1742,28 @@ Long64_t AliAnalysisManager::StartAnalysis(const char *type, TTree * const tree,
    gROOT->cd();
    if (!fInitOK) {
       Error("StartAnalysis","Analysis manager was not initialized !");
-      cdir->cd();
+      if (cdir) cdir->cd();
       return -1;
    }
    if (!CheckTasks()) Fatal("StartAnalysis", "Not all needed libraries were loaded");
-   if (fDebug > 1) printf("StartAnalysis %s\n",GetName());
+   if (fDebug > 1) {
+      printf("StartAnalysis %s\n",GetName());
+      AliLog::SetGlobalLogLevel(AliLog::kInfo);
+   }
    fMaxEntries = nentries;
    fIsRemote = kFALSE;
    TString anaType = type;
    anaType.ToLower();
    fMode = kLocalAnalysis;
-   Bool_t runlocalinit = kTRUE;
-   if (anaType.Contains("file")) {
-      runlocalinit = kFALSE;
-      fIsRemote = kTRUE;
-   }   
+   if (anaType.Contains("file"))      fIsRemote = kTRUE;
    if (anaType.Contains("proof"))     fMode = kProofAnalysis;
    else if (anaType.Contains("grid")) fMode = kGridAnalysis;
    else if (anaType.Contains("mix"))  fMode = kMixingAnalysis;
+   if (fInputEventHandler) {
+      TString fname;
+      InputFileFromTree(tree, fname);
+      if (fname.Length()) fInputEventHandler->SetInputFileName(fname);
+   }
 
    if (fMode == kGridAnalysis) {
       fIsRemote = kTRUE;
@@ -1547,39 +1771,35 @@ Long64_t AliAnalysisManager::StartAnalysis(const char *type, TTree * const tree,
          if (!fGridHandler) {
             Error("StartAnalysis", "Cannot start grid analysis without a grid handler.");
             Info("===", "Add an AliAnalysisAlien object as plugin for this manager and configure it.");
-            cdir->cd();
+            if (cdir) cdir->cd();
             return -1;
          }
          // Write analysis manager in the analysis file
          cout << "===== RUNNING GRID ANALYSIS: " << GetName() << endl;
          // run local task configuration
-         TIter nextTask(fTasks);
-         AliAnalysisTask *task;
-         while ((task=(AliAnalysisTask*)nextTask())) {
-            task->LocalInit();
-            gROOT->cd();
-         }
+         RunLocalInit();
          if (!fGridHandler->StartAnalysis(nentries, firstentry)) {
             Info("StartAnalysis", "Grid analysis was stopped and cannot be terminated");
-            cdir->cd();
+            if (cdir) cdir->cd();
             return -1;
          }   
 
          // Terminate grid analysis
-         if (fSelector && fSelector->GetStatus() == -1) {cdir->cd(); return -1;}
-         if (fGridHandler->GetRunMode() == AliAnalysisGrid::kOffline) {cdir->cd(); return 0;}
+         if (fSelector && fSelector->GetStatus() == -1) {if (cdir) cdir->cd(); return -1;}
+         if (fGridHandler->GetRunMode() == AliAnalysisGrid::kOffline) {if (cdir) cdir->cd(); return 0;}
          cout << "===== MERGING OUTPUTS REGISTERED BY YOUR ANALYSIS JOB: " << GetName() << endl;
          if (!fGridHandler->MergeOutputs()) {
             // Return if outputs could not be merged or if it alien handler
             // was configured for offline mode or local testing.
-            cdir->cd();
+            if (cdir) cdir->cd();
             return 0;
          }
       }   
       cout << "===== TERMINATING GRID ANALYSIS JOB: " << GetName() << endl;
+      if (cdir) cdir->cd();
       ImportWrappers(NULL);
       Terminate();
-      cdir->cd();
+      if (cdir) cdir->cd();
       return 0;
    }
    TString line;
@@ -1593,7 +1813,7 @@ Long64_t AliAnalysisManager::StartAnalysis(const char *type, TTree * const tree,
       chain = (TChain*)tree;
       if (!chain || !chain->GetListOfFiles()->First()) {
          Error("StartAnalysis", "Cannot process null or empty chain...");
-         cdir->cd();
+         if (cdir) cdir->cd();
          return -1;
       }   
       ttype = "TChain";
@@ -1604,13 +1824,7 @@ Long64_t AliAnalysisManager::StartAnalysis(const char *type, TTree * const tree,
    // Initialize locally all tasks (happens for all modes)
    TIter next(fTasks);
    AliAnalysisTask *task;
-   if (runlocalinit) {
-      while ((task=(AliAnalysisTask*)next())) {
-         task->LocalInit();
-         gROOT->cd();
-      }
-      if (getsysInfo) AliSysInfo::AddStamp("LocalInit_all", 0);
-   }   
+   RunLocalInit();
    
    switch (fMode) {
       case kLocalAnalysis:
@@ -1672,7 +1886,7 @@ Long64_t AliAnalysisManager::StartAnalysis(const char *type, TTree * const tree,
          }
          if (!gROOT->GetListOfProofs() || !gROOT->GetListOfProofs()->GetEntries()) {
             Error("StartAnalysis", "No PROOF!!! Exiting.");
-            cdir->cd();
+            if (cdir) cdir->cd();
             return -1;
          }   
          line = Form("gProof->AddInput((TObject*)%p);", this);
@@ -1683,7 +1897,7 @@ Long64_t AliAnalysisManager::StartAnalysis(const char *type, TTree * const tree,
             retv = chain->Process("AliAnalysisSelector", "", nentries, firstentry);
          } else {
             Error("StartAnalysis", "No chain!!! Exiting.");
-            cdir->cd();
+            if (cdir) cdir->cd();
             return -1;
          }      
          break;
@@ -1693,7 +1907,7 @@ Long64_t AliAnalysisManager::StartAnalysis(const char *type, TTree * const tree,
             if (!fGridHandler) {
                Error("StartAnalysis", "Cannot start grid analysis without a grid handler.");
                Info("===", "Add an AliAnalysisAlien object as plugin for this manager and configure it.");
-               cdir->cd();
+               if (cdir) cdir->cd();
                return -1;
             }
             // Write analysis manager in the analysis file
@@ -1701,31 +1915,31 @@ Long64_t AliAnalysisManager::StartAnalysis(const char *type, TTree * const tree,
             // Start the analysis via the handler
             if (!fGridHandler->StartAnalysis(nentries, firstentry)) {
                Info("StartAnalysis", "Grid analysis was stopped and cannot be terminated");
-               cdir->cd();
+               if (cdir) cdir->cd();
                return -1;
             }   
 
             // Terminate grid analysis
-            if (fSelector && fSelector->GetStatus() == -1) {cdir->cd(); return -1;}
-            if (fGridHandler->GetRunMode() == AliAnalysisGrid::kOffline) {cdir->cd(); return 0;}
+            if (fSelector && fSelector->GetStatus() == -1) {if (cdir) cdir->cd(); return -1;}
+            if (fGridHandler->GetRunMode() == AliAnalysisGrid::kOffline) {if (cdir) cdir->cd(); return 0;}
             cout << "===== MERGING OUTPUTS REGISTERED BY YOUR ANALYSIS JOB: " << GetName() << endl;
             if (!fGridHandler->MergeOutputs()) {
                // Return if outputs could not be merged or if it alien handler
                // was configured for offline mode or local testing.
-               cdir->cd();
+               if (cdir) cdir->cd();
                return 0;
             }
          }   
          cout << "===== TERMINATING GRID ANALYSIS JOB: " << GetName() << endl;
          ImportWrappers(NULL);
          Terminate();
-         cdir->cd();
+         if (cdir) cdir->cd();
          return 0;
       case kMixingAnalysis:   
          // Run event mixing analysis
          if (!fEventPool) {
             Error("StartAnalysis", "Cannot run event mixing without event pool");
-            cdir->cd();
+            if (cdir) cdir->cd();
             return -1;
          }
          cout << "===== RUNNING EVENT MIXING ANALYSIS " << GetName() << endl;
@@ -1738,14 +1952,14 @@ Long64_t AliAnalysisManager::StartAnalysis(const char *type, TTree * const tree,
             retv = chain->Process(fSelector);
             if (retv < 0) {
                Error("StartAnalysis", "Mixing analysis failed");
-               cdir->cd();
+               if (cdir) cdir->cd();
                return retv;
             }   
          }
          PackOutput(fSelector->GetOutputList());
          Terminate();
    }
-   cdir->cd();
+   if (cdir) cdir->cd();
    return retv;
 }   
 
@@ -1768,6 +1982,7 @@ Long64_t AliAnalysisManager::StartAnalysis(const char *type, const char *dataset
    }   
    fMode = kProofAnalysis;
    TString line;
+   TString proofProcessOpt;
    SetEventLoop(kTRUE);
    // Set the dataset flag
    TObject::SetBit(kUseDataSet);
@@ -1784,6 +1999,8 @@ Long64_t AliAnalysisManager::StartAnalysis(const char *type, const char *dataset
       } else {
          dataset = fGridHandler->GetProofDataSet();
       }
+
+      proofProcessOpt = fGridHandler->GetProofProcessOpt();
    }   
 
    if (!gROOT->GetListOfProofs() || !gROOT->GetListOfProofs()->GetEntries()) {
@@ -1792,17 +2009,13 @@ Long64_t AliAnalysisManager::StartAnalysis(const char *type, const char *dataset
    }   
 
    // Initialize locally all tasks
-   TIter next(fTasks);
-   AliAnalysisTask *task;
-   while ((task=(AliAnalysisTask*)next())) {
-      task->LocalInit();
-   }
-   
+   RunLocalInit();
+      
    line = Form("gProof->AddInput((TObject*)%p);", this);
    gROOT->ProcessLine(line);
    Long_t retv;
-   line = Form("gProof->Process(\"%s\", \"AliAnalysisSelector\", \"\", %lld, %lld);",
-               dataset, nentries, firstentry);
+   line = Form("gProof->Process(\"%s\", \"AliAnalysisSelector\", \"%s\", %lld, %lld);",
+               dataset,proofProcessOpt.Data(), nentries, firstentry);
    cout << "===== RUNNING PROOF ANALYSIS " << GetName() << " ON DATASET " << dataset << endl;
    retv = (Long_t)gROOT->ProcessLine(line);
    return retv;
@@ -1968,6 +2181,12 @@ void AliAnalysisManager::ExecAnalysis(Option_t *option)
    static Long64_t nentries = 0;
    static TTree *lastTree = 0;
    static TStopwatch *timer = new TStopwatch();
+   // Only the first call to Process will trigger a true Notify. Other Notify
+   // coming before is ignored.
+   if (!TObject::TestBit(AliAnalysisManager::kTrueNotify)) {
+      TObject::SetBit(AliAnalysisManager::kTrueNotify);
+      Notify();
+   }   
    if (fDebug > 0) printf("MGR: Processing event #%d\n", fNcalls);
    else {
       if (fTree && (fTree != lastTree)) {
@@ -1977,13 +2196,14 @@ void AliAnalysisManager::ExecAnalysis(Option_t *option)
       if (!fNcalls) timer->Start();
       if (!fIsRemote && TObject::TestBit(kUseProgressBar)) ProgressBar("Processing event", fNcalls, TMath::Min(fMaxEntries,nentries), timer, kFALSE);
    }
+   fIOTimer->Start(kTRUE);
    gROOT->cd();
    TDirectory *cdir = gDirectory;
    Bool_t getsysInfo = ((fNSysInfo>0) && (fMode==kLocalAnalysis))?kTRUE:kFALSE;
    if (getsysInfo && ((fNcalls%fNSysInfo)==0)) AliSysInfo::AddStamp("Exec_start", (Int_t)fNcalls);
    if (!fInitOK) {
       Error("ExecAnalysis", "Analysis manager was not initialized !");
-      cdir->cd();
+      if (cdir) cdir->cd();
       return;
    }
    fNcalls++;
@@ -1999,7 +2219,7 @@ void AliAnalysisManager::ExecAnalysis(Option_t *option)
       if (!cont) cont = (AliAnalysisDataContainer*)fInputs->At(0);
       if (!cont) {
              Error("ExecAnalysis","Cannot execute analysis in TSelector mode without at least one top container");
-         cdir->cd();
+         if (cdir) cdir->cd();
          return;
       }   
       cont->SetData(fTree); // This will notify all consumers
@@ -2015,18 +2235,26 @@ void AliAnalysisManager::ExecAnalysis(Option_t *option)
 //
 //    Execute the tasks
 //      TIter next1(cont->GetConsumers());
+      fIOTimer->Stop();
+      fIOTime += fIOTimer->RealTime();
+      fCPUTimer->Start(kTRUE);
       TIter next1(fTopTasks);
       Int_t itask = 0;
       while ((task=(AliAnalysisTask*)next1())) {
          if (fDebug >1) {
             cout << "    Executing task " << task->GetName() << endl;
-         }      
+         }
+         if (fStatistics) fStatistics->StartTimer(GetTaskIndex(task), task->GetName(), task->ClassName());
          task->ExecuteTask(option);
+         if (fStatistics) fStatistics->StopTimer();
          gROOT->cd();
          if (getsysInfo && ((fNcalls%fNSysInfo)==0)) 
             AliSysInfo::AddStamp(task->ClassName(), fNcalls, itask, 1);
          itask++;   
       }
+      fCPUTimer->Stop();
+      fCPUTime += fCPUTimer->RealTime();
+      fIOTimer->Start(kTRUE);
 //
 //    Call FinishEvent() for optional output and MC services 
       if (fInputEventHandler)   fInputEventHandler  ->FinishEvent();
@@ -2035,35 +2263,48 @@ void AliAnalysisManager::ExecAnalysis(Option_t *option)
       // Gather system information if requested
       if (getsysInfo && ((fNcalls%fNSysInfo)==0)) 
          AliSysInfo::AddStamp("Handlers_FinishEvent",fNcalls, 1001, 1);
-      cdir->cd();   
+      if (cdir) cdir->cd();   
+      fIOTimer->Stop();
+      fIOTime += fIOTimer->RealTime();
       return;
    }   
    // The event loop is not controlled by TSelector   
 //
 //  Call BeginEvent() for optional input/output and MC services 
+   fIOTimer->Start(kTRUE);
    if (fInputEventHandler)   fInputEventHandler  ->BeginEvent(-1);
    if (fOutputEventHandler)  fOutputEventHandler ->BeginEvent(-1);
    if (fMCtruthEventHandler) fMCtruthEventHandler->BeginEvent(-1);
+   fIOTimer->Stop();
+   fIOTime += fIOTimer->RealTime();
    gROOT->cd();
    if (getsysInfo && ((fNcalls%fNSysInfo)==0)) 
       AliSysInfo::AddStamp("Handlers_BeginEvent",fNcalls, 1000, 0);
+   fCPUTimer->Start(kTRUE);
    TIter next2(fTopTasks);
    while ((task=(AliAnalysisTask*)next2())) {
       task->SetActive(kTRUE);
       if (fDebug > 1) {
          cout << "    Executing task " << task->GetName() << endl;
       }   
+      if (fStatistics) fStatistics->StartTimer(GetTaskIndex(task), task->GetName(), task->ClassName());
       task->ExecuteTask(option);
+      if (fStatistics) fStatistics->StopTimer();
       gROOT->cd();
    }   
+   fCPUTimer->Stop();
+   fCPUTime += fCPUTimer->RealTime();
 //
 // Call FinishEvent() for optional output and MC services 
+   fIOTimer->Start(kTRUE);
    if (fInputEventHandler)   fInputEventHandler  ->FinishEvent();
    if (fOutputEventHandler)  fOutputEventHandler ->FinishEvent();
    if (fMCtruthEventHandler) fMCtruthEventHandler->FinishEvent();
    if (getsysInfo && ((fNcalls%fNSysInfo)==0)) 
       AliSysInfo::AddStamp("Handlers_FinishEvent",fNcalls, 1000, 1);
-   cdir->cd();   
+   if (cdir) cdir->cd();   
+   fIOTimer->Stop();
+   fIOTime += fIOTimer->RealTime();
 }
 
 //______________________________________________________________________________
@@ -2083,16 +2324,18 @@ Bool_t AliAnalysisManager::IsPipe(std::ostream &out)
 void AliAnalysisManager::SetInputEventHandler(AliVEventHandler* const handler)
 {
 // Set the input event handler and create a container for it.
+   Changed();
    fInputEventHandler   = handler;
-   fCommonInput = CreateContainer("cAUTO_INPUT", TChain::Class(), AliAnalysisManager::kInputContainer);
+   if (!fCommonInput) fCommonInput = CreateContainer("cAUTO_INPUT", TChain::Class(), AliAnalysisManager::kInputContainer);
 }
 
 //______________________________________________________________________________
 void AliAnalysisManager::SetOutputEventHandler(AliVEventHandler* const handler)
 {
 // Set the input event handler and create a container for it.
+   Changed();
    fOutputEventHandler   = handler;
-   fCommonOutput = CreateContainer("cAUTO_OUTPUT", TTree::Class(), AliAnalysisManager::kOutputContainer, "default");
+   if (!fCommonOutput) fCommonOutput = CreateContainer("cAUTO_OUTPUT", TTree::Class(), AliAnalysisManager::kOutputContainer, "default");
    fCommonOutput->SetSpecialOutput();
 }
 
@@ -2217,14 +2460,14 @@ Bool_t AliAnalysisManager::ValidateOutputFiles() const
       file = TFile::Open(filename);
       if (!file || file->IsZombie() || file->TestBit(TFile::kRecovered)) {
          Error("ValidateOutputs", "Output file <%s> was not created or invalid", filename.Data());
-         cdir->cd();
+         if (cdir) cdir->cd();
          return kFALSE;
       }
       file->Close();
       openedFiles += filename;
       openedFiles += " ";
    }
-   cdir->cd();
+   if (cdir) cdir->cd();
    return kTRUE;
 }   
 
@@ -2345,8 +2588,8 @@ void AliAnalysisManager::DoLoadBranch(const char *name)
     fTable.Add(br);
   }
   if (br->GetReadEntry()==fCurrentEntry) return;
-  Int_t ret = br->GetEntry(GetCurrentEntry());
-  if (ret<0) {
+  Long64_t readbytes = br->GetEntry(GetCurrentEntry());
+  if (readbytes<0) {
     Error("DoLoadBranch", "Could not load entry %lld from branch %s",GetCurrentEntry(), name);
     if (crtEntry != fCurrentEntry) {
       CountEvent(1,0,1,0);
@@ -2431,3 +2674,208 @@ const char* AliAnalysisManager::GetOADBPath()
       
    return oadbPath;
 }
+
+//______________________________________________________________________________
+void AliAnalysisManager::SetGlobalStr(const char *key, const char *value)
+{
+// Define a custom string variable mapped to a global unique name. The variable
+// can be then retrieved by a given analysis macro via GetGlobalStr(key).
+   AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
+   if (!mgr) {
+      ::Error("AliAnalysisManager::SetGlobalStr", "No analysis manager defined");
+      return;
+   }   
+   Bool_t valid = kFALSE;
+   TString existing = AliAnalysisManager::GetGlobalStr(key, valid);
+   if (valid) {
+      ::Error("AliAnalysisManager::SetGlobalStr", "Global %s = %s already defined.", key, existing.Data());
+      return;
+   }
+   mgr->GetGlobals()->Add(new TObjString(key), new TObjString(value));
+}
+
+//______________________________________________________________________________
+const char *AliAnalysisManager::GetGlobalStr(const char *key, Bool_t &valid)
+{
+// Static method to retrieve a global variable defined via SetGlobalStr.
+   valid = kFALSE;
+   AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
+   if (!mgr) return 0;
+   TObject *value = mgr->GetGlobals()->GetValue(key);
+   if (!value) return 0;
+   valid = kTRUE;
+   return value->GetName();
+}
+
+//______________________________________________________________________________
+void AliAnalysisManager::SetGlobalInt(const char *key, Int_t value)
+{
+// Define a custom integer variable mapped to a global unique name. The variable
+// can be then retrieved by a given analysis macro via GetGlobalInt(key).
+   AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
+   if (!mgr) {
+      ::Error("AliAnalysisManager::SetGlobalStr", "No analysis manager defined");
+      return;
+   }   
+   Bool_t valid = kFALSE;
+   Int_t existing = AliAnalysisManager::GetGlobalInt(key, valid);
+   if (valid) {
+      ::Error("AliAnalysisManager::SetGlobalInt", "Global %s = %i already defined.", key, existing);
+      return;
+   }
+   mgr->GetGlobals()->Add(new TObjString(key), new TObjString(TString::Format("%i",value)));
+}
+
+//______________________________________________________________________________
+Int_t AliAnalysisManager::GetGlobalInt(const char *key, Bool_t &valid)
+{
+// Static method to retrieve a global variable defined via SetGlobalInt.
+   valid = kFALSE;
+   AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
+   if (!mgr) return 0;
+   TObject *value = mgr->GetGlobals()->GetValue(key);
+   if (!value) return 0;
+   valid = kTRUE;
+   TString s = value->GetName();
+   return s.Atoi();
+}
+
+//______________________________________________________________________________
+void AliAnalysisManager::SetGlobalDbl(const char *key, Double_t value)
+{
+// Define a custom double precision variable mapped to a global unique name. The variable
+// can be then retrieved by a given analysis macro via GetGlobalInt(key).
+   AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
+   if (!mgr) {
+      ::Error("AliAnalysisManager::SetGlobalStr", "No analysis manager defined");
+      return;
+   }   
+   Bool_t valid = kFALSE;
+   Double_t existing = AliAnalysisManager::GetGlobalDbl(key, valid);
+   if (valid) {
+      ::Error("AliAnalysisManager::SetGlobalInt", "Global %s = %g already defined.", key, existing);
+      return;
+   }
+   mgr->GetGlobals()->Add(new TObjString(key), new TObjString(TString::Format("%f.16",value)));
+}
+
+//______________________________________________________________________________
+Double_t AliAnalysisManager::GetGlobalDbl(const char *key, Bool_t &valid)
+{
+// Static method to retrieve a global variable defined via SetGlobalDbl.
+   valid = kFALSE;
+   AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
+   if (!mgr) return 0;
+   TObject *value = mgr->GetGlobals()->GetValue(key);
+   if (!value) return 0;
+   valid = kTRUE;
+   TString s = value->GetName();
+   return s.Atof();
+}
+
+//______________________________________________________________________________
+void AliAnalysisManager::AddClassDebug(const char *className, Int_t debugLevel)
+{
+// Sets Class debug level
+
+   if (!fDebugOptions) {
+      fDebugOptions = new TObjArray();
+      fDebugOptions->SetOwner(kTRUE);
+   }
+
+   TNamed *debugOpt = (TNamed*)fDebugOptions->FindObject(className);
+   if (!debugOpt) {
+     AliInfo(TString::Format("Adding debug level %d for class %s",debugLevel,className).Data());
+     fDebugOptions->Add(new TNamed(className,TString::Format("%d",debugLevel).Data()));
+   } else {
+      TString oldDebugStr = debugOpt->GetTitle();
+      Int_t oldDebug = oldDebugStr.Atoi();
+      if (debugLevel > oldDebug) {
+         AliWarning(TString::Format("Overwriting debug level to %d class %s, because it is higher then previously set (%d).",debugLevel,className,oldDebug).Data());
+         debugOpt->SetTitle(TString::Format("%d",debugLevel).Data());
+      } else {
+         AliWarning(TString::Format("Ignoring debug level to %d class %s, because it is smaller then previously set (%d).",debugLevel,className,oldDebug).Data());
+      }
+   }
+}
+
+//______________________________________________________________________________
+void AliAnalysisManager::ApplyDebugOptions()
+{
+// Apply debug options
+
+   if (!fDebugOptions) return;
+   
+   TIter next(fDebugOptions);
+   TNamed *debug;
+   TString debugLevel;
+   while ((debug=dynamic_cast<TNamed*>(next()))) {
+      debugLevel = debug->GetTitle();
+      AliInfo(TString::Format("Class=%s debulLevel=%d",debug->GetName(),debugLevel.Atoi()).Data());
+      AliLog::SetClassDebugLevel(debug->GetName(), debugLevel.Atoi());
+   }
+}
+
+//______________________________________________________________________________
+Bool_t AliAnalysisManager::IsMacroLoaded(const char filename)
+{
+// Check if a macro was loaded.
+   return fgMacroNames.Contains(filename);
+}
+   
+//______________________________________________________________________________
+Int_t AliAnalysisManager::LoadMacro(const char *filename, Int_t *error, Bool_t check)
+{
+// Redirection of gROOT->LoadMacro which makes sure the same macro is not loaded 
+// twice
+   TString macroName = gSystem->BaseName(filename);
+   // Strip appended +, ++, +g, +O
+   Int_t index = macroName.Index("+");
+   if (index>0) macroName.Remove(index);
+   if (fgMacroNames.Contains(macroName)) {
+      // Macro with the same name loaded already in this root session, do 
+      // nothing
+      error = 0;
+      return 0;
+   }
+   Int_t ret = gROOT->LoadMacro(filename,error,check);
+   // In case of error return the error code
+   if (ret) return ret;
+   // Append the macro name to the loaded macros list
+   fgMacroNames += macroName;
+   fgMacroNames += " ";
+   return ret;
+}   
+
+//______________________________________________________________________________
+void AliAnalysisManager::Lock()
+{
+// Security lock. This is to detect NORMAL user errors and not really to
+// protect against intentional hacks.
+   if (fLocked) return;
+   fLocked = kTRUE;
+   if (fInputEventHandler)  fInputEventHandler->Lock();
+   if (fOutputEventHandler) fOutputEventHandler->Lock();
+   if (fMCtruthEventHandler) fMCtruthEventHandler->Lock();
+   Info("Lock","====== ANALYSIS MANAGER LOCKED ======");
+}
+
+//______________________________________________________________________________
+void AliAnalysisManager::UnLock()
+{
+// Verbose unlocking. Hackers will be punished ;-) ... 
+   if (!fLocked) return;
+   fLocked = kFALSE;
+   if (fInputEventHandler)  fInputEventHandler->UnLock();
+   if (fOutputEventHandler) fOutputEventHandler->UnLock();
+   if (fMCtruthEventHandler) fMCtruthEventHandler->UnLock();
+   Info("UnLock", "====== ANALYSIS MANAGER UNLOCKED ======");
+}
+
+//______________________________________________________________________________
+void AliAnalysisManager::Changed()
+{
+// All critical setters pass through the Changed method that throws an exception 
+// in case the lock was set.
+   if (fLocked) Fatal("Changed","Critical setter called in locked mode");
+}