The method LocalInit() may be implemented to call locally (on the client)
[u/mrichter/AliRoot.git] / ANALYSIS / AliAnalysisManager.cxx
index ab8e035..f235c35 100644 (file)
@@ -167,7 +167,7 @@ void AliAnalysisManager::Init(TTree *tree)
   // Init() will be called many times when running with PROOF.
    if (!tree) return;
    if (fDebug > 1) {
-      printf("AliAnalysisManager::Init(%s)\n", tree->GetName());
+      printf("->AliAnalysisManager::Init(%s)\n", tree->GetName());
    }
    if (!fInitOK) InitAnalysis();
    if (!fInitOK) return;
@@ -178,6 +178,9 @@ void AliAnalysisManager::Init(TTree *tree)
       return;
    }
    top->SetData(tree);
+   if (fDebug > 1) {
+      printf("<-AliAnalysisManager::Init(%s)\n", tree->GetName());
+   }
 }
 
 //______________________________________________________________________________
@@ -199,7 +202,7 @@ void AliAnalysisManager::SlaveBegin(TTree *tree)
   // When running with PROOF SlaveBegin() is called on each slave server.
   // The tree argument is deprecated (on PROOF 0 is passed).
    if (fDebug > 1) {
-      cout << "AliAnalysisManager::SlaveBegin()" << endl;
+      cout << "->AliAnalysisManager::SlaveBegin()" << endl;
    }
 
    TIter next(fTasks);
@@ -208,6 +211,9 @@ void AliAnalysisManager::SlaveBegin(TTree *tree)
    while ((task=(AliAnalysisTask*)next())) 
       task->CreateOutputObjects();
    if (fMode == kLocalAnalysis) Init(tree);   
+   if (fDebug > 1) {
+      cout << "<-AliAnalysisManager::SlaveBegin()" << endl;
+   }
 }
 
 //______________________________________________________________________________
@@ -221,6 +227,11 @@ Bool_t AliAnalysisManager::Notify()
    if (fTree) {
       TFile *curfile = fTree->GetCurrentFile();
       if (curfile && fDebug>1) printf("AliAnalysisManager::Notify() file: %s\n", curfile->GetName());
+      TIter next(fTasks);
+      AliAnalysisTask *task;
+      // Call Notify for all tasks
+      while ((task=(AliAnalysisTask*)next())) 
+         task->Notify();      
    }
    return kTRUE;
 }    
@@ -246,19 +257,23 @@ Bool_t AliAnalysisManager::Process(Long64_t entry)
   //  Assuming that fChain is the pointer to the TChain being processed,
   //  use fChain->GetTree()->GetEntry(entry).
    if (fDebug > 1) {
-      cout << "AliAnalysisManager::Process()" << endl;
+      cout << "->AliAnalysisManager::Process()" << endl;
    }
    GetEntry(entry);
    ExecAnalysis();
+   if (fDebug > 1) {
+      cout << "<-AliAnalysisManager::Process()" << endl;
+   }
    return kTRUE;
 }
 
 //______________________________________________________________________________
 void AliAnalysisManager::PackOutput(TList *target)
 {
-  // Pack all output data containers in the output list.
+  // Pack all output data containers in the output list. Called at SlaveTerminate
+  // stage in PROOF case for each slave.
    if (fDebug > 1) {
-      cout << "AliAnalysisManager::PackOutput()" << endl;
+      cout << "->AliAnalysisManager::PackOutput()" << endl;
    }   
    if (!target) {
       Error("PackOutput", "No target. Aborting.");
@@ -266,55 +281,43 @@ void AliAnalysisManager::PackOutput(TList *target)
    }
 
    if (fMode == kProofAnalysis) {
-      AliAnalysisDataContainer *top = (AliAnalysisDataContainer*)fInputs->At(0);
-      if (!top) {
-          cout<<"Error: No top input container !" <<endl;
-          return;
-      }
-      top->SetData(0);
-
       TIter next(fOutputs);
       AliAnalysisDataContainer *output;
       while ((output=(AliAnalysisDataContainer*)next())) {
-         if (fDebug > 1) printf("   Packing container %s\n", output->GetName());
-         if (output->GetData()) target->Add(output);
-//         output->SetDataOwned(kFALSE);
+         if (fDebug > 1) printf("   Packing container %s...\n", output->GetName());
+         if (output->GetData()) target->Add(output->ExportData());
       }
    } 
-   fContainers->Clear();
    if (fDebug > 1) {
-      printf("   ->output list contains %d containers\n", target->GetSize());
+      printf("<-AliAnalysisManager::PackOutput: output list contains %d containers\n", target->GetSize());
    }
 }
 
 //______________________________________________________________________________
