Fix from Salvatore for new framework
[u/mrichter/AliRoot.git] / ANALYSIS / AliAnalysisManager.cxx
index 693ff6c..b47f3a0 100644 (file)
@@ -17,7 +17,7 @@
 // Author: Andrei Gheata, 31/05/2006
 
 //==============================================================================
-//   AliAnalysysManager - Manager analysis class. Allows creation of several
+//   AliAnalysisManager - Manager analysis class. Allows creation of several
 // analysis tasks and data containers storing their input/output. Allows
 // connecting/chaining tasks via shared data containers. Serializes the current
 // event for all tasks depending only on initial input data.
 //
 //==============================================================================
 
-#include <Riostream.h>
+#include "AliAnalysisManager.h"
 
+#include <cerrno>
+#include <Riostream.h>
 #include <TError.h>
+#include <TMap.h>
 #include <TClass.h>
 #include <TFile.h>
-//#include <TKey.h>
+#include <TTreeCache.h>
+#include <TEnv.h>
 #include <TMath.h>
 #include <TH1.h>
 #include <TMethodCall.h>
@@ -40,6 +44,7 @@
 #include <TCanvas.h>
 #include <TStopwatch.h>
 
+#include "AliLog.h"
 #include "AliAnalysisSelector.h"
 #include "AliAnalysisGrid.h"
 #include "AliAnalysisTask.h"
 #include "AliVEventHandler.h"
 #include "AliVEventPool.h"
 #include "AliSysInfo.h"
-#include "AliAnalysisManager.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),
+                    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);
 }
 
 //______________________________________________________________________________
@@ -108,6 +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),
@@ -117,11 +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),
+                    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);
@@ -133,7 +197,6 @@ AliAnalysisManager::AliAnalysisManager(const AliAnalysisManager& other)
    fParamCont  = new TObjArray(*other.fParamCont);
    fgCommonFileName  = "AnalysisResults.root";
    fgAnalysisManager = this;
-   TObject::SetObjectStat(kFALSE);
 }
    
 //______________________________________________________________________________
@@ -151,6 +214,8 @@ AliAnalysisManager& AliAnalysisManager::operator=(const AliAnalysisManager& othe
       fNSysInfo   = other.fNSysInfo;
       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);
@@ -159,13 +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;
 }
@@ -181,23 +267,92 @@ 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;
-   return fTree ? fTree->GetTree()->GetEntry(entry, getall) : 0;
+   if (!fAutoBranchHandling)
+     return 123456789;
+   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;
 }
-   
+
+//______________________________________________________________________________
+Int_t AliAnalysisManager::GetRunFromAlienPath(const char *path)
+{
+// Attempt to extract run number from input data path. Works only for paths to
+// 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 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);
+         }
+      }
+   }         
+   Int_t run = srun.Atoi();
+   if (run>0) printf("=== GetRunFromAlienPath: run %d of %s data ===\n", run, type.Data());
+   return run;
+}   
+
 //______________________________________________________________________________
 Bool_t AliAnalysisManager::Init(TTree *tree)
 {
@@ -261,6 +416,8 @@ 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);
    if (!top) {
@@ -268,6 +425,7 @@ Bool_t AliAnalysisManager::Init(TTree *tree)
       return kFALSE;
    }
    top->SetData(tree);
+   CheckBranches(kFALSE);
    if (fDebug > 1) {
       printf("<-AliAnalysisManager::Init(%s)\n", tree->GetName());
    }
@@ -281,6 +439,13 @@ 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;
    Bool_t initOK = kTRUE;
@@ -288,6 +453,7 @@ void AliAnalysisManager::SlaveBegin(TTree *tree)
    TDirectory *curdir = gDirectory;
    // Call SlaveBegin only once in case of mixing
    if (isCalled && fMode==kMixingAnalysis) return;
+   gROOT->cd();
    // Call Init of EventHandler
    if (fOutputEventHandler) {
       if (fMode == kProofAnalysis) {
@@ -303,7 +469,7 @@ void AliAnalysisManager::SlaveBegin(TTree *tree)
       if (!fSelector) Error("SlaveBegin", "Selector not set");
       else if (!init) {fSelector->Abort(msg); fSelector->SetStatus(-1);}
    }
-
+   gROOT->cd();
    if (fInputEventHandler) {
       fInputEventHandler->SetInputTree(tree);
       if (fMode == kProofAnalysis) {
@@ -317,7 +483,7 @@ void AliAnalysisManager::SlaveBegin(TTree *tree)
       if (!fSelector) Error("SlaveBegin", "Selector not set");      
       else if (!init) {fSelector->Abort(msg); fSelector->SetStatus(-1);}
    }
-
+   gROOT->cd();
    if (fMCtruthEventHandler) {
       if (fMode == kProofAnalysis) {
          init = fMCtruthEventHandler->Init("proof");
@@ -337,14 +503,27 @@ void AliAnalysisManager::SlaveBegin(TTree *tree)
    AliAnalysisTask *task;
    // Call CreateOutputObjects for all tasks
    Bool_t getsysInfo = ((fNSysInfo>0) && (fMode==kLocalAnalysis))?kTRUE:kFALSE;
+   Bool_t dirStatus = TH1::AddDirectoryStatus();
    Int_t itask = 0;
    while ((task=(AliAnalysisTask*)next())) {
-      curdir = gDirectory;
+      gROOT->cd();
+      // Start with memory as current dir and make sure by default histograms do not get attached to files.
+      TH1::AddDirectory(kFALSE);
       task->CreateOutputObjects();
+      if (!task->CheckPostData()) {
+         Error("SlaveBegin","####### IMPORTANT! ####### \n\n\n\
+                Task %s (%s) did not call PostData() for all its outputs in (User)CreateOutputObjects()\n\n\
+                ####### FIX YOUR CODE, THIS WILL PRODUCE A FATAL ERROR IN FUTURE! ##########", task->GetName(), task->ClassName());
+      }
       if (getsysInfo) AliSysInfo::AddStamp(Form("%s_CREATEOUTOBJ",task->ClassName()), 0, itask, 0);
       itask++;
-      if (curdir) curdir->cd();
    }
+   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");
 }
 
@@ -356,20 +535,32 @@ 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;
 
    TFile *curfile = fTree->GetCurrentFile();
    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 && (run != fRunFromPath)) {
+      fRunFromPath = run;
+      if (fDebug > 1) printf("   ### run found from path: %d\n", run);
+   }
    TIter next(fTasks);
    AliAnalysisTask *task;
-   // Call Notify for all tasks
-   while ((task=(AliAnalysisTask*)next())) 
-      task->Notify();
        
    // Call Notify of the event handlers
    if (fInputEventHandler) {
@@ -383,12 +574,19 @@ Bool_t AliAnalysisManager::Notify()
    if (fMCtruthEventHandler) {
        fMCtruthEventHandler->Notify(curfile->GetName());
    }
+
+   // Call Notify for all tasks
+   while ((task=(AliAnalysisTask*)next())) 
+      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
@@ -407,15 +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);
-   ExecAnalysis();
-   if (fDebug > 1) printf("<-AliAnalysisManager::Process()\n");
+   // This method is obsolete. ExecAnalysis is called instead.
    return kTRUE;
 }
 
@@ -425,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;
@@ -447,16 +652,20 @@ void AliAnalysisManager::PackOutput(TList *target)
          gROOT->cd();
          if (fDebug > 1) printf("<-FinishTaskOutput: task %s\n", task->GetName());
       }
