X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=ANALYSIS%2FAliAnalysisManager.cxx;h=09666beb84dc3c909283d1e6d3c6399ee06ace9b;hb=fd245273e3e399717bfce498e96d6a4d122671f4;hp=50d112337ace872555e56dd153de3bc023360acb;hpb=c3732d792f46f6d86fb87869722343a08db82568;p=u%2Fmrichter%2FAliRoot.git diff --git a/ANALYSIS/AliAnalysisManager.cxx b/ANALYSIS/AliAnalysisManager.cxx index 50d112337ac..09666beb84d 100644 --- a/ANALYSIS/AliAnalysisManager.cxx +++ b/ANALYSIS/AliAnalysisManager.cxx @@ -27,10 +27,14 @@ #include "AliAnalysisManager.h" +#include #include #include +#include #include #include +#include +#include #include #include #include @@ -40,6 +44,7 @@ #include #include +#include "AliLog.h" #include "AliAnalysisSelector.h" #include "AliAnalysisGrid.h" #include "AliAnalysisTask.h" @@ -50,58 +55,85 @@ #include "AliSysInfo.h" #include "AliAnalysisStatistics.h" +using std::ofstream; +using std::ios; +using std::cout; +using std::endl; ClassImp(AliAnalysisManager) AliAnalysisManager *AliAnalysisManager::fgAnalysisManager = NULL; TString AliAnalysisManager::fgCommonFileName = ""; +TString AliAnalysisManager::fgMacroNames = ""; +Int_t AliAnalysisManager::fPBUpdateFreq = 1; //______________________________________________________________________________ AliAnalysisManager::AliAnalysisManager(const char *name, const char *title) :TNamed(name,title), - fTree(NULL), - fInputEventHandler(NULL), - fOutputEventHandler(NULL), - fMCtruthEventHandler(NULL), - fEventPool(NULL), + fTree(0), + fInputEventHandler(0), + fOutputEventHandler(0), + fMCtruthEventHandler(0), + fEventPool(0), fCurrentEntry(-1), fNSysInfo(0), fMode(kLocalAnalysis), fInitOK(kFALSE), + fMustClean(kFALSE), fIsRemote(kFALSE), + fLocked(kFALSE), fDebug(0), fSpecialOutputLocation(""), - fTasks(NULL), - fTopTasks(NULL), - fZombies(NULL), - fContainers(NULL), - fInputs(NULL), - fOutputs(NULL), - fParamCont(NULL), - fCommonInput(NULL), - fCommonOutput(NULL), - fSelector(NULL), - fGridHandler(NULL), - fExtraFiles(""), + fTasks(0), + fTopTasks(0), + fZombies(0), + fContainers(0), + fInputs(0), + fOutputs(0), + fParamCont(0), + fDebugOptions(0), + fFileDescriptors(new TObjArray()), + fCurrentDescriptor(0), + fCommonInput(0), + fCommonOutput(0), + fSelector(0), + fGridHandler(0), + fExtraFiles(), + fFileInfoLog(), fAutoBranchHandling(kTRUE), + fAsyncReading(kFALSE), // default prefetching on fTable(), fRunFromPath(0), fNcalls(0), + fMaxEntries(0), + fCacheSize(100000000), // default 100 MB fStatisticsMsg(), fRequestedBranches(), - fStatistics(0) + fStatistics(0), + fGlobals(0), + fIOTimer(0), + fCPUTimer(0), + fInitTimer(0), + fIOTime(0), + fCPUTime(0), + fInitTime(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(); + } + fIOTimer = new TStopwatch(); + fCPUTimer = new TStopwatch(); + fInitTimer = new TStopwatch(); SetEventLoop(kTRUE); - TObject::SetObjectStat(kFALSE); } //______________________________________________________________________________ @@ -116,7 +148,9 @@ AliAnalysisManager::AliAnalysisManager(const AliAnalysisManager& other) fNSysInfo(0), fMode(other.fMode), fInitOK(other.fInitOK), + fMustClean(other.fMustClean), fIsRemote(other.fIsRemote), + fLocked(other.fLocked), fDebug(other.fDebug), fSpecialOutputLocation(""), fTasks(NULL), @@ -126,18 +160,32 @@ AliAnalysisManager::AliAnalysisManager(const AliAnalysisManager& other) fInputs(NULL), fOutputs(NULL), fParamCont(NULL), + fDebugOptions(NULL), + fFileDescriptors(new TObjArray()), + fCurrentDescriptor(0), fCommonInput(NULL), fCommonOutput(NULL), fSelector(NULL), fGridHandler(NULL), - fExtraFiles(), + fExtraFiles(other.fExtraFiles), + fFileInfoLog(other.fFileInfoLog), fAutoBranchHandling(other.fAutoBranchHandling), + fAsyncReading(other.fAsyncReading), fTable(), fRunFromPath(0), fNcalls(other.fNcalls), + fMaxEntries(other.fMaxEntries), + fCacheSize(other.fCacheSize), fStatisticsMsg(other.fStatisticsMsg), fRequestedBranches(other.fRequestedBranches), - fStatistics(other.fStatistics) + fStatistics(other.fStatistics), + fGlobals(other.fGlobals), + fIOTimer(new TStopwatch()), + fCPUTimer(new TStopwatch()), + fInitTimer(new TStopwatch()), + fIOTime(0), + fCPUTime(0), + fInitTime(0) { // Copy constructor. fTasks = new TObjArray(*other.fTasks); @@ -149,7 +197,6 @@ AliAnalysisManager::AliAnalysisManager(const AliAnalysisManager& other) fParamCont = new TObjArray(*other.fParamCont); fgCommonFileName = "AnalysisResults.root"; fgAnalysisManager = this; - TObject::SetObjectStat(kFALSE); } //______________________________________________________________________________ @@ -168,6 +215,7 @@ AliAnalysisManager& AliAnalysisManager::operator=(const AliAnalysisManager& othe fMode = other.fMode; fInitOK = other.fInitOK; fIsRemote = other.fIsRemote; + fLocked = other.fLocked; fDebug = other.fDebug; fTasks = new TObjArray(*other.fTasks); fTopTasks = new TObjArray(*other.fTopTasks); @@ -176,20 +224,34 @@ AliAnalysisManager& AliAnalysisManager::operator=(const AliAnalysisManager& othe fInputs = new TObjArray(*other.fInputs); fOutputs = new TObjArray(*other.fOutputs); fParamCont = new TObjArray(*other.fParamCont); + fDebugOptions = NULL; + fFileDescriptors = new TObjArray(); + fCurrentDescriptor = 0; fCommonInput = NULL; fCommonOutput = NULL; fSelector = NULL; fGridHandler = NULL; fExtraFiles = other.fExtraFiles; + fFileInfoLog = other.fFileInfoLog; fgCommonFileName = "AnalysisResults.root"; fgAnalysisManager = this; fAutoBranchHandling = other.fAutoBranchHandling; + fAsyncReading = other.fAsyncReading; fTable.Clear("nodelete"); fRunFromPath = other.fRunFromPath; fNcalls = other. fNcalls; + fMaxEntries = other.fMaxEntries; + fCacheSize = other.fCacheSize; fStatisticsMsg = other.fStatisticsMsg; fRequestedBranches = other.fRequestedBranches; fStatistics = other.fStatistics; + fGlobals = new TMap(); + fIOTimer = new TStopwatch(); + fCPUTimer = new TStopwatch(); + fInitTimer = new TStopwatch(); + fIOTime = 0.; + fCPUTime = 0.; + fInitTime = 0.; } return *this; } @@ -205,15 +267,44 @@ AliAnalysisManager::~AliAnalysisManager() if (fInputs) delete fInputs; if (fOutputs) delete fOutputs; if (fParamCont) delete fParamCont; + if (fDebugOptions) delete fDebugOptions; if (fGridHandler) delete fGridHandler; if (fInputEventHandler) delete fInputEventHandler; if (fOutputEventHandler) delete fOutputEventHandler; if (fMCtruthEventHandler) delete fMCtruthEventHandler; if (fEventPool) delete fEventPool; if (fgAnalysisManager==this) fgAnalysisManager = NULL; - TObject::SetObjectStat(kTRUE); + if (fGlobals) {fGlobals->DeleteAll(); delete fGlobals;} + if (fFileDescriptors) {fFileDescriptors->Delete(); delete fFileDescriptors;} + delete fIOTimer; + delete fCPUTimer; + delete fInitTimer; } +//______________________________________________________________________________ +void AliAnalysisManager::CreateReadCache() +{ +// Create cache for reading according fCacheSize and fAsyncReading. + if (!fTree || !fTree->GetCurrentFile()) { + Error("CreateReadCache","Current tree or tree file not yet defined"); + return; + } + if (!fCacheSize) { + if (fDebug) Info("CreateReadCache","=== Read caching disabled ==="); + return; + } + gEnv->SetValue("TFile.AsyncPrefetching",(Int_t)fAsyncReading); + if (fAsyncReading) gEnv->SetValue("Cache.Directory",Form("file://%s/cache", gSystem->WorkingDirectory())); + if (fAsyncReading) gEnv->SetValue("TFile.AsyncReading",1); + fTree->SetCacheSize(fCacheSize); + TTreeCache::SetLearnEntries(1); //<<< we can take the decision after 1 entry + fTree->AddBranchToCache("*",kTRUE); //<<< add all branches to the cache + if (fDebug) { + Info("CreateReadCache","Read cache enabled %lld bytes with async reading=%d",fCacheSize, (Int_t)fAsyncReading); + } + return; +} + //______________________________________________________________________________ Int_t AliAnalysisManager::GetEntry(Long64_t entry, Int_t getall) { @@ -221,7 +312,12 @@ Int_t AliAnalysisManager::GetEntry(Long64_t entry, Int_t getall) fCurrentEntry = entry; if (!fAutoBranchHandling) return 123456789; - return fTree ? fTree->GetTree()->GetEntry(entry, getall) : -1; + if (!fTree || !fTree->GetTree()) return -1; + fIOTimer->Start(kTRUE); + Long64_t readbytes = fTree->GetTree()->GetEntry(entry, getall); + fIOTimer->Stop(); + fIOTime += fIOTimer->RealTime(); + return (Int_t)readbytes; } //______________________________________________________________________________ @@ -231,27 +327,29 @@ Int_t AliAnalysisManager::GetRunFromAlienPath(const char *path) // 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 run = 0; - Int_t index = s.Index("/alice/sim"); - if (index >= 0) { - for (Int_t i=0; i<3; i++) { - index = s.Index("/", index+1); - if (index<0) return 0; - } - srun = s(index+1,6); - run = atoi(srun); - } - index = s.Index("/alice/data"); - if (index >= 0) { - for (Int_t i=0; i<4; i++) { - index = s.Index("/", index+1); - if (index<0) return 0; + 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); + } } - srun = s(index+1,9); - run = atoi(srun); - } + } + Int_t run = srun.Atoi(); + if (run>0) printf("=== GetRunFromAlienPath: run %d of %s data ===\n", run, type.Data()); return run; } @@ -318,6 +416,7 @@ Bool_t AliAnalysisManager::Init(TTree *tree) if (!fInitOK) InitAnalysis(); if (!fInitOK) return kFALSE; fTree = tree; + if (fMode != kProofAnalysis) CreateReadCache(); fTable.Rehash(100); AliAnalysisDataContainer *top = fCommonInput; if (!top) top = (AliAnalysisDataContainer*)fInputs->At(0); @@ -340,6 +439,13 @@ 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"); + // Init timer should be already started + // Apply debug options + ApplyDebugOptions(); + if (fCacheSize && + fMCtruthEventHandler && + (fMode != kProofAnalysis)) fMCtruthEventHandler->SetCacheSize(fCacheSize); + if (!CheckTasks()) Fatal("SlaveBegin", "Not all needed libraries were loaded"); static Bool_t isCalled = kFALSE; Bool_t init = kFALSE; Bool_t initOK = kTRUE; @@ -404,11 +510,20 @@ 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++; } TH1::AddDirectory(dirStatus); if (curdir) curdir->cd(); + fInitTimer->Stop(); + fInitTime += fInitTimer->RealTime(); + fInitTimer->Continue(); + printf("Initialization time: %g [sec]\n", fInitTime); if (fDebug > 1) printf("<-AliAnalysisManager::SlaveBegin()\n"); } @@ -420,7 +535,9 @@ Bool_t AliAnalysisManager::Notify() // is started when using PROOF. It is normaly not necessary to make changes // to the generated code, but the routine can be extended by the // user if needed. The return value is currently not used. + fIOTimer->Start(kTRUE); if (!fTree) return kFALSE; + if (!TObject::TestBit(AliAnalysisManager::kTrueNotify)) return kFALSE; fTable.Clear("nodelete"); // clearing the hash table may not be needed -> C.L. if (fMode == kProofAnalysis) fIsRemote = kTRUE; @@ -429,12 +546,19 @@ Bool_t AliAnalysisManager::Notify() if (!curfile) { Error("Notify","No current file"); return kFALSE; + } + if (IsCollectThroughput()) { + if (fCurrentDescriptor) fCurrentDescriptor->Done(); + fCurrentDescriptor = new AliAnalysisFileDescriptor(curfile); + fFileDescriptors->Add(fCurrentDescriptor); } if (fDebug > 1) printf("->AliAnalysisManager::Notify() file: %s\n", curfile->GetName()); Int_t run = AliAnalysisManager::GetRunFromAlienPath(curfile->GetName()); - if (run) SetRunFromPath(run); - if (fDebug > 1) printf(" ### run found from path: %d\n", run); + if (run && (run != fRunFromPath)) { + fRunFromPath = run; + if (fDebug > 1) printf(" ### run found from path: %d\n", run); + } TIter next(fTasks); AliAnalysisTask *task; @@ -456,11 +580,13 @@ Bool_t AliAnalysisManager::Notify() task->Notify(); if (fDebug > 1) printf("<-AliAnalysisManager::Notify()\n"); + fIOTimer->Stop(); + fIOTime += fIOTimer->RealTime(); 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 @@ -479,18 +605,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); - - if (fInputEventHandler) fInputEventHandler ->GetEntry(); - ExecAnalysis(); - if (fDebug > 1) printf("<-AliAnalysisManager::Process()\n"); + // This method is obsolete. ExecAnalysis is called instead. return kTRUE; } @@ -500,6 +616,20 @@ void AliAnalysisManager::PackOutput(TList *target) // Pack all output data containers in the output list. Called at SlaveTerminate // stage in PROOF case for each slave. if (fDebug > 1) printf("->AliAnalysisManager::PackOutput()\n"); + fIOTimer->Start(kTRUE); + std::ofstream out; + if (IsCollectThroughput()) { + if (fCurrentDescriptor) fCurrentDescriptor->Done(); + fFileDescriptors->Print(); + if (fFileInfoLog.IsNull()) fFileInfoLog = "fileinfo.log"; + out.open(fFileInfoLog, std::ios::app); + if (out.bad()) Error("SavePrimitive", "Bad file name: %s", fFileInfoLog.Data()); + else { + TIter nextflog(fFileDescriptors); + TObject *log; + while ((log=nextflog())) log->SavePrimitive(out,""); + } + } if (!target) { Error("PackOutput", "No target. Exiting."); return; @@ -524,7 +654,7 @@ void AliAnalysisManager::PackOutput(TList *target) } } // Write statistics message on the workers. - WriteStatisticsMsg(fNcalls); + if (fStatistics) WriteStatisticsMsg(fNcalls); if (fMode == kProofAnalysis) { TIter next(fOutputs); @@ -706,7 +836,37 @@ void AliAnalysisManager::PackOutput(TList *target) } } } - cdir->cd(); + fIOTime += fIOTimer->RealTime(); + if ((fDebug || IsCollectThroughput())) { + fInitTimer->Stop(); + fInitTime = fInitTimer->RealTime()-fIOTime-fCPUTime; + printf("=Analysis %s= init time: %g[sec]\ + \n I/O & data mng.: %g [sec]\ + \n task execution: %g [sec]\ + \n total time: CPU=%g [sec] REAL=%g[sec]\n", + GetName(), fInitTime, fIOTime, fCPUTime, fInitTimer->CpuTime(), fInitTimer->RealTime()); + if (IsCollectThroughput()) { + out << "#summary#########################################################" << endl; + out << "train_name " << GetName() << endl; + out << "root_time " << fInitTimer->RealTime() << endl; + out << "root_cpu " << fInitTimer->CpuTime() << endl; + out << "init_time " << fInitTime << endl; + out << "io_mng_time " << fIOTime << endl; + out << "exec_time " << fCPUTime << endl; + TString aliensite = gSystem->Getenv("ALIEN_SITE"); + out << "alien_site " << aliensite << endl; + out << "host_name "; + TString hostname = gSystem->Getenv("ALIEN_HOSTNAME"); + if (hostname.IsNull()) { + out.close(); + gSystem->Exec(Form("hostname -f >> %s", fFileInfoLog.Data())); + } else { + out << hostname << endl; + } + } + } + + if (cdir) cdir->cd(); if (fDebug > 1) printf("<-AliAnalysisManager::PackOutput: output list contains %d containers\n", target->GetSize()); } @@ -715,6 +875,7 @@ void AliAnalysisManager::ImportWrappers(TList *source) { // Import data in output containers from wrappers coming in source. if (fDebug > 1) printf("->AliAnalysisManager::ImportWrappers()\n"); + fIOTimer->Start(kTRUE); TIter next(fOutputs); AliAnalysisDataContainer *cont; AliAnalysisDataWrapper *wrap; @@ -755,6 +916,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(); @@ -783,6 +945,8 @@ void AliAnalysisManager::ImportWrappers(TList *source) cont->ImportData(wrap); } if (cdir) cdir->cd(); + fIOTimer->Stop(); + fIOTime += fIOTimer->RealTime(); if (fDebug > 1) printf("<-AliAnalysisManager::ImportWrappers(): %d containers imported\n", icont); } @@ -790,6 +954,7 @@ void AliAnalysisManager::ImportWrappers(TList *source) void AliAnalysisManager::UnpackOutput(TList *source) { // Called by AliAnalysisSelector::Terminate only on the client. + fIOTimer->Start(kTRUE); if (fDebug > 1) printf("->AliAnalysisManager::UnpackOutput()\n"); if (!source) { Error("UnpackOutput", "No target. Exiting."); @@ -815,11 +980,15 @@ void AliAnalysisManager::UnpackOutput(TList *source) // If task is active, execute it if (task->IsPostEventLoop() && task->IsActive()) { if (fDebug > 1) printf("== Executing post event loop task %s\n", task->GetName()); + if (fStatistics) fStatistics->StartTimer(GetTaskIndex(task), task->GetName(), task->ClassName()); task->ExecuteTask(); } } + if (fStatistics) fStatistics->StopTimer(); } } + fIOTimer->Stop(); + fIOTime += fIOTimer->RealTime(); if (fDebug > 1) printf("<-AliAnalysisManager::UnpackOutput()\n"); } @@ -830,6 +999,7 @@ void AliAnalysisManager::Terminate() // a query. It always runs on the client, it can be used to present // the results graphically. if (fDebug > 1) printf("->AliAnalysisManager::Terminate()\n"); + fInitTimer->Start(kTRUE); TDirectory *cdir = gDirectory; gROOT->cd(); AliAnalysisTask *task; @@ -850,8 +1020,8 @@ void AliAnalysisManager::Terminate() if (TObject::TestBit(kSaveCanvases)) { if (!gROOT->IsBatch()) { if (fDebug>1) printf("Waiting 5 sec for %s::Terminate() to finish drawing ...\n", task->ClassName()); - timer.Start(); - while (timer.CpuTime()<5) { + timer.Start(kTRUE); + while (timer.RealTime()<5) { timer.Continue(); gSystem->ProcessEvents(); } @@ -952,6 +1122,7 @@ void AliAnalysisManager::Terminate() } gROOT->cd(); next1.Reset(); + TString copiedFiles; while ((output=(AliAnalysisDataContainer*)next1())) { // Close all files at output TDirectory *opwd = gDirectory; @@ -959,20 +1130,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 - WriteStatisticsMsg(fNcalls); + if (fStatistics) WriteStatisticsMsg(fNcalls); if (getsysInfo) { TDirectory *crtdir = gDirectory; TFile f("syswatch.root", "RECREATE"); @@ -1013,7 +1190,7 @@ 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->SetTitle(Form("%s: Exec dVM[MB]/event", task->GetName())); hist->GetYaxis()->SetTitle("deltaVM [MB]"); } } @@ -1065,12 +1242,16 @@ 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(); } - cdir->cd(); + if (cdir) cdir->cd(); + fInitTimer->Stop(); + if (fDebug || IsCollectThroughput()) { + printf("=Analysis %s= Terminate time: %g[sec]\n", GetName(), fInitTimer->RealTime()); + } if (fDebug > 1) printf("<-AliAnalysisManager::Terminate()\n"); } //______________________________________________________________________________ @@ -1122,8 +1303,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 @@ -1141,8 +1322,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; @@ -1154,6 +1335,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; @@ -1170,6 +1356,14 @@ AliAnalysisTask *AliAnalysisManager::GetTask(const char *name) const return (AliAnalysisTask*)fTasks->FindObject(name); } +//______________________________________________________________________________ +Int_t AliAnalysisManager::GetTaskIndex(const AliAnalysisTask *task) const +{ +// Returns task inded in the manager's list, -1 if not registered. + if (!fTasks) return -1; + return fTasks->IndexOf(task); +} + //______________________________________________________________________________ AliAnalysisDataContainer *AliAnalysisManager::CreateContainer(const char *name, TClass *datatype, EAliAnalysisContType type, const char *filename) @@ -1263,7 +1457,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) @@ -1397,7 +1591,7 @@ void AliAnalysisManager::AddBranches(const char *branches) fRequestedBranches += obj->GetName(); } } - if (arr) delete arr; + delete arr; } //______________________________________________________________________________ @@ -1418,10 +1612,37 @@ void AliAnalysisManager::CheckBranches(Bool_t load) } } fTable.Add(br); - if (load && br->GetReadEntry()!=GetCurrentEntry()) br->GetEntry(GetCurrentEntry()); + 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 { @@ -1437,8 +1658,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(" "); + } + } } //______________________________________________________________________________ @@ -1448,6 +1683,41 @@ 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(); + } + if (cdir) cdir->cd(); + TObject::SetBit(kTasksInitialized, kTRUE); +} + +//______________________________________________________________________________ +void AliAnalysisManager::InputFileFromTree(TTree * const tree, TString &fname) +{ +// Retrieves name of the file from tree + fname = ""; + if (!tree) return; + TFile *file = tree->GetCurrentFile(); + TString basename; + if (!file) { + TChain *chain = dynamic_cast(tree); + if (!chain || !chain->GetNtrees()) return; + basename = gSystem->BaseName(chain->GetListOfFiles()->First()->GetTitle()); + } else { + basename = gSystem->BaseName(file->GetName()); + } + Int_t index = basename.Index("#"); + fname = basename(index+1, basename.Length()); +} + //______________________________________________________________________________ Long64_t AliAnalysisManager::StartAnalysis(const char *type, Long64_t nentries, Long64_t firstentry) { @@ -1472,22 +1742,28 @@ Long64_t AliAnalysisManager::StartAnalysis(const char *type, TTree * const tree, gROOT->cd(); if (!fInitOK) { Error("StartAnalysis","Analysis manager was not initialized !"); - cdir->cd(); + if (cdir) 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; + if (fInputEventHandler) { + TString fname; + InputFileFromTree(tree, fname); + if (fname.Length()) fInputEventHandler->SetInputFileName(fname); + } if (fMode == kGridAnalysis) { fIsRemote = kTRUE; @@ -1495,39 +1771,35 @@ Long64_t AliAnalysisManager::StartAnalysis(const char *type, TTree * const tree, 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(); + if (cdir) cdir->cd(); return -1; } // 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(); + if (cdir) 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;} + if (fSelector && fSelector->GetStatus() == -1) {if (cdir) cdir->cd(); return -1;} + if (fGridHandler->GetRunMode() == AliAnalysisGrid::kOffline) {if (cdir) cdir->cd(); return 0;} cout << "===== MERGING OUTPUTS REGISTERED BY YOUR ANALYSIS JOB: " << GetName() << endl; if (!fGridHandler->MergeOutputs()) { // Return if outputs could not be merged or if it alien handler // was configured for offline mode or local testing. - cdir->cd(); + if (cdir) cdir->cd(); return 0; } } cout << "===== TERMINATING GRID ANALYSIS JOB: " << GetName() << endl; + if (cdir) cdir->cd(); ImportWrappers(NULL); Terminate(); - cdir->cd(); + if (cdir) cdir->cd(); return 0; } TString line; @@ -1541,7 +1813,7 @@ Long64_t AliAnalysisManager::StartAnalysis(const char *type, TTree * const tree, chain = (TChain*)tree; if (!chain || !chain->GetListOfFiles()->First()) { Error("StartAnalysis", "Cannot process null or empty chain..."); - cdir->cd(); + if (cdir) cdir->cd(); return -1; } ttype = "TChain"; @@ -1552,13 +1824,7 @@ 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: @@ -1570,6 +1836,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++; @@ -1615,10 +1886,10 @@ Long64_t AliAnalysisManager::StartAnalysis(const char *type, TTree * const tree, } if (!gROOT->GetListOfProofs() || !gROOT->GetListOfProofs()->GetEntries()) { Error("StartAnalysis", "No PROOF!!! Exiting."); - cdir->cd(); + if (cdir) cdir->cd(); return -1; } - line = Form("gProof->AddInput((TObject*)0x%lx);", (ULong_t)this); + line = Form("gProof->AddInput((TObject*)%p);", this); gROOT->ProcessLine(line); if (chain) { chain->SetProof(); @@ -1626,7 +1897,7 @@ Long64_t AliAnalysisManager::StartAnalysis(const char *type, TTree * const tree, retv = chain->Process("AliAnalysisSelector", "", nentries, firstentry); } else { Error("StartAnalysis", "No chain!!! Exiting."); - cdir->cd(); + if (cdir) cdir->cd(); return -1; } break; @@ -1636,7 +1907,7 @@ Long64_t AliAnalysisManager::StartAnalysis(const char *type, TTree * const tree, 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(); + if (cdir) cdir->cd(); return -1; } // Write analysis manager in the analysis file @@ -1644,31 +1915,31 @@ Long64_t AliAnalysisManager::StartAnalysis(const char *type, TTree * const tree, // Start the analysis via the handler if (!fGridHandler->StartAnalysis(nentries, firstentry)) { Info("StartAnalysis", "Grid analysis was stopped and cannot be terminated"); - cdir->cd(); + if (cdir) 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;} + if (fSelector && fSelector->GetStatus() == -1) {if (cdir) cdir->cd(); return -1;} + if (fGridHandler->GetRunMode() == AliAnalysisGrid::kOffline) {if (cdir) cdir->cd(); return 0;} cout << "===== MERGING OUTPUTS REGISTERED BY YOUR ANALYSIS JOB: " << GetName() << endl; if (!fGridHandler->MergeOutputs()) { // Return if outputs could not be merged or if it alien handler // was configured for offline mode or local testing. - cdir->cd(); + if (cdir) cdir->cd(); return 0; } } cout << "===== TERMINATING GRID ANALYSIS JOB: " << GetName() << endl; ImportWrappers(NULL); Terminate(); - cdir->cd(); + if (cdir) cdir->cd(); return 0; case kMixingAnalysis: // Run event mixing analysis if (!fEventPool) { Error("StartAnalysis", "Cannot run event mixing without event pool"); - cdir->cd(); + if (cdir) cdir->cd(); return -1; } cout << "===== RUNNING EVENT MIXING ANALYSIS " << GetName() << endl; @@ -1681,14 +1952,14 @@ Long64_t AliAnalysisManager::StartAnalysis(const char *type, TTree * const tree, retv = chain->Process(fSelector); if (retv < 0) { Error("StartAnalysis", "Mixing analysis failed"); - cdir->cd(); + if (cdir) cdir->cd(); return retv; } } PackOutput(fSelector->GetOutputList()); Terminate(); } - cdir->cd(); + if (cdir) cdir->cd(); return retv; } @@ -1711,11 +1982,11 @@ Long64_t AliAnalysisManager::StartAnalysis(const char *type, const char *dataset } fMode = kProofAnalysis; TString line; + TString proofProcessOpt; SetEventLoop(kTRUE); // Set the dataset flag TObject::SetBit(kUseDataSet); fTree = 0; - TChain *chain = 0; if (fGridHandler) { // Start proof analysis using the grid handler if (!fGridHandler->StartAnalysis(nentries, firstentry)) { @@ -1728,6 +1999,8 @@ Long64_t AliAnalysisManager::StartAnalysis(const char *type, const char *dataset } else { dataset = fGridHandler->GetProofDataSet(); } + + proofProcessOpt = fGridHandler->GetProofProcessOpt(); } if (!gROOT->GetListOfProofs() || !gROOT->GetListOfProofs()->GetEntries()) { @@ -1736,25 +2009,15 @@ Long64_t AliAnalysisManager::StartAnalysis(const char *type, const char *dataset } // Initialize locally all tasks - TIter next(fTasks); - AliAnalysisTask *task; - while ((task=(AliAnalysisTask*)next())) { - task->LocalInit(); - } - - line = Form("gProof->AddInput((TObject*)0x%lx);", (ULong_t)this); + RunLocalInit(); + + line = Form("gProof->AddInput((TObject*)%p);", this); gROOT->ProcessLine(line); Long_t retv; - if (chain) { -// chain->SetProof(); - cout << "===== RUNNING PROOF ANALYSIS " << GetName() << " ON TEST CHAIN " << chain->GetName() << endl; - retv = chain->Process("AliAnalysisSelector", "", nentries, firstentry); - } else { - line = Form("gProof->Process(\"%s\", \"AliAnalysisSelector\", \"\", %lld, %lld);", - dataset, nentries, firstentry); - cout << "===== RUNNING PROOF ANALYSIS " << GetName() << " ON DATASET " << dataset << endl; - retv = (Long_t)gROOT->ProcessLine(line); - } + line = Form("gProof->Process(\"%s\", \"AliAnalysisSelector\", \"%s\", %lld, %lld);", + dataset,proofProcessOpt.Data(), nentries, firstentry); + cout << "===== RUNNING PROOF ANALYSIS " << GetName() << " ON DATASET " << dataset << endl; + retv = (Long_t)gROOT->ProcessLine(line); return retv; } @@ -1918,6 +2181,12 @@ void AliAnalysisManager::ExecAnalysis(Option_t *option) static Long64_t nentries = 0; static TTree *lastTree = 0; static TStopwatch *timer = new TStopwatch(); + // Only the first call to Process will trigger a true Notify. Other Notify + // coming before is ignored. + if (!TObject::TestBit(AliAnalysisManager::kTrueNotify)) { + TObject::SetBit(AliAnalysisManager::kTrueNotify); + Notify(); + } if (fDebug > 0) printf("MGR: Processing event #%d\n", fNcalls); else { if (fTree && (fTree != lastTree)) { @@ -1925,15 +2194,16 @@ void AliAnalysisManager::ExecAnalysis(Option_t *option) lastTree = fTree; } if (!fNcalls) timer->Start(); - if (!fIsRemote && TObject::TestBit(kUseProgressBar)) ProgressBar("Processing event", fNcalls, nentries, timer, kFALSE); + if (!fIsRemote && TObject::TestBit(kUseProgressBar)) ProgressBar("Processing event", fNcalls, TMath::Min(fMaxEntries,nentries), timer, kFALSE); } + fIOTimer->Start(kTRUE); gROOT->cd(); TDirectory *cdir = gDirectory; Bool_t getsysInfo = ((fNSysInfo>0) && (fMode==kLocalAnalysis))?kTRUE:kFALSE; if (getsysInfo && ((fNcalls%fNSysInfo)==0)) AliSysInfo::AddStamp("Exec_start", (Int_t)fNcalls); if (!fInitOK) { Error("ExecAnalysis", "Analysis manager was not initialized !"); - cdir->cd(); + if (cdir) cdir->cd(); return; } fNcalls++; @@ -1949,7 +2219,7 @@ void AliAnalysisManager::ExecAnalysis(Option_t *option) if (!cont) cont = (AliAnalysisDataContainer*)fInputs->At(0); if (!cont) { Error("ExecAnalysis","Cannot execute analysis in TSelector mode without at least one top container"); - cdir->cd(); + if (cdir) cdir->cd(); return; } cont->SetData(fTree); // This will notify all consumers @@ -1965,18 +2235,26 @@ void AliAnalysisManager::ExecAnalysis(Option_t *option) // // Execute the tasks // TIter next1(cont->GetConsumers()); + fIOTimer->Stop(); + fIOTime += fIOTimer->RealTime(); + fCPUTimer->Start(kTRUE); TIter next1(fTopTasks); Int_t itask = 0; while ((task=(AliAnalysisTask*)next1())) { if (fDebug >1) { cout << " Executing task " << task->GetName() << endl; - } + } + if (fStatistics) fStatistics->StartTimer(GetTaskIndex(task), task->GetName(), task->ClassName()); task->ExecuteTask(option); + if (fStatistics) fStatistics->StopTimer(); gROOT->cd(); if (getsysInfo && ((fNcalls%fNSysInfo)==0)) AliSysInfo::AddStamp(task->ClassName(), fNcalls, itask, 1); itask++; } + fCPUTimer->Stop(); + fCPUTime += fCPUTimer->RealTime(); + fIOTimer->Start(kTRUE); // // Call FinishEvent() for optional output and MC services if (fInputEventHandler) fInputEventHandler ->FinishEvent(); @@ -1985,56 +2263,103 @@ void AliAnalysisManager::ExecAnalysis(Option_t *option) // Gather system information if requested if (getsysInfo && ((fNcalls%fNSysInfo)==0)) AliSysInfo::AddStamp("Handlers_FinishEvent",fNcalls, 1001, 1); - cdir->cd(); + if (cdir) cdir->cd(); + fIOTimer->Stop(); + fIOTime += fIOTimer->RealTime(); return; } // The event loop is not controlled by TSelector // // Call BeginEvent() for optional input/output and MC services + fIOTimer->Start(kTRUE); if (fInputEventHandler) fInputEventHandler ->BeginEvent(-1); if (fOutputEventHandler) fOutputEventHandler ->BeginEvent(-1); if (fMCtruthEventHandler) fMCtruthEventHandler->BeginEvent(-1); + fIOTimer->Stop(); + fIOTime += fIOTimer->RealTime(); gROOT->cd(); if (getsysInfo && ((fNcalls%fNSysInfo)==0)) AliSysInfo::AddStamp("Handlers_BeginEvent",fNcalls, 1000, 0); + fCPUTimer->Start(kTRUE); TIter next2(fTopTasks); while ((task=(AliAnalysisTask*)next2())) { task->SetActive(kTRUE); if (fDebug > 1) { cout << " Executing task " << task->GetName() << endl; } + if (fStatistics) fStatistics->StartTimer(GetTaskIndex(task), task->GetName(), task->ClassName()); task->ExecuteTask(option); + if (fStatistics) fStatistics->StopTimer(); gROOT->cd(); } + fCPUTimer->Stop(); + fCPUTime += fCPUTimer->RealTime(); // // Call FinishEvent() for optional output and MC services + fIOTimer->Start(kTRUE); if (fInputEventHandler) fInputEventHandler ->FinishEvent(); if (fOutputEventHandler) fOutputEventHandler ->FinishEvent(); if (fMCtruthEventHandler) fMCtruthEventHandler->FinishEvent(); if (getsysInfo && ((fNcalls%fNSysInfo)==0)) AliSysInfo::AddStamp("Handlers_FinishEvent",fNcalls, 1000, 1); - cdir->cd(); + if (cdir) cdir->cd(); + fIOTimer->Stop(); + fIOTime += fIOTimer->RealTime(); } +//______________________________________________________________________________ +Bool_t AliAnalysisManager::IsPipe(std::ostream &out) +{ +// Check if the stdout is connected to a pipe (C.Holm) + Bool_t ispipe = kFALSE; + out.seekp(0, std::ios_base::cur); + if (out.fail()) { + out.clear(); + if (errno == ESPIPE) ispipe = kTRUE; + } + return ispipe; +} + //______________________________________________________________________________ void AliAnalysisManager::SetInputEventHandler(AliVEventHandler* const handler) { // Set the input event handler and create a container for it. + Changed(); fInputEventHandler = handler; - 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); } //______________________________________________________________________________ void AliAnalysisManager::SetOutputEventHandler(AliVEventHandler* const handler) { // Set the input event handler and create a container for it. + Changed(); 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) { @@ -2135,14 +2460,14 @@ Bool_t AliAnalysisManager::ValidateOutputFiles() const file = TFile::Open(filename); if (!file || file->IsZombie() || file->TestBit(TFile::kRecovered)) { Error("ValidateOutputs", "Output file <%s> was not created or invalid", filename.Data()); - cdir->cd(); + if (cdir) cdir->cd(); return kFALSE; } file->Close(); openedFiles += filename; openedFiles += " "; } - cdir->cd(); + if (cdir) cdir->cd(); return kTRUE; } @@ -2160,10 +2485,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; @@ -2176,7 +2501,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; @@ -2184,11 +2512,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(); @@ -2217,8 +2543,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) { @@ -2252,8 +2588,8 @@ void AliAnalysisManager::DoLoadBranch(const char *name) fTable.Add(br); } if (br->GetReadEntry()==fCurrentEntry) return; - Int_t ret = br->GetEntry(GetCurrentEntry()); - if (ret<0) { + Long64_t readbytes = br->GetEntry(GetCurrentEntry()); + if (readbytes<0) { Error("DoLoadBranch", "Could not load entry %lld from branch %s",GetCurrentEntry(), name); if (crtEntry != fCurrentEntry) { CountEvent(1,0,1,0); @@ -2302,27 +2638,244 @@ void AliAnalysisManager::AddStatisticsMsg(const char *line) } //______________________________________________________________________________ -void AliAnalysisManager::WriteStatisticsMsg(Int_t nevents) +void AliAnalysisManager::WriteStatisticsMsg(Int_t) { -// Write the statistics message in a file named . // 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; - if (fStatistics) { - 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; - } else { - if (!nevents) return; - out.open(Form("%09d.stat", nevents), ios::out); - if (!fStatisticsMsg.IsNull()) out << fStatisticsMsg << endl; - } + AddStatisticsMsg(Form("Number of input events: %lld",fStatistics->GetNinput())); + AddStatisticsMsg(Form("Number of processed events: %lld",fStatistics->GetNprocessed())); + AddStatisticsMsg(Form("Number of failed events (I/O): %lld",fStatistics->GetNfailed())); + AddStatisticsMsg(Form("Number of accepted events for mask %s: %lld", AliAnalysisStatistics::GetMaskAsString(fStatistics->GetOfflineMask()), fStatistics->GetNaccepted())); + out.open(Form("%lld_%lld_%lld_%lld.stat",fStatistics->GetNinput(), + fStatistics->GetNprocessed(),fStatistics->GetNfailed(), + fStatistics->GetNaccepted()), ios::out); + out << fStatisticsMsg << endl; out.close(); } + +//______________________________________________________________________________ +const char* AliAnalysisManager::GetOADBPath() +{ +// returns the path of the OADB +// this static function just depends on environment variables + + static TString oadbPath; + + if (gSystem->Getenv("OADB_PATH")) + oadbPath = gSystem->Getenv("OADB_PATH"); + else if (gSystem->Getenv("ALICE_ROOT")) + oadbPath.Form("%s/OADB", gSystem->Getenv("ALICE_ROOT")); + else + ::Fatal("AliAnalysisManager::GetOADBPath", "Cannot figure out AODB path. Define ALICE_ROOT or OADB_PATH!"); + + return oadbPath; +} + +//______________________________________________________________________________ +void AliAnalysisManager::SetGlobalStr(const char *key, const char *value) +{ +// Define a custom string variable mapped to a global unique name. The variable +// can be then retrieved by a given analysis macro via GetGlobalStr(key). + AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); + if (!mgr) { + ::Error("AliAnalysisManager::SetGlobalStr", "No analysis manager defined"); + return; + } + Bool_t valid = kFALSE; + TString existing = AliAnalysisManager::GetGlobalStr(key, valid); + if (valid) { + ::Error("AliAnalysisManager::SetGlobalStr", "Global %s = %s already defined.", key, existing.Data()); + return; + } + mgr->GetGlobals()->Add(new TObjString(key), new TObjString(value)); +} + +//______________________________________________________________________________ +const char *AliAnalysisManager::GetGlobalStr(const char *key, Bool_t &valid) +{ +// Static method to retrieve a global variable defined via SetGlobalStr. + valid = kFALSE; + AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); + if (!mgr) return 0; + TObject *value = mgr->GetGlobals()->GetValue(key); + if (!value) return 0; + valid = kTRUE; + return value->GetName(); +} + +//______________________________________________________________________________ +void AliAnalysisManager::SetGlobalInt(const char *key, Int_t value) +{ +// Define a custom integer variable mapped to a global unique name. The variable +// can be then retrieved by a given analysis macro via GetGlobalInt(key). + AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); + if (!mgr) { + ::Error("AliAnalysisManager::SetGlobalStr", "No analysis manager defined"); + return; + } + Bool_t valid = kFALSE; + Int_t existing = AliAnalysisManager::GetGlobalInt(key, valid); + if (valid) { + ::Error("AliAnalysisManager::SetGlobalInt", "Global %s = %i already defined.", key, existing); + return; + } + mgr->GetGlobals()->Add(new TObjString(key), new TObjString(TString::Format("%i",value))); +} + +//______________________________________________________________________________ +Int_t AliAnalysisManager::GetGlobalInt(const char *key, Bool_t &valid) +{ +// Static method to retrieve a global variable defined via SetGlobalInt. + valid = kFALSE; + AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); + if (!mgr) return 0; + TObject *value = mgr->GetGlobals()->GetValue(key); + if (!value) return 0; + valid = kTRUE; + TString s = value->GetName(); + return s.Atoi(); +} + +//______________________________________________________________________________ +void AliAnalysisManager::SetGlobalDbl(const char *key, Double_t value) +{ +// Define a custom double precision variable mapped to a global unique name. The variable +// can be then retrieved by a given analysis macro via GetGlobalInt(key). + AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); + if (!mgr) { + ::Error("AliAnalysisManager::SetGlobalStr", "No analysis manager defined"); + return; + } + Bool_t valid = kFALSE; + Double_t existing = AliAnalysisManager::GetGlobalDbl(key, valid); + if (valid) { + ::Error("AliAnalysisManager::SetGlobalInt", "Global %s = %g already defined.", key, existing); + return; + } + mgr->GetGlobals()->Add(new TObjString(key), new TObjString(TString::Format("%f.16",value))); +} + +//______________________________________________________________________________ +Double_t AliAnalysisManager::GetGlobalDbl(const char *key, Bool_t &valid) +{ +// Static method to retrieve a global variable defined via SetGlobalDbl. + valid = kFALSE; + AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager(); + if (!mgr) return 0; + TObject *value = mgr->GetGlobals()->GetValue(key); + if (!value) return 0; + valid = kTRUE; + TString s = value->GetName(); + return s.Atof(); +} + +//______________________________________________________________________________ +void AliAnalysisManager::AddClassDebug(const char *className, Int_t debugLevel) +{ +// Sets Class debug level + + if (!fDebugOptions) { + fDebugOptions = new TObjArray(); + fDebugOptions->SetOwner(kTRUE); + } + + TNamed *debugOpt = (TNamed*)fDebugOptions->FindObject(className); + if (!debugOpt) { + AliInfo(TString::Format("Adding debug level %d for class %s",debugLevel,className).Data()); + fDebugOptions->Add(new TNamed(className,TString::Format("%d",debugLevel).Data())); + } else { + TString oldDebugStr = debugOpt->GetTitle(); + Int_t oldDebug = oldDebugStr.Atoi(); + if (debugLevel > oldDebug) { + AliWarning(TString::Format("Overwriting debug level to %d class %s, because it is higher then previously set (%d).",debugLevel,className,oldDebug).Data()); + debugOpt->SetTitle(TString::Format("%d",debugLevel).Data()); + } else { + AliWarning(TString::Format("Ignoring debug level to %d class %s, because it is smaller then previously set (%d).",debugLevel,className,oldDebug).Data()); + } + } +} + +//______________________________________________________________________________ +void AliAnalysisManager::ApplyDebugOptions() +{ +// Apply debug options + + if (!fDebugOptions) return; + + TIter next(fDebugOptions); + TNamed *debug; + TString debugLevel; + while ((debug=dynamic_cast(next()))) { + debugLevel = debug->GetTitle(); + AliInfo(TString::Format("Class=%s debulLevel=%d",debug->GetName(),debugLevel.Atoi()).Data()); + AliLog::SetClassDebugLevel(debug->GetName(), debugLevel.Atoi()); + } +} + +//______________________________________________________________________________ +Bool_t AliAnalysisManager::IsMacroLoaded(const char filename) +{ +// Check if a macro was loaded. + return fgMacroNames.Contains(filename); +} + +//______________________________________________________________________________ +Int_t AliAnalysisManager::LoadMacro(const char *filename, Int_t *error, Bool_t check) +{ +// Redirection of gROOT->LoadMacro which makes sure the same macro is not loaded +// twice + TString macroName = gSystem->BaseName(filename); + // Strip appended +, ++, +g, +O + Int_t index = macroName.Index("+"); + if (index>0) macroName.Remove(index); + if (fgMacroNames.Contains(macroName)) { + // Macro with the same name loaded already in this root session, do + // nothing + error = 0; + return 0; + } + Int_t ret = gROOT->LoadMacro(filename,error,check); + // In case of error return the error code + if (ret) return ret; + // Append the macro name to the loaded macros list + fgMacroNames += macroName; + fgMacroNames += " "; + return ret; +} + +//______________________________________________________________________________ +void AliAnalysisManager::Lock() +{ +// Security lock. This is to detect NORMAL user errors and not really to +// protect against intentional hacks. + if (fLocked) return; + fLocked = kTRUE; + if (fInputEventHandler) fInputEventHandler->Lock(); + if (fOutputEventHandler) fOutputEventHandler->Lock(); + if (fMCtruthEventHandler) fMCtruthEventHandler->Lock(); + Info("Lock","====== ANALYSIS MANAGER LOCKED ======"); +} + +//______________________________________________________________________________ +void AliAnalysisManager::UnLock() +{ +// Verbose unlocking. Hackers will be punished ;-) ... + if (!fLocked) return; + fLocked = kFALSE; + if (fInputEventHandler) fInputEventHandler->UnLock(); + if (fOutputEventHandler) fOutputEventHandler->UnLock(); + if (fMCtruthEventHandler) fMCtruthEventHandler->UnLock(); + Info("UnLock", "====== ANALYSIS MANAGER UNLOCKED ======"); +} + +//______________________________________________________________________________ +void AliAnalysisManager::Changed() +{ +// All critical setters pass through the Changed method that throws an exception +// in case the lock was set. + if (fLocked) Fatal("Changed","Critical setter called in locked mode"); +}