-void AliAnalysisManager::ReplaceOutputContainers(TList *source)
+void AliAnalysisManager::ImportWrappers(TList *source)
 {
-// Replace all exising containers with the ones coming in source.
+// Import data in output containers from wrappers coming in source.
+   if (fDebug > 1) {
+      cout << "->AliAnalysisManager::ImportWrappers()" << endl;
+   }   
    TIter next(fOutputs);
-   AliAnalysisDataContainer *cont, *output;
+   AliAnalysisDataContainer *cont;
+   AliAnalysisDataWrapper   *wrap;
+   Int_t icont = 0;
    while ((cont=(AliAnalysisDataContainer*)next())) {
-      output = (AliAnalysisDataContainer*)source->FindObject(cont->GetName());
-      if (!output) {
-         printf("Error: container %s not found in analysis output !\n", cont->GetName());
+      wrap = (AliAnalysisDataWrapper*)source->FindObject(cont->GetName());
+      if (!wrap && fDebug>1) {
+         printf("(WW) ImportWrappers: container %s not found in analysis output !\n", cont->GetName());
          continue;
       }
-      if (fDebug > 1) printf("...Replacing output container %s\n", output->GetName());
-      if (cont->GetFileName()) printf("    -> %s\n", output->GetFileName());
-      Int_t ntasks = fTasks->GetEntries();
-      AliAnalysisTask *task;
-      AliAnalysisDataSlot *oslot;
-      for (Int_t i=0; i<ntasks; i++) {
-         task = (AliAnalysisTask*)fTasks->At(i);
-         Int_t nout = task->GetNoutputs();
-         for (Int_t iout=0; iout<nout; iout++) {
-            oslot = task->GetOutputSlot(iout);
-            if (oslot->GetContainer() == cont) oslot->ConnectContainer(output);
-         }
-      }
-//      output->GetConsumers()->Delete();
-//      if (output->GetProducer()) delete output->GetProducer();
+      icont++;
+      if (fDebug > 1) printf("   Importing data for container %s\n", wrap->GetName());
+      if (cont->GetFileName()) printf("    -> %s\n", cont->GetFileName());
+      cont->ImportData(wrap);
    }         
+   if (fDebug > 1) {
+      cout << "<-AliAnalysisManager::ImportWrappers(): "<< icont << " containers imported" << endl;
+   }   
 }
 
 //______________________________________________________________________________
@@ -322,31 +325,22 @@ void AliAnalysisManager::UnpackOutput(TList *source)
 {
   // Called by AliAnalysisSelector::Terminate. Output containers should
   // be in source in the same order as in fOutputs.
-
+   if (fDebug > 1) {
+      cout << "->AliAnalysisManager::UnpackOutput()" << endl;
+   }   
    if (!source) {
-      Error("PackOutput", "No target. Aborting.");
+      Error("UnpackOutput", "No target. Aborting.");
       return;
    }
    if (fDebug > 1) {
-      printf("AliAnalysisManager::UnpackOutput(): %d containers\n", source->GetSize());
       printf("   Source list contains %d containers\n", source->GetSize());
    }   
 
-   if (fMode == kProofAnalysis) {
-      ReplaceOutputContainers(source);
-      fOutputs->Clear();
-   }
-
-   TCollection *collection = source;
-   if (fMode == kLocalAnalysis) collection = fOutputs;
-   TIter next(collection);
+   if (fMode == kProofAnalysis) ImportWrappers(source);
 
+   TIter next(fOutputs);
    AliAnalysisDataContainer *output;
    while ((output=(AliAnalysisDataContainer*)next())) {
-      if (fMode == kProofAnalysis) {
-         output->SetDataOwned(kTRUE);
-         fOutputs->Add(output);
-      }
       if (!output->GetData()) continue;
       // Check if the output need to be written to a file.
       const char *filename = output->GetFileName();
@@ -365,6 +359,9 @@ void AliAnalysisManager::UnpackOutput(TList *source)
       }
       output->GetData()->Write();      
    }
+   if (fDebug > 1) {
+      cout << "<-AliAnalysisManager::UnpackOutput()" << endl;
+   }   
 }
 
 //______________________________________________________________________________
@@ -374,12 +371,15 @@ void AliAnalysisManager::Terminate()
   // a query. It always runs on the client, it can be used to present
   // the results graphically.
    if (fDebug > 1) {
-      cout << "AliAnalysisManager::Terminate()" << endl;
+      cout << "->AliAnalysisManager::Terminate()" << endl;
    }   
    AliAnalysisTask *task;
    TIter next(fTasks);
    // Call Terminate() for tasks
    while ((task=(AliAnalysisTask*)next())) task->Terminate();
+   if (fDebug > 1) {
+      cout << "<-AliAnalysisManager::Terminate()" << endl;
+   }   
 }
 
 //______________________________________________________________________________
@@ -576,18 +576,31 @@ void AliAnalysisManager::StartAnalysis(const char *type, TTree *tree)
    }
    if (fMode == kGridAnalysis) {
       Warning("StartAnalysis", "GRID analysis mode not implemented. Running local.");
-      fMode = kLocalAnalysis; 
-   }     
+      fMode = kLocalAnalysis;
+   }
    char line[128];   
+   // Disable by default all branches
+   if (tree) tree->SetBranchStatus("*",0);
    TChain *chain = dynamic_cast<TChain*>(tree);
+
+   // Initialize locally all tasks
+   TIter next(fTasks);
+   AliAnalysisTask *task;
+   while ((task=(AliAnalysisTask*)next())) task->LocalInit();
+
    switch (fMode) {
       case kLocalAnalysis:
          if (!tree) {
+            TIter next(fTasks);
+            AliAnalysisTask *task;
+            // Call CreateOutputObjects for all tasks
+            while ((task=(AliAnalysisTask*)next())) task->CreateOutputObjects();
             ExecAnalysis();
+            Terminate();
             return;
          } 
          // Run tree-based analysis via AliAnalysisSelector  
-         gROOT->ProcessLine(".L $ALICE_ROOT/ANALYSIS/AliAnalysisSelector.cxx+");
+         gROOT->ProcessLine(".L AliAnalysisSelector.cxx+");
          cout << "===== RUNNING LOCAL ANALYSIS " << GetName() << " ON TREE " << tree->GetName() << endl;
          sprintf(line, "AliAnalysisSelector *selector = new AliAnalysisSelector((AliAnalysisManager*)0x%lx);",(ULong_t)this);
          gROOT->ProcessLine(line);