-   }      
+   }
+   // Write statistics message on the workers.
+   if (fStatistics) WriteStatisticsMsg(fNcalls);
    
    if (fMode == kProofAnalysis) {
       TIter next(fOutputs);
       AliAnalysisDataContainer *output;
       Bool_t isManagedByHandler = kFALSE;
+      TList filestmp;
+      filestmp.SetOwner();
       while ((output=(AliAnalysisDataContainer*)next())) {
          // Do not consider outputs of post event loop tasks
          isManagedByHandler = kFALSE;
-         if (output->GetProducer()->IsPostEventLoop()) continue;
+         if (output->GetProducer() && output->GetProducer()->IsPostEventLoop()) continue;
          const char *filename = output->GetFileName();
          if (!(strcmp(filename, "default")) && fOutputEventHandler) {
             isManagedByHandler = kTRUE;
@@ -476,33 +685,42 @@ void AliAnalysisManager::PackOutput(TList *target)
                // File resident outputs. 
                // Check first if the file exists.
                TString openoption = "RECREATE";
-               if (!gSystem->AccessPathName(output->GetFileName())) openoption = "UPDATE";
-               TFile *file = AliAnalysisManager::OpenFile(output, openoption, kTRUE);
+               Bool_t firsttime = kTRUE;
+               if (filestmp.FindObject(output->GetFileName())) {
+                  firsttime = kFALSE;
+               } else {   
+                  filestmp.Add(new TNamed(output->GetFileName(),""));
+               }   
+               if (!gSystem->AccessPathName(output->GetFileName()) && !firsttime) openoption = "UPDATE";
+//               TFile *file = AliAnalysisManager::OpenFile(output, openoption, kTRUE);
                // Save data to file, then close.
                if (output->GetData()->InheritsFrom(TCollection::Class())) {
                   // If data is a collection, we set the name of the collection 
                   // as the one of the container and we save as a single key.
                   TCollection *coll = (TCollection*)output->GetData();
                   coll->SetName(output->GetName());
-                  coll->Write(output->GetName(), TObject::kSingleKey);
+//                  coll->Write(output->GetName(), TObject::kSingleKey);
                } else {
                   if (output->GetData()->InheritsFrom(TTree::Class())) {
+                     TFile *file = AliAnalysisManager::OpenFile(output, openoption, kTRUE);
+                     // Save data to file, then close.
                      TTree *tree = (TTree*)output->GetData();
                      // Check if tree is in memory
                      if (tree->GetDirectory()==gROOT) tree->SetDirectory(gDirectory);
                      tree->AutoSave();
+                     file->Close();
                   } else {
-                     output->GetData()->Write();
+//                     output->GetData()->Write();
                   }   
                }      
                if (fDebug > 1) printf("PackOutput %s: memory merge, file resident output\n", output->GetName());
-               if (fDebug > 2) {
-                  printf("   file %s listing content:\n", filename);
-                  file->ls();
-               }   
+//               if (fDebug > 2) {
+//                  printf("   file %s listing content:\n", filename);
+//                  file->ls();
+//               }   
                // Clear file list to release object ownership to user.
 //               file->Clear();
-               file->Close();
+//               file->Close();
                output->SetFile(NULL);
                // Restore current directory
                if (opwd) opwd->cd();
@@ -575,8 +793,8 @@ void AliAnalysisManager::PackOutput(TList *target)
                TString remote = fSpecialOutputLocation;
                remote += "/";
                Int_t gid = gROOT->ProcessLine("gProofServ->GetGroupId();");
-               if (remote.BeginsWith("alien://")) {
-                  gROOT->ProcessLine("TGrid::Connect(\"alien://pcapiserv01.cern.ch:10000\", gProofServ->GetUser());");
+               if (remote.BeginsWith("alien:")) {
+                  gROOT->ProcessLine("TGrid::Connect(\"alien:\", gProofServ->GetUser());");
                   remote += outFilename;
                   remote.ReplaceAll(".root", Form("_%d.root", gid));
                } else {   
@@ -618,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());
 }
 
@@ -627,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;
@@ -667,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();
@@ -674,8 +924,8 @@ void AliAnalysisManager::ImportWrappers(TList *source)
          // Try to fetch first an object having the container name.
          obj = gDirectory->Get(cont->GetName());
          if (!obj) {
-            Warning("ImportWrappers", "Could not import object for container %s in file %s:%s.\n Object will not be available in Terminate()", 
-                    cont->GetName(), filename, cont->GetFolderName());
+            Warning("ImportWrappers", "Could not import object of type:%s for container %s in file %s:%s.\n Object will not be available in Terminate(). Try if possible to name the output object as the container (%s) or to embed it in a TList", 
+                    cont->GetType()->GetName(), cont->GetName(), filename, cont->GetFolderName(), cont->GetName());
             continue;
          }  
          wrap = new AliAnalysisDataWrapper(obj);
@@ -695,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);
 }
 
@@ -702,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.");
@@ -727,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");
 }
 
