ROOT logo
/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/* $Id$ */
// Author: Andrei Gheata, 31/05/2006

//==============================================================================
//   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 "AliAnalysisManager.h"

#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>
#include <TChain.h>
#include <TSystem.h>
#include <TROOT.h>
#include <TCanvas.h>
#include <TStopwatch.h>

#include "AliLog.h"
#include "AliAnalysisSelector.h"
#include "AliAnalysisGrid.h"
#include "AliAnalysisTask.h"
#include "AliAnalysisDataContainer.h"
#include "AliAnalysisDataSlot.h"
#include "AliVEventHandler.h"
#include "AliVEventPool.h"
#include "AliSysInfo.h"
#include "AliAnalysisStatistics.h"
#include "AliVEvent.h"
#include "AliHLTTestInputHandler.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(0),
                    fInputEventHandler(0),
                    fOutputEventHandler(0),
                    fMCtruthEventHandler(0),
                    fEventPool(0),
                    fCurrentEntry(-1),
                    fNSysInfo(0),
                    fMode(kLocalAnalysis),
                    fInitOK(kFALSE),
                    fMustClean(kFALSE),
                    fIsRemote(kFALSE),
                    fLocked(kFALSE),
                    fMCLoop(kFALSE),
                    fDebug(0),
                    fSpecialOutputLocation(""), 
                    fTasks(0),
                    fTopTasks(0),
                    fZombies(0),
                    fContainers(0),
                    fInputs(0),
                    fOutputs(0),
                    fParamCont(0),
                    fExchangeCont(0),
                    fDebugOptions(0),
                    fFileDescriptors(new TObjArray()),
                    fCurrentDescriptor(0),
                    fCommonInput(0),
                    fCommonOutput(0),
                    fSelector(0),
                    fGridHandler(0),
                    fExtraFiles(),
                    fFileInfoLog(),
                    fAutoBranchHandling(kTRUE), 
                    fAsyncReading(kFALSE), // 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";
   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();
     fExchangeCont = new TObjArray();
     fGlobals    = new TMap();
   }
   fIOTimer = new TStopwatch();
   fCPUTimer = new TStopwatch();
   fInitTimer = new TStopwatch();
   SetEventLoop(kTRUE);
}

//______________________________________________________________________________
AliAnalysisManager::AliAnalysisManager(const AliAnalysisManager& other)
                   :TNamed(other),
                    fTree(NULL),
                    fInputEventHandler(NULL),
                    fOutputEventHandler(NULL),
                    fMCtruthEventHandler(NULL),
                    fEventPool(NULL),
                    fCurrentEntry(-1),
                    fNSysInfo(0),
                    fMode(other.fMode),
                    fInitOK(other.fInitOK),
                    fMustClean(other.fMustClean),
                    fIsRemote(other.fIsRemote),
                    fLocked(other.fLocked),
                    fMCLoop(other.fMCLoop),
                    fDebug(other.fDebug),
                    fSpecialOutputLocation(""), 
                    fTasks(NULL),
                    fTopTasks(NULL),
                    fZombies(NULL),
                    fContainers(NULL),
                    fInputs(NULL),
                    fOutputs(NULL),
                    fParamCont(NULL),
                    fExchangeCont(NULL),
                    fDebugOptions(NULL),
                    fFileDescriptors(new TObjArray()),
                    fCurrentDescriptor(0),
                    fCommonInput(NULL),
                    fCommonOutput(NULL),
                    fSelector(NULL),
                    fGridHandler(NULL),
                    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);
   fTopTasks   = new TObjArray(*other.fTopTasks);
   fZombies    = new TObjArray(*other.fZombies);
   fContainers = new TObjArray(*other.fContainers);
   fInputs     = new TObjArray(*other.fInputs);
   fOutputs    = new TObjArray(*other.fOutputs);
   fParamCont  = new TObjArray(*other.fParamCont);
   fExchangeCont  = new TObjArray(*other.fExchangeCont);
   fgCommonFileName  = "AnalysisResults.root";
   fgAnalysisManager = this;
}
   
//______________________________________________________________________________
AliAnalysisManager& AliAnalysisManager::operator=(const AliAnalysisManager& other)
{
// Assignment
   if (&other != this) {
      TNamed::operator=(other);
      fInputEventHandler   = other.fInputEventHandler;
      fOutputEventHandler  = other.fOutputEventHandler;
      fMCtruthEventHandler = other.fMCtruthEventHandler;
      fEventPool           = other.fEventPool;
      fTree       = NULL;
      fCurrentEntry = -1;
      fNSysInfo   = other.fNSysInfo;
      fMode       = other.fMode;
      fInitOK     = other.fInitOK;
      fIsRemote   = other.fIsRemote;
      fLocked     = other.fLocked;
      fMCLoop     = other.fMCLoop;
      fDebug      = other.fDebug;
      fTasks      = new TObjArray(*other.fTasks);
      fTopTasks   = new TObjArray(*other.fTopTasks);
      fZombies    = new TObjArray(*other.fZombies);
      fContainers = new TObjArray(*other.fContainers);
      fInputs     = new TObjArray(*other.fInputs);
      fOutputs    = new TObjArray(*other.fOutputs);
      fParamCont  = new TObjArray(*other.fParamCont);
      fExchangeCont  = new TObjArray(*other.fExchangeCont);
      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;
}

//______________________________________________________________________________
AliAnalysisManager::~AliAnalysisManager()
{
// Destructor.
   if (fTasks) {fTasks->Delete(); delete fTasks;}
   delete fTopTasks;
   delete fZombies;
   if (fContainers) {fContainers->Delete(); delete fContainers;}
   delete fInputs;
   delete fOutputs;
   delete fParamCont;
   delete fExchangeCont;
   delete fDebugOptions;
   delete fGridHandler;
   delete fInputEventHandler;
   delete fOutputEventHandler;
   delete fMCtruthEventHandler;
   delete fEventPool;
   if (fgAnalysisManager==this) fgAnalysisManager = NULL;
   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
   if (!fAutoBranchHandling && !fRequestedBranches.IsNull()) {
      TObjArray *arr = fRequestedBranches.Tokenize(",");
      TIter next(arr);
      TObject *obj;
      while ((obj=next()))
         fTree->AddBranchToCache(obj->GetName(),kTRUE);  //<<< add requested branches to cache
      delete arr;   
   } else {
      fTree->AddBranchToCache("*", kTRUE);  //<<< add all branches to cache
   }   
   if (fDebug) {
      Info("CreateReadCache","Read cache enabled %lld bytes with async reading=%d",fCacheSize, (Int_t)fAsyncReading);
   }
   return;
}   

//______________________________________________________________________________
Bool_t AliAnalysisManager::EventLoop(Long64_t nevents)
{
// Initialize an event loop where the data producer is the input handler
// The handler must implement MakeTree creating the tree of events (likely
// memory resident) and generate the current event in the method BeginEvent.
// If the tree is memory resident, the handler should never call TTree::Fill
// method.
   cout << "===== RUNNING IN EVENT LOOP MODE: " << GetName() << endl;
   if (!fInputEventHandler) {
     Error("EventLoop", "No input handler: exiting");
     return kFALSE;
   }
   TTree *tree = new TTree("DummyTree", "Dummy tree for AliAnalysisManager::EventLoop");
   SetExternalLoop(kTRUE);
   if (!Init(tree)) return kFALSE;
   SlaveBegin(tree);
   for (Long64_t iev=0; iev<nevents; iev++)
      ExecAnalysis();
   TList dummyList;
   PackOutput(&dummyList);
   fIsRemote = kTRUE;
   Terminate();
   return kTRUE;
}
      
//______________________________________________________________________________
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;
   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)
{
  // The Init() function is called when the selector needs to initialize
  // a new tree or chain. Typically here the branch addresses of the tree
  // will be set. It is normaly not necessary to make changes to the
  // generated code, but the routine can be extended by the user if needed.
  // Init() will be called many times when running with PROOF.
   Bool_t init = kFALSE;
   if (!tree) return kFALSE; // Should not happen - protected in selector caller
   if (fDebug > 1) {
      printf("->AliAnalysisManager::Init(%s)\n", tree->GetName());
   }
   // Call InitTree of EventHandler
   if (fOutputEventHandler) {
      if (fMode == kProofAnalysis) {
         init = fOutputEventHandler->Init(0x0, "proof");
      } else {
         init = fOutputEventHandler->Init(0x0, "local");
      }
      if (!init) {
         Error("Init", "Output event handler failed to initialize");
         return kFALSE;
      }         
   }
   
   if (fInputEventHandler) {
      if (fMode == kProofAnalysis) {
         init = fInputEventHandler->Init(tree, "proof");
      } else {
         init = fInputEventHandler->Init(tree, "local");
      }
      if (!init) {
         Error("Init", "Input event handler failed to initialize tree"); 
         return kFALSE;
      }         
   } else {
      // If no input event handler we need to get the tree once
      // for the chain
      if(!tree->GetTree()) {
         Long64_t readEntry = tree->LoadTree(0);
         if (readEntry == -2) {
            Error("Init", "Input tree has no entry. Exiting");
            return kFALSE;
         }
      }   
   }

   if (fMCtruthEventHandler) {
      if (fMode == kProofAnalysis) {
         init = fMCtruthEventHandler->Init(0x0, "proof");
      } else {
         init = fMCtruthEventHandler->Init(0x0, "local");
      }
      if (!init) {
         Error("Init", "MC event handler failed to initialize"); 
         return kFALSE;
      }         
   }

   if (!fInitOK) InitAnalysis();
   if (!fInitOK) return kFALSE;
   fTree = tree;
   if (fMode != kProofAnalysis) CreateReadCache();
   else {
     // cholm - here we should re-add to the table or branches 
     fTable.Clear();
   }
   AliAnalysisDataContainer *top = fCommonInput;
   if (!top) top = (AliAnalysisDataContainer*)fInputs->At(0);
   if (!top) {
      Error("Init","No top input container !");
      return kFALSE;
   }
   top->SetData(tree);
   CheckBranches(kFALSE);
   fTable.Rehash(100);
   if (fDebug > 1) {
      printf("<-AliAnalysisManager::Init(%s)\n", tree->GetName());
   }
   return kTRUE;
}

//______________________________________________________________________________
void AliAnalysisManager::SlaveBegin(TTree *tree)
{
  // The SlaveBegin() function is called after the Begin() function.
  // 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;
   TString msg;
   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) {
         // Merging AOD's in PROOF via TProofOutputFile
         if (fDebug > 1) printf("   Initializing AOD output file %s...\n", fOutputEventHandler->GetOutputFileName());
         init = fOutputEventHandler->Init("proof");
         if (!init) msg = "Failed to initialize output handler on worker";
      } else {
         init = fOutputEventHandler->Init("local");
         if (!init) msg = "Failed to initialize output handler";
      }
      initOK &= init;
      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) {
         init = fInputEventHandler->Init("proof");
         if (!init) msg = "Failed to initialize input handler on worker";
      } else {
         init = fInputEventHandler->Init("local");
         if (!init) msg = "Failed to initialize input handler";
      }
      initOK &= init;
      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");
         if (!init) msg = "Failed to initialize MC handler on worker";
      } else {
         init = fMCtruthEventHandler->Init("local");
         if (!init) msg = "Failed to initialize MC handler";
      }
      initOK &= init;
      if (!fSelector) Error("SlaveBegin", "Selector not set");      
      else if (!init) {fSelector->Abort(msg); fSelector->SetStatus(-1);}
   }
   if (curdir) curdir->cd();
   isCalled = kTRUE;
   if (!initOK) return;   
   TIter next(fTasks);
   AliAnalysisTask *task;
   // Call CreateOutputObjects for all tasks
   Bool_t getsysInfo = ((fNSysInfo>0) && (fMode==kLocalAnalysis))?kTRUE:kFALSE;
   if (getsysInfo) AliSysInfo::SetVerbose(kTRUE); 
   Bool_t dirStatus = TH1::AddDirectoryStatus();
   Int_t itask = 0;
   while ((task=(AliAnalysisTask*)next())) {
      gROOT->cd();
      // Start with memory as current dir and make sure by default histograms do not get attached to files.
      TH1::AddDirectory(kFALSE);
      TString pictname = Form("%s_%s", task->GetName(), task->ClassName());
      UInt_t taskvmem = task->GetUniqueID();
      if (taskvmem==0) {
        Warning("SlaveBegin","Setting vmem limit to 1024 MB for %s",pictname.Data());
        taskvmem = 1024*1024;
      } else {
        Info("SlaveBegin","User set vmem limit to %u KB for %s",taskvmem, pictname.Data());
      }
      try {
        ProcInfo_t pinfo;
        gSystem->GetProcInfo(&pinfo);
        Long_t vmem = pinfo.fMemVirtual + pinfo.fMemResident; 
        task->CreateOutputObjects(); // C.L.
        gSystem->GetProcInfo(&pinfo);
        vmem -= pinfo.fMemVirtual + pinfo.fMemResident;
        task->SetUniqueID(taskvmem+vmem);
        if (task->GetUniqueID()>2147483647) {
          Error("SlaveBegin", "Task %s takes more vmem %ld KB than requested %u KB, task disabled", 
                pictname.Data(), -vmem, taskvmem); 
        }
      } catch(std::exception const& e) {
        Error("SlaveBegin", "Caught exception %s in %s, task disabled", e.what(), pictname.Data()); 
        task->SetUniqueID(-1);
      } catch(...) { 
        Error("SlaveBegin", "Caught exception in %s, task disabled", pictname.Data()); 
        task->SetUniqueID(-1);
      }
      //todo
      Int_t ns = task->GetNoutputs();
      for (Int_t islot=0; islot<ns; ++islot) {
        AliAnalysisDataContainer *cont = task->GetOutputSlot(islot)->GetContainer();
        if (!cont)
          continue;
        TSeqCollection *col = dynamic_cast<TSeqCollection*>(cont->GetData());
        if (col) {
          continue;
          Int_t nents = col->GetEntries();
          for (Int_t coli = 0; coli<nents; ++coli) {
            TTree *utree = dynamic_cast<TTree*>(col->At(coli));
            if (utree) {
              TDirectory *dir = utree->GetDirectory();
              if (!dir || dir == gROOT) {
                ::Error("SlaveBegin","Problem: found memory resident tree %s for task %s, disabling task", 
                        utree->GetName(), pictname.Data());
                task->SetUniqueID(-1);
              } else {
                ::Info("SlaveBegin","Setting auto flush for %s for task %s",utree->GetName(),pictname.Data()); 
                utree->SetAutoSave(0);
                utree->SetAutoFlush(-2*1024*1024);
              }
            }
          }
          continue;
        }
        TTree *utree = dynamic_cast<TTree*>(cont->GetData());
        if (utree) {
          TDirectory *dir = utree->GetDirectory();
          if (!dir || dir == gROOT) {
            ::Error("SlaveBegin","Problem: found memory resident tree %s for task %s, disabling task", 
                    utree->GetName(), pictname.Data());
            task->SetUniqueID(-1);
          } else {
            ::Info("SlaveBegin","Setting auto flush for %s for task %s",utree->GetName(),pictname.Data());
            utree->SetAutoSave(0);
            utree->SetAutoFlush(-2*1024*1024);
          }
          continue;
        }
      }

      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++;
   }
   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");
}

//______________________________________________________________________________
Bool_t AliAnalysisManager::Notify()
{
   // The Notify() function is called when a new file is opened. This
   // can be either for a new TTree in a TChain or when when a new TTree
   // 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 of the event handlers
   if (fInputEventHandler) {
       fInputEventHandler->Notify(curfile->GetName());
   }

   if (fOutputEventHandler) {
       fOutputEventHandler->Notify(curfile->GetName());
   }

   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)
{
  // 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
  // specifies which entry in the currently loaded tree is to be processed.
  // It can be passed to either TTree::GetEntry() or TBranch::GetEntry()
  // to read either all or the required parts of the data. When processing
  // keyed objects with PROOF, the object is already loaded and is available
  // via the fObject pointer.
  //
  // This function should contain the "body" of the analysis. It can contain
  // simple or elaborate selection criteria, run algorithms on the data
  // of the event and typically fill histograms.

  // WARNING when a selector is used with a TChain, you must use
  //  the pointer to the current TTree to call GetEntry(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).

   // This method is obsolete. ExecAnalysis is called instead.
   return kTRUE;
}

//______________________________________________________________________________
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;
   }
   TDirectory *cdir = gDirectory;
   gROOT->cd();
   if (fInputEventHandler)   fInputEventHandler  ->Terminate();
   if (fOutputEventHandler)  fOutputEventHandler ->Terminate();
   if (fMCtruthEventHandler) fMCtruthEventHandler->Terminate();
   gROOT->cd();

   // Call FinishTaskOutput() for each event loop task (not called for 
   // post-event loop tasks - use Terminate() fo those)
   TIter nexttask(fTasks);
   AliAnalysisTask *task;
   while ((task=(AliAnalysisTask*)nexttask())) {
      if (!task->IsPostEventLoop()) {
         if (fDebug > 1) printf("->FinishTaskOutput: task %s\n", task->GetName());
         task->FinishTaskOutput();
         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() && output->GetProducer()->IsPostEventLoop()) continue;
         const char *filename = output->GetFileName();
         if (!(strcmp(filename, "default")) && fOutputEventHandler) {
            isManagedByHandler = kTRUE;
            printf("#### Handler output. Extra: %s\n", fExtraFiles.Data());
            filename = fOutputEventHandler->GetOutputFileName();
         }
         // Check if data was posted to this container. If not, issue an error.
         if (!output->GetData() && !isManagedByHandler) {
            Error("PackOutput", "No data for output container %s. Forgot to PostData ?", output->GetName());
            continue;
         }   
         if (!output->IsSpecialOutput()) {
            // Normal outputs
            if (strlen(filename) && !isManagedByHandler) {
               // Backup current folder
               TDirectory *opwd = gDirectory;
               // File resident outputs. 
               // Check first if the file exists.
               TString openoption = "RECREATE";
               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);
               } 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();
                  }   
               }      
               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();
//               }   
               // Clear file list to release object ownership to user.
//               file->Clear();
//               file->Close();
               output->SetFile(NULL);
               // Restore current directory
               if (opwd) opwd->cd();
            } else {
               // Memory-resident outputs   
               if (fDebug > 1) printf("PackOutput %s: memory merge memory resident output\n", filename);
            }   
            AliAnalysisDataWrapper *wrap = 0;
            if (isManagedByHandler) {
               wrap = new AliAnalysisDataWrapper(fOutputEventHandler->GetTree());
               wrap->SetName(output->GetName());
            }   
            else                    wrap =output->ExportData();
            // Output wrappers must NOT delete data after merging - the user owns them
            wrap->SetDeleteData(kFALSE);
            target->Add(wrap);
         } else {
         // Special outputs. The file must be opened and connected to the container.
            TDirectory *opwd = gDirectory;
            TFile *file = output->GetFile();
            if (!file) {
               AliAnalysisTask *producer = output->GetProducer();
               Fatal("PackOutput", 
                     "File %s for special container %s was NOT opened in %s::CreateOutputObjects !!!",
                     output->GetFileName(), output->GetName(), producer->ClassName());
               continue;
            }   
            TString outFilename = file->GetName();
            if (fDebug > 1) printf("PackOutput %s: special output\n", output->GetName());
            if (isManagedByHandler) {
               // Terminate IO for files managed by the output handler
               // file->Write() moved to AOD handler (A.G. 11.01.10)
//               if (file) file->Write();
               if (file && fDebug > 2) {
                  printf("   handled file %s listing content:\n", file->GetName());
                  file->ls();
               }   
               fOutputEventHandler->TerminateIO();
            } else {               
               file->cd();
               // Release object ownership to users after writing data to file
               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);
               } else {
                  if (output->GetData()->InheritsFrom(TTree::Class())) {
                     TTree *tree = (TTree*)output->GetData();
                     tree->SetDirectory(file);
                     tree->AutoSave();
                  } else {
                     output->GetData()->Write();
                  }   
               }      
               if (fDebug > 2) {
                  printf("   file %s listing content:\n", output->GetFileName());
                  file->ls();
               }
               // Clear file list to release object ownership to user.
//               file->Clear();
               file->Close();
               output->SetFile(NULL);
            }
            // Restore current directory
            if (opwd) opwd->cd();
            // Check if a special output location was provided or the output files have to be merged
            if (strlen(fSpecialOutputLocation.Data())) {
               TString remote = fSpecialOutputLocation;
               remote += "/";
               Int_t gid = gROOT->ProcessLine("gProofServ->GetGroupId();");
               if (remote.BeginsWith("alien:")) {
                  gROOT->ProcessLine("TGrid::Connect(\"alien:\", gProofServ->GetUser());");
                  remote += outFilename;
                  remote.ReplaceAll(".root", Form("_%d.root", gid));
               } else {   
                  remote += Form("%s_%d_", gSystem->HostName(), gid);
                  remote += outFilename;
               }   
               if (fDebug > 1) 
                  Info("PackOutput", "Output file for container %s to be copied \n   at: %s. No merging.",
                       output->GetName(), remote.Data());
               TFile::Cp ( outFilename.Data(), remote.Data() );
               // Copy extra outputs
               if (fExtraFiles.Length() && isManagedByHandler) {
                  TObjArray *arr = fExtraFiles.Tokenize(" ");
                  TObjString *os;
                  TIter nextfilename(arr);
                  while ((os=(TObjString*)nextfilename())) {
                     outFilename = os->GetString();
                     remote = fSpecialOutputLocation;
                     remote += "/";
                     if (remote.BeginsWith("alien://")) {
                        remote += outFilename;
                        remote.ReplaceAll(".root", Form("_%d.root", gid));
                     } else {   
                        remote += Form("%s_%d_", gSystem->HostName(), gid);
                        remote += outFilename;
                     }   
                     if (fDebug > 1) 
                        Info("PackOutput", "Extra AOD file %s to be copied \n   at: %s. No merging.",
                             outFilename.Data(), remote.Data());
                     TFile::Cp ( outFilename.Data(), remote.Data() );
                  }   
                  delete arr;
               }   
            } else {
            // No special location specified-> use TProofOutputFile as merging utility
            // The file at this output slot must be opened in CreateOutputObjects
               if (fDebug > 1) printf("   File for container %s to be merged via file merger...\n", output->GetName());
            }
         }      
      }
   } 
   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());
}

//______________________________________________________________________________
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;
   Int_t icont = 0;
   Bool_t inGrid = (fMode == kGridAnalysis)?kTRUE:kFALSE;
   TDirectory *cdir = gDirectory;
   while ((cont=(AliAnalysisDataContainer*)next())) {
      wrap = 0;
      if (cont->GetProducer() && cont->GetProducer()->IsPostEventLoop() && !inGrid) continue;
      if (cont->IsRegisterDataset()) continue;
      const char *filename = cont->GetFileName();
      Bool_t isManagedByHandler = kFALSE;
      if (!(strcmp(filename, "default")) && fOutputEventHandler) {
         isManagedByHandler = kTRUE;
         filename = fOutputEventHandler->GetOutputFileName();
      }
      if (cont->IsSpecialOutput() || inGrid) {
         if (strlen(fSpecialOutputLocation.Data())) continue;
         // Copy merged file from PROOF scratch space. 
         // In case of grid the files are already in the current directory.
         if (!inGrid) {
            if (isManagedByHandler && fExtraFiles.Length()) {
               // Copy extra registered dAOD files.
               TObjArray *arr = fExtraFiles.Tokenize(" ");
               TObjString *os;
               TIter nextfilename(arr);
               while ((os=(TObjString*)nextfilename())) GetFileFromWrapper(os->GetString(), source);
               delete arr;
            }
            if (!GetFileFromWrapper(filename, source)) continue;
         }   
         // Normally we should connect data from the copied file to the
         // corresponding output container, but it is not obvious how to do this
         // automatically if several objects in file...
         TFile *f = (TFile*)gROOT->GetListOfFiles()->FindObject(filename);
         if (!f) f = TFile::Open(filename, "READ");
         if (!f) {
            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();
         if (!folder.IsNull()) f->cd(folder);
         // Try to fetch first an object having the container name.
         obj = gDirectory->Get(cont->GetName());
         if (!obj) {
            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);
         wrap->SetDeleteData(kFALSE);
      }   
      if (!wrap) wrap = (AliAnalysisDataWrapper*)source->FindObject(cont->GetName());
      if (!wrap) {
         Error("ImportWrappers","Container %s not found in analysis output !", cont->GetName());
         continue;
      }
      icont++;
      if (fDebug > 1) {
         printf("   Importing data for container %s\n", cont->GetName());
         if (strlen(filename)) printf("    -> file %s\n", filename);
         else printf("\n");
      }   
      cont->ImportData(wrap);
   }
   if (cdir) cdir->cd();
   fIOTimer->Stop();
   fIOTime += fIOTimer->RealTime();
   if (fDebug > 1) printf("<-AliAnalysisManager::ImportWrappers(): %d containers imported\n", icont);
}

//______________________________________________________________________________
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.");
      return;
   }
   if (fDebug > 1) printf("   Source list contains %d containers\n", source->GetSize());

   if (fMode == kProofAnalysis) ImportWrappers(source);

   TIter next(fOutputs);
   AliAnalysisDataContainer *output;
   while ((output=(AliAnalysisDataContainer*)next())) {
      if (!output->GetData()) continue;
      // Check if there are client tasks that run post event loop
      if (output->HasConsumers()) {
         // Disable event loop semaphore
         output->SetPostEventLoop(kTRUE);
         TObjArray *list = output->GetConsumers();
         Int_t ncons = list->GetEntriesFast();
         for (Int_t i=0; i<ncons; i++) {
            AliAnalysisTask *task = (AliAnalysisTask*)list->At(i);
            task->CheckNotify(kTRUE);
            // 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");
}

//______________________________________________________________________________
void AliAnalysisManager::Terminate()
{
  // The Terminate() function is the last function to be called during
  // 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;
   AliAnalysisDataContainer *output;
   TIter next(fTasks);
   TStopwatch timer;
   Bool_t getsysInfo = ((fNSysInfo>0) && (fMode==kLocalAnalysis))?kTRUE:kFALSE;
   if (getsysInfo) AliSysInfo::SetVerbose(kTRUE);
   // Call Terminate() for tasks
   Int_t itask = 0;
   while (!IsSkipTerminate() && (task=(AliAnalysisTask*)next())) {
      // Save all the canvases produced by the Terminate
      TString pictname = Form("%s_%s", task->GetName(), task->ClassName());
      UInt_t taskvmem = task->GetUniqueID();
      if (taskvmem<2147483648) {
        try { 
          ProcInfo_t pinfo;
          gSystem->GetProcInfo(&pinfo);
          Long_t vmem = pinfo.fMemVirtual + pinfo.fMemResident;
          task->Terminate(); // C.L.
          vmem -= pinfo.fMemVirtual + pinfo.fMemResident;
          task->SetUniqueID(taskvmem+vmem);
          if (task->GetUniqueID()>2147483647) {
            Error("Terminate", "Task %s takes more vmem %ld KB than still available %u KB, task disabled", 
                  pictname.Data(), -vmem, taskvmem); 
          }
        } catch(std::exception const& e) {
          Error("Terminate", "Caught exception %s in %s, task disabled", e.what(), pictname.Data()); 
          task->SetUniqueID(-1);
        } catch(...) { 
          Error("Terminate", "Caught exception in %s, task disabled", pictname.Data()); 
          task->SetUniqueID(-1);
        }
      }
      gROOT->cd();
      if (getsysInfo) 
         AliSysInfo::AddStamp(Form("%s_TERMINATE",task->ClassName()),0, itask, 2);
      itask++;   
      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(kTRUE);
            while (timer.RealTime()<5) {
               timer.Continue();
               gSystem->ProcessEvents();
            }
         }
         Int_t iend = gROOT->GetListOfCanvases()->GetEntries();
         if (iend==0) continue;
         TCanvas *canvas;
         for (Int_t ipict=0; ipict<iend; ipict++) {
            canvas = (TCanvas*)gROOT->GetListOfCanvases()->At(ipict);
            if (!canvas) continue;         
            canvas->SaveAs(Form("%s_%02d.gif", pictname.Data(),ipict));
         } 
         gROOT->GetListOfCanvases()->Delete(); 
      }
   }   
   //
   if (fInputEventHandler)   fInputEventHandler  ->TerminateIO();
   if (fOutputEventHandler)  fOutputEventHandler ->TerminateIO();
   if (fMCtruthEventHandler) fMCtruthEventHandler->TerminateIO();
   gROOT->cd();
   TObjArray *allOutputs = new TObjArray();
   Int_t icont;
   for (icont=0; icont<fOutputs->GetEntriesFast(); icont++) allOutputs->Add(fOutputs->At(icont));
   if (!IsSkipTerminate())
      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++;
      if (fMode == kGridAnalysis && icont<=fOutputs->GetEntriesFast()) continue;
      if (fMode == kProofAnalysis) {
        if (output->IsSpecialOutput() || output->IsRegisterDataset()) continue;
      }  
      const char *filename = output->GetFileName();
      TString openoption = "RECREATE";
      if (!(strcmp(filename, "default"))) continue;
      if (!strlen(filename)) continue;
      if (!output->GetData()) continue;
      TDirectory *opwd = gDirectory;
      TFile *file = output->GetFile();
      if (!file) file = (TFile*)gROOT->GetListOfFiles()->FindObject(filename);
      if (!file) {
	      //if (handlerFile == filename && !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 {
         if (fDebug>1) printf("File <%s> already opened with option: <%s> \n", filename, file->GetOption());
         openoption = file->GetOption();
         if (openoption == "READ") {
            if (fDebug>1) printf("...reopening in UPDATE mode\n");
            file->ReOpen("UPDATE");            
         }
      }   
      if (file->IsZombie()) {
         Error("Terminate", "Cannot open output file %s", filename);
         continue;
      }   
      output->SetFile(file);
      file->cd();
      // Check for a folder request
      TString dir = output->GetFolderName();
      if (!dir.IsNull()) {
         if (!file->GetDirectory(dir)) file->mkdir(dir);
         file->cd(dir);
      }  
      if (fDebug > 1) printf("...writing container %s to file %s:%s\n", output->GetName(), file->GetName(), output->GetFolderName());
      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);
      } else {
         if (output->GetData()->InheritsFrom(TTree::Class())) {
            TTree *tree = (TTree*)output->GetData();
            tree->SetDirectory(gDirectory);
            tree->AutoSave();
         } else {
            output->GetData()->Write();
         }   
      }      
      if (opwd) opwd->cd();
   }
   gROOT->cd();
   next1.Reset();
   TString copiedFiles;
   while ((output=(AliAnalysisDataContainer*)next1())) {
      // Close all files at output
      TDirectory *opwd = gDirectory;
      if (output->GetFile()) {
         // Clear file list to release object ownership to user.
//         output->GetFile()->Clear();
         output->GetFile()->Close();
         // Copy merged outputs in alien if requested
         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");
      TH1 *hist;
      TString cut;
      if (!f.IsZombie()) {
         TTree *tree = AliSysInfo::MakeTree("syswatch.log");
         tree->SetName("syswatch");
         tree->SetMarkerStyle(kCircle);
         tree->SetMarkerColor(kBlue);
         tree->SetMarkerSize(0.5);
         if (!gROOT->IsBatch()) {
            tree->SetAlias("event", "id0");
            tree->SetAlias("task",  "id1");
            tree->SetAlias("stage", "id2");
            // Already defined aliases
            // tree->SetAlias("deltaT","stampSec-stampOldSec");
            // tree->SetAlias("T","stampSec-first");
            // tree->SetAlias("deltaVM","(pI.fMemVirtual-pIOld.fMemVirtual)");
            // tree->SetAlias("VM","pI.fMemVirtual");
            TCanvas *canvas = new TCanvas("SysInfo","SysInfo",10,10,1200,800);
            Int_t npads = 1 /*COO plot for all tasks*/ +
                          fTopTasks->GetEntries() /*Exec plot per task*/ +
                          1 /*Terminate plot for all tasks*/ +
                          1; /*vm plot*/
                          
            Int_t iopt = (Int_t)TMath::Sqrt((Double_t)npads);
            if (npads<iopt*(iopt+1))
               canvas->Divide(iopt, iopt+1, 0.01, 0.01);
            else
               canvas->Divide(iopt+1, iopt+1, 0.01, 0.01);
            Int_t ipad = 1;
            // draw the plot of deltaVM for Exec for each task
            for (itask=0; itask<fTopTasks->GetEntriesFast(); itask++) {
               task = (AliAnalysisTask*)fTopTasks->At(itask);
               canvas->cd(ipad++);
               cut = Form("task==%d && stage==1", itask);
               tree->Draw("deltaVM:event",cut,"", 1234567890, 0);
               hist = (TH1*)gPad->GetListOfPrimitives()->FindObject("htemp");            
               if (hist) {
                  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
            canvas->cd(ipad++);
            tree->SetMarkerStyle(kFullTriangleUp);
            tree->SetMarkerColor(kRed);
            tree->SetMarkerSize(0.8);
            cut = "task>=0 && task<1000 && stage==0";
            tree->Draw("deltaVM:sname",cut,"", 1234567890, 0);
            hist = (TH1*)gPad->GetListOfPrimitives()->FindObject("htemp");            
            if (hist) {
               hist->SetTitle("Memory in CreateOutputObjects()");
               hist->GetYaxis()->SetTitle("deltaVM [MB]");
               hist->GetXaxis()->SetTitle("task");
            }   
            // draw the plot of deltaVM for Terminate for all tasks
            canvas->cd(ipad++);
            tree->SetMarkerStyle(kOpenSquare);
            tree->SetMarkerColor(kMagenta);
            cut = "task>=0 && task<1000 && stage==2";
            tree->Draw("deltaVM:sname",cut,"", 1234567890, 0);
            hist = (TH1*)gPad->GetListOfPrimitives()->FindObject("htemp");
            if (hist) {
               hist->SetTitle("Memory in Terminate()");
               hist->GetYaxis()->SetTitle("deltaVM [MB]");
               hist->GetXaxis()->SetTitle("task");
            }   
            // Full VM profile
            canvas->cd(ipad++);
            tree->SetMarkerStyle(kFullCircle);
            tree->SetMarkerColor(kGreen);
            cut = Form("task==%d && stage==1",fTopTasks->GetEntriesFast()-1);            
            tree->Draw("VM:event",cut,"", 1234567890, 0);
            hist = (TH1*)gPad->GetListOfPrimitives()->FindObject("htemp");
            if (hist) {
               hist->SetTitle("Virtual memory");
               hist->GetYaxis()->SetTitle("VM [MB]");
            }
            canvas->Modified();   
         }   
         tree->SetMarkerStyle(kCircle);
         tree->SetMarkerColor(kBlue);
         tree->SetMarkerSize(0.5);
         tree->Write();
         f.Close();
         delete tree;
      }
      if (crtdir) crtdir->cd();
   }
   // Validate the output files
   if (ValidateOutputFiles() && fIsRemote && fMode!=kProofAnalysis) {
      ofstream out;
      out.open("outputs_valid", ios::out);
      out.close();
   }
   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");
}
//______________________________________________________________________________
void AliAnalysisManager::ProfileTask(Int_t itop, const char *option) const
{
// Profiles the task having the itop index in the list of top (first level) tasks.
   AliAnalysisTask *task = (AliAnalysisTask*)fTopTasks->At(itop);
   if (!task) {
      Error("ProfileTask", "There are only %d top tasks in the manager", fTopTasks->GetEntries());
      return;
   }
   ProfileTask(task->GetName(), option);
}      

//______________________________________________________________________________
void AliAnalysisManager::ProfileTask(const char *name, const char */*option*/) const
{
// Profile a managed task after the execution of the analysis in case NSysInfo
// was used.
   if (gSystem->AccessPathName("syswatch.root")) {
      Error("ProfileTask", "No file syswatch.root found in the current directory");
      return;
   }
   if (gROOT->IsBatch()) return;
   AliAnalysisTask *task = (AliAnalysisTask*)fTopTasks->FindObject(name);
   if (!task) {
      Error("ProfileTask", "No top task named %s known by the manager.", name);
      return;
   }
   Int_t itop = fTopTasks->IndexOf(task);
   Int_t itask = fTasks->IndexOf(task);
   // Create canvas with 2 pads: first draw COO + Terminate, second Exec
   TDirectory *cdir = gDirectory;
   TFile f("syswatch.root");
   TTree *tree = (TTree*)f.Get("syswatch");
   if (!tree) {
      Error("ProfileTask", "No tree named <syswatch> found in file syswatch.root");
      return;
   }   
   tree->SetAlias("event", "id0");
   tree->SetAlias("task",  "id1");
   tree->SetAlias("stage", "id2");
   if (fDebug > 1) printf("=== Profiling task %s (class %s)\n", name, task->ClassName());
   TCanvas *canvas = new TCanvas(Form("profile_%d",itop),Form("Profile of task %s (class %s)",name,task->ClassName()),10,10,800,600);
   canvas->Divide(2, 2, 0.01, 0.01);
   Int_t ipad = 1;
   TString cut;
   TH1 *hist;
   // VM profile for COO and Terminate methods
   canvas->cd(ipad++);
   cut = Form("task==%d && (stage==0 || stage==2)",itask);
   tree->Draw("deltaVM:sname",cut,"", 1234567890, 0);
   hist = (TH1*)gPad->GetListOfPrimitives()->FindObject("htemp");
   if (hist) {
      hist->SetTitle("Alocated VM[MB] for COO and Terminate");
      hist->GetYaxis()->SetTitle("deltaVM [MB]");
      hist->GetXaxis()->SetTitle("method");
   }   
   // CPU profile per event
   canvas->cd(ipad++);
   cut = Form("task==%d && stage==1",itop);
   tree->Draw("deltaT:event",cut,"", 1234567890, 0);
   hist = (TH1*)gPad->GetListOfPrimitives()->FindObject("htemp");
   if (hist) {
      hist->SetTitle("Execution time per event");
      hist->GetYaxis()->SetTitle("CPU/event [s]");
   }   
   // VM profile for Exec
   canvas->cd(ipad++);
   cut = Form("task==%d && stage==1",itop);
   tree->Draw("deltaVM:event",cut,"", 1234567890, 0);
   hist = (TH1*)gPad->GetListOfPrimitives()->FindObject("htemp");
   if (hist) {
      hist->SetTitle("Alocated VM[MB] per event");
      hist->GetYaxis()->SetTitle("deltaVM [MB]");
   }   
   canvas->Modified();
   delete tree;
   f.Close();
   if (cdir) cdir->cd();
}     

//______________________________________________________________________________
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;
   }   
   task->SetActive(kFALSE);
   fTasks->Add(task);
}  

//______________________________________________________________________________
AliAnalysisTask *AliAnalysisManager::GetTask(const char *name) const
{
// Retreive task by name.
   if (!fTasks) return NULL;
   return (AliAnalysisTask*)fTasks->FindObject(name);
}

//______________________________________________________________________________
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)
{
// Create a data container of a certain type. Types can be:
//   kExchangeContainer  = 0, used to exchange data between tasks
//   kInputContainer   = 1, used to store input data
//   kOutputContainer  = 2, used for writing result to a file
// filename: composed by file#folder (e.g. results.root#INCLUSIVE) - will write
// the output object to a folder inside the output file
   if (fContainers->FindObject(name)) {
      Error("CreateContainer","A container named %s already defined !",name);
      return NULL;
   }   
   AliAnalysisDataContainer *cont = new AliAnalysisDataContainer(name, datatype);
   fContainers->Add(cont);
   switch (type) {
      case kInputContainer:
         fInputs->Add(cont);
         break;
      case kOutputContainer:
         fOutputs->Add(cont);
         if (filename && strlen(filename)) {
            cont->SetFileName(filename);
            cont->SetDataOwned(kFALSE);  // data owned by the file
         }   
         break;
      case kParamContainer:
         fParamCont->Add(cont);
         if (filename && strlen(filename)) {
            cont->SetFileName(filename);
            cont->SetDataOwned(kFALSE);  // data owned by the file
         }   
         break;
      case kExchangeContainer:
         cont->SetExchange(kTRUE);
         fExchangeCont->Add(cont);
         cont->SetDataOwned(kFALSE); // data owned by the publisher
         break;   
   }
   return cont;
}
         
//______________________________________________________________________________
Bool_t AliAnalysisManager::ConnectInput(AliAnalysisTask *task, Int_t islot,
                                        AliAnalysisDataContainer *cont)
{
// Connect input of an existing task to a data container.
   if (!task) {
      Error("ConnectInput", "Task pointer is NULL");
      return kFALSE;
   }   
   if (!fTasks->FindObject(task)) {
      AddTask(task);
      Info("ConnectInput", "Task %s was not registered. Now owned by analysis manager", task->GetName());
   } 
   Bool_t connected = task->ConnectInput(islot, cont);
   return connected;
}   

//______________________________________________________________________________
Bool_t AliAnalysisManager::ConnectOutput(AliAnalysisTask *task, Int_t islot,
                                        AliAnalysisDataContainer *cont)
{
// Connect output of an existing task to a data container.
   if (!task) {
      Error("ConnectOutput", "Task pointer is NULL");
      return kFALSE;
   }   
   if (!fTasks->FindObject(task)) {
      AddTask(task);
      Warning("ConnectOutput", "Task %s not registered. Now owned by analysis manager", task->GetName());
   } 
   Bool_t connected = task->ConnectOutput(islot, cont);
   return connected;
}   
                               
//______________________________________________________________________________
void AliAnalysisManager::CleanContainers()
{
// Clean data from all containers that have already finished all client tasks.
   TIter next(fContainers);
   AliAnalysisDataContainer *cont;
   while ((cont=(AliAnalysisDataContainer *)next())) {
      if (cont->IsOwnedData() && 
          cont->IsDataReady() && 
          cont->ClientsExecuted()) cont->DeleteData();
   }
}

//______________________________________________________________________________
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
   if (fInitOK) return kTRUE;
   if (!gSystem->AccessPathName("outputs_valid"))
      gSystem->Unlink("outputs_valid");
   // Check for top tasks (depending only on input data containers)
   if (!fTasks->First()) {
      Error("InitAnalysis", "Analysis has no tasks !");
      return kFALSE;
   }   
   TIter next(fTasks);
   AliAnalysisTask *task;
   AliAnalysisDataContainer *cont;
   Int_t ntop = 0;
   Int_t nzombies = 0;
   Bool_t iszombie = kFALSE;
   Bool_t istop = kTRUE;
   Int_t i;
   while ((task=(AliAnalysisTask*)next())) {
      istop = kTRUE;
      iszombie = kFALSE;
      Int_t ninputs = task->GetNinputs();
      for (i=0; i<ninputs; i++) {
         cont = task->GetInputSlot(i)->GetContainer();
         if (!cont) {
            if (!iszombie) {
               task->SetZombie();
               fZombies->Add(task);
               nzombies++;
               iszombie = kTRUE;
            }   
            Error("InitAnalysis", "Input slot %d of task %s has no container connected ! Declared zombie...", 
                  i, task->GetName()); 
         }
         if (iszombie) continue;
         // Check if cont is an input container
         if (istop && !fInputs->FindObject(cont)) istop=kFALSE;
         // Connect to parent task
      }
      if (istop) {
         ntop++;
         fTopTasks->Add(task);
      }
   }
   if (!ntop) {
      Error("InitAnalysis", "No top task defined. At least one task should be connected only to input containers");
      return kFALSE;
   }                        
   // Check now if there are orphan tasks
   for (i=0; i<ntop; i++) {
      task = (AliAnalysisTask*)fTopTasks->At(i);
      task->SetUsed();
   }
   Int_t norphans = 0;
   next.Reset();
   while ((task=(AliAnalysisTask*)next())) {
      if (!task->IsUsed()) {
         norphans++;
         Warning("InitAnalysis", "Task %s is orphan", task->GetName());
      }   
   }          
   // Check the task hierarchy (no parent task should depend on data provided
   // by a daughter task)
   for (i=0; i<ntop; i++) {
      task = (AliAnalysisTask*)fTopTasks->At(i);
      if (task->CheckCircularDeps()) {
         Error("InitAnalysis", "Found illegal circular dependencies between following tasks:");
         PrintStatus("dep");
         return kFALSE;
      }   
   }
   // Check that all containers feeding post-event loop tasks are in the outputs list
   TIter nextcont(fContainers); // loop over all containers
   while ((cont=(AliAnalysisDataContainer*)nextcont())) {
      if (!cont->IsPostEventLoop() && !fOutputs->FindObject(cont)) {
         if (cont->HasConsumers()) {
         // Check if one of the consumers is post event loop
            TIter nextconsumer(cont->GetConsumers());
            while ((task=(AliAnalysisTask*)nextconsumer())) {
               if (task->IsPostEventLoop()) {
                  fOutputs->Add(cont);
                  break;
               }
            }
         }
      }
   }   
   // Check if all special output containers have a file name provided
   TIter nextout(fOutputs);
   while ((cont=(AliAnalysisDataContainer*)nextout())) {
      if (cont->IsSpecialOutput() && !strlen(cont->GetFileName())) {
         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.
   if (!fInitOK) {
      Info("PrintStatus", "Analysis manager %s not initialized : call InitAnalysis() first", GetName());
      return;
   }   
   Bool_t getsysInfo = ((fNSysInfo>0) && (fMode==kLocalAnalysis))?kTRUE:kFALSE;
   if (getsysInfo) {
      AliSysInfo::SetVerbose(kTRUE);
      Info("PrintStatus", "System information will be collected each %lld events", fNSysInfo);
   }   
   AliAnalysisDataContainer *cont = fCommonInput;
   if (!cont) cont = (AliAnalysisDataContainer*)fInputs->At(0);
   printf("=== TOP CONTAINER:\n");
   cont->PrintContainer(option,0);
   // Reset "touched" flag
   TIter next(fContainers);
   while ((cont = (AliAnalysisDataContainer*)next())) cont->SetTouched(kFALSE);
   TIter nextt(fTasks);
   AliAnalysisTask *task;
   while ((task=(AliAnalysisTask*)nextt()))
      task->SetActive(kFALSE);
  
   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("   ");
    }
  }
}

//______________________________________________________________________________
void AliAnalysisManager::ResetAnalysis()
{
// Reset all execution flags and clean containers.
   TIter nextTask(fTasks);
   AliAnalysisTask *task;
   while ((task=(AliAnalysisTask*)nextTask())) {
      // Clean all tasks
      task->Reset();
   }         
//   CleanContainers();
}

//______________________________________________________________________________
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
// MIX. Process nentries starting from firstentry
   Long64_t retv = 0;
   // Backup current directory and make sure gDirectory points to gROOT
   TDirectory *cdir = gDirectory;
   gROOT->cd();
   if (!fInitOK) {
      Error("StartAnalysis","Analysis manager was not initialized !");
      if (cdir) cdir->cd();
      return -1;
   }
   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;
   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.");
            if (cdir) cdir->cd();
            return -1;
         }
         // Write analysis manager in the analysis file
         cout << "===== RUNNING GRID ANALYSIS: " << GetName() << endl;
         // run local task configuration
         RunLocalInit();
         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;
      if (cdir) cdir->cd();
      ImportWrappers(NULL);
      Terminate();
      if (cdir) cdir->cd();
      return 0;
   }
   TString line;
   SetEventLoop(kFALSE);
   // Enable event loop mode if a tree was provided
   if (tree || fGridHandler || fMode==kMixingAnalysis) SetEventLoop(kTRUE);

   TChain *chain = 0;
   TString ttype = "TTree";
   if (tree && tree->IsA() == TChain::Class()) {
      chain = (TChain*)tree;
      if (!chain || !chain->GetListOfFiles()->First()) {
         Error("StartAnalysis", "Cannot process null or empty chain...");
         if (cdir) cdir->cd();
         return -1;
      }   
      ttype = "TChain";
   }   

   Bool_t getsysInfo = ((fNSysInfo>0) && (fMode==kLocalAnalysis))?kTRUE:kFALSE;
   if (getsysInfo) {
      AliSysInfo::SetVerbose(kTRUE); 
      AliSysInfo::AddStamp("Start", 0);
   }   
   // Initialize locally all tasks (happens for all modes)
   TIter next(fTasks);
   AliAnalysisTask *task;
   RunLocalInit();
   
   switch (fMode) {
      case kLocalAnalysis:
         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");
               return 0;
            }
            ExecAnalysis();
            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;
         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.");
            if (cdir) cdir->cd();
            return -1;
         }   
         line = Form("gProof->AddInput((TObject*)%p);", this);
         gROOT->ProcessLine(line);
         if (chain) {
            chain->SetProof();
            cout << "===== RUNNING PROOF ANALYSIS " << GetName() << " ON CHAIN " << chain->GetName() << endl;
            retv = chain->Process("AliAnalysisSelector", "", nentries, firstentry);
         } else {
            Error("StartAnalysis", "No chain!!! Exiting.");
            if (cdir) cdir->cd();
            return -1;
         }      
         break;
      case 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.");
               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");
            if (cdir) cdir->cd();
            return -1;
         }
         cout << "===== RUNNING EVENT MIXING ANALYSIS " << GetName() << endl;
         fSelector = new AliAnalysisSelector(this);
         while ((chain=fEventPool->GetNextChain())) {
            next.Reset();
            // Call NotifyBinChange for all tasks
            while ((task=(AliAnalysisTask*)next()))
               if (!task->IsPostEventLoop()) task->NotifyBinChange();
            retv = chain->Process(fSelector);
            if (retv < 0) {
               Error("StartAnalysis", "Mixing analysis failed");
               if (cdir) cdir->cd();
               return retv;
            }   
         }
         PackOutput(fSelector->GetOutputList());
         Terminate();
   }
   if (cdir) cdir->cd();
   return retv;
}   

