X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=ANALYSIS%2FAliAnalysisManager.cxx;h=7fbad0c67d13330f26535982386d57e153ef3832;hb=6d2e58f050d9d3c79a03b5af3389307398679ea5;hp=f8c07fc1f476ec3298c1ed77a95fa09b95e31105;hpb=ff0d33e8fd8183803beaef12e214bc2b88b35041;p=u%2Fmrichter%2FAliRoot.git diff --git a/ANALYSIS/AliAnalysisManager.cxx b/ANALYSIS/AliAnalysisManager.cxx index f8c07fc1f47..7fbad0c67d1 100644 --- a/ANALYSIS/AliAnalysisManager.cxx +++ b/ANALYSIS/AliAnalysisManager.cxx @@ -17,7 +17,7 @@ // Author: Andrei Gheata, 31/05/2006 //============================================================================== -// AliAnalysysManager - Manager analysis class. Allows creation of several +// AliAnalysisManager - Manager analysis class. Allows creation of several // analysis tasks and data containers storing their input/output. Allows // connecting/chaining tasks via shared data containers. Serializes the current // event for all tasks depending only on initial input data. @@ -25,12 +25,14 @@ // //============================================================================== -#include +#include "AliAnalysisManager.h" +#include +#include #include +#include #include #include -//#include #include #include #include @@ -40,6 +42,7 @@ #include #include +#include "AliLog.h" #include "AliAnalysisSelector.h" #include "AliAnalysisGrid.h" #include "AliAnalysisTask.h" @@ -48,12 +51,13 @@ #include "AliVEventHandler.h" #include "AliVEventPool.h" #include "AliSysInfo.h" -#include "AliAnalysisManager.h" +#include "AliAnalysisStatistics.h" ClassImp(AliAnalysisManager) AliAnalysisManager *AliAnalysisManager::fgAnalysisManager = NULL; TString AliAnalysisManager::fgCommonFileName = ""; +Int_t AliAnalysisManager::fPBUpdateFreq = 1; //______________________________________________________________________________ AliAnalysisManager::AliAnalysisManager(const char *name, const char *title) @@ -83,20 +87,29 @@ AliAnalysisManager::AliAnalysisManager(const char *name, const char *title) fGridHandler(NULL), fExtraFiles(""), fAutoBranchHandling(kTRUE), - fTable() + fTable(), + fRunFromPath(0), + fNcalls(0), + fMaxEntries(0), + fStatisticsMsg(), + fRequestedBranches(), + fStatistics(0), + fGlobals(0) { // Default constructor. fgAnalysisManager = this; fgCommonFileName = "AnalysisResults.root"; - fTasks = new TObjArray(); - fTopTasks = new TObjArray(); - fZombies = new TObjArray(); - fContainers = new TObjArray(); - fInputs = new TObjArray(); - fOutputs = new TObjArray(); - fParamCont = new TObjArray(); + if (TClass::IsCallingNew() != TClass::kDummyNew) { + fTasks = new TObjArray(); + fTopTasks = new TObjArray(); + fZombies = new TObjArray(); + fContainers = new TObjArray(); + fInputs = new TObjArray(); + fOutputs = new TObjArray(); + fParamCont = new TObjArray(); + fGlobals = new TMap(); + } SetEventLoop(kTRUE); - TObject::SetObjectStat(kFALSE); } //______________________________________________________________________________ @@ -127,7 +140,14 @@ AliAnalysisManager::AliAnalysisManager(const AliAnalysisManager& other) fGridHandler(NULL), fExtraFiles(), fAutoBranchHandling(other.fAutoBranchHandling), - fTable() + fTable(), + fRunFromPath(0), + fNcalls(other.fNcalls), + fMaxEntries(other.fMaxEntries), + fStatisticsMsg(other.fStatisticsMsg), + fRequestedBranches(other.fRequestedBranches), + fStatistics(other.fStatistics), + fGlobals(other.fGlobals) { // Copy constructor. fTasks = new TObjArray(*other.fTasks); @@ -139,7 +159,6 @@ AliAnalysisManager::AliAnalysisManager(const AliAnalysisManager& other) fParamCont = new TObjArray(*other.fParamCont); fgCommonFileName = "AnalysisResults.root"; fgAnalysisManager = this; - TObject::SetObjectStat(kFALSE); } //______________________________________________________________________________ @@ -174,7 +193,14 @@ AliAnalysisManager& AliAnalysisManager::operator=(const AliAnalysisManager& othe fgCommonFileName = "AnalysisResults.root"; fgAnalysisManager = this; fAutoBranchHandling = other.fAutoBranchHandling; - fTable.Clear("nodelete"); + fTable.Clear("nodelete"); + fRunFromPath = other.fRunFromPath; + fNcalls = other. fNcalls; + fMaxEntries = other.fMaxEntries; + fStatisticsMsg = other.fStatisticsMsg; + fRequestedBranches = other.fRequestedBranches; + fStatistics = other.fStatistics; + fGlobals = new TMap(); } return *this; } @@ -196,7 +222,7 @@ AliAnalysisManager::~AliAnalysisManager() if (fMCtruthEventHandler) delete fMCtruthEventHandler; if (fEventPool) delete fEventPool; if (fgAnalysisManager==this) fgAnalysisManager = NULL; - TObject::SetObjectStat(kTRUE); + if (fGlobals) {fGlobals->DeleteAll(); delete fGlobals;} } //______________________________________________________________________________ @@ -205,10 +231,43 @@ Int_t AliAnalysisManager::GetEntry(Long64_t entry, Int_t getall) // Read one entry of the tree or a whole branch. fCurrentEntry = entry; if (!fAutoBranchHandling) - return entry; - return fTree ? fTree->GetTree()->GetEntry(entry, getall) : 0; + return 123456789; + return fTree ? fTree->GetTree()->GetEntry(entry, getall) : -1; } - + +//______________________________________________________________________________ +Int_t AliAnalysisManager::GetRunFromAlienPath(const char *path) +{ +// Attempt to extract run number from input data path. Works only for paths to +// alice data in alien. +// sim: /alice/sim//run_no/... +// data: /alice/data/year/period/000run_no/... (ESD or AOD) + TString type = "unknown"; + TString s(path); + if (s.Contains("/alice/data")) type = "real"; + else if (s.Contains("/alice/sim")) type = "simulated"; + TString srun; + Int_t ind1, ind2; + ind1 = s.Index("/00"); + if (ind1>0) { + ind2 = s.Index("/",ind1+1); + if (ind2-ind1>8) srun = s(ind1+1, ind2-ind1-1); + } + if (srun.IsNull()) { + ind1 = s.Index("/LHC"); + if (ind1>0) { + ind1 = s.Index("/",ind1+1); + if (ind1>0) { + ind2 = s.Index("/",ind1+1); + if (ind2>0) srun = s(ind1+1, ind2-ind1-1); + } + } + } + Int_t run = srun.Atoi(); + if (run>0) printf("=== GetRunFromAlienPath: run %d of %s data ===\n", run, type.Data()); + return run; +} + //______________________________________________________________________________ Bool_t AliAnalysisManager::Init(TTree *tree) { @@ -280,6 +339,7 @@ Bool_t AliAnalysisManager::Init(TTree *tree) return kFALSE; } top->SetData(tree); + CheckBranches(kFALSE); if (fDebug > 1) { printf("<-AliAnalysisManager::Init(%s)\n", tree->GetName()); } @@ -293,6 +353,7 @@ void AliAnalysisManager::SlaveBegin(TTree *tree) // When running with PROOF SlaveBegin() is called on each slave server. // The tree argument is deprecated (on PROOF 0 is passed). if (fDebug > 1) printf("->AliAnalysisManager::SlaveBegin()\n"); + if (!CheckTasks()) Fatal("SlaveBegin", "Not all needed libraries were loaded"); static Bool_t isCalled = kFALSE; Bool_t init = kFALSE; Bool_t initOK = kTRUE; @@ -357,6 +418,11 @@ void AliAnalysisManager::SlaveBegin(TTree *tree) // Start with memory as current dir and make sure by default histograms do not get attached to files. TH1::AddDirectory(kFALSE); task->CreateOutputObjects(); + if (!task->CheckPostData()) { + Error("SlaveBegin","####### IMPORTANT! ####### \n\n\n\ + Task %s (%s) did not call PostData() for all its outputs in (User)CreateOutputObjects()\n\n\ + ####### FIX YOUR CODE, THIS WILL PRODUCE A FATAL ERROR IN FUTURE! ##########", task->GetName(), task->ClassName()); + } if (getsysInfo) AliSysInfo::AddStamp(Form("%s_CREATEOUTOBJ",task->ClassName()), 0, itask, 0); itask++; } @@ -374,6 +440,7 @@ Bool_t AliAnalysisManager::Notify() // to the generated code, but the routine can be extended by the // user if needed. The return value is currently not used. if (!fTree) return kFALSE; + if (!TObject::TestBit(AliAnalysisManager::kTrueNotify)) return kFALSE; fTable.Clear("nodelete"); // clearing the hash table may not be needed -> C.L. if (fMode == kProofAnalysis) fIsRemote = kTRUE; @@ -385,11 +452,13 @@ Bool_t AliAnalysisManager::Notify() } if (fDebug > 1) printf("->AliAnalysisManager::Notify() file: %s\n", curfile->GetName()); + Int_t run = AliAnalysisManager::GetRunFromAlienPath(curfile->GetName()); + if (run && (run != fRunFromPath)) { + fRunFromPath = run; + if (fDebug > 1) printf(" ### run found from path: %d\n", run); + } TIter next(fTasks); AliAnalysisTask *task; - // Call Notify for all tasks - while ((task=(AliAnalysisTask*)next())) - task->Notify(); // Call Notify of the event handlers if (fInputEventHandler) { @@ -404,12 +473,16 @@ Bool_t AliAnalysisManager::Notify() fMCtruthEventHandler->Notify(curfile->GetName()); } + // Call Notify for all tasks + while ((task=(AliAnalysisTask*)next())) + task->Notify(); + if (fDebug > 1) printf("<-AliAnalysisManager::Notify()\n"); return kTRUE; } //______________________________________________________________________________ -Bool_t AliAnalysisManager::Process(Long64_t entry) +Bool_t AliAnalysisManager::Process(Long64_t) { // The Process() function is called for each entry in the tree (or possibly // keyed object in the case of PROOF) to be processed. The entry argument @@ -428,15 +501,8 @@ Bool_t AliAnalysisManager::Process(Long64_t entry) // The entry is always the local entry number in the current tree. // Assuming that fChain is the pointer to the TChain being processed, // use fChain->GetTree()->GetEntry(entry). - if (fDebug > 1) printf("->AliAnalysisManager::Process(%lld)\n", entry); - if (fInputEventHandler) fInputEventHandler ->BeginEvent(entry); - if (fOutputEventHandler) fOutputEventHandler ->BeginEvent(entry); - if (fMCtruthEventHandler) fMCtruthEventHandler->BeginEvent(entry); - - GetEntry(entry); - ExecAnalysis(); - if (fDebug > 1) printf("<-AliAnalysisManager::Process()\n"); + // This method is obsolete. ExecAnalysis is called instead. return kTRUE; } @@ -468,16 +534,20 @@ void AliAnalysisManager::PackOutput(TList *target) gROOT->cd(); if (fDebug > 1) printf("<-FinishTaskOutput: task %s\n", task->GetName()); } - } + } + // Write statistics message on the workers. + if (fStatistics) WriteStatisticsMsg(fNcalls); if (fMode == kProofAnalysis) { TIter next(fOutputs); AliAnalysisDataContainer *output; Bool_t isManagedByHandler = kFALSE; + TList filestmp; + filestmp.SetOwner(); while ((output=(AliAnalysisDataContainer*)next())) { // Do not consider outputs of post event loop tasks isManagedByHandler = kFALSE; - if (output->GetProducer()->IsPostEventLoop()) continue; + if (output->GetProducer() && output->GetProducer()->IsPostEventLoop()) continue; const char *filename = output->GetFileName(); if (!(strcmp(filename, "default")) && fOutputEventHandler) { isManagedByHandler = kTRUE; @@ -497,33 +567,42 @@ void AliAnalysisManager::PackOutput(TList *target) // File resident outputs. // Check first if the file exists. TString openoption = "RECREATE"; - if (!gSystem->AccessPathName(output->GetFileName())) openoption = "UPDATE"; - TFile *file = AliAnalysisManager::OpenFile(output, openoption, kTRUE); + Bool_t firsttime = kTRUE; + if (filestmp.FindObject(output->GetFileName())) { + firsttime = kFALSE; + } else { + filestmp.Add(new TNamed(output->GetFileName(),"")); + } + if (!gSystem->AccessPathName(output->GetFileName()) && !firsttime) openoption = "UPDATE"; +// TFile *file = AliAnalysisManager::OpenFile(output, openoption, kTRUE); // Save data to file, then close. if (output->GetData()->InheritsFrom(TCollection::Class())) { // If data is a collection, we set the name of the collection // as the one of the container and we save as a single key. TCollection *coll = (TCollection*)output->GetData(); coll->SetName(output->GetName()); - coll->Write(output->GetName(), TObject::kSingleKey); +// coll->Write(output->GetName(), TObject::kSingleKey); } else { if (output->GetData()->InheritsFrom(TTree::Class())) { + TFile *file = AliAnalysisManager::OpenFile(output, openoption, kTRUE); + // Save data to file, then close. TTree *tree = (TTree*)output->GetData(); // Check if tree is in memory if (tree->GetDirectory()==gROOT) tree->SetDirectory(gDirectory); tree->AutoSave(); + file->Close(); } else { - output->GetData()->Write(); +// output->GetData()->Write(); } } if (fDebug > 1) printf("PackOutput %s: memory merge, file resident output\n", output->GetName()); - if (fDebug > 2) { - printf(" file %s listing content:\n", filename); - file->ls(); - } +// if (fDebug > 2) { +// printf(" file %s listing content:\n", filename); +// file->ls(); +// } // Clear file list to release object ownership to user. // file->Clear(); - file->Close(); +// file->Close(); output->SetFile(NULL); // Restore current directory if (opwd) opwd->cd(); @@ -596,8 +675,8 @@ void AliAnalysisManager::PackOutput(TList *target) TString remote = fSpecialOutputLocation; remote += "/"; Int_t gid = gROOT->ProcessLine("gProofServ->GetGroupId();"); - if (remote.BeginsWith("alien://")) { - gROOT->ProcessLine("TGrid::Connect(\"alien://pcapiserv01.cern.ch:10000\", gProofServ->GetUser());"); + if (remote.BeginsWith("alien:")) { + gROOT->ProcessLine("TGrid::Connect(\"alien:\", gProofServ->GetUser());"); remote += outFilename; remote.ReplaceAll(".root", Form("_%d.root", gid)); } else { @@ -688,6 +767,7 @@ void AliAnalysisManager::ImportWrappers(TList *source) Error("ImportWrappers", "Cannot open file %s in read-only mode", filename); continue; } + f->cd(); TObject *obj = 0; // Cd to the directory pointed by the container TString folder = cont->GetFolderName(); @@ -695,8 +775,8 @@ void AliAnalysisManager::ImportWrappers(TList *source) // Try to fetch first an object having the container name. obj = gDirectory->Get(cont->GetName()); if (!obj) { - Warning("ImportWrappers", "Could not import object for container %s in file %s:%s.\n Object will not be available in Terminate()", - cont->GetName(), filename, cont->GetFolderName()); + Warning("ImportWrappers", "Could not import object of type:%s for container %s in file %s:%s.\n Object will not be available in Terminate(). Try if possible to name the output object as the container (%s) or to embed it in a TList", + cont->GetType()->GetName(), cont->GetName(), filename, cont->GetFolderName(), cont->GetName()); continue; } wrap = new AliAnalysisDataWrapper(obj); @@ -812,10 +892,13 @@ void AliAnalysisManager::Terminate() for (icont=0; icontGetEntriesFast(); icont++) allOutputs->Add(fParamCont->At(icont)); TIter next1(allOutputs); TString handlerFile = ""; + TString extraOutputs = ""; if (fOutputEventHandler) { handlerFile = fOutputEventHandler->GetOutputFileName(); + extraOutputs = fOutputEventHandler->GetExtraOutputs(); } icont = 0; + TList filestmp; while ((output=(AliAnalysisDataContainer*)next1())) { // Special outputs or grid files have the files already closed and written. icont++; @@ -833,7 +916,13 @@ void AliAnalysisManager::Terminate() if (!file) file = (TFile*)gROOT->GetListOfFiles()->FindObject(filename); if (!file) { //if (handlerFile == filename && !gSystem->AccessPathName(filename)) openoption = "UPDATE"; - if (!gSystem->AccessPathName(filename)) openoption = "UPDATE"; + Bool_t firsttime = kTRUE; + if (filestmp.FindObject(filename) || extraOutputs.Contains(filename)) { + firsttime = kFALSE; + } else { + filestmp.Add(new TNamed(filename,"")); + } + if (!gSystem->AccessPathName(filename) && !firsttime) openoption = "UPDATE"; if (fDebug>1) printf("Opening file: %s option=%s\n",filename, openoption.Data()); file = new TFile(filename, openoption); } else { @@ -876,6 +965,7 @@ void AliAnalysisManager::Terminate() } gROOT->cd(); next1.Reset(); + TString copiedFiles; while ((output=(AliAnalysisDataContainer*)next1())) { // Close all files at output TDirectory *opwd = gDirectory; @@ -883,19 +973,26 @@ void AliAnalysisManager::Terminate() // Clear file list to release object ownership to user. // output->GetFile()->Clear(); output->GetFile()->Close(); - output->SetFile(NULL); // Copy merged outputs in alien if requested - if (fSpecialOutputLocation.Length() && - fSpecialOutputLocation.BeginsWith("alien://")) { + if (fSpecialOutputLocation.BeginsWith("alien://")) { + if (copiedFiles.Contains(output->GetFile()->GetName())) { + if (opwd) opwd->cd(); + output->SetFile(NULL); + continue; + } Info("Terminate", "Copy file %s to %s", output->GetFile()->GetName(),fSpecialOutputLocation.Data()); + gROOT->ProcessLine("if (!gGrid) TGrid::Connect(\"alien:\");"); TFile::Cp(output->GetFile()->GetName(), Form("%s/%s", fSpecialOutputLocation.Data(), output->GetFile()->GetName())); + copiedFiles += output->GetFile()->GetName(); } + output->SetFile(NULL); } if (opwd) opwd->cd(); } delete allOutputs; - + //Write statistics information on the client + if (fStatistics) WriteStatisticsMsg(fNcalls); if (getsysInfo) { TDirectory *crtdir = gDirectory; TFile f("syswatch.root", "RECREATE"); @@ -936,8 +1033,8 @@ void AliAnalysisManager::Terminate() tree->Draw("deltaVM:event",cut,"", 1234567890, 0); hist = (TH1*)gPad->GetListOfPrimitives()->FindObject("htemp"); if (hist) { - hist->SetTitle(Form("%s: Exec dVM[kB]/event", task->GetName())); - hist->GetYaxis()->SetTitle("deltaVM [kB]"); + hist->SetTitle(Form("%s: Exec dVM[MB]/event", task->GetName())); + hist->GetYaxis()->SetTitle("deltaVM [MB]"); } } // Draw the plot of deltaVM for CreateOutputObjects for all tasks @@ -950,7 +1047,7 @@ void AliAnalysisManager::Terminate() hist = (TH1*)gPad->GetListOfPrimitives()->FindObject("htemp"); if (hist) { hist->SetTitle("Memory in CreateOutputObjects()"); - hist->GetYaxis()->SetTitle("deltaVM [kB]"); + hist->GetYaxis()->SetTitle("deltaVM [MB]"); hist->GetXaxis()->SetTitle("task"); } // draw the plot of deltaVM for Terminate for all tasks @@ -962,7 +1059,7 @@ void AliAnalysisManager::Terminate() hist = (TH1*)gPad->GetListOfPrimitives()->FindObject("htemp"); if (hist) { hist->SetTitle("Memory in Terminate()"); - hist->GetYaxis()->SetTitle("deltaVM [kB]"); + hist->GetYaxis()->SetTitle("deltaVM [MB]"); hist->GetXaxis()->SetTitle("task"); } // Full VM profile @@ -974,7 +1071,7 @@ void AliAnalysisManager::Terminate() hist = (TH1*)gPad->GetListOfPrimitives()->FindObject("htemp"); if (hist) { hist->SetTitle("Virtual memory"); - hist->GetYaxis()->SetTitle("VM [kB]"); + hist->GetYaxis()->SetTitle("VM [MB]"); } canvas->Modified(); } @@ -988,7 +1085,7 @@ void AliAnalysisManager::Terminate() if (crtdir) crtdir->cd(); } // Validate the output files - if (ValidateOutputFiles()) { + if (ValidateOutputFiles() && fIsRemote && fMode!=kProofAnalysis) { ofstream out; out.open("outputs_valid", ios::out); out.close(); @@ -1045,8 +1142,8 @@ void AliAnalysisManager::ProfileTask(const char *name, const char */*option*/) c tree->Draw("deltaVM:sname",cut,"", 1234567890, 0); hist = (TH1*)gPad->GetListOfPrimitives()->FindObject("htemp"); if (hist) { - hist->SetTitle("Alocated VM[kB] for COO and Terminate"); - hist->GetYaxis()->SetTitle("deltaVM [kB]"); + hist->SetTitle("Alocated VM[MB] for COO and Terminate"); + hist->GetYaxis()->SetTitle("deltaVM [MB]"); hist->GetXaxis()->SetTitle("method"); } // CPU profile per event @@ -1064,8 +1161,8 @@ void AliAnalysisManager::ProfileTask(const char *name, const char */*option*/) c tree->Draw("deltaVM:event",cut,"", 1234567890, 0); hist = (TH1*)gPad->GetListOfPrimitives()->FindObject("htemp"); if (hist) { - hist->SetTitle("Alocated VM[kB] per event"); - hist->GetYaxis()->SetTitle("deltaVM [kB]"); + hist->SetTitle("Alocated VM[MB] per event"); + hist->GetYaxis()->SetTitle("deltaVM [MB]"); } canvas->Modified(); delete tree; @@ -1077,6 +1174,11 @@ void AliAnalysisManager::ProfileTask(const char *name, const char */*option*/) c void AliAnalysisManager::AddTask(AliAnalysisTask *task) { // Adds a user task to the global list of tasks. + if (fInitOK) { + Error("AddTask", "Cannot add task %s since InitAnalysis was already called", task->GetName()); + return; + } + if (fTasks->FindObject(task)) { Warning("AddTask", "Task %s: the same object already added to the analysis manager. Not adding.", task->GetName()); return; @@ -1186,7 +1288,7 @@ Bool_t AliAnalysisManager::InitAnalysis() // Initialization of analysis chain of tasks. Should be called after all tasks // and data containers are properly connected // Reset flag and remove valid_outputs file if exists - fInitOK = kFALSE; + if (fInitOK) return kTRUE; if (!gSystem->AccessPathName("outputs_valid")) gSystem->Unlink("outputs_valid"); // Check for top tasks (depending only on input data containers) @@ -1278,11 +1380,98 @@ Bool_t AliAnalysisManager::InitAnalysis() Error("InitAnalysis", "Wrong container %s : a file name MUST be provided for special outputs", cont->GetName()); return kFALSE; } - } + } + // Initialize requested branch list if needed + if (!fAutoBranchHandling) { + next.Reset(); + while ((task=(AliAnalysisTask*)next())) { + if (!task->HasBranches()) { + Error("InitAnalysis", "Manual branch loading requested but task %s of type %s does not define branches.\nUse: fBranchNames = \"ESD:br1,br2,...,brN AOD:bra1,bra2,...,braM\"", + task->GetName(), task->ClassName()); + return kFALSE; + } + if (!fInputEventHandler || !strlen(fInputEventHandler->GetDataType())) { + Error("InitAnalysis", "Manual branch loading requested but no input handler defined or handler does not define data type."); + return kFALSE; + } + TString taskbranches; + task->GetBranches(fInputEventHandler->GetDataType(), taskbranches); + if (taskbranches.IsNull()) { + Error("InitAnalysis", "Manual branch loading requested but task %s of type %s does not define branches of type %s:", + task->GetName(), task->ClassName(), fInputEventHandler->GetDataType()); + return kFALSE; + } + AddBranches(taskbranches); + } + } fInitOK = kTRUE; return kTRUE; } +//______________________________________________________________________________ +void AliAnalysisManager::AddBranches(const char *branches) +{ +// Add branches to the existing fRequestedBranches. + TString br(branches); + TObjArray *arr = br.Tokenize(","); + TIter next(arr); + TObject *obj; + while ((obj=next())) { + if (!fRequestedBranches.Contains(obj->GetName())) { + if (!fRequestedBranches.IsNull()) fRequestedBranches += ","; + fRequestedBranches += obj->GetName(); + } + } + delete arr; +} + +//______________________________________________________________________________ +void AliAnalysisManager::CheckBranches(Bool_t load) +{ +// The method checks the input branches to be loaded during the analysis. + if (fAutoBranchHandling || fRequestedBranches.IsNull() || !fTree) return; + TObjArray *arr = fRequestedBranches.Tokenize(","); + TIter next(arr); + TObject *obj; + while ((obj=next())) { + TBranch *br = dynamic_cast(fTable.FindObject(obj->GetName())); + if (!br) { + br = fTree->GetBranch(obj->GetName()); + if (!br) { + Error("CheckBranches", "Could not find branch %s",obj->GetName()); + continue; + } + } + fTable.Add(br); + if (load && br->GetReadEntry()!=GetCurrentEntry()) br->GetEntry(GetCurrentEntry()); + } + delete arr; +} + +//______________________________________________________________________________ +Bool_t AliAnalysisManager::CheckTasks() const +{ +// Check consistency of tasks. + Int_t ntasks = fTasks->GetEntries(); + if (!ntasks) { + Error("CheckTasks", "No tasks connected to the manager. This may be due to forgetting to compile the task or to load their library."); + return kFALSE; + } + // Get the pointer to AliAnalysisTaskSE::Class() + TClass *badptr = (TClass*)gROOT->ProcessLine("AliAnalysisTaskSE::Class()"); + // Loop all tasks to check if their corresponding library was loaded + TIter next(fTasks); + TObject *obj; + while ((obj=next())) { + if (obj->IsA() == badptr) { + Error("CheckTasks", "##################\n \ + Class for task %s NOT loaded. You probably forgot to load the library for this task (or compile it dynamically).\n###########################\n",obj->GetName()); + return kFALSE; + } + } + return kTRUE; +} + //______________________________________________________________________________ void AliAnalysisManager::PrintStatus(Option_t *option) const { @@ -1298,6 +1487,22 @@ void AliAnalysisManager::PrintStatus(Option_t *option) const AliAnalysisTask *task; while ((task=(AliAnalysisTask*)next())) task->PrintTask(option); + + if (!fAutoBranchHandling && !fRequestedBranches.IsNull()) + printf("Requested input branches:\n%s\n", fRequestedBranches.Data()); + + TString sopt(option); + sopt.ToUpper(); + + if (sopt.Contains("ALL")) + { + if ( fOutputEventHandler ) + { + cout << TString('_',78) << endl; + cout << "OutputEventHandler:" << endl; + fOutputEventHandler->Print(" "); + } + } } //______________________________________________________________________________ @@ -1307,6 +1512,35 @@ void AliAnalysisManager::ResetAnalysis() CleanContainers(); } +//______________________________________________________________________________ +void AliAnalysisManager::RunLocalInit() +{ +// Run LocalInit method for all tasks. + TDirectory *cdir = gDirectory; + if (IsTrainInitialized()) return; + TIter nextTask(fTasks); + AliAnalysisTask *task; + while ((task=(AliAnalysisTask*)nextTask())) { + gROOT->cd(); + task->LocalInit(); + } + cdir->cd(); + TObject::SetBit(kTasksInitialized, kTRUE); +} + +//______________________________________________________________________________ +Long64_t AliAnalysisManager::StartAnalysis(const char *type, Long64_t nentries, Long64_t firstentry) +{ +// Start analysis having a grid handler. + if (!fGridHandler) { + Error("StartAnalysis", "Cannot start analysis providing just the analysis type without a grid handler."); + Info("===", "Add an AliAnalysisAlien object as plugin for this manager and configure it."); + return -1; + } + TTree *tree = NULL; + return StartAnalysis(type, tree, nentries, firstentry); +} + //______________________________________________________________________________ Long64_t AliAnalysisManager::StartAnalysis(const char *type, TTree * const tree, Long64_t nentries, Long64_t firstentry) { @@ -1321,16 +1555,17 @@ Long64_t AliAnalysisManager::StartAnalysis(const char *type, TTree * const tree, cdir->cd(); return -1; } - if (fDebug > 1) printf("StartAnalysis %s\n",GetName()); + if (!CheckTasks()) Fatal("StartAnalysis", "Not all needed libraries were loaded"); + if (fDebug > 1) { + printf("StartAnalysis %s\n",GetName()); + AliLog::SetGlobalLogLevel(AliLog::kInfo); + } + fMaxEntries = nentries; fIsRemote = kFALSE; TString anaType = type; anaType.ToLower(); fMode = kLocalAnalysis; - Bool_t runlocalinit = kTRUE; - if (anaType.Contains("file")) { - runlocalinit = kFALSE; - fIsRemote = kTRUE; - } + if (anaType.Contains("file")) fIsRemote = kTRUE; if (anaType.Contains("proof")) fMode = kProofAnalysis; else if (anaType.Contains("grid")) fMode = kGridAnalysis; else if (anaType.Contains("mix")) fMode = kMixingAnalysis; @@ -1347,12 +1582,7 @@ Long64_t AliAnalysisManager::StartAnalysis(const char *type, TTree * const tree, // Write analysis manager in the analysis file cout << "===== RUNNING GRID ANALYSIS: " << GetName() << endl; // run local task configuration - TIter nextTask(fTasks); - AliAnalysisTask *task; - while ((task=(AliAnalysisTask*)nextTask())) { - task->LocalInit(); - gROOT->cd(); - } + RunLocalInit(); if (!fGridHandler->StartAnalysis(nentries, firstentry)) { Info("StartAnalysis", "Grid analysis was stopped and cannot be terminated"); cdir->cd(); @@ -1376,10 +1606,10 @@ Long64_t AliAnalysisManager::StartAnalysis(const char *type, TTree * const tree, cdir->cd(); return 0; } - char line[256]; + TString line; SetEventLoop(kFALSE); // Enable event loop mode if a tree was provided - if (tree || fMode==kMixingAnalysis) SetEventLoop(kTRUE); + if (tree || fGridHandler || fMode==kMixingAnalysis) SetEventLoop(kTRUE); TChain *chain = 0; TString ttype = "TTree"; @@ -1398,17 +1628,11 @@ Long64_t AliAnalysisManager::StartAnalysis(const char *type, TTree * const tree, // Initialize locally all tasks (happens for all modes) TIter next(fTasks); AliAnalysisTask *task; - if (runlocalinit) { - while ((task=(AliAnalysisTask*)next())) { - task->LocalInit(); - gROOT->cd(); - } - if (getsysInfo) AliSysInfo::AddStamp("LocalInit_all", 0); - } + RunLocalInit(); switch (fMode) { case kLocalAnalysis: - if (!tree) { + if (!tree && !fGridHandler) { TIter nextT(fTasks); // Call CreateOutputObjects for all tasks Int_t itask = 0; @@ -1416,6 +1640,11 @@ Long64_t AliAnalysisManager::StartAnalysis(const char *type, TTree * const tree, while ((task=(AliAnalysisTask*)nextT())) { TH1::AddDirectory(kFALSE); task->CreateOutputObjects(); + if (!task->CheckPostData()) { + Error("SlaveBegin","####### IMPORTANT! ####### \n\n\n\ + Task %s (%s) did not call PostData() for all its outputs in (User)CreateOutputObjects()\n\n\ + ########### FIX YOUR CODE, THIS WILL PRODUCE A FATAL ERROR IN FUTURE! ###########", task->GetName(), task->ClassName()); + } if (getsysInfo) AliSysInfo::AddStamp(Form("%s_CREATEOUTOBJ",task->ClassName()), 0, itask, 0); gROOT->cd(); itask++; @@ -1430,19 +1659,41 @@ Long64_t AliAnalysisManager::StartAnalysis(const char *type, TTree * const tree, Terminate(); return 0; } + fSelector = new AliAnalysisSelector(this); + // Check if a plugin handler is used + if (fGridHandler) { + // Get the chain from the plugin + TString dataType = "esdTree"; + if (fInputEventHandler) { + dataType = fInputEventHandler->GetDataType(); + dataType.ToLower(); + dataType += "Tree"; + } + chain = fGridHandler->GetChainForTestMode(dataType); + if (!chain) { + Error("StartAnalysis", "No chain for test mode. Aborting."); + return -1; + } + cout << "===== RUNNING LOCAL ANALYSIS" << GetName() << " ON CHAIN " << chain->GetName() << endl; + retv = chain->Process(fSelector, "", nentries, firstentry); + break; + } // Run tree-based analysis via AliAnalysisSelector cout << "===== RUNNING LOCAL ANALYSIS " << GetName() << " ON TREE " << tree->GetName() << endl; - fSelector = new AliAnalysisSelector(this); retv = tree->Process(fSelector, "", nentries, firstentry); break; case kProofAnalysis: fIsRemote = kTRUE; + // Check if the plugin is used + if (fGridHandler) { + return StartAnalysis(type, fGridHandler->GetProofDataSet(), nentries, firstentry); + } if (!gROOT->GetListOfProofs() || !gROOT->GetListOfProofs()->GetEntries()) { Error("StartAnalysis", "No PROOF!!! Exiting."); cdir->cd(); return -1; } - sprintf(line, "gProof->AddInput((TObject*)0x%lx);", (ULong_t)this); + line = Form("gProof->AddInput((TObject*)%p);", this); gROOT->ProcessLine(line); if (chain) { chain->SetProof(); @@ -1455,8 +1706,39 @@ Long64_t AliAnalysisManager::StartAnalysis(const char *type, TTree * const tree, } break; case kGridAnalysis: - Warning("StartAnalysis", "GRID analysis mode not implemented. Running local."); - break; + fIsRemote = kTRUE; + if (!anaType.Contains("terminate")) { + if (!fGridHandler) { + Error("StartAnalysis", "Cannot start grid analysis without a grid handler."); + Info("===", "Add an AliAnalysisAlien object as plugin for this manager and configure it."); + cdir->cd(); + return -1; + } + // Write analysis manager in the analysis file + cout << "===== RUNNING GRID ANALYSIS: " << GetName() << endl; + // Start the analysis via the handler + if (!fGridHandler->StartAnalysis(nentries, firstentry)) { + Info("StartAnalysis", "Grid analysis was stopped and cannot be terminated"); + cdir->cd(); + return -1; + } + + // Terminate grid analysis + if (fSelector && fSelector->GetStatus() == -1) {cdir->cd(); return -1;} + if (fGridHandler->GetRunMode() == AliAnalysisGrid::kOffline) {cdir->cd(); return 0;} + cout << "===== MERGING OUTPUTS REGISTERED BY YOUR ANALYSIS JOB: " << GetName() << endl; + if (!fGridHandler->MergeOutputs()) { + // Return if outputs could not be merged or if it alien handler + // was configured for offline mode or local testing. + cdir->cd(); + return 0; + } + } + cout << "===== TERMINATING GRID ANALYSIS JOB: " << GetName() << endl; + ImportWrappers(NULL); + Terminate(); + cdir->cd(); + return 0; case kMixingAnalysis: // Run event mixing analysis if (!fEventPool) { @@ -1503,34 +1785,40 @@ Long64_t AliAnalysisManager::StartAnalysis(const char *type, const char *dataset return -1; } fMode = kProofAnalysis; - char line[256]; + TString line; SetEventLoop(kTRUE); // Set the dataset flag TObject::SetBit(kUseDataSet); fTree = 0; + if (fGridHandler) { + // Start proof analysis using the grid handler + if (!fGridHandler->StartAnalysis(nentries, firstentry)) { + Error("StartAnalysis", "The grid plugin could not start PROOF analysis"); + return -1; + } + // Check if the plugin is in test mode + if (fGridHandler->GetRunMode() == AliAnalysisGrid::kTest) { + dataset = "test_collection"; + } else { + dataset = fGridHandler->GetProofDataSet(); + } + } - // Initialize locally all tasks - TIter next(fTasks); - AliAnalysisTask *task; - while ((task=(AliAnalysisTask*)next())) { - task->LocalInit(); - } - if (!gROOT->GetListOfProofs() || !gROOT->GetListOfProofs()->GetEntries()) { Error("StartAnalysis", "No PROOF!!! Exiting."); return -1; } - sprintf(line, "gProof->AddInput((TObject*)0x%lx);", (ULong_t)this); + + // Initialize locally all tasks + RunLocalInit(); + + line = Form("gProof->AddInput((TObject*)%p);", this); gROOT->ProcessLine(line); -// sprintf(line, "gProof->GetDataSet(\"%s\");", dataset); -// if (!gROOT->ProcessLine(line)) { -// Error("StartAnalysis", "Dataset %s not found", dataset); -// return -1; -// } - sprintf(line, "gProof->Process(\"%s\", \"AliAnalysisSelector\", \"\", %lld, %lld);", - dataset, nentries, firstentry); + Long_t retv; + line = Form("gProof->Process(\"%s\", \"AliAnalysisSelector\", \"\", %lld, %lld);", + dataset, nentries, firstentry); cout << "===== RUNNING PROOF ANALYSIS " << GetName() << " ON DATASET " << dataset << endl; - Long_t retv = (Long_t)gROOT->ProcessLine(line); + retv = (Long_t)gROOT->ProcessLine(line); return retv; } @@ -1582,13 +1870,16 @@ TFile *AliAnalysisManager::OpenFile(AliAnalysisDataContainer *cont, const char * } //______________________________________________________________________________ -TFile *AliAnalysisManager::OpenProofFile(AliAnalysisDataContainer *cont, const char *option) +TFile *AliAnalysisManager::OpenProofFile(AliAnalysisDataContainer *cont, const char *option, const char *extaod) { // Opens a special output file used in PROOF. TString line; TString filename = cont->GetFileName(); if (cont == fCommonOutput) { - if (fOutputEventHandler) filename = fOutputEventHandler->GetOutputFileName(); + if (fOutputEventHandler) { + if (strlen(extaod)) filename = extaod; + filename = fOutputEventHandler->GetOutputFileName(); + } else Fatal("OpenProofFile","No output container. Exiting."); } TFile *f = NULL; @@ -1627,13 +1918,16 @@ TFile *AliAnalysisManager::OpenProofFile(AliAnalysisDataContainer *cont, const c TObject *pof = fSelector->GetOutputList()->FindObject(filename); if (pof) { // Get the actual file - line = Form("((TProofOutputFile*)0x%lx)->GetFileName();", (ULong_t)pof); + line = Form("((TProofOutputFile*)%p)->GetFileName();", pof); filename = (const char*)gROOT->ProcessLine(line); if (fDebug>1) { printf("File: %s already booked via TProofOutputFile\n", filename.Data()); } f = (TFile*)gROOT->GetListOfFiles()->FindObject(filename); - if (!f) Fatal("OpenProofFile", "Proof output file found but no file opened for %s", filename.Data()); + if (!f) { + Fatal("OpenProofFile", "Proof output file found but no file opened for %s", filename.Data()); + return NULL; + } // Check if option "UPDATE" was preserved TString opt(option); opt.ToUpper(); @@ -1660,7 +1954,7 @@ TFile *AliAnalysisManager::OpenProofFile(AliAnalysisDataContainer *cont, const c printf(" == proof file name: %s", f->GetName()); } // Add to proof output list - line = Form("((TList*)0x%lx)->Add(pf);",(ULong_t)fSelector->GetOutputList()); + line = Form("((TList*)%p)->Add(pf);",fSelector->GetOutputList()); if (fDebug > 1) printf("=== %s\n", line.Data()); gROOT->ProcessLine(line); } @@ -1685,34 +1979,39 @@ TFile *AliAnalysisManager::OpenProofFile(AliAnalysisDataContainer *cont, const c void AliAnalysisManager::ExecAnalysis(Option_t *option) { // Execute analysis. - static Long64_t ncalls = 0; static Long64_t nentries = 0; static TTree *lastTree = 0; static TStopwatch *timer = new TStopwatch(); - if (fDebug > 0) printf("MGR: Processing event #%lld\n", ncalls); + // Only the first call to Process will trigger a true Notify. Other Notify + // coming before is ignored. + if (!TObject::TestBit(AliAnalysisManager::kTrueNotify)) { + TObject::SetBit(AliAnalysisManager::kTrueNotify); + Notify(); + } + if (fDebug > 0) printf("MGR: Processing event #%d\n", fNcalls); else { if (fTree && (fTree != lastTree)) { nentries += fTree->GetEntries(); lastTree = fTree; } - if (!ncalls) timer->Start(); - if (!fIsRemote && TObject::TestBit(kUseProgressBar)) ProgressBar("Processing event", ncalls, nentries, timer, kFALSE); + if (!fNcalls) timer->Start(); + if (!fIsRemote && TObject::TestBit(kUseProgressBar)) ProgressBar("Processing event", fNcalls, TMath::Min(fMaxEntries,nentries), timer, kFALSE); } gROOT->cd(); TDirectory *cdir = gDirectory; Bool_t getsysInfo = ((fNSysInfo>0) && (fMode==kLocalAnalysis))?kTRUE:kFALSE; - if (getsysInfo && ((ncalls%fNSysInfo)==0)) AliSysInfo::AddStamp("Exec_start", (Int_t)ncalls); - ncalls++; + if (getsysInfo && ((fNcalls%fNSysInfo)==0)) AliSysInfo::AddStamp("Exec_start", (Int_t)fNcalls); if (!fInitOK) { Error("ExecAnalysis", "Analysis manager was not initialized !"); cdir->cd(); return; } + fNcalls++; AliAnalysisTask *task; // Check if the top tree is active. if (fTree) { - if (getsysInfo && ((ncalls%fNSysInfo)==0)) - AliSysInfo::AddStamp("Handlers_BeginEventGroup",(Int_t)ncalls, 1002, 0); + if (getsysInfo && ((fNcalls%fNSysInfo)==0)) + AliSysInfo::AddStamp("Handlers_BeginEventGroup",fNcalls, 1002, 0); TIter next(fTasks); // De-activate all tasks while ((task=(AliAnalysisTask*)next())) task->SetActive(kFALSE); @@ -1731,8 +2030,8 @@ void AliAnalysisManager::ExecAnalysis(Option_t *option) if (fOutputEventHandler) fOutputEventHandler ->BeginEvent(entry); if (fMCtruthEventHandler) fMCtruthEventHandler->BeginEvent(entry); gROOT->cd(); - if (getsysInfo && ((ncalls%fNSysInfo)==0)) - AliSysInfo::AddStamp("Handlers_BeginEvent",(Int_t)ncalls, 1000, 0); + if (getsysInfo && ((fNcalls%fNSysInfo)==0)) + AliSysInfo::AddStamp("Handlers_BeginEvent",fNcalls, 1000, 0); // // Execute the tasks // TIter next1(cont->GetConsumers()); @@ -1744,8 +2043,8 @@ void AliAnalysisManager::ExecAnalysis(Option_t *option) } task->ExecuteTask(option); gROOT->cd(); - if (getsysInfo && ((ncalls%fNSysInfo)==0)) - AliSysInfo::AddStamp(task->ClassName(),(Int_t)ncalls, itask, 1); + if (getsysInfo && ((fNcalls%fNSysInfo)==0)) + AliSysInfo::AddStamp(task->ClassName(), fNcalls, itask, 1); itask++; } // @@ -1754,8 +2053,8 @@ void AliAnalysisManager::ExecAnalysis(Option_t *option) if (fOutputEventHandler) fOutputEventHandler ->FinishEvent(); if (fMCtruthEventHandler) fMCtruthEventHandler->FinishEvent(); // Gather system information if requested - if (getsysInfo && ((ncalls%fNSysInfo)==0)) - AliSysInfo::AddStamp("Handlers_FinishEvent",(Int_t)ncalls, 1001, 1); + if (getsysInfo && ((fNcalls%fNSysInfo)==0)) + AliSysInfo::AddStamp("Handlers_FinishEvent",fNcalls, 1001, 1); cdir->cd(); return; } @@ -1766,8 +2065,8 @@ void AliAnalysisManager::ExecAnalysis(Option_t *option) if (fOutputEventHandler) fOutputEventHandler ->BeginEvent(-1); if (fMCtruthEventHandler) fMCtruthEventHandler->BeginEvent(-1); gROOT->cd(); - if (getsysInfo && ((ncalls%fNSysInfo)==0)) - AliSysInfo::AddStamp("Handlers_BeginEvent",(Int_t)ncalls, 1000, 0); + if (getsysInfo && ((fNcalls%fNSysInfo)==0)) + AliSysInfo::AddStamp("Handlers_BeginEvent",fNcalls, 1000, 0); TIter next2(fTopTasks); while ((task=(AliAnalysisTask*)next2())) { task->SetActive(kTRUE); @@ -1782,18 +2081,30 @@ void AliAnalysisManager::ExecAnalysis(Option_t *option) if (fInputEventHandler) fInputEventHandler ->FinishEvent(); if (fOutputEventHandler) fOutputEventHandler ->FinishEvent(); if (fMCtruthEventHandler) fMCtruthEventHandler->FinishEvent(); - if (getsysInfo && ((ncalls%fNSysInfo)==0)) - AliSysInfo::AddStamp("Handlers_FinishEvent",(Int_t)ncalls, 1000, 1); + if (getsysInfo && ((fNcalls%fNSysInfo)==0)) + AliSysInfo::AddStamp("Handlers_FinishEvent",fNcalls, 1000, 1); cdir->cd(); } +//______________________________________________________________________________ +Bool_t AliAnalysisManager::IsPipe(std::ostream &out) +{ +// Check if the stdout is connected to a pipe (C.Holm) + Bool_t ispipe = kFALSE; + out.seekp(0, std::ios_base::cur); + if (out.fail()) { + out.clear(); + if (errno == ESPIPE) ispipe = kTRUE; + } + return ispipe; +} + //______________________________________________________________________________ void AliAnalysisManager::SetInputEventHandler(AliVEventHandler* const handler) { // Set the input event handler and create a container for it. fInputEventHandler = handler; - fCommonInput = CreateContainer("cAUTO_INPUT", TChain::Class(), AliAnalysisManager::kInputContainer); -// Warning("SetInputEventHandler", " An automatic input container for the input chain was created.\nPlease use: mgr->GetCommonInputContainer() to access it."); + if (!fCommonInput) fCommonInput = CreateContainer("cAUTO_INPUT", TChain::Class(), AliAnalysisManager::kInputContainer); } //______________________________________________________________________________ @@ -1801,11 +2112,31 @@ void AliAnalysisManager::SetOutputEventHandler(AliVEventHandler* const handler) { // Set the input event handler and create a container for it. fOutputEventHandler = handler; - fCommonOutput = CreateContainer("cAUTO_OUTPUT", TTree::Class(), AliAnalysisManager::kOutputContainer, "default"); + if (!fCommonOutput) fCommonOutput = CreateContainer("cAUTO_OUTPUT", TTree::Class(), AliAnalysisManager::kOutputContainer, "default"); fCommonOutput->SetSpecialOutput(); -// Warning("SetOutputEventHandler", " An automatic output container for the output tree was created.\nPlease use: mgr->GetCommonOutputContainer() to access it."); } +//______________________________________________________________________________ +void AliAnalysisManager::SetDebugLevel(UInt_t level) +{ +// Set verbosity of the analysis manager. If the progress bar is used, the call is ignored + if (TObject::TestBit(kUseProgressBar)) { + Info("SetDebugLevel","Ignored. Disable the progress bar first."); + return; + } + fDebug = level; +} + +//______________________________________________________________________________ +void AliAnalysisManager::SetUseProgressBar(Bool_t flag, Int_t freq) +{ +// Enable a text mode progress bar. Resets debug level to 0. + Info("SetUseProgressBar", "Progress bar enabled, updated every %d events.\n ### NOTE: Debug level reset to 0 ###", freq); + TObject::SetBit(kUseProgressBar,flag); + fPBUpdateFreq = freq; + fDebug = 0; +} + //______________________________________________________________________________ void AliAnalysisManager::RegisterExtraFile(const char *fname) { @@ -1824,13 +2155,14 @@ Bool_t AliAnalysisManager::GetFileFromWrapper(const char *filename, const TList // Copy a file from the location specified ina the wrapper with the same name from the source list. char fullPath[512]; char chUrl[512]; + char tmp[1024]; TObject *pof = source->FindObject(filename); if (!pof || !pof->InheritsFrom("TProofOutputFile")) { Error("GetFileFromWrapper", "TProofOutputFile object not found in output list for file %s", filename); return kFALSE; } - gROOT->ProcessLine(Form("sprintf((char*)0x%lx, \"%%s\", ((TProofOutputFile*)0x%lx)->GetOutputFileName();)", (ULong_t)fullPath, (ULong_t)pof)); - gROOT->ProcessLine(Form("sprintf((char*)0x%lx, \"%%s\", gProof->GetUrl();)", (ULong_t)chUrl)); + gROOT->ProcessLine(Form("sprintf((char*)%p, \"%%s\", ((TProofOutputFile*)%p)->GetOutputFileName());", fullPath, pof)); + gROOT->ProcessLine(Form("sprintf((char*)%p, \"%%s\", gProof->GetUrl());",chUrl)); TString clientUrl(chUrl); TString fullPath_str(fullPath); if (clientUrl.Contains("localhost")){ @@ -1844,8 +2176,13 @@ Bool_t AliAnalysisManager::GetFileFromWrapper(const char *filename, const TList delete arrayPort; delete array; } + else if (clientUrl.Contains("__lite__")) { + // Special case for ProofLite environement - get file info and copy. + gROOT->ProcessLine(Form("sprintf((char*)%p,\"%%s\",((TProofOutputFile*)%p)->GetDir());", tmp, pof)); + fullPath_str = Form("%s/%s", tmp, fullPath); + } if (fDebug > 1) - Info("GetFileFromWrapper","Copying file %s from PROOF scratch space", fullPath_str.Data()); + Info("GetFileFromWrapper","Copying file %s from PROOF scratch space to %s", fullPath_str.Data(),filename); Bool_t gotit = TFile::Cp(fullPath_str.Data(), filename); if (!gotit) Error("GetFileFromWrapper", "Could not get file %s from proof scratch space", filename); @@ -1925,10 +2262,10 @@ void AliAnalysisManager::ProgressBar(const char *opname, Long64_t current, Long6 static Bool_t oneoftwo = kFALSE; static Int_t nrefresh = 0; static Int_t nchecks = 0; - const char symbol[4] = {'=','\\','|','/'}; - char progress[11] = " "; - Int_t ichar = icount%4; + static char lastChar = 0; + const char symbol[4] = {'-','\\','|','/'}; + if (!lastChar) lastChar = (IsPipe(std::cerr))?'\r':'\n'; if (!refresh) { nrefresh = 0; if (!size) return; @@ -1941,7 +2278,10 @@ void AliAnalysisManager::ProgressBar(const char *opname, Long64_t current, Long6 nrefresh++; if (!osize) return; } + if ((current % fPBUpdateFreq) != 0) return; icount++; + char progress[11] = " "; + Int_t ichar = icount%4; Double_t time = 0.; Int_t hours = 0; Int_t minutes = 0; @@ -1949,11 +2289,9 @@ void AliAnalysisManager::ProgressBar(const char *opname, Long64_t current, Long6 if (owatch && !last) { owatch->Stop(); time = owatch->RealTime(); - hours = (Int_t)(time/3600.); - time -= 3600*hours; - minutes = (Int_t)(time/60.); - time -= 60*minutes; - seconds = (Int_t)time; + seconds = int(time) % 60; + minutes = (int(time) / 60) % 60; + hours = (int(time) / 60 / 60); if (refresh) { if (oseconds==seconds) { owatch->Continue(); @@ -1982,8 +2320,18 @@ void AliAnalysisManager::ProgressBar(const char *opname, Long64_t current, Long6 if(size<10000) fprintf(stderr, "%s [%10s] %4lld ", oname.Data(), progress, ocurrent); else if(size<100000) fprintf(stderr, "%s [%10s] %5lld ",oname.Data(), progress, ocurrent); else fprintf(stderr, "%s [%10s] %7lld ",oname.Data(), progress, ocurrent); - if (time>0.) fprintf(stderr, "[%6.2f %%] TIME %.2d:%.2d:%.2d \r", percent, hours, minutes, seconds); - else fprintf(stderr, "[%6.2f %%]\r", percent); + if (time>0.) { + Int_t full = Int_t(ocurrent > 0 ? + time * (float(osize)/ocurrent) + .5 : + 99*3600+59*60+59); + Int_t remain = Int_t(full - time); + Int_t rsec = remain % 60; + Int_t rmin = (remain / 60) % 60; + Int_t rhour = (remain / 60 / 60); + fprintf(stderr, "[%6.2f %%] TIME %.2d:%.2d:%.2d ETA %.2d:%.2d:%.2d%c", + percent, hours, minutes, seconds, rhour, rmin, rsec, lastChar); + } + else fprintf(stderr, "[%6.2f %%]%c", percent, lastChar); if (refresh && oneoftwo) oname = nname; if (owatch) owatch->Continue(); if (last) { @@ -2002,8 +2350,9 @@ void AliAnalysisManager::ProgressBar(const char *opname, Long64_t current, Long6 void AliAnalysisManager::DoLoadBranch(const char *name) { // Get tree and load branch if needed. + static Long64_t crtEntry = -100; - if (!fTree) + if (fAutoBranchHandling || !fTree) return; TBranch *br = dynamic_cast(fTable.FindObject(name)); @@ -2015,7 +2364,188 @@ void AliAnalysisManager::DoLoadBranch(const char *name) } fTable.Add(br); } - if (br->GetReadEntry()==GetCurrentEntry()) - return; - br->GetEntry(GetCurrentEntry()); + if (br->GetReadEntry()==fCurrentEntry) return; + Int_t ret = br->GetEntry(GetCurrentEntry()); + if (ret<0) { + Error("DoLoadBranch", "Could not load entry %lld from branch %s",GetCurrentEntry(), name); + if (crtEntry != fCurrentEntry) { + CountEvent(1,0,1,0); + crtEntry = fCurrentEntry; + } + } else { + if (crtEntry != fCurrentEntry) { + CountEvent(1,1,0,0); + crtEntry = fCurrentEntry; + } + } +} + +//______________________________________________________________________________ +void AliAnalysisManager::AddStatisticsTask(UInt_t offlineMask) +{ +// Add the statistics task to the manager. + if (fStatistics) { + Info("AddStatisticsTask", "Already added"); + return; + } + TString line = Form("AliAnalysisTaskStat::AddToManager(%u);", offlineMask); + gROOT->ProcessLine(line); +} + +//______________________________________________________________________________ +void AliAnalysisManager::CountEvent(Int_t ninput, Int_t nprocessed, Int_t nfailed, Int_t naccepted) +{ +// Bookkeep current event; + if (!fStatistics) return; + fStatistics->AddInput(ninput); + fStatistics->AddProcessed(nprocessed); + fStatistics->AddFailed(nfailed); + fStatistics->AddAccepted(naccepted); +} + +//______________________________________________________________________________ +void AliAnalysisManager::AddStatisticsMsg(const char *line) +{ +// Add a line in the statistics message. If available, the statistics message is written +// at the end of the SlaveTerminate phase on workers AND at the end of Terminate +// on the client. + if (!strlen(line)) return; + if (!fStatisticsMsg.IsNull()) fStatisticsMsg += "\n"; + fStatisticsMsg += line; +} + +//______________________________________________________________________________ +void AliAnalysisManager::WriteStatisticsMsg(Int_t) +{ +// If fStatistics is present, write the file in the format ninput_nprocessed_nfailed_naccepted.stat + static Bool_t done = kFALSE; + if (done) return; + done = kTRUE; + if (!fStatistics) return; + ofstream out; + AddStatisticsMsg(Form("Number of input events: %lld",fStatistics->GetNinput())); + AddStatisticsMsg(Form("Number of processed events: %lld",fStatistics->GetNprocessed())); + AddStatisticsMsg(Form("Number of failed events (I/O): %lld",fStatistics->GetNfailed())); + AddStatisticsMsg(Form("Number of accepted events for mask %s: %lld", AliAnalysisStatistics::GetMaskAsString(fStatistics->GetOfflineMask()), fStatistics->GetNaccepted())); + out.open(Form("%lld_%lld_%lld_%lld.stat",fStatistics->GetNinput(), + fStatistics->GetNprocessed(),fStatistics->GetNfailed(), + fStatistics->GetNaccepted()), ios::out); + out << fStatisticsMsg << endl; + out.close(); +} + +//______________________________________________________________________________ +const char* AliAnalysisManager::GetOADBPath() +{ +// returns the path of the OADB +// this static function just depends on environment variables + + static TString oadbPath; + + if (gSystem->Getenv("OADB_PATH")) + oadbPath = gSystem->Getenv("OADB_PATH"); + else if (gSystem->Getenv("ALICE_ROOT")) + oadbPath.Form("%s/OADB", gSystem->Getenv("ALICE_ROOT")); + else + ::Fatal("AliAnalysisManager::GetOADBPath", "Cannot figure out AODB path. Define ALICE_ROOT or OADB_PATH!"); + + return oadbPath; +} + +//______________________________________________________________________________ +void AliAnalysisManager::SetGlobalStr(const char *key, const char *value) +{ +// Define a custom string variable mapped to a global unique name. The variable +// can be then retrieved by a given analysis macro via GetGlobalStr(key). + AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); + if (!mgr) { + ::Error("AliAnalysisManager::SetGlobalStr", "No analysis manager defined"); + return; + } + Bool_t valid = kFALSE; + TString existing = AliAnalysisManager::GetGlobalStr(key, valid); + if (valid) { + ::Error("AliAnalysisManager::SetGlobalStr", "Global %s = %s already defined.", key, existing.Data()); + return; + } + mgr->GetGlobals()->Add(new TObjString(key), new TObjString(value)); +} + +//______________________________________________________________________________ +const char *AliAnalysisManager::GetGlobalStr(const char *key, Bool_t &valid) +{ +// Static method to retrieve a global variable defined via SetGlobalStr. + valid = kFALSE; + AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); + if (!mgr) return 0; + TObject *value = mgr->GetGlobals()->GetValue(key); + if (!value) return 0; + valid = kTRUE; + return value->GetName(); +} + +//______________________________________________________________________________ +void AliAnalysisManager::SetGlobalInt(const char *key, Int_t value) +{ +// Define a custom integer variable mapped to a global unique name. The variable +// can be then retrieved by a given analysis macro via GetGlobalInt(key). + AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); + if (!mgr) { + ::Error("AliAnalysisManager::SetGlobalStr", "No analysis manager defined"); + return; + } + Bool_t valid = kFALSE; + Int_t existing = AliAnalysisManager::GetGlobalInt(key, valid); + if (valid) { + ::Error("AliAnalysisManager::SetGlobalInt", "Global %s = %i already defined.", key, existing); + return; + } + mgr->GetGlobals()->Add(new TObjString(key), new TObjString(TString::Format("%i",value))); +} + +//______________________________________________________________________________ +Int_t AliAnalysisManager::GetGlobalInt(const char *key, Bool_t &valid) +{ +// Static method to retrieve a global variable defined via SetGlobalInt. + valid = kFALSE; + AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); + if (!mgr) return 0; + TObject *value = mgr->GetGlobals()->GetValue(key); + if (!value) return 0; + valid = kTRUE; + TString s = value->GetName(); + return s.Atoi(); +} + +//______________________________________________________________________________ +void AliAnalysisManager::SetGlobalDbl(const char *key, Double_t value) +{ +// Define a custom double precision variable mapped to a global unique name. The variable +// can be then retrieved by a given analysis macro via GetGlobalInt(key). + AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); + if (!mgr) { + ::Error("AliAnalysisManager::SetGlobalStr", "No analysis manager defined"); + return; + } + Bool_t valid = kFALSE; + Double_t existing = AliAnalysisManager::GetGlobalDbl(key, valid); + if (valid) { + ::Error("AliAnalysisManager::SetGlobalInt", "Global %s = %g already defined.", key, existing); + return; + } + mgr->GetGlobals()->Add(new TObjString(key), new TObjString(TString::Format("%f.16",value))); +} + +//______________________________________________________________________________ +Double_t AliAnalysisManager::GetGlobalDbl(const char *key, Bool_t &valid) +{ +// Static method to retrieve a global variable defined via SetGlobalDbl. + valid = kFALSE; + AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); + if (!mgr) return 0; + TObject *value = mgr->GetGlobals()->GetValue(key); + if (!value) return 0; + valid = kTRUE; + TString s = value->GetName(); + return s.Atof(); }