@@ -742,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;
@@ -761,9 +1019,9 @@ void AliAnalysisManager::Terminate()
       itask++;   
       if (TObject::TestBit(kSaveCanvases)) {
          if (!gROOT->IsBatch()) {
-            if (fDebug>1) printf("Waiting 5 sec for %s::Terminate() to finish drawing ...", task->ClassName());
-            timer.Start();
-            while (timer.CpuTime()<5) {
+            if (fDebug>1) printf("Waiting 5 sec for %s::Terminate() to finish drawing ...\n", task->ClassName());
+            timer.Start(kTRUE);
+            while (timer.RealTime()<5) {
                timer.Continue();
                gSystem->ProcessEvents();
             }
@@ -791,10 +1049,13 @@ void AliAnalysisManager::Terminate()
       for (icont=0; icont<fParamCont->GetEntriesFast(); icont++) allOutputs->Add(fParamCont->At(icont));
    TIter next1(allOutputs);
    TString handlerFile = "";
+   TString extraOutputs = "";
    if (fOutputEventHandler) {
       handlerFile = fOutputEventHandler->GetOutputFileName();
+      extraOutputs = fOutputEventHandler->GetExtraOutputs();
    }
    icont = 0;
+   TList filestmp;
    while ((output=(AliAnalysisDataContainer*)next1())) {
       // Special outputs or grid files have the files already closed and written.
       icont++;
@@ -812,7 +1073,13 @@ void AliAnalysisManager::Terminate()
       if (!file) file = (TFile*)gROOT->GetListOfFiles()->FindObject(filename);
       if (!file) {
              //if (handlerFile == filename && !gSystem->AccessPathName(filename)) openoption = "UPDATE";
-         if (!gSystem->AccessPathName(filename)) openoption = "UPDATE";
+         Bool_t firsttime = kTRUE;
+         if (filestmp.FindObject(filename) || extraOutputs.Contains(filename)) {
+            firsttime = kFALSE;
+         } else {   
+            filestmp.Add(new TNamed(filename,""));
+         }   
+         if (!gSystem->AccessPathName(filename) && !firsttime) openoption = "UPDATE";
              if (fDebug>1) printf("Opening file: %s  option=%s\n",filename, openoption.Data());
          file = new TFile(filename, openoption);
       } else {
@@ -855,6 +1122,7 @@ void AliAnalysisManager::Terminate()
    }
    gROOT->cd();
    next1.Reset();
+   TString copiedFiles;
    while ((output=(AliAnalysisDataContainer*)next1())) {
       // Close all files at output
       TDirectory *opwd = gDirectory;
@@ -862,19 +1130,26 @@ 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();
    }   
    delete allOutputs;
-
+   //Write statistics information on the client
+   if (fStatistics) WriteStatisticsMsg(fNcalls);
    if (getsysInfo) {
       TDirectory *crtdir = gDirectory;
       TFile f("syswatch.root", "RECREATE");
@@ -915,8 +1190,8 @@ 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->GetYaxis()->SetTitle("deltaVM [kB]");
+                  hist->SetTitle(Form("%s: Exec dVM[MB]/event", task->GetName()));
+                  hist->GetYaxis()->SetTitle("deltaVM [MB]");
                }   
             }
             // Draw the plot of deltaVM for CreateOutputObjects for all tasks
@@ -929,7 +1204,7 @@ void AliAnalysisManager::Terminate()
             hist = (TH1*)gPad->GetListOfPrimitives()->FindObject("htemp");            
             if (hist) {
                hist->SetTitle("Memory in CreateOutputObjects()");
-               hist->GetYaxis()->SetTitle("deltaVM [kB]");
+               hist->GetYaxis()->SetTitle("deltaVM [MB]");
                hist->GetXaxis()->SetTitle("task");
             }   
             // draw the plot of deltaVM for Terminate for all tasks
@@ -941,7 +1216,7 @@ void AliAnalysisManager::Terminate()
             hist = (TH1*)gPad->GetListOfPrimitives()->FindObject("htemp");
             if (hist) {
                hist->SetTitle("Memory in Terminate()");
-               hist->GetYaxis()->SetTitle("deltaVM [kB]");
+               hist->GetYaxis()->SetTitle("deltaVM [MB]");
                hist->GetXaxis()->SetTitle("task");
             }   
             // Full VM profile
@@ -953,7 +1228,7 @@ void AliAnalysisManager::Terminate()
             hist = (TH1*)gPad->GetListOfPrimitives()->FindObject("htemp");
             if (hist) {
                hist->SetTitle("Virtual memory");
-               hist->GetYaxis()->SetTitle("VM [kB]");
+               hist->GetYaxis()->SetTitle("VM [MB]");
             }
             canvas->Modified();   
          }   
@@ -967,12 +1242,16 @@ void AliAnalysisManager::Terminate()
       if (crtdir) crtdir->cd();
    }
    // Validate the output files
-   if (ValidateOutputFiles()) {
+   if (ValidateOutputFiles() && fIsRemote && fMode!=kProofAnalysis) {
       ofstream out;
       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");
 }
 //______________________________________________________________________________
@@ -1024,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
@@ -1043,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;
@@ -1056,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;
@@ -1073,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)
 {
@@ -1165,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)
@@ -1257,12 +1549,101 @@ Bool_t AliAnalysisManager::InitAnalysis()
          Error("InitAnalysis", "Wrong container %s : a file name MUST be provided for special outputs", cont->GetName());
          return kFALSE;
       }
-   }      
+   }
+   // Initialize requested branch list if needed
+   if (!fAutoBranchHandling) {
+      next.Reset();
+      while ((task=(AliAnalysisTask*)next())) {
+         if (!task->HasBranches()) {
+            Error("InitAnalysis", "Manual branch loading requested but task %s of type %s does not define branches.\nUse: fBranchNames = \"ESD:br1,br2,...,brN AOD:bra1,bra2,...,braM\"",
+                  task->GetName(), task->ClassName());
+            return kFALSE;
+         }
+         if (!fInputEventHandler || !strlen(fInputEventHandler->GetDataType())) {
+            Error("InitAnalysis", "Manual branch loading requested but no input handler defined or handler does not define data type.");
+            return kFALSE;
+         }
+         TString taskbranches;
+         task->GetBranches(fInputEventHandler->GetDataType(), taskbranches);
+         if (taskbranches.IsNull()) {
+            Error("InitAnalysis", "Manual branch loading requested but task %s of type %s does not define branches of type %s:",
+                  task->GetName(), task->ClassName(), fInputEventHandler->GetDataType());
+            return kFALSE;      
+         }
+         AddBranches(taskbranches);
+      }         
+   }
    fInitOK = kTRUE;
    return kTRUE;
 }   
 
 //______________________________________________________________________________