//______________________________________________________________________________
Long64_t AliAnalysisManager::StartAnalysis(const char *type, const char *dataset, Long64_t nentries, Long64_t firstentry)
{
// Start analysis for this manager on a given dataset. Analysis task can be: 
// LOCAL, PROOF or GRID. Process nentries starting from firstentry.
   if (!fInitOK) {
      Error("StartAnalysis","Analysis manager was not initialized !");
      return -1;
   }
   fIsRemote = kTRUE;
   if (fDebug > 1) printf("StartAnalysis %s\n",GetName());
   TString anaType = type;
   anaType.ToLower();
   if (!anaType.Contains("proof")) {
      Error("StartAnalysis", "Cannot process datasets in %s mode. Try PROOF.", type);
      return -1;
   }   
   fMode = kProofAnalysis;
   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();
   }   

   if (!gROOT->GetListOfProofs() || !gROOT->GetListOfProofs()->GetEntries()) {
      Error("StartAnalysis", "No PROOF!!! Exiting.");
      return -1;
   }   

   // Initialize locally all tasks
   RunLocalInit();
      
   line = Form("gProof->AddInput((TObject*)%p);", this);
   gROOT->ProcessLine(line);
   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;
   retv = (Long_t)gROOT->ProcessLine(line);
   return retv;
}   

//______________________________________________________________________________
TFile *AliAnalysisManager::OpenFile(AliAnalysisDataContainer *cont, const char *option, Bool_t ignoreProof)
{
// Opens according the option the file specified by cont->GetFileName() and changes
// current directory to cont->GetFolderName(). If the file was already opened, it
// checks if the option UPDATE was preserved. File open via TProofOutputFile can
// be optionally ignored.
  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
  TString filename = cont->GetFileName();
  TFile *f = NULL;
  if (filename.IsNull()) {
    ::Error("AliAnalysisManager::OpenFile", "No file name specified for container %s", cont->GetName());
    return NULL;
  }
  if (mgr->GetAnalysisType()==AliAnalysisManager::kProofAnalysis && cont->IsSpecialOutput()
      && !ignoreProof)
    f = mgr->OpenProofFile(cont,option);
  else {
    // Check first if the file is already opened
    f = (TFile*)gROOT->GetListOfFiles()->FindObject(filename);
    if (f) {
      // Check if option "UPDATE" was preserved 
      TString opt(option);
      opt.ToUpper();
      if ((opt=="UPDATE") && (opt!=f->GetOption())) 
        ::Info("AliAnalysisManager::OpenFile", "File %s already opened in %s mode!", cont->GetFileName(), f->GetOption());
    } else {
      f = TFile::Open(filename, option);
    }    
  }   
  if (f && !f->IsZombie() && !f->TestBit(TFile::kRecovered)) {
    cont->SetFile(f);
    // Cd to file
    f->cd();
    // Check for a folder request
    TString dir = cont->GetFolderName(); 
    if (!dir.IsNull()) {
      if (!f->GetDirectory(dir)) f->mkdir(dir);
      f->cd(dir);
    }
    return f;
  }
  ::Fatal("AliAnalysisManager::OpenFile", "File %s could not be opened", filename.Data());
  cont->SetFile(NULL);
  return NULL;
}    
 
//______________________________________________________________________________
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) {
        if (strlen(extaod)) filename = extaod;
        filename = fOutputEventHandler->GetOutputFileName();
     }   
     else Fatal("OpenProofFile","No output container. Exiting.");
  }   
  TFile *f = NULL;
  if (fMode!=kProofAnalysis || !fSelector) {
    Fatal("OpenProofFile","Cannot open PROOF file %s: no PROOF or selector",filename.Data());
    return NULL;
  } 
  if (fSpecialOutputLocation.Length()) {
    f = (TFile*)gROOT->GetListOfFiles()->FindObject(filename);
    if (f) {
      // Check if option "UPDATE" was preserved 
      TString opt(option);
      opt.ToUpper();
      if ((opt=="UPDATE") && (opt!=f->GetOption()))
        ::Info("OpenProofFile", "File %s already opened in %s mode!", cont->GetFileName(), f->GetOption());
    } else {
      f = new TFile(filename, option);
    }
    if (f && !f->IsZombie() && !f->TestBit(TFile::kRecovered)) {
      cont->SetFile(f);
      // Cd to file
      f->cd();
      // Check for a folder request
      TString dir = cont->GetFolderName(); 
      if (dir.Length()) {
        if (!f->GetDirectory(dir)) f->mkdir(dir);
        f->cd(dir);
      }      
      return f;
    }
    Fatal("OpenProofFile", "File %s could not be opened", cont->GetFileName());
    cont->SetFile(NULL);
    return NULL;       
  }
  // Check if there is already a proof output file in the output list
  TObject *pof = fSelector->GetOutputList()->FindObject(filename);
  if (pof) {
    // Get the actual file
    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());
       return NULL;
    }   
    // Check if option "UPDATE" was preserved 
    TString opt(option);
    opt.ToUpper();
    if ((opt=="UPDATE") && (opt!=f->GetOption())) 
      Fatal("OpenProofFile", "File %s already opened, but not in UPDATE mode!", cont->GetFileName());
  } else {
    if (cont->IsRegisterDataset()) {
      TString dsetName = filename;
      dsetName.ReplaceAll(".root", cont->GetTitle());
      dsetName.ReplaceAll(":","_");
      if (fDebug>1) printf("Booking dataset: %s\n", dsetName.Data());
      line = Form("TProofOutputFile *pf = new TProofOutputFile(\"%s\", \"DROV\", \"%s\");", filename.Data(), dsetName.Data());
    } else {
      if (fDebug>1) printf("Booking TProofOutputFile: %s to be merged\n", filename.Data());
      line = Form("TProofOutputFile *pf = new TProofOutputFile(\"%s\");", filename.Data());
    }
    if (fDebug > 1) printf("=== %s\n", line.Data());
    gROOT->ProcessLine(line);
    line = Form("pf->OpenFile(\"%s\");", option);
    gROOT->ProcessLine(line);
    f = gFile;
    if (fDebug > 1) {
      gROOT->ProcessLine("pf->Print()");
      printf(" == proof file name: %s", f->GetName());
    }   
    // Add to proof output list
    line = Form("((TList*)%p)->Add(pf);",fSelector->GetOutputList());
    if (fDebug > 1) printf("=== %s\n", line.Data());
    gROOT->ProcessLine(line);
  }
  if (f && !f->IsZombie() && !f->TestBit(TFile::kRecovered)) {
    cont->SetFile(f);
    // Cd to file
    f->cd();
    // Check for a folder request
    TString dir = cont->GetFolderName(); 
    if (!dir.IsNull()) {
      if (!f->GetDirectory(dir)) f->mkdir(dir);
      f->cd(dir);
    }
    return f;
  }
  Fatal("OpenProofFile", "File %s could not be opened", cont->GetFileName());
  cont->SetFile(NULL);  
  return NULL;
}   

//______________________________________________________________________________
void AliAnalysisManager::ExecAnalysis(Option_t *option)
{
// Execute analysis.
   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)) {
         nentries += fTree->GetEntries();
         lastTree = fTree;
      }   
      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 !");
      if (cdir) cdir->cd();
      return;
   }
   fNcalls++;
   AliAnalysisTask *task;
   // Reset the analysis
   ResetAnalysis();
   // Check if the top tree is active.
   if (fTree) {
      if (getsysInfo && ((fNcalls%fNSysInfo)==0)) 
         AliSysInfo::AddStamp("Handlers_BeginEventGroup",fNcalls, 1002, 0);
      TIter next(fTasks);
   // De-activate all tasks (not needed anymore after ResetAnalysis
//      while ((task=(AliAnalysisTask*)next())) task->SetActive(kFALSE);
      AliAnalysisDataContainer *cont = fCommonInput;
      if (!cont) cont = (AliAnalysisDataContainer*)fInputs->At(0);
      if (!cont) {
	      Error("ExecAnalysis","Cannot execute analysis in TSelector mode without at least one top container");
         if (cdir) cdir->cd();
         return;
      }   
      cont->SetData(fTree); // This set activity for all tasks reading only from the top container
      Long64_t entry = fTree->GetTree()->GetReadEntry();      
//
//    Call BeginEvent() for optional input/output and MC services 
      if (fInputEventHandler)   fInputEventHandler  ->BeginEvent(entry);
      if (fOutputEventHandler)  fOutputEventHandler ->BeginEvent(entry);
      if (fMCtruthEventHandler) fMCtruthEventHandler->BeginEvent(entry);
      gROOT->cd();
      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())) {
         task->SetActive(kTRUE);
         if (fDebug >1) {
            cout << "    Executing task " << task->GetName() << endl;
         }
         if (fStatistics) fStatistics->StartTimer(GetTaskIndex(task), task->GetName(), task->ClassName());
         UInt_t taskvmem = task->GetUniqueID();
         if (taskvmem<2147483648) {
           TString pictname = Form("%s_%s", task->GetName(), task->ClassName());
           try { 
             ProcInfo_t pinfo;
             gSystem->GetProcInfo(&pinfo);
             Long_t vmem = pinfo.fMemVirtual + pinfo.fMemResident; 
             task->ExecuteTask(option); // C.L.
             gSystem->GetProcInfo(&pinfo);
             vmem -= pinfo.fMemVirtual + pinfo.fMemResident;
             task->SetUniqueID(taskvmem+vmem);
             if (task->GetUniqueID()>2147483647) {
               Error("ExecAnalysis", "Task %s takes more vmem %ld KB than still available %u KB, task disabled", 
                     pictname.Data(), -vmem, taskvmem); 
             } else if (vmem<0) {
               if (!task->InheritsFrom("AliPhysicsSelectionTask"))
                 Warning("ExecAnalysis", "Task %s uses %ld KB vmem in UserExec (entry=%d), if seen repeatedly check for a memory leak!", pictname.Data(), -vmem, (Int_t)entry); 
             }
           } catch(std::exception const& e) {
             Error("ExecAnalysis", "Caught exception %s in %s, task disabled", e.what(), pictname.Data()); 
             task->SetUniqueID(-1);
           } catch(...) { 
             Error("ExecAnalysis", "Caught exception in %s, task disabled", pictname.Data()); 
             task->SetUniqueID(-1);
           }
         }
         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();
      if (fOutputEventHandler)  fOutputEventHandler ->FinishEvent();
      if (fMCtruthEventHandler) fMCtruthEventHandler->FinishEvent();
      // Gather system information if requested
      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 && ((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);
   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;
   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;
   if (!fCommonOutput) fCommonOutput = CreateContainer("cAUTO_OUTPUT", TTree::Class(), AliAnalysisManager::kOutputContainer, "default");
   fCommonOutput->SetSpecialOutput();
}

//______________________________________________________________________________
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
// connected to any output container, so that the manager can properly register,
// retrieve or merge them when running in distributed mode. The file names are
// separated by blancs. The method has to be called in MyAnalysisTask::LocalInit().
   if (fExtraFiles.Contains(fname)) return;
   if (fExtraFiles.Length()) fExtraFiles += " ";
   fExtraFiles += fname;
}

//______________________________________________________________________________
Bool_t AliAnalysisManager::GetFileFromWrapper(const char *filename, const TList *source)
{
// 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*)%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")){
      TObjArray* array = fullPath_str.Tokenize ( "//" );
      TObjString *strobj = ( TObjString *)array->At(1);
      TObjArray* arrayPort = strobj->GetString().Tokenize ( ":" );
      TObjString *strobjPort = ( TObjString *) arrayPort->At(1);
      fullPath_str.ReplaceAll(strobj->GetString().Data(),"localhost:PORT");
      fullPath_str.ReplaceAll(":PORT",Form(":%s",strobjPort->GetString().Data()));
      if (fDebug > 1) Info("GetFileFromWrapper","Using tunnel from %s to %s",fullPath_str.Data(),filename);
      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 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);
   return gotit;
}

//______________________________________________________________________________
void AliAnalysisManager::GetAnalysisTypeString(TString &type) const
{
// Fill analysis type in the provided string.
   switch (fMode) {
      case kLocalAnalysis:
         type = "local";
         return;
      case kProofAnalysis:
         type = "proof";
         return;
      case kGridAnalysis:
         type = "grid";
         return;
      case kMixingAnalysis:
         type = "mix";
   }
}

//______________________________________________________________________________
Bool_t AliAnalysisManager::ValidateOutputFiles() const
{
// Validate all output files.
   TIter next(fOutputs);
   AliAnalysisDataContainer *output;
   TDirectory *cdir = gDirectory;
   TString openedFiles;
   while ((output=(AliAnalysisDataContainer*)next())) {
      if (output->IsRegisterDataset()) continue;
      TString filename = output->GetFileName();
      if (filename == "default") {
         if (!fOutputEventHandler) continue;
         filename = fOutputEventHandler->GetOutputFileName();
         // Main AOD may not be there
         if (gSystem->AccessPathName(filename)) continue;
      }
      // Check if the file is closed
      if (openedFiles.Contains(filename)) continue;;
      TFile *file = (TFile*)gROOT->GetListOfFiles()->FindObject(filename);
      if (file) {
         Warning("ValidateOutputs", "File %s was not closed. Closing.", filename.Data());
         // Clear file list to release object ownership to user.
//         file->Clear();
         file->Close();
      }
      file = TFile::Open(filename);
      if (!file || file->IsZombie() || file->TestBit(TFile::kRecovered)) {
         Error("ValidateOutputs", "Output file <%s> was not created or invalid", filename.Data());
         if (cdir) cdir->cd();
         return kFALSE;
      }
      file->Close();
      openedFiles += filename;
      openedFiles += " ";
   }
   if (cdir) cdir->cd();
   return kTRUE;
}   

