ANALYSIS/AliAnalysisManager.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 /* $Id$ */
  17 // Author: Andrei Gheata, 31/05/2006
  18
  19 //==============================================================================
  20 //   AliAnalysysManager - Manager analysis class. Allows creation of several
  21 // analysis tasks and data containers storing their input/output. Allows
  22 // connecting/chaining tasks via shared data containers. Serializes the current
  23 // event for all tasks depending only on initial input data.
  24 //==============================================================================
  25 //
  26 //==============================================================================
  27
  28 #include <Riostream.h>
  29
  30 #include <TClass.h>
  31 #include <TFile.h>
  32 #include <TMethodCall.h>
  33 #include <TChain.h>
  34 #include <TSystem.h>
  35 #include <TROOT.h>
  36
  37 #include "AliAnalysisTask.h"
  38 #include "AliAnalysisDataContainer.h"
  39 #include "AliAnalysisDataSlot.h"
  40 #include "AliVEventHandler.h"
  41 #include "AliAnalysisManager.h"
  42
  43 ClassImp(AliAnalysisManager)
  44
  45 AliAnalysisManager *AliAnalysisManager::fgAnalysisManager = NULL;
  46
  47 //______________________________________________________________________________
  48 AliAnalysisManager::AliAnalysisManager(const char *name, const char *title)
  49                    :TNamed(name,title),
  50                     fTree(NULL),
  51                     fInputEventHandler(NULL),
  52                     fOutputEventHandler(NULL),
  53                     fMCtruthEventHandler(NULL),
  54                     fCurrentEntry(-1),
  55                     fMode(kLocalAnalysis),
  56                     fInitOK(kFALSE),
  57                     fDebug(0),
  58                     fTasks(NULL),
  59                     fTopTasks(NULL),
  60                     fZombies(NULL),
  61                     fContainers(NULL),
  62                     fInputs(NULL),
  63                     fOutputs(NULL)
  64 {
  65 // Default constructor.
  66    fgAnalysisManager = this;
  67    fTasks      = new TObjArray();
  68    fTopTasks   = new TObjArray();
  69    fZombies    = new TObjArray();
  70    fContainers = new TObjArray();
  71    fInputs     = new TObjArray();
  72    fOutputs    = new TObjArray();
  73    SetEventLoop(kTRUE);
  74 }
  75
  76 //______________________________________________________________________________
  77 AliAnalysisManager::AliAnalysisManager(const AliAnalysisManager& other)
  78                    :TNamed(other),
  79                     fTree(NULL),
  80                     fInputEventHandler(NULL),
  81                     fOutputEventHandler(NULL),
  82                     fMCtruthEventHandler(NULL),
  83                     fCurrentEntry(-1),
  84                     fMode(other.fMode),
  85                     fInitOK(other.fInitOK),
  86                     fDebug(other.fDebug),
  87                     fTasks(NULL),
  88                     fTopTasks(NULL),
  89                     fZombies(NULL),
  90                     fContainers(NULL),
  91                     fInputs(NULL),
  92                     fOutputs(NULL)
  93 {
  94 // Copy constructor.
  95    fTasks      = new TObjArray(*other.fTasks);
  96    fTopTasks   = new TObjArray(*other.fTopTasks);
  97    fZombies    = new TObjArray(*other.fZombies);
  98    fContainers = new TObjArray(*other.fContainers);
  99    fInputs     = new TObjArray(*other.fInputs);
 100    fOutputs    = new TObjArray(*other.fOutputs);
 101    fgAnalysisManager = this;
 102 }
 103
 104 //______________________________________________________________________________
 105 AliAnalysisManager& AliAnalysisManager::operator=(const AliAnalysisManager& other)
 106 {
 107 // Assignment
 108    if (&other != this) {
 109       TNamed::operator=(other);
 110       fInputEventHandler   = other.fInputEventHandler;
 111       fOutputEventHandler  = other.fOutputEventHandler;
 112       fMCtruthEventHandler = other.fMCtruthEventHandler;
 113       fTree       = NULL;
 114       fCurrentEntry = -1;
 115       fMode       = other.fMode;
 116       fInitOK     = other.fInitOK;
 117       fDebug      = other.fDebug;
 118       fTasks      = new TObjArray(*other.fTasks);
 119       fTopTasks   = new TObjArray(*other.fTopTasks);
 120       fZombies    = new TObjArray(*other.fZombies);
 121       fContainers = new TObjArray(*other.fContainers);
 122       fInputs     = new TObjArray(*other.fInputs);
 123       fOutputs    = new TObjArray(*other.fOutputs);
 124       fgAnalysisManager = this;
 125    }
 126    return *this;
 127 }
 128
 129 //______________________________________________________________________________
 130 AliAnalysisManager::~AliAnalysisManager()
 131 {
 132 // Destructor.
 133    if (fTasks) {fTasks->Delete(); delete fTasks;}
 134    if (fTopTasks) delete fTopTasks;
 135    if (fZombies) delete fZombies;
 136    if (fContainers) {fContainers->Delete(); delete fContainers;}
 137    if (fInputs) delete fInputs;
 138    if (fOutputs) delete fOutputs;
 139    if (fgAnalysisManager==this) fgAnalysisManager = NULL;
 140 }
 141
 142 //______________________________________________________________________________
 143 Int_t AliAnalysisManager::GetEntry(Long64_t entry, Int_t getall)
 144 {
 145 // Read one entry of the tree or a whole branch.
 146    if (fDebug > 1) {
 147       cout << "== AliAnalysisManager::GetEntry()" << endl;
 148    }
 149    fCurrentEntry = entry;
 150    return fTree ? fTree->GetTree()->GetEntry(entry, getall) : 0;
 151 }
 152
 153 //______________________________________________________________________________
 154 void AliAnalysisManager::Init(TTree *tree)
 155 {
 156   // The Init() function is called when the selector needs to initialize
 157   // a new tree or chain. Typically here the branch addresses of the tree
 158   // will be set. It is normaly not necessary to make changes to the
 159   // generated code, but the routine can be extended by the user if needed.
 160   // Init() will be called many times when running with PROOF.
 161    if (!tree) return;
 162    if (fDebug > 1) {
 163       printf("->AliAnalysisManager::Init(%s)\n", tree->GetName());
 164    }
 165
 166    if (fInputEventHandler) {
 167        fInputEventHandler->SetInputTree(tree);
 168        fInputEventHandler->InitIO("proof");
 169    }
 170
 171    if (!fInitOK) InitAnalysis();
 172    if (!fInitOK) return;
 173    fTree = tree;
 174    AliAnalysisDataContainer *top = (AliAnalysisDataContainer*)fInputs->At(0);
 175    if (!top) {
 176       cout<<"Error: No top input container !" <<endl;
 177       return;
 178    }
 179    top->SetData(tree);
 180    if (fDebug > 1) {
 181       printf("<-AliAnalysisManager::Init(%s)\n", tree->GetName());
 182    }
 183 }
 184
 185 //______________________________________________________________________________
 186 void AliAnalysisManager::Begin(TTree *tree)
 187 {
 188   // The Begin() function is called at the start of the query.
 189   // When running with PROOF Begin() is only called on the client.
 190   // The tree argument is deprecated (on PROOF 0 is passed).
 191    if (fDebug > 1) {
 192       cout << "AliAnalysisManager::Begin()" << endl;
 193    }
 194    Init(tree);
 195 }
 196
 197 //______________________________________________________________________________
 198 void AliAnalysisManager::SlaveBegin(TTree *tree)
 199 {
 200   // The SlaveBegin() function is called after the Begin() function.
 201   // When running with PROOF SlaveBegin() is called on each slave server.
 202   // The tree argument is deprecated (on PROOF 0 is passed).
 203    if (fDebug > 1) {
 204       cout << "->AliAnalysisManager::SlaveBegin()" << endl;
 205    }
 206    // Call InitIO of EventHandler
 207    if (fOutputEventHandler) {
 208        if (fMode == kProofAnalysis) {
 209            fOutputEventHandler->InitIO("proof");
 210        } else {
 211            fOutputEventHandler->InitIO("local");
 212        }
 213    }
 214    if (fInputEventHandler) {
 215        if (fMode == kProofAnalysis) {
 216            fInputEventHandler->SetInputTree(tree);
 217            fInputEventHandler->InitIO("proof");
 218        } else {
 219            fInputEventHandler->SetInputTree(tree);
 220            fInputEventHandler->InitIO("local");
 221        }
 222    }
 223
 224    if (fMCtruthEventHandler) {
 225        if (fMode == kProofAnalysis) {
 226            fMCtruthEventHandler->InitIO("proof");
 227        } else {
 228            fMCtruthEventHandler->InitIO("local");
 229        }
 230    }
 231
 232    //
 233    TIter next(fTasks);
 234    AliAnalysisTask *task;
 235    // Call CreateOutputObjects for all tasks
 236    while ((task=(AliAnalysisTask*)next())) {
 237       TDirectory *curdir = gDirectory;
 238       task->CreateOutputObjects();
 239       if (curdir) curdir->cd();
 240    }
 241    if (fMode == kLocalAnalysis)
 242        Init(tree);
 243    if (fDebug > 1) {
 244       cout << "<-AliAnalysisManager::SlaveBegin()" << endl;
 245    }
 246 }
 247
 248 //______________________________________________________________________________
 249 Bool_t AliAnalysisManager::Notify()
 250 {
 251    // The Notify() function is called when a new file is opened. This
 252    // can be either for a new TTree in a TChain or when when a new TTree
 253    // is started when using PROOF. It is normaly not necessary to make changes
 254    // to the generated code, but the routine can be extended by the
 255    // user if needed. The return value is currently not used.
 256     if (fTree) {
 257         TFile *curfile = fTree->GetCurrentFile();
 258         if (curfile && fDebug>1) printf("AliAnalysisManager::Notify() file: %s\n", curfile->GetName());
 259         TIter next(fTasks);
 260         AliAnalysisTask *task;
 261         // Call Notify for all tasks
 262         while ((task=(AliAnalysisTask*)next()))
 263             task->Notify();
 264
 265         // Call Notify of the event handlers
 266         if (fInputEventHandler) {
 267             fInputEventHandler->Notify(curfile->GetName());
 268         }
 269
 270         if (fOutputEventHandler) {
 271             fOutputEventHandler->Notify(curfile->GetName());
 272         }
 273
 274         if (fMCtruthEventHandler) {
 275             fMCtruthEventHandler->Notify(curfile->GetName());
 276         }
 277
 278     }
 279     return kTRUE;
 280 }
 281
 282 //______________________________________________________________________________
 283 Bool_t AliAnalysisManager::Process(Long64_t entry)
 284 {
 285   // The Process() function is called for each entry in the tree (or possibly
 286   // keyed object in the case of PROOF) to be processed. The entry argument
 287   // specifies which entry in the currently loaded tree is to be processed.
 288   // It can be passed to either TTree::GetEntry() or TBranch::GetEntry()
 289   // to read either all or the required parts of the data. When processing
 290   // keyed objects with PROOF, the object is already loaded and is available
 291   // via the fObject pointer.
 292   //
 293   // This function should contain the "body" of the analysis. It can contain
 294   // simple or elaborate selection criteria, run algorithms on the data
 295   // of the event and typically fill histograms.
 296
 297   // WARNING when a selector is used with a TChain, you must use
 298   //  the pointer to the current TTree to call GetEntry(entry).
 299   //  The entry is always the local entry number in the current tree.
 300   //  Assuming that fChain is the pointer to the TChain being processed,
 301   //  use fChain->GetTree()->GetEntry(entry).
 302    if (fDebug > 1) {
 303       cout << "->AliAnalysisManager::Process()" << endl;
 304    }
 305    if (fInputEventHandler)   fInputEventHandler  ->BeginEvent();
 306    if (fOutputEventHandler)  fOutputEventHandler ->BeginEvent();
 307    if (fMCtruthEventHandler) fMCtruthEventHandler->BeginEvent();
 308
 309    GetEntry(entry);
 310    ExecAnalysis();
 311    if (fDebug > 1) {
 312       cout << "<-AliAnalysisManager::Process()" << endl;
 313    }
 314    return kTRUE;
 315 }
 316
 317 //______________________________________________________________________________
 318 void AliAnalysisManager::PackOutput(TList *target)
 319 {
 320   // Pack all output data containers in the output list. Called at SlaveTerminate
 321   // stage in PROOF case for each slave.
 322    if (fDebug > 1) {
 323       cout << "->AliAnalysisManager::PackOutput()" << endl;
 324    }
 325    if (!target) {
 326       Error("PackOutput", "No target. Aborting.");
 327       return;
 328    }
 329    if (fInputEventHandler)   fInputEventHandler  ->Terminate();
 330    if (fOutputEventHandler)  fOutputEventHandler ->Terminate();
 331    if (fMCtruthEventHandler) fMCtruthEventHandler->Terminate();
 332
 333    if (fMode == kProofAnalysis) {
 334       TIter next(fOutputs);
 335       AliAnalysisDataContainer *output;
 336       while ((output=(AliAnalysisDataContainer*)next())) {
 337          if (output->GetData()) {
 338             if (output->GetProducer()->IsPostEventLoop()) continue;
 339             AliAnalysisDataWrapper *wrap = output->ExportData();
 340             // Output wrappers must delete data after merging (AG 13/11/07)
 341             wrap->SetDeleteData(kTRUE);
 342             if (fDebug > 1) printf("   Packing container %s...\n", output->GetName());
 343             target->Add(wrap);
 344          }
 345       }
 346    }
 347    if (fDebug > 1) {
 348       printf("<-AliAnalysisManager::PackOutput: output list contains %d containers\n", target->GetSize());
 349    }
 350 }
 351
 352 //______________________________________________________________________________
 353 void AliAnalysisManager::ImportWrappers(TList *source)
 354 {
 355 // Import data in output containers from wrappers coming in source.
 356    if (fDebug > 1) {
 357       cout << "->AliAnalysisManager::ImportWrappers()" << endl;
 358    }
 359    TIter next(fOutputs);
 360    AliAnalysisDataContainer *cont;
 361    AliAnalysisDataWrapper   *wrap;
 362    Int_t icont = 0;
 363    while ((cont=(AliAnalysisDataContainer*)next())) {
 364       if (cont->GetProducer()->IsPostEventLoop()) continue;
 365       wrap = (AliAnalysisDataWrapper*)source->FindObject(cont->GetName());
 366       if (!wrap && fDebug>1) {
 367          printf("(WW) ImportWrappers: container %s not found in analysis output !\n", cont->GetName());
 368          continue;
 369       }
 370       icont++;
 371       if (fDebug > 1) printf("   Importing data for container %s\n", wrap->GetName());
 372       if (cont->GetFileName()) printf("    -> %s\n", cont->GetFileName());
 373       cont->ImportData(wrap);
 374    }
 375    if (fDebug > 1) {
 376       cout << "<-AliAnalysisManager::ImportWrappers(): "<< icont << " containers imported" << endl;
 377    }
 378 }
 379
 380 //______________________________________________________________________________
 381 void AliAnalysisManager::UnpackOutput(TList *source)
 382 {
 383   // Called by AliAnalysisSelector::Terminate. Output containers should
 384   // be in source in the same order as in fOutputs.
 385    if (fDebug > 1) {
 386       cout << "->AliAnalysisManager::UnpackOutput()" << endl;
 387    }
 388    if (!source) {
 389       Error("UnpackOutput", "No target. Aborting.");
 390       return;
 391    }
 392    if (fDebug > 1) {
 393       printf("   Source list contains %d containers\n", source->GetSize());
 394    }
 395
 396    if (fMode == kProofAnalysis) ImportWrappers(source);
 397
 398    TIter next(fOutputs);
 399    AliAnalysisDataContainer *output;
 400    while ((output=(AliAnalysisDataContainer*)next())) {
 401       if (!output->GetData()) continue;
 402       // Check if there are client tasks that run post event loop
 403       if (output->HasConsumers()) {
 404          // Disable event loop semaphore
 405          output->SetPostEventLoop(kTRUE);
 406          TObjArray *list = output->GetConsumers();
 407          Int_t ncons = list->GetEntriesFast();
 408          for (Int_t i=0; i<ncons; i++) {
 409             AliAnalysisTask *task = (AliAnalysisTask*)list->At(i);
 410             task->CheckNotify(kTRUE);
 411             // If task is active, execute it
 412             if (task->IsPostEventLoop() && task->IsActive()) {
 413                if (fDebug > 1) {
 414                   cout << "== Executing post event loop task " << task->GetName() << endl;
 415                }
 416                task->ExecuteTask();
 417             }
 418          }
 419       }
 420       // Check if the output need to be written to a file.
 421       const char *filename = output->GetFileName();
 422       if (!(strcmp(filename, "default"))) {
 423           if (fOutputEventHandler) filename = fOutputEventHandler->GetOutputFileName();
 424       }
 425
 426       if (!filename || !strlen(filename)) continue;
 427       TFile *file = (TFile*)gROOT->GetListOfFiles()->FindObject(filename);
 428       if (file) file->cd();
 429       else      file = new TFile(filename, "RECREATE");
 430       if (file->IsZombie()) continue;
 431       // Reparent data to this file
 432       TMethodCall callEnv;
 433       if (output->GetData()->IsA())
 434          callEnv.InitWithPrototype(output->GetData()->IsA(), "SetDirectory", "TDirectory*");
 435       if (callEnv.IsValid()) {
 436          callEnv.SetParam((Long_t) file);
 437          callEnv.Execute(output->GetData());
 438       }
 439       output->GetData()->Write();
 440    }
 441    if (fDebug > 1) {
 442       cout << "<-AliAnalysisManager::UnpackOutput()" << endl;
 443    }
 444 }
 445
 446 //______________________________________________________________________________
 447 void AliAnalysisManager::Terminate()
 448 {
 449   // The Terminate() function is the last function to be called during
 450   // a query. It always runs on the client, it can be used to present
 451   // the results graphically.
 452    if (fDebug > 1) {
 453       cout << "->AliAnalysisManager::Terminate()" << endl;
 454    }
 455    AliAnalysisTask *task;
 456    TIter next(fTasks);
 457    // Call Terminate() for tasks
 458    while ((task=(AliAnalysisTask*)next())) task->Terminate();
 459    if (fDebug > 1) {
 460       cout << "<-AliAnalysisManager::Terminate()" << endl;
 461    }
 462    //
 463    if (fInputEventHandler)   fInputEventHandler  ->TerminateIO();
 464    if (fOutputEventHandler)  fOutputEventHandler ->TerminateIO();
 465    if (fMCtruthEventHandler) fMCtruthEventHandler->TerminateIO();
 466 }
 467
 468 //______________________________________________________________________________
 469 void AliAnalysisManager::AddTask(AliAnalysisTask *task)
 470 {
 471 // Adds a user task to the global list of tasks.
 472    task->SetActive(kFALSE);
 473    fTasks->Add(task);
 474 }
 475
 476 //______________________________________________________________________________
 477 AliAnalysisTask *AliAnalysisManager::GetTask(const char *name) const
 478 {
 479 // Retreive task by name.
 480    if (!fTasks) return NULL;
 481    return (AliAnalysisTask*)fTasks->FindObject(name);
 482 }
 483
 484 //______________________________________________________________________________
 485 AliAnalysisDataContainer *AliAnalysisManager::CreateContainer(const char *name,
 486                                 TClass *datatype, EAliAnalysisContType type, const char *filename)
 487 {
 488 // Create a data container of a certain type. Types can be:
 489 //   kExchangeContainer  = 0, used to exchange date between tasks
 490 //   kInputContainer   = 1, used to store input data
 491 //   kOutputContainer  = 2, used for posting results
 492    if (fContainers->FindObject(name)) {
 493       Error("CreateContainer","A container named %s already defined !\n",name);
 494       return NULL;
 495    }
 496    AliAnalysisDataContainer *cont = new AliAnalysisDataContainer(name, datatype);
 497    fContainers->Add(cont);
 498    switch (type) {
 499       case kInputContainer:
 500          fInputs->Add(cont);
 501          break;
 502       case kOutputContainer:
 503          fOutputs->Add(cont);
 504          if (filename && strlen(filename)) cont->SetFileName(filename);
 505          break;
 506       case kExchangeContainer:
 507          break;
 508    }
 509    return cont;
 510 }
 511
 512 //______________________________________________________________________________
 513 Bool_t AliAnalysisManager::ConnectInput(AliAnalysisTask *task, Int_t islot,
 514                                         AliAnalysisDataContainer *cont)
 515 {
 516 // Connect input of an existing task to a data container.
 517    if (!fTasks->FindObject(task)) {
 518       AddTask(task);
 519       Warning("ConnectInput", "Task %s not registered. Now owned by analysis manager", task->GetName());
 520    }
 521    Bool_t connected = task->ConnectInput(islot, cont);
 522    return connected;
 523 }
 524
 525 //______________________________________________________________________________
 526 Bool_t AliAnalysisManager::ConnectOutput(AliAnalysisTask *task, Int_t islot,
 527                                         AliAnalysisDataContainer *cont)
 528 {
 529 // Connect output of an existing task to a data container.
 530    if (!fTasks->FindObject(task)) {
 531       AddTask(task);
 532       Warning("ConnectOutput", "Task %s not registered. Now owned by analysis manager", task->GetName());
 533    }
 534    Bool_t connected = task->ConnectOutput(islot, cont);
 535    return connected;
 536 }
 537
 538 //______________________________________________________________________________
 539 void AliAnalysisManager::CleanContainers()
 540 {
 541 // Clean data from all containers that have already finished all client tasks.
 542    TIter next(fContainers);
 543    AliAnalysisDataContainer *cont;
 544    while ((cont=(AliAnalysisDataContainer *)next())) {
 545       if (cont->IsOwnedData() &&
 546           cont->IsDataReady() &&
 547           cont->ClientsExecuted()) cont->DeleteData();
 548    }
 549 }
 550
 551 //______________________________________________________________________________
 552 Bool_t AliAnalysisManager::InitAnalysis()
 553 {
 554 // Initialization of analysis chain of tasks. Should be called after all tasks
 555 // and data containers are properly connected
 556    // Check for input/output containers
 557    fInitOK = kFALSE;
 558    // Check for top tasks (depending only on input data containers)
 559    if (!fTasks->First()) {
 560       Error("InitAnalysis", "Analysis has no tasks !");
 561       return kFALSE;
 562    }
 563    TIter next(fTasks);
 564    AliAnalysisTask *task;
 565    AliAnalysisDataContainer *cont;
 566    Int_t ntop = 0;
 567    Int_t nzombies = 0;
 568    Bool_t iszombie = kFALSE;
 569    Bool_t istop = kTRUE;
 570    Int_t i;
 571    while ((task=(AliAnalysisTask*)next())) {
 572       istop = kTRUE;
 573       iszombie = kFALSE;
 574       Int_t ninputs = task->GetNinputs();
 575       for (i=0; i<ninputs; i++) {
 576          cont = task->GetInputSlot(i)->GetContainer();
 577          if (!cont) {
 578             if (!iszombie) {
 579                task->SetZombie();
 580                fZombies->Add(task);
 581                nzombies++;
 582                iszombie = kTRUE;
 583             }
 584             Error("InitAnalysis", "Input slot %d of task %s has no container connected ! Declared zombie...",
 585                   i, task->GetName());
 586          }
 587          if (iszombie) continue;
 588          // Check if cont is an input container
 589          if (istop && !fInputs->FindObject(cont)) istop=kFALSE;
 590          // Connect to parent task
 591       }
 592       if (istop) {
 593          ntop++;
 594          fTopTasks->Add(task);
 595       }
 596    }
 597    if (!ntop) {
 598       Error("InitAnalysis", "No top task defined. At least one task should be connected only to input containers");
 599       return kFALSE;
 600    }
 601    // Check now if there are orphan tasks
 602    for (i=0; i<ntop; i++) {
 603       task = (AliAnalysisTask*)fTopTasks->At(i);
 604       task->SetUsed();
 605    }
 606    Int_t norphans = 0;
 607    next.Reset();
 608    while ((task=(AliAnalysisTask*)next())) {
 609       if (!task->IsUsed()) {
 610          norphans++;
 611          Warning("InitAnalysis", "Task %s is orphan", task->GetName());
 612       }
 613    }
 614    // Check the task hierarchy (no parent task should depend on data provided
 615    // by a daughter task)
 616    for (i=0; i<ntop; i++) {
 617       task = (AliAnalysisTask*)fTopTasks->At(i);
 618       if (task->CheckCircularDeps()) {
 619          Error("InitAnalysis", "Found illegal circular dependencies between following tasks:");
 620          PrintStatus("dep");
 621          return kFALSE;
 622       }
 623    }
 624    // Check that all containers feeding post-event loop tasks are in the outputs list
 625    TIter nextcont(fContainers); // loop over all containers
 626    while ((cont=(AliAnalysisDataContainer*)nextcont())) {
 627       if (!cont->IsPostEventLoop() && !fOutputs->FindObject(cont)) {
 628          if (cont->HasConsumers()) {
 629          // Check if one of the consumers is post event loop
 630             TIter nextconsumer(cont->GetConsumers());
 631             while ((task=(AliAnalysisTask*)nextconsumer())) {
 632                if (task->IsPostEventLoop()) {
 633                   fOutputs->Add(cont);
 634                   break;
 635                }
 636             }
 637          }
 638       }
 639    }
 640    fInitOK = kTRUE;
 641    return kTRUE;
 642 }
 643
 644 //______________________________________________________________________________
 645 void AliAnalysisManager::PrintStatus(Option_t *option) const
 646 {
 647 // Print task hierarchy.
 648    TIter next(fTopTasks);
 649    AliAnalysisTask *task;
 650    while ((task=(AliAnalysisTask*)next()))
 651       task->PrintTask(option);
 652 }
 653
 654 //______________________________________________________________________________
 655 void AliAnalysisManager::ResetAnalysis()
 656 {
 657 // Reset all execution flags and clean containers.
 658    CleanContainers();
 659 }
 660
 661 //______________________________________________________________________________
 662 void AliAnalysisManager::StartAnalysis(const char *type, TTree *tree)
 663 {
 664 // Start analysis for this manager. Analysis task can be: LOCAL, PROOF or GRID.
 665    if (!fInitOK) {
 666       Error("StartAnalysis","Analysis manager was not initialized !");
 667       return;
 668    }
 669    if (fDebug>1) {
 670       cout << "StartAnalysis: " << GetName() << endl;
 671    }
 672    TString anaType = type;
 673    anaType.ToLower();
 674    fMode = kLocalAnalysis;
 675    if (tree) {
 676       if (anaType.Contains("proof"))     fMode = kProofAnalysis;
 677       else if (anaType.Contains("grid")) fMode = kGridAnalysis;
 678    }
 679    if (fMode == kGridAnalysis) {
 680       Warning("StartAnalysis", "GRID analysis mode not implemented. Running local.");
 681       fMode = kLocalAnalysis;
 682    }
 683    char line[128];
 684    SetEventLoop(kFALSE);
 685    // Disable all branches if requested and set event loop mode
 686    if (tree) {
 687       if (TestBit(kDisableBranches)) {
 688          printf("Disabling all branches...\n");
 689 //         tree->SetBranchStatus("*",0); // not yet working
 690       }
 691       SetEventLoop(kTRUE);
 692    }
 693
 694    TChain *chain = dynamic_cast<TChain*>(tree);
 695
 696    // Initialize locally all tasks
 697    TIter next(fTasks);
 698    AliAnalysisTask *task;
 699    while ((task=(AliAnalysisTask*)next())) {
 700       task->LocalInit();
 701    }
 702
 703    switch (fMode) {
 704       case kLocalAnalysis:
 705          if (!tree) {
 706             TIter next(fTasks);
 707             AliAnalysisTask *task;
 708             // Call CreateOutputObjects for all tasks
 709             while ((task=(AliAnalysisTask*)next())) {
 710                TDirectory *curdir = gDirectory;
 711                task->CreateOutputObjects();
 712                if (curdir) curdir->cd();
 713             }
 714             ExecAnalysis();
 715             Terminate();
 716             return;
 717          }
 718          // Run tree-based analysis via AliAnalysisSelector
 719 //         gROOT->ProcessLine(".L $ALICE_ROOT/ANALYSIS/AliAnalysisSelector.cxx+");
 720          cout << "===== RUNNING LOCAL ANALYSIS " << GetName() << " ON TREE " << tree->GetName() << endl;
 721          sprintf(line, "AliAnalysisSelector *selector = new AliAnalysisSelector((AliAnalysisManager*)0x%lx);",(ULong_t)this);
 722          gROOT->ProcessLine(line);
 723          sprintf(line, "((TTree*)0x%lx)->Process(selector);",(ULong_t)tree);
 724          gROOT->ProcessLine(line);
 725          break;
 726       case kProofAnalysis:
 727          if (!gROOT->GetListOfProofs() || !gROOT->GetListOfProofs()->GetEntries()) {
 728             printf("StartAnalysis: no PROOF!!!\n");
 729             return;
 730          }
 731          sprintf(line, "gProof->AddInput((TObject*)0x%lx);", (ULong_t)this);
 732          gROOT->ProcessLine(line);
 733          if (chain) {
 734             chain->SetProof();
 735             cout << "===== RUNNING PROOF ANALYSIS " << GetName() << " ON CHAIN " << chain->GetName() << endl;
 736             chain->Process("AliAnalysisSelector");
 737          } else {
 738             printf("StartAnalysis: no chain\n");
 739             return;
 740          }
 741          break;
 742       case kGridAnalysis:
 743          Warning("StartAnalysis", "GRID analysis mode not implemented. Running local.");
 744    }
 745 }
 746
 747 //______________________________________________________________________________
 748 void AliAnalysisManager::ExecAnalysis(Option_t *option)
 749 {
 750 // Execute analysis.
 751    if (!fInitOK) {
 752      Error("ExecAnalysis", "Analysis manager was not initialized !");
 753       return;
 754    }
 755    AliAnalysisTask *task;
 756    // Check if the top tree is active.
 757    if (fTree) {
 758       TIter next(fTasks);
 759    // De-activate all tasks
 760       while ((task=(AliAnalysisTask*)next())) task->SetActive(kFALSE);
 761       AliAnalysisDataContainer *cont = (AliAnalysisDataContainer*)fInputs->At(0);
 762       if (!cont) {
 763               Error("ExecAnalysis","Cannot execute analysis in TSelector mode without at least one top container");
 764          return;
 765       }
 766       cont->SetData(fTree); // This will notify all consumers
 767 //
 768 //    Call BeginEvent() for optional input/output and MC services
 769       if (fInputEventHandler)   fInputEventHandler  ->BeginEvent();
 770       if (fOutputEventHandler)  fOutputEventHandler ->BeginEvent();
 771       if (fMCtruthEventHandler) fMCtruthEventHandler->BeginEvent();
 772 //
 773 //    Execute the tasks
 774       TIter next1(cont->GetConsumers());
 775       while ((task=(AliAnalysisTask*)next1())) {
 776          if (fDebug >1) {
 777             cout << "    Executing task " << task->GetName() << endl;
 778          }
 779
 780          task->ExecuteTask(option);
 781       }
 782 //
 783 //    Call FinishEvent() for optional output and MC services
 784       if (fInputEventHandler)   fInputEventHandler  ->FinishEvent();
 785       if (fOutputEventHandler)  fOutputEventHandler ->FinishEvent();
 786       if (fMCtruthEventHandler) fMCtruthEventHandler->FinishEvent();
 787 //
 788       return;
 789    }
 790    // The event loop is not controlled by TSelector
 791 //
 792 //  Call BeginEvent() for optional input/output and MC services
 793    if (fInputEventHandler)   fInputEventHandler  ->BeginEvent();
 794    if (fOutputEventHandler)  fOutputEventHandler ->BeginEvent();
 795    if (fMCtruthEventHandler) fMCtruthEventHandler->BeginEvent();
 796    TIter next2(fTopTasks);
 797    while ((task=(AliAnalysisTask*)next2())) {
 798       task->SetActive(kTRUE);
 799       if (fDebug > 1) {
 800          cout << "    Executing task " << task->GetName() << endl;
 801       }
 802       task->ExecuteTask(option);
 803    }
 804 //
 805 // Call FinishEvent() for optional output and MC services
 806    if (fInputEventHandler)   fInputEventHandler  ->FinishEvent();
 807    if (fOutputEventHandler)  fOutputEventHandler ->FinishEvent();
 808    if (fMCtruthEventHandler) fMCtruthEventHandler->FinishEvent();
 809 }
 810
 811 //______________________________________________________________________________
 812 void AliAnalysisManager::FinishAnalysis()
 813 {
 814 // Finish analysis.
 815 }