+void AliAnalysisManager::AddBranches(const char *branches)
+{
+// Add branches to the existing fRequestedBranches.
+   TString br(branches);
+   TObjArray *arr = br.Tokenize(",");
+   TIter next(arr);
+   TObject *obj;
+   while ((obj=next())) {
+      if (!fRequestedBranches.Contains(obj->GetName())) {
+         if (!fRequestedBranches.IsNull()) fRequestedBranches += ",";
+         fRequestedBranches += obj->GetName();
+      }
+   }
+  delete arr;
+}   
+
+//______________________________________________________________________________
+void AliAnalysisManager::CheckBranches(Bool_t load)
+{
+// The method checks the input branches to be loaded during the analysis.
+   if (fAutoBranchHandling || fRequestedBranches.IsNull() || !fTree) return;   
+   TObjArray *arr = fRequestedBranches.Tokenize(",");
+   TIter next(arr);
+   TObject *obj;
+   while ((obj=next())) {
+      TBranch *br = dynamic_cast<TBranch*>(fTable.FindObject(obj->GetName()));
+      if (!br) {
+         br = fTree->GetBranch(obj->GetName());
+         if (!br) {
+            Error("CheckBranches", "Could not find branch %s",obj->GetName());
+            continue;
+         }
+      }   
+      fTable.Add(br);
+      if (load && br->GetReadEntry()!=GetCurrentEntry()) {
+         br->GetEntry(GetCurrentEntry());
+      }      
+   }
+  delete arr;
+}
+
+//______________________________________________________________________________
+Bool_t AliAnalysisManager::CheckTasks() const
+{
+// Check consistency of tasks.
+   Int_t ntasks = fTasks->GetEntries();
+   if (!ntasks) {
+      Error("CheckTasks", "No tasks connected to the manager. This may be due to forgetting to compile the task or to load their library.");
+      return kFALSE;
+   }
+   // Get the pointer to AliAnalysisTaskSE::Class()
+   TClass *badptr = (TClass*)gROOT->ProcessLine("AliAnalysisTaskSE::Class()");
+   // Loop all tasks to check if their corresponding library was loaded
+   TIter next(fTasks);
+   TObject *obj;
+   while ((obj=next())) {
+      if (obj->IsA() == badptr) {
+         Error("CheckTasks", "##################\n \
+         Class for task %s NOT loaded. You probably forgot to load the library for this task (or compile it dynamically).\n###########################\n",obj->GetName());
+         return kFALSE;
+      }
+   }
+   return kTRUE;      
+}   
+
+//______________________________________________________________________________
 void AliAnalysisManager::PrintStatus(Option_t *option) const
 {
 // Print task hierarchy.
@@ -1277,6 +1658,22 @@ void AliAnalysisManager::PrintStatus(Option_t *option) const
    AliAnalysisTask *task;
    while ((task=(AliAnalysisTask*)next()))
       task->PrintTask(option);
+  
+   if (!fAutoBranchHandling && !fRequestedBranches.IsNull()) 
+      printf("Requested input branches:\n%s\n", fRequestedBranches.Data());
+  
+  TString sopt(option);
+  sopt.ToUpper();
+  
+  if (sopt.Contains("ALL"))
+  {
+    if ( fOutputEventHandler )
+    {
+      cout << TString('_',78) << endl;
+      cout << "OutputEventHandler:" << endl;
+      fOutputEventHandler->Print("   ");
+    }
+  }
 }
 
 //______________________________________________________________________________
@@ -1287,6 +1684,54 @@ 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.
+   if (!fGridHandler) {
+      Error("StartAnalysis", "Cannot start analysis providing just the analysis type without a grid handler.");
+      Info("===", "Add an AliAnalysisAlien object as plugin for this manager and configure it.");
+      return -1;
+   }
+   TTree *tree = NULL;
+   return StartAnalysis(type, tree, nentries, firstentry);
+}
+
+//______________________________________________________________________________
 Long64_t AliAnalysisManager::StartAnalysis(const char *type, TTree * const tree, Long64_t nentries, Long64_t firstentry)
 {
 // Start analysis for this manager. Analysis task can be: LOCAL, PROOF, GRID or
@@ -1297,65 +1742,70 @@ 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 (fDebug > 1) printf("StartAnalysis %s\n",GetName());
+   if (!CheckTasks()) Fatal("StartAnalysis", "Not all needed libraries were loaded");
+   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;
-   }   
+   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;
       if (!anaType.Contains("terminate")) {
          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;
    }
-   char line[256];
+   TString line;
    SetEventLoop(kFALSE);
    // Enable event loop mode if a tree was provided
-   if (tree || fMode==kMixingAnalysis) SetEventLoop(kTRUE);
+   if (tree || fGridHandler || fMode==kMixingAnalysis) SetEventLoop(kTRUE);
 
    TChain *chain = 0;
    TString ttype = "TTree";
