#include <TMap.h>
#include <TClass.h>
#include <TFile.h>
+#include <TTreeCache.h>
+#include <TEnv.h>
#include <TMath.h>
#include <TH1.h>
#include <TMethodCall.h>
#include "AliVEventPool.h"
#include "AliSysInfo.h"
#include "AliAnalysisStatistics.h"
+#include "AliVEvent.h"
+#include "AliHLTTestInputHandler.h"
using std::ofstream;
using std::ios;
AliAnalysisManager *AliAnalysisManager::fgAnalysisManager = NULL;
TString AliAnalysisManager::fgCommonFileName = "";
+TString AliAnalysisManager::fgMacroNames = "";
Int_t AliAnalysisManager::fPBUpdateFreq = 1;
//______________________________________________________________________________
fMustClean(kFALSE),
fIsRemote(kFALSE),
fLocked(kFALSE),
+ fMCLoop(kFALSE),
fDebug(0),
fSpecialOutputLocation(""),
fTasks(0),
fInputs(0),
fOutputs(0),
fParamCont(0),
+ fExchangeCont(0),
fDebugOptions(0),
fFileDescriptors(new TObjArray()),
fCurrentDescriptor(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),
- fGlobals(0)
+ fGlobals(0),
+ fIOTimer(0),
+ fCPUTimer(0),
+ fInitTimer(0),
+ fIOTime(0),
+ fCPUTime(0),
+ fInitTime(0)
{
// Default constructor.
fgAnalysisManager = this;
fInputs = new TObjArray();
fOutputs = new TObjArray();
fParamCont = new TObjArray();
+ fExchangeCont = new TObjArray();
fGlobals = new TMap();
- }
+ }
+ fIOTimer = new TStopwatch();
+ fCPUTimer = new TStopwatch();
+ fInitTimer = new TStopwatch();
SetEventLoop(kTRUE);
}
fMustClean(other.fMustClean),
fIsRemote(other.fIsRemote),
fLocked(other.fLocked),
+ fMCLoop(other.fMCLoop),
fDebug(other.fDebug),
fSpecialOutputLocation(""),
fTasks(NULL),
fInputs(NULL),
fOutputs(NULL),
fParamCont(NULL),
+ fExchangeCont(NULL),
fDebugOptions(NULL),
fFileDescriptors(new TObjArray()),
fCurrentDescriptor(0),
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),
- fGlobals(other.fGlobals)
+ 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);
fInputs = new TObjArray(*other.fInputs);
fOutputs = new TObjArray(*other.fOutputs);
fParamCont = new TObjArray(*other.fParamCont);
+ fExchangeCont = new TObjArray(*other.fExchangeCont);
fgCommonFileName = "AnalysisResults.root";
fgAnalysisManager = this;
}
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);
fInputs = new TObjArray(*other.fInputs);
fOutputs = new TObjArray(*other.fOutputs);
fParamCont = new TObjArray(*other.fParamCont);
+ fExchangeCont = new TObjArray(*other.fExchangeCont);
fDebugOptions = NULL;
fFileDescriptors = new TObjArray();
fCurrentDescriptor = 0;
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;
}
{
// Destructor.
if (fTasks) {fTasks->Delete(); delete fTasks;}
- if (fTopTasks) delete fTopTasks;
- if (fZombies) delete fZombies;
+ delete fTopTasks;
+ delete fZombies;
if (fContainers) {fContainers->Delete(); delete fContainers;}
- 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;
+ delete fInputs;
+ delete fOutputs;
+ delete fParamCont;
+ delete fExchangeCont;
+ delete fDebugOptions;
+ delete fGridHandler;
+ delete fInputEventHandler;
+ delete fOutputEventHandler;
+ delete fMCtruthEventHandler;
+ delete fEventPool;
if (fgAnalysisManager==this) fgAnalysisManager = NULL;
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
+ if (!fAutoBranchHandling && !fRequestedBranches.IsNull()) {
+ TObjArray *arr = fRequestedBranches.Tokenize(",");
+ TIter next(arr);
+ TObject *obj;
+ while ((obj=next()))
+ fTree->AddBranchToCache(obj->GetName(),kTRUE); //<<< add requested branches to cache
+ delete arr;
+ } else {
+ fTree->AddBranchToCache("*", kTRUE); //<<< add all branches to 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; iev<nevents; iev++)
+ ExecAnalysis();
+ TList dummyList;
+ PackOutput(&dummyList);
+ fIsRemote = kTRUE;
+ Terminate();
+ return kTRUE;
+}
+
//______________________________________________________________________________
Int_t AliAnalysisManager::GetEntry(Long64_t entry, Int_t getall)
{
fCurrentEntry = entry;
if (!fAutoBranchHandling)
return 123456789;
- if (!fTree) return -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;
}
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) {
}
top->SetData(tree);
CheckBranches(kFALSE);
+ fTable.Rehash(100);
if (fDebug > 1) {
printf("<-AliAnalysisManager::Init(%s)\n", tree->GetName());
}
// 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;
}
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");
}
// 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;
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());
task->Notify();
if (fDebug > 1) printf("<-AliAnalysisManager::Notify()\n");
+ fIOTimer->Stop();
+ fIOTime += fIOTimer->RealTime();
return kTRUE;
}
// 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";
- std::ofstream out;
- out.open(fFileInfoLog, std::ios::out);
+ out.open(fFileInfoLog, std::ios::app);
if (out.bad()) Error("SavePrimitive", "Bad file name: %s", fFileInfoLog.Data());
else {
TIter nextflog(fFileDescriptors);
}
}
}
+ 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());
}
{
// 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;
cont->ImportData(wrap);
}
if (cdir) cdir->cd();
+ fIOTimer->Stop();
+ fIOTime += fIOTimer->RealTime();
if (fDebug > 1) printf("<-AliAnalysisManager::ImportWrappers(): %d containers imported\n", icont);
}
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.");
// 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");
}
// 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;
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();
}
out.open("outputs_valid", ios::out);
out.close();
}
- if (cdir) 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");
}
//______________________________________________________________________________
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)
}
break;
case kExchangeContainer:
+ cont->SetExchange(kTRUE);
+ fExchangeCont->Add(cont);
+ cont->SetDataOwned(kFALSE); // data owned by the publisher
break;
}
return cont;
Error("CheckBranches", "Could not find branch %s",obj->GetName());
continue;
}
+ fTable.Add(br);
}
- fTable.Add(br);
if (load && br->GetReadEntry()!=GetCurrentEntry()) {
br->GetEntry(GetCurrentEntry());
}
Bool_t getsysInfo = ((fNSysInfo>0) && (fMode==kLocalAnalysis))?kTRUE:kFALSE;
if (getsysInfo)
Info("PrintStatus", "System information will be collected each %lld events", fNSysInfo);
- TIter next(fTopTasks);
+ AliAnalysisDataContainer *cont = fCommonInput;
+ if (!cont) cont = (AliAnalysisDataContainer*)fInputs->At(0);
+ printf("=== TOP CONTAINER:\n");
+ cont->PrintContainer(option,0);
+ // Reset "touched" flag
+ TIter next(fContainers);
+ while ((cont = (AliAnalysisDataContainer*)next())) cont->SetTouched(kFALSE);
+ TIter nextt(fTasks);
AliAnalysisTask *task;
- while ((task=(AliAnalysisTask*)next()))
- task->PrintTask(option);
+ while ((task=(AliAnalysisTask*)nextt()))
+ task->SetActive(kFALSE);
if (!fAutoBranchHandling && !fRequestedBranches.IsNull())
printf("Requested input branches:\n%s\n", fRequestedBranches.Data());
void AliAnalysisManager::ResetAnalysis()
{
// Reset all execution flags and clean containers.
- CleanContainers();
+ TIter nextTask(fTasks);
+ AliAnalysisTask *task;
+ while ((task=(AliAnalysisTask*)nextTask())) {
+ // Clean all tasks
+ task->Reset();
+ }
+// CleanContainers();
}
//______________________________________________________________________________
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<TChain*>(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)
{
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;
}
fMode = kProofAnalysis;
TString line;
+ TString proofProcessOpt;
SetEventLoop(kTRUE);
// Set the dataset flag
TObject::SetBit(kUseDataSet);
} else {
dataset = fGridHandler->GetProofDataSet();
}
+
+ proofProcessOpt = fGridHandler->GetProofProcessOpt();
}
if (!gROOT->GetListOfProofs() || !gROOT->GetListOfProofs()->GetEntries()) {
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;
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;
}
fNcalls++;
AliAnalysisTask *task;
+ // Reset the analysis
+ ResetAnalysis();
// Check if the top tree is active.
if (fTree) {
if (getsysInfo && ((fNcalls%fNSysInfo)==0))
AliSysInfo::AddStamp("Handlers_BeginEventGroup",fNcalls, 1002, 0);
TIter next(fTasks);
- // De-activate all tasks
- while ((task=(AliAnalysisTask*)next())) task->SetActive(kFALSE);
+ // De-activate all tasks (not needed anymore after ResetAnalysis
+// while ((task=(AliAnalysisTask*)next())) task->SetActive(kFALSE);
AliAnalysisDataContainer *cont = fCommonInput;
if (!cont) cont = (AliAnalysisDataContainer*)fInputs->At(0);
if (!cont) {
if (cdir) cdir->cd();
return;
}
- cont->SetData(fTree); // This will notify all consumers
- Long64_t entry = fTree->GetTree()->GetReadEntry();
+ cont->SetData(fTree); // This set activity for all tasks reading only from the top container
+ Long64_t entry = fTree->GetTree()->GetReadEntry();
//
// Call BeginEvent() for optional input/output and MC services
if (fInputEventHandler) fInputEventHandler ->BeginEvent(entry);
//
// 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) {
+ 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();
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();
if (getsysInfo && ((fNcalls%fNSysInfo)==0))
AliSysInfo::AddStamp("Handlers_FinishEvent",fNcalls, 1001, 1);
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);
if (cdir) cdir->cd();
+ fIOTimer->Stop();
+ fIOTime += fIOTimer->RealTime();
}
//______________________________________________________________________________
fDebugOptions->SetOwner(kTRUE);
}
- // substracting DebugOffset, beacuse of AliLog::SetClassDebugLevel()
- debugLevel -= AliLog::kDebug-1;
-
TNamed *debugOpt = (TNamed*)fDebugOptions->FindObject(className);
if (!debugOpt) {
- AliInfo(TString::Format("Adding debug level %d for class %s",debugLevel+AliLog::kDebug-1,className).Data());
+ 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+AliLog::kDebug-1,className,oldDebug+AliLog::kDebug-1).Data());
+ 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+AliLog::kDebug-1,className,oldDebug+AliLog::kDebug-1).Data());
+ AliWarning(TString::Format("Ignoring debug level to %d class %s, because it is smaller then previously set (%d).",debugLevel,className,oldDebug).Data());
}
}
}
TString debugLevel;
while ((debug=dynamic_cast<TNamed*>(next()))) {
debugLevel = debug->GetTitle();
- AliInfo(TString::Format("ApplyDebugOptions : Class=%s debulLevel=%d",debug->GetName(),debugLevel.Atoi()+AliLog::kDebug-1).Data());
+ 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()
{
// in case the lock was set.
if (fLocked) Fatal("Changed","Critical setter called in locked mode");
}
+
+//______________________________________________________________________________
+void AliAnalysisManager::InitInputData(AliVEvent* esdEvent, AliESDfriend* esdFriend)
+{
+
+// Method to propagte to all the connected tasks the HLT event.
+// This method expects that the input hanlder is of type HLT, should
+// not be used otherwise
+
+ if (fInputEventHandler) {
+ TString classInputHandler = fInputEventHandler->ClassName();
+ if (classInputHandler.Contains("HLT")){
+ TObjArray* arrTasks = GetTasks();
+ fInputEventHandler->InitTaskInputData(esdEvent, esdFriend, arrTasks);
+ }
+ else {
+ Fatal("PropagateHLTEvent", "Input Handler not of type HLT, we cannot use this method!");
+ }
+ }
+ else {
+ Fatal("PropagateHLTEvent", "Input Handler not found, we cannot use this method!");
+ }
+}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff