PROOF-aware version of the analysis framework (Andrei)
authorhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 6 Feb 2007 16:25:45 +0000 (16:25 +0000)
committerhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 6 Feb 2007 16:25:45 +0000 (16:25 +0000)
56 files changed:
ANALYSIS/ANALYSISLinkDef.h
ANALYSIS/AliAnalysisDataContainer.cxx
ANALYSIS/AliAnalysisDataContainer.h
ANALYSIS/AliAnalysisDataSlot.cxx
ANALYSIS/AliAnalysisDataSlot.h
ANALYSIS/AliAnalysisGoodies.cxx
ANALYSIS/AliAnalysisManager.cxx
ANALYSIS/AliAnalysisManager.h
ANALYSIS/AliAnalysisRLContainer.cxx [deleted file]
ANALYSIS/AliAnalysisRLContainer.h [deleted file]
ANALYSIS/AliAnalysisSelector.cxx [new file with mode: 0644]
ANALYSIS/AliAnalysisSelector.h [new file with mode: 0644]
ANALYSIS/AliAnalysisTask.cxx
ANALYSIS/AliAnalysisTask.h
ANALYSIS/AnalysisExtraLinkDef.h [deleted file]
ANALYSIS/AnalysisOldLinkDef.h [new file with mode: 0644]
ANALYSIS/AnalysisTaskLinkDef.h [deleted file]
ANALYSIS/Makefile
ANALYSIS/PROOF-INF.ANALYSIS/BUILD.sh [moved from ANALYSIS/PROOF-INF.ANALYSIS_NEW/BUILD.sh with 100% similarity]
ANALYSIS/PROOF-INF.ANALYSIS/SETUP.C [new file with mode: 0644]
ANALYSIS/PROOF-INF.ANALYSIS_NEW/SETUP.C [deleted file]
ANALYSIS/libANALYSIS.pkg
ANALYSIS/libANALYSIS_EXTRA.pkg [deleted file]
ANALYSIS/libANALYSIS_NEW.pkg [deleted file]
ANALYSIS/libAnalysisOld.pkg [new file with mode: 0644]
ANALYSIS/runAnalysis.C
ANALYSIS/testEvent.C
ANALYSIS/testEvent.h
ESDCheck/AliAnalysisTaskPt.cxx
ESDCheck/AliAnalysisTaskPt.h
ESDCheck/AliEMCALQATask.cxx
ESDCheck/AliEMCALQATask.h
ESDCheck/AliFMDQATask.cxx
ESDCheck/AliFMDQATask.h
ESDCheck/AliHMPIDQATask.cxx
ESDCheck/AliHMPIDQATask.h
ESDCheck/AliMUONQATask.cxx
ESDCheck/AliMUONQATask.h
ESDCheck/AliPHOSQATask.cxx
ESDCheck/AliPHOSQATask.h
ESDCheck/AliPMDQATask.cxx
ESDCheck/AliPMDQATask.h
ESDCheck/AliT0QATask.cxx
ESDCheck/AliT0QATask.h
ESDCheck/AliTOFQATask.cxx
ESDCheck/AliTOFQATask.h
ESDCheck/AliTRDQATask.cxx
ESDCheck/AliTRDQATask.h
ESDCheck/ana.C
JETAN/JetAnalysisManager.C
PWG2/AnalysisMacros/Batch/analysis.jdl
PWG2/AnalysisMacros/Batch/runAnalysis.C
PWG2/AnalysisMacros/Interactive/runAnalysis.C
PWG2/AnalysisMacros/Local/runAnalysis.C
PWG2/AnalysisMacros/README
build/module.dep

index 16f15f5..a8be576 100644 (file)
 #ifdef __CINT__
 
-#pragma link off all glols;
+#pragma link off all globals;
 #pragma link off all classes;
 #pragma link off all functions;
 
-#pragma link C++ class TGliteXmlEventlist+;
+#pragma link C++ class  AliAnalysisDataContainer+;
+#pragma link C++ class  AliAnalysisTask+;
+#pragma link C++ class  AliAnalysisDataSlot+;
+#pragma link C++ class  AliAnalysisManager+;
 
-#pragma link C++ class AliD0toKpi+;
-#pragma link C++ class AliD0toKpiAnalysis+;
-#pragma link C++ class AliRunAnalysis+;
-#pragma link C++ class AliAnalysis+;
-
-#pragma link C++ class AliAOD+;
-#pragma link C++ class AliEventBuffer+;
-#pragma link C++ class AliVAODParticle+;
-#pragma link C++ class AliAODParticle+;
-#pragma link C++ class AliAODPair+;
-
-#pragma link C++ class AliAODRun+;
-
-#pragma link C++ class AliTrackPoints+;
-#pragma link C++ class AliClusterMap+;
-
-#pragma link C++ class AliReader+;
-#pragma link C++ class AliReaderAOD+;
-#pragma link C++ class AliReaderESD+;
-#pragma link C++ class AliReaderESDTree+;
-#pragma link C++ class AliReaderKineTree+;
-
-#pragma link C++ class AliFlowAnalysis+;
-#pragma link C++ class AliMuonAnalysis+;
-
-#pragma link C++ class AliEventCut+;
-#pragma link C++ class AliEventEmptyCut+;
-#pragma link C++ class AliEventBaseCut+;
-
-#pragma link C++ class AliPrimVertexXCut+;
-#pragma link C++ class AliPrimVertexYCut+;
-#pragma link C++ class AliPrimVertexZCut+;
-#pragma link C++ class AliNChargedCut+;
-
-#pragma link C++ class AliAODParticleCut-;
-#pragma link C++ class AliAODParticleEmptyCut-;
-#pragma link C++ class AliAODParticleBaseCut+;
-
-#pragma link C++ class AliAODMomentumCut+;
-#pragma link C++ class AliAODPtCut+;
-#pragma link C++ class AliAODEnergyCut+;
-#pragma link C++ class AliAODRapidityCut+;
-#pragma link C++ class AliAODPseudoRapidityCut+;
-#pragma link C++ class AliAODPxCut+;
-#pragma link C++ class AliAODPyCut+;
-#pragma link C++ class AliAODPzCut+;
-#pragma link C++ class AliAODPhiCut+;
-#pragma link C++ class AliAODThetaCut+;
-#pragma link C++ class AliAODVxCut+;
-#pragma link C++ class AliAODVyCut+;
-#pragma link C++ class AliAODVzCut+;
-#pragma link C++ class AliAODPIDCut+;
-#pragma link C++ class AliAODLogicalOperCut-;
-#pragma link C++ class AliAODAndCut+;
-#pragma link C++ class AliAODOrCut+;
-
-
-#pragma link C++ class AliAODPairCut-;
-#pragma link C++ class AliAODPairEmptyCut-;
-#pragma link C++ class AliAODPairBaseCut+;
-
-#pragma link C++ class AliAODQInvCut+;
-#pragma link C++ class AliAODKtCut+;
-#pragma link C++ class AliAODKStarCut+;
-#pragma link C++ class AliAODKStarOutCut+;
-#pragma link C++ class AliAODKStarSideCut+;
-#pragma link C++ class AliAODKStarLongCut+;
-#pragma link C++ class AliAODQSideLCMSCut+;
-#pragma link C++ class AliAODQOutLCMSCut+;
-#pragma link C++ class AliAODQLongLCMSCut+;
-#pragma link C++ class AliAODDeltaECut+;
-#pragma link C++ class AliAODDeltaPCut+;
-#pragma link C++ class AliAODDeltaPvectorCut+;
-#pragma link C++ class AliAODDeltaPhiCut+;
-#pragma link C++ class AliAODDeltaThetaCut+;
-#pragma link C++ class AliAODAvSeparationCut+;
-#pragma link C++ class AliAODSeparationCut+;
-#pragma link C++ class AliAODITSSeparationCut+;
-#pragma link C++ class AliAODCluterOverlapCut+;
-#pragma link C++ class AliAODOutSideSameSignCut+;
-#pragma link C++ class AliAODOutSideDiffSignCut+;
-#pragma link C++ class AliAODLogicalOperPairCut-;
-#pragma link C++ class AliAODOrPairCut+;
-#pragma link C++ class AliAODAndPairCut+;
-    
-#pragma link C++ class AliAODevent+;
-#pragma link C++ class AliAODv0+;
-#pragma link C++ class AliAODxi+;
-
-#pragma link C++ class AliAnalysisEventCuts+;
-#pragma link C++ class AliAnalysisTrackCuts+;
+#pragma link C++ class  AliAnalysisGoodies+;
 
 #endif
index 7d06ac3..4af7146 100644 (file)
 //
 //==============================================================================
 
-#include "Riostream.h"
+#include <Riostream.h>
+#include <TMethodCall.h>
 
-#include "TClass.h"
-#include "TTree.h"
-#include "TFile.h"
-//#include "AliLog.h"
+#include <TClass.h>
+#include <TTree.h>
+#include <TROOT.h>
 
 #include "AliAnalysisDataContainer.h"
 #include "AliAnalysisDataSlot.h"
@@ -59,13 +59,13 @@ ClassImp(AliAnalysisDataContainer)
 AliAnalysisDataContainer::AliAnalysisDataContainer() : TNamed(),
                           fDataReady(kFALSE),
                           fOwnedData(kFALSE),
-                          fFile(NULL),
+                          fFileName(),
                           fData(NULL),
                           fType(NULL),
                           fProducer(NULL),
                           fConsumers(NULL)
 {
-// Default ctor.
+// Dummy ctor.
 }
 
 //______________________________________________________________________________