@@ -1363,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";
@@ -1374,26 +1824,28 @@ 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:
-         if (!tree) {
+         if (!tree && !fGridHandler) {
             TIter nextT(fTasks);
             // Call CreateOutputObjects for all tasks
             Int_t itask = 0;
+            Bool_t dirStatus = TH1::AddDirectoryStatus();
             while ((task=(AliAnalysisTask*)nextT())) {
+               TH1::AddDirectory(kFALSE);
                task->CreateOutputObjects();
+               if (!task->CheckPostData()) {
+                  Error("SlaveBegin","####### IMPORTANT! ####### \n\n\n\
+                        Task %s (%s) did not call PostData() for all its outputs in (User)CreateOutputObjects()\n\n\
+                        ########### FIX YOUR CODE, THIS WILL PRODUCE A FATAL ERROR IN FUTURE! ###########", task->GetName(), task->ClassName());
+               }
                if (getsysInfo) AliSysInfo::AddStamp(Form("%s_CREATEOUTOBJ",task->ClassName()), 0, itask, 0);
                gROOT->cd();
                itask++;
             }   
+            TH1::AddDirectory(dirStatus);
             if (IsExternalLoop()) {
                Info("StartAnalysis", "Initialization done. Event loop is controlled externally.\
                      \nSetData for top container, call ExecAnalysis in a loop and then Terminate manually");
@@ -1403,18 +1855,41 @@ Long64_t AliAnalysisManager::StartAnalysis(const char *type, TTree * const tree,
             Terminate();
             return 0;
          } 
+         fSelector = new AliAnalysisSelector(this);
+         // Check if a plugin handler is used
+         if (fGridHandler) {
+            // Get the chain from the plugin
+            TString dataType = "esdTree";
+            if (fInputEventHandler) {
+               dataType = fInputEventHandler->GetDataType();
+               dataType.ToLower();
+               dataType += "Tree";
+            }   
+            chain = fGridHandler->GetChainForTestMode(dataType);
+            if (!chain) {
+               Error("StartAnalysis", "No chain for test mode. Aborting.");
+               return -1;
+            }
+            cout << "===== RUNNING LOCAL ANALYSIS" << GetName() << " ON CHAIN " << chain->GetName() << endl;
+            retv = chain->Process(fSelector, "", nentries, firstentry);
+            break;
+         }
          // Run tree-based analysis via AliAnalysisSelector  
          cout << "===== RUNNING LOCAL ANALYSIS " << GetName() << " ON TREE " << tree->GetName() << endl;
-         fSelector = new AliAnalysisSelector(this);
          retv = tree->Process(fSelector, "", nentries, firstentry);
          break;
       case kProofAnalysis:
+         fIsRemote = kTRUE;
+         // Check if the plugin is used
+         if (fGridHandler) {
+            return StartAnalysis(type, fGridHandler->GetProofDataSet(), nentries, firstentry);
+         }
          if (!gROOT->GetListOfProofs() || !gROOT->GetListOfProofs()->GetEntries()) {
             Error("StartAnalysis", "No PROOF!!! Exiting.");
-            cdir->cd();
+            if (cdir) cdir->cd();
             return -1;
          }   
-         sprintf(line, "gProof->AddInput((TObject*)0x%lx);", (ULong_t)this);
+         line = Form("gProof->AddInput((TObject*)%p);", this);
          gROOT->ProcessLine(line);
          if (chain) {
             chain->SetProof();
@@ -1422,18 +1897,49 @@ 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;
       case kGridAnalysis:
-         Warning("StartAnalysis", "GRID analysis mode not implemented. Running local.");
-         break;
+         fIsRemote = kTRUE;
+         if (!anaType.Contains("terminate")) {
+            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.");
+               if (cdir) cdir->cd();
+               return -1;
+            }
+            // Write analysis manager in the analysis file
+            cout << "===== RUNNING GRID ANALYSIS: " << GetName() << endl;
+            // Start the analysis via the handler
+            if (!fGridHandler->StartAnalysis(nentries, firstentry)) {
+               Info("StartAnalysis", "Grid analysis was stopped and cannot be terminated");
+               if (cdir) cdir->cd();
+               return -1;
+            }   
+
+            // Terminate grid analysis
+            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.
+               if (cdir) cdir->cd();
+               return 0;
+            }
+         }   
+         cout << "===== TERMINATING GRID ANALYSIS JOB: " << GetName() << endl;
+         ImportWrappers(NULL);
+         Terminate();
+         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;
@@ -1446,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;
 }   
 
@@ -1466,6 +1972,7 @@ Long64_t AliAnalysisManager::StartAnalysis(const char *type, const char *dataset
       Error("StartAnalysis","Analysis manager was not initialized !");
       return -1;
    }
+   fIsRemote = kTRUE;
    if (fDebug > 1) printf("StartAnalysis %s\n",GetName());
    TString anaType = type;
    anaType.ToLower();
@@ -1474,34 +1981,43 @@ Long64_t AliAnalysisManager::StartAnalysis(const char *type, const char *dataset
       return -1;
    }   
    fMode = kProofAnalysis;
-   char line[256];
+   TString line;
+   TString proofProcessOpt;
    SetEventLoop(kTRUE);
    // Set the dataset flag
    TObject::SetBit(kUseDataSet);
    fTree = 0;
+   if (fGridHandler) {
+      // Start proof analysis using the grid handler
+      if (!fGridHandler->StartAnalysis(nentries, firstentry)) {
+         Error("StartAnalysis", "The grid plugin could not start PROOF analysis");
+         return -1;
+      }
+      // Check if the plugin is in test mode
+      if (fGridHandler->GetRunMode() == AliAnalysisGrid::kTest) {
+         dataset = "test_collection";
+      } else {
+         dataset = fGridHandler->GetProofDataSet();
+      }
+
+      proofProcessOpt = fGridHandler->GetProofProcessOpt();
+   }   
 
-   // Initialize locally all tasks
-   TIter next(fTasks);
-   AliAnalysisTask *task;
-   while ((task=(AliAnalysisTask*)next())) {
-      task->LocalInit();
-   }
-   
    if (!gROOT->GetListOfProofs() || !gROOT->GetListOfProofs()->GetEntries()) {
       Error("StartAnalysis", "No PROOF!!! Exiting.");
       return -1;
    }   
-   sprintf(line, "gProof->AddInput((TObject*)0x%lx);", (ULong_t)this);
+
+   // Initialize locally all tasks
+   RunLocalInit();
+      
+   line = Form("gProof->AddInput((TObject*)%p);", this);
    gROOT->ProcessLine(line);
-//   sprintf(line, "gProof->GetDataSet(\"%s\");", dataset);
-//   if (!gROOT->ProcessLine(line)) {
-//      Error("StartAnalysis", "Dataset %s not found", dataset);
-//      return -1;
-//   }   
-   sprintf(line, "gProof->Process(\"%s\", \"AliAnalysisSelector\", \"\", %lld, %lld);",
-           dataset, nentries, firstentry);
+   Long_t retv;
+   line = Form("gProof->Process(\"%s\", \"AliAnalysisSelector\", \"%s\", %lld, %lld);",
+               dataset,proofProcessOpt.Data(), nentries, firstentry);
    cout << "===== RUNNING PROOF ANALYSIS " << GetName() << " ON DATASET " << dataset << endl;
-   Long_t retv = (Long_t)gROOT->ProcessLine(line);
+   retv = (Long_t)gROOT->ProcessLine(line);
    return retv;
 }   
 
