X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=ANALYSIS%2FAliAnalysisManager.cxx;h=93cbd6e2306d9e7dcbadf93667dee2ecb4beda02;hb=351a983151ee1c376912caf0fb95c1b254f82ed4;hp=e34b957b518ff992371ddeb17c27a68779abdcc5;hpb=dcc1f876236ec49e6c8593e792f438349fdbbed4;p=u%2Fmrichter%2FAliRoot.git diff --git a/ANALYSIS/AliAnalysisManager.cxx b/ANALYSIS/AliAnalysisManager.cxx index e34b957b518..93cbd6e2306 100644 --- a/ANALYSIS/AliAnalysisManager.cxx +++ b/ANALYSIS/AliAnalysisManager.cxx @@ -30,8 +30,11 @@ #include #include #include +#include #include #include +#include +#include #include #include #include @@ -41,6 +44,7 @@ #include #include +#include "AliLog.h" #include "AliAnalysisSelector.h" #include "AliAnalysisGrid.h" #include "AliAnalysisTask.h" @@ -51,60 +55,86 @@ #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), + fMCLoop(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); } //______________________________________________________________________________ @@ -119,7 +149,10 @@ AliAnalysisManager::AliAnalysisManager(const AliAnalysisManager& other) fNSysInfo(0), fMode(other.fMode), fInitOK(other.fInitOK), + fMustClean(other.fMustClean), fIsRemote(other.fIsRemote), + fLocked(other.fLocked), + fMCLoop(other.fMCLoop), fDebug(other.fDebug), fSpecialOutputLocation(""), fTasks(NULL), @@ -129,19 +162,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); @@ -153,7 +199,6 @@ AliAnalysisManager::AliAnalysisManager(const AliAnalysisManager& other) fParamCont = new TObjArray(*other.fParamCont); fgCommonFileName = "AnalysisResults.root"; fgAnalysisManager = this; - TObject::SetObjectStat(kFALSE); } //______________________________________________________________________________ @@ -172,6 +217,8 @@ AliAnalysisManager& AliAnalysisManager::operator=(const AliAnalysisManager& othe fMode = other.fMode; fInitOK = other.fInitOK; fIsRemote = other.fIsRemote; + fLocked = other.fLocked; + fMCLoop = other.fMCLoop; fDebug = other.fDebug; fTasks = new TObjArray(*other.fTasks); fTopTasks = new TObjArray(*other.fTopTasks); @@ -180,21 +227,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; } @@ -210,15 +270,70 @@ 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; +} + +//______________________________________________________________________________ +Bool_t AliAnalysisManager::EventLoop(Long64_t nevents) +{ +// Initialize an event loop where the data producer is the input handler +// The handler must implement MakeTree creating the tree of events (likely +// memory resident) and generate the current event in the method BeginEvent. +// If the tree is memory resident, the handler should never call TTree::Fill +// method. + cout << "===== RUNNING IN EVENT LOOP MODE: " << GetName() << endl; + if (!fInputEventHandler) { + Error("EventLoop", "No input handler: exiting"); + return kFALSE; + } + TTree *tree = new TTree("DummyTree", "Dummy tree for AliAnalysisManager::EventLoop"); + SetExternalLoop(kTRUE); + if (!Init(tree)) return kFALSE; + SlaveBegin(tree); + for (Long64_t iev=0; ievGetTree()->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; } //______________________________________________________________________________ @@ -236,27 +356,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; } @@ -323,7 +445,11 @@ Bool_t AliAnalysisManager::Init(TTree *tree) if (!fInitOK) InitAnalysis(); if (!fInitOK) return kFALSE; fTree = tree; - fTable.Rehash(100); + if (fMode != kProofAnalysis) CreateReadCache(); + else { + // cholm - here we should re-add to the table or branches + fTable.Clear(); + } AliAnalysisDataContainer *top = fCommonInput; if (!top) top = (AliAnalysisDataContainer*)fInputs->At(0); if (!top) { @@ -332,6 +458,7 @@ Bool_t AliAnalysisManager::Init(TTree *tree) } top->SetData(tree); CheckBranches(kFALSE); + fTable.Rehash(100); if (fDebug > 1) { printf("<-AliAnalysisManager::Init(%s)\n", tree->GetName()); } @@ -345,6 +472,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; @@ -409,11 +543,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"); } @@ -425,7 +568,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; @@ -434,12 +579,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; @@ -461,11 +613,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 @@ -484,18 +638,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; } @@ -505,6 +649,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; @@ -711,7 +869,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()); } @@ -720,6 +908,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; @@ -760,6 +949,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(); @@ -788,6 +978,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); } @@ -795,6 +987,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."); @@ -820,11 +1013,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"); } @@ -835,6 +1032,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; @@ -855,8 +1053,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(); } @@ -957,6 +1155,7 @@ void AliAnalysisManager::Terminate() } gROOT->cd(); next1.Reset(); + TString copiedFiles; while ((output=(AliAnalysisDataContainer*)next1())) { // Close all files at output TDirectory *opwd = gDirectory; @@ -964,14 +1163,20 @@ 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(); } @@ -1018,7 +1223,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]"); } } @@ -1075,7 +1280,11 @@ void AliAnalysisManager::Terminate() 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"); } //______________________________________________________________________________ @@ -1127,8 +1336,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 @@ -1146,8 +1355,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; @@ -1159,6 +1368,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; @@ -1175,6 +1389,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) @@ -1268,7 +1490,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) @@ -1421,13 +1643,39 @@ void AliAnalysisManager::CheckBranches(Bool_t load) Error("CheckBranches", "Could not find branch %s",obj->GetName()); continue; } + fTable.Add(br); } - 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 { @@ -1468,6 +1716,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) { @@ -1492,23 +1775,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; @@ -1516,39 +1804,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; @@ -1562,7 +1846,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"; @@ -1573,13 +1857,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: @@ -1591,6 +1869,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++; @@ -1636,7 +1919,7 @@ 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*)%p);", this); @@ -1647,7 +1930,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; @@ -1657,7 +1940,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 @@ -1665,31 +1948,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; @@ -1702,14 +1985,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; } @@ -1732,6 +2015,7 @@ 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); @@ -1748,6 +2032,8 @@ Long64_t AliAnalysisManager::StartAnalysis(const char *type, const char *dataset } else { dataset = fGridHandler->GetProofDataSet(); } + + proofProcessOpt = fGridHandler->GetProofProcessOpt(); } if (!gROOT->GetListOfProofs() || !gROOT->GetListOfProofs()->GetEntries()) { @@ -1756,17 +2042,13 @@ 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(); - } - + RunLocalInit(); + line = Form("gProof->AddInput((TObject*)%p);", this); gROOT->ProcessLine(line); Long_t retv; - line = Form("gProof->Process(\"%s\", \"AliAnalysisSelector\", \"\", %lld, %lld);", - dataset, nentries, firstentry); + 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; @@ -1932,6 +2214,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)) { @@ -1941,13 +2229,14 @@ void AliAnalysisManager::ExecAnalysis(Option_t *option) if (!fNcalls) timer->Start(); 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++; @@ -1963,7 +2252,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 @@ -1979,18 +2268,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(); @@ -1999,35 +2296,48 @@ 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(); } //______________________________________________________________________________ @@ -2047,16 +2357,18 @@ Bool_t AliAnalysisManager::IsPipe(std::ostream &out) 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); + 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(); } @@ -2181,14 +2493,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; } @@ -2268,7 +2580,7 @@ void AliAnalysisManager::ProgressBar(const char *opname, Long64_t current, Long6 Int_t full = Int_t(ocurrent > 0 ? time * (float(osize)/ocurrent) + .5 : 99*3600+59*60+59); - Int_t remain = full - time; + Int_t remain = Int_t(full - time); Int_t rsec = remain % 60; Int_t rmin = (remain / 60) % 60; Int_t rhour = (remain / 60 / 60); @@ -2309,8 +2621,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); @@ -2359,7 +2671,7 @@ void AliAnalysisManager::AddStatisticsMsg(const char *line) } //______________________________________________________________________________ -void AliAnalysisManager::WriteStatisticsMsg(Int_t nevents) +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; @@ -2395,3 +2707,208 @@ const char* AliAnalysisManager::GetOADBPath() 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"); +}