@@ -73,13 +73,14 @@ AliAnalysisDataContainer::AliAnalysisDataContainer(const char *name, TClass *typ
                          :TNamed(name,""),
                           fDataReady(kFALSE),
                           fOwnedData(kTRUE),
-                          fFile(NULL),
+                          fFileName(),
                           fData(NULL),
                           fType(type),
                           fProducer(NULL),
                           fConsumers(NULL)
 {
-// Normal constructor.
+// Default constructor.
+   SetTitle(fType->GetName());
 }
 
 //______________________________________________________________________________
@@ -87,13 +88,14 @@ AliAnalysisDataContainer::AliAnalysisDataContainer(const AliAnalysisDataContaine
                          :TNamed(cont),
                           fDataReady(cont.fDataReady),
                           fOwnedData(kFALSE),
-                          fFile(cont.fFile),
+                          fFileName(cont.fFileName),
                           fData(cont.fData),
-                          fType(cont.fType),
+                          fType(NULL),
                           fProducer(cont.fProducer),
                           fConsumers(NULL)
 {
 // Copy ctor.
+   GetType();
    if (cont.fConsumers) {
       fConsumers = new TObjArray(2);
       Int_t ncons = cont.fConsumers->GetEntriesFast();
@@ -107,10 +109,6 @@ AliAnalysisDataContainer::~AliAnalysisDataContainer()
 // Destructor. Deletes data ! (What happens if data is a container ???)
    if (fData && fOwnedData) delete fData;
    if (fConsumers) delete fConsumers;
-   if (fFile) {
-      fFile->Close();
-      delete fFile;
-   }   
 }
 
 //______________________________________________________________________________
@@ -121,9 +119,9 @@ AliAnalysisDataContainer &AliAnalysisDataContainer::operator=(const AliAnalysisD
       TNamed::operator=(cont);
       fDataReady = cont.fDataReady;
       fOwnedData = kFALSE;  // !!! Data owned by cont.
-      fFile = cont.fFile;
+      fFileName = cont.fFileName;
       fData = cont.fData;
-      fType = cont.fType;
+      GetType();
       fProducer = cont.fProducer;
       if (cont.fConsumers) {
          fConsumers = new TObjArray(2);
@@ -135,6 +133,154 @@ AliAnalysisDataContainer &AliAnalysisDataContainer::operator=(const AliAnalysisD
 }      
 
 //______________________________________________________________________________
+void AliAnalysisDataContainer::AddConsumer(AliAnalysisTask *consumer, Int_t islot)
+{
+// Add a consumer for contained data;
+   AliAnalysisDataSlot *slot = consumer->GetInputSlot(islot);
+   if (!slot || !slot->GetType()) {
+     cout<<"Consumer task "<< consumer->GetName()<<" does not have an input/type #"<<islot<<endl;
+     //AliError(Form("Consumer task %s does not have an input #%i", consumer->GetName(),islot));
+      return;
+   }
+   if (!slot->GetType()->InheritsFrom(GetType())) {
+     cout<<"Data type "<<slot->GetTitle()<<" for input slot "<<islot<<" of task "<<consumer->GetName()<<" does not match container type "<<GetTitle()<<endl;  
+     //AliError(Form("Data type %s for input slot %i of task %s does not match container type %s", slot->GetType()->GetName(),islot,consumer->GetName(),fType->GetName()));
+      return;
+   }   
+
+   if (!fConsumers) fConsumers = new TObjArray(2);   
+   fConsumers->Add(consumer);
+   // Add the consumer task to the list of task of the producer
+   if (fProducer && !fProducer->GetListOfTasks()->FindObject(consumer)) 
+      fProducer->Add(consumer);
+}      
+
+//______________________________________________________________________________
+Bool_t AliAnalysisDataContainer::ClientsExecuted() const
+{
+// Check if all client tasks have executed.
+   TIter next(fConsumers);
+   AliAnalysisTask *task;
+   while ((task=(AliAnalysisTask*)next())) {
+      if (!task->HasExecuted()) return kFALSE;
+   }
+   return kTRUE;
+}   
+
+//______________________________________________________________________________
+void AliAnalysisDataContainer::DeleteData()
+{
+// Delete data if not needed anymore.
+   if (!fDataReady || !ClientsExecuted()) {
+     cout<<"Data not ready or not all clients of container "<<GetName()<<" executed. Data not deleted."<<endl;
+     //AliWarning(Form("Data not ready or not all clients of container %s executed. Data not deleted.", GetName()));
+      return;
+   }
+   if (!fOwnedData) {
+     cout<<"Data not owned by container "<<GetName()<<". Not deleted."<<endl;
+     //AliWarning(Form("Data not owned by container %s. Not deleted.", GetName()));
+      return;
+   }
+   delete fData;
+   fData = 0;
+   fDataReady = kFALSE;
+}   
+
+//______________________________________________________________________________
+TClass *AliAnalysisDataContainer::GetType() const
+{
+// Get class type for this slot.
+   AliAnalysisDataContainer *cont = (AliAnalysisDataContainer*)this;
+   if (!fType) cont->SetType(gROOT->GetClass(fTitle.Data()));
+   if (!fType) printf("AliAnalysisDataContainer: Unknown class: %s\n", GetTitle());
+   return fType;
+}
+
+//______________________________________________________________________________
+void AliAnalysisDataContainer::GetEntry(Long64_t ientry)
+{
+// If data is ready and derives from TTree or from TBranch, this will get the
+// requested entry in memory if not already loaded.
+   if (!fDataReady || !GetType()) return;
+   Bool_t istree = fType->InheritsFrom(TTree::Class());
+   if (istree) {
+      TTree *tree = (TTree*)fData;
+      if (tree->GetReadEntry() != ientry) tree->GetEntry(ientry);
+      return;
+   }   
+   Bool_t isbranch = fType->InheritsFrom(TBranch::Class());
+   if (isbranch) {
+      TBranch *branch = (TBranch*)fData;
+      if (branch->GetReadEntry() != ientry) branch->GetEntry(ientry);
+      return;
+   }   
+}   
+
+//______________________________________________________________________________
+Long64_t AliAnalysisDataContainer::Merge(TCollection *list)
+{
+// Merge a list of containers with this one. Containers in the list must have
+// data of the same type.
+   if (!list || !fData) return 0;
+   printf("Merging %d containers %s\n", list->GetSize()+1, GetName());
+   TMethodCall callEnv;
+   if (fData->IsA())
+      callEnv.InitWithPrototype(fData->IsA(), "Merge", "TCollection*");
+   if (!callEnv.IsValid() && !list->IsEmpty()) {
+      cout << "No merge interface for data stored by " << GetName() << ". Merging not possible !" << endl;
+      return 1;
+   }   
+   
+   if (list->IsEmpty()) return 1;
+
+   TIter next(list);
+   AliAnalysisDataContainer *cont;   
+   // Make a list where to temporary store the data to be merged.
+   TList *collectionData = new TList();
+   Int_t count = 0; // object counter
+   while ((cont=(AliAnalysisDataContainer*)next())) {
+      TObject *data = cont->GetData();
+      if (!data) continue;
+      if (strcmp(cont->GetName(), GetName())) {
+         cout << "Not merging containers with different names !" << endl;
+         continue;
+      }
+      printf(" ... merging object %s\n", data->GetName());
+      collectionData->Add(data);
+      count++;
+   }   
+   callEnv.SetParam((Long_t) collectionData);
+   callEnv.Execute(fData);
+   delete collectionData;
+   
+   return count+1;   
+}
+
+//______________________________________________________________________________
+void AliAnalysisDataContainer::PrintContainer(Option_t *option, Int_t indent) const
+{
+// Print info about this container.
+   TString ind;
+   for (Int_t i=0; i<indent; i++) ind += " ";
+   TString opt(option);
+   opt.ToLower();
+   Bool_t dep = (opt.Contains("dep"))?kTRUE:kFALSE;
+   if (!dep) {
+      printf("%s\n", Form("%sContainer: %s  type: %s", ind.Data(), GetName(), GetTitle()));
+      if (fProducer) 
+         printf("%s\n", Form("%s = Data producer: task %s",ind.Data(),fProducer->GetName()));
+      else
+         printf("%s\n", Form("%s= No data producer"));
+      printf("%s", Form("%s = Consumer tasks: "));
+      if (!fConsumers || !fConsumers->GetEntriesFast()) printf("-none-\n");
+      else printf("\n");
+   }   
+   TIter next(fConsumers);
+   AliAnalysisTask *task;
+   while ((task=(AliAnalysisTask*)next())) task->PrintTask(option, indent+3);
+}   
+
+//______________________________________________________________________________
 Bool_t AliAnalysisDataContainer::SetData(TObject *data, Option_t *)
 {
 // Set the data as READY only if it was published by the producer.
@@ -175,56 +321,6 @@ Bool_t AliAnalysisDataContainer::SetData(TObject *data, Option_t *)
 }
 
 //______________________________________________________________________________
-void AliAnalysisDataContainer::OpenFile(const char *name, Option_t *option)
-{
-// Data will be written to this file at the end of processing.
-// Option represent the way the file is accessed: NEW, APPEND, ...
-   if (fFile) {
-      fFile->Close();
-      delete fFile;
-   }
-   fFile =  new TFile(name, option);
-   if (fFile->IsZombie()) {
-     cout<<"Cannot open file "<<name<<" with option "<<option<<endl;
-     //AliError(Form("Cannot open file %s with option %s",name,option));
-      fFile = 0;
-   }   
-}   
-
-//______________________________________________________________________________
-void AliAnalysisDataContainer::WriteData()
-{
-// Write data to the file.
-   if (fFile) {
-      TDirectory *cursav = gDirectory;
-      fFile->cd();
-      fData->Write();
-//      fFile->Write();
-      if (cursav) cursav->cd();
-   }   
-}
-
-//______________________________________________________________________________
-void AliAnalysisDataContainer::GetEntry(Long64_t ientry)
-{
-// If data is ready and derives from TTree or from TBranch, this will get the
-// requested entry in memory if not already loaded.
-   if (!fDataReady) return;
-   Bool_t istree = fType->InheritsFrom(TTree::Class());
-   if (istree) {
-      TTree *tree = (TTree*)fData;
-      if (tree->GetReadEntry() != ientry) tree->GetEntry(ientry);
-      return;
-   }   
-   Bool_t isbranch = fType->InheritsFrom(TBranch::Class());
-   if (isbranch) {
-      TBranch *branch = (TBranch*)fData;
-      if (branch->GetReadEntry() != ientry) branch->GetEntry(ientry);
-      return;
-   }   
-}   
-
-//______________________________________________________________________________
 void AliAnalysisDataContainer::SetProducer(AliAnalysisTask *prod, Int_t islot)
 {
 // Set the producer of data. The slot number is required for data type checking.
@@ -243,8 +339,8 @@ void AliAnalysisDataContainer::SetProducer(AliAnalysisTask *prod, Int_t islot)
      //AliError(Form("Producer task %s does not have an output #%i", prod->GetName(),islot));
       return;
    }   
-   if (!slot->GetType()->InheritsFrom(fType)) {
-     cout<<"Data type "<<slot->GetType()->GetName()<<"for output slot "<<islot<<" of task "<<prod->GetName()<<" does not match container type "<<fType->GetName()<<endl;
+   if (!slot->GetType()->InheritsFrom(GetType())) {
+     cout<<"Data type "<<slot->GetTitle()<<"for output slot "<<islot<<" of task "<<prod->GetName()<<" does not match container type "<<GetTitle()<<endl;
      //AliError(Form("Data type %s for output slot %i of task %s does not match container type %s", slot->GetType()->GetName(),islot,prod->GetName(),fType->GetName()));
       return;
    }   
@@ -257,81 +353,4 @@ void AliAnalysisDataContainer::SetProducer(AliAnalysisTask *prod, Int_t islot)
       if (!prod->GetListOfTasks()->FindObject(cons)) prod->Add(cons);
    }   
 }   
-
-//______________________________________________________________________________
-void AliAnalysisDataContainer::AddConsumer(AliAnalysisTask *consumer, Int_t islot)
-{
-// Add a consumer for contained data;
-   AliAnalysisDataSlot *slot = consumer->GetInputSlot(islot);
-   if (!slot) {
-     cout<<"Consumer task "<< consumer->GetName()<<" does not have an input #"<<islot<<endl;
-     //AliError(Form("Consumer task %s does not have an input #%i", consumer->GetName(),islot));
-      return;
-   }   
-   if (!slot->GetType()->InheritsFrom(fType)) {
-     cout<<"Data type "<<slot->GetType()->GetName()<<" for input slot "<<islot<<" of task "<<consumer->GetName()<<" does not match container type "<<fType->GetName()<<endl;  
-     //AliError(Form("Data type %s for input slot %i of task %s does not match container type %s", slot->GetType()->GetName(),islot,consumer->GetName(),fType->GetName()));
-      return;
-   }   
-
-   if (!fConsumers) fConsumers = new TObjArray(2);   
-   fConsumers->Add(consumer);
-   // Add the consumer task to the list of task of the producer
-   if (fProducer && !fProducer->GetListOfTasks()->FindObject(consumer)) 
-      fProducer->Add(consumer);
-}      
-
-//______________________________________________________________________________
-Bool_t AliAnalysisDataContainer::ClientsExecuted() const
-{
-// Check if all client tasks have executed.
-   TIter next(fConsumers);
-   AliAnalysisTask *task;
-   while ((task=(AliAnalysisTask*)next())) {
-      if (!task->HasExecuted()) return kFALSE;
-   }
-   return kTRUE;
-}   
-
-//______________________________________________________________________________
-void AliAnalysisDataContainer::DeleteData()
-{
-// Delete data if not needed anymore.
-   if (!fDataReady || !ClientsExecuted()) {
-     cout<<"Data not ready or not all clients of container "<<GetName()<<" executed. Data not deleted."<<endl;
-     //AliWarning(Form("Data not ready or not all clients of container %s executed. Data not deleted.", GetName()));
-      return;
-   }
-   if (!fOwnedData) {
-     cout<<"Data not owned by container "<<GetName()<<". Not deleted."<<endl;
-     //AliWarning(Form("Data not owned by container %s. Not deleted.", GetName()));
-      return;
-   }
-   delete fData;
-   fData = 0;
-   fDataReady = kFALSE;
-}   
       
-//______________________________________________________________________________
-void AliAnalysisDataContainer::PrintContainer(Option_t *option, Int_t indent) const
-{
-// Print info about this container.
-   TString ind;
-   for (Int_t i=0; i<indent; i++) ind += " ";
-   TString opt(option);
-   opt.ToLower();
-   Bool_t dep = (opt.Contains("dep"))?kTRUE:kFALSE;
-   if (!dep) {
-      printf("%s\n", Form("%sContainer: %s  type: %s", ind.Data(), GetName(), fType->GetName()));
-      if (fProducer) 
-         printf("%s\n", Form("%s = Data producer: task %s",ind.Data(),fProducer->GetName()));
-      else
-         printf("%s\n", Form("%s= No data producer"));
-      printf("%s", Form("%s = Consumer tasks: "));
-      if (!fConsumers || !fConsumers->GetEntriesFast()) printf("-none-\n");
-      else printf("\n");
-   }   
-   TIter next(fConsumers);
-   AliAnalysisTask *task;
-   while ((task=(AliAnalysisTask*)next())) task->PrintTask(option, indent+3);
-}   
index 2bdcd5b..e5978a2 100644 (file)
 #include "TNamed.h"
 #endif
 
+#ifndef ROOT_TString
+#include "TString.h"
+#endif
+
 class TClass;
-class TFile;
 class TObjArray;
+class TCollection;
 class AliAnalysisTask;
 class AliESD;
 
@@ -42,7 +46,8 @@ enum ENotifyMessage {
    AliAnalysisDataContainer &operator=(const AliAnalysisDataContainer &cont);
    // Getters
    TObject                  *GetData() const      {return fData;}
-   TClass                   *GetType() const      {return fType;}
+   const char               *GetFileName() const  {return fFileName.Data();}
+   TClass                   *GetType() const;
    AliAnalysisTask          *GetProducer() const  {return fProducer;}
    TObjArray                *GetConsumers() const {return fConsumers;}
    virtual void              GetEntry(Long64_t ientry);
@@ -50,7 +55,7 @@ enum ENotifyMessage {
    void                      ResetDataReady()     {fDataReady = kFALSE;}
    virtual Bool_t            SetData(TObject *data, Option_t *option="");
    void                      SetDataOwned(Bool_t flag) {fOwnedData = flag;}
-   void                      OpenFile(const char *name, Option_t *option="RECREATE");
+   void                      SetFileName(const char *filename) {fFileName = filename;}
    void                      SetProducer(AliAnalysisTask *prod, Int_t islot);
    void                      AddConsumer(AliAnalysisTask *cons, Int_t islot);
    void                      DeleteData();
@@ -60,18 +65,22 @@ enum ENotifyMessage {
    Bool_t                    ClientsExecuted() const;
    Bool_t                    HasConsumers() const {return (fConsumers != 0);}
    Bool_t                    HasProducer() const  {return (fProducer != 0);}
+   // Container merging
+   virtual Long64_t          Merge(TCollection *list);
    // Send a notify signal to the container
    virtual void              NotifyChange(ENotifyMessage /*type*/) {;}
    // Print connected tasks/status
    void                      PrintContainer(Option_t *option="all", Int_t indent=0) const;
-   void                      WriteData();
-   
+
+private:
+   void                      SetType(TClass *type) {fType = type;}   
+
 protected:
    Bool_t                    fDataReady;  // Flag that data is ready
    Bool_t                    fOwnedData;  // Flag data ownership
-   TFile                    *fFile;       // File storing the data
+   TString                   fFileName;   // File storing the data
    TObject                  *fData;       // Contained data
-   TClass                   *fType;       // Type of contained data
+   TClass                   *fType;       //! Type of contained data
    AliAnalysisTask          *fProducer;   // Analysis task to which the slot belongs
    TObjArray                *fConsumers;  // List of consumers of the data
    
index 09fa5f1..379f9fa 100644 (file)
 // match.
 //==============================================================================
 
-#include "Riostream.h"
-
-#include "TClass.h"
-#include "TTree.h"
-//#include "AliLog.h"
+#include <Riostream.h>
+#include <TROOT.h>
+#include <TClass.h>
+#include <TTree.h>
 
 #include "AliAnalysisDataSlot.h"
 #include "AliAnalysisTask.h"
 ClassImp(AliAnalysisDataSlot)
 
 //______________________________________________________________________________
+AliAnalysisDataSlot::AliAnalysisDataSlot(TClass *type, AliAnalysisTask *task)
+                    :TNamed(), 
+                     fType(type),
+                     fParent(task), 
+                     fContainer(NULL)
+{
+// Default constructor.
+   SetTitle(fType->GetName());
+}
+
+//______________________________________________________________________________
+AliAnalysisDataSlot::AliAnalysisDataSlot(const AliAnalysisDataSlot &slot)
+                    :TNamed(slot), 
+                     fType(NULL), 
+                     fParent(slot.fParent), 
+                     fContainer(slot.fContainer)
+{
+// Copy ctor.
+   GetType();
+}                        
+
+//______________________________________________________________________________
 AliAnalysisDataSlot& AliAnalysisDataSlot::operator=(const AliAnalysisDataSlot &slot)
 {
 // Assignment
    if (&slot == this) return *this;
-   TObject::operator=(slot);
-   fType = slot.fType;
+   TNamed::operator=(slot);
+   GetType();
    fParent = slot.fParent;
    fContainer = slot.fContainer;   
    return *this;
@@ -69,9 +90,9 @@ Bool_t AliAnalysisDataSlot::ConnectContainer(AliAnalysisDataContainer *cont)
 // Connect the data slot with a given container. The operation will succeed only
 // if the type defined by the slot inherits from the type enforced by the container.
 // The error message in case of failure is posted by the caller.
-   if (!cont || !fType) return kFALSE;
+   if (!cont || !GetType()) return kFALSE;
    if (!fType->InheritsFrom(cont->GetType())) {
-     cout<<"Data slot of type "<<fType->GetName()<<" of task "<<fParent->GetName()<<" cannot be connected to data container "<<cont->GetName()<<" of type "<<cont->GetType()->GetName()<<endl;
+     cout<<"Data slot of type "<<GetTitle()<<" of task "<<fParent->GetName()<<" cannot be connected to data container "<<cont->GetName()<<" of type "<<cont->GetTitle()<<endl;
      //AliError(Form("Data slot of type %s of task %s cannot be connected to data container %s of type %s", fType->GetName(), fParent->GetName(), cont->GetName(), cont->GetType()->GetName()));
       return kFALSE;
    }   
@@ -80,11 +101,22 @@ Bool_t AliAnalysisDataSlot::ConnectContainer(AliAnalysisDataContainer *cont)
 }   
 
 //______________________________________________________________________________
+TClass *AliAnalysisDataSlot::GetType() const
+{
+// Get class type for this slot.
+   AliAnalysisDataSlot *slot = (AliAnalysisDataSlot*)this;
+   if (!fType) slot->SetType(gROOT->GetClass(fTitle.Data()));
+   if (!fType) printf("AliAnalysisDataSlot: Unknown class: %s\n", GetTitle());
+   return fType;
+}
+   
+//______________________________________________________________________________
 void *AliAnalysisDataSlot::GetBranchAddress(const char *branchname) const
 {
 // Retrieve the address for a given branch. One should always test this before
 // using SetBranchAddress because the address gets set by the first caller.
 // Call this in MyTask::Init()
+   if (!GetType()) return NULL;
    if (!fType->InheritsFrom(TTree::Class())) {
      cout<<"Cannot call GetBranchAddress() for data slot of task "<<fParent->GetName()<<" not pointing to tree-type data"<<endl;
      //AliFatal(Form("Cannot call GetBranchAddress() for data slot of task %s not pointing to tree-type data", fParent->GetName()));
@@ -125,7 +157,7 @@ TObject *AliAnalysisDataSlot::GetData() const
 {
 // Retreives the data from the container if it is ready.
    if (!fContainer) {
-     cout<<"Data slot of type "<<fType->GetName()<<" of task "<<fParent->GetName()<<" has no connected data container"<<endl;
+     cout<<"Data slot of type "<<GetTitle()<<" of task "<<fParent->GetName()<<" has no connected data container"<<endl;
      //AliError(Form("Data slot of type %s of task %s has no connected data container",fType->GetName(), fParent->GetName()));    
       return NULL;
    }
@@ -138,7 +170,7 @@ Bool_t  AliAnalysisDataSlot::IsDataReady() const
 {
 // Check if data for this slot is ready in its container.
    if (!fContainer) {
-     cout<<"Data slot of type "<<fType->GetName()<<" of task "<<fParent->GetName()<<" has no connected data container"<<endl;
+     cout<<"Data slot of type "<<GetTitle()<<" of task "<<fParent->GetName()<<" has no connected data container"<<endl;
      //AliError(Form("Data slot of type %s of task %s has no connected data container",fType->GetName(), fParent->GetName()));    
       return kFALSE;
    }
index 25cb7ca..87c7154 100644 (file)
 //      container with data of the same type.
 //==============================================================================
 
-#ifndef ROOT_TObject
-#include "TObject.h"
+#ifndef ROOT_TNamed
+#include "TNamed.h"
 #endif
 
 class TClass;
 class AliAnalysisDataContainer;
 class AliAnalysisTask;
 
-class AliAnalysisDataSlot : public TObject {
+class AliAnalysisDataSlot : public TNamed {
 
 public:
-   AliAnalysisDataSlot() : fType(NULL), fParent(NULL), fContainer(NULL) {}
-   AliAnalysisDataSlot(TClass *type, AliAnalysisTask *task) : fType(type), fParent(task), fContainer(NULL) {}
-   AliAnalysisDataSlot(const AliAnalysisDataSlot &slot) : TObject(), fType(slot.fType), fParent(slot.fParent), fContainer(slot.fContainer) {}
+   AliAnalysisDataSlot() : TNamed(), fType(NULL), fParent(NULL), fContainer(NULL) {}
+   AliAnalysisDataSlot(TClass *type, AliAnalysisTask *task);
+   AliAnalysisDataSlot(const AliAnalysisDataSlot &slot);
    virtual ~AliAnalysisDataSlot() {}
 
    // Assignment
@@ -36,16 +36,19 @@ public:
    // Getters
    void                     *GetBranchAddress(const char *branch) const;
    Bool_t                    SetBranchAddress(const char *branch, void *address);
-   TClass                   *GetType() const      {return fType;}
+   TClass                   *GetType() const;
    AliAnalysisTask          *GetParent() const    {return fParent;}
    AliAnalysisDataContainer *GetContainer() const {return fContainer;}
    TObject                  *GetData() const;
    // Slot status checking
    Bool_t                    IsConnected() const  {return ((fContainer)?kTRUE:kFALSE);}
    Bool_t                    IsDataReady() const;
+
+private:
+   void                      SetType(TClass *type) {fType = type;}
    
 protected:
-   TClass                   *fType;       // Data type required by the slot
+   TClass                   *fType;       //! Type of the slot
    AliAnalysisTask          *fParent;     // Analysis task to which the slot belongs
    AliAnalysisDataContainer *fContainer;  // Container connected to the slot
    
index dab76a6..2317263 100644 (file)
@@ -443,7 +443,7 @@ const Bool_t AliAnalysisGoodies::ProcessChain(TChain * chain) const
   // Make tasks 
   // The top input must be common to all top tasks
   TClass * classIn = fTaskInType[0] ; 
-  AliAnalysisDataContainer * taskInput  = mgr->CreateContainer("Input  Container", classIn, AliAnalysisManager::kInputContainer) ;
+  AliAnalysisDataContainer * taskInput  = mgr->CreateContainer("InputContainer", classIn, AliAnalysisManager::kInputContainer) ;
   Int_t index ; 
   for (index = 0; index < fnumberOfTasks; index++) {
     AliAnalysisTask * task = fTaskList[index] ;
@@ -451,17 +451,19 @@ const Bool_t AliAnalysisGoodies::ProcessChain(TChain * chain) const
   
     // Create containers for input/output
     TClass * classOu = fTaskOuType[index] ; 
-    AliAnalysisDataContainer * taskOutput = mgr->CreateContainer("Output Container", classOu, AliAnalysisManager::kOutputContainer) ;
+    AliAnalysisDataContainer * taskOutput = mgr->CreateContainer(Form("OutputContainer%d",index), classOu, AliAnalysisManager::kOutputContainer,
+                                            Form("%s.root",task->GetName())) ;
     mgr->ConnectInput (task, 0, taskInput);
     mgr->ConnectOutput(task, 0, taskOutput);
   }
   
   // Open data
-  taskInput->SetData(chain);
+//  taskInput->SetData(chain);
 
   if (mgr->InitAnalysis()) {
     mgr->PrintStatus();
-    chain->Process(mgr);
+//    chain->Process(mgr);
+    mgr->StartAnalysis("local",chain);
   } else 
     rv = kFALSE ; 
   
index 4746588..1208cfc 100644 (file)
 //
 //==============================================================================
 
-#include "Riostream.h"
+#include <Riostream.h>
 
-#include "TClass.h"
-#include "TFile.h"
-#include "TTree.h"
-//#include "AliLog.h"
+#include <TClass.h>
+#include <TFile.h>
+#include <TMethodCall.h>
+#include <TChain.h>
+#include <TSystem.h>
+#include <TROOT.h>
 
-#include "AliAnalysisManager.h"
 #include "AliAnalysisTask.h"
 #include "AliAnalysisDataContainer.h"
 #include "AliAnalysisDataSlot.h"
+#include "AliAnalysisManager.h"
 
 ClassImp(AliAnalysisManager)
 
+AliAnalysisManager *AliAnalysisManager::fgAnalysisManager = NULL;
+
 //______________________________________________________________________________
-AliAnalysisManager::AliAnalysisManager() : TSelector(),
+AliAnalysisManager::AliAnalysisManager() 
+                   :TNamed(),
                     fTree(NULL),
+                    fCurrentEntry(-1),
+                    fMode(kLocalAnalysis),
                     fInitOK(kFALSE),
+                    fTasks(NULL),
+                    fTopTasks(NULL),
+                    fZombies(NULL),
                     fContainers(NULL),
                     fInputs(NULL),
-                    fOutputs(NULL),
+                    fOutputs(NULL)
+{
+// Dummy constructor.
+   fgAnalysisManager = this;
+}
+
+//______________________________________________________________________________
+AliAnalysisManager::AliAnalysisManager(const char *name, const char *title)
+                   :TNamed(name,title),
+                    fTree(NULL),
+                    fCurrentEntry(-1),
+                    fMode(kLocalAnalysis),
+                    fInitOK(kFALSE),
+                    fDebug(0),
                     fTasks(NULL),
                     fTopTasks(NULL),
-                    fZombies(NULL)
+                    fZombies(NULL),
+                    fContainers(NULL),
+                    fInputs(NULL),
+                    fOutputs(NULL)
 {
 // Default constructor.
-   if (TClass::IsCallingNew() != TClass::kDummyNew) {
-      fContainers = new TObjArray();
-      fInputs     = new TObjArray();
-      fOutputs    = new TObjArray();  
-      fTasks      = new TObjArray();
-      fTopTasks   = new TObjArray();
-      fZombies    = new TObjArray();
-//      fStatus     = new AliAnalysisInfo(this);
-   }
+   fgAnalysisManager = this;
+   fTasks      = new TObjArray();
+   fTopTasks   = new TObjArray();
+   fZombies    = new TObjArray();
+   fContainers = new TObjArray();
+   fInputs     = new TObjArray();
+   fOutputs    = new TObjArray();  
 }
 
-#ifdef NEVER
 //______________________________________________________________________________
 AliAnalysisManager::AliAnalysisManager(const AliAnalysisManager& other)
-                   :TSelector(other),
+                   :TNamed(other),
                     fTree(NULL),
-                    fInitOK(kFALSE),
-                    fContainers(NULL),
-                    fInputs(NULL),
-                    fOutputs(NULL),
+                    fCurrentEntry(-1),
+                    fMode(other.fMode),
+                    fInitOK(other.fInitOK),
+                    fDebug(other.fDebug),
                     fTasks(NULL),
                     fTopTasks(NULL),
-                    fZombies(NULL)
+                    fZombies(NULL),
+                    fContainers(NULL),
+                    fInputs(NULL),
+                    fOutputs(NULL)
 {
 // Copy constructor.
-   fInitOK     = other.fInitOK;
-   fContainers = new TObjArray(*other.fContainers);
-   fInputs     = new TObjArray(*other.fInputs);
-   fOutputs    = new TObjArray(*other.fOutputs);
    fTasks      = new TObjArray(*other.fTasks);
    fTopTasks   = new TObjArray(*other.fTopTasks);
    fZombies    = new TObjArray(*other.fZombies);
-//   fStatus     = new AliAnalysisInfo(this);
+   fContainers = new TObjArray(*other.fContainers);
+   fInputs     = new TObjArray(*other.fInputs);
+   fOutputs    = new TObjArray(*other.fOutputs);
+   fgAnalysisManager = this;
 }
    
 //______________________________________________________________________________
@@ -91,36 +116,44 @@ AliAnalysisManager& AliAnalysisManager::operator=(const AliAnalysisManager& othe
 {
 // Assignment
    if (&other != this) {
-      TSelector::operator=(other);
-      fTree       = other.fTree;
+      TNamed::operator=(other);
+      fTree       = NULL;
+      fCurrentEntry = -1;
+      fMode       = other.fMode;
       fInitOK     = other.fInitOK;
-      fContainers = new TObjArray(*other.fContainers);
-      fInputs     = new TObjArray(*other.fInputs);
-      fOutputs    = new TObjArray(*other.fOutputs);
+      fDebug      = other.fDebug;
       fTasks      = new TObjArray(*other.fTasks);
       fTopTasks   = new TObjArray(*other.fTopTasks);
       fZombies    = new TObjArray(*other.fZombies);
-//      fStatus     = new AliAnalysisInfo(this);
+      fContainers = new TObjArray(*other.fContainers);
+      fInputs     = new TObjArray(*other.fInputs);
+      fOutputs    = new TObjArray(*other.fOutputs);
+      fgAnalysisManager = this;
    }
    return *this;
 }
-#endif
 
 //______________________________________________________________________________
 AliAnalysisManager::~AliAnalysisManager()
 {
 // Destructor.
-   if (fContainers) {fContainers->Delete(); delete fContainers;}
-   if (fInputs) delete fInputs;
-   if (fOutputs) delete fOutputs;
    if (fTasks) {fTasks->Delete(); delete fTasks;}
    if (fTopTasks) delete fTopTasks;
    if (fZombies) delete fZombies;
+   if (fContainers) {fContainers->Delete(); delete fContainers;}
+   if (fInputs) delete fInputs;
+   if (fOutputs) delete fOutputs;
+   if (fgAnalysisManager==this) fgAnalysisManager = NULL;
 }
+
 //______________________________________________________________________________
 Int_t AliAnalysisManager::GetEntry(Long64_t entry, Int_t getall)
 {
 // Read one entry of the tree or a whole branch.
+   if (fDebug > 1) {
+      cout << "== AliAnalysisManager::GetEntry()" << endl;
+   }   
+   fCurrentEntry = entry;
    return fTree ? fTree->GetTree()->GetEntry(entry, getall) : 0;
 }
    
@@ -132,15 +165,18 @@ void AliAnalysisManager::Init(TTree *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.
-   printf("AliAnalysisManager::Init(%s)\n", tree->GetName());
-   if (!fInitOK) {
-     cout<<"You have to call InitAnalysis first"<<endl;
-     //AliError("You have to call InitAnalysis first");
-      return;
-   }   
    if (!tree) return;
+   if (fDebug > 1) {
+      printf("AliAnalysisManager::Init(%s)\n", tree->GetName());
+   }
+   if (!fInitOK) InitAnalysis();
+   if (!fInitOK) return;
    fTree = tree;
    AliAnalysisDataContainer *top = (AliAnalysisDataContainer*)fInputs->At(0);
+   if (!top) {
+      cout<<"Error: No top input container !" <<endl;
+      return;
+   }   
    top->SetData(tree);
 }
 
@@ -150,7 +186,9 @@ void AliAnalysisManager::Begin(TTree *tree)
   // The Begin() function is called at the start of the query.
   // When running with PROOF Begin() is only called on the client.
   // The tree argument is deprecated (on PROOF 0 is passed).
-   printf("AliAnalysisManager::Begin(%s)\n", tree->GetName());
+   if (fDebug > 1) {
+      cout << "AliAnalysisManager::Begin()" << endl;
+   }   
    Init(tree);
 }
 
@@ -160,8 +198,15 @@ 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).
-   printf("AliAnalysisManager::SlaveBegin(%s)\n", tree->GetName());
-   Init(tree);
+   if (fDebug > 1) {
+      cout << "AliAnalysisManager::SlaveBegin()" << endl;
+   }   
+   TIter next(fTasks);
+   AliAnalysisTask *task;
+   // Call CreateOutputObjects for all tasks
+   while ((task=(AliAnalysisTask*)next())) 
+      task->CreateOutputObjects();
+   if (fMode == kLocalAnalysis) Init(tree);   
 }
 
 //______________________________________________________________________________
@@ -174,7 +219,7 @@ Bool_t AliAnalysisManager::Notify()
    // user if needed. The return value is currently not used.
    if (fTree) {
       TFile *curfile = fTree->GetCurrentFile();
-      if (curfile) printf("AliAnalysisManager::Notify() file: %s\n", curfile->GetName());
+      if (curfile && fDebug>1) printf("AliAnalysisManager::Notify() file: %s\n", curfile->GetName());
    }
    return kTRUE;
 }    
@@ -200,32 +245,117 @@ Bool_t AliAnalysisManager::Process(Long64_t entry)
   //  Assuming that fChain is the pointer to the TChain being processed,
   //  use fChain->GetTree()->GetEntry(entry).
   
-//   printf("AliAnalysisManager::Process(%lld)\n", entry);
+   if (fDebug > 1) {
+      cout << "AliAnalysisManager::Process()" << endl;
+   }   
    GetEntry(entry);
    ExecAnalysis();
    return kTRUE;
 }
 
 //______________________________________________________________________________
-void AliAnalysisManager::SlaveTerminate()
+void AliAnalysisManager::PackOutput(TList *target)
 {
-  // The SlaveTerminate() function is called after all entries or objects
-  // have been processed. When running with PROOF SlaveTerminate() is called
-  // on each slave server.
-
-   printf("AliAnalysisManager::SlaveTerminate()\n");
-   if (!fOutput)
-   {
-     cout<<"ERROR: Output list not initialized."<<endl;
-     //AliError("ERROR: Output list not initialized.");
-     return;
-   }
+  // Pack all output data containers in the output list.
+   if (fDebug > 1) {
+      cout << "AliAnalysisManager::PackOutput()" << endl;
+   }   
+   if (!target) {
+      Error("PackOutput", "No target. Aborting.");
+      return;
+   }   
+
+   if (fMode == kProofAnalysis) {
+      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);
+      }
+   } 
+   fContainers->Clear();
+   if (fDebug > 1) {
+      printf("   ->output list contains %d containers\n", target->GetSize());  
+   }   
+}
+
+//______________________________________________________________________________
+void AliAnalysisManager::ReplaceOutputContainers(TList *source)
+{
+// Replace all exising containers with the ones coming in source.
    TIter next(fOutputs);
-   AliAnalysisDataContainer *output;
-   while ((output=(AliAnalysisDataContainer *)next())) {
-      output->SetDataOwned(kFALSE);
-      fOutput->Add(output->GetData());
+   AliAnalysisDataContainer *cont, *output;
+   while ((cont=(AliAnalysisDataContainer*)next())) {
+      output = (AliAnalysisDataContainer*)source->FindObject(cont->GetName());
+      if (!output) {
+         printf("Error: 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();
+   }         
+}
+
+//______________________________________________________________________________
+void AliAnalysisManager::UnpackOutput(TList *source)
+{
+  // Called by AliAnalysisSelector::Terminate. Output containers should
+  // be in source in the same order as in fOutputs.
+
+   if (!source) {
+      Error("PackOutput", "No target. Aborting.");
+      return;
+   }
+   if (fDebug > 1) {
+      printf("AliAnalysisManager::UnpackOutput(): %d containers\n", source->GetSize());
+      printf("   Source list contains %d containers\n", source->GetSize());
    }   
+   TCollection *collection = source;
+   if (fMode == kLocalAnalysis) collection = fOutputs;
+   TIter next(collection);
+
+   if (fMode == kProofAnalysis) {
+      ReplaceOutputContainers(source);
+      fOutputs->Clear();
+   }   
+   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();
+      if (!filename || !strlen(filename)) continue;
+      TFile *file = (TFile*)gROOT->GetListOfFiles()->FindObject(filename);
+      if (file) file->cd();
+      else      file = new TFile(filename, "RECREATE");
+      if (file->IsZombie()) continue;
+      // Reparent data to this file
+      TMethodCall callEnv;
+      if (output->GetData()->IsA())
+         callEnv.InitWithPrototype(output->GetData()->IsA(), "SetDirectory", "TDirectory*");
+      if (callEnv.IsValid()) {
+         callEnv.SetParam((Long_t) file);
+         callEnv.Execute(output->GetData());
+      }
+      output->GetData()->Write();      
+   }
 }
 
 //______________________________________________________________________________
@@ -233,15 +363,14 @@ 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 or save the results to file.
-   printf("AliAnalysisManager::Terminate()\n");
-   AliAnalysisDataContainer *output;
+  // the results graphically.
+   if (fDebug > 1) {
+      cout << "AliAnalysisManager::Terminate()" << endl;
+   }   
    AliAnalysisTask *task;
-   TIter next(fOutputs);
-   while ((output=(AliAnalysisDataContainer *)next())) output->WriteData();
-   TIter next1(fTasks);
+   TIter next(fTasks);
    // Call Terminate() for tasks
-   while ((task=(AliAnalysisTask*)next1())) task->Terminate();
+   while ((task=(AliAnalysisTask*)next())) task->Terminate();
 }
 
 //______________________________________________________________________________
@@ -262,10 +391,10 @@ AliAnalysisTask *AliAnalysisManager::GetTask(const char *name) const
 
 //______________________________________________________________________________
 AliAnalysisDataContainer *AliAnalysisManager::CreateContainer(const char *name, 
-                                TClass *datatype, EAliAnalysisContType type)
+                                TClass *datatype, EAliAnalysisContType type, const char *filename)
 {
 // Create a data container of a certain type. Types can be:
-//   kNormalContainer  = 0, used to exchange date between tasks
+//   kExchangeContainer  = 0, used to exchange date between tasks
 //   kInputContainer   = 1, used to store input data
 //   kOutputContainer  = 2, used for posting results
    AliAnalysisDataContainer *cont = new AliAnalysisDataContainer(name, datatype);
@@ -275,9 +404,11 @@ AliAnalysisDataContainer *AliAnalysisManager::CreateContainer(const char *name,
          fInputs->Add(cont);
          break;
       case kOutputContainer:
+         if (fOutputs->FindObject(name)) printf("CreateContainer: warning: a container named %s existing !\n",name);
          fOutputs->Add(cont);
+         if (filename && strlen(filename)) cont->SetFileName(filename);
          break;
-      case kNormalContainer:
+      case kExchangeContainer:
          break;   
    }
    return cont;
@@ -290,8 +421,7 @@ Bool_t AliAnalysisManager::ConnectInput(AliAnalysisTask *task, Int_t islot,
 // Connect input of an existing task to a data container.
    if (!fTasks->FindObject(task)) {
       AddTask(task);
-      cout<<"Task "<<task->GetName()<<" not registered. Now owned by analysis manager"<<endl;
-      //AliInfo(Form("Task %s not registered. Now owned by analysis manager", task->GetName()));
+      Warning("ConnectInput", "Task %s not registered. Now owned by analysis manager", task->GetName());
    } 
    Bool_t connected = task->ConnectInput(islot, cont);
    return connected;
@@ -304,8 +434,7 @@ Bool_t AliAnalysisManager::ConnectOutput(AliAnalysisTask *task, Int_t islot,
 // Connect output of an existing task to a data container.
    if (!fTasks->FindObject(task)) {
       AddTask(task);
-      cout<<"Task "<<task->GetName()<<"not registered. Now owned by analysis manager"<<endl;
-      //AliInfo(Form("Task %s not registered. Now owned by analysis manager", task->GetName()));
+      Warning("ConnectOutput", "Task %s not registered. Now owned by analysis manager", task->GetName());
    } 
    Bool_t connected = task->ConnectOutput(islot, cont);
    return connected;
@@ -331,18 +460,9 @@ Bool_t AliAnalysisManager::InitAnalysis()
 // and data containers are properly connected
    // Check for input/output containers
    fInitOK = kFALSE;
-//   if (!fInputs->GetEntriesFast()) {
-//      AliError("No input container defined. At least one container should store input data");
-//      return kFALSE;
-//   }   
-//   if (!fOutputs->GetEntriesFast()) {
-//      AliError("No output container defined. At least one container should store output data");
-//      return kFALSE;
-//   }   
    // Check for top tasks (depending only on input data containers)
    if (!fTasks->First()) {
-     cout<<"Analysis has no tasks !"<<endl;
-     //AliError("Analysis have no tasks !");
+      Error("InitAnalysis", "Analysis has no tasks !");
       return kFALSE;
    }   
    TIter next(fTasks);
@@ -357,13 +477,6 @@ Bool_t AliAnalysisManager::InitAnalysis()
       istop = kTRUE;
       iszombie = kFALSE;
       Int_t ninputs = task->GetNinputs();
-//      if (!ninputs) {
-//         task->SetZombie();
-//         fZombies->Add(task);
-//         nzombies++;
-//         AliWarning(Form("Task %s has no input slots defined ! Declared zombie...",task->GetName()));
-//         continue;
-//      }
       for (i=0; i<ninputs; i++) {
          cont = task->GetInputSlot(i)->GetContainer();
          if (!cont) {
@@ -373,8 +486,8 @@ Bool_t AliAnalysisManager::InitAnalysis()
                nzombies++;
                iszombie = kTRUE;
             }   
-            cout<<"Input slot "<<i<<" of task "<<task->GetName()<<" has no container connected ! Declared zombie..."<<endl;
-           //AliWarning(Form("Input slot %i of task %s has no container connected ! Declared zombie...",i,task->GetName()));
+            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
@@ -387,8 +500,7 @@ Bool_t AliAnalysisManager::InitAnalysis()
       }
    }
    if (!ntop) {
-     cout<<"No top task defined. At least one task should be connected only to input containers"<<endl;
-     //AliError("No top task defined. At least one task should be connected only to input containers");
+      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
@@ -401,8 +513,7 @@ Bool_t AliAnalysisManager::InitAnalysis()
    while ((task=(AliAnalysisTask*)next())) {
       if (!task->IsUsed()) {
          norphans++;
-         cout<<"Task "<<task->GetName()<<" is orphan"<<endl;
-        //AliWarning(Form("Task %s is orphan",task->GetName()));
+         Warning("InitAnalysis", "Task %s is orphan", task->GetName());
       }   
    }          
    // Check the task hierarchy (no parent task should depend on data provided
@@ -410,8 +521,7 @@ Bool_t AliAnalysisManager::InitAnalysis()
    for (i=0; i<ntop; i++) {
       task = (AliAnalysisTask*)fTopTasks->At(i);
       if (task->CheckCircularDeps()) {
-       cout<<"Found illegal circular dependencies between following tasks:"<<endl;
-       //AliError("Found illegal circular dependencies between following tasks:");
+         Error("InitAnalysis", "Found illegal circular dependencies between following tasks:");
          PrintStatus("dep");
          return kFALSE;
       }   
@@ -438,30 +548,93 @@ void AliAnalysisManager::ResetAnalysis()
 }
 
 //______________________________________________________________________________
+void AliAnalysisManager::StartAnalysis(const char *type, TTree *tree)
+{
+// Start analysis for this manager. Analysis task can be: LOCAL, PROOF or GRID.
+   if (!fInitOK) {
+      Error("StartAnalysis","Analysis manager was not initialized !");
+      return;
+   }
+   if (fDebug>1) {
+      cout << "StartAnalysis: " << GetName() << endl;   
+   }   
+   TString anaType = type;
+   anaType.ToLower();
+   fMode = kLocalAnalysis;
+   if (tree) {
+      if (anaType.Contains("proof"))     fMode = kProofAnalysis;
+      else if (anaType.Contains("grid")) fMode = kGridAnalysis;
+   }
+   if (fMode == kGridAnalysis) {
+      Warning("StartAnalysis", "GRID analysis mode not implemented. Running local.");
+      fMode = kLocalAnalysis; 
+   }     
+   char line[128];   
+   TChain *chain = dynamic_cast<TChain*>(tree);
+   switch (fMode) {
+      case kLocalAnalysis:
+         if (!tree) {
+            ExecAnalysis();
+            return;
+         } 
+         // Run tree-based analysis via AliAnalysisSelector  
+         gROOT->ProcessLine(".L $ALICE_ROOT/ANALYSIS/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);
+         sprintf(line, "((TTree*)0x%lx)->Process(selector);",(ULong_t)tree);
+         gROOT->ProcessLine(line);
+         break;
+      case kProofAnalysis:
+         if (!gROOT->GetListOfProofs() || !gROOT->GetListOfProofs()->GetEntries()) {
+            printf("StartAnalysis: no PROOF!!!\n");
+            return;
+         }   
+         sprintf(line, "gProof->AddInput((TObject*)0x%lx);", (ULong_t)this);
+         gROOT->ProcessLine(line);
+         if (chain) {
+            chain->SetProof();
+            cout << "===== RUNNING PROOF ANALYSIS " << GetName() << " ON CHAIN " << chain->GetName() << endl;
+            chain->Process(gSystem->ExpandPathName("$ALICE_ROOT/ANALYSIS/AliAnalysisSelector.cxx+"));
+         } else {
+            printf("StartAnalysis: no chain\n");
+            return;
+         }      
+         break;
+      case kGridAnalysis:
+         Warning("StartAnalysis", "GRID analysis mode not implemented. Running local.");
+   }   
+}   
+
+//______________________________________________________________________________
 void AliAnalysisManager::ExecAnalysis(Option_t *option)
 {
 // Execute analysis.
    if (!fInitOK) {
-     cout<<"Analysis manager was not initialized !"<<endl;
-     //AliError("Analysis manager was not initialized !");
+     Error("ExecAnalysis", "Analysis manager was not initialized !");
       return;
    }   
    AliAnalysisTask *task;
    // Check if the top tree is active.
    if (fTree) {
+      if (fDebug>1) {
+         printf("AliAnalysisManager::ExecAnalysis\n");
+      }   
       TIter next(fTasks);
    // De-activate all tasks
       while ((task=(AliAnalysisTask*)next())) task->SetActive(kFALSE);
       AliAnalysisDataContainer *cont = (AliAnalysisDataContainer*)fInputs->At(0);
       if (!cont) {
-       cout<<"Cannot execute analysis in TSelector mode without at least one top container"<<endl;
-       //AliError("Cannot execute analysis in TSelector mode without at least one top container");
+             Error("ExecAnalysis","Cannot execute analysis in TSelector mode without at least one top container");
          return;
       }   
       cont->SetData(fTree); // This will notify all consumers
       TIter next1(cont->GetConsumers());
       while ((task=(AliAnalysisTask*)next1())) {
 //         task->SetActive(kTRUE);
+         if (fDebug >1) {
+            cout << "    Executing task " << task->GetName() << endl;
+         }   
          task->ExecuteTask(option);
       }
       return;
@@ -470,7 +643,9 @@ void AliAnalysisManager::ExecAnalysis(Option_t *option)
    TIter next2(fTopTasks);
    while ((task=(AliAnalysisTask*)next2())) {
       task->SetActive(kTRUE);
-      printf("executing %s\n", task->GetName());
+      if (fDebug > 1) {
+         cout << "    Executing task " << task->GetName() << endl;
+      }   
       task->ExecuteTask(option);
    }   
 }
index 8ee6c3b..0085423 100644 (file)
 // event for all tasks depending only on initial input data.
 //==============================================================================
 
-#ifndef ROOT_TSelector
-#include "TSelector.h"
+#ifndef ROOT_TNamed
+#include <TNamed.h>
 #endif
 
 class TClass;
+class TTree;
 class AliAnalysisDataContainer;
 class AliAnalysisTask;
 
-class AliAnalysisManager : public TSelector {
+class AliAnalysisManager : public TNamed {
 
 public:
 
 enum EAliAnalysisContType {
-   kNormalContainer  = 0,
+   kExchangeContainer  = 0,
    kInputContainer   = 1,
    kOutputContainer  = 2
 };   
+
+enum EAliAnalysisExecMode {
+   kLocalAnalysis    = 0,
+   kProofAnalysis    = 1,
+   kGridAnalysis     = 2
+};
+
    AliAnalysisManager();
+   AliAnalysisManager(const char *name, const char *title="");
    virtual            ~AliAnalysisManager();
+
+   AliAnalysisManager(const AliAnalysisManager& other);
+   AliAnalysisManager& operator=(const AliAnalysisManager& other);
    
-   // Selector-specific methods
+   void                StartAnalysis(const char *type="local", TTree *tree=0);
+
    virtual void        Init(TTree *tree);   
    virtual void        Begin(TTree *tree);
    virtual Bool_t      Notify();
@@ -41,22 +54,32 @@ enum EAliAnalysisContType {
    virtual Bool_t      ProcessCut(Long64_t entry) {return Process(entry);}
    virtual Bool_t      Process(Long64_t entry);
    virtual Int_t       GetEntry(Long64_t entry, Int_t getall = 0);
-   virtual void        SlaveTerminate();
+   void                PackOutput(TList *target);
+   void                UnpackOutput(TList *source);
    virtual void        Terminate();
 
-   // Getters
-   TTree              *GetTree() const       {return fTree;}
+   // Getters/Setters
+   static AliAnalysisManager *GetAnalysisManager() {return fgAnalysisManager;}
    TObjArray          *GetContainers() const {return fContainers;}
+   UInt_t              GetDebugLevel() const {return fDebug;}
    TObjArray          *GetInputs() const     {return fInputs;}
    TObjArray          *GetOutputs() const    {return fOutputs;}
    TObjArray          *GetTasks() const      {return fTasks;}
    TObjArray          *GetTopTasks() const   {return fTopTasks;}
+   TTree              *GetTree() const       {return fTree;}
    TObjArray          *GetZombieTasks() const {return fZombies;}
-//   AliAnalysisInfo    *GetStatus() const     {return fStatus;}  
+   Long64_t            GetCurrentEntry() const {return fCurrentEntry;}
+   EAliAnalysisExecMode 
+                       GetAnalysisType() const {return fMode;}
+
+   void                SetAnalysisType(EAliAnalysisExecMode mode) {fMode = mode;}
+   void                SetCurrentEntry(Long64_t entry) {fCurrentEntry = entry;}
+   void                SetDebugLevel(UInt_t level) {fDebug = level;}
 
    // Container handling
    AliAnalysisDataContainer *CreateContainer(const char *name, TClass *datatype, 
-                                EAliAnalysisContType type=kNormalContainer);
+                       EAliAnalysisContType type     = kExchangeContainer, 
+                       const char          *filename = NULL);
    
    // Including tasks and getting them
    void                 AddTask(AliAnalysisTask *task);
@@ -79,21 +102,22 @@ enum EAliAnalysisContType {
    void                 PrintStatus(Option_t *option="all") const;
 
 protected:
-   TTree               *fTree;         // Input tree in case of TSelector model
-   Bool_t               fInitOK;       // Initialisation done
-   TObjArray           *fContainers;   //-> List of all containers
-   TObjArray           *fInputs;       //-> List of containers with input data
-   TObjArray           *fOutputs;      //-> List of containers with results
-   TObjArray           *fTasks;        //-> List of analysis tasks
-   TObjArray           *fTopTasks;     //-> List of top tasks
-   TObjArray           *fZombies;      //-> List of zombie tasks
-//   AliAnalysisInfo     *fStatus;       // Analysis info object
+   void                 ReplaceOutputContainers(TList *source);
 
 private:
-   AliAnalysisManager(const AliAnalysisManager& other);
-   AliAnalysisManager& operator=(const AliAnalysisManager& other);
-
+   TTree               *fTree;         //! Input tree in case of TSelector model
+   Long64_t             fCurrentEntry; //! Current processed entry in the tree
+   EAliAnalysisExecMode fMode;         // Execution mode
+   Bool_t               fInitOK;       // Initialisation done
+   UInt_t               fDebug;        // Debug level
+   TObjArray           *fTasks;        // List of analysis tasks
+   TObjArray           *fTopTasks;     // List of top tasks
+   TObjArray           *fZombies;      // List of zombie tasks
+   TObjArray           *fContainers;   // List of all containers
+   TObjArray           *fInputs;       // List of containers with input data
+   TObjArray           *fOutputs;      // List of containers with results
 
+   static AliAnalysisManager *fgAnalysisManager; //! static pointer to object instance
    ClassDef(AliAnalysisManager,1)  // Analysis manager class
 };   
 #endif
diff --git a/ANALYSIS/AliAnalysisRLContainer.cxx b/ANALYSIS/AliAnalysisRLContainer.cxx
deleted file mode 100644 (file)
index 7c1a577..0000000
+++ /dev/null
@@ -1,224 +0,0 @@
-/**************************************************************************
- * 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
-
-//==============================================================================
-//   AliAnalysysRLContainer - 
-//
-//
-//
-//==============================================================================
-
-#include "AliAnalysisRLContainer.h"
-#include "TTree.h"
-#include "TFile.h"
-
-#include "AliLog.h"
-#include "AliRunLoader.h"
-#include "AliESD.h"
-#include "AliHeader.h"
-#include "AliStack.h"
-#include "AliAnalysisDataContainer.h"
-#include "AliAnalysisDataSlot.h"
-#include "AliAnalysisTask.h"
-
-ClassImp(AliAnalysisRLContainer)
-
-//______________________________________________________________________________
-AliAnalysisRLContainer::AliAnalysisRLContainer()
-                       :AliAnalysisDataContainer(),
-                        fRunLoader(NULL),
-                        fESD(NULL),
-                        fKineFile(NULL),
-                        fKinematicsLoaded(kFALSE),
-                        fHeaderLoaded(kFALSE)
-{
-// Dummy ctor.
-}
-
-//______________________________________________________________________________
-AliAnalysisRLContainer::AliAnalysisRLContainer(const char *name)
-                       :AliAnalysisDataContainer(name, TTree::Class()),
-                        fRunLoader(NULL),
-                        fESD(NULL),
-                        fKineFile(NULL),
-                        fKinematicsLoaded(kFALSE),
-                        fHeaderLoaded(kFALSE)
-{
-// Normal constructor.
-}
-
-//______________________________________________________________________________
-AliAnalysisRLContainer::AliAnalysisRLContainer(const AliAnalysisRLContainer &rlc)
-                       :AliAnalysisDataContainer(rlc),
-                        fRunLoader(rlc.fRunLoader),
-                        fESD(rlc.fESD),
-                        fKineFile(rlc.fKineFile),
-                        fKinematicsLoaded(rlc.fKinematicsLoaded),
-                        fHeaderLoaded(rlc.fHeaderLoaded)
-{
-// Copy constructor.
-}   
-
-//______________________________________________________________________________
-AliAnalysisRLContainer::~AliAnalysisRLContainer()
-{
-// Destructor. Deletes data ! (What happens if data is a container ???)
-}
-
-//______________________________________________________________________________
-AliAnalysisRLContainer &AliAnalysisRLContainer::operator=(const AliAnalysisRLContainer &rlc)
-{
-// Assignment.
-   if (&rlc != this) {
-      AliAnalysisDataContainer::operator=(rlc);
-      fRunLoader = rlc.fRunLoader;
-      fESD = rlc.fESD;
-      fKineFile = rlc.fKineFile;
-      fKinematicsLoaded = rlc.fKinematicsLoaded;
-      fHeaderLoaded = rlc.fHeaderLoaded;
-   }
-   return *this;   
-}
-
-//______________________________________________________________________________
-Bool_t AliAnalysisRLContainer::SetData(TObject *data, Option_t */*option*/)
-{
-// Data must be a tree here.
-   fData = data;
-   TTree *tree = (TTree *)data;
-   // Set branch address
-   tree->SetBranchAddress("ESD", &fESD);
-   fDataReady = kTRUE;
-   return kTRUE;
-}
-
-//______________________________________________________________________________
-void AliAnalysisRLContainer::GetEntry(Long64_t ientry)
-{
-// If data is ready and derives from TTree or from TBranch, this will get the
-// requested entry in memory if not already loaded.
-   if (!fDataReady) return;
-   TTree *tree = (TTree*)fData;
-   tree->GetTree()->GetEntry(ientry);
-   if (fRunLoader) fRunLoader->GetEvent(ientry);
-}   
-
-//______________________________________________________________________________
-void AliAnalysisRLContainer::NotifyChange(ENotifyMessage type)
-{
-// Notify container that file has changed.
-   AliAnalysisDataContainer::NotifyChange(type);
-   if (!type==kFileChange) return;
-   DeleteKinematicsFile();
-   DeleteRunLoader();
-}
-
-//______________________________________________________________________________
-void AliAnalysisRLContainer::DeleteRunLoader() 
-{
-// Deletes the runloader.
-   if (fRunLoader) {
-      fRunLoader->Delete();
-      fRunLoader = 0;
-   }
-   fKinematicsLoaded = kFALSE;
-   fHeaderLoaded = kFALSE;
-}
-
-//______________________________________________________________________________
-void AliAnalysisRLContainer::DeleteKinematicsFile() 
-{
-// Closes the kinematics file and deletes the pointer.
-   if (fKineFile) {
-      fKineFile->Close();
-      delete fKineFile;
-      fKineFile = 0;
-   }
-}   
-
-//______________________________________________________________________________
-AliRunLoader* AliAnalysisRLContainer::GetRunLoader()
-{
-// Returns AliRun instance corresponding to current ESD active in fTree
-// Loads galice.root, the file is identified by replacing "AliESDs" to
-// "galice" in the file path of the ESD file. This is a hack, to be changed!
-
-   if (!fDataReady) return 0;
-   TTree *tree = (TTree*)fData;
-   if (!fRunLoader) {
-      if (!tree->GetCurrentFile()) return 0;
-      TString fileName(tree->GetCurrentFile()->GetName());
-      fileName.ReplaceAll("AliESDs", "galice");
-      fRunLoader = AliRunLoader::Open(fileName);
-      if (!fRunLoader) return 0;
-      if (fRunLoader->LoadgAlice() != 0) {
-         delete fRunLoader;
-         fRunLoader = 0;
-         return 0;
-      }
-      fRunLoader->GetEvent(tree->GetTree()->GetReadEntry());
-  }
-  return fRunLoader;
-}
-
-//______________________________________________________________________________
-AliHeader* AliAnalysisRLContainer::GetHeader()
-{
-// Returns header retrieved from RunLoader
-   AliRunLoader* runLoader = GetRunLoader();
-   if (!runLoader) return 0;
-   if (!fHeaderLoaded) 
-      if (runLoader->LoadHeader() != 0) return 0;
-   fHeaderLoaded = kTRUE;
-   return runLoader->GetHeader();
-}
-
-//______________________________________________________________________________
-TTree* AliAnalysisRLContainer::GetKinematics()
-{
-// Returns kinematics tree corresponding to current ESD active in fTree
-// Loads the kinematics from the kinematics file, the file is identified by replacing "AliESDs" to
-// "Kinematics" in the file path of the ESD file. This is a hack, to be changed!
-
-   if (!fDataReady) return 0;
-   TTree *tree = (TTree*)fData;
-   if (!fKineFile) {
-      if (!tree->GetCurrentFile()) return 0;
-      TString fileName(tree->GetCurrentFile()->GetName());
-      fileName.ReplaceAll("AliESDs", "Kinematics");
-
-      AliDebug(AliLog::kInfo, Form("Opening %s", fileName.Data()));
-
-      fKineFile = TFile::Open(fileName);
-      if (!fKineFile) return 0;
-   }
-   return dynamic_cast<TTree*> (fKineFile->Get(Form("Event%d/TreeK", tree->GetTree()->GetReadEntry())));
-}
-
-//______________________________________________________________________________
-AliStack* AliAnalysisRLContainer::GetStack()
-{
-// Returns stack retrieved from RunLoader
-
-   AliRunLoader* runLoader = GetRunLoader();
-   if (!runLoader) return 0;
-   if (!fKinematicsLoaded)
-      if (runLoader->LoadKinematics() != 0) return 0;
-   fKinematicsLoaded = kTRUE;
-   return runLoader->Stack();
-}
diff --git a/ANALYSIS/AliAnalysisRLContainer.h b/ANALYSIS/AliAnalysisRLContainer.h
deleted file mode 100644 (file)
index 8a24f82..0000000
+++ /dev/null
@@ -1,55 +0,0 @@
-#ifndef ALIANALYSISRLCONTAINER_H
-#define ALIANALYSISRLCONTAINER_H
-/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
- * See cxx source for full Copyright notice                               */
-
-/* $Id$ */
-// Author: Andrei Gheata, 31/05/2006
-
-//==============================================================================
-//   AliAnalysysRLContainer - Special container working with AliRunLoader
-//        with trees
-//==============================================================================
-
-#ifndef ALIANALYSISDATQCONTAINER_H
-#include "AliAnalysisDataContainer.h"
-#endif
-
-class TFile;
-class TTree;
-class AliRunLoader;
-class AliHeader;
-class AliStack;
-
-class AliAnalysisRLContainer : public AliAnalysisDataContainer {
-
-public:
-   AliAnalysisRLContainer();
-   AliAnalysisRLContainer(const char *name);
-   AliAnalysisRLContainer(const AliAnalysisRLContainer &rlc);
-   virtual ~AliAnalysisRLContainer();
-   
-   AliAnalysisRLContainer &operator=(const AliAnalysisRLContainer &rlc);
-   AliRunLoader             *GetRunLoader();
-   AliHeader                *GetHeader();
-   AliStack                 *GetStack();
-   TTree                    *GetKinematics();
-   AliESD                   *GetESD() const {return fESD;}
-   virtual void              GetEntry(Long64_t ientry);
-   virtual Bool_t            SetData(TObject *data, Option_t *option="");
-   // Send a notify signal to the container
-   virtual void              NotifyChange(ENotifyMessage type);
-
-private:
-   void                      DeleteKinematicsFile();
-   void                      DeleteRunLoader();   
-
-   AliRunLoader*             fRunLoader;    //! pointer to the RunLoader if galice.root was opened
-   AliESD*                   fESD;        //! "ESD" branch in fChain
-   TFile*                    fKineFile;   //! pointer to Kinematics.root if the file was opened
-   Bool_t                    fKinematicsLoaded;    // determines if the stack is properly loaded (AliRunLoader::LoadKinematics() succeeded), this is needed because the GetStack returnes a invalid stack object when the function failed
-   Bool_t                    fHeaderLoaded;        // determines if the header is properly loaded
-
-   ClassDef(AliAnalysisRLContainer,1)  // Class describing a data container using AliRunLoader
-};
-#endif
diff --git a/ANALYSIS/AliAnalysisSelector.cxx b/ANALYSIS/AliAnalysisSelector.cxx
new file mode 100644 (file)
index 0000000..a585053
--- /dev/null
@@ -0,0 +1,142 @@
+/**************************************************************************
+ * 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
+
+//==============================================================================
+//   AliAnalysisSelector - A transparent selector to be created by 
+// AliAnalysisManager to handle analysis.
+//==============================================================================
+
+#include "Riostream.h"
+
+#include "AliAnalysisManager.h"
+#include "AliAnalysisTask.h"
+#include "AliAnalysisDataContainer.h"
+#include "AliAnalysisSelector.h"
+
+ClassImp(AliAnalysisSelector)
+
+//______________________________________________________________________________
+AliAnalysisSelector::AliAnalysisSelector(AliAnalysisManager *mgr)
+                    :TSelector(),
+                     fInitialized(kFALSE),
+                     fAnalysis(mgr)
+{
+// Constructor. Called by AliAnalysisManager which registers itself on the
+// selector running on the master.
+}
+
+//______________________________________________________________________________
+AliAnalysisSelector::~AliAnalysisSelector()
+{
+// Dtor. The analysis manager object is sent in the input list and duplicated
+// on the workers - it needs to be deleted (?)
+//   if (fAnalysis) delete fAnalysis;
+}
+
+//______________________________________________________________________________
+void AliAnalysisSelector::Init(TTree *tree)
+{
+// Called after Begin/SlaveBegin, assumes that fAnalysis is already initialized.
+// Is Init called on workers in case of PROOF.
+   if (!fAnalysis) {
+      Error("Init", "Analysis manager NULL !");
+      return;
+   }
+   if (!tree) {
+      Error("Init", "Input tree is NULL !");
+      return;
+   }
+   fAnalysis->Init(tree);
+   fInitialized = kTRUE;
+}
+
+//______________________________________________________________________________
+void AliAnalysisSelector::Begin(TTree *)
+{
+// Assembly the input list.
+   RestoreAnalysisManager();
+}
+
+//______________________________________________________________________________
+void AliAnalysisSelector::SlaveBegin(TTree *tree)
+{
+// Called on each worker. We "unpack" analysis manager here and call InitAnalysis.
+   RestoreAnalysisManager();
+   if (fAnalysis) fAnalysis->SlaveBegin(tree);   
+}      
+
+//______________________________________________________________________________
+Bool_t AliAnalysisSelector::Process(Long64_t entry)
+{
+// Event loop.
+   if (fAnalysis->GetDebugLevel() >1 ) {
+      printf("AliAnalysisSelector::Process()\n");
+   }   
+   fAnalysis->GetEntry(entry); // Not needed anymore in version 2
+   fAnalysis->ExecAnalysis();
+   return kTRUE;
+}   
+
+//______________________________________________________________________________
+void AliAnalysisSelector::RestoreAnalysisManager()
+{
+// Restores analysis manager from the input list.
+   if (!fAnalysis) {
+      TIter next(fInput);
+      TObject *obj;
+      while ((obj=next())) {
+         if (obj->IsA() == AliAnalysisManager::Class()) {
+            fAnalysis = (AliAnalysisManager*)obj;
+            break;
+         }
+      }
+      if (!fAnalysis) {
+         Error("SlaveBegin", "Analysis manager not found in the input list");
+         return;
+      }   
+   }
+}
+
+//______________________________________________________________________________
+void AliAnalysisSelector::SlaveTerminate()
+{
+  // The SlaveTerminate() function is called after all entries or objects
+  // have been processed. When running with PROOF SlaveTerminate() is called
+  // on each slave server.
+   if (fAnalysis->GetDebugLevel() >1 ) {
+      printf("AliAnalysisSelector::SlaveTerminate()\n");
+   }   
+   fAnalysis->PackOutput(fOutput);
+}  
+
+//______________________________________________________________________________
+void AliAnalysisSelector::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 or save the results to file.
+   if (!fAnalysis) {
+      Error("Terminate","AliAnalysisSelector::Terminate: No analysisManager!!!");
+      return;
+   }   
+   if (fAnalysis->GetDebugLevel() >1 ) {
+      printf("AliAnalysisSelector::Terminate()\n");
+   }   
+   fAnalysis->UnpackOutput(fOutput);
+   fAnalysis->Terminate();   
+}
diff --git a/ANALYSIS/AliAnalysisSelector.h b/ANALYSIS/AliAnalysisSelector.h
new file mode 100644 (file)
index 0000000..93c4e42
--- /dev/null
@@ -0,0 +1,47 @@
+#ifndef ALIANALYSISSELECTOR_H
+#define ALIANALYSISSELECTOR_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+// Author: Andrei Gheata, 31/05/2006
+
+//==============================================================================
+//   AliAnalysisSelector - Transparent selector class instantiated by an
+// analysis manager object.
+//==============================================================================
+
+#ifndef ROOT_TSelector
+#include "TSelector.h"
+#endif
+
+class AliAnalysisManager;
+
+class AliAnalysisSelector : public TSelector {
+
+protected:
+   Bool_t              fInitialized; // Flag that initialization was done
+   AliAnalysisManager *fAnalysis;    // Analysis manager to be processed
+   
+private:
+   AliAnalysisSelector(const AliAnalysisSelector&);            // not implemented
+   AliAnalysisSelector& operator=(const AliAnalysisSelector&); // not implemented
+   void                RestoreAnalysisManager();
+
+public:
+   AliAnalysisSelector() : TSelector(), fInitialized(kFALSE), fAnalysis(NULL) {}
+   AliAnalysisSelector(AliAnalysisManager *mgr);
+   virtual ~AliAnalysisSelector();
+   
+   virtual int         Version() const {return 1;}
+   virtual void        Init(TTree *tree);
+   virtual void        Begin(TTree *);
+   virtual void        SlaveBegin(TTree *tree);
+   virtual Bool_t      Notify() {return kTRUE;}   
+   virtual Bool_t      Process(Long64_t entry);
+   virtual void        SlaveTerminate();
+   virtual void        Terminate();
+
+   ClassDef(AliAnalysisSelector,0)  //A class for processing jobs using AliAnalysisManager
+};
+
+#endif
index 223845c..2efecdf 100644 (file)
 // To connect a slot to a data container, the data types declared by both must
 // match.
 //
-// The method Init will be called once per session at the moment when the data is
-// available at all input slots. 
-// The method Init() has to be overloaded by the derived class in order to:
-// 1. Define objects that should be created only once per session (e.g. output
-//    histograms)
-// 2. Set the branch address or connect to a branch address in case the input
-//    slots are connected to trees.
-//
+// The method ConnectInputData() has to be overloaded by the derived class in order to
+// set the branch address or connect to a branch address in case the input
+// slots are connected to trees.
 // Example:
-// MyAnalysisTask::Init(Option_t *)
+// MyAnalysisTask::ConnectInputData(Option_t *)
 // {
-//    if (!fHist1) fHist1 = new TH1F("h1", ....);
-//    if (!fHist2) fHist2 = new TH1F("h2", ....);
-//    fESD = GetBranchAddress(islot=0, "ESD");
-//    if (!fESD) SetBranchAddress(islot=0, "ESD", &fESD);
+//  // One should first check if the branch address was taken by some other task
+//    char ** address = (char **)GetBranchAddress(0, "ESD");
+//    if (address) {
+//      fESD = (AliESD*)(*address);
+//    } else {
+//      fESD = new AliESD();
+//      SetBranchAddress(0, "ESD", &fESD);
+//    }
+// }
+// 
+// The method CreateOutputObjects() has to be overloaded an will contain the
+// objects that should be created only once per session (e.g. output
+// histograms)
+//
+// void MyAnalysisTask::CreateOutputObjects()
+//{
+  // create histograms 
+//  fhPt = new TH1F("fhPt","This is the Pt distribution",15,0.1,3.1);
+//  fhPt->SetStats(kTRUE);
+//  fhPt->GetXaxis()->SetTitle("P_{T} [GeV]");
+//  fhPt->GetYaxis()->SetTitle("#frac{dN}{dP_{T}}");
+//  fhPt->GetXaxis()->SetTitleColor(1);
+//  fhPt->SetMarkerStyle(kFullCircle);
 // }
 //
 // The method Terminate() will be called by the framework once at the end of
-// data processing. Overload this if needed.
+// data processing. Overload this if needed. DO NOT ASSUME that the pointers
+// to histograms defined in  CreateOutputObjects() are valid, since this is
+// not true in case of PROOF. Restore the pointer values like:
+//
+//void MyAnalysisTask::Terminate(Option_t *) 
+//{
+//  fhPt = (TH1F*)GetOutputData(0);
+// ...
+//}
+
 //
 //==============================================================================
 
 #include <Riostream.h>
-#include <TClass.h>
 #include <TDirectory.h>
+#include <TClass.h>
 
-//#include "AliLog.h"
 #include "AliAnalysisTask.h"
 #include "AliAnalysisDataSlot.h"
 #include "AliAnalysisDataContainer.h"
@@ -139,6 +161,7 @@ AliAnalysisTask::AliAnalysisTask(const AliAnalysisTask &task)
 AliAnalysisTask::~AliAnalysisTask()
 {
 // Dtor.
+   if (fTasks) fTasks->Clear();
    if (fInputs)  {fInputs->Delete(); delete fInputs;}
    if (fOutputs) {fOutputs->Delete(); delete fOutputs;}
 }   
@@ -177,8 +200,7 @@ Bool_t AliAnalysisTask::AreSlotsConnected()
    for (i=0; i<fNinputs; i++) {
       slot = (AliAnalysisDataSlot*)fInputs->At(i);
       if (!slot) {
-       cout<<"Input slot "<<i<<" of task "<<GetName()<<" not defined !"<<endl;
-       //AliError(Form("Input slot %i of task %s not defined !",i,GetName()));
+             Error("AreSlotsConnected", "Input slot %d of task %s not defined !",i,GetName());
          return kFALSE;
       }   
       if (!slot->IsConnected()) return kFALSE;
@@ -186,8 +208,7 @@ Bool_t AliAnalysisTask::AreSlotsConnected()
    for (i=0; i<fNoutputs; i++) {
       slot = (AliAnalysisDataSlot*)fOutputs->At(i);
       if (!slot) {
-       cout<<"Output slot "<<i<<" of task "<<GetName()<<" not defined !"<<endl;
-       //AliError(Form("Output slot %i of task %s not defined !",i,GetName()));
+         Error("AreSlotsConnected", "Output slot %d of task %s not defined !",i,GetName());
          return kFALSE;
       }   
       if (!slot->IsConnected()) return kFALSE;
@@ -212,7 +233,7 @@ void AliAnalysisTask::CheckNotify(Bool_t init)
    SetActive(kTRUE);
    if (fInitialized) return;
    TDirectory *cursav = gDirectory;
-   Init();
+   ConnectInputData();
    if (cursav) cursav->cd();
    fInitialized = kTRUE;
 }
@@ -223,14 +244,12 @@ Bool_t AliAnalysisTask::ConnectInput(Int_t islot, AliAnalysisDataContainer *cont
 // Connect an input slot to a data container.
    AliAnalysisDataSlot *input = GetInputSlot(islot);
    if (!input) {
-     cout<<"Input slot "<<islot<<" not defined for analysis task "<<GetName()<<endl;
-     //AliError(Form("Input slot %i not defined for analysis task %s", islot, GetName()));
+      Error("ConnectInput","Input slot %i not defined for analysis task %s", islot, GetName());
       return kFALSE;
    }
    // Check type matching          
    if (!input->GetType()->InheritsFrom(cont->GetType())) {
-     cout<<"Data type "<<input->GetType()->GetName()<<" for input "<<islot<<" of task "<<GetName()<<" not matching container "<<cont->GetName()<<" of type "<<cont->GetType()->GetName()<<endl;
-     //AliError(Form("Data type %s for input %i of task %s not matching container %s of type %s",input->GetType()->GetName(), islot, GetName(), cont->GetName(), cont->GetType()->GetName()));
+      Error("ConnectInput","Data type %s for input %i of task %s not matching container %s of type %s",input->GetType()->GetName(), islot, GetName(), cont->GetName(), cont->GetType()->GetName());
       return kFALSE;
    }  
    // Connect the slot to the container as input          
@@ -247,14 +266,12 @@ Bool_t AliAnalysisTask::ConnectOutput(Int_t islot, AliAnalysisDataContainer *con
 // Connect an output slot to a data container.
    AliAnalysisDataSlot *output = GetOutputSlot(islot);
    if (!output) {
-     cout<<"Output slot "<<islot<<" not defined for analysis task "<<GetName()<<endl;
-     //AliError(Form("Output slot %i not defined for analysis task %s", islot, GetName()));
+      Error("ConnectOutput","Output slot %i not defined for analysis task %s", islot, GetName());
       return kFALSE;
    }
    // Check type matching          
    if (!output->GetType()->InheritsFrom(cont->GetType())) {
-     cout<<"Data type "<<output->GetType()->GetName()<<" for output "<<islot<<" of task "<<GetName()<<" not matching container "<<cont->GetName()<<" of type "<<cont->GetType()->GetName()<<endl;
-     //AliError(Form("Data type %s for output %i of task %s not matching container %s of type %s",output->GetType()->GetName(), islot, GetName(), cont->GetName(), cont->GetType()->GetName()));
+      Error("ConnectOutput","Data type %s for output %i of task %s not matching container %s of type %s",output->GetType()->GetName(), islot, GetName(), cont->GetName(), cont->GetType()->GetName());
       return kFALSE;
    }            
    // Connect the slot to the container as output         
@@ -278,11 +295,6 @@ void AliAnalysisTask::DefineInput(Int_t islot, TClass *type)
 void AliAnalysisTask::DefineOutput(Int_t islot, TClass *type)
 {
 // Define an output slot and its type.
-   if (islot<0) {
-     cout<<"Cannot define negative output slot number for task "<<GetName()<<endl;
-     //AliError(Form("Cannot define negative output slot number for task %s", GetName()));
-      return;
-   }   
    AliAnalysisDataSlot *output = new AliAnalysisDataSlot(type, this);
    if (fNoutputs<islot+1) {
       fNoutputs = islot+1;
@@ -299,8 +311,7 @@ TClass *AliAnalysisTask::GetInputType(Int_t islot) const
 // Retreive type of a given input slot.
    AliAnalysisDataSlot *input = GetInputSlot(islot);
    if (!input) {
-     cout<<"Input slot "<<islot<<" not defined for analysis task "<<GetName()<<endl;
-     //AliError(Form("Input slot %i not defined for analysis task %s", islot, GetName()));
+      Error("GetInputType","Input slot %d not defined for analysis task %s", islot, GetName());
       return NULL;
    }
    return (input->GetType());
@@ -312,8 +323,7 @@ TClass *AliAnalysisTask::GetOutputType(Int_t islot) const
 // Retreive type of a given output slot.
    AliAnalysisDataSlot *output = GetOutputSlot(islot);
    if (!output) {
-     cout<<"Output slot "<<islot<<" not defined for analysis task "<<GetName()<<endl;
-     //AliError(Form("Output slot %i not defined for analysis task %s", islot, GetName()));
+      Error("GetOutputType","Output slot %d not defined for analysis task %s", islot, GetName());
       return NULL;
    }
    return (output->GetType());
@@ -326,14 +336,26 @@ TObject *AliAnalysisTask::GetInputData(Int_t islot) const
 // the object has to be statically cast to the appropriate type.
    AliAnalysisDataSlot *input = GetInputSlot(islot);
    if (!input) {
-     cout<<"Input slot "<<islot<<" not defined for analysis task "<<GetName()<<endl;
-     //AliError(Form("Input slot %i not defined for analysis task %s", islot, GetName()));
+      Error("GetInputData","Input slot %d not defined for analysis task %s", islot, GetName());
       return NULL;
    }
    return (input->GetData()); 
 }
 
 //______________________________________________________________________________
+TObject *AliAnalysisTask::GetOutputData(Int_t islot) const
+{
+// Retreive output data for a slot. Normally called in UserTask::Terminate to
+// get a valid pointer to data even in case of Proof.
+   AliAnalysisDataSlot *output = GetOutputSlot(islot);
+   if (!output) {
+      Error("GetOutputData","Input slot %d not defined for analysis task %s", islot, GetName());
+      return NULL;
+   }
+   return (output->GetData()); 
+}
+
+//______________________________________________________________________________
 char *AliAnalysisTask::GetBranchAddress(Int_t islot, const char *branch) const
 {
 // Check if a branch with a given name from the specified input is connected
@@ -350,23 +372,22 @@ Bool_t AliAnalysisTask::SetBranchAddress(Int_t islot, const char *branch, void *
 }   
 
 //______________________________________________________________________________
-void AliAnalysisTask::Init(Option_t *)
+void AliAnalysisTask::ConnectInputData(Option_t *)
 {
-// Branch address initialization.
+// Overload and connect your branches here.
 }
 
 //______________________________________________________________________________
-void AliAnalysisTask::Terminate(Option_t *)
+void AliAnalysisTask::CreateOutputObjects()
 {
-// Method called by the framework at the end of data processing.
+// Overload and create your output objects here.
 }
 
 //______________________________________________________________________________
-void AliAnalysisTask::OpenFile(Int_t iout, const char *name, Option_t *option) const
+void AliAnalysisTask::Terminate(Option_t *)
 {
-// Set data at output iout to be written in the specified file.
-   GetOutputSlot(iout)->GetContainer()->OpenFile(name, option);
-}   
+// Method called by the framework at the end of data processing.
+}
 
 //______________________________________________________________________________
 Bool_t AliAnalysisTask::PostData(Int_t iout, TObject *data, Option_t *option)
@@ -378,13 +399,11 @@ Bool_t AliAnalysisTask::PostData(Int_t iout, TObject *data, Option_t *option)
    fPublishedData = 0;
    AliAnalysisDataSlot *output = GetOutputSlot(iout);
    if (!output) {
-     cout<<"Output slot "<<iout<<" not defined for analysis task "<<GetName()<<endl;
-     //AliError(Form("Output slot %i not defined for analysis task %s", iout, GetName()));
+      Error("PostData","Output slot %i not defined for analysis task %s", iout, GetName());
       return kFALSE;
    }
    if (!output->IsConnected()) {
-     cout<<"Output slot "<<iout<<" of analysis task "<<GetName()<<" not connected to any data container"<<endl;
-     //AliError(Form("Output slot %i of analysis task %s not connected to any data container", iout, GetName()));
+      Error("PostData","Output slot %i of analysis task %s not connected to any data container", iout, GetName());
       return kFALSE;
    }
    if (!fOutputReady) {
index b44588a..35bfd1b 100644 (file)
@@ -31,7 +31,44 @@ class AliAnalysisTask : public TTask {
     kTaskZombie  = BIT(15),
     kTaskChecked = BIT(16)
   };   
+
+ protected:
+  Bool_t                    fReady;      // Flag if the task is ready
+  Bool_t                    fInitialized; // True if Init() was called
+  Int_t                     fNinputs;    // Number of inputs
+  Int_t                     fNoutputs;   // Number of outputs
+  Bool_t                   *fOutputReady; //[fNoutputs] Flags for output readyness
+  TObject                  *fPublishedData; // !published data
+  TObjArray                *fInputs;     // Array of input slots
+  TObjArray                *fOutputs;    // Array of output slots
+
+  // Define the input/output slots (called by user in the ctor of the derived class)
+  //=== CALL IN THE CONSTRUCTOR OF DERIVED CLASS TO DEFINE INPUTS/OUTPUTS ===
+  void                      DefineInput(Int_t islot, TClass *type);
+  void                      DefineOutput(Int_t islot, TClass *type);
+  //=====================================================================
+  
+  //=====================================================================
+  // === OVERLOAD THIS TO CONNECT TREE BRANCHES AT INPUT SLOTS. YOU
+  // SHOULD DEFINE HERE ALSO THE OBJECTS TO BE CONNECTED TO YOUR OUTPUTS
+  virtual void              ConnectInputData(Option_t *option="");
+  //=====================================================================
+  
+  // Post output data (called by Exec() when data is ready)
+  //=== CALL IN EXEC() FOR EACH OUTPUT WHEN READY ===
+  Bool_t                    PostData(Int_t iout, TObject *data, Option_t *option="");
+  //=====================================================================
   
+  // === USE THIS FIRST IN YOUR Init() TO CHECH IF A BRANCH IS ALREADY CONNECTED
+  // TO SOME ADDRESS.
+  char                     *GetBranchAddress(Int_t islot, const char *branch) const;
+  // === CALL THIS AFTERWARDS IN Init() IF THE BRANCH ADDRESS IS NOT YET SET
+  Bool_t                    SetBranchAddress(Int_t islot, const char *branch, void *address) const;
+  //=====================================================================
+  // === CALL THIS IN CreateOutputObjects IF THE OUTPUT IS TO BE WRITTEN AT OUTPUT IOUT
+//  void                      OpenFile(Int_t iout, const char *name, Option_t *option) const;
+  
+public:  
   AliAnalysisTask();
   AliAnalysisTask(const char *name, const char *title);
   AliAnalysisTask(const AliAnalysisTask &task); 
@@ -39,6 +76,9 @@ class AliAnalysisTask : public TTask {
   
   // Assignment
   AliAnalysisTask& operator=(const AliAnalysisTask &task);
+  //=====================================================================
+  // === OVERLOAD THIS AND CREATE YOUR OUTPUT OBJECTS (HISTOGRAMS,DATA) HERE
+  virtual void              CreateOutputObjects();
   // Conect inputs/outputs to data containers (by AliAnalysisModule)
   Bool_t                    ConnectInput(Int_t islot, AliAnalysisDataContainer *cont);
   Bool_t                    ConnectOutput(Int_t islot, AliAnalysisDataContainer *cont);
@@ -58,6 +98,7 @@ class AliAnalysisTask : public TTask {
   TClass                   *GetOutputType(Int_t islot) const;
   // === USE THIS TO RETREIVE INPUT DATA AND STATICALLY CAST IT TO THE DECLARED TYPE
   TObject                  *GetInputData(Int_t islot) const;
+  TObject                  *GetOutputData(Int_t islot) const;  
   Bool_t                    IsOutputReady(Int_t islot) const {return fOutputReady[islot];}
   Bool_t                    IsChecked() const  {return TObject::TestBit(kTaskChecked);}
   Bool_t                    IsInitialized() const  {return fInitialized;}
@@ -78,43 +119,7 @@ class AliAnalysisTask : public TTask {
   // === OVERLOAD THIS IF YOU WANT TO DO SOMETHING WITH THE OUTPUT
   virtual void              Terminate(Option_t *option="");
   //=====================================================================
-  
- protected:
-  // Define the input/output slots (called by user in the ctor of the derived class)
-  //=== CALL IN THE CONSTRUCTOR OF DERIVED CLASS TO DEFINE INPUTS/OUTPUTS ===
-  void                      DefineInput(Int_t islot, TClass *type);
-  void                      DefineOutput(Int_t islot, TClass *type);
-  //=====================================================================
-  
-  //=====================================================================
-  // === OVERLOAD THIS TO CONNECT TREE BRANCHES AT INPUT SLOTS. YOU
-  // SHOULD DEFINE HERE ALSO THE OBJECTS TO BE CONNECTED TO YOUR OUTPUTS
-  virtual void              Init(Option_t *option="");
-  //=====================================================================
-  
-  // Post output data (called by Exec() when data is ready)
-  //=== CALL IN EXEC() FOR EACH OUTPUT WHEN READY ===
-  Bool_t                    PostData(Int_t iout, TObject *data, Option_t *option="");
-  //=====================================================================
-  
-  // === USE THIS FIRST IN YOUR Init() TO CHECH IF A BRANCH IS ALREADY CONNECTED
-  // TO SOME ADDRESS.
-  char                     *GetBranchAddress(Int_t islot, const char *branch) const;
-  // === CALL THIS AFTERWARDS IN Init() IF THE BRANCH ADDRESS IS NOT YET SET
-  Bool_t                    SetBranchAddress(Int_t islot, const char *branch, void *address) const;
-  //=====================================================================
-  // === CALL THIS IN INIT IF THE OUTPUT IS TO BE WRITTEN AT OUTPUT IOUT
-  void                      OpenFile(Int_t iout, const char *name, Option_t *option) const;
-  
-  Bool_t                    fReady;      // Flag if the task is ready
-  Bool_t                    fInitialized; // True if Init() was called
-  Int_t                     fNinputs;    // Number of inputs
-  Int_t                     fNoutputs;   // Number of outputs
-  Bool_t                   *fOutputReady; //[fNoutputs] Flags for output readyness
-  TObject                  *fPublishedData; // !published data
-  TObjArray                *fInputs;     // Array of input slots
-  TObjArray                *fOutputs;    // Array of output slots
-  
-  ClassDef(AliAnalysisTask,2)  // Class describing an analysis task
+    
+  ClassDef(AliAnalysisTask,1)  // Class describing an analysis task
 };
 #endif
diff --git a/ANALYSIS/AnalysisExtraLinkDef.h b/ANALYSIS/AnalysisExtraLinkDef.h
deleted file mode 100644 (file)
index 9548f15..0000000
+++ /dev/null
@@ -1,9 +0,0 @@
-#ifdef __CINT__
-
-#pragma link off all globals;
-#pragma link off all classes;
-#pragma link off all functions;
-
-#pragma link C++ class  AliAnalysisRLContainer+;
-
-#endif
diff --git a/ANALYSIS/AnalysisOldLinkDef.h b/ANALYSIS/AnalysisOldLinkDef.h
new file mode 100644 (file)
index 0000000..16f15f5
--- /dev/null
@@ -0,0 +1,101 @@
+#ifdef __CINT__
+
+#pragma link off all glols;
+#pragma link off all classes;
+#pragma link off all functions;
+
+#pragma link C++ class TGliteXmlEventlist+;
+
+#pragma link C++ class AliD0toKpi+;
+#pragma link C++ class AliD0toKpiAnalysis+;
+#pragma link C++ class AliRunAnalysis+;
+#pragma link C++ class AliAnalysis+;
+
+#pragma link C++ class AliAOD+;
+#pragma link C++ class AliEventBuffer+;
+#pragma link C++ class AliVAODParticle+;
+#pragma link C++ class AliAODParticle+;
+#pragma link C++ class AliAODPair+;
+
+#pragma link C++ class AliAODRun+;
+
+#pragma link C++ class AliTrackPoints+;
+#pragma link C++ class AliClusterMap+;
+
+#pragma link C++ class AliReader+;
+#pragma link C++ class AliReaderAOD+;
+#pragma link C++ class AliReaderESD+;
+#pragma link C++ class AliReaderESDTree+;
+#pragma link C++ class AliReaderKineTree+;
+
+#pragma link C++ class AliFlowAnalysis+;
+#pragma link C++ class AliMuonAnalysis+;
+
+#pragma link C++ class AliEventCut+;
+#pragma link C++ class AliEventEmptyCut+;
+#pragma link C++ class AliEventBaseCut+;
+
+#pragma link C++ class AliPrimVertexXCut+;
+#pragma link C++ class AliPrimVertexYCut+;
+#pragma link C++ class AliPrimVertexZCut+;
+#pragma link C++ class AliNChargedCut+;
+
+#pragma link C++ class AliAODParticleCut-;
+#pragma link C++ class AliAODParticleEmptyCut-;
+#pragma link C++ class AliAODParticleBaseCut+;
+
+#pragma link C++ class AliAODMomentumCut+;
+#pragma link C++ class AliAODPtCut+;
+#pragma link C++ class AliAODEnergyCut+;
+#pragma link C++ class AliAODRapidityCut+;
+#pragma link C++ class AliAODPseudoRapidityCut+;
+#pragma link C++ class AliAODPxCut+;
+#pragma link C++ class AliAODPyCut+;
+#pragma link C++ class AliAODPzCut+;
+#pragma link C++ class AliAODPhiCut+;
+#pragma link C++ class AliAODThetaCut+;
+#pragma link C++ class AliAODVxCut+;
+#pragma link C++ class AliAODVyCut+;
+#pragma link C++ class AliAODVzCut+;
+#pragma link C++ class AliAODPIDCut+;
+#pragma link C++ class AliAODLogicalOperCut-;
+#pragma link C++ class AliAODAndCut+;
+#pragma link C++ class AliAODOrCut+;
+
+
+#pragma link C++ class AliAODPairCut-;
+#pragma link C++ class AliAODPairEmptyCut-;
+#pragma link C++ class AliAODPairBaseCut+;
+
+#pragma link C++ class AliAODQInvCut+;
+#pragma link C++ class AliAODKtCut+;
+#pragma link C++ class AliAODKStarCut+;
+#pragma link C++ class AliAODKStarOutCut+;
+#pragma link C++ class AliAODKStarSideCut+;
+#pragma link C++ class AliAODKStarLongCut+;
+#pragma link C++ class AliAODQSideLCMSCut+;
+#pragma link C++ class AliAODQOutLCMSCut+;
+#pragma link C++ class AliAODQLongLCMSCut+;
+#pragma link C++ class AliAODDeltaECut+;
+#pragma link C++ class AliAODDeltaPCut+;
+#pragma link C++ class AliAODDeltaPvectorCut+;
+#pragma link C++ class AliAODDeltaPhiCut+;
+#pragma link C++ class AliAODDeltaThetaCut+;
+#pragma link C++ class AliAODAvSeparationCut+;
+#pragma link C++ class AliAODSeparationCut+;
+#pragma link C++ class AliAODITSSeparationCut+;
+#pragma link C++ class AliAODCluterOverlapCut+;
+#pragma link C++ class AliAODOutSideSameSignCut+;
+#pragma link C++ class AliAODOutSideDiffSignCut+;
+#pragma link C++ class AliAODLogicalOperPairCut-;
+#pragma link C++ class AliAODOrPairCut+;
+#pragma link C++ class AliAODAndPairCut+;
+    
+#pragma link C++ class AliAODevent+;
+#pragma link C++ class AliAODv0+;
+#pragma link C++ class AliAODxi+;
+
+#pragma link C++ class AliAnalysisEventCuts+;
+#pragma link C++ class AliAnalysisTrackCuts+;
+
+#endif
diff --git a/ANALYSIS/AnalysisTaskLinkDef.h b/ANALYSIS/AnalysisTaskLinkDef.h
deleted file mode 100644 (file)
index a8be576..0000000
+++ /dev/null
@@ -1,14 +0,0 @@
-#ifdef __CINT__
-
-#pragma link off all globals;
-#pragma link off all classes;
-#pragma link off all functions;
-
-#pragma link C++ class  AliAnalysisDataContainer+;
-#pragma link C++ class  AliAnalysisTask+;
-#pragma link C++ class  AliAnalysisDataSlot+;
-#pragma link C++ class  AliAnalysisManager+;
-
-#pragma link C++ class  AliAnalysisGoodies+;
-
-#endif
index c5b7797..a60e53a 100644 (file)
@@ -1,7 +1,7 @@
 
 include $(ROOTSYS)/test/Makefile.arch
 
-default-target: libANALYSIS_NEW.so
+default-target: libANALYSIS.so
 
 ALICEINC      = -I.
 
@@ -14,25 +14,25 @@ else
   endif
 endif
 
-# for building of ANALYSIS_NEW.par
-ifneq ($(ANALYSIS_NEW_INCLUDE),)
-  ALICEINC += -I../$(ANALYSIS_NEW_INCLUDE)
+# for building of ANALYSIS.par
+ifneq ($(ANALYSIS_INCLUDE),)
+  ALICEINC += -I../$(ANALYSIS_INCLUDE)
 endif
 
 CXXFLAGS     += $(ALICEINC) -g
 
-PACKAGE = ANALYSIS_NEW
+PACKAGE = ANALYSIS
 include lib$(PACKAGE).pkg
 
-DHDR_ANALYSIS_NEW := $(DHDR)
-HDRS_ANALYSIS_NEW := $(HDRS)
-SRCS_ANALYSIS_NEW := $(SRCS) G__$(PACKAGE).cxx
-OBJS_ANALYSIS_NEW := $(SRCS_ANALYSIS_NEW:.cxx=.o)
+DHDR_ANALYSIS := $(DHDR)
+HDRS_ANALYSIS := $(HDRS)
+SRCS_ANALYSIS := $(SRCS) G__$(PACKAGE).cxx
+OBJS_ANALYSIS := $(SRCS_ANALYSIS:.cxx=.o)
 
 PARFILE       = $(PACKAGE).par
 
 
-lib$(PACKAGE).so: $(OBJS_ANALYSIS_NEW)
+lib$(PACKAGE).so: $(OBJS_ANALYSIS)
        @echo "Linking" $@ ...
        @/bin/rm -f $@
 ifeq ($(PLATFORM),macosx)
@@ -47,7 +47,7 @@ endif
        $(CXX) $(CXXFLAGS) $(PACKCXXFLAGS) -c $< -o $@
 
 clean:
-       @rm -f $(OBJS_ANALYSIS_NEW) *.so G__$(PACKAGE).* $(PARFILE)
+       @rm -f $(OBJS_ANALYSIS) *.so G__$(PACKAGE).* $(PARFILE)
 
 G__$(PACKAGE).cxx G__$(PACKAGE).h: $(HDRS) $(DHDR)
        @echo "Generating dictionary ..."
@@ -55,7 +55,7 @@ G__$(PACKAGE).cxx G__$(PACKAGE).h: $(HDRS) $(DHDR)
 
 ### CREATE PAR FILE
 
-$(PARFILE): $(patsubst %,$(PACKAGE)/%,$(filter-out G__%, $(HDRS_ANALYSIS_NEW) $(SRCS_ANALYSIS_NEW) $(DHDR_ANALYSIS_NEW) Makefile Makefile.arch lib$(PACKAGE).pkg PROOF-INF))
+$(PARFILE): $(patsubst %,$(PACKAGE)/%,$(filter-out G__%, $(HDRS_ANALYSIS) $(SRCS_ANALYSIS) $(DHDR_ANALYSIS) Makefile Makefile.arch lib$(PACKAGE).pkg PROOF-INF))
        @echo "Creating archive" $@ ...
        @tar cfzh $@ $(PACKAGE)
        @rm -rf $(PACKAGE)
diff --git a/ANALYSIS/PROOF-INF.ANALYSIS/SETUP.C b/ANALYSIS/PROOF-INF.ANALYSIS/SETUP.C
new file mode 100644 (file)
index 0000000..ca7c208
--- /dev/null
@@ -0,0 +1,12 @@
+void SETUP()
+{
+  // Load the ANALYSIS library
+   gSystem->Load("libANALYSIS");
+
+   // Set the Inlucde paths
+   gSystem->SetIncludePath("-I$ROOTSYS/include -IANALYSIS");
+   gROOT->ProcessLine(".include ANALYSIS");
+
+   // Set our location, so that other packages can find us
+   gSystem->Setenv("ANALYSIS_INCLUDE", "ANALYSIS");
+}
diff --git a/ANALYSIS/PROOF-INF.ANALYSIS_NEW/SETUP.C b/ANALYSIS/PROOF-INF.ANALYSIS_NEW/SETUP.C
deleted file mode 100644 (file)
index 47d6675..0000000
+++ /dev/null
@@ -1,12 +0,0 @@
-void SETUP()
-{
-  // Load the ANALYSIS_NEW library
-   gSystem->Load("libANALYSIS_NEW");
-
-   // Set the Inlucde paths
-   gSystem->SetIncludePath("-I$ROOTSYS/include -IANALYSIS_NEW");
-   gROOT->ProcessLine(".include ANALYSIS_NEW");
-
-   // Set our location, so that other packages can find us
-   gSystem->Setenv("ANALYSIS_NEW_INCLUDE", "ANALYSIS_NEW");
-}
index 76dfa8d..f3bee69 100644 (file)
@@ -1,33 +1,15 @@
-SRCS= TGliteXmlEventlist.cxx\
-      AliAOD.cxx AliEventBuffer.cxx \
-      AliRunAnalysis.cxx AliAnalysis.cxx \
-      AliVAODParticle.cxx AliAODParticle.cxx \
-      AliAODPair.cxx   AliAODRun.cxx     \
-      AliAODParticleCut.cxx AliAODParticleBaseCut.cxx \
-      AliAODPairCut.cxx AliAODPairBaseCut.cxx \
-      AliEventCut.cxx AliEventBaseCut.cxx \
-      AliReader.cxx AliReaderAOD.cxx AliReaderKineTree.cxx \
-      AliReaderESD.cxx AliReaderESDTree.cxx \
-      AliTrackPoints.cxx AliClusterMap.cxx \
-      AliD0toKpi.cxx  AliD0toKpiAnalysis.cxx AliFlowAnalysis.cxx \
-      AliMuonAnalysis.cxx  AliAODv0.cxx  AliAODxi.cxx  AliAODevent.cxx \
-      AliAnalysisEventCuts.cxx AliAnalysisTrackCuts.cxx
+SRCS = AliAnalysisDataContainer.cxx AliAnalysisDataSlot.cxx \
+       AliAnalysisManager.cxx AliAnalysisTask.cxx AliAnalysisGoodies.cxx
 
-HDRS= $(SRCS:.cxx=.h) 
 
-DHDR:=ANALYSISLinkDef.h
+HDRS:= $(SRCS:.cxx=.h) 
+
+DHDR= ANALYSISLinkDef.h
+
+CHECKALIEN = $(shell root-config --has-alien)
+ifeq (yes,$(CHECKALIEN))
+PACKCXXFLAGS := $(CXXFLAGS) -DWITHALIEN
+endif
+EXPORT:=$(SRCS:.cxx=.h)
 
-EXPORT:=AliAOD.h AliEventBuffer.h\
-      AliVAODParticle.h     AliAODParticle.h  \
-      AliAODPair.h          AliAODRun.h \
-      AliAODPairCut.h       AliAODPairBaseCut.h \
-      AliAODParticleCut.h   AliAODParticleBaseCut.h \
-      AliRunAnalysis.h      AliAnalysis.h     \
-      AliEventCut.h         AliEventBaseCut.h \
-      AliReader.h           AliReaderESD.h    \
-      AliTrackPoints.h      AliClusterMap.h   \
-      AliFlowAnalysis.h     AliReaderESDTree.h \
-      AliMuonAnalysis.h     AliAODv0.h   AliAODxi.h  AliAODevent.h \
-      AliAnalysisEventCuts.h AliAnalysisTrackCuts.h
 
-EINCLUDE:= TPC ITS
diff --git a/ANALYSIS/libANALYSIS_EXTRA.pkg b/ANALYSIS/libANALYSIS_EXTRA.pkg
deleted file mode 100644 (file)
index 9ed84ae..0000000
+++ /dev/null
@@ -1,7 +0,0 @@
-SRCS= AliAnalysisRLContainer.cxx
-
-HDRS= $(SRCS:.cxx=.h) 
-
-DHDR:=AnalysisExtraLinkDef.h
-
-EXPORT:=$(HDRS)
diff --git a/ANALYSIS/libANALYSIS_NEW.pkg b/ANALYSIS/libANALYSIS_NEW.pkg
deleted file mode 100644 (file)
index 8ef174f..0000000
+++ /dev/null
@@ -1,15 +0,0 @@
-SRCS = AliAnalysisDataContainer.cxx AliAnalysisDataSlot.cxx \
-       AliAnalysisManager.cxx AliAnalysisTask.cxx AliAnalysisGoodies.cxx
-
-
-HDRS:= $(SRCS:.cxx=.h) 
-
-DHDR= AnalysisTaskLinkDef.h
-
-CHECKALIEN = $(shell root-config --has-alien)
-ifeq (yes,$(CHECKALIEN))
-PACKCXXFLAGS := $(CXXFLAGS) -DWITHALIEN
-endif
-EXPORT:=$(SRCS:.cxx=.h)
-
-
diff --git a/ANALYSIS/libAnalysisOld.pkg b/ANALYSIS/libAnalysisOld.pkg
new file mode 100644 (file)
index 0000000..e76eef4
--- /dev/null
@@ -0,0 +1,33 @@
+SRCS= TGliteXmlEventlist.cxx\
+      AliAOD.cxx AliEventBuffer.cxx \
+      AliRunAnalysis.cxx AliAnalysis.cxx \
+      AliVAODParticle.cxx AliAODParticle.cxx \
+      AliAODPair.cxx   AliAODRun.cxx     \
+      AliAODParticleCut.cxx AliAODParticleBaseCut.cxx \
+      AliAODPairCut.cxx AliAODPairBaseCut.cxx \
+      AliEventCut.cxx AliEventBaseCut.cxx \
+      AliReader.cxx AliReaderAOD.cxx AliReaderKineTree.cxx \
+      AliReaderESD.cxx AliReaderESDTree.cxx \
+      AliTrackPoints.cxx AliClusterMap.cxx \
+      AliD0toKpi.cxx  AliD0toKpiAnalysis.cxx AliFlowAnalysis.cxx \
+      AliMuonAnalysis.cxx  AliAODv0.cxx  AliAODxi.cxx  AliAODevent.cxx \
+      AliAnalysisEventCuts.cxx AliAnalysisTrackCuts.cxx
+
+HDRS= $(SRCS:.cxx=.h) 
+
+DHDR:=AnalysisOldLinkDef.h
+
+EXPORT:=AliAOD.h AliEventBuffer.h\
+      AliVAODParticle.h     AliAODParticle.h  \
+      AliAODPair.h          AliAODRun.h \
+      AliAODPairCut.h       AliAODPairBaseCut.h \
+      AliAODParticleCut.h   AliAODParticleBaseCut.h \
+      AliRunAnalysis.h      AliAnalysis.h     \
+      AliEventCut.h         AliEventBaseCut.h \
+      AliReader.h           AliReaderESD.h    \
+      AliTrackPoints.h      AliClusterMap.h   \
+      AliFlowAnalysis.h     AliReaderESDTree.h \
+      AliMuonAnalysis.h     AliAODv0.h   AliAODxi.h  AliAODevent.h \
+      AliAnalysisEventCuts.h AliAnalysisTrackCuts.h
+
+EINCLUDE:= TPC ITS
index d1fb265..1cb8e32 100644 (file)
@@ -3,10 +3,10 @@ void runAnalysis() {
   timer.Start();
 
   gSystem->AddIncludePath("-I\"$ALICE_ROOT/include\"");
-  gSystem->Load("libANALYSIS_NEW.so");
+  gSystem->Load("libANALYSIS.so");
 
   gROOT->LoadMacro("testEvent.C+");
-  generate();
+//  generate();
   filter_reco();
 
   timer.Stop();
index ca62bd7..92aa9a5 100644 (file)
@@ -1,6 +1,6 @@
 // #####    TO RUN THIS MACRO:
 // bash$ aliroot         (due to AliInfo, AliError, ...)
-// root[0] gSystem->Load("libANALYSIS_NEW");
+// root[0] gSystem->Load("libANALYSIS");
 // IN case you do not have the include path set to AliRoot includes:
 // root[1] gSystem->AddIncludePath("-I\"$ALICE_ROOT/include\"");
 // root[2] .L testEvent.C+;
@@ -10,6 +10,7 @@
 #include "TClonesArray.h"
 #include "TChain.h"
 #include "TH1.h"
+#include "TMath.h"
 #include "TCanvas.h"
 #include "testEvent.h"   
 
 void generate()
 {
 // Simple event generation
-   AliAnalysisManager *mgr = new AliAnalysisManager();
+   AliAnalysisManager *mgr = new AliAnalysisManager("generate");
    TaskGenerate *task = new TaskGenerate("gener");
    mgr->AddTask(task);
 
    if (mgr->InitAnalysis()) {
       mgr->PrintStatus();
-      mgr->ExecAnalysis();
+      mgr->StartAnalysis();
    }   
    delete mgr;
 }   
@@ -41,11 +42,12 @@ void filter_reco()
    chain->Add("event08000.root");
    chain->Add("event10000.root");
    // Create an analysis manager
-   AliAnalysisManager *mgr = new AliAnalysisManager();
+   AliAnalysisManager *mgr = new AliAnalysisManager("testEvent");
    // Create a filter task and register it
    TaskFilter *task1 = new TaskFilter("TaskFilter");
    mgr->AddTask(task1);
    // Create a reco task and register it
+
    TaskRecoPi0 *task2 = new TaskRecoPi0("TaskRecoPi0");
    mgr->AddTask(task2);
    // Create containers for input/output
@@ -56,21 +58,22 @@ void filter_reco()
    AliAnalysisDataContainer *coutput2 = mgr->CreateContainer("output1", 
                       TList::Class(), AliAnalysisManager::kOutputContainer);
    AliAnalysisDataContainer *coutput = mgr->CreateContainer("output", 
-                      TH1::Class(), AliAnalysisManager::kOutputContainer);
+                      TH1::Class(), AliAnalysisManager::kOutputContainer, "output.root");
    // Connect containers to the task input/outputs
    mgr->ConnectInput(task1,0,cinput);
    mgr->ConnectOutput(task1,0,coutput1);
    mgr->ConnectOutput(task1,1,coutput2);
    mgr->ConnectInput(task2,0,coutput1);
    mgr->ConnectOutput(task2,0,coutput);
+
    // Connect input data
-   cinput->SetData(chain);
+//   cinput->SetData(chain);
    // Init analysis and start event loop
    if (mgr->InitAnalysis()) {
       mgr->PrintStatus();
-      chain->Process(mgr);
+      mgr->StartAnalysis("local",chain);
    }
-//   delete mgr;   
+   delete mgr;   
 }
    
 ClassImp(TaskGenerate)
@@ -102,28 +105,28 @@ TaskFilter::TaskFilter(const char *name)
 }
 
 //______________________________________________________________________________
-void TaskFilter::Init(Option_t *)
+void TaskFilter::ConnectInputData(Option_t *)
 {
 // Initialize branches.
-   printf("   Init %s\n", GetName());
-   if (!fEvent) {
+   printf("   ConnectInputData of task %s\n", GetName());
+   char ** address = (char **)GetBranchAddress(0, "event");
+   if (address) {
       // One should first check if the branch address was taken by some other task
-      char ** address = (char **)GetBranchAddress(0, "event");
-      if (address) fEvent = (AnaEvent*)(*address);
-      if (!fEvent) {
-         fEvent = new AnaEvent();
-         SetBranchAddress(0, "event", &fEvent);
-      }
-      // The output tree will be written to gammas.root
-      TDirectory *dirsav = gDirectory;
-      // Open a file for output #0
-      OpenFile(0, "gammas.root", "RECREATE");
+      fEvent = (AnaEvent*)(*address);
+   } else {
+      fEvent = new AnaEvent();
+      SetBranchAddress(0, "event", &fEvent);
+   } 
+}
+   
+//______________________________________________________________________________
+void TaskFilter::CreateOutputObjects()
+{
+   printf("   CreateOutputObjects of task %s\n", GetName());
+   if (!fList) {
       fOutput = new TTree("TGAM", "gammas");
       TBranch *branch = fOutput->Branch("event", &fEvent, 18000,1);
       branch->SetAutoDelete(kFALSE);
-      if (dirsav) dirsav->cd();
-   } 
-   if (!fList) {
       fList = new TList();
       fHist1 = new TH1I("ntracks", "Number of tracks per event", 100, 0, 1000);
       fHist1->SetLineColor(kRed);
@@ -196,10 +199,10 @@ TaskRecoPi0::~TaskRecoPi0()
 }   
 
 //______________________________________________________________________________
-void TaskRecoPi0::Init(Option_t *)
+void TaskRecoPi0::ConnectInputData(Option_t *)
 {
 // Initialize branches.
-   printf("   Init %s\n", GetName());
+   printf("   ConnectInputData for task %s\n", GetName());
    if (!fEvent) {
       // One should first check if the branch address was taken by some other task
       char ** address = (char **)GetBranchAddress(0, "event");
@@ -208,10 +211,16 @@ void TaskRecoPi0::Init(Option_t *)
          fEvent = new AnaEvent();
          SetBranchAddress(0, "event", &fEvent);
       }
-      fGammas = new TObjArray();
-      fPions  = new TObjArray();
    } 
+}
+
+//______________________________________________________________________________
+void TaskRecoPi0::CreateOutputObjects()
+{
+   printf("   CreateOutputObjects of task %s\n", GetName());
    if (!fHist) {
+      fGammas = new TObjArray();
+      fPions  = new TObjArray();
       fHist = new TH1F("Pt_pi0", "Pt distribution for pi0's", 100, 0., 10.);
       fHist->SetLineColor(kRed);
    }   
index 8486c9e..47b7cfa 100644 (file)
@@ -45,7 +45,7 @@ public:
    virtual ~TaskGenerate() {}
    
    virtual void   Exec(Option_t *option);
-   ClassDef(TaskGenerate,0)  // Simple generator
+   ClassDef(TaskGenerate,1)  // Simple generator
 };
 
 // The next task is filtering the input events coming from a chain and having
@@ -60,13 +60,15 @@ private:
    TH1I          *fHist1;        // Number of gammas per event
    TH1I          *fHist2;        // Number of gammas per event
 public:
+   TaskFilter() : AliAnalysisTask(), fEvent(0), fOutput(0), fList(0), fHist1(0), fHist2(0) {}
    TaskFilter(const char *name);
    virtual ~TaskFilter() {}
    
-   virtual void   Init(Option_t *);
+   virtual void   ConnectInputData(Option_t *);
+   virtual void   CreateOutputObjects();
    virtual void   Exec(Option_t *option);
    virtual void   Terminate(Option_t *);
-   ClassDef(TaskFilter,0)  // Event filter
+   ClassDef(TaskFilter,1)  // Event filter
 };   
 
 // This task reconstructs pi0's for gammas coming from the same vertex   
@@ -78,13 +80,15 @@ private:
    TObjArray     *fPions;        // Array of pi0's
    TH1F          *fHist;         // Pt distrib. of reconstructed pions
 public:
+   TaskRecoPi0() : AliAnalysisTask(), fEvent(0), fGammas(0), fPions(0), fHist(0) {}
    TaskRecoPi0(const char *name);
    virtual ~TaskRecoPi0();
 
-   virtual void   Init(Option_t *);
+   virtual void   ConnectInputData(Option_t *);
+   virtual void   CreateOutputObjects();
    virtual void   Exec(Option_t *option);
    virtual void   Terminate(Option_t *);
-   ClassDef(TaskRecoPi0,0)  // Pi0 reconstructor
+   ClassDef(TaskRecoPi0,1)  // Pi0 reconstructor
 };   
       
 //______________________________________________________________________________
index 33d41f2..fe3f16d 100644 (file)
@@ -46,7 +46,7 @@ AliAnalysisTaskPt::AliAnalysisTaskPt(const char *name) :
 }
 
 //________________________________________________________________________
-void AliAnalysisTaskPt::Init(Option_t *) 
+void AliAnalysisTaskPt::ConnectInputData(Option_t *) 
 {
   // Initialisation of branch container and histograms 
   
@@ -59,25 +59,20 @@ void AliAnalysisTaskPt::Init(Option_t *)
     return ;
   }
   
-  if (!fESD) {
-    // One should first check if the branch address was taken by some other task
-    char ** address = (char **)GetBranchAddress(0, "ESD") ;
-    if (address) 
-      fESD = (AliESD *)(*address) ; 
-    if (!fESD) 
-      fChain->SetBranchAddress("ESD", &fESD) ;  
+  // One should first check if the branch address was taken by some other task
+  char ** address = (char **)GetBranchAddress(0, "ESD");
+  if (address) {
+    fESD = (AliESD*)(*address);
+  } else {
+    fESD = new AliESD();
+    SetBranchAddress(0, "ESD", &fESD);
   }
-  // The output objects will be written to 
-  TDirectory * cdir = gDirectory ; 
-  // Open a file for output #0
-  char outputName[1024] ; 
-  sprintf(outputName, "%s.root", GetName() ) ; 
-  OpenFile(0, outputName , "RECREATE") ; 
-  if (cdir) 
-    cdir->cd() ; 
-  
-  // create histograms 
+}
 
+//________________________________________________________________________
+void AliAnalysisTaskPt::CreateOutputObjects()
+{
+  // create histograms 
   fhPt = new TH1F("fhPt","This is the Pt distribution",15,0.1,3.1);
   fhPt->SetStats(kTRUE);
   fhPt->GetXaxis()->SetTitle("P_{T} [GeV]");
@@ -133,7 +128,9 @@ void AliAnalysisTaskPt::Terminate(Option_t *)
   c1->cd(1)->SetLeftMargin(0.15);
   c1->cd(1)->SetBottomMargin(0.15);  
   c1->cd(1)->SetLogy();
-  fhPt->DrawCopy("E");
+  fOutputContainer = (TObjArray*)GetOutputData(0);
+  fhPt = (TH1F*)fOutputContainer->At(0);
+  if (fhPt) fhPt->DrawCopy("E");
 
   c1->Print("TracksPt.eps");
 
index b1c726c..3983313 100644 (file)
@@ -20,7 +20,8 @@ public:
   AliAnalysisTaskPt(const char *name);
   virtual ~AliAnalysisTaskPt() {}
   
-  virtual void   Init(Option_t * opt = "");
+  virtual void   ConnectInputData(Option_t *);
+  virtual void   CreateOutputObjects();
   virtual void   Exec(Option_t * opt = "");
   virtual void   Terminate(Option_t * opt = "");
   
index 1c94fe2..f3e1332 100644 (file)
@@ -75,7 +75,7 @@ AliEMCALQATask::~AliEMCALQATask()
 }
 
 //______________________________________________________________________________
-void AliEMCALQATask::Init(const Option_t*)
+void AliEMCALQATask::ConnectInputData(const Option_t*)
 {
   // Initialisation of branch container and histograms 
     
@@ -88,25 +88,20 @@ void AliEMCALQATask::Init(const Option_t*)
     return ;
   }
   
-  if (!fESD) {
-    // One should first check if the branch address was taken by some other task
-    char ** address = (char **)GetBranchAddress(0, "ESD") ;
-    if (address) 
-      fESD = (AliESD *)(*address) ; 
-    if (!fESD) 
-      fChain->SetBranchAddress("ESD", &fESD) ;  
+  // One should first check if the branch address was taken by some other task
+  char ** address = (char **)GetBranchAddress(0, "ESD");
+  if (address) {
+    fESD = (AliESD*)(*address);
+  } else {
+    fESD = new AliESD();
+    SetBranchAddress(0, "ESD", &fESD);
   }
-  // The output objects will be written to 
-  TDirectory * cdir = gDirectory ; 
-  // Open a file for output #0
-  char outputName[1024] ; 
-  sprintf(outputName, "%s.root", GetName() ) ; 
-  OpenFile(0, outputName , "RECREATE") ; 
-  if (cdir) 
-    cdir->cd() ; 
-  
-  // create histograms 
+}
   
+//______________________________________________________________________________
+void AliEMCALQATask::CreateOutputObjects()  
+{
+// create histograms  
   fhEMCALPos           = new TNtuple("EMCALPos"        , "Position in EMCAL" , "x:y:z");
   fhEMCAL              = new TNtuple("EMCAL"           , "EMCAL" , "event:digits:clusters:photons");
   fhEMCALEnergy        = new TH1D("EMCALEnergy"        , "EMCALEnergy"       , 1000, 0., 10. ) ;
@@ -208,7 +203,13 @@ void AliEMCALQATask::Exec(Option_t *)
 void AliEMCALQATask::Terminate(Option_t *)
 {
   // Processing when the event loop is ended
-  
+  fOutputContainer = (TObjArray*)GetOutputData(0);
+  fhEMCALEnergy = (TH1D*)fOutputContainer->At(2);
+  fhEMCALDigits = (TH1I*)fOutputContainer->At(3);
+  fhEMCALRecParticles = (TH1D*)fOutputContainer->At(4);
+  fhEMCALPhotons = (TH1I*)fOutputContainer->At(5);
+  fhEMCALInvariantMass = (TH1D*)fOutputContainer->At(6);
+  fhEMCALDigitsEvent = (TH1I*)fOutputContainer->At(7);
   printf("EMCALEnergy Mean        : %5.3f , RMS : %5.3f \n", fhEMCALEnergy->GetMean(),        fhEMCALEnergy->GetRMS()        ) ;
   printf("EMCALDigits Mean        : %5.3f , RMS : %5.3f \n", fhEMCALDigits->GetMean(),        fhEMCALDigits->GetRMS()        ) ;
   printf("EMCALRecParticles Mean  : %5.3f , RMS : %5.3f \n", fhEMCALRecParticles->GetMean(),  fhEMCALRecParticles->GetRMS()  ) ;
index 993bc7c..18e0b58 100644 (file)
@@ -23,7 +23,8 @@ public:
   virtual ~AliEMCALQATask() ;
    
   virtual void Exec(Option_t * opt = "") ;
-  virtual void Init(Option_t * opt = "") ; 
+  virtual void ConnectInputData(Option_t *);
+  virtual void CreateOutputObjects();
   virtual void Terminate(Option_t * opt = "") ;
 
 private:
index be02626..06e6782 100644 (file)
@@ -67,7 +67,7 @@ AliFMDQATask::~AliFMDQATask()
 }
 
 //______________________________________________________________________________
-void AliFMDQATask::Init(const Option_t*)
+void AliFMDQATask::ConnectInputData(const Option_t*)
 {
   // Initialisation of branch container and histograms 
     
@@ -80,23 +80,19 @@ void AliFMDQATask::Init(const Option_t*)
     return ;
   }
   
-  if (!fESD) {
-    // One should first check if the branch address was taken by some other task
-    char ** address = (char **)GetBranchAddress(0, "ESD") ;
-    if (address) 
-      fESD = (AliESD *)(*address) ; 
-    if (!fESD) 
-      fChain->SetBranchAddress("ESD", &fESD) ;  
+  // One should first check if the branch address was taken by some other task
+  char ** address = (char **)GetBranchAddress(0, "ESD");
+  if (address) {
+    fESD = (AliESD*)(*address);
+  } else {
+    fESD = new AliESD();
+    SetBranchAddress(0, "ESD", &fESD);
   }
-  // The output objects will be written to 
-  TDirectory * cdir = gDirectory ; 
-  // Open a file for output #0
-  char outputName[1024] ; 
-  sprintf(outputName, "%s.root", GetName() ) ; 
-  OpenFile(0, outputName , "RECREATE") ; 
-  if (cdir) 
-    cdir->cd() ; 
-  
+}
+
+//________________________________________________________________________
+void AliFMDQATask::CreateOutputObjects()
+{  
   // create histograms 
   fhFMD1i = new TH1D("FMD1i", "FMD1i", 100, -0.5, 3);
   fhFMD2i = new TH1D("FMD2i", "FMD2i", 100, -0.5, 3);
@@ -190,6 +186,13 @@ void AliFMDQATask::Terminate(Option_t *)
 {
   // Processing when the event loop is ended
  
+  fOutputContainer = (TObjArray*)GetOutputData(0);
+  fhFMD1i = (TH1D*)fOutputContainer->At(0);
+  fhFMD2i = (TH1D*)fOutputContainer->At(1);
+  fhFMD2o = (TH1D*)fOutputContainer->At(2);
+  fhFMD3i = (TH1D*)fOutputContainer->At(3);
+  fhFMD3o = (TH1D*)fOutputContainer->At(4);
+
   TCanvas * cFMD1 = new TCanvas("cFMD1", "FMD ESD Test", 400, 10, 600, 700);
   cFMD1->Divide(3, 2) ; 
 
index c9c54b7..b1c4d37 100644 (file)
@@ -22,7 +22,8 @@ public:
   virtual ~AliFMDQATask() ;
    
   virtual void Exec(Option_t * opt = "") ;
-  virtual void Init(Option_t * opt = "") ; 
+  virtual void ConnectInputData(Option_t *);
+  virtual void CreateOutputObjects();
   virtual void Terminate(Option_t * opt = "") ;
 
 private:
index 86a294a..839966c 100644 (file)
@@ -72,7 +72,7 @@ AliHMPIDQATask::~AliHMPIDQATask()
 }
 
 //______________________________________________________________________________
-void AliHMPIDQATask::Init(const Option_t*)
+void AliHMPIDQATask::ConnectInputData(const Option_t*)
 {
   // Initialisation of branch container and histograms 
     
@@ -85,23 +85,19 @@ void AliHMPIDQATask::Init(const Option_t*)
     return ;
   }
   
-  if (!fESD) {
-    // One should first check if the branch address was taken by some other task
-    char ** address = (char **)GetBranchAddress(0, "ESD") ;
-    if (address) 
-      fESD = (AliESD *)(*address) ; 
-    if (!fESD) 
-      fChain->SetBranchAddress("ESD", &fESD) ;  
+  // One should first check if the branch address was taken by some other task
+  char ** address = (char **)GetBranchAddress(0, "ESD");
+  if (address) {
+    fESD = (AliESD*)(*address);
+  } else {
+    fESD = new AliESD();
+    SetBranchAddress(0, "ESD", &fESD);
   }
-  // The output objects will be written to 
-  TDirectory * cdir = gDirectory ; 
-  // Open a file for output #0
-  char outputName[1024] ; 
-  sprintf(outputName, "%s.root", GetName() ) ; 
-  OpenFile(0, outputName , "RECREATE") ; 
-  if (cdir) 
-    cdir->cd() ; 
-  
+}
+
+//________________________________________________________________________
+void AliHMPIDQATask::CreateOutputObjects()
+{  
   // create histograms 
   fhHMPIDCkovP    = new TH2F("CkovP" , "#theta_{c}, [rad];P, [GeV]", 150,   0,  7  ,100, -3, 1); 
   fhHMPIDSigP     = new TH2F("SigP"  ,"#sigma_{#theta_c}"          , 150,   0,  7  ,100, 0, 1e20);
@@ -177,6 +173,16 @@ void AliHMPIDQATask::Exec(Option_t *)
 void AliHMPIDQATask::Terminate(Option_t *)
 {
   // Processing when the event loop is ended
+  fOutputContainer = (TObjArray*)GetOutputData(0);
+  fhHMPIDCkovP   = (TH2F*)fOutputContainer->At(0);
+  fhHMPIDSigP    = (TH2F*)fOutputContainer->At(1);
+  fhHMPIDMipXY   = (TH2F*)fOutputContainer->At(2);
+  fhHMPIDDifXY   = (TH2F*)fOutputContainer->At(3);
+  fhHMPIDProb[0] = (TH1F*)fOutputContainer->At(4);
+  fhHMPIDProb[1] = (TH1F*)fOutputContainer->At(5);
+  fhHMPIDProb[2] = (TH1F*)fOutputContainer->At(6);
+  fhHMPIDProb[3] = (TH1F*)fOutputContainer->At(7);
+  fhHMPIDProb[4] = (TH1F*)fOutputContainer->At(8);
   
   Float_t n = 1.292 ; //mean freon ref idx 
   TF1 * hHMPIDpPi = new TF1("RiPiTheo", "acos(sqrt(x*x+[0]*[0])/(x*[1]))", 1.2, 7) ; 
index 26e96dd..9b70d1a 100644 (file)
@@ -22,7 +22,8 @@ public:
   virtual ~AliHMPIDQATask() ;
    
   virtual void Exec(Option_t * opt = "") ;
-  virtual void Init(Option_t * opt = "") ; 
+  virtual void ConnectInputData(Option_t *);
+  virtual void CreateOutputObjects();
   virtual void Terminate(Option_t * opt = "") ;
 
 private:
index 4f4a20e..6273a47 100644 (file)
@@ -78,7 +78,7 @@ AliMUONQATask::~AliMUONQATask()
 }
 
 //______________________________________________________________________________
-void AliMUONQATask::Init(const Option_t*)
+void AliMUONQATask::ConnectInputData(const Option_t*)
 {
   // Initialisation of branch container and histograms 
     
@@ -91,23 +91,19 @@ void AliMUONQATask::Init(const Option_t*)
     return ;
   }
   
-  if (!fESD) {
-    // One should first check if the branch address was taken by some other task
-    char ** address = (char **)GetBranchAddress(0, "ESD") ;
-    if (address) 
-      fESD = (AliESD *)(*address) ; 
-    if (!fESD) 
-      fChain->SetBranchAddress("ESD", &fESD) ;  
+  // One should first check if the branch address was taken by some other task
+  char ** address = (char **)GetBranchAddress(0, "ESD");
+  if (address) {
+    fESD = (AliESD*)(*address);
+  } else {
+    fESD = new AliESD();
+    SetBranchAddress(0, "ESD", &fESD);
   }
-  // The output objects will be written to 
-  TDirectory * cdir = gDirectory ; 
-  // Open a file for output #0
-  char outputName[1024] ; 
-  sprintf(outputName, "%s.root", GetName() ) ; 
-  OpenFile(0, outputName , "RECREATE") ; 
-  if (cdir) 
-    cdir->cd() ; 
-  
+}
+
+//________________________________________________________________________
+void AliMUONQATask::CreateOutputObjects()
+{  
   // create histograms 
   fhMUONVertex = new TH1F("hMUONVertex","ITS Vertex"                ,100, -25., 25.);
   fhMUONMult   = new TH1F("hMUONMult"  ,"Multiplicity of ESD tracks",10,  -0.5, 9.5);
@@ -206,6 +202,9 @@ void AliMUONQATask::Terminate(Option_t *)
   // Processing when the event loop is ended
 
   AliInfo(Form("Terminate %s:", GetName())) ;
+  fOutputContainer = (TObjArray*)GetOutputData(0);
+  fhMUONVertex = (TH1F*)fOutputContainer->At(0);
+  fhMUONMult   = (TH1F*)fOutputContainer->At(1); 
   
   Int_t eff_match = -1 ; 
   if (ftracktot) 
index 0d0636c..6438641 100644 (file)
@@ -21,7 +21,8 @@ public:
   virtual ~AliMUONQATask() ;
    
   virtual void Exec(Option_t * opt = "") ;
-  virtual void Init(Option_t * opt = "") ; 
+  virtual void ConnectInputData(Option_t *);
+  virtual void CreateOutputObjects();
   virtual void Terminate(Option_t * opt = "") ;
 
 private:
index da42386..94e3382 100644 (file)
@@ -75,7 +75,7 @@ AliPHOSQATask::~AliPHOSQATask()
 
 
 //______________________________________________________________________________
-void AliPHOSQATask::Init(const Option_t*)
+void AliPHOSQATask::ConnectInputData(const Option_t*)
 {
   // Initialisation of branch container and histograms 
     
@@ -88,23 +88,19 @@ void AliPHOSQATask::Init(const Option_t*)
     return ;
   }
   
-  if (!fESD) {
-    // One should first check if the branch address was taken by some other task
-    char ** address = (char **)GetBranchAddress(0, "ESD") ;
-    if (address) 
-      fESD = (AliESD *)(*address) ; 
-    if (!fESD) 
-      fChain->SetBranchAddress("ESD", &fESD) ;  
+  // One should first check if the branch address was taken by some other task
+  char ** address = (char **)GetBranchAddress(0, "ESD");
+  if (address) {
+    fESD = (AliESD*)(*address);
+  } else {
+    fESD = new AliESD();
+    SetBranchAddress(0, "ESD", &fESD);
   }
-  // The output objects will be written to 
-  TDirectory * cdir = gDirectory ; 
-  // Open a file for output #0
-  char outputName[1024] ; 
-  sprintf(outputName, "%s.root", GetName() ) ; 
-  OpenFile(0, outputName , "RECREATE") ; 
-  if (cdir) 
-    cdir->cd() ; 
-  
+}
+
+//________________________________________________________________________
+void AliPHOSQATask::CreateOutputObjects()
+{  
   // create histograms 
   
   fhPHOSPos            = new TNtuple("PHOSPos"         , "Position in PHOS"  , "x:y:z");
@@ -205,7 +201,17 @@ void AliPHOSQATask::Exec(Option_t *)
 void AliPHOSQATask::Terminate(Option_t *)
 {
   // Processing when the event loop is ended
-  
+
+  fOutputContainer = (TObjArray*)GetOutputData(0);  
+  fhPHOSPos            = (TNtuple*)fOutputContainer->At(0);
+  fhPHOS               = (TNtuple*)fOutputContainer->At(1);
+  fhPHOSEnergy         = (TH1D*)fOutputContainer->At(2);
+  fhPHOSDigits         = (TH1I*)fOutputContainer->At(3);
+  fhPHOSRecParticles   = (TH1D*)fOutputContainer->At(4);
+  fhPHOSPhotons        = (TH1I*)fOutputContainer->At(5);
+  fhPHOSInvariantMass  = (TH1D*)fOutputContainer->At(6);
+  fhPHOSDigitsEvent    = (TH1I*)fOutputContainer->At(7);
+
   printf("PHOSEnergy Mean         : %5.3f , RMS : %5.3f \n", fhPHOSEnergy->GetMean(),         fhPHOSEnergy->GetRMS()         ) ;
   printf("PHOSDigits Mean         : %5.3f , RMS : %5.3f \n", fhPHOSDigits->GetMean(),         fhPHOSDigits->GetRMS()         ) ;
   printf("PHOSRecParticles Mean   : %5.3f , RMS : %5.3f \n", fhPHOSRecParticles->GetMean(),   fhPHOSRecParticles->GetRMS()   ) ;
index 82d136c..df9b104 100644 (file)
@@ -23,7 +23,8 @@ public:
   virtual ~AliPHOSQATask() ;
    
   virtual void Exec(Option_t * opt = "") ;
-  virtual void Init(Option_t * opt = "") ; 
+  virtual void ConnectInputData(Option_t *);
+  virtual void CreateOutputObjects();
   virtual void Terminate(Option_t * opt = "") ;
 
 private:
index d36a1d5..ecceb3f 100644 (file)
@@ -136,7 +136,7 @@ AliPMDQATask::~AliPMDQATask()
 }
 
 //______________________________________________________________________________
-void AliPMDQATask::Init(const Option_t*)
+void AliPMDQATask::ConnectInputData(const Option_t*)
 {
   // Initialisation of branch container and histograms 
     
@@ -149,23 +149,19 @@ void AliPMDQATask::Init(const Option_t*)
     return ;
   }
   
-  if (!fESD) {
-    // One should first check if the branch address was taken by some other task
-    char ** address = (char **)GetBranchAddress(0, "ESD") ;
-    if (address) 
-      fESD = (AliESD *)(*address) ; 
-    if (!fESD) 
-      fChain->SetBranchAddress("ESD", &fESD) ;  
+  // One should first check if the branch address was taken by some other task
+  char ** address = (char **)GetBranchAddress(0, "ESD");
+  if (address) {
+    fESD = (AliESD*)(*address);
+  } else {
+    fESD = new AliESD();
+    SetBranchAddress(0, "ESD", &fESD);
   }
-  // The output objects will be written to 
-  TDirectory * cdir = gDirectory ; 
-  // Open a file for output #0
-  char outputName[1024] ; 
-  sprintf(outputName, "%s.root", GetName() ) ; 
-  OpenFile(0, outputName , "RECREATE") ; 
-  if (cdir) 
-    cdir->cd() ; 
-  
+}
+
+//________________________________________________________________________
+void AliPMDQATask::CreateOutputObjects()
+{  
   // create histograms 
   
   fhPMDP1   = new TH2F("fhPMDP1","XY of Clusters",100,-100.,100.,100,-100.,100.);
@@ -436,7 +432,48 @@ void AliPMDQATask::Exec(Option_t *)
 void AliPMDQATask::Terminate(Option_t *)
 {
   // Processing when the event loop is ended
-  
+  fOutputContainer = (TObjArray*)GetOutputData(0);
+  
+  fhPMDP1   = (TH2F*)fOutputContainer->At(0);
+  fhPMDC2   = (TH1F*)fOutputContainer->At(1);
+  fhPMDP2   = (TH1F*)fOutputContainer->At(2);
+  fhPMDC3   = (TH1F*)fOutputContainer->At(3);
+  fhPMDP3   = (TH1F*)fOutputContainer->At(4);
+  fhPMDP4   = (TH1F*)fOutputContainer->At(5);
+  fhPMDC5   = (TH1F*)fOutputContainer->At(6);
+  fhPMDP5   = (TH1F*)fOutputContainer->At(7);
+  fhPMDCP0  = (TH2F*)fOutputContainer->At(8);
+  fhPMDCP1  = (TH2F*)fOutputContainer->At(9);
+  fhPMDCP2  = (TH2F*)fOutputContainer->At(10);
+  fhPMDCP3  = (TH2F*)fOutputContainer->At(11);
+  fhPMDCP4  = (TH2F*)fOutputContainer->At(12);
+
+  fhPMDSM1  = (TH2F*)fOutputContainer->At(13);
+  fhPMDSM2  = (TH2F*)fOutputContainer->At(14);
+  fhPMDSM3  = (TH2F*)fOutputContainer->At(15);
+  fhPMDSM4  = (TH2F*)fOutputContainer->At(16);
+  fhPMDSM5  = (TH2F*)fOutputContainer->At(17);
+  fhPMDSM6  = (TH2F*)fOutputContainer->At(18);
+  fhPMDSM7  = (TH2F*)fOutputContainer->At(19);
+  fhPMDSM8  = (TH2F*)fOutputContainer->At(20);
+  fhPMDSM9  = (TH2F*)fOutputContainer->At(21);
+  fhPMDSM10 = (TH2F*)fOutputContainer->At(22);
+  fhPMDSM11 = (TH2F*)fOutputContainer->At(23);
+  fhPMDSM12 = (TH2F*)fOutputContainer->At(24);
+  fhPMDSM13 = (TH2F*)fOutputContainer->At(25);
+  fhPMDSM14 = (TH2F*)fOutputContainer->At(26);
+  fhPMDSM15 = (TH2F*)fOutputContainer->At(27);
+  fhPMDSM16 = (TH2F*)fOutputContainer->At(28);
+  fhPMDSM17 = (TH2F*)fOutputContainer->At(29);
+  fhPMDSM18 = (TH2F*)fOutputContainer->At(30);
+  fhPMDSM19 = (TH2F*)fOutputContainer->At(31);
+  fhPMDSM20 = (TH2F*)fOutputContainer->At(32);
+  fhPMDSM21 = (TH2F*)fOutputContainer->At(33);
+  fhPMDSM22 = (TH2F*)fOutputContainer->At(34);
+  fhPMDSM23 = (TH2F*)fOutputContainer->At(35);
+  fhPMDSM24 = (TH2F*)fOutputContainer->At(36);
+  fhPMDSM   = (TH1F*)fOutputContainer->At(37);
+
   gStyle->SetOptStat(110000);
   gStyle->SetOptFit(1);
 
index 20bba8c..6742b1b 100644 (file)
@@ -22,7 +22,8 @@ public:
   virtual ~AliPMDQATask() ;
    
   virtual void Exec(Option_t * opt = "") ;
-  virtual void Init(Option_t * opt = "") ; 
+  virtual void ConnectInputData(Option_t *);
+  virtual void CreateOutputObjects();
   virtual void Terminate(Option_t * opt = "") ;
 
 private:
index 63f018b..a0353cf 100644 (file)
@@ -62,7 +62,7 @@ AliT0QATask::~AliT0QATask()
 }
 
 //______________________________________________________________________________
-void AliT0QATask::Init(const Option_t*)
+void AliT0QATask::ConnectInputData(const Option_t*)
 {
   // Initialisation of branch container and histograms 
     
@@ -75,25 +75,20 @@ void AliT0QATask::Init(const Option_t*)
     return ;
   }
   
-  if (!fESD) {
-    // One should first check if the branch address was taken by some other task
-    char ** address = (char **)GetBranchAddress(0, "ESD") ;
-    if (address) 
-      fESD = (AliESD *)(*address) ; 
-    if (!fESD) 
-      fChain->SetBranchAddress("ESD", &fESD) ;  
+  // One should first check if the branch address was taken by some other task
+  char ** address = (char **)GetBranchAddress(0, "ESD");
+  if (address) {
+    fESD = (AliESD*)(*address);
+  } else {
+    fESD = new AliESD();
+    SetBranchAddress(0, "ESD", &fESD);
   }
-  // The output objects will be written to 
-  TDirectory * cdir = gDirectory ; 
-  // Open a file for output #0
-  char outputName[1024] ; 
-  sprintf(outputName, "%s.root", GetName() ) ; 
-  OpenFile(0, outputName , "RECREATE") ; 
-  if (cdir) 
-    cdir->cd() ; 
-  
-  // create histograms 
+}
   
+//________________________________________________________________________
+void AliT0QATask::CreateOutputObjects()
+{
+  // create histograms   
   fhT01 = new TH1F("hRealVertex", "Primary vertex", 100,   -20,    20);
   fhT02 = new TH1F("hT0start",    "T0 start time",  100, 12400, 12600);
   fhT03 = new TH1F("hT0vertex",   "T0vertex",       100,   -20,    20);
@@ -142,7 +137,11 @@ void AliT0QATask::Exec(Option_t *)
 void AliT0QATask::Terminate(Option_t *)
 {
   // Processing when the event loop is ended
-  
+  fOutputContainer = (TObjArray*)GetOutputData(0);
+  fhT01 = (TH1F*)fOutputContainer->At(0);
+  fhT02 = (TH1F*)fOutputContainer->At(1);
+  fhT03 = (TH1F*)fOutputContainer->At(2);
+
   Float_t mean = fhT02->GetMean();
 
   printf ("mean time T0 ps %f\n", mean) ;
index c49b1d2..c6a9cda 100644 (file)
@@ -23,7 +23,8 @@ public:
   virtual ~AliT0QATask() ;
    
   virtual void Exec(Option_t * opt = "") ;
-  virtual void Init(Option_t * opt = "") ; 
+  virtual void ConnectInputData(Option_t *);
+  virtual void CreateOutputObjects();
   virtual void Terminate(Option_t * opt = "") ;
 
 private:
index baefdc6..4be9c22 100644 (file)
@@ -166,7 +166,7 @@ AliTOFQATask& AliTOFQATask::operator=(const AliTOFQATask &qatask)
   return *this;
 }
 //______________________________________________________________________________
-void AliTOFQATask::Init(const Option_t*)
+void AliTOFQATask::ConnectInputData(const Option_t*)
 {
   // Initialisation of branch container and histograms 
     
@@ -179,16 +179,23 @@ void AliTOFQATask::Init(const Option_t*)
     return ;
   }
   
-  if (!fESD) {
-    // One should first check if the branch address was taken by some other task
-    char ** address = (char **)GetBranchAddress(0, "ESD") ;
-    if (address) 
-      fESD = (AliESD *)(*address) ; 
-    if (!fESD) 
-      fChain->SetBranchAddress("ESD", &fESD) ;  
+  // One should first check if the branch address was taken by some other task
+  char ** address = (char **)GetBranchAddress(0, "ESD");
+  if (address) {
+    fESD = (AliESD*)(*address);
+  } else {
+    fESD = new AliESD();
+    SetBranchAddress(0, "ESD", &fESD);
   }
+}
+
+//________________________________________________________________________
+void AliTOFQATask::CreateOutputObjects()
+{
+// Create histograms
   BookHistos();
 }
+
 //______________________________________________________________________________
 void AliTOFQATask::Exec(Option_t *) 
 {
@@ -323,16 +330,7 @@ void AliTOFQATask::Exec(Option_t *)
 }
 //______________________________________________________________________________
 void AliTOFQATask::BookHistos()
-{
-  
-  // The output objects will be written to: 
-  TDirectory * cdir = gDirectory ; 
-  // Open a file for output #0
-  char outputName[1024] ; 
-  sprintf(outputName, "%s.root", GetName() ) ; 
-  OpenFile(0, outputName , "RECREATE") ; 
-  if (cdir) cdir->cd() ;   
-
+{  
   // Construct histograms:
   
   fhTOFMatch= 
@@ -574,8 +572,26 @@ void AliTOFQATask::Terminate(Option_t *)
   // some plots
 
   AliInfo("TOF QA Task: End of events loop");
+  fOutputContainer = (TObjArray*)GetOutputData(0);
+  fhTOFMatch       = (TH1F*)fOutputContainer->At(0);
+  fhESDeffPhi      = (TH1F*)fOutputContainer->At(1);
+  fhESDeffTheta    = (TH1F*)fOutputContainer->At(2);
+  fhESDeffMom      = (TH1F*)fOutputContainer->At(3);
+  fhTOFeffPhi      = (TH1F*)fOutputContainer->At(4);
+  fhTOFeffPhiMT    = (TH1F*)fOutputContainer->At(5);
+  fhTOFeffTheta    = (TH1F*)fOutputContainer->At(6);
+  fhTOFeffThetaMT  = (TH1F*)fOutputContainer->At(7);
+  fhTOFeffMom      = (TH1F*)fOutputContainer->At(8);
+  fhTOFeffMomMT    = (TH1F*)fOutputContainer->At(9);
+  fhTOFsector      = (TH1F*)fOutputContainer->At(10);
+  fhTOFsectorMT    = (TH1F*)fOutputContainer->At(11);
+  fhTOFTime        = (TH1F*)fOutputContainer->At(12);
+  fhTOFDeltaTime   = (TH1F*)fOutputContainer->At(13);
+  fhTOFDeltaTimeMT = (TH1F*)fOutputContainer->At(14);
+  fhTOFIDSpecies   = (TH1F*)fOutputContainer->At(15);
+  fhTOFMassVsMom   = (TH1F*)fOutputContainer->At(16);
+  fhTOFMass        = (TH1F*)fOutputContainer->At(17);
   GetEfficiency();
-  PostData(0, fOutputContainer);
+//  PostData(0, fOutputContainer);
   DrawHistos() ; 
-
 }
index 08a6cb5..fb796d0 100644 (file)
@@ -24,7 +24,8 @@ public:
   AliTOFQATask& operator=(const AliTOFQATask & qatask); // assignment operator
   virtual ~AliTOFQATask(); //dtor
   virtual void Exec(Option_t * opt = "") ;
-  virtual void Init(Option_t * opt = "") ; 
+  virtual void ConnectInputData(Option_t *);
+  virtual void CreateOutputObjects();
   virtual void Terminate(Option_t * opt = "") ;
 
 private:
index e6d96b3..196a314 100644 (file)
@@ -57,7 +57,7 @@ AliTRDQATask::AliTRDQATask(const char *name) :
 }
 
 //______________________________________________________________________________
-void AliTRDQATask::Init(const Option_t *)
+void AliTRDQATask::ConnectInputData(const Option_t *)
 {
   // Initialisation of branch container and histograms 
 
@@ -70,27 +70,20 @@ void AliTRDQATask::Init(const Option_t *)
     return ;
   }
 
-  if (!fESD) {
-    // One should first check if the branch address was taken by some other task
-    char ** address = (char **)GetBranchAddress(0, "ESD");
-    if (address) {
-      fESD = (AliESD *)(*address); 
-      AliInfo("Old ESD found.");
-    }
-    if (!fESD) {
-      fESD = new AliESD();
-      SetBranchAddress(0, "ESD", &fESD);  
-      if (fESD) AliInfo("ESD connected.");
-    }
+  // One should first check if the branch address was taken by some other task
+  char ** address = (char **)GetBranchAddress(0, "ESD");
+  if (address) {
+    fESD = (AliESD*)(*address);
+  } else {
+    fESD = new AliESD();
+    SetBranchAddress(0, "ESD", &fESD);
   }
-  // The output objects will be written to 
-  TDirectory * cdir = gDirectory ; 
-  OpenFile(0, Form("%s.root", GetName()), "RECREATE"); 
-  if (cdir) 
-    cdir->cd() ; 
+}
 
+//________________________________________________________________________
+void AliTRDQATask::CreateOutputObjects()
+{
   // create histograms 
-
   fNTracks     = new TH1D("ntracks", ";number of all tracks", 500, -0.5, 499.5); 
   fEventSize   = new TH1D("evSize", ";event size (MB)", 100, 0, 5);
 
@@ -175,12 +168,48 @@ void AliTRDQATask::Init(const Option_t *)
   fOutputContainer = new TObjArray(150); 
   
   // register histograms to the container  
-  TIter next(gDirectory->GetList());
-  TObject *obj;
   int counter = 0;
   
-  while (obj = next.Next()) {
-    if (obj->InheritsFrom("TH1"))  fOutputContainer->AddAt(obj, counter++);
+  fOutputContainer->AddAt(fNTracks,     counter++);
+  fOutputContainer->AddAt(fEventSize,   counter++);
+  fOutputContainer->AddAt(fTrackStatus, counter++);
+  fOutputContainer->AddAt(fKinkIndex,   counter++);
+  fOutputContainer->AddAt(fParIn,       counter++);
+  fOutputContainer->AddAt(fParOut,      counter++);
+  fOutputContainer->AddAt(fXIn,         counter++);
+  fOutputContainer->AddAt(fXOut,        counter++);
+  fOutputContainer->AddAt(fAlpha[0],    counter++);
+  fOutputContainer->AddAt(fAlpha[1],    counter++);
+  fOutputContainer->AddAt(fAlpha[2],    counter++);
+  fOutputContainer->AddAt(fAlpha[3],    counter++);
+
+  fOutputContainer->AddAt(fSectorTRD,   counter++);
+  for(int i=0; i<nbits; i++) {
+     fOutputContainer->AddAt(fPt[i],      counter++);
+     fOutputContainer->AddAt(fTheta[i],   counter++);
+     fOutputContainer->AddAt(fSigmaY[i],  counter++);
+     fOutputContainer->AddAt(fChi2[i],    counter++);
+     fOutputContainer->AddAt(fPlaneYZ[i], counter++);
+  }   
+  fOutputContainer->AddAt(fEffPt[0], counter++);
+  fOutputContainer->AddAt(fEffPt[1], counter++);
+  fOutputContainer->AddAt(fEffPt[2], counter++);
+  fOutputContainer->AddAt(fEffPt[3], counter++);
+
+  fOutputContainer->AddAt(fClustersTRD[0], counter++);
+  fOutputContainer->AddAt(fClustersTRD[1], counter++);
+  fOutputContainer->AddAt(fClustersTRD[2], counter++);
+  fOutputContainer->AddAt(fTime,      counter++);
+  fOutputContainer->AddAt(fBudget,    counter++);
+  fOutputContainer->AddAt(fQuality,   counter++);
+  fOutputContainer->AddAt(fSignal,    counter++);
+  fOutputContainer->AddAt(fTrdSigMom, counter++);
+  fOutputContainer->AddAt(fTpcSigMom, counter++);
+  for(int i=0; i<6; i++) {
+     fOutputContainer->AddAt(fTpcPID[i],       counter++);
+     fOutputContainer->AddAt(fTpcSigMomPID[i], counter++);
+     fOutputContainer->AddAt(fTrdPID[i],       counter++);
+     fOutputContainer->AddAt(fTrdSigMomPID[i], counter++);
   }
 
   AliInfo(Form("Number of histograms = %d", counter));
@@ -324,11 +353,55 @@ void AliTRDQATask::Terminate(Option_t *)
 {
   // Processing when the event loop is ended
   AliInfo("TRD QA module");
+  fOutputContainer = (TObjArray*)GetOutputData(0);
+  int counter = 0;
+  fNTracks     = (TH1D*)fOutputContainer->At(counter++);
+  fEventSize   = (TH1D*)fOutputContainer->At(counter++);
+  fTrackStatus = (TH1D*)fOutputContainer->At(counter++);
+  fKinkIndex   = (TH1D*)fOutputContainer->At(counter++);
+  fParIn       = (TH1D*)fOutputContainer->At(counter++);
+  fParOut      = (TH1D*)fOutputContainer->At(counter++);
+  fXIn         = (TH1D*)fOutputContainer->At(counter++);
+  fXOut        = (TH1D*)fOutputContainer->At(counter++);
+  fAlpha[0]    = (TH1D*)fOutputContainer->At(counter++);
+  fAlpha[1]    = (TH1D*)fOutputContainer->At(counter++);
+  fAlpha[2]    = (TH1D*)fOutputContainer->At(counter++);
+  fAlpha[3]    = (TH1D*)fOutputContainer->At(counter++);
+
+  fSectorTRD   = (TH1D*)fOutputContainer->At(counter++);
+  const int nbits = 6;
+  for(int i=0; i<nbits; i++) {
+     fPt[i]      = (TH1D*)fOutputContainer->At(counter++);
+     fTheta[i]   = (TH1D*)fOutputContainer->At(counter++);
+     fSigmaY[i]  = (TH1D*)fOutputContainer->At(counter++);
+     fChi2[i]    = (TH1D*)fOutputContainer->At(counter++);
+     fPlaneYZ[i] = (TH2D*)fOutputContainer->At(counter++);
+  }   
+  fEffPt[0] = (TH1D*)fOutputContainer->At(counter++);
+  fEffPt[1] = (TH1D*)fOutputContainer->At(counter++);
+  fEffPt[2] = (TH1D*)fOutputContainer->At(counter++);
+  fEffPt[3] = (TH1D*)fOutputContainer->At(counter++);
+
+  fClustersTRD[0] = (TH1D*)fOutputContainer->At(counter++);
+  fClustersTRD[1] = (TH1D*)fOutputContainer->At(counter++);
+  fClustersTRD[2] = (TH1D*)fOutputContainer->At(counter++);
+  fTime      = (TH1D*)fOutputContainer->At(counter++);
+  fBudget    = (TH1D*)fOutputContainer->At(counter++);
+  fQuality   = (TH1D*)fOutputContainer->At(counter++);
+  fSignal    = (TH1D*)fOutputContainer->At(counter++);
+  fTrdSigMom = (TH2D*)fOutputContainer->At(counter++);
+  fTpcSigMom = (TH2D*)fOutputContainer->At(counter++);
+  for(int i=0; i<6; i++) {
+     fTpcPID[i]       = (TH1D*)fOutputContainer->At(counter++);
+     fTpcSigMomPID[i] = (TH2D*)fOutputContainer->At(counter++);
+     fTrdPID[i]       = (TH1D*)fOutputContainer->At(counter++);
+     fTrdSigMomPID[i] = (TH2D*)fOutputContainer->At(counter++);
+  }
 
   // create efficiency histograms
   
   CalculateEff();
-  PostData(0, fOutputContainer);
+//  PostData(0, fOutputContainer);
 
   DrawESD() ; 
   DrawGeoESD() ; 
index 42181b6..6d67c7c 100644 (file)
@@ -21,7 +21,8 @@ public:
   virtual ~AliTRDQATask() {}
    
   virtual void Exec(Option_t * opt = "");
-  virtual void Init(Option_t * opt = ""); 
+  virtual void ConnectInputData(Option_t *);
+  virtual void CreateOutputObjects();
   virtual void Terminate(Option_t * opt = "");
 
 private:
index cbfd372..7f388cd 100644 (file)
@@ -55,7 +55,7 @@ void ana()
 {  
   if (! gIsAnalysisLoaded ) {
     LoadLib("ESD") ; 
-    LoadLib("ANALYSIS_NEW") ; 
+    LoadLib("ANALYSIS") ; 
     printf("Include path = %s\n", gSystem->GetIncludePath()) ; 
     LoadLib("AnalysisCheck") ; 
   }
index bac6a18..b5b6a29 100644 (file)
@@ -5,7 +5,7 @@ void JetAnalysisManager()
     //
     gSystem->Load("libEG.so");
     gSystem->Load("libGeom.so");
-    gSystem->Load("libANALYSIS_NEW.so");
+    gSystem->Load("libANALYSIS.so");
     gSystem->Load("libESD.so"); 
     gSystem->Load("libJETAN.so");
     //
@@ -40,7 +40,7 @@ void JetAnalysisManager()
     
     mgr->ConnectInput (jetana,0,cinput1);
     mgr->ConnectOutput(jetana,0,coutput1);
-    cinput1->SetData(chain1);
+//    cinput1->SetData(chain1);
 
 //
 // Run the analysis
@@ -48,6 +48,7 @@ void JetAnalysisManager()
 
     if (mgr->InitAnalysis()) {
        mgr->PrintStatus();
-       chain1->Process(mgr);
+//     chain1->Process(mgr);
+   mgr->StartAnalysis("local",chain1);
     }
 }
index 09573aa..abd1cbd 100644 (file)
@@ -27,7 +27,7 @@ InputDataCollection="LF:/alice/cern.ch/user/p/pchrist/Tutorial/BATCH/pp10.xml,no
 InputFile= {"LF:/alice/cern.ch/user/p/pchrist/Tutorial/BATCH/AliAnalysisTaskPt.cxx",
             "LF:/alice/cern.ch/user/p/pchrist/Tutorial/BATCH/AliAnalysisTaskPt.h",
            "LF:/alice/cern.ch/user/p/pchrist/Tutorial/BATCH/ESD.par", 
-           "LF:/alice/cern.ch/user/p/pchrist/Tutorial/BATCH/ANALYSIS_NEW.par", 
+           "LF:/alice/cern.ch/user/p/pchrist/Tutorial/BATCH/ANALYSIS.par", 
             "LF:/alice/cern.ch/user/p/pchrist/Tutorial/BATCH/demoBatch.C",
             "LF:/alice/cern.ch/user/p/pchrist/Tutorial/BATCH/runAnalysis.C"};
            
index 57991bc..11db5f3 100644 (file)
@@ -81,7 +81,7 @@ void runAnalysis() {
     
     gSystem->ChangeDirectory("../");
   }
-  gSystem->Load("libANALYSIS_NEW.so");
+  gSystem->Load("libANALYSIS.so");
 
   printf("*** Connect to AliEn ***\n");
   TGrid::Connect("alien://"); 
index 4134179..a0ed1ef 100644 (file)
@@ -44,9 +44,9 @@ void runAnalysis() {
   gSystem->Load("libESD.so");
 
   //_____________________________________________________________//
-  //_____________Setting up ANALYSIS_NEW.par_____________________//
+  //_____________Setting up ANALYSIS.par_____________________//
   //_____________________________________________________________//
-  const char* pararchivename2 = "ANALYSIS_NEW";
+  const char* pararchivename2 = "ANALYSIS";
   //////////////////////////////////////////
   // Libraries required to load
   //////////////////////////////////////////
@@ -81,7 +81,7 @@ void runAnalysis() {
     
     gSystem->ChangeDirectory("../");
   }
-  gSystem->Load("libANALYSIS_NEW.so");
+  gSystem->Load("libANALYSIS.so");
 
   printf("*** Connect to AliEn ***\n");
   TGrid::Connect("alien://"); 
index 8399b4d..cf65659 100644 (file)
@@ -44,9 +44,9 @@ void runAnalysis() {
   gSystem->Load("libESD.so");
 
   //_____________________________________________________________//
-  //_____________Setting up ANALYSIS_NEW.par_____________________//
+  //_____________Setting up ANALYSIS.par_____________________//
   //_____________________________________________________________//
-  const char* pararchivename2 = "ANALYSIS_NEW";
+  const char* pararchivename2 = "ANALYSIS";
   //////////////////////////////////////////
   // Libraries required to load
   //////////////////////////////////////////
@@ -81,7 +81,7 @@ void runAnalysis() {
     
     gSystem->ChangeDirectory("../");
   }
-  gSystem->Load("libANALYSIS_NEW.so");
+  gSystem->Load("libANALYSIS.so");
 
   gROOT->LoadMacro("AliAnalysisTaskPt.cxx+");  
   gROOT->LoadMacro("demoLocal.C");
index d8bf1cf..9749365 100644 (file)
@@ -14,7 +14,7 @@ o) Interactive
 o) Batch
    You can find the executable (that you should store under your $HOME/bin  AliEn directory), the jdl, the xml collection, as well as the macro runAnalysis.C. You should also use the AliAnalysisTaskPt.* from the Local directory. The macros will be updated slightly (I'll include the usage of the tags) once the new root version will be deployed in AliEn. Everybody who wants to use these files should change them accordingly!!!
 
-In order to run the examples you should use the ESD.par as well as the ANALYSIS_NEW.par. You can creat both par files by typing "make ESD.par" and "make ANALYSIS_NEW.par" respectively under $ALICE_ROOT.
+In order to run the examples you should use the ESD.par as well as the ANALYSIS_NEW.par. You can creat both par files by typing "make ESD.par" and "make ANALYSIS.par" respectively under $ALICE_ROOT.
 
 ===========================================================
 For any questions send mails to: Panos.Christakoglou@cern.ch
index beec54a..2a3ded0 100644 (file)
@@ -1,5 +1,5 @@
 ALIROOT/module.mk:      ALIROOT/binaliroot.pkg 
-ANALYSIS/module.mk:     ANALYSIS/libANALYSIS.pkg ANALYSIS/libANALYSIS_NEW.pkg ANALYSIS/libANALYSIS_EXTRA.pkg ANALYSIS/libAliengui.pkg ANALYSIS/binaliengui.pkg
+ANALYSIS/module.mk:     ANALYSIS/libANALYSIS.pkg ANALYSIS/libAnalysisOld.pkg ANALYSIS/libAliengui.pkg ANALYSIS/binaliengui.pkg
 ACORDE/module.mk:        ACORDE/libACORDE.pkg
 EMCAL/module.mk:        EMCAL/libEMCALbase.pkg EMCAL/libEMCALsim.pkg EMCAL/libEMCALrec.pkg
 EPEMGEN/module.mk:       EPEMGEN/libEPEMGEN.pkg