@@ -1553,13 +2069,16 @@ TFile *AliAnalysisManager::OpenFile(AliAnalysisDataContainer *cont, const char *
 }    
  
 //______________________________________________________________________________
-TFile *AliAnalysisManager::OpenProofFile(AliAnalysisDataContainer *cont, const char *option)
+TFile *AliAnalysisManager::OpenProofFile(AliAnalysisDataContainer *cont, const char *option, const char *extaod)
 {
 // Opens a special output file used in PROOF.
   TString line;
   TString filename = cont->GetFileName();
   if (cont == fCommonOutput) {
-     if (fOutputEventHandler) filename = fOutputEventHandler->GetOutputFileName();
+     if (fOutputEventHandler) {
+        if (strlen(extaod)) filename = extaod;
+        filename = fOutputEventHandler->GetOutputFileName();
+     }   
      else Fatal("OpenProofFile","No output container. Exiting.");
   }   
   TFile *f = NULL;
@@ -1598,13 +2117,16 @@ TFile *AliAnalysisManager::OpenProofFile(AliAnalysisDataContainer *cont, const c
   TObject *pof = fSelector->GetOutputList()->FindObject(filename);
   if (pof) {
     // Get the actual file
-    line = Form("((TProofOutputFile*)0x%lx)->GetFileName();", (ULong_t)pof);
+    line = Form("((TProofOutputFile*)%p)->GetFileName();", pof);
     filename = (const char*)gROOT->ProcessLine(line);
     if (fDebug>1) {
       printf("File: %s already booked via TProofOutputFile\n", filename.Data());
     }  
     f = (TFile*)gROOT->GetListOfFiles()->FindObject(filename);
-    if (!f) Fatal("OpenProofFile", "Proof output file found but no file opened for %s", filename.Data());
+    if (!f) {
+       Fatal("OpenProofFile", "Proof output file found but no file opened for %s", filename.Data());
+       return NULL;
+    }   
     // Check if option "UPDATE" was preserved 
     TString opt(option);
     opt.ToUpper();
@@ -1631,7 +2153,7 @@ TFile *AliAnalysisManager::OpenProofFile(AliAnalysisDataContainer *cont, const c
       printf(" == proof file name: %s", f->GetName());
     }   
     // Add to proof output list
-    line = Form("((TList*)0x%lx)->Add(pf);",(ULong_t)fSelector->GetOutputList());
+    line = Form("((TList*)%p)->Add(pf);",fSelector->GetOutputList());
     if (fDebug > 1) printf("=== %s\n", line.Data());
     gROOT->ProcessLine(line);
   }
@@ -1656,34 +2178,40 @@ TFile *AliAnalysisManager::OpenProofFile(AliAnalysisDataContainer *cont, const c
 void AliAnalysisManager::ExecAnalysis(Option_t *option)
 {
 // Execute analysis.
-   static Long64_t ncalls = 0;
    static Long64_t nentries = 0;
    static TTree *lastTree = 0;
    static TStopwatch *timer = new TStopwatch();
-   if (fDebug > 0) printf("MGR: Processing event #%lld\n", ncalls);
+   // 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)) {
          nentries += fTree->GetEntries();
          lastTree = fTree;
       }   
-      if (!ncalls) timer->Start();
-      ProgressBar("Processing event", ncalls, nentries, timer, kFALSE);
+      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 && ((ncalls%fNSysInfo)==0)) AliSysInfo::AddStamp("Exec_start", (Int_t)ncalls);
-   ncalls++;
+   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++;
    AliAnalysisTask *task;
    // Check if the top tree is active.
    if (fTree) {
-      if (getsysInfo && ((ncalls%fNSysInfo)==0)) 
-         AliSysInfo::AddStamp("Handlers_BeginEventGroup",(Int_t)ncalls, 1002, 0);
+      if (getsysInfo && ((fNcalls%fNSysInfo)==0)) 
+         AliSysInfo::AddStamp("Handlers_BeginEventGroup",fNcalls, 1002, 0);
       TIter next(fTasks);
    // De-activate all tasks
       while ((task=(AliAnalysisTask*)next())) task->SetActive(kFALSE);
@@ -1691,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
@@ -1702,82 +2230,137 @@ void AliAnalysisManager::ExecAnalysis(Option_t *option)
       if (fOutputEventHandler)  fOutputEventHandler ->BeginEvent(entry);
       if (fMCtruthEventHandler) fMCtruthEventHandler->BeginEvent(entry);
       gROOT->cd();
-      if (getsysInfo && ((ncalls%fNSysInfo)==0)) 
-         AliSysInfo::AddStamp("Handlers_BeginEvent",(Int_t)ncalls, 1000, 0);
+      if (getsysInfo && ((fNcalls%fNSysInfo)==0)) 
+         AliSysInfo::AddStamp("Handlers_BeginEvent",fNcalls, 1000, 0);
 //
 //    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 && ((ncalls%fNSysInfo)==0)) 
-            AliSysInfo::AddStamp(task->ClassName(),(Int_t)ncalls, itask, 1);
+         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();
       if (fOutputEventHandler)  fOutputEventHandler ->FinishEvent();
       if (fMCtruthEventHandler) fMCtruthEventHandler->FinishEvent();
       // Gather system information if requested
-      if (getsysInfo && ((ncalls%fNSysInfo)==0)) 
-         AliSysInfo::AddStamp("Handlers_FinishEvent",(Int_t)ncalls, 1001, 1);
-      cdir->cd();   
+      if (getsysInfo && ((fNcalls%fNSysInfo)==0)) 
+         AliSysInfo::AddStamp("Handlers_FinishEvent",fNcalls, 1001, 1);
+      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 && ((ncalls%fNSysInfo)==0)) 
-      AliSysInfo::AddStamp("Handlers_BeginEvent",(Int_t)ncalls, 1000, 0);
+   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 && ((ncalls%fNSysInfo)==0)) 
-      AliSysInfo::AddStamp("Handlers_FinishEvent",(Int_t)ncalls, 1000, 1);
-   cdir->cd();   
+   if (getsysInfo && ((fNcalls%fNSysInfo)==0)) 
+      AliSysInfo::AddStamp("Handlers_FinishEvent",fNcalls, 1000, 1);
+   if (cdir) cdir->cd();   
+   fIOTimer->Stop();
+   fIOTime += fIOTimer->RealTime();
 }
 
 //______________________________________________________________________________
+Bool_t AliAnalysisManager::IsPipe(std::ostream &out)
+{
+// Check if the stdout is connected to a pipe (C.Holm)
+  Bool_t ispipe = kFALSE;
+  out.seekp(0, std::ios_base::cur);
+  if (out.fail()) {
+    out.clear();
+    if (errno == ESPIPE) ispipe = kTRUE;
+  }
+  return ispipe;
+}
+   
+//______________________________________________________________________________
 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);
-//   Warning("SetInputEventHandler", " An automatic input container for the input chain was created.\nPlease use: mgr->GetCommonInputContainer() to access it.");
+   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();
-//   Warning("SetOutputEventHandler", " An automatic output container for the output tree was created.\nPlease use: mgr->GetCommonOutputContainer() to access it.");
 }
 
 //______________________________________________________________________________
+void AliAnalysisManager::SetDebugLevel(UInt_t level)
+{
+// Set verbosity of the analysis manager. If the progress bar is used, the call is ignored
+   if (TObject::TestBit(kUseProgressBar)) {
+      Info("SetDebugLevel","Ignored. Disable the progress bar first.");
+      return;
+   }
+   fDebug = level;
+}
+   
+//______________________________________________________________________________
+void AliAnalysisManager::SetUseProgressBar(Bool_t flag, Int_t freq)
+{
+// Enable a text mode progress bar. Resets debug level to 0.
+   Info("SetUseProgressBar", "Progress bar enabled, updated every %d events.\n  ### NOTE: Debug level reset to 0 ###", freq);
+   TObject::SetBit(kUseProgressBar,flag);
+   fPBUpdateFreq = freq;
+   fDebug = 0;
+}   
+
+//______________________________________________________________________________
 void AliAnalysisManager::RegisterExtraFile(const char *fname)
 {
 // This method is used externally to register output files which are not
@@ -1795,13 +2378,14 @@ Bool_t AliAnalysisManager::GetFileFromWrapper(const char *filename, const TList
 // Copy a file from the location specified ina the wrapper with the same name from the source list.
    char fullPath[512];
    char chUrl[512];
+   char tmp[1024];
    TObject *pof =  source->FindObject(filename);
    if (!pof || !pof->InheritsFrom("TProofOutputFile")) {
       Error("GetFileFromWrapper", "TProofOutputFile object not found in output list for file %s", filename);
       return kFALSE;
    }
-   gROOT->ProcessLine(Form("sprintf((char*)0x%lx, \"%%s\", ((TProofOutputFile*)0x%lx)->GetOutputFileName();)", fullPath, pof));
-   gROOT->ProcessLine(Form("sprintf((char*)0x%lx, \"%%s\", gProof->GetUrl();)", chUrl));
+   gROOT->ProcessLine(Form("sprintf((char*)%p, \"%%s\", ((TProofOutputFile*)%p)->GetOutputFileName());", fullPath, pof));
+   gROOT->ProcessLine(Form("sprintf((char*)%p, \"%%s\", gProof->GetUrl());",chUrl));
    TString clientUrl(chUrl);
    TString fullPath_str(fullPath);
    if (clientUrl.Contains("localhost")){
@@ -1815,8 +2399,13 @@ Bool_t AliAnalysisManager::GetFileFromWrapper(const char *filename, const TList
       delete arrayPort;
       delete array;
    }
+   else if (clientUrl.Contains("__lite__")) { 
+     // Special case for ProofLite environement - get file info and copy. 
+     gROOT->ProcessLine(Form("sprintf((char*)%p,\"%%s\",((TProofOutputFile*)%p)->GetDir());", tmp, pof));
+     fullPath_str = Form("%s/%s", tmp, fullPath);
+   }
    if (fDebug > 1) 
-      Info("GetFileFromWrapper","Copying file %s from PROOF scratch space", fullPath_str.Data());
+     Info("GetFileFromWrapper","Copying file %s from PROOF scratch space to %s", fullPath_str.Data(),filename);
    Bool_t gotit = TFile::Cp(fullPath_str.Data(), filename); 
    if (!gotit)
       Error("GetFileFromWrapper", "Could not get file %s from proof scratch space", filename);
@@ -1871,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;
 }   
 
@@ -1896,10 +2485,10 @@ void AliAnalysisManager::ProgressBar(const char *opname, Long64_t current, Long6
    static Bool_t oneoftwo = kFALSE;
    static Int_t nrefresh = 0;
    static Int_t nchecks = 0;
-   const char symbol[4] = {'=','\\','|','/'}; 
-   char progress[11] = "          ";
-   Int_t ichar = icount%4;
+   static char lastChar = 0;
+   const char symbol[4] = {'-','\\','|','/'}; 
    
+   if (!lastChar) lastChar = (IsPipe(std::cerr))?'\r':'\n';
    if (!refresh) {
       nrefresh = 0;
       if (!size) return;
@@ -1912,7 +2501,10 @@ void AliAnalysisManager::ProgressBar(const char *opname, Long64_t current, Long6
       nrefresh++;
       if (!osize) return;
    }     
+   if ((current % fPBUpdateFreq) != 0) return;
    icount++;
+   char progress[11] = "          ";
+   Int_t ichar = icount%4;
    Double_t time = 0.;
    Int_t hours = 0;
    Int_t minutes = 0;
@@ -1920,11 +2512,9 @@ void AliAnalysisManager::ProgressBar(const char *opname, Long64_t current, Long6
    if (owatch && !last) {
       owatch->Stop();
       time = owatch->RealTime();
-      hours = (Int_t)(time/3600.);
-      time -= 3600*hours;
-      minutes = (Int_t)(time/60.);
-      time -= 60*minutes;
-      seconds = (Int_t)time;
+      seconds   = int(time) % 60;
+      minutes   = (int(time) / 60) % 60;
+      hours     = (int(time) / 60 / 60);
       if (refresh)  {
          if (oseconds==seconds) {
             owatch->Continue();
@@ -1953,8 +2543,18 @@ void AliAnalysisManager::ProgressBar(const char *opname, Long64_t current, Long6
    if(size<10000) fprintf(stderr, "%s [%10s] %4lld ", oname.Data(), progress, ocurrent);
    else if(size<100000) fprintf(stderr, "%s [%10s] %5lld ",oname.Data(), progress, ocurrent);
    else fprintf(stderr, "%s [%10s] %7lld ",oname.Data(), progress, ocurrent);
-   if (time>0.) fprintf(stderr, "[%6.2f %%]   TIME %.2d:%.2d:%.2d             \r", percent, hours, minutes, seconds);
-   else fprintf(stderr, "[%6.2f %%]\r", percent);
+   if (time>0.) {
+     Int_t full   = Int_t(ocurrent > 0 ? 
+                         time * (float(osize)/ocurrent) + .5 : 
+                         99*3600+59*60+59); 
+     Int_t remain = Int_t(full - time);
+     Int_t rsec   = remain % 60;
+     Int_t rmin   = (remain / 60) % 60;
+     Int_t rhour  = (remain / 60 / 60);
+     fprintf(stderr, "[%6.2f %%]   TIME %.2d:%.2d:%.2d  ETA %.2d:%.2d:%.2d%c",
+            percent, hours, minutes, seconds, rhour, rmin, rsec, lastChar);
+   }
+   else fprintf(stderr, "[%6.2f %%]%c", percent, lastChar);
    if (refresh && oneoftwo) oname = nname;
    if (owatch) owatch->Continue();
    if (last) {
@@ -1968,3 +2568,314 @@ void AliAnalysisManager::ProgressBar(const char *opname, Long64_t current, Long6
       fprintf(stderr, "\n");
    }   
 }
+
+//______________________________________________________________________________
+void AliAnalysisManager::DoLoadBranch(const char *name) 
+{
+  // Get tree and load branch if needed.
+  static Long64_t crtEntry = -100;
+
+  if (fAutoBranchHandling || !fTree)
+    return;
+
+  TBranch *br = dynamic_cast<TBranch*>(fTable.FindObject(name));
+  if (!br) {
+    br = fTree->GetBranch(name);
+    if (!br) {
+      Error("DoLoadBranch", "Could not find branch %s",name);
+      return;
+    }
+    fTable.Add(br);
+  }
+  if (br->GetReadEntry()==fCurrentEntry) return;
+  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);
+      crtEntry = fCurrentEntry;
+    }  
+  } else {
+    if (crtEntry != fCurrentEntry) {
+      CountEvent(1,1,0,0);
+      crtEntry = fCurrentEntry;
+    }
+  }
+}
+
+//______________________________________________________________________________
+void AliAnalysisManager::AddStatisticsTask(UInt_t offlineMask)
+{
+// Add the statistics task to the manager.
+  if (fStatistics) {
+     Info("AddStatisticsTask", "Already added");
+     return;
+  }
+  TString line = Form("AliAnalysisTaskStat::AddToManager(%u);", offlineMask);
+  gROOT->ProcessLine(line);
+}  
+
+//______________________________________________________________________________
+void AliAnalysisManager::CountEvent(Int_t ninput, Int_t nprocessed, Int_t nfailed, Int_t naccepted)
+{
+// Bookkeep current event;
+   if (!fStatistics) return;
+   fStatistics->AddInput(ninput);
+   fStatistics->AddProcessed(nprocessed);
+   fStatistics->AddFailed(nfailed);
+   fStatistics->AddAccepted(naccepted);
+}   
+
+//______________________________________________________________________________
+void AliAnalysisManager::AddStatisticsMsg(const char *line)
+{
+// Add a line in the statistics message. If available, the statistics message is written
+// at the end of the SlaveTerminate phase on workers AND at the end of Terminate
+// on the client.
+   if (!strlen(line)) return;
+   if (!fStatisticsMsg.IsNull()) fStatisticsMsg += "\n";
+   fStatisticsMsg += line;
+}
+
+//______________________________________________________________________________
+void AliAnalysisManager::WriteStatisticsMsg(Int_t)
+{
+// If fStatistics is present, write the file in the format ninput_nprocessed_nfailed_naccepted.stat
+   static Bool_t done = kFALSE;
+   if (done) return;
+   done = kTRUE;
+   if (!fStatistics) return;
+   ofstream out;
+   AddStatisticsMsg(Form("Number of input events:        %lld",fStatistics->GetNinput()));
+   AddStatisticsMsg(Form("Number of processed events:    %lld",fStatistics->GetNprocessed()));      
+   AddStatisticsMsg(Form("Number of failed events (I/O): %lld",fStatistics->GetNfailed()));
+   AddStatisticsMsg(Form("Number of accepted events for mask %s: %lld", AliAnalysisStatistics::GetMaskAsString(fStatistics->GetOfflineMask()), fStatistics->GetNaccepted()));
+   out.open(Form("%lld_%lld_%lld_%lld.stat",fStatistics->GetNinput(),
+                 fStatistics->GetNprocessed(),fStatistics->GetNfailed(),
+                 fStatistics->GetNaccepted()), ios::out);      
+   out << fStatisticsMsg << endl;
+   out.close();
+}
+
+//______________________________________________________________________________
+const char* AliAnalysisManager::GetOADBPath()
+{
+// returns the path of the OADB
+// this static function just depends on environment variables
+
+   static TString oadbPath;
+
+   if (gSystem->Getenv("OADB_PATH"))
+      oadbPath = gSystem->Getenv("OADB_PATH");
+   else if (gSystem->Getenv("ALICE_ROOT"))
+      oadbPath.Form("%s/OADB", gSystem->Getenv("ALICE_ROOT"));
+   else
+      ::Fatal("AliAnalysisManager::GetOADBPath", "Cannot figure out AODB path. Define ALICE_ROOT or OADB_PATH!");
+      
+   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");
+}