//______________________________________________________________________________
void AliAnalysisManager::ProgressBar(const char *opname, Long64_t current, Long64_t size, TStopwatch * const watch, Bool_t last, Bool_t refresh)
{
// Implements a nice text mode progress bar.
   static Long64_t icount = 0;
   static TString oname;
   static TString nname;
   static Long64_t ocurrent = 0;
   static Long64_t osize = 0;
   static Int_t oseconds = 0;
   static TStopwatch *owatch = 0;
   static Bool_t oneoftwo = kFALSE;
   static Int_t nrefresh = 0;
   static Int_t nchecks = 0;
   static char lastChar = 0;
   const char symbol[4] = {'-','\\','|','/'}; 
   
   if (!lastChar) lastChar = (IsPipe(std::cerr))?'\r':'\n';
   if (!refresh) {
      nrefresh = 0;
      if (!size) return;
      owatch = watch;
      oname = opname;
      ocurrent = TMath::Abs(current);
      osize = TMath::Abs(size);
      if (ocurrent > osize) ocurrent=osize;
   } else {
      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;
   Int_t seconds = 0;
   if (owatch && !last) {
      owatch->Stop();
      time = owatch->RealTime();
      seconds   = int(time) % 60;
      minutes   = (int(time) / 60) % 60;
      hours     = (int(time) / 60 / 60);
      if (refresh)  {
         if (oseconds==seconds) {
            owatch->Continue();
            return;
         }
         oneoftwo = !oneoftwo;   
      }
      oseconds = seconds;   
   }
   if (refresh && oneoftwo) {
      nname = oname;
      if (nchecks <= 0) nchecks = nrefresh+1;
      Int_t pctdone = (Int_t)(100.*nrefresh/nchecks);
      oname = Form("     == %d%% ==", pctdone);
   }         
   Double_t percent = 100.0*ocurrent/osize;
   Int_t nchar = Int_t(percent/10);
   if (nchar>10) nchar=10;
   Int_t i;
   for (i=0; i<nchar; i++)  progress[i] = '=';
   progress[nchar] = symbol[ichar];
   for (i=nchar+1; i<10; i++) progress[i] = ' ';
   progress[10] = '\0';
   oname += "                    ";
   oname.Remove(20);
   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.) {
     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) {
      icount = 0;
      owatch = 0;
      ocurrent = 0;
      osize = 0;
      oseconds = 0;
      oneoftwo = kFALSE;
      nrefresh = 0;
      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");
}

//______________________________________________________________________________
void AliAnalysisManager::InitInputData(AliVEvent* esdEvent, AliVfriendEvent* esdFriend)
{

// Method to propagte to all the connected tasks the HLT event.
// This method expects that the input hanlder is of type HLT, should 
// not be used otherwise

  if (fInputEventHandler)  {
    TString classInputHandler = fInputEventHandler->ClassName();
    if (classInputHandler.Contains("HLT")){
      TObjArray* arrTasks = GetTasks();
      fInputEventHandler->InitTaskInputData(esdEvent, esdFriend, arrTasks);
    }
    else {
      Fatal("PropagateHLTEvent", "Input Handler not of type HLT, we cannot use this method!");
    }
  }
  else {
    Fatal("PropagateHLTEvent", "Input Handler not found, we cannot use this method!");
  }
}
 AliAnalysisManager.cxx:1
 AliAnalysisManager.cxx:2
 AliAnalysisManager.cxx:3
 AliAnalysisManager.cxx:4
 AliAnalysisManager.cxx:5
 AliAnalysisManager.cxx:6
 AliAnalysisManager.cxx:7
 AliAnalysisManager.cxx:8
 AliAnalysisManager.cxx:9
 AliAnalysisManager.cxx:10
 AliAnalysisManager.cxx:11
 AliAnalysisManager.cxx:12
 AliAnalysisManager.cxx:13
 AliAnalysisManager.cxx:14
 AliAnalysisManager.cxx:15
 AliAnalysisManager.cxx:16
 AliAnalysisManager.cxx:17
 AliAnalysisManager.cxx:18
 AliAnalysisManager.cxx:19
 AliAnalysisManager.cxx:20
 AliAnalysisManager.cxx:21
 AliAnalysisManager.cxx:22
 AliAnalysisManager.cxx:23
 AliAnalysisManager.cxx:24
 AliAnalysisManager.cxx:25
 AliAnalysisManager.cxx:26
 AliAnalysisManager.cxx:27
 AliAnalysisManager.cxx:28
 AliAnalysisManager.cxx:29
 AliAnalysisManager.cxx:30
 AliAnalysisManager.cxx:31
 AliAnalysisManager.cxx:32
 AliAnalysisManager.cxx:33
 AliAnalysisManager.cxx:34
 AliAnalysisManager.cxx:35
 AliAnalysisManager.cxx:36
 AliAnalysisManager.cxx:37
 AliAnalysisManager.cxx:38
 AliAnalysisManager.cxx:39
 AliAnalysisManager.cxx:40
 AliAnalysisManager.cxx:41
 AliAnalysisManager.cxx:42
 AliAnalysisManager.cxx:43
 AliAnalysisManager.cxx:44
 AliAnalysisManager.cxx:45
 AliAnalysisManager.cxx:46
 AliAnalysisManager.cxx:47
 AliAnalysisManager.cxx:48
 AliAnalysisManager.cxx:49
 AliAnalysisManager.cxx:50
 AliAnalysisManager.cxx:51
 AliAnalysisManager.cxx:52
 AliAnalysisManager.cxx:53
 AliAnalysisManager.cxx:54
 AliAnalysisManager.cxx:55
 AliAnalysisManager.cxx:56
 AliAnalysisManager.cxx:57
 AliAnalysisManager.cxx:58
 AliAnalysisManager.cxx:59
 AliAnalysisManager.cxx:60
 AliAnalysisManager.cxx:61
 AliAnalysisManager.cxx:62
 AliAnalysisManager.cxx:63
 AliAnalysisManager.cxx:64
 AliAnalysisManager.cxx:65
 AliAnalysisManager.cxx:66
 AliAnalysisManager.cxx:67
 AliAnalysisManager.cxx:68
 AliAnalysisManager.cxx:69
 AliAnalysisManager.cxx:70
 AliAnalysisManager.cxx:71
 AliAnalysisManager.cxx:72
 AliAnalysisManager.cxx:73
 AliAnalysisManager.cxx:74
 AliAnalysisManager.cxx:75
 AliAnalysisManager.cxx:76
 AliAnalysisManager.cxx:77
 AliAnalysisManager.cxx:78
 AliAnalysisManager.cxx:79
 AliAnalysisManager.cxx:80
 AliAnalysisManager.cxx:81
 AliAnalysisManager.cxx:82
 AliAnalysisManager.cxx:83
 AliAnalysisManager.cxx:84
 AliAnalysisManager.cxx:85
 AliAnalysisManager.cxx:86
 AliAnalysisManager.cxx:87
 AliAnalysisManager.cxx:88
 AliAnalysisManager.cxx:89
 AliAnalysisManager.cxx:90
 AliAnalysisManager.cxx:91
 AliAnalysisManager.cxx:92
 AliAnalysisManager.cxx:93
 AliAnalysisManager.cxx:94
 AliAnalysisManager.cxx:95
 AliAnalysisManager.cxx:96
 AliAnalysisManager.cxx:97
 AliAnalysisManager.cxx:98
 AliAnalysisManager.cxx:99
 AliAnalysisManager.cxx:100
 AliAnalysisManager.cxx:101
 AliAnalysisManager.cxx:102
 AliAnalysisManager.cxx:103
 AliAnalysisManager.cxx:104
 AliAnalysisManager.cxx:105
 AliAnalysisManager.cxx:106
 AliAnalysisManager.cxx:107
 AliAnalysisManager.cxx:108
 AliAnalysisManager.cxx:109
 AliAnalysisManager.cxx:110
 AliAnalysisManager.cxx:111
 AliAnalysisManager.cxx:112
 AliAnalysisManager.cxx:113
 AliAnalysisManager.cxx:114
 AliAnalysisManager.cxx:115
 AliAnalysisManager.cxx:116
 AliAnalysisManager.cxx:117
 AliAnalysisManager.cxx:118
 AliAnalysisManager.cxx:119
 AliAnalysisManager.cxx:120
 AliAnalysisManager.cxx:121
 AliAnalysisManager.cxx:122
 AliAnalysisManager.cxx:123
 AliAnalysisManager.cxx:124
 AliAnalysisManager.cxx:125
 AliAnalysisManager.cxx:126
 AliAnalysisManager.cxx:127
 AliAnalysisManager.cxx:128
 AliAnalysisManager.cxx:129
 AliAnalysisManager.cxx:130
 AliAnalysisManager.cxx:131
 AliAnalysisManager.cxx:132
 AliAnalysisManager.cxx:133
 AliAnalysisManager.cxx:134
 AliAnalysisManager.cxx:135
 AliAnalysisManager.cxx:136
 AliAnalysisManager.cxx:137
 AliAnalysisManager.cxx:138
 AliAnalysisManager.cxx:139
 AliAnalysisManager.cxx:140
 AliAnalysisManager.cxx:141
 AliAnalysisManager.cxx:142
 AliAnalysisManager.cxx:143
 AliAnalysisManager.cxx:144
 AliAnalysisManager.cxx:145
 AliAnalysisManager.cxx:146
 AliAnalysisManager.cxx:147
 AliAnalysisManager.cxx:148
 AliAnalysisManager.cxx:149
 AliAnalysisManager.cxx:150
 AliAnalysisManager.cxx:151
 AliAnalysisManager.cxx:152
 AliAnalysisManager.cxx:153
 AliAnalysisManager.cxx:154
 AliAnalysisManager.cxx:155
 AliAnalysisManager.cxx:156
 AliAnalysisManager.cxx:157
 AliAnalysisManager.cxx:158
 AliAnalysisManager.cxx:159
 AliAnalysisManager.cxx:160
 AliAnalysisManager.cxx:161
 AliAnalysisManager.cxx:162
 AliAnalysisManager.cxx:163
 AliAnalysisManager.cxx:164
 AliAnalysisManager.cxx:165
 AliAnalysisManager.cxx:166
 AliAnalysisManager.cxx:167
 AliAnalysisManager.cxx:168
 AliAnalysisManager.cxx:169
 AliAnalysisManager.cxx:170
 AliAnalysisManager.cxx:171
 AliAnalysisManager.cxx:172
 AliAnalysisManager.cxx:173
 AliAnalysisManager.cxx:174
 AliAnalysisManager.cxx:175
 AliAnalysisManager.cxx:176
 AliAnalysisManager.cxx:177
 AliAnalysisManager.cxx:178
 AliAnalysisManager.cxx:179
 AliAnalysisManager.cxx:180
 AliAnalysisManager.cxx:181
 AliAnalysisManager.cxx:182
 AliAnalysisManager.cxx:183
 AliAnalysisManager.cxx:184
 AliAnalysisManager.cxx:185
 AliAnalysisManager.cxx:186
 AliAnalysisManager.cxx:187
 AliAnalysisManager.cxx:188
 AliAnalysisManager.cxx:189
 AliAnalysisManager.cxx:190
 AliAnalysisManager.cxx:191
 AliAnalysisManager.cxx:192
 AliAnalysisManager.cxx:193
 AliAnalysisManager.cxx:194
 AliAnalysisManager.cxx:195
 AliAnalysisManager.cxx:196
 AliAnalysisManager.cxx:197
 AliAnalysisManager.cxx:198
 AliAnalysisManager.cxx:199
 AliAnalysisManager.cxx:200
 AliAnalysisManager.cxx:201
 AliAnalysisManager.cxx:202
 AliAnalysisManager.cxx:203
 AliAnalysisManager.cxx:204
 AliAnalysisManager.cxx:205
 AliAnalysisManager.cxx:206
 AliAnalysisManager.cxx:207
 AliAnalysisManager.cxx:208
 AliAnalysisManager.cxx:209
 AliAnalysisManager.cxx:210
 AliAnalysisManager.cxx:211
 AliAnalysisManager.cxx:212
 AliAnalysisManager.cxx:213
 AliAnalysisManager.cxx:214
 AliAnalysisManager.cxx:215
 AliAnalysisManager.cxx:216
 AliAnalysisManager.cxx:217
 AliAnalysisManager.cxx:218
 AliAnalysisManager.cxx:219
 AliAnalysisManager.cxx:220
 AliAnalysisManager.cxx:221
 AliAnalysisManager.cxx:222
 AliAnalysisManager.cxx:223
 AliAnalysisManager.cxx:224
 AliAnalysisManager.cxx:225
 AliAnalysisManager.cxx:226
 AliAnalysisManager.cxx:227
 AliAnalysisManager.cxx:228
 AliAnalysisManager.cxx:229
 AliAnalysisManager.cxx:230
 AliAnalysisManager.cxx:231
 AliAnalysisManager.cxx:232
 AliAnalysisManager.cxx:233
 AliAnalysisManager.cxx:234
 AliAnalysisManager.cxx:235
 AliAnalysisManager.cxx:236
 AliAnalysisManager.cxx:237
 AliAnalysisManager.cxx:238
 AliAnalysisManager.cxx:239
 AliAnalysisManager.cxx:240
 AliAnalysisManager.cxx:241
 AliAnalysisManager.cxx:242
 AliAnalysisManager.cxx:243
 AliAnalysisManager.cxx:244
 AliAnalysisManager.cxx:245
 AliAnalysisManager.cxx:246
 AliAnalysisManager.cxx:247
 AliAnalysisManager.cxx:248
 AliAnalysisManager.cxx:249
 AliAnalysisManager.cxx:250
 AliAnalysisManager.cxx:251
 AliAnalysisManager.cxx:252
 AliAnalysisManager.cxx:253
 AliAnalysisManager.cxx:254
 AliAnalysisManager.cxx:255
 AliAnalysisManager.cxx:256
 AliAnalysisManager.cxx:257
 AliAnalysisManager.cxx:258
 AliAnalysisManager.cxx:259
 AliAnalysisManager.cxx:260
 AliAnalysisManager.cxx:261
 AliAnalysisManager.cxx:262
 AliAnalysisManager.cxx:263
 AliAnalysisManager.cxx:264
 AliAnalysisManager.cxx:265
 AliAnalysisManager.cxx:266
 AliAnalysisManager.cxx:267
 AliAnalysisManager.cxx:268
 AliAnalysisManager.cxx:269
 AliAnalysisManager.cxx:270
 AliAnalysisManager.cxx:271
 AliAnalysisManager.cxx:272
 AliAnalysisManager.cxx:273
 AliAnalysisManager.cxx:274
 AliAnalysisManager.cxx:275
 AliAnalysisManager.cxx:276
 AliAnalysisManager.cxx:277
 AliAnalysisManager.cxx:278
 AliAnalysisManager.cxx:279
 AliAnalysisManager.cxx:280
 AliAnalysisManager.cxx:281
 AliAnalysisManager.cxx:282
 AliAnalysisManager.cxx:283
 AliAnalysisManager.cxx:284
 AliAnalysisManager.cxx:285
 AliAnalysisManager.cxx:286
 AliAnalysisManager.cxx:287
 AliAnalysisManager.cxx:288
 AliAnalysisManager.cxx:289
 AliAnalysisManager.cxx:290
 AliAnalysisManager.cxx:291
 AliAnalysisManager.cxx:292
 AliAnalysisManager.cxx:293
 AliAnalysisManager.cxx:294
 AliAnalysisManager.cxx:295
 AliAnalysisManager.cxx:296
 AliAnalysisManager.cxx:297
 AliAnalysisManager.cxx:298
 AliAnalysisManager.cxx:299
 AliAnalysisManager.cxx:300
 AliAnalysisManager.cxx:301
 AliAnalysisManager.cxx:302
 AliAnalysisManager.cxx:303
 AliAnalysisManager.cxx:304
 AliAnalysisManager.cxx:305
 AliAnalysisManager.cxx:306
 AliAnalysisManager.cxx:307
 AliAnalysisManager.cxx:308
 AliAnalysisManager.cxx:309
 AliAnalysisManager.cxx:310
 AliAnalysisManager.cxx:311
 AliAnalysisManager.cxx:312
 AliAnalysisManager.cxx:313
 AliAnalysisManager.cxx:314
 AliAnalysisManager.cxx:315
 AliAnalysisManager.cxx:316
 AliAnalysisManager.cxx:317
 AliAnalysisManager.cxx:318
 AliAnalysisManager.cxx:319
 AliAnalysisManager.cxx:320
 AliAnalysisManager.cxx:321
 AliAnalysisManager.cxx:322
 AliAnalysisManager.cxx:323
 AliAnalysisManager.cxx:324
 AliAnalysisManager.cxx:325
 AliAnalysisManager.cxx:326
 AliAnalysisManager.cxx:327
 AliAnalysisManager.cxx:328
 AliAnalysisManager.cxx:329
 AliAnalysisManager.cxx:330
 AliAnalysisManager.cxx:331
 AliAnalysisManager.cxx:332
 AliAnalysisManager.cxx:333
 AliAnalysisManager.cxx:334
 AliAnalysisManager.cxx:335
 AliAnalysisManager.cxx:336
 AliAnalysisManager.cxx:337
 AliAnalysisManager.cxx:338
 AliAnalysisManager.cxx:339
 AliAnalysisManager.cxx:340
 AliAnalysisManager.cxx:341
 AliAnalysisManager.cxx:342
 AliAnalysisManager.cxx:343
 AliAnalysisManager.cxx:344
 AliAnalysisManager.cxx:345
 AliAnalysisManager.cxx:346
 AliAnalysisManager.cxx:347
 AliAnalysisManager.cxx:348
 AliAnalysisManager.cxx:349
 AliAnalysisManager.cxx:350
 AliAnalysisManager.cxx:351
 AliAnalysisManager.cxx:352
 AliAnalysisManager.cxx:353
 AliAnalysisManager.cxx:354
 AliAnalysisManager.cxx:355
 AliAnalysisManager.cxx:356
 AliAnalysisManager.cxx:357
 AliAnalysisManager.cxx:358
 AliAnalysisManager.cxx:359
 AliAnalysisManager.cxx:360
 AliAnalysisManager.cxx:361
 AliAnalysisManager.cxx:362
 AliAnalysisManager.cxx:363
 AliAnalysisManager.cxx:364
 AliAnalysisManager.cxx:365
 AliAnalysisManager.cxx:366
 AliAnalysisManager.cxx:367
 AliAnalysisManager.cxx:368
 AliAnalysisManager.cxx:369
 AliAnalysisManager.cxx:370
 AliAnalysisManager.cxx:371
 AliAnalysisManager.cxx:372
 AliAnalysisManager.cxx:373
 AliAnalysisManager.cxx:374
 AliAnalysisManager.cxx:375
 AliAnalysisManager.cxx:376
 AliAnalysisManager.cxx:377
 AliAnalysisManager.cxx:378
 AliAnalysisManager.cxx:379
 AliAnalysisManager.cxx:380
 AliAnalysisManager.cxx:381
 AliAnalysisManager.cxx:382
 AliAnalysisManager.cxx:383
 AliAnalysisManager.cxx:384
 AliAnalysisManager.cxx:385
 AliAnalysisManager.cxx:386
 AliAnalysisManager.cxx:387
 AliAnalysisManager.cxx:388
 AliAnalysisManager.cxx:389
 AliAnalysisManager.cxx:390
 AliAnalysisManager.cxx:391
 AliAnalysisManager.cxx:392
 AliAnalysisManager.cxx:393
 AliAnalysisManager.cxx:394
 AliAnalysisManager.cxx:395
 AliAnalysisManager.cxx:396
 AliAnalysisManager.cxx:397
 AliAnalysisManager.cxx:398
 AliAnalysisManager.cxx:399
 AliAnalysisManager.cxx:400
 AliAnalysisManager.cxx:401
 AliAnalysisManager.cxx:402
 AliAnalysisManager.cxx:403
 AliAnalysisManager.cxx:404
 AliAnalysisManager.cxx:405
 AliAnalysisManager.cxx:406
 AliAnalysisManager.cxx:407
 AliAnalysisManager.cxx:408
 AliAnalysisManager.cxx:409
 AliAnalysisManager.cxx:410
 AliAnalysisManager.cxx:411
 AliAnalysisManager.cxx:412
 AliAnalysisManager.cxx:413
 AliAnalysisManager.cxx:414
 AliAnalysisManager.cxx:415
 AliAnalysisManager.cxx:416
 AliAnalysisManager.cxx:417
 AliAnalysisManager.cxx:418
 AliAnalysisManager.cxx:419
 AliAnalysisManager.cxx:420
 AliAnalysisManager.cxx:421
 AliAnalysisManager.cxx:422
 AliAnalysisManager.cxx:423
 AliAnalysisManager.cxx:424
 AliAnalysisManager.cxx:425
 AliAnalysisManager.cxx:426
 AliAnalysisManager.cxx:427
 AliAnalysisManager.cxx:428
 AliAnalysisManager.cxx:429
 AliAnalysisManager.cxx:430
 AliAnalysisManager.cxx:431
 AliAnalysisManager.cxx:432
 AliAnalysisManager.cxx:433
 AliAnalysisManager.cxx:434
 AliAnalysisManager.cxx:435
 AliAnalysisManager.cxx:436
 AliAnalysisManager.cxx:437
 AliAnalysisManager.cxx:438
 AliAnalysisManager.cxx:439
 AliAnalysisManager.cxx:440
 AliAnalysisManager.cxx:441
 AliAnalysisManager.cxx:442
 AliAnalysisManager.cxx:443
 AliAnalysisManager.cxx:444
 AliAnalysisManager.cxx:445
 AliAnalysisManager.cxx:446
 AliAnalysisManager.cxx:447
 AliAnalysisManager.cxx:448
 AliAnalysisManager.cxx:449
 AliAnalysisManager.cxx:450
 AliAnalysisManager.cxx:451
 AliAnalysisManager.cxx:452
 AliAnalysisManager.cxx:453
 AliAnalysisManager.cxx:454
 AliAnalysisManager.cxx:455
 AliAnalysisManager.cxx:456
 AliAnalysisManager.cxx:457
 AliAnalysisManager.cxx:458
 AliAnalysisManager.cxx:459
 AliAnalysisManager.cxx:460
 AliAnalysisManager.cxx:461
 AliAnalysisManager.cxx:462
 AliAnalysisManager.cxx:463
 AliAnalysisManager.cxx:464
 AliAnalysisManager.cxx:465
 AliAnalysisManager.cxx:466
 AliAnalysisManager.cxx:467
 AliAnalysisManager.cxx:468
 AliAnalysisManager.cxx:469
 AliAnalysisManager.cxx:470
 AliAnalysisManager.cxx:471
 AliAnalysisManager.cxx:472
 AliAnalysisManager.cxx:473
 AliAnalysisManager.cxx:474
 AliAnalysisManager.cxx:475
 AliAnalysisManager.cxx:476
 AliAnalysisManager.cxx:477
 AliAnalysisManager.cxx:478
 AliAnalysisManager.cxx:479
 AliAnalysisManager.cxx:480
 AliAnalysisManager.cxx:481
 AliAnalysisManager.cxx:482
 AliAnalysisManager.cxx:483
 AliAnalysisManager.cxx:484
 AliAnalysisManager.cxx:485
 AliAnalysisManager.cxx:486
 AliAnalysisManager.cxx:487
 AliAnalysisManager.cxx:488
 AliAnalysisManager.cxx:489
 AliAnalysisManager.cxx:490
 AliAnalysisManager.cxx:491
 AliAnalysisManager.cxx:492
 AliAnalysisManager.cxx:493
 AliAnalysisManager.cxx:494
 AliAnalysisManager.cxx:495
 AliAnalysisManager.cxx:496
 AliAnalysisManager.cxx:497
 AliAnalysisManager.cxx:498
 AliAnalysisManager.cxx:499
 AliAnalysisManager.cxx:500
 AliAnalysisManager.cxx:501
 AliAnalysisManager.cxx:502
 AliAnalysisManager.cxx:503
 AliAnalysisManager.cxx:504
 AliAnalysisManager.cxx:505
 AliAnalysisManager.cxx:506
 AliAnalysisManager.cxx:507
 AliAnalysisManager.cxx:508
 AliAnalysisManager.cxx:509
 AliAnalysisManager.cxx:510
 AliAnalysisManager.cxx:511
 AliAnalysisManager.cxx:512
 AliAnalysisManager.cxx:513
 AliAnalysisManager.cxx:514
 AliAnalysisManager.cxx:515
 AliAnalysisManager.cxx:516
 AliAnalysisManager.cxx:517
 AliAnalysisManager.cxx:518
 AliAnalysisManager.cxx:519
 AliAnalysisManager.cxx:520
 AliAnalysisManager.cxx:521
 AliAnalysisManager.cxx:522
 AliAnalysisManager.cxx:523
 AliAnalysisManager.cxx:524
 AliAnalysisManager.cxx:525
 AliAnalysisManager.cxx:526
 AliAnalysisManager.cxx:527
 AliAnalysisManager.cxx:528
 AliAnalysisManager.cxx:529
 AliAnalysisManager.cxx:530
 AliAnalysisManager.cxx:531
 AliAnalysisManager.cxx:532
 AliAnalysisManager.cxx:533
 AliAnalysisManager.cxx:534
 AliAnalysisManager.cxx:535
 AliAnalysisManager.cxx:536
 AliAnalysisManager.cxx:537
 AliAnalysisManager.cxx:538
 AliAnalysisManager.cxx:539
 AliAnalysisManager.cxx:540
 AliAnalysisManager.cxx:541
 AliAnalysisManager.cxx:542
 AliAnalysisManager.cxx:543
 AliAnalysisManager.cxx:544
 AliAnalysisManager.cxx:545
 AliAnalysisManager.cxx:546
 AliAnalysisManager.cxx:547
 AliAnalysisManager.cxx:548
 AliAnalysisManager.cxx:549
 AliAnalysisManager.cxx:550
 AliAnalysisManager.cxx:551
 AliAnalysisManager.cxx:552
 AliAnalysisManager.cxx:553
 AliAnalysisManager.cxx:554
 AliAnalysisManager.cxx:555
 AliAnalysisManager.cxx:556
 AliAnalysisManager.cxx:557
 AliAnalysisManager.cxx:558
 AliAnalysisManager.cxx:559
 AliAnalysisManager.cxx:560
 AliAnalysisManager.cxx:561
 AliAnalysisManager.cxx:562
 AliAnalysisManager.cxx:563
 AliAnalysisManager.cxx:564
 AliAnalysisManager.cxx:565
 AliAnalysisManager.cxx:566
 AliAnalysisManager.cxx:567
 AliAnalysisManager.cxx:568
 AliAnalysisManager.cxx:569
 AliAnalysisManager.cxx:570
 AliAnalysisManager.cxx:571
 AliAnalysisManager.cxx:572
 AliAnalysisManager.cxx:573
 AliAnalysisManager.cxx:574
 AliAnalysisManager.cxx:575
 AliAnalysisManager.cxx:576
 AliAnalysisManager.cxx:577
 AliAnalysisManager.cxx:578
 AliAnalysisManager.cxx:579
 AliAnalysisManager.cxx:580
 AliAnalysisManager.cxx:581
 AliAnalysisManager.cxx:582
 AliAnalysisManager.cxx:583
 AliAnalysisManager.cxx:584
 AliAnalysisManager.cxx:585
 AliAnalysisManager.cxx:586
 AliAnalysisManager.cxx:587
 AliAnalysisManager.cxx:588
 AliAnalysisManager.cxx:589
 AliAnalysisManager.cxx:590
 AliAnalysisManager.cxx:591
 AliAnalysisManager.cxx:592
 AliAnalysisManager.cxx:593
 AliAnalysisManager.cxx:594
 AliAnalysisManager.cxx:595
 AliAnalysisManager.cxx:596
 AliAnalysisManager.cxx:597
 AliAnalysisManager.cxx:598
 AliAnalysisManager.cxx:599
 AliAnalysisManager.cxx:600
 AliAnalysisManager.cxx:601
 AliAnalysisManager.cxx:602
 AliAnalysisManager.cxx:603
 AliAnalysisManager.cxx:604
 AliAnalysisManager.cxx:605
 AliAnalysisManager.cxx:606
 AliAnalysisManager.cxx:607
 AliAnalysisManager.cxx:608
 AliAnalysisManager.cxx:609
 AliAnalysisManager.cxx:610
 AliAnalysisManager.cxx:611
 AliAnalysisManager.cxx:612
 AliAnalysisManager.cxx:613
 AliAnalysisManager.cxx:614
 AliAnalysisManager.cxx:615
 AliAnalysisManager.cxx:616
 AliAnalysisManager.cxx:617
 AliAnalysisManager.cxx:618
 AliAnalysisManager.cxx:619
 AliAnalysisManager.cxx:620
 AliAnalysisManager.cxx:621
 AliAnalysisManager.cxx:622
 AliAnalysisManager.cxx:623
 AliAnalysisManager.cxx:624
 AliAnalysisManager.cxx:625
 AliAnalysisManager.cxx:626
 AliAnalysisManager.cxx:627
 AliAnalysisManager.cxx:628
 AliAnalysisManager.cxx:629
 AliAnalysisManager.cxx:630
 AliAnalysisManager.cxx:631
 AliAnalysisManager.cxx:632
 AliAnalysisManager.cxx:633
 AliAnalysisManager.cxx:634
 AliAnalysisManager.cxx:635
 AliAnalysisManager.cxx:636
 AliAnalysisManager.cxx:637
 AliAnalysisManager.cxx:638
 AliAnalysisManager.cxx:639
 AliAnalysisManager.cxx:640
 AliAnalysisManager.cxx:641
 AliAnalysisManager.cxx:642
 AliAnalysisManager.cxx:643
 AliAnalysisManager.cxx:644
 AliAnalysisManager.cxx:645
 AliAnalysisManager.cxx:646
 AliAnalysisManager.cxx:647
 AliAnalysisManager.cxx:648
 AliAnalysisManager.cxx:649
 AliAnalysisManager.cxx:650
 AliAnalysisManager.cxx:651
 AliAnalysisManager.cxx:652
 AliAnalysisManager.cxx:653
 AliAnalysisManager.cxx:654
 AliAnalysisManager.cxx:655
 AliAnalysisManager.cxx:656
 AliAnalysisManager.cxx:657
 AliAnalysisManager.cxx:658
 AliAnalysisManager.cxx:659
 AliAnalysisManager.cxx:660
 AliAnalysisManager.cxx:661
 AliAnalysisManager.cxx:662
 AliAnalysisManager.cxx:663
 AliAnalysisManager.cxx:664
 AliAnalysisManager.cxx:665
 AliAnalysisManager.cxx:666
 AliAnalysisManager.cxx:667
 AliAnalysisManager.cxx:668
 AliAnalysisManager.cxx:669
 AliAnalysisManager.cxx:670
 AliAnalysisManager.cxx:671
 AliAnalysisManager.cxx:672
 AliAnalysisManager.cxx:673
 AliAnalysisManager.cxx:674
 AliAnalysisManager.cxx:675
 AliAnalysisManager.cxx:676
 AliAnalysisManager.cxx:677
 AliAnalysisManager.cxx:678
 AliAnalysisManager.cxx:679
 AliAnalysisManager.cxx:680
 AliAnalysisManager.cxx:681
 AliAnalysisManager.cxx:682
 AliAnalysisManager.cxx:683
 AliAnalysisManager.cxx:684
 AliAnalysisManager.cxx:685
 AliAnalysisManager.cxx:686
 AliAnalysisManager.cxx:687
 AliAnalysisManager.cxx:688
 AliAnalysisManager.cxx:689
 AliAnalysisManager.cxx:690
 AliAnalysisManager.cxx:691
 AliAnalysisManager.cxx:692
 AliAnalysisManager.cxx:693
 AliAnalysisManager.cxx:694
 AliAnalysisManager.cxx:695
 AliAnalysisManager.cxx:696
 AliAnalysisManager.cxx:697
 AliAnalysisManager.cxx:698
 AliAnalysisManager.cxx:699
 AliAnalysisManager.cxx:700
 AliAnalysisManager.cxx:701
 AliAnalysisManager.cxx:702
 AliAnalysisManager.cxx:703
 AliAnalysisManager.cxx:704
 AliAnalysisManager.cxx:705
 AliAnalysisManager.cxx:706
 AliAnalysisManager.cxx:707
 AliAnalysisManager.cxx:708
 AliAnalysisManager.cxx:709
 AliAnalysisManager.cxx:710
 AliAnalysisManager.cxx:711
 AliAnalysisManager.cxx:712
 AliAnalysisManager.cxx:713
 AliAnalysisManager.cxx:714
 AliAnalysisManager.cxx:715
 AliAnalysisManager.cxx:716
 AliAnalysisManager.cxx:717
 AliAnalysisManager.cxx:718
 AliAnalysisManager.cxx:719
 AliAnalysisManager.cxx:720
 AliAnalysisManager.cxx:721
 AliAnalysisManager.cxx:722
 AliAnalysisManager.cxx:723
 AliAnalysisManager.cxx:724
 AliAnalysisManager.cxx:725
 AliAnalysisManager.cxx:726
 AliAnalysisManager.cxx:727
 AliAnalysisManager.cxx:728
 AliAnalysisManager.cxx:729
 AliAnalysisManager.cxx:730
 AliAnalysisManager.cxx:731
 AliAnalysisManager.cxx:732
 AliAnalysisManager.cxx:733
 AliAnalysisManager.cxx:734
 AliAnalysisManager.cxx:735
 AliAnalysisManager.cxx:736
 AliAnalysisManager.cxx:737
 AliAnalysisManager.cxx:738
 AliAnalysisManager.cxx:739
 AliAnalysisManager.cxx:740
 AliAnalysisManager.cxx:741
 AliAnalysisManager.cxx:742
 AliAnalysisManager.cxx:743
 AliAnalysisManager.cxx:744
 AliAnalysisManager.cxx:745
 AliAnalysisManager.cxx:746
 AliAnalysisManager.cxx:747
 AliAnalysisManager.cxx:748
 AliAnalysisManager.cxx:749
 AliAnalysisManager.cxx:750
 AliAnalysisManager.cxx:751
 AliAnalysisManager.cxx:752
 AliAnalysisManager.cxx:753
 AliAnalysisManager.cxx:754
 AliAnalysisManager.cxx:755
 AliAnalysisManager.cxx:756
 AliAnalysisManager.cxx:757
 AliAnalysisManager.cxx:758
 AliAnalysisManager.cxx:759
 AliAnalysisManager.cxx:760
 AliAnalysisManager.cxx:761
 AliAnalysisManager.cxx:762
 AliAnalysisManager.cxx:763
 AliAnalysisManager.cxx:764
 AliAnalysisManager.cxx:765
 AliAnalysisManager.cxx:766
 AliAnalysisManager.cxx:767
 AliAnalysisManager.cxx:768
 AliAnalysisManager.cxx:769
 AliAnalysisManager.cxx:770
 AliAnalysisManager.cxx:771
 AliAnalysisManager.cxx:772
 AliAnalysisManager.cxx:773
 AliAnalysisManager.cxx:774
 AliAnalysisManager.cxx:775
 AliAnalysisManager.cxx:776
 AliAnalysisManager.cxx:777
 AliAnalysisManager.cxx:778
 AliAnalysisManager.cxx:779
 AliAnalysisManager.cxx:780
 AliAnalysisManager.cxx:781
 AliAnalysisManager.cxx:782
 AliAnalysisManager.cxx:783
 AliAnalysisManager.cxx:784
 AliAnalysisManager.cxx:785
 AliAnalysisManager.cxx:786
 AliAnalysisManager.cxx:787
 AliAnalysisManager.cxx:788
 AliAnalysisManager.cxx:789
 AliAnalysisManager.cxx:790
 AliAnalysisManager.cxx:791
 AliAnalysisManager.cxx:792
 AliAnalysisManager.cxx:793
 AliAnalysisManager.cxx:794
 AliAnalysisManager.cxx:795
 AliAnalysisManager.cxx:796
 AliAnalysisManager.cxx:797
 AliAnalysisManager.cxx:798
 AliAnalysisManager.cxx:799
 AliAnalysisManager.cxx:800
 AliAnalysisManager.cxx:801
 AliAnalysisManager.cxx:802
 AliAnalysisManager.cxx:803
 AliAnalysisManager.cxx:804
 AliAnalysisManager.cxx:805
 AliAnalysisManager.cxx:806
 AliAnalysisManager.cxx:807
 AliAnalysisManager.cxx:808
 AliAnalysisManager.cxx:809
 AliAnalysisManager.cxx:810
 AliAnalysisManager.cxx:811
 AliAnalysisManager.cxx:812
 AliAnalysisManager.cxx:813
 AliAnalysisManager.cxx:814
 AliAnalysisManager.cxx:815
 AliAnalysisManager.cxx:816
 AliAnalysisManager.cxx:817
 AliAnalysisManager.cxx:818
 AliAnalysisManager.cxx:819
 AliAnalysisManager.cxx:820
 AliAnalysisManager.cxx:821
 AliAnalysisManager.cxx:822
 AliAnalysisManager.cxx:823
 AliAnalysisManager.cxx:824
 AliAnalysisManager.cxx:825
 AliAnalysisManager.cxx:826
 AliAnalysisManager.cxx:827
 AliAnalysisManager.cxx:828
 AliAnalysisManager.cxx:829
 AliAnalysisManager.cxx:830
 AliAnalysisManager.cxx:831
 AliAnalysisManager.cxx:832
 AliAnalysisManager.cxx:833
 AliAnalysisManager.cxx:834
 AliAnalysisManager.cxx:835
 AliAnalysisManager.cxx:836
 AliAnalysisManager.cxx:837
 AliAnalysisManager.cxx:838
 AliAnalysisManager.cxx:839
 AliAnalysisManager.cxx:840
 AliAnalysisManager.cxx:841
 AliAnalysisManager.cxx:842
 AliAnalysisManager.cxx:843
 AliAnalysisManager.cxx:844
 AliAnalysisManager.cxx:845
 AliAnalysisManager.cxx:846
 AliAnalysisManager.cxx:847
 AliAnalysisManager.cxx:848
 AliAnalysisManager.cxx:849
 AliAnalysisManager.cxx:850
 AliAnalysisManager.cxx:851
 AliAnalysisManager.cxx:852
 AliAnalysisManager.cxx:853
 AliAnalysisManager.cxx:854
 AliAnalysisManager.cxx:855
 AliAnalysisManager.cxx:856
 AliAnalysisManager.cxx:857
 AliAnalysisManager.cxx:858
 AliAnalysisManager.cxx:859
 AliAnalysisManager.cxx:860
 AliAnalysisManager.cxx:861
 AliAnalysisManager.cxx:862
 AliAnalysisManager.cxx:863
 AliAnalysisManager.cxx:864
 AliAnalysisManager.cxx:865
 AliAnalysisManager.cxx:866
 AliAnalysisManager.cxx:867
 AliAnalysisManager.cxx:868
 AliAnalysisManager.cxx:869
 AliAnalysisManager.cxx:870
 AliAnalysisManager.cxx:871
 AliAnalysisManager.cxx:872
 AliAnalysisManager.cxx:873
 AliAnalysisManager.cxx:874
 AliAnalysisManager.cxx:875
 AliAnalysisManager.cxx:876
 AliAnalysisManager.cxx:877
 AliAnalysisManager.cxx:878
 AliAnalysisManager.cxx:879
 AliAnalysisManager.cxx:880
 AliAnalysisManager.cxx:881
 AliAnalysisManager.cxx:882
 AliAnalysisManager.cxx:883
 AliAnalysisManager.cxx:884
 AliAnalysisManager.cxx:885
 AliAnalysisManager.cxx:886
 AliAnalysisManager.cxx:887
 AliAnalysisManager.cxx:888
 AliAnalysisManager.cxx:889
 AliAnalysisManager.cxx:890
 AliAnalysisManager.cxx:891
 AliAnalysisManager.cxx:892
 AliAnalysisManager.cxx:893
 AliAnalysisManager.cxx:894
 AliAnalysisManager.cxx:895
 AliAnalysisManager.cxx:896
 AliAnalysisManager.cxx:897
 AliAnalysisManager.cxx:898
 AliAnalysisManager.cxx:899
 AliAnalysisManager.cxx:900
 AliAnalysisManager.cxx:901
 AliAnalysisManager.cxx:902
 AliAnalysisManager.cxx:903
 AliAnalysisManager.cxx:904
 AliAnalysisManager.cxx:905
 AliAnalysisManager.cxx:906
 AliAnalysisManager.cxx:907
 AliAnalysisManager.cxx:908
 AliAnalysisManager.cxx:909
 AliAnalysisManager.cxx:910
 AliAnalysisManager.cxx:911
 AliAnalysisManager.cxx:912
 AliAnalysisManager.cxx:913
 AliAnalysisManager.cxx:914
 AliAnalysisManager.cxx:915
 AliAnalysisManager.cxx:916
 AliAnalysisManager.cxx:917
 AliAnalysisManager.cxx:918
 AliAnalysisManager.cxx:919
 AliAnalysisManager.cxx:920
 AliAnalysisManager.cxx:921
 AliAnalysisManager.cxx:922
 AliAnalysisManager.cxx:923
 AliAnalysisManager.cxx:924
 AliAnalysisManager.cxx:925
 AliAnalysisManager.cxx:926
 AliAnalysisManager.cxx:927
 AliAnalysisManager.cxx:928
 AliAnalysisManager.cxx:929
 AliAnalysisManager.cxx:930
 AliAnalysisManager.cxx:931
 AliAnalysisManager.cxx:932
 AliAnalysisManager.cxx:933
 AliAnalysisManager.cxx:934
 AliAnalysisManager.cxx:935
 AliAnalysisManager.cxx:936
 AliAnalysisManager.cxx:937
 AliAnalysisManager.cxx:938
 AliAnalysisManager.cxx:939
 AliAnalysisManager.cxx:940
 AliAnalysisManager.cxx:941
 AliAnalysisManager.cxx:942
 AliAnalysisManager.cxx:943
 AliAnalysisManager.cxx:944
 AliAnalysisManager.cxx:945
 AliAnalysisManager.cxx:946
 AliAnalysisManager.cxx:947
 AliAnalysisManager.cxx:948
 AliAnalysisManager.cxx:949
 AliAnalysisManager.cxx:950
 AliAnalysisManager.cxx:951
 AliAnalysisManager.cxx:952
 AliAnalysisManager.cxx:953
 AliAnalysisManager.cxx:954
 AliAnalysisManager.cxx:955
 AliAnalysisManager.cxx:956
 AliAnalysisManager.cxx:957
 AliAnalysisManager.cxx:958
 AliAnalysisManager.cxx:959
 AliAnalysisManager.cxx:960
 AliAnalysisManager.cxx:961
 AliAnalysisManager.cxx:962
 AliAnalysisManager.cxx:963
 AliAnalysisManager.cxx:964
 AliAnalysisManager.cxx:965
 AliAnalysisManager.cxx:966
 AliAnalysisManager.cxx:967
 AliAnalysisManager.cxx:968
 AliAnalysisManager.cxx:969
 AliAnalysisManager.cxx:970
 AliAnalysisManager.cxx:971
 AliAnalysisManager.cxx:972
 AliAnalysisManager.cxx:973
 AliAnalysisManager.cxx:974
 AliAnalysisManager.cxx:975
 AliAnalysisManager.cxx:976
 AliAnalysisManager.cxx:977
 AliAnalysisManager.cxx:978
 AliAnalysisManager.cxx:979
 AliAnalysisManager.cxx:980
 AliAnalysisManager.cxx:981
 AliAnalysisManager.cxx:982
 AliAnalysisManager.cxx:983
 AliAnalysisManager.cxx:984
 AliAnalysisManager.cxx:985
 AliAnalysisManager.cxx:986
 AliAnalysisManager.cxx:987
 AliAnalysisManager.cxx:988
 AliAnalysisManager.cxx:989
 AliAnalysisManager.cxx:990
 AliAnalysisManager.cxx:991
 AliAnalysisManager.cxx:992
 AliAnalysisManager.cxx:993
 AliAnalysisManager.cxx:994
 AliAnalysisManager.cxx:995
 AliAnalysisManager.cxx:996
 AliAnalysisManager.cxx:997
 AliAnalysisManager.cxx:998
 AliAnalysisManager.cxx:999
 AliAnalysisManager.cxx:1000
 AliAnalysisManager.cxx:1001
 AliAnalysisManager.cxx:1002
 AliAnalysisManager.cxx:1003
 AliAnalysisManager.cxx:1004
 AliAnalysisManager.cxx:1005
 AliAnalysisManager.cxx:1006
 AliAnalysisManager.cxx:1007
 AliAnalysisManager.cxx:1008
 AliAnalysisManager.cxx:1009
 AliAnalysisManager.cxx:1010
 AliAnalysisManager.cxx:1011
 AliAnalysisManager.cxx:1012
 AliAnalysisManager.cxx:1013
 AliAnalysisManager.cxx:1014
 AliAnalysisManager.cxx:1015
 AliAnalysisManager.cxx:1016
 AliAnalysisManager.cxx:1017
 AliAnalysisManager.cxx:1018
 AliAnalysisManager.cxx:1019
 AliAnalysisManager.cxx:1020
 AliAnalysisManager.cxx:1021
 AliAnalysisManager.cxx:1022
 AliAnalysisManager.cxx:1023
 AliAnalysisManager.cxx:1024
 AliAnalysisManager.cxx:1025
 AliAnalysisManager.cxx:1026
 AliAnalysisManager.cxx:1027
 AliAnalysisManager.cxx:1028
 AliAnalysisManager.cxx:1029
 AliAnalysisManager.cxx:1030
 AliAnalysisManager.cxx:1031
 AliAnalysisManager.cxx:1032
 AliAnalysisManager.cxx:1033
 AliAnalysisManager.cxx:1034
 AliAnalysisManager.cxx:1035
 AliAnalysisManager.cxx:1036
 AliAnalysisManager.cxx:1037
 AliAnalysisManager.cxx:1038
 AliAnalysisManager.cxx:1039
 AliAnalysisManager.cxx:1040
 AliAnalysisManager.cxx:1041
 AliAnalysisManager.cxx:1042
 AliAnalysisManager.cxx:1043
 AliAnalysisManager.cxx:1044
 AliAnalysisManager.cxx:1045
 AliAnalysisManager.cxx:1046
 AliAnalysisManager.cxx:1047
 AliAnalysisManager.cxx:1048
 AliAnalysisManager.cxx:1049
 AliAnalysisManager.cxx:1050
 AliAnalysisManager.cxx:1051
 AliAnalysisManager.cxx:1052
 AliAnalysisManager.cxx:1053
 AliAnalysisManager.cxx:1054
 AliAnalysisManager.cxx:1055
 AliAnalysisManager.cxx:1056
 AliAnalysisManager.cxx:1057
 AliAnalysisManager.cxx:1058
 AliAnalysisManager.cxx:1059
 AliAnalysisManager.cxx:1060
 AliAnalysisManager.cxx:1061
 AliAnalysisManager.cxx:1062
 AliAnalysisManager.cxx:1063
 AliAnalysisManager.cxx:1064
 AliAnalysisManager.cxx:1065
 AliAnalysisManager.cxx:1066
 AliAnalysisManager.cxx:1067
 AliAnalysisManager.cxx:1068
 AliAnalysisManager.cxx:1069
 AliAnalysisManager.cxx:1070
 AliAnalysisManager.cxx:1071
 AliAnalysisManager.cxx:1072
 AliAnalysisManager.cxx:1073
 AliAnalysisManager.cxx:1074
 AliAnalysisManager.cxx:1075
 AliAnalysisManager.cxx:1076
 AliAnalysisManager.cxx:1077
 AliAnalysisManager.cxx:1078
 AliAnalysisManager.cxx:1079
 AliAnalysisManager.cxx:1080
 AliAnalysisManager.cxx:1081
 AliAnalysisManager.cxx:1082
 AliAnalysisManager.cxx:1083
 AliAnalysisManager.cxx:1084
 AliAnalysisManager.cxx:1085
 AliAnalysisManager.cxx:1086
 AliAnalysisManager.cxx:1087
 AliAnalysisManager.cxx:1088
 AliAnalysisManager.cxx:1089
 AliAnalysisManager.cxx:1090
 AliAnalysisManager.cxx:1091
 AliAnalysisManager.cxx:1092
 AliAnalysisManager.cxx:1093
 AliAnalysisManager.cxx:1094
 AliAnalysisManager.cxx:1095
 AliAnalysisManager.cxx:1096
 AliAnalysisManager.cxx:1097
 AliAnalysisManager.cxx:1098
 AliAnalysisManager.cxx:1099
 AliAnalysisManager.cxx:1100
 AliAnalysisManager.cxx:1101
 AliAnalysisManager.cxx:1102
 AliAnalysisManager.cxx:1103
 AliAnalysisManager.cxx:1104
 AliAnalysisManager.cxx:1105
 AliAnalysisManager.cxx:1106
 AliAnalysisManager.cxx:1107
 AliAnalysisManager.cxx:1108
 AliAnalysisManager.cxx:1109
 AliAnalysisManager.cxx:1110
 AliAnalysisManager.cxx:1111
 AliAnalysisManager.cxx:1112
 AliAnalysisManager.cxx:1113
 AliAnalysisManager.cxx:1114
 AliAnalysisManager.cxx:1115
 AliAnalysisManager.cxx:1116
 AliAnalysisManager.cxx:1117
 AliAnalysisManager.cxx:1118
 AliAnalysisManager.cxx:1119
 AliAnalysisManager.cxx:1120
 AliAnalysisManager.cxx:1121
 AliAnalysisManager.cxx:1122
 AliAnalysisManager.cxx:1123
 AliAnalysisManager.cxx:1124
 AliAnalysisManager.cxx:1125
 AliAnalysisManager.cxx:1126
 AliAnalysisManager.cxx:1127
 AliAnalysisManager.cxx:1128
 AliAnalysisManager.cxx:1129
 AliAnalysisManager.cxx:1130
 AliAnalysisManager.cxx:1131
 AliAnalysisManager.cxx:1132
 AliAnalysisManager.cxx:1133
 AliAnalysisManager.cxx:1134
 AliAnalysisManager.cxx:1135
 AliAnalysisManager.cxx:1136
 AliAnalysisManager.cxx:1137
 AliAnalysisManager.cxx:1138
 AliAnalysisManager.cxx:1139
 AliAnalysisManager.cxx:1140
 AliAnalysisManager.cxx:1141
 AliAnalysisManager.cxx:1142
 AliAnalysisManager.cxx:1143
 AliAnalysisManager.cxx:1144
 AliAnalysisManager.cxx:1145
 AliAnalysisManager.cxx:1146
 AliAnalysisManager.cxx:1147
 AliAnalysisManager.cxx:1148
 AliAnalysisManager.cxx:1149
 AliAnalysisManager.cxx:1150
 AliAnalysisManager.cxx:1151
 AliAnalysisManager.cxx:1152
 AliAnalysisManager.cxx:1153
 AliAnalysisManager.cxx:1154
 AliAnalysisManager.cxx:1155
 AliAnalysisManager.cxx:1156
 AliAnalysisManager.cxx:1157
 AliAnalysisManager.cxx:1158
 AliAnalysisManager.cxx:1159
 AliAnalysisManager.cxx:1160
 AliAnalysisManager.cxx:1161
 AliAnalysisManager.cxx:1162
 AliAnalysisManager.cxx:1163
 AliAnalysisManager.cxx:1164
 AliAnalysisManager.cxx:1165
 AliAnalysisManager.cxx:1166
 AliAnalysisManager.cxx:1167
 AliAnalysisManager.cxx:1168
 AliAnalysisManager.cxx:1169
 AliAnalysisManager.cxx:1170
 AliAnalysisManager.cxx:1171
 AliAnalysisManager.cxx:1172
 AliAnalysisManager.cxx:1173
 AliAnalysisManager.cxx:1174
 AliAnalysisManager.cxx:1175
 AliAnalysisManager.cxx:1176
 AliAnalysisManager.cxx:1177
 AliAnalysisManager.cxx:1178
 AliAnalysisManager.cxx:1179
 AliAnalysisManager.cxx:1180
 AliAnalysisManager.cxx:1181
 AliAnalysisManager.cxx:1182
 AliAnalysisManager.cxx:1183
 AliAnalysisManager.cxx:1184
 AliAnalysisManager.cxx:1185
 AliAnalysisManager.cxx:1186
 AliAnalysisManager.cxx:1187
 AliAnalysisManager.cxx:1188
 AliAnalysisManager.cxx:1189
 AliAnalysisManager.cxx:1190
 AliAnalysisManager.cxx:1191
 AliAnalysisManager.cxx:1192
 AliAnalysisManager.cxx:1193
 AliAnalysisManager.cxx:1194
 AliAnalysisManager.cxx:1195
 AliAnalysisManager.cxx:1196
 AliAnalysisManager.cxx:1197
 AliAnalysisManager.cxx:1198
 AliAnalysisManager.cxx:1199
 AliAnalysisManager.cxx:1200
 AliAnalysisManager.cxx:1201
 AliAnalysisManager.cxx:1202
 AliAnalysisManager.cxx:1203
 AliAnalysisManager.cxx:1204
 AliAnalysisManager.cxx:1205
 AliAnalysisManager.cxx:1206
 AliAnalysisManager.cxx:1207
 AliAnalysisManager.cxx:1208
 AliAnalysisManager.cxx:1209
 AliAnalysisManager.cxx:1210
 AliAnalysisManager.cxx:1211
 AliAnalysisManager.cxx:1212
 AliAnalysisManager.cxx:1213
 AliAnalysisManager.cxx:1214
 AliAnalysisManager.cxx:1215
 AliAnalysisManager.cxx:1216
 AliAnalysisManager.cxx:1217
 AliAnalysisManager.cxx:1218
 AliAnalysisManager.cxx:1219
 AliAnalysisManager.cxx:1220
 AliAnalysisManager.cxx:1221
 AliAnalysisManager.cxx:1222
 AliAnalysisManager.cxx:1223
 AliAnalysisManager.cxx:1224
 AliAnalysisManager.cxx:1225
 AliAnalysisManager.cxx:1226
 AliAnalysisManager.cxx:1227
 AliAnalysisManager.cxx:1228
 AliAnalysisManager.cxx:1229
 AliAnalysisManager.cxx:1230
 AliAnalysisManager.cxx:1231
 AliAnalysisManager.cxx:1232
 AliAnalysisManager.cxx:1233
 AliAnalysisManager.cxx:1234
 AliAnalysisManager.cxx:1235
 AliAnalysisManager.cxx:1236
 AliAnalysisManager.cxx:1237
 AliAnalysisManager.cxx:1238
 AliAnalysisManager.cxx:1239
 AliAnalysisManager.cxx:1240
 AliAnalysisManager.cxx:1241
 AliAnalysisManager.cxx:1242
 AliAnalysisManager.cxx:1243
 AliAnalysisManager.cxx:1244
 AliAnalysisManager.cxx:1245
 AliAnalysisManager.cxx:1246
 AliAnalysisManager.cxx:1247
 AliAnalysisManager.cxx:1248
 AliAnalysisManager.cxx:1249
 AliAnalysisManager.cxx:1250
 AliAnalysisManager.cxx:1251
 AliAnalysisManager.cxx:1252
 AliAnalysisManager.cxx:1253
 AliAnalysisManager.cxx:1254
 AliAnalysisManager.cxx:1255
 AliAnalysisManager.cxx:1256
 AliAnalysisManager.cxx:1257
 AliAnalysisManager.cxx:1258
 AliAnalysisManager.cxx:1259
 AliAnalysisManager.cxx:1260
 AliAnalysisManager.cxx:1261
 AliAnalysisManager.cxx:1262
 AliAnalysisManager.cxx:1263
 AliAnalysisManager.cxx:1264
 AliAnalysisManager.cxx:1265
 AliAnalysisManager.cxx:1266
 AliAnalysisManager.cxx:1267
 AliAnalysisManager.cxx:1268
 AliAnalysisManager.cxx:1269
 AliAnalysisManager.cxx:1270
 AliAnalysisManager.cxx:1271
 AliAnalysisManager.cxx:1272
 AliAnalysisManager.cxx:1273
 AliAnalysisManager.cxx:1274
 AliAnalysisManager.cxx:1275
 AliAnalysisManager.cxx:1276
 AliAnalysisManager.cxx:1277
 AliAnalysisManager.cxx:1278
 AliAnalysisManager.cxx:1279
 AliAnalysisManager.cxx:1280
 AliAnalysisManager.cxx:1281
 AliAnalysisManager.cxx:1282
 AliAnalysisManager.cxx:1283
 AliAnalysisManager.cxx:1284
 AliAnalysisManager.cxx:1285
 AliAnalysisManager.cxx:1286
 AliAnalysisManager.cxx:1287
 AliAnalysisManager.cxx:1288
 AliAnalysisManager.cxx:1289
 AliAnalysisManager.cxx:1290
 AliAnalysisManager.cxx:1291
 AliAnalysisManager.cxx:1292
 AliAnalysisManager.cxx:1293
 AliAnalysisManager.cxx:1294
 AliAnalysisManager.cxx:1295
 AliAnalysisManager.cxx:1296
 AliAnalysisManager.cxx:1297
 AliAnalysisManager.cxx:1298
 AliAnalysisManager.cxx:1299
 AliAnalysisManager.cxx:1300
 AliAnalysisManager.cxx:1301
 AliAnalysisManager.cxx:1302
 AliAnalysisManager.cxx:1303
 AliAnalysisManager.cxx:1304
 AliAnalysisManager.cxx:1305
 AliAnalysisManager.cxx:1306
 AliAnalysisManager.cxx:1307
 AliAnalysisManager.cxx:1308
 AliAnalysisManager.cxx:1309
 AliAnalysisManager.cxx:1310
 AliAnalysisManager.cxx:1311
 AliAnalysisManager.cxx:1312
 AliAnalysisManager.cxx:1313
 AliAnalysisManager.cxx:1314
 AliAnalysisManager.cxx:1315
 AliAnalysisManager.cxx:1316
 AliAnalysisManager.cxx:1317
 AliAnalysisManager.cxx:1318
 AliAnalysisManager.cxx:1319
 AliAnalysisManager.cxx:1320
 AliAnalysisManager.cxx:1321
 AliAnalysisManager.cxx:1322
 AliAnalysisManager.cxx:1323
 AliAnalysisManager.cxx:1324
 AliAnalysisManager.cxx:1325
 AliAnalysisManager.cxx:1326
 AliAnalysisManager.cxx:1327
 AliAnalysisManager.cxx:1328
 AliAnalysisManager.cxx:1329
 AliAnalysisManager.cxx:1330
 AliAnalysisManager.cxx:1331
 AliAnalysisManager.cxx:1332
 AliAnalysisManager.cxx:1333
 AliAnalysisManager.cxx:1334
 AliAnalysisManager.cxx:1335
 AliAnalysisManager.cxx:1336
 AliAnalysisManager.cxx:1337
 AliAnalysisManager.cxx:1338
 AliAnalysisManager.cxx:1339
 AliAnalysisManager.cxx:1340
 AliAnalysisManager.cxx:1341
 AliAnalysisManager.cxx:1342
 AliAnalysisManager.cxx:1343
 AliAnalysisManager.cxx:1344
 AliAnalysisManager.cxx:1345
 AliAnalysisManager.cxx:1346
 AliAnalysisManager.cxx:1347
 AliAnalysisManager.cxx:1348
 AliAnalysisManager.cxx:1349
 AliAnalysisManager.cxx:1350
 AliAnalysisManager.cxx:1351
 AliAnalysisManager.cxx:1352
 AliAnalysisManager.cxx:1353
 AliAnalysisManager.cxx:1354
 AliAnalysisManager.cxx:1355
 AliAnalysisManager.cxx:1356
 AliAnalysisManager.cxx:1357
 AliAnalysisManager.cxx:1358
 AliAnalysisManager.cxx:1359
 AliAnalysisManager.cxx:1360
 AliAnalysisManager.cxx:1361
 AliAnalysisManager.cxx:1362
 AliAnalysisManager.cxx:1363
 AliAnalysisManager.cxx:1364
 AliAnalysisManager.cxx:1365
 AliAnalysisManager.cxx:1366
 AliAnalysisManager.cxx:1367
 AliAnalysisManager.cxx:1368
 AliAnalysisManager.cxx:1369
 AliAnalysisManager.cxx:1370
 AliAnalysisManager.cxx:1371
 AliAnalysisManager.cxx:1372
 AliAnalysisManager.cxx:1373
 AliAnalysisManager.cxx:1374
 AliAnalysisManager.cxx:1375
 AliAnalysisManager.cxx:1376
 AliAnalysisManager.cxx:1377
 AliAnalysisManager.cxx:1378
 AliAnalysisManager.cxx:1379
 AliAnalysisManager.cxx:1380
 AliAnalysisManager.cxx:1381
 AliAnalysisManager.cxx:1382
 AliAnalysisManager.cxx:1383
 AliAnalysisManager.cxx:1384
 AliAnalysisManager.cxx:1385
 AliAnalysisManager.cxx:1386
 AliAnalysisManager.cxx:1387
 AliAnalysisManager.cxx:1388
 AliAnalysisManager.cxx:1389
 AliAnalysisManager.cxx:1390
 AliAnalysisManager.cxx:1391
 AliAnalysisManager.cxx:1392
 AliAnalysisManager.cxx:1393
 AliAnalysisManager.cxx:1394
 AliAnalysisManager.cxx:1395
 AliAnalysisManager.cxx:1396
 AliAnalysisManager.cxx:1397
 AliAnalysisManager.cxx:1398
 AliAnalysisManager.cxx:1399
 AliAnalysisManager.cxx:1400
 AliAnalysisManager.cxx:1401
 AliAnalysisManager.cxx:1402
 AliAnalysisManager.cxx:1403
 AliAnalysisManager.cxx:1404
 AliAnalysisManager.cxx:1405
 AliAnalysisManager.cxx:1406
 AliAnalysisManager.cxx:1407
 AliAnalysisManager.cxx:1408
 AliAnalysisManager.cxx:1409
 AliAnalysisManager.cxx:1410
 AliAnalysisManager.cxx:1411
 AliAnalysisManager.cxx:1412
 AliAnalysisManager.cxx:1413
 AliAnalysisManager.cxx:1414
 AliAnalysisManager.cxx:1415
 AliAnalysisManager.cxx:1416
 AliAnalysisManager.cxx:1417
 AliAnalysisManager.cxx:1418
 AliAnalysisManager.cxx:1419
 AliAnalysisManager.cxx:1420
 AliAnalysisManager.cxx:1421
 AliAnalysisManager.cxx:1422
 AliAnalysisManager.cxx:1423
 AliAnalysisManager.cxx:1424
 AliAnalysisManager.cxx:1425
 AliAnalysisManager.cxx:1426
 AliAnalysisManager.cxx:1427
 AliAnalysisManager.cxx:1428
 AliAnalysisManager.cxx:1429
 AliAnalysisManager.cxx:1430
 AliAnalysisManager.cxx:1431
 AliAnalysisManager.cxx:1432
 AliAnalysisManager.cxx:1433
 AliAnalysisManager.cxx:1434
 AliAnalysisManager.cxx:1435
 AliAnalysisManager.cxx:1436
 AliAnalysisManager.cxx:1437
 AliAnalysisManager.cxx:1438
 AliAnalysisManager.cxx:1439
 AliAnalysisManager.cxx:1440
 AliAnalysisManager.cxx:1441
 AliAnalysisManager.cxx:1442
 AliAnalysisManager.cxx:1443
 AliAnalysisManager.cxx:1444
 AliAnalysisManager.cxx:1445
 AliAnalysisManager.cxx:1446
 AliAnalysisManager.cxx:1447
 AliAnalysisManager.cxx:1448
 AliAnalysisManager.cxx:1449
 AliAnalysisManager.cxx:1450
 AliAnalysisManager.cxx:1451
 AliAnalysisManager.cxx:1452
 AliAnalysisManager.cxx:1453
 AliAnalysisManager.cxx:1454
 AliAnalysisManager.cxx:1455
 AliAnalysisManager.cxx:1456
 AliAnalysisManager.cxx:1457
 AliAnalysisManager.cxx:1458
 AliAnalysisManager.cxx:1459
 AliAnalysisManager.cxx:1460
 AliAnalysisManager.cxx:1461
 AliAnalysisManager.cxx:1462
 AliAnalysisManager.cxx:1463
 AliAnalysisManager.cxx:1464
 AliAnalysisManager.cxx:1465
 AliAnalysisManager.cxx:1466
 AliAnalysisManager.cxx:1467
 AliAnalysisManager.cxx:1468
 AliAnalysisManager.cxx:1469
 AliAnalysisManager.cxx:1470
 AliAnalysisManager.cxx:1471
 AliAnalysisManager.cxx:1472
 AliAnalysisManager.cxx:1473
 AliAnalysisManager.cxx:1474
 AliAnalysisManager.cxx:1475
 AliAnalysisManager.cxx:1476
 AliAnalysisManager.cxx:1477
 AliAnalysisManager.cxx:1478
 AliAnalysisManager.cxx:1479
 AliAnalysisManager.cxx:1480
 AliAnalysisManager.cxx:1481
 AliAnalysisManager.cxx:1482
 AliAnalysisManager.cxx:1483
 AliAnalysisManager.cxx:1484
 AliAnalysisManager.cxx:1485
 AliAnalysisManager.cxx:1486
 AliAnalysisManager.cxx:1487
 AliAnalysisManager.cxx:1488
 AliAnalysisManager.cxx:1489
 AliAnalysisManager.cxx:1490
 AliAnalysisManager.cxx:1491
 AliAnalysisManager.cxx:1492
 AliAnalysisManager.cxx:1493
 AliAnalysisManager.cxx:1494
 AliAnalysisManager.cxx:1495
 AliAnalysisManager.cxx:1496
 AliAnalysisManager.cxx:1497
 AliAnalysisManager.cxx:1498
 AliAnalysisManager.cxx:1499
 AliAnalysisManager.cxx:1500
 AliAnalysisManager.cxx:1501
 AliAnalysisManager.cxx:1502
 AliAnalysisManager.cxx:1503
 AliAnalysisManager.cxx:1504
 AliAnalysisManager.cxx:1505
 AliAnalysisManager.cxx:1506
 AliAnalysisManager.cxx:1507
 AliAnalysisManager.cxx:1508
 AliAnalysisManager.cxx:1509
 AliAnalysisManager.cxx:1510
 AliAnalysisManager.cxx:1511
 AliAnalysisManager.cxx:1512
 AliAnalysisManager.cxx:1513
 AliAnalysisManager.cxx:1514
 AliAnalysisManager.cxx:1515
 AliAnalysisManager.cxx:1516
 AliAnalysisManager.cxx:1517
 AliAnalysisManager.cxx:1518
 AliAnalysisManager.cxx:1519
 AliAnalysisManager.cxx:1520
 AliAnalysisManager.cxx:1521
 AliAnalysisManager.cxx:1522
 AliAnalysisManager.cxx:1523
 AliAnalysisManager.cxx:1524
 AliAnalysisManager.cxx:1525
 AliAnalysisManager.cxx:1526
 AliAnalysisManager.cxx:1527
 AliAnalysisManager.cxx:1528
 AliAnalysisManager.cxx:1529
 AliAnalysisManager.cxx:1530
 AliAnalysisManager.cxx:1531
 AliAnalysisManager.cxx:1532
 AliAnalysisManager.cxx:1533
 AliAnalysisManager.cxx:1534
 AliAnalysisManager.cxx:1535
 AliAnalysisManager.cxx:1536
 AliAnalysisManager.cxx:1537
 AliAnalysisManager.cxx:1538
 AliAnalysisManager.cxx:1539
 AliAnalysisManager.cxx:1540
 AliAnalysisManager.cxx:1541
 AliAnalysisManager.cxx:1542
 AliAnalysisManager.cxx:1543
 AliAnalysisManager.cxx:1544
 AliAnalysisManager.cxx:1545
 AliAnalysisManager.cxx:1546
 AliAnalysisManager.cxx:1547
 AliAnalysisManager.cxx:1548
 AliAnalysisManager.cxx:1549
 AliAnalysisManager.cxx:1550
 AliAnalysisManager.cxx:1551
 AliAnalysisManager.cxx:1552
 AliAnalysisManager.cxx:1553
 AliAnalysisManager.cxx:1554
 AliAnalysisManager.cxx:1555
 AliAnalysisManager.cxx:1556
 AliAnalysisManager.cxx:1557
 AliAnalysisManager.cxx:1558
 AliAnalysisManager.cxx:1559
 AliAnalysisManager.cxx:1560
 AliAnalysisManager.cxx:1561
 AliAnalysisManager.cxx:1562
 AliAnalysisManager.cxx:1563
 AliAnalysisManager.cxx:1564
 AliAnalysisManager.cxx:1565
 AliAnalysisManager.cxx:1566
 AliAnalysisManager.cxx:1567
 AliAnalysisManager.cxx:1568
 AliAnalysisManager.cxx:1569
 AliAnalysisManager.cxx:1570
 AliAnalysisManager.cxx:1571
 AliAnalysisManager.cxx:1572
 AliAnalysisManager.cxx:1573
 AliAnalysisManager.cxx:1574
 AliAnalysisManager.cxx:1575
 AliAnalysisManager.cxx:1576
 AliAnalysisManager.cxx:1577
 AliAnalysisManager.cxx:1578
 AliAnalysisManager.cxx:1579
 AliAnalysisManager.cxx:1580
 AliAnalysisManager.cxx:1581
 AliAnalysisManager.cxx:1582
 AliAnalysisManager.cxx:1583
 AliAnalysisManager.cxx:1584
 AliAnalysisManager.cxx:1585
 AliAnalysisManager.cxx:1586
 AliAnalysisManager.cxx:1587
 AliAnalysisManager.cxx:1588
 AliAnalysisManager.cxx:1589
 AliAnalysisManager.cxx:1590
 AliAnalysisManager.cxx:1591
 AliAnalysisManager.cxx:1592
 AliAnalysisManager.cxx:1593
 AliAnalysisManager.cxx:1594
 AliAnalysisManager.cxx:1595
 AliAnalysisManager.cxx:1596
 AliAnalysisManager.cxx:1597
 AliAnalysisManager.cxx:1598
 AliAnalysisManager.cxx:1599
 AliAnalysisManager.cxx:1600
 AliAnalysisManager.cxx:1601
 AliAnalysisManager.cxx:1602
 AliAnalysisManager.cxx:1603
 AliAnalysisManager.cxx:1604
 AliAnalysisManager.cxx:1605
 AliAnalysisManager.cxx:1606
 AliAnalysisManager.cxx:1607
 AliAnalysisManager.cxx:1608
 AliAnalysisManager.cxx:1609
 AliAnalysisManager.cxx:1610
 AliAnalysisManager.cxx:1611
 AliAnalysisManager.cxx:1612
 AliAnalysisManager.cxx:1613
 AliAnalysisManager.cxx:1614
 AliAnalysisManager.cxx:1615
 AliAnalysisManager.cxx:1616
 AliAnalysisManager.cxx:1617
 AliAnalysisManager.cxx:1618
 AliAnalysisManager.cxx:1619
 AliAnalysisManager.cxx:1620
 AliAnalysisManager.cxx:1621
 AliAnalysisManager.cxx:1622
 AliAnalysisManager.cxx:1623
 AliAnalysisManager.cxx:1624
 AliAnalysisManager.cxx:1625
 AliAnalysisManager.cxx:1626
 AliAnalysisManager.cxx:1627
 AliAnalysisManager.cxx:1628
 AliAnalysisManager.cxx:1629
 AliAnalysisManager.cxx:1630
 AliAnalysisManager.cxx:1631
 AliAnalysisManager.cxx:1632
 AliAnalysisManager.cxx:1633
 AliAnalysisManager.cxx:1634
 AliAnalysisManager.cxx:1635
 AliAnalysisManager.cxx:1636
 AliAnalysisManager.cxx:1637
 AliAnalysisManager.cxx:1638
 AliAnalysisManager.cxx:1639
 AliAnalysisManager.cxx:1640
 AliAnalysisManager.cxx:1641
 AliAnalysisManager.cxx:1642
 AliAnalysisManager.cxx:1643
 AliAnalysisManager.cxx:1644
 AliAnalysisManager.cxx:1645
 AliAnalysisManager.cxx:1646
 AliAnalysisManager.cxx:1647
 AliAnalysisManager.cxx:1648
 AliAnalysisManager.cxx:1649
 AliAnalysisManager.cxx:1650
 AliAnalysisManager.cxx:1651
 AliAnalysisManager.cxx:1652
 AliAnalysisManager.cxx:1653
 AliAnalysisManager.cxx:1654
 AliAnalysisManager.cxx:1655
 AliAnalysisManager.cxx:1656
 AliAnalysisManager.cxx:1657
 AliAnalysisManager.cxx:1658
 AliAnalysisManager.cxx:1659
 AliAnalysisManager.cxx:1660
 AliAnalysisManager.cxx:1661
 AliAnalysisManager.cxx:1662
 AliAnalysisManager.cxx:1663
 AliAnalysisManager.cxx:1664
 AliAnalysisManager.cxx:1665
 AliAnalysisManager.cxx:1666
 AliAnalysisManager.cxx:1667
 AliAnalysisManager.cxx:1668
 AliAnalysisManager.cxx:1669
 AliAnalysisManager.cxx:1670
 AliAnalysisManager.cxx:1671
 AliAnalysisManager.cxx:1672
 AliAnalysisManager.cxx:1673
 AliAnalysisManager.cxx:1674
 AliAnalysisManager.cxx:1675
 AliAnalysisManager.cxx:1676
 AliAnalysisManager.cxx:1677
 AliAnalysisManager.cxx:1678
 AliAnalysisManager.cxx:1679
 AliAnalysisManager.cxx:1680
 AliAnalysisManager.cxx:1681
 AliAnalysisManager.cxx:1682
 AliAnalysisManager.cxx:1683
 AliAnalysisManager.cxx:1684
 AliAnalysisManager.cxx:1685
 AliAnalysisManager.cxx:1686
 AliAnalysisManager.cxx:1687
 AliAnalysisManager.cxx:1688
 AliAnalysisManager.cxx:1689
 AliAnalysisManager.cxx:1690
 AliAnalysisManager.cxx:1691
 AliAnalysisManager.cxx:1692
 AliAnalysisManager.cxx:1693
 AliAnalysisManager.cxx:1694
 AliAnalysisManager.cxx:1695
 AliAnalysisManager.cxx:1696
 AliAnalysisManager.cxx:1697
 AliAnalysisManager.cxx:1698
 AliAnalysisManager.cxx:1699
 AliAnalysisManager.cxx:1700
 AliAnalysisManager.cxx:1701
 AliAnalysisManager.cxx:1702
 AliAnalysisManager.cxx:1703
 AliAnalysisManager.cxx:1704
 AliAnalysisManager.cxx:1705
 AliAnalysisManager.cxx:1706
 AliAnalysisManager.cxx:1707
 AliAnalysisManager.cxx:1708
 AliAnalysisManager.cxx:1709
 AliAnalysisManager.cxx:1710
 AliAnalysisManager.cxx:1711
 AliAnalysisManager.cxx:1712
 AliAnalysisManager.cxx:1713
 AliAnalysisManager.cxx:1714
 AliAnalysisManager.cxx:1715
 AliAnalysisManager.cxx:1716
 AliAnalysisManager.cxx:1717
 AliAnalysisManager.cxx:1718
 AliAnalysisManager.cxx:1719
 AliAnalysisManager.cxx:1720
 AliAnalysisManager.cxx:1721
 AliAnalysisManager.cxx:1722
 AliAnalysisManager.cxx:1723
 AliAnalysisManager.cxx:1724
 AliAnalysisManager.cxx:1725
 AliAnalysisManager.cxx:1726
 AliAnalysisManager.cxx:1727
 AliAnalysisManager.cxx:1728
 AliAnalysisManager.cxx:1729
 AliAnalysisManager.cxx:1730
 AliAnalysisManager.cxx:1731
 AliAnalysisManager.cxx:1732
 AliAnalysisManager.cxx:1733
 AliAnalysisManager.cxx:1734
 AliAnalysisManager.cxx:1735
 AliAnalysisManager.cxx:1736
 AliAnalysisManager.cxx:1737
 AliAnalysisManager.cxx:1738
 AliAnalysisManager.cxx:1739
 AliAnalysisManager.cxx:1740
 AliAnalysisManager.cxx:1741
 AliAnalysisManager.cxx:1742
 AliAnalysisManager.cxx:1743
 AliAnalysisManager.cxx:1744
 AliAnalysisManager.cxx:1745
 AliAnalysisManager.cxx:1746
 AliAnalysisManager.cxx:1747
 AliAnalysisManager.cxx:1748
 AliAnalysisManager.cxx:1749
 AliAnalysisManager.cxx:1750
 AliAnalysisManager.cxx:1751
 AliAnalysisManager.cxx:1752
 AliAnalysisManager.cxx:1753
 AliAnalysisManager.cxx:1754
 AliAnalysisManager.cxx:1755
 AliAnalysisManager.cxx:1756
 AliAnalysisManager.cxx:1757
 AliAnalysisManager.cxx:1758
 AliAnalysisManager.cxx:1759
 AliAnalysisManager.cxx:1760
 AliAnalysisManager.cxx:1761
 AliAnalysisManager.cxx:1762
 AliAnalysisManager.cxx:1763
 AliAnalysisManager.cxx:1764
 AliAnalysisManager.cxx:1765
 AliAnalysisManager.cxx:1766
 AliAnalysisManager.cxx:1767
 AliAnalysisManager.cxx:1768
 AliAnalysisManager.cxx:1769
 AliAnalysisManager.cxx:1770
 AliAnalysisManager.cxx:1771
 AliAnalysisManager.cxx:1772
 AliAnalysisManager.cxx:1773
 AliAnalysisManager.cxx:1774
 AliAnalysisManager.cxx:1775
 AliAnalysisManager.cxx:1776
 AliAnalysisManager.cxx:1777
 AliAnalysisManager.cxx:1778
 AliAnalysisManager.cxx:1779
 AliAnalysisManager.cxx:1780
 AliAnalysisManager.cxx:1781
 AliAnalysisManager.cxx:1782
 AliAnalysisManager.cxx:1783
 AliAnalysisManager.cxx:1784
 AliAnalysisManager.cxx:1785
 AliAnalysisManager.cxx:1786
 AliAnalysisManager.cxx:1787
 AliAnalysisManager.cxx:1788
 AliAnalysisManager.cxx:1789
 AliAnalysisManager.cxx:1790
 AliAnalysisManager.cxx:1791
 AliAnalysisManager.cxx:1792
 AliAnalysisManager.cxx:1793
 AliAnalysisManager.cxx:1794
 AliAnalysisManager.cxx:1795
 AliAnalysisManager.cxx:1796
 AliAnalysisManager.cxx:1797
 AliAnalysisManager.cxx:1798
 AliAnalysisManager.cxx:1799
 AliAnalysisManager.cxx:1800
 AliAnalysisManager.cxx:1801
 AliAnalysisManager.cxx:1802
 AliAnalysisManager.cxx:1803
 AliAnalysisManager.cxx:1804
 AliAnalysisManager.cxx:1805
 AliAnalysisManager.cxx:1806
 AliAnalysisManager.cxx:1807
 AliAnalysisManager.cxx:1808
 AliAnalysisManager.cxx:1809
 AliAnalysisManager.cxx:1810
 AliAnalysisManager.cxx:1811
 AliAnalysisManager.cxx:1812
 AliAnalysisManager.cxx:1813
 AliAnalysisManager.cxx:1814
 AliAnalysisManager.cxx:1815
 AliAnalysisManager.cxx:1816
 AliAnalysisManager.cxx:1817
 AliAnalysisManager.cxx:1818
 AliAnalysisManager.cxx:1819
 AliAnalysisManager.cxx:1820
 AliAnalysisManager.cxx:1821
 AliAnalysisManager.cxx:1822
 AliAnalysisManager.cxx:1823
 AliAnalysisManager.cxx:1824
 AliAnalysisManager.cxx:1825
 AliAnalysisManager.cxx:1826
 AliAnalysisManager.cxx:1827
 AliAnalysisManager.cxx:1828
 AliAnalysisManager.cxx:1829
 AliAnalysisManager.cxx:1830
 AliAnalysisManager.cxx:1831
 AliAnalysisManager.cxx:1832
 AliAnalysisManager.cxx:1833
 AliAnalysisManager.cxx:1834
 AliAnalysisManager.cxx:1835
 AliAnalysisManager.cxx:1836
 AliAnalysisManager.cxx:1837
 AliAnalysisManager.cxx:1838
 AliAnalysisManager.cxx:1839
 AliAnalysisManager.cxx:1840
 AliAnalysisManager.cxx:1841
 AliAnalysisManager.cxx:1842
 AliAnalysisManager.cxx:1843
 AliAnalysisManager.cxx:1844
 AliAnalysisManager.cxx:1845
 AliAnalysisManager.cxx:1846
 AliAnalysisManager.cxx:1847
 AliAnalysisManager.cxx:1848
 AliAnalysisManager.cxx:1849
 AliAnalysisManager.cxx:1850
 AliAnalysisManager.cxx:1851
 AliAnalysisManager.cxx:1852
 AliAnalysisManager.cxx:1853
 AliAnalysisManager.cxx:1854
 AliAnalysisManager.cxx:1855
 AliAnalysisManager.cxx:1856
 AliAnalysisManager.cxx:1857
 AliAnalysisManager.cxx:1858
 AliAnalysisManager.cxx:1859
 AliAnalysisManager.cxx:1860
 AliAnalysisManager.cxx:1861
 AliAnalysisManager.cxx:1862
 AliAnalysisManager.cxx:1863
 AliAnalysisManager.cxx:1864
 AliAnalysisManager.cxx:1865
 AliAnalysisManager.cxx:1866
 AliAnalysisManager.cxx:1867
 AliAnalysisManager.cxx:1868
 AliAnalysisManager.cxx:1869
 AliAnalysisManager.cxx:1870
 AliAnalysisManager.cxx:1871
 AliAnalysisManager.cxx:1872
 AliAnalysisManager.cxx:1873
 AliAnalysisManager.cxx:1874
 AliAnalysisManager.cxx:1875
 AliAnalysisManager.cxx:1876
 AliAnalysisManager.cxx:1877
 AliAnalysisManager.cxx:1878
 AliAnalysisManager.cxx:1879
 AliAnalysisManager.cxx:1880
 AliAnalysisManager.cxx:1881
 AliAnalysisManager.cxx:1882
 AliAnalysisManager.cxx:1883
 AliAnalysisManager.cxx:1884
 AliAnalysisManager.cxx:1885
 AliAnalysisManager.cxx:1886
 AliAnalysisManager.cxx:1887
 AliAnalysisManager.cxx:1888
 AliAnalysisManager.cxx:1889
 AliAnalysisManager.cxx:1890
 AliAnalysisManager.cxx:1891
 AliAnalysisManager.cxx:1892
 AliAnalysisManager.cxx:1893
 AliAnalysisManager.cxx:1894
 AliAnalysisManager.cxx:1895
 AliAnalysisManager.cxx:1896
 AliAnalysisManager.cxx:1897
 AliAnalysisManager.cxx:1898
 AliAnalysisManager.cxx:1899
 AliAnalysisManager.cxx:1900
 AliAnalysisManager.cxx:1901
 AliAnalysisManager.cxx:1902
 AliAnalysisManager.cxx:1903
 AliAnalysisManager.cxx:1904
 AliAnalysisManager.cxx:1905
 AliAnalysisManager.cxx:1906
 AliAnalysisManager.cxx:1907
 AliAnalysisManager.cxx:1908
 AliAnalysisManager.cxx:1909
 AliAnalysisManager.cxx:1910
 AliAnalysisManager.cxx:1911
 AliAnalysisManager.cxx:1912
 AliAnalysisManager.cxx:1913
 AliAnalysisManager.cxx:1914
 AliAnalysisManager.cxx:1915
 AliAnalysisManager.cxx:1916
 AliAnalysisManager.cxx:1917
 AliAnalysisManager.cxx:1918
 AliAnalysisManager.cxx:1919
 AliAnalysisManager.cxx:1920
 AliAnalysisManager.cxx:1921
 AliAnalysisManager.cxx:1922
 AliAnalysisManager.cxx:1923
 AliAnalysisManager.cxx:1924
 AliAnalysisManager.cxx:1925
 AliAnalysisManager.cxx:1926
 AliAnalysisManager.cxx:1927
 AliAnalysisManager.cxx:1928
 AliAnalysisManager.cxx:1929
 AliAnalysisManager.cxx:1930
 AliAnalysisManager.cxx:1931
 AliAnalysisManager.cxx:1932
 AliAnalysisManager.cxx:1933
 AliAnalysisManager.cxx:1934
 AliAnalysisManager.cxx:1935
 AliAnalysisManager.cxx:1936
 AliAnalysisManager.cxx:1937
 AliAnalysisManager.cxx:1938
 AliAnalysisManager.cxx:1939
 AliAnalysisManager.cxx:1940
 AliAnalysisManager.cxx:1941
 AliAnalysisManager.cxx:1942
 AliAnalysisManager.cxx:1943
 AliAnalysisManager.cxx:1944
 AliAnalysisManager.cxx:1945
 AliAnalysisManager.cxx:1946
 AliAnalysisManager.cxx:1947
 AliAnalysisManager.cxx:1948
 AliAnalysisManager.cxx:1949
 AliAnalysisManager.cxx:1950
 AliAnalysisManager.cxx:1951
 AliAnalysisManager.cxx:1952
 AliAnalysisManager.cxx:1953
 AliAnalysisManager.cxx:1954
 AliAnalysisManager.cxx:1955
 AliAnalysisManager.cxx:1956
 AliAnalysisManager.cxx:1957
 AliAnalysisManager.cxx:1958
 AliAnalysisManager.cxx:1959
 AliAnalysisManager.cxx:1960
 AliAnalysisManager.cxx:1961
 AliAnalysisManager.cxx:1962
 AliAnalysisManager.cxx:1963
 AliAnalysisManager.cxx:1964
 AliAnalysisManager.cxx:1965
 AliAnalysisManager.cxx:1966
 AliAnalysisManager.cxx:1967
 AliAnalysisManager.cxx:1968
 AliAnalysisManager.cxx:1969
 AliAnalysisManager.cxx:1970
 AliAnalysisManager.cxx:1971
 AliAnalysisManager.cxx:1972
 AliAnalysisManager.cxx:1973
 AliAnalysisManager.cxx:1974
 AliAnalysisManager.cxx:1975
 AliAnalysisManager.cxx:1976
 AliAnalysisManager.cxx:1977
 AliAnalysisManager.cxx:1978
 AliAnalysisManager.cxx:1979
 AliAnalysisManager.cxx:1980
 AliAnalysisManager.cxx:1981
 AliAnalysisManager.cxx:1982
 AliAnalysisManager.cxx:1983
 AliAnalysisManager.cxx:1984
 AliAnalysisManager.cxx:1985
 AliAnalysisManager.cxx:1986
 AliAnalysisManager.cxx:1987
 AliAnalysisManager.cxx:1988
 AliAnalysisManager.cxx:1989
 AliAnalysisManager.cxx:1990
 AliAnalysisManager.cxx:1991
 AliAnalysisManager.cxx:1992
 AliAnalysisManager.cxx:1993
 AliAnalysisManager.cxx:1994
 AliAnalysisManager.cxx:1995
 AliAnalysisManager.cxx:1996
 AliAnalysisManager.cxx:1997
 AliAnalysisManager.cxx:1998
 AliAnalysisManager.cxx:1999
 AliAnalysisManager.cxx:2000
 AliAnalysisManager.cxx:2001
 AliAnalysisManager.cxx:2002
 AliAnalysisManager.cxx:2003
 AliAnalysisManager.cxx:2004
 AliAnalysisManager.cxx:2005
 AliAnalysisManager.cxx:2006
 AliAnalysisManager.cxx:2007
 AliAnalysisManager.cxx:2008
 AliAnalysisManager.cxx:2009
 AliAnalysisManager.cxx:2010
 AliAnalysisManager.cxx:2011
 AliAnalysisManager.cxx:2012
 AliAnalysisManager.cxx:2013
 AliAnalysisManager.cxx:2014
 AliAnalysisManager.cxx:2015
 AliAnalysisManager.cxx:2016
 AliAnalysisManager.cxx:2017
 AliAnalysisManager.cxx:2018
 AliAnalysisManager.cxx:2019
 AliAnalysisManager.cxx:2020
 AliAnalysisManager.cxx:2021
 AliAnalysisManager.cxx:2022
 AliAnalysisManager.cxx:2023
 AliAnalysisManager.cxx:2024
 AliAnalysisManager.cxx:2025
 AliAnalysisManager.cxx:2026
 AliAnalysisManager.cxx:2027
 AliAnalysisManager.cxx:2028
 AliAnalysisManager.cxx:2029
 AliAnalysisManager.cxx:2030
 AliAnalysisManager.cxx:2031
 AliAnalysisManager.cxx:2032
 AliAnalysisManager.cxx:2033
 AliAnalysisManager.cxx:2034
 AliAnalysisManager.cxx:2035
 AliAnalysisManager.cxx:2036
 AliAnalysisManager.cxx:2037
 AliAnalysisManager.cxx:2038
 AliAnalysisManager.cxx:2039
 AliAnalysisManager.cxx:2040
 AliAnalysisManager.cxx:2041
 AliAnalysisManager.cxx:2042
 AliAnalysisManager.cxx:2043
 AliAnalysisManager.cxx:2044
 AliAnalysisManager.cxx:2045
 AliAnalysisManager.cxx:2046
 AliAnalysisManager.cxx:2047
 AliAnalysisManager.cxx:2048
 AliAnalysisManager.cxx:2049
 AliAnalysisManager.cxx:2050
 AliAnalysisManager.cxx:2051
 AliAnalysisManager.cxx:2052
 AliAnalysisManager.cxx:2053
 AliAnalysisManager.cxx:2054
 AliAnalysisManager.cxx:2055
 AliAnalysisManager.cxx:2056
 AliAnalysisManager.cxx:2057
 AliAnalysisManager.cxx:2058
 AliAnalysisManager.cxx:2059
 AliAnalysisManager.cxx:2060
 AliAnalysisManager.cxx:2061
 AliAnalysisManager.cxx:2062
 AliAnalysisManager.cxx:2063
 AliAnalysisManager.cxx:2064
 AliAnalysisManager.cxx:2065
 AliAnalysisManager.cxx:2066
 AliAnalysisManager.cxx:2067
 AliAnalysisManager.cxx:2068
 AliAnalysisManager.cxx:2069
 AliAnalysisManager.cxx:2070
 AliAnalysisManager.cxx:2071
 AliAnalysisManager.cxx:2072
 AliAnalysisManager.cxx:2073
 AliAnalysisManager.cxx:2074
 AliAnalysisManager.cxx:2075
 AliAnalysisManager.cxx:2076
 AliAnalysisManager.cxx:2077
 AliAnalysisManager.cxx:2078
 AliAnalysisManager.cxx:2079
 AliAnalysisManager.cxx:2080
 AliAnalysisManager.cxx:2081
 AliAnalysisManager.cxx:2082
 AliAnalysisManager.cxx:2083
 AliAnalysisManager.cxx:2084
 AliAnalysisManager.cxx:2085
 AliAnalysisManager.cxx:2086
 AliAnalysisManager.cxx:2087
 AliAnalysisManager.cxx:2088
 AliAnalysisManager.cxx:2089
 AliAnalysisManager.cxx:2090
 AliAnalysisManager.cxx:2091
 AliAnalysisManager.cxx:2092
 AliAnalysisManager.cxx:2093
 AliAnalysisManager.cxx:2094
 AliAnalysisManager.cxx:2095
 AliAnalysisManager.cxx:2096
 AliAnalysisManager.cxx:2097
 AliAnalysisManager.cxx:2098
 AliAnalysisManager.cxx:2099
 AliAnalysisManager.cxx:2100
 AliAnalysisManager.cxx:2101
 AliAnalysisManager.cxx:2102
 AliAnalysisManager.cxx:2103
 AliAnalysisManager.cxx:2104
 AliAnalysisManager.cxx:2105
 AliAnalysisManager.cxx:2106
 AliAnalysisManager.cxx:2107
 AliAnalysisManager.cxx:2108
 AliAnalysisManager.cxx:2109
 AliAnalysisManager.cxx:2110
 AliAnalysisManager.cxx:2111
 AliAnalysisManager.cxx:2112
 AliAnalysisManager.cxx:2113
 AliAnalysisManager.cxx:2114
 AliAnalysisManager.cxx:2115
 AliAnalysisManager.cxx:2116
 AliAnalysisManager.cxx:2117
 AliAnalysisManager.cxx:2118
 AliAnalysisManager.cxx:2119
 AliAnalysisManager.cxx:2120
 AliAnalysisManager.cxx:2121
 AliAnalysisManager.cxx:2122
 AliAnalysisManager.cxx:2123
 AliAnalysisManager.cxx:2124
 AliAnalysisManager.cxx:2125
 AliAnalysisManager.cxx:2126
 AliAnalysisManager.cxx:2127
 AliAnalysisManager.cxx:2128
 AliAnalysisManager.cxx:2129
 AliAnalysisManager.cxx:2130
 AliAnalysisManager.cxx:2131
 AliAnalysisManager.cxx:2132
 AliAnalysisManager.cxx:2133
 AliAnalysisManager.cxx:2134
 AliAnalysisManager.cxx:2135
 AliAnalysisManager.cxx:2136
 AliAnalysisManager.cxx:2137
 AliAnalysisManager.cxx:2138
 AliAnalysisManager.cxx:2139
 AliAnalysisManager.cxx:2140
 AliAnalysisManager.cxx:2141
 AliAnalysisManager.cxx:2142
 AliAnalysisManager.cxx:2143
 AliAnalysisManager.cxx:2144
 AliAnalysisManager.cxx:2145
 AliAnalysisManager.cxx:2146
 AliAnalysisManager.cxx:2147
 AliAnalysisManager.cxx:2148
 AliAnalysisManager.cxx:2149
 AliAnalysisManager.cxx:2150
 AliAnalysisManager.cxx:2151
 AliAnalysisManager.cxx:2152
 AliAnalysisManager.cxx:2153
 AliAnalysisManager.cxx:2154
 AliAnalysisManager.cxx:2155
 AliAnalysisManager.cxx:2156
 AliAnalysisManager.cxx:2157
 AliAnalysisManager.cxx:2158
 AliAnalysisManager.cxx:2159
 AliAnalysisManager.cxx:2160
 AliAnalysisManager.cxx:2161
 AliAnalysisManager.cxx:2162
 AliAnalysisManager.cxx:2163
 AliAnalysisManager.cxx:2164
 AliAnalysisManager.cxx:2165
 AliAnalysisManager.cxx:2166
 AliAnalysisManager.cxx:2167
 AliAnalysisManager.cxx:2168
 AliAnalysisManager.cxx:2169
 AliAnalysisManager.cxx:2170
 AliAnalysisManager.cxx:2171
 AliAnalysisManager.cxx:2172
 AliAnalysisManager.cxx:2173
 AliAnalysisManager.cxx:2174
 AliAnalysisManager.cxx:2175
 AliAnalysisManager.cxx:2176
 AliAnalysisManager.cxx:2177
 AliAnalysisManager.cxx:2178
 AliAnalysisManager.cxx:2179
 AliAnalysisManager.cxx:2180
 AliAnalysisManager.cxx:2181
 AliAnalysisManager.cxx:2182
 AliAnalysisManager.cxx:2183
 AliAnalysisManager.cxx:2184
 AliAnalysisManager.cxx:2185
 AliAnalysisManager.cxx:2186
 AliAnalysisManager.cxx:2187
 AliAnalysisManager.cxx:2188
 AliAnalysisManager.cxx:2189
 AliAnalysisManager.cxx:2190
 AliAnalysisManager.cxx:2191
 AliAnalysisManager.cxx:2192
 AliAnalysisManager.cxx:2193
 AliAnalysisManager.cxx:2194
 AliAnalysisManager.cxx:2195
 AliAnalysisManager.cxx:2196
 AliAnalysisManager.cxx:2197
 AliAnalysisManager.cxx:2198
 AliAnalysisManager.cxx:2199
 AliAnalysisManager.cxx:2200
 AliAnalysisManager.cxx:2201
 AliAnalysisManager.cxx:2202
 AliAnalysisManager.cxx:2203
 AliAnalysisManager.cxx:2204
 AliAnalysisManager.cxx:2205
 AliAnalysisManager.cxx:2206
 AliAnalysisManager.cxx:2207
 AliAnalysisManager.cxx:2208
 AliAnalysisManager.cxx:2209
 AliAnalysisManager.cxx:2210
 AliAnalysisManager.cxx:2211
 AliAnalysisManager.cxx:2212
 AliAnalysisManager.cxx:2213
 AliAnalysisManager.cxx:2214
 AliAnalysisManager.cxx:2215
 AliAnalysisManager.cxx:2216
 AliAnalysisManager.cxx:2217
 AliAnalysisManager.cxx:2218
 AliAnalysisManager.cxx:2219
 AliAnalysisManager.cxx:2220
 AliAnalysisManager.cxx:2221
 AliAnalysisManager.cxx:2222
 AliAnalysisManager.cxx:2223
 AliAnalysisManager.cxx:2224
 AliAnalysisManager.cxx:2225
 AliAnalysisManager.cxx:2226
 AliAnalysisManager.cxx:2227
 AliAnalysisManager.cxx:2228
 AliAnalysisManager.cxx:2229
 AliAnalysisManager.cxx:2230
 AliAnalysisManager.cxx:2231
 AliAnalysisManager.cxx:2232
 AliAnalysisManager.cxx:2233
 AliAnalysisManager.cxx:2234
 AliAnalysisManager.cxx:2235
 AliAnalysisManager.cxx:2236
 AliAnalysisManager.cxx:2237
 AliAnalysisManager.cxx:2238
 AliAnalysisManager.cxx:2239
 AliAnalysisManager.cxx:2240
 AliAnalysisManager.cxx:2241
 AliAnalysisManager.cxx:2242
 AliAnalysisManager.cxx:2243
 AliAnalysisManager.cxx:2244
 AliAnalysisManager.cxx:2245
 AliAnalysisManager.cxx:2246
 AliAnalysisManager.cxx:2247
 AliAnalysisManager.cxx:2248
 AliAnalysisManager.cxx:2249
 AliAnalysisManager.cxx:2250
 AliAnalysisManager.cxx:2251
 AliAnalysisManager.cxx:2252
 AliAnalysisManager.cxx:2253
 AliAnalysisManager.cxx:2254
 AliAnalysisManager.cxx:2255
 AliAnalysisManager.cxx:2256
 AliAnalysisManager.cxx:2257
 AliAnalysisManager.cxx:2258
 AliAnalysisManager.cxx:2259
 AliAnalysisManager.cxx:2260
 AliAnalysisManager.cxx:2261
 AliAnalysisManager.cxx:2262
 AliAnalysisManager.cxx:2263
 AliAnalysisManager.cxx:2264
 AliAnalysisManager.cxx:2265
 AliAnalysisManager.cxx:2266
 AliAnalysisManager.cxx:2267
 AliAnalysisManager.cxx:2268
 AliAnalysisManager.cxx:2269
 AliAnalysisManager.cxx:2270
 AliAnalysisManager.cxx:2271
 AliAnalysisManager.cxx:2272
 AliAnalysisManager.cxx:2273
 AliAnalysisManager.cxx:2274
 AliAnalysisManager.cxx:2275
 AliAnalysisManager.cxx:2276
 AliAnalysisManager.cxx:2277
 AliAnalysisManager.cxx:2278
 AliAnalysisManager.cxx:2279
 AliAnalysisManager.cxx:2280
 AliAnalysisManager.cxx:2281
 AliAnalysisManager.cxx:2282
 AliAnalysisManager.cxx:2283
 AliAnalysisManager.cxx:2284
 AliAnalysisManager.cxx:2285
 AliAnalysisManager.cxx:2286
 AliAnalysisManager.cxx:2287
 AliAnalysisManager.cxx:2288
 AliAnalysisManager.cxx:2289
 AliAnalysisManager.cxx:2290
 AliAnalysisManager.cxx:2291
 AliAnalysisManager.cxx:2292
 AliAnalysisManager.cxx:2293
 AliAnalysisManager.cxx:2294
 AliAnalysisManager.cxx:2295
 AliAnalysisManager.cxx:2296
 AliAnalysisManager.cxx:2297
 AliAnalysisManager.cxx:2298
 AliAnalysisManager.cxx:2299
 AliAnalysisManager.cxx:2300
 AliAnalysisManager.cxx:2301
 AliAnalysisManager.cxx:2302
 AliAnalysisManager.cxx:2303
 AliAnalysisManager.cxx:2304
 AliAnalysisManager.cxx:2305
 AliAnalysisManager.cxx:2306
 AliAnalysisManager.cxx:2307
 AliAnalysisManager.cxx:2308
 AliAnalysisManager.cxx:2309
 AliAnalysisManager.cxx:2310
 AliAnalysisManager.cxx:2311
 AliAnalysisManager.cxx:2312
 AliAnalysisManager.cxx:2313
 AliAnalysisManager.cxx:2314
 AliAnalysisManager.cxx:2315
 AliAnalysisManager.cxx:2316
 AliAnalysisManager.cxx:2317
 AliAnalysisManager.cxx:2318
 AliAnalysisManager.cxx:2319
 AliAnalysisManager.cxx:2320
 AliAnalysisManager.cxx:2321
 AliAnalysisManager.cxx:2322
 AliAnalysisManager.cxx:2323
 AliAnalysisManager.cxx:2324
 AliAnalysisManager.cxx:2325
 AliAnalysisManager.cxx:2326
 AliAnalysisManager.cxx:2327
 AliAnalysisManager.cxx:2328
 AliAnalysisManager.cxx:2329
 AliAnalysisManager.cxx:2330
 AliAnalysisManager.cxx:2331
 AliAnalysisManager.cxx:2332
 AliAnalysisManager.cxx:2333
 AliAnalysisManager.cxx:2334
 AliAnalysisManager.cxx:2335
 AliAnalysisManager.cxx:2336
 AliAnalysisManager.cxx:2337
 AliAnalysisManager.cxx:2338
 AliAnalysisManager.cxx:2339
 AliAnalysisManager.cxx:2340
 AliAnalysisManager.cxx:2341
 AliAnalysisManager.cxx:2342
 AliAnalysisManager.cxx:2343
 AliAnalysisManager.cxx:2344
 AliAnalysisManager.cxx:2345
 AliAnalysisManager.cxx:2346
 AliAnalysisManager.cxx:2347
 AliAnalysisManager.cxx:2348
 AliAnalysisManager.cxx:2349
 AliAnalysisManager.cxx:2350
 AliAnalysisManager.cxx:2351
 AliAnalysisManager.cxx:2352
 AliAnalysisManager.cxx:2353
 AliAnalysisManager.cxx:2354
 AliAnalysisManager.cxx:2355
 AliAnalysisManager.cxx:2356
 AliAnalysisManager.cxx:2357
 AliAnalysisManager.cxx:2358
 AliAnalysisManager.cxx:2359
 AliAnalysisManager.cxx:2360
 AliAnalysisManager.cxx:2361
 AliAnalysisManager.cxx:2362
 AliAnalysisManager.cxx:2363
 AliAnalysisManager.cxx:2364
 AliAnalysisManager.cxx:2365
 AliAnalysisManager.cxx:2366
 AliAnalysisManager.cxx:2367
 AliAnalysisManager.cxx:2368
 AliAnalysisManager.cxx:2369
 AliAnalysisManager.cxx:2370
 AliAnalysisManager.cxx:2371
 AliAnalysisManager.cxx:2372
 AliAnalysisManager.cxx:2373
 AliAnalysisManager.cxx:2374
 AliAnalysisManager.cxx:2375
 AliAnalysisManager.cxx:2376
 AliAnalysisManager.cxx:2377
 AliAnalysisManager.cxx:2378
 AliAnalysisManager.cxx:2379
 AliAnalysisManager.cxx:2380
 AliAnalysisManager.cxx:2381
 AliAnalysisManager.cxx:2382
 AliAnalysisManager.cxx:2383
 AliAnalysisManager.cxx:2384
 AliAnalysisManager.cxx:2385
 AliAnalysisManager.cxx:2386
 AliAnalysisManager.cxx:2387
 AliAnalysisManager.cxx:2388
 AliAnalysisManager.cxx:2389
 AliAnalysisManager.cxx:2390
 AliAnalysisManager.cxx:2391
 AliAnalysisManager.cxx:2392
 AliAnalysisManager.cxx:2393
 AliAnalysisManager.cxx:2394
 AliAnalysisManager.cxx:2395
 AliAnalysisManager.cxx:2396
 AliAnalysisManager.cxx:2397
 AliAnalysisManager.cxx:2398
 AliAnalysisManager.cxx:2399
 AliAnalysisManager.cxx:2400
 AliAnalysisManager.cxx:2401
 AliAnalysisManager.cxx:2402
 AliAnalysisManager.cxx:2403
 AliAnalysisManager.cxx:2404
 AliAnalysisManager.cxx:2405
 AliAnalysisManager.cxx:2406
 AliAnalysisManager.cxx:2407
 AliAnalysisManager.cxx:2408
 AliAnalysisManager.cxx:2409
 AliAnalysisManager.cxx:2410
 AliAnalysisManager.cxx:2411
 AliAnalysisManager.cxx:2412
 AliAnalysisManager.cxx:2413
 AliAnalysisManager.cxx:2414
 AliAnalysisManager.cxx:2415
 AliAnalysisManager.cxx:2416
 AliAnalysisManager.cxx:2417
 AliAnalysisManager.cxx:2418
 AliAnalysisManager.cxx:2419
 AliAnalysisManager.cxx:2420
 AliAnalysisManager.cxx:2421
 AliAnalysisManager.cxx:2422
 AliAnalysisManager.cxx:2423
 AliAnalysisManager.cxx:2424
 AliAnalysisManager.cxx:2425
 AliAnalysisManager.cxx:2426
 AliAnalysisManager.cxx:2427
 AliAnalysisManager.cxx:2428
 AliAnalysisManager.cxx:2429
 AliAnalysisManager.cxx:2430
 AliAnalysisManager.cxx:2431
 AliAnalysisManager.cxx:2432
 AliAnalysisManager.cxx:2433
 AliAnalysisManager.cxx:2434
 AliAnalysisManager.cxx:2435
 AliAnalysisManager.cxx:2436
 AliAnalysisManager.cxx:2437
 AliAnalysisManager.cxx:2438
 AliAnalysisManager.cxx:2439
 AliAnalysisManager.cxx:2440
 AliAnalysisManager.cxx:2441
 AliAnalysisManager.cxx:2442
 AliAnalysisManager.cxx:2443
 AliAnalysisManager.cxx:2444
 AliAnalysisManager.cxx:2445
 AliAnalysisManager.cxx:2446
 AliAnalysisManager.cxx:2447
 AliAnalysisManager.cxx:2448
 AliAnalysisManager.cxx:2449
 AliAnalysisManager.cxx:2450
 AliAnalysisManager.cxx:2451
 AliAnalysisManager.cxx:2452
 AliAnalysisManager.cxx:2453
 AliAnalysisManager.cxx:2454
 AliAnalysisManager.cxx:2455
 AliAnalysisManager.cxx:2456
 AliAnalysisManager.cxx:2457
 AliAnalysisManager.cxx:2458
 AliAnalysisManager.cxx:2459
 AliAnalysisManager.cxx:2460
 AliAnalysisManager.cxx:2461
 AliAnalysisManager.cxx:2462
 AliAnalysisManager.cxx:2463
 AliAnalysisManager.cxx:2464
 AliAnalysisManager.cxx:2465
 AliAnalysisManager.cxx:2466
 AliAnalysisManager.cxx:2467
 AliAnalysisManager.cxx:2468
 AliAnalysisManager.cxx:2469
 AliAnalysisManager.cxx:2470
 AliAnalysisManager.cxx:2471
 AliAnalysisManager.cxx:2472
 AliAnalysisManager.cxx:2473
 AliAnalysisManager.cxx:2474
 AliAnalysisManager.cxx:2475
 AliAnalysisManager.cxx:2476
 AliAnalysisManager.cxx:2477
 AliAnalysisManager.cxx:2478
 AliAnalysisManager.cxx:2479
 AliAnalysisManager.cxx:2480
 AliAnalysisManager.cxx:2481
 AliAnalysisManager.cxx:2482
 AliAnalysisManager.cxx:2483
 AliAnalysisManager.cxx:2484
 AliAnalysisManager.cxx:2485
 AliAnalysisManager.cxx:2486
 AliAnalysisManager.cxx:2487
 AliAnalysisManager.cxx:2488
 AliAnalysisManager.cxx:2489
 AliAnalysisManager.cxx:2490
 AliAnalysisManager.cxx:2491
 AliAnalysisManager.cxx:2492
 AliAnalysisManager.cxx:2493
 AliAnalysisManager.cxx:2494
 AliAnalysisManager.cxx:2495
 AliAnalysisManager.cxx:2496
 AliAnalysisManager.cxx:2497
 AliAnalysisManager.cxx:2498
 AliAnalysisManager.cxx:2499
 AliAnalysisManager.cxx:2500
 AliAnalysisManager.cxx:2501
 AliAnalysisManager.cxx:2502
 AliAnalysisManager.cxx:2503
 AliAnalysisManager.cxx:2504
 AliAnalysisManager.cxx:2505
 AliAnalysisManager.cxx:2506
 AliAnalysisManager.cxx:2507
 AliAnalysisManager.cxx:2508
 AliAnalysisManager.cxx:2509
 AliAnalysisManager.cxx:2510
 AliAnalysisManager.cxx:2511
 AliAnalysisManager.cxx:2512
 AliAnalysisManager.cxx:2513
 AliAnalysisManager.cxx:2514
 AliAnalysisManager.cxx:2515
 AliAnalysisManager.cxx:2516
 AliAnalysisManager.cxx:2517
 AliAnalysisManager.cxx:2518
 AliAnalysisManager.cxx:2519
 AliAnalysisManager.cxx:2520
 AliAnalysisManager.cxx:2521
 AliAnalysisManager.cxx:2522
 AliAnalysisManager.cxx:2523
 AliAnalysisManager.cxx:2524
 AliAnalysisManager.cxx:2525
 AliAnalysisManager.cxx:2526
 AliAnalysisManager.cxx:2527
 AliAnalysisManager.cxx:2528
 AliAnalysisManager.cxx:2529
 AliAnalysisManager.cxx:2530
 AliAnalysisManager.cxx:2531
 AliAnalysisManager.cxx:2532
 AliAnalysisManager.cxx:2533
 AliAnalysisManager.cxx:2534
 AliAnalysisManager.cxx:2535
 AliAnalysisManager.cxx:2536
 AliAnalysisManager.cxx:2537
 AliAnalysisManager.cxx:2538
 AliAnalysisManager.cxx:2539
 AliAnalysisManager.cxx:2540
 AliAnalysisManager.cxx:2541
 AliAnalysisManager.cxx:2542
 AliAnalysisManager.cxx:2543
 AliAnalysisManager.cxx:2544
 AliAnalysisManager.cxx:2545
 AliAnalysisManager.cxx:2546
 AliAnalysisManager.cxx:2547
 AliAnalysisManager.cxx:2548
 AliAnalysisManager.cxx:2549
 AliAnalysisManager.cxx:2550
 AliAnalysisManager.cxx:2551
 AliAnalysisManager.cxx:2552
 AliAnalysisManager.cxx:2553
 AliAnalysisManager.cxx:2554
 AliAnalysisManager.cxx:2555
 AliAnalysisManager.cxx:2556
 AliAnalysisManager.cxx:2557
 AliAnalysisManager.cxx:2558
 AliAnalysisManager.cxx:2559
 AliAnalysisManager.cxx:2560
 AliAnalysisManager.cxx:2561
 AliAnalysisManager.cxx:2562
 AliAnalysisManager.cxx:2563
 AliAnalysisManager.cxx:2564
 AliAnalysisManager.cxx:2565
 AliAnalysisManager.cxx:2566
 AliAnalysisManager.cxx:2567
 AliAnalysisManager.cxx:2568
 AliAnalysisManager.cxx:2569
 AliAnalysisManager.cxx:2570
 AliAnalysisManager.cxx:2571
 AliAnalysisManager.cxx:2572
 AliAnalysisManager.cxx:2573
 AliAnalysisManager.cxx:2574
 AliAnalysisManager.cxx:2575
 AliAnalysisManager.cxx:2576
 AliAnalysisManager.cxx:2577
 AliAnalysisManager.cxx:2578
 AliAnalysisManager.cxx:2579
 AliAnalysisManager.cxx:2580
 AliAnalysisManager.cxx:2581
 AliAnalysisManager.cxx:2582
 AliAnalysisManager.cxx:2583
 AliAnalysisManager.cxx:2584
 AliAnalysisManager.cxx:2585
 AliAnalysisManager.cxx:2586
 AliAnalysisManager.cxx:2587
 AliAnalysisManager.cxx:2588
 AliAnalysisManager.cxx:2589
 AliAnalysisManager.cxx:2590
 AliAnalysisManager.cxx:2591
 AliAnalysisManager.cxx:2592
 AliAnalysisManager.cxx:2593
 AliAnalysisManager.cxx:2594
 AliAnalysisManager.cxx:2595
 AliAnalysisManager.cxx:2596
 AliAnalysisManager.cxx:2597
 AliAnalysisManager.cxx:2598
 AliAnalysisManager.cxx:2599
 AliAnalysisManager.cxx:2600
 AliAnalysisManager.cxx:2601
 AliAnalysisManager.cxx:2602
 AliAnalysisManager.cxx:2603
 AliAnalysisManager.cxx:2604
 AliAnalysisManager.cxx:2605
 AliAnalysisManager.cxx:2606
 AliAnalysisManager.cxx:2607
 AliAnalysisManager.cxx:2608
 AliAnalysisManager.cxx:2609
 AliAnalysisManager.cxx:2610
 AliAnalysisManager.cxx:2611
 AliAnalysisManager.cxx:2612
 AliAnalysisManager.cxx:2613
 AliAnalysisManager.cxx:2614
 AliAnalysisManager.cxx:2615
 AliAnalysisManager.cxx:2616
 AliAnalysisManager.cxx:2617
 AliAnalysisManager.cxx:2618
 AliAnalysisManager.cxx:2619
 AliAnalysisManager.cxx:2620
 AliAnalysisManager.cxx:2621
 AliAnalysisManager.cxx:2622
 AliAnalysisManager.cxx:2623
 AliAnalysisManager.cxx:2624
 AliAnalysisManager.cxx:2625
 AliAnalysisManager.cxx:2626
 AliAnalysisManager.cxx:2627
 AliAnalysisManager.cxx:2628
 AliAnalysisManager.cxx:2629
 AliAnalysisManager.cxx:2630
 AliAnalysisManager.cxx:2631
 AliAnalysisManager.cxx:2632
 AliAnalysisManager.cxx:2633
 AliAnalysisManager.cxx:2634
 AliAnalysisManager.cxx:2635
 AliAnalysisManager.cxx:2636
 AliAnalysisManager.cxx:2637
 AliAnalysisManager.cxx:2638
 AliAnalysisManager.cxx:2639
 AliAnalysisManager.cxx:2640
 AliAnalysisManager.cxx:2641
 AliAnalysisManager.cxx:2642
 AliAnalysisManager.cxx:2643
 AliAnalysisManager.cxx:2644
 AliAnalysisManager.cxx:2645
 AliAnalysisManager.cxx:2646
 AliAnalysisManager.cxx:2647
 AliAnalysisManager.cxx:2648
 AliAnalysisManager.cxx:2649
 AliAnalysisManager.cxx:2650
 AliAnalysisManager.cxx:2651
 AliAnalysisManager.cxx:2652
 AliAnalysisManager.cxx:2653
 AliAnalysisManager.cxx:2654
 AliAnalysisManager.cxx:2655
 AliAnalysisManager.cxx:2656
 AliAnalysisManager.cxx:2657
 AliAnalysisManager.cxx:2658
 AliAnalysisManager.cxx:2659
 AliAnalysisManager.cxx:2660
 AliAnalysisManager.cxx:2661
 AliAnalysisManager.cxx:2662
 AliAnalysisManager.cxx:2663
 AliAnalysisManager.cxx:2664
 AliAnalysisManager.cxx:2665
 AliAnalysisManager.cxx:2666
 AliAnalysisManager.cxx:2667
 AliAnalysisManager.cxx:2668
 AliAnalysisManager.cxx:2669
 AliAnalysisManager.cxx:2670
 AliAnalysisManager.cxx:2671
 AliAnalysisManager.cxx:2672
 AliAnalysisManager.cxx:2673
 AliAnalysisManager.cxx:2674
 AliAnalysisManager.cxx:2675
 AliAnalysisManager.cxx:2676
 AliAnalysisManager.cxx:2677
 AliAnalysisManager.cxx:2678
 AliAnalysisManager.cxx:2679
 AliAnalysisManager.cxx:2680
 AliAnalysisManager.cxx:2681
 AliAnalysisManager.cxx:2682
 AliAnalysisManager.cxx:2683
 AliAnalysisManager.cxx:2684
 AliAnalysisManager.cxx:2685
 AliAnalysisManager.cxx:2686
 AliAnalysisManager.cxx:2687
 AliAnalysisManager.cxx:2688
 AliAnalysisManager.cxx:2689
 AliAnalysisManager.cxx:2690
 AliAnalysisManager.cxx:2691
 AliAnalysisManager.cxx:2692
 AliAnalysisManager.cxx:2693
 AliAnalysisManager.cxx:2694
 AliAnalysisManager.cxx:2695
 AliAnalysisManager.cxx:2696
 AliAnalysisManager.cxx:2697
 AliAnalysisManager.cxx:2698
 AliAnalysisManager.cxx:2699
 AliAnalysisManager.cxx:2700
 AliAnalysisManager.cxx:2701
 AliAnalysisManager.cxx:2702
 AliAnalysisManager.cxx:2703
 AliAnalysisManager.cxx:2704
 AliAnalysisManager.cxx:2705
 AliAnalysisManager.cxx:2706
 AliAnalysisManager.cxx:2707
 AliAnalysisManager.cxx:2708
 AliAnalysisManager.cxx:2709
 AliAnalysisManager.cxx:2710
 AliAnalysisManager.cxx:2711
 AliAnalysisManager.cxx:2712
 AliAnalysisManager.cxx:2713
 AliAnalysisManager.cxx:2714
 AliAnalysisManager.cxx:2715
 AliAnalysisManager.cxx:2716
 AliAnalysisManager.cxx:2717
 AliAnalysisManager.cxx:2718
 AliAnalysisManager.cxx:2719
 AliAnalysisManager.cxx:2720
 AliAnalysisManager.cxx:2721
 AliAnalysisManager.cxx:2722
 AliAnalysisManager.cxx:2723
 AliAnalysisManager.cxx:2724
 AliAnalysisManager.cxx:2725
 AliAnalysisManager.cxx:2726
 AliAnalysisManager.cxx:2727
 AliAnalysisManager.cxx:2728
 AliAnalysisManager.cxx:2729
 AliAnalysisManager.cxx:2730
 AliAnalysisManager.cxx:2731
 AliAnalysisManager.cxx:2732
 AliAnalysisManager.cxx:2733
 AliAnalysisManager.cxx:2734
 AliAnalysisManager.cxx:2735
 AliAnalysisManager.cxx:2736
 AliAnalysisManager.cxx:2737
 AliAnalysisManager.cxx:2738
 AliAnalysisManager.cxx:2739
 AliAnalysisManager.cxx:2740
 AliAnalysisManager.cxx:2741
 AliAnalysisManager.cxx:2742
 AliAnalysisManager.cxx:2743
 AliAnalysisManager.cxx:2744
 AliAnalysisManager.cxx:2745
 AliAnalysisManager.cxx:2746
 AliAnalysisManager.cxx:2747
 AliAnalysisManager.cxx:2748
 AliAnalysisManager.cxx:2749
 AliAnalysisManager.cxx:2750
 AliAnalysisManager.cxx:2751
 AliAnalysisManager.cxx:2752
 AliAnalysisManager.cxx:2753
 AliAnalysisManager.cxx:2754
 AliAnalysisManager.cxx:2755
 AliAnalysisManager.cxx:2756
 AliAnalysisManager.cxx:2757
 AliAnalysisManager.cxx:2758
 AliAnalysisManager.cxx:2759
 AliAnalysisManager.cxx:2760
 AliAnalysisManager.cxx:2761
 AliAnalysisManager.cxx:2762
 AliAnalysisManager.cxx:2763
 AliAnalysisManager.cxx:2764
 AliAnalysisManager.cxx:2765
 AliAnalysisManager.cxx:2766
 AliAnalysisManager.cxx:2767
 AliAnalysisManager.cxx:2768
 AliAnalysisManager.cxx:2769
 AliAnalysisManager.cxx:2770
 AliAnalysisManager.cxx:2771
 AliAnalysisManager.cxx:2772
 AliAnalysisManager.cxx:2773
 AliAnalysisManager.cxx:2774
 AliAnalysisManager.cxx:2775
 AliAnalysisManager.cxx:2776
 AliAnalysisManager.cxx:2777
 AliAnalysisManager.cxx:2778
 AliAnalysisManager.cxx:2779
 AliAnalysisManager.cxx:2780
 AliAnalysisManager.cxx:2781
 AliAnalysisManager.cxx:2782
 AliAnalysisManager.cxx:2783
 AliAnalysisManager.cxx:2784
 AliAnalysisManager.cxx:2785
 AliAnalysisManager.cxx:2786
 AliAnalysisManager.cxx:2787
 AliAnalysisManager.cxx:2788
 AliAnalysisManager.cxx:2789
 AliAnalysisManager.cxx:2790
 AliAnalysisManager.cxx:2791
 AliAnalysisManager.cxx:2792
 AliAnalysisManager.cxx:2793
 AliAnalysisManager.cxx:2794
 AliAnalysisManager.cxx:2795
 AliAnalysisManager.cxx:2796
 AliAnalysisManager.cxx:2797
 AliAnalysisManager.cxx:2798
 AliAnalysisManager.cxx:2799
 AliAnalysisManager.cxx:2800
 AliAnalysisManager.cxx:2801
 AliAnalysisManager.cxx:2802
 AliAnalysisManager.cxx:2803
 AliAnalysisManager.cxx:2804
 AliAnalysisManager.cxx:2805
 AliAnalysisManager.cxx:2806
 AliAnalysisManager.cxx:2807
 AliAnalysisManager.cxx:2808
 AliAnalysisManager.cxx:2809
 AliAnalysisManager.cxx:2810
 AliAnalysisManager.cxx:2811
 AliAnalysisManager.cxx:2812
 AliAnalysisManager.cxx:2813
 AliAnalysisManager.cxx:2814
 AliAnalysisManager.cxx:2815
 AliAnalysisManager.cxx:2816
 AliAnalysisManager.cxx:2817
 AliAnalysisManager.cxx:2818
 AliAnalysisManager.cxx:2819
 AliAnalysisManager.cxx:2820
 AliAnalysisManager.cxx:2821
 AliAnalysisManager.cxx:2822
 AliAnalysisManager.cxx:2823
 AliAnalysisManager.cxx:2824
 AliAnalysisManager.cxx:2825
 AliAnalysisManager.cxx:2826
 AliAnalysisManager.cxx:2827
 AliAnalysisManager.cxx:2828
 AliAnalysisManager.cxx:2829
 AliAnalysisManager.cxx:2830
 AliAnalysisManager.cxx:2831
 AliAnalysisManager.cxx:2832
 AliAnalysisManager.cxx:2833
 AliAnalysisManager.cxx:2834
 AliAnalysisManager.cxx:2835
 AliAnalysisManager.cxx:2836
 AliAnalysisManager.cxx:2837
 AliAnalysisManager.cxx:2838
 AliAnalysisManager.cxx:2839
 AliAnalysisManager.cxx:2840
 AliAnalysisManager.cxx:2841
 AliAnalysisManager.cxx:2842
 AliAnalysisManager.cxx:2843
 AliAnalysisManager.cxx:2844
 AliAnalysisManager.cxx:2845
 AliAnalysisManager.cxx:2846
 AliAnalysisManager.cxx:2847
 AliAnalysisManager.cxx:2848
 AliAnalysisManager.cxx:2849
 AliAnalysisManager.cxx:2850
 AliAnalysisManager.cxx:2851
 AliAnalysisManager.cxx:2852
 AliAnalysisManager.cxx:2853
 AliAnalysisManager.cxx:2854
 AliAnalysisManager.cxx:2855
 AliAnalysisManager.cxx:2856
 AliAnalysisManager.cxx:2857
 AliAnalysisManager.cxx:2858
 AliAnalysisManager.cxx:2859
 AliAnalysisManager.cxx:2860
 AliAnalysisManager.cxx:2861
 AliAnalysisManager.cxx:2862
 AliAnalysisManager.cxx:2863
 AliAnalysisManager.cxx:2864
 AliAnalysisManager.cxx:2865
 AliAnalysisManager.cxx:2866
 AliAnalysisManager.cxx:2867
 AliAnalysisManager.cxx:2868
 AliAnalysisManager.cxx:2869
 AliAnalysisManager.cxx:2870
 AliAnalysisManager.cxx:2871
 AliAnalysisManager.cxx:2872
 AliAnalysisManager.cxx:2873
 AliAnalysisManager.cxx:2874
 AliAnalysisManager.cxx:2875
 AliAnalysisManager.cxx:2876
 AliAnalysisManager.cxx:2877
 AliAnalysisManager.cxx:2878
 AliAnalysisManager.cxx:2879
 AliAnalysisManager.cxx:2880
 AliAnalysisManager.cxx:2881
 AliAnalysisManager.cxx:2882
 AliAnalysisManager.cxx:2883
 AliAnalysisManager.cxx:2884
 AliAnalysisManager.cxx:2885
 AliAnalysisManager.cxx:2886
 AliAnalysisManager.cxx:2887
 AliAnalysisManager.cxx:2888
 AliAnalysisManager.cxx:2889
 AliAnalysisManager.cxx:2890
 AliAnalysisManager.cxx:2891
 AliAnalysisManager.cxx:2892
 AliAnalysisManager.cxx:2893
 AliAnalysisManager.cxx:2894
 AliAnalysisManager.cxx:2895
 AliAnalysisManager.cxx:2896
 AliAnalysisManager.cxx:2897
 AliAnalysisManager.cxx:2898
 AliAnalysisManager.cxx:2899
 AliAnalysisManager.cxx:2900
 AliAnalysisManager.cxx:2901
 AliAnalysisManager.cxx:2902
 AliAnalysisManager.cxx:2903
 AliAnalysisManager.cxx:2904
 AliAnalysisManager.cxx:2905
 AliAnalysisManager.cxx:2906
 AliAnalysisManager.cxx:2907
 AliAnalysisManager.cxx:2908
 AliAnalysisManager.cxx:2909
 AliAnalysisManager.cxx:2910
 AliAnalysisManager.cxx:2911
 AliAnalysisManager.cxx:2912
 AliAnalysisManager.cxx:2913
 AliAnalysisManager.cxx:2914
 AliAnalysisManager.cxx:2915
 AliAnalysisManager.cxx:2916
 AliAnalysisManager.cxx:2917
 AliAnalysisManager.cxx:2918
 AliAnalysisManager.cxx:2919
 AliAnalysisManager.cxx:2920
 AliAnalysisManager.cxx:2921
 AliAnalysisManager.cxx:2922
 AliAnalysisManager.cxx:2923
 AliAnalysisManager.cxx:2924
 AliAnalysisManager.cxx:2925
 AliAnalysisManager.cxx:2926
 AliAnalysisManager.cxx:2927
 AliAnalysisManager.cxx:2928
 AliAnalysisManager.cxx:2929
 AliAnalysisManager.cxx:2930
 AliAnalysisManager.cxx:2931
 AliAnalysisManager.cxx:2932
 AliAnalysisManager.cxx:2933
 AliAnalysisManager.cxx:2934
 AliAnalysisManager.cxx:2935
 AliAnalysisManager.cxx:2936
 AliAnalysisManager.cxx:2937
 AliAnalysisManager.cxx:2938
 AliAnalysisManager.cxx:2939
 AliAnalysisManager.cxx:2940
 AliAnalysisManager.cxx:2941
 AliAnalysisManager.cxx:2942
 AliAnalysisManager.cxx:2943
 AliAnalysisManager.cxx:2944
 AliAnalysisManager.cxx:2945
 AliAnalysisManager.cxx:2946
 AliAnalysisManager.cxx:2947
 AliAnalysisManager.cxx:2948
 AliAnalysisManager.cxx:2949
 AliAnalysisManager.cxx:2950
 AliAnalysisManager.cxx:2951
 AliAnalysisManager.cxx:2952
 AliAnalysisManager.cxx:2953
 AliAnalysisManager.cxx:2954
 AliAnalysisManager.cxx:2955
 AliAnalysisManager.cxx:2956
 AliAnalysisManager.cxx:2957
 AliAnalysisManager.cxx:2958
 AliAnalysisManager.cxx:2959
 AliAnalysisManager.cxx:2960
 AliAnalysisManager.cxx:2961
 AliAnalysisManager.cxx:2962
 AliAnalysisManager.cxx:2963
 AliAnalysisManager.cxx:2964
 AliAnalysisManager.cxx:2965
 AliAnalysisManager.cxx:2966
 AliAnalysisManager.cxx:2967
 AliAnalysisManager.cxx:2968
 AliAnalysisManager.cxx:2969
 AliAnalysisManager.cxx:2970
 AliAnalysisManager.cxx:2971
 AliAnalysisManager.cxx:2972
 AliAnalysisManager.cxx:2973
 AliAnalysisManager.cxx:2974
 AliAnalysisManager.cxx:2975
 AliAnalysisManager.cxx:2976
 AliAnalysisManager.cxx:2977
 AliAnalysisManager.cxx:2978
 AliAnalysisManager.cxx:2979
 AliAnalysisManager.cxx:2980
 AliAnalysisManager.cxx:2981
 AliAnalysisManager.cxx:2982
 AliAnalysisManager.cxx:2983
 AliAnalysisManager.cxx:2984
 AliAnalysisManager.cxx:2985
 AliAnalysisManager.cxx:2986
 AliAnalysisManager.cxx:2987
 AliAnalysisManager.cxx:2988
 AliAnalysisManager.cxx:2989
 AliAnalysisManager.cxx:2990
 AliAnalysisManager.cxx:2991
 AliAnalysisManager.cxx:2992
 AliAnalysisManager.cxx:2993
 AliAnalysisManager.cxx:2994
 AliAnalysisManager.cxx:2995
 AliAnalysisManager.cxx:2996
 AliAnalysisManager.cxx:2997
 AliAnalysisManager.cxx:2998
 AliAnalysisManager.cxx:2999
 AliAnalysisManager.cxx:3000
 AliAnalysisManager.cxx:3001
 AliAnalysisManager.cxx:3002
 AliAnalysisManager.cxx:3003
 AliAnalysisManager.cxx:3004
 AliAnalysisManager.cxx:3005
 AliAnalysisManager.cxx:3006
 AliAnalysisManager.cxx:3007
 AliAnalysisManager.cxx:3008
 AliAnalysisManager.cxx:3009
 AliAnalysisManager.cxx:3010
 AliAnalysisManager.cxx:3011
 AliAnalysisManager.cxx:3012
 AliAnalysisManager.cxx:3013
 AliAnalysisManager.cxx:3014
 AliAnalysisManager.cxx:3015
 AliAnalysisManager.cxx:3016
 AliAnalysisManager.cxx:3017
 AliAnalysisManager.cxx:3018
 AliAnalysisManager.cxx:3019
 AliAnalysisManager.cxx:3020
 AliAnalysisManager.cxx:3021
 AliAnalysisManager.cxx:3022
 AliAnalysisManager.cxx:3023
 AliAnalysisManager.cxx:3024
 AliAnalysisManager.cxx:3025
 AliAnalysisManager.cxx:3026
 AliAnalysisManager.cxx:3027
 AliAnalysisManager.cxx:3028
 AliAnalysisManager.cxx:3029
 AliAnalysisManager.cxx:3030
 AliAnalysisManager.cxx:3031
 AliAnalysisManager.cxx:3032
 AliAnalysisManager.cxx:3033
 AliAnalysisManager.cxx:3034
 AliAnalysisManager.cxx:3035
 AliAnalysisManager.cxx:3036
 AliAnalysisManager.cxx:3037
 AliAnalysisManager.cxx:3038
 AliAnalysisManager.cxx:3039
 AliAnalysisManager.cxx:3040
 AliAnalysisManager.cxx:3041
 AliAnalysisManager.cxx:3042
 AliAnalysisManager.cxx:3043
 AliAnalysisManager.cxx:3044
 AliAnalysisManager.cxx:3045
 AliAnalysisManager.cxx:3046
 AliAnalysisManager.cxx:3047
 AliAnalysisManager.cxx:3048
 AliAnalysisManager.cxx:3049
 AliAnalysisManager.cxx:3050
 AliAnalysisManager.cxx:3051
 AliAnalysisManager.cxx:3052
 AliAnalysisManager.cxx:3053
 AliAnalysisManager.cxx:3054
 AliAnalysisManager.cxx:3055
 AliAnalysisManager.cxx:3056
 AliAnalysisManager.cxx:3057
 AliAnalysisManager.cxx:3058
 AliAnalysisManager.cxx:3059
 AliAnalysisManager.cxx:3060
 AliAnalysisManager.cxx:3061
 AliAnalysisManager.cxx:3062
 AliAnalysisManager.cxx:3063
 AliAnalysisManager.cxx:3064
 AliAnalysisManager.cxx:3065
 AliAnalysisManager.cxx:3066
 AliAnalysisManager.cxx:3067
 AliAnalysisManager.cxx:3068
 AliAnalysisManager.cxx:3069
 AliAnalysisManager.cxx:3070
 AliAnalysisManager.cxx:3071
 AliAnalysisManager.cxx:3072
 AliAnalysisManager.cxx:3073
 AliAnalysisManager.cxx:3074
 AliAnalysisManager.cxx:3075
 AliAnalysisManager.cxx:3076
 AliAnalysisManager.cxx:3077
 AliAnalysisManager.cxx:3078
 AliAnalysisManager.cxx:3079
 AliAnalysisManager.cxx:3080
 AliAnalysisManager.cxx:3081
 AliAnalysisManager.cxx:3082
 AliAnalysisManager.cxx:3083
 AliAnalysisManager.cxx:3084
 AliAnalysisManager.cxx:3085
 AliAnalysisManager.cxx:3086
 AliAnalysisManager.cxx:3087
 AliAnalysisManager.cxx:3088
 AliAnalysisManager.cxx:3089
 AliAnalysisManager.cxx:3090
 AliAnalysisManager.cxx:3091
 AliAnalysisManager.cxx:3092
 AliAnalysisManager.cxx:3093
 AliAnalysisManager.cxx:3094
 AliAnalysisManager.cxx:3095
 AliAnalysisManager.cxx:3096
 AliAnalysisManager.cxx:3097