// Author: Andrei Gheata, 31/05/2006
//==============================================================================
-// AliAnalysysManager - Manager analysis class. Allows creation of several
+// AliAnalysisManager - Manager analysis class. Allows creation of several
// analysis tasks and data containers storing their input/output. Allows
// connecting/chaining tasks via shared data containers. Serializes the current
// event for all tasks depending only on initial input data.
//
//==============================================================================
-#include <Riostream.h>
+#include "AliAnalysisManager.h"
+#include <cerrno>
+#include <Riostream.h>
#include <TError.h>
#include <TClass.h>
#include <TFile.h>
-//#include <TKey.h>
#include <TMath.h>
#include <TH1.h>
#include <TMethodCall.h>
#include "AliVEventHandler.h"
#include "AliVEventPool.h"
#include "AliSysInfo.h"
-#include "AliAnalysisManager.h"
+#include "AliAnalysisStatistics.h"
ClassImp(AliAnalysisManager)
AliAnalysisManager *AliAnalysisManager::fgAnalysisManager = NULL;
TString AliAnalysisManager::fgCommonFileName = "";
+Int_t AliAnalysisManager::fPBUpdateFreq = 1;
//______________________________________________________________________________
AliAnalysisManager::AliAnalysisManager(const char *name, const char *title)
fExtraFiles(""),
fAutoBranchHandling(kTRUE),
fTable(),
- fRunFromPath(0)
+ fRunFromPath(0),
+ fNcalls(0),
+ fMaxEntries(0),
+ fStatisticsMsg(),
+ fRequestedBranches(),
+ fStatistics(0)
{
// Default constructor.
fgAnalysisManager = this;
fExtraFiles(),
fAutoBranchHandling(other.fAutoBranchHandling),
fTable(),
- fRunFromPath(0)
+ fRunFromPath(0),
+ fNcalls(other.fNcalls),
+ fMaxEntries(other.fMaxEntries),
+ fStatisticsMsg(other.fStatisticsMsg),
+ fRequestedBranches(other.fRequestedBranches),
+ fStatistics(other.fStatistics)
{
// Copy constructor.
fTasks = new TObjArray(*other.fTasks);
fAutoBranchHandling = other.fAutoBranchHandling;
fTable.Clear("nodelete");
fRunFromPath = other.fRunFromPath;
+ fNcalls = other. fNcalls;
+ fMaxEntries = other.fMaxEntries;
+ fStatisticsMsg = other.fStatisticsMsg;
+ fRequestedBranches = other.fRequestedBranches;
+ fStatistics = other.fStatistics;
}
return *this;
}
// Read one entry of the tree or a whole branch.
fCurrentEntry = entry;
if (!fAutoBranchHandling)
- return entry;
- return fTree ? fTree->GetTree()->GetEntry(entry, getall) : 0;
+ return 123456789;
+ return fTree ? fTree->GetTree()->GetEntry(entry, getall) : -1;
}
//______________________________________________________________________________
return kFALSE;
}
top->SetData(tree);
+ CheckBranches(kFALSE);
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");
+ if (!CheckTasks()) Fatal("SlaveBegin", "Not all needed libraries were loaded");
static Bool_t isCalled = kFALSE;
Bool_t init = kFALSE;
Bool_t initOK = kTRUE;
// 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++;
}
gROOT->cd();
if (fDebug > 1) printf("<-FinishTaskOutput: task %s\n", task->GetName());
}
- }
+ }
+ // Write statistics message on the workers.
+ if (fStatistics) WriteStatisticsMsg(fNcalls);
if (fMode == kProofAnalysis) {
TIter next(fOutputs);
// Try to fetch first an object having the container name.
obj = gDirectory->Get(cont->GetName());
if (!obj) {
- Warning("ImportWrappers", "Could not import object for container %s in file %s:%s.\n Object will not be available in Terminate()",
- cont->GetName(), filename, cont->GetFolderName());
+ Warning("ImportWrappers", "Could not import object of type:%s for container %s in file %s:%s.\n Object will not be available in Terminate(). Try if possible to name the output object as the container (%s) or to embed it in a TList",
+ cont->GetType()->GetName(), cont->GetName(), filename, cont->GetFolderName(), cont->GetName());
continue;
}
wrap = new AliAnalysisDataWrapper(obj);
if (opwd) opwd->cd();
}
delete allOutputs;
-
+ //Write statistics information on the client
+ if (fStatistics) WriteStatisticsMsg(fNcalls);
if (getsysInfo) {
TDirectory *crtdir = gDirectory;
TFile f("syswatch.root", "RECREATE");
hist = (TH1*)gPad->GetListOfPrimitives()->FindObject("htemp");
if (hist) {
hist->SetTitle(Form("%s: Exec dVM[kB]/event", task->GetName()));
- hist->GetYaxis()->SetTitle("deltaVM [kB]");
+ hist->GetYaxis()->SetTitle("deltaVM [MB]");
}
}
// Draw the plot of deltaVM for CreateOutputObjects for all tasks
hist = (TH1*)gPad->GetListOfPrimitives()->FindObject("htemp");
if (hist) {
hist->SetTitle("Memory in CreateOutputObjects()");
- hist->GetYaxis()->SetTitle("deltaVM [kB]");
+ hist->GetYaxis()->SetTitle("deltaVM [MB]");
hist->GetXaxis()->SetTitle("task");
}
// draw the plot of deltaVM for Terminate for all tasks
hist = (TH1*)gPad->GetListOfPrimitives()->FindObject("htemp");
if (hist) {
hist->SetTitle("Memory in Terminate()");
- hist->GetYaxis()->SetTitle("deltaVM [kB]");
+ hist->GetYaxis()->SetTitle("deltaVM [MB]");
hist->GetXaxis()->SetTitle("task");
}
// Full VM profile
hist = (TH1*)gPad->GetListOfPrimitives()->FindObject("htemp");
if (hist) {
hist->SetTitle("Virtual memory");
- hist->GetYaxis()->SetTitle("VM [kB]");
+ hist->GetYaxis()->SetTitle("VM [MB]");
}
canvas->Modified();
}
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();
Error("InitAnalysis", "Wrong container %s : a file name MUST be provided for special outputs", cont->GetName());
return kFALSE;
}
- }
+ }
+ // Initialize requested branch list if needed
+ if (!fAutoBranchHandling) {
+ next.Reset();
+ while ((task=(AliAnalysisTask*)next())) {
+ if (!task->HasBranches()) {
+ Error("InitAnalysis", "Manual branch loading requested but task %s of type %s does not define branches.\nUse: fBranchNames = \"ESD:br1,br2,...,brN AOD:bra1,bra2,...,braM\"",
+ task->GetName(), task->ClassName());
+ return kFALSE;
+ }
+ if (!fInputEventHandler || !strlen(fInputEventHandler->GetDataType())) {
+ Error("InitAnalysis", "Manual branch loading requested but no input handler defined or handler does not define data type.");
+ return kFALSE;
+ }
+ TString taskbranches;
+ task->GetBranches(fInputEventHandler->GetDataType(), taskbranches);
+ if (taskbranches.IsNull()) {
+ Error("InitAnalysis", "Manual branch loading requested but task %s of type %s does not define branches of type %s:",
+ task->GetName(), task->ClassName(), fInputEventHandler->GetDataType());
+ return kFALSE;
+ }
+ AddBranches(taskbranches);
+ }
+ }
fInitOK = kTRUE;
return kTRUE;
}
+//______________________________________________________________________________
+void AliAnalysisManager::AddBranches(const char *branches)
+{
+// Add branches to the existing fRequestedBranches.
+ TString br(branches);
+ TObjArray *arr = br.Tokenize(",");
+ TIter next(arr);
+ TObject *obj;
+ while ((obj=next())) {
+ if (!fRequestedBranches.Contains(obj->GetName())) {
+ if (!fRequestedBranches.IsNull()) fRequestedBranches += ",";
+ fRequestedBranches += obj->GetName();
+ }
+ }
+ delete arr;
+}
+
+//______________________________________________________________________________
+void AliAnalysisManager::CheckBranches(Bool_t load)
+{
+// The method checks the input branches to be loaded during the analysis.
+ if (fAutoBranchHandling || fRequestedBranches.IsNull() || !fTree) return;
+ TObjArray *arr = fRequestedBranches.Tokenize(",");
+ TIter next(arr);
+ TObject *obj;
+ while ((obj=next())) {
+ TBranch *br = dynamic_cast<TBranch*>(fTable.FindObject(obj->GetName()));
+ if (!br) {
+ br = fTree->GetBranch(obj->GetName());
+ if (!br) {
+ Error("CheckBranches", "Could not find branch %s",obj->GetName());
+ continue;
+ }
+ }
+ fTable.Add(br);
+ if (load && br->GetReadEntry()!=GetCurrentEntry()) br->GetEntry(GetCurrentEntry());
+ }
+ delete arr;
+}
+
+//______________________________________________________________________________
+Bool_t AliAnalysisManager::CheckTasks() const
+{
+// Check consistency of tasks.
+ // 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
{
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(" ");
+ }
+ }
}
//______________________________________________________________________________
cdir->cd();
return -1;
}
+ if (!CheckTasks()) Fatal("StartAnalysis", "Not all needed libraries were loaded");
if (fDebug > 1) printf("StartAnalysis %s\n",GetName());
+ fMaxEntries = nentries;
fIsRemote = kFALSE;
TString anaType = type;
anaType.ToLower();
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++;
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();
// 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)) {
task->LocalInit();
}
- line = Form("gProof->AddInput((TObject*)0x%lx);", (ULong_t)this);
+ 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\", \"\", %lld, %lld);",
+ dataset, nentries, firstentry);
+ cout << "===== RUNNING PROOF ANALYSIS " << GetName() << " ON DATASET " << dataset << endl;
+ retv = (Long_t)gROOT->ProcessLine(line);
return retv;
}
TObject *pof = fSelector->GetOutputList()->FindObject(filename);
if (pof) {
// Get the actual file
- line = Form("((TProofOutputFile*)0x%lx)->GetFileName();", (ULong_t)pof);
+ line = Form("((TProofOutputFile*)%p)->GetFileName();", pof);
filename = (const char*)gROOT->ProcessLine(line);
if (fDebug>1) {
printf("File: %s already booked via TProofOutputFile\n", filename.Data());
printf(" == proof file name: %s", f->GetName());
}
// Add to proof output list
- line = Form("((TList*)0x%lx)->Add(pf);",(ULong_t)fSelector->GetOutputList());
+ line = Form("((TList*)%p)->Add(pf);",fSelector->GetOutputList());
if (fDebug > 1) printf("=== %s\n", line.Data());
gROOT->ProcessLine(line);
}
void AliAnalysisManager::ExecAnalysis(Option_t *option)
{
// Execute analysis.
- static Long64_t ncalls = 0;
static Long64_t nentries = 0;
static TTree *lastTree = 0;
static TStopwatch *timer = new TStopwatch();
- if (fDebug > 0) printf("MGR: Processing event #%lld\n", ncalls);
+ if (fDebug > 0) printf("MGR: Processing event #%d\n", fNcalls);
else {
if (fTree && (fTree != lastTree)) {
nentries += fTree->GetEntries();
lastTree = fTree;
}
- if (!ncalls) timer->Start();
- if (!fIsRemote && TObject::TestBit(kUseProgressBar)) ProgressBar("Processing event", ncalls, nentries, timer, kFALSE);
+ if (!fNcalls) timer->Start();
+ if (!fIsRemote && TObject::TestBit(kUseProgressBar)) ProgressBar("Processing event", fNcalls, TMath::Min(fMaxEntries,nentries), timer, kFALSE);
}
gROOT->cd();
TDirectory *cdir = gDirectory;
Bool_t getsysInfo = ((fNSysInfo>0) && (fMode==kLocalAnalysis))?kTRUE:kFALSE;
- if (getsysInfo && ((ncalls%fNSysInfo)==0)) AliSysInfo::AddStamp("Exec_start", (Int_t)ncalls);
- ncalls++;
+ if (getsysInfo && ((fNcalls%fNSysInfo)==0)) AliSysInfo::AddStamp("Exec_start", (Int_t)fNcalls);
if (!fInitOK) {
Error("ExecAnalysis", "Analysis manager was not initialized !");
cdir->cd();
return;
}
+ fNcalls++;
AliAnalysisTask *task;
// Check if the top tree is active.
if (fTree) {
- if (getsysInfo && ((ncalls%fNSysInfo)==0))
- AliSysInfo::AddStamp("Handlers_BeginEventGroup",(Int_t)ncalls, 1002, 0);
+ if (getsysInfo && ((fNcalls%fNSysInfo)==0))
+ AliSysInfo::AddStamp("Handlers_BeginEventGroup",fNcalls, 1002, 0);
TIter next(fTasks);
// De-activate all tasks
while ((task=(AliAnalysisTask*)next())) task->SetActive(kFALSE);
if (fOutputEventHandler) fOutputEventHandler ->BeginEvent(entry);
if (fMCtruthEventHandler) fMCtruthEventHandler->BeginEvent(entry);
gROOT->cd();
- if (getsysInfo && ((ncalls%fNSysInfo)==0))
- AliSysInfo::AddStamp("Handlers_BeginEvent",(Int_t)ncalls, 1000, 0);
+ if (getsysInfo && ((fNcalls%fNSysInfo)==0))
+ AliSysInfo::AddStamp("Handlers_BeginEvent",fNcalls, 1000, 0);
//
// Execute the tasks
// TIter next1(cont->GetConsumers());
}
task->ExecuteTask(option);
gROOT->cd();
- if (getsysInfo && ((ncalls%fNSysInfo)==0))
- AliSysInfo::AddStamp(task->ClassName(),(Int_t)ncalls, itask, 1);
+ if (getsysInfo && ((fNcalls%fNSysInfo)==0))
+ AliSysInfo::AddStamp(task->ClassName(), fNcalls, itask, 1);
itask++;
}
//
if (fOutputEventHandler) fOutputEventHandler ->FinishEvent();
if (fMCtruthEventHandler) fMCtruthEventHandler->FinishEvent();
// Gather system information if requested
- if (getsysInfo && ((ncalls%fNSysInfo)==0))
- AliSysInfo::AddStamp("Handlers_FinishEvent",(Int_t)ncalls, 1001, 1);
+ if (getsysInfo && ((fNcalls%fNSysInfo)==0))
+ AliSysInfo::AddStamp("Handlers_FinishEvent",fNcalls, 1001, 1);
cdir->cd();
return;
}
if (fOutputEventHandler) fOutputEventHandler ->BeginEvent(-1);
if (fMCtruthEventHandler) fMCtruthEventHandler->BeginEvent(-1);
gROOT->cd();
- if (getsysInfo && ((ncalls%fNSysInfo)==0))
- AliSysInfo::AddStamp("Handlers_BeginEvent",(Int_t)ncalls, 1000, 0);
+ if (getsysInfo && ((fNcalls%fNSysInfo)==0))
+ AliSysInfo::AddStamp("Handlers_BeginEvent",fNcalls, 1000, 0);
TIter next2(fTopTasks);
while ((task=(AliAnalysisTask*)next2())) {
task->SetActive(kTRUE);
if (fInputEventHandler) fInputEventHandler ->FinishEvent();
if (fOutputEventHandler) fOutputEventHandler ->FinishEvent();
if (fMCtruthEventHandler) fMCtruthEventHandler->FinishEvent();
- if (getsysInfo && ((ncalls%fNSysInfo)==0))
- AliSysInfo::AddStamp("Handlers_FinishEvent",(Int_t)ncalls, 1000, 1);
+ if (getsysInfo && ((fNcalls%fNSysInfo)==0))
+ AliSysInfo::AddStamp("Handlers_FinishEvent",fNcalls, 1000, 1);
cdir->cd();
}
+//______________________________________________________________________________
+Bool_t AliAnalysisManager::IsPipe(std::ostream &out)
+{
+// Check if the stdout is connected to a pipe (C.Holm)
+ Bool_t ispipe = kFALSE;
+ out.seekp(0, std::ios_base::cur);
+ if (out.fail()) {
+ out.clear();
+ if (errno == ESPIPE) ispipe = kTRUE;
+ }
+ return ispipe;
+}
+
//______________________________________________________________________________
void AliAnalysisManager::SetInputEventHandler(AliVEventHandler* const handler)
{
// Set the input event handler and create a container for it.
fInputEventHandler = handler;
fCommonInput = CreateContainer("cAUTO_INPUT", TChain::Class(), AliAnalysisManager::kInputContainer);
-// Warning("SetInputEventHandler", " An automatic input container for the input chain was created.\nPlease use: mgr->GetCommonInputContainer() to access it.");
}
//______________________________________________________________________________
fOutputEventHandler = handler;
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)
{
// Copy a file from the location specified ina the wrapper with the same name from the source list.
char fullPath[512];
char chUrl[512];
+ char tmp[1024];
TObject *pof = source->FindObject(filename);
if (!pof || !pof->InheritsFrom("TProofOutputFile")) {
Error("GetFileFromWrapper", "TProofOutputFile object not found in output list for file %s", filename);
return kFALSE;
}
- gROOT->ProcessLine(Form("sprintf((char*)0x%lx, \"%%s\", ((TProofOutputFile*)0x%lx)->GetOutputFileName();)", (ULong_t)fullPath, (ULong_t)pof));
- gROOT->ProcessLine(Form("sprintf((char*)0x%lx, \"%%s\", gProof->GetUrl();)", (ULong_t)chUrl));
+ gROOT->ProcessLine(Form("sprintf((char*)%p, \"%%s\", ((TProofOutputFile*)%p)->GetOutputFileName());", fullPath, pof));
+ gROOT->ProcessLine(Form("sprintf((char*)%p, \"%%s\", gProof->GetUrl());",chUrl));
TString clientUrl(chUrl);
TString fullPath_str(fullPath);
if (clientUrl.Contains("localhost")){
delete arrayPort;
delete array;
}
+ else if (clientUrl.Contains("__lite__")) {
+ // Special case for ProofLite environement - get file info and copy.
+ gROOT->ProcessLine(Form("sprintf((char*)%p,\"%%s\",((TProofOutputFile*)%p)->GetDir());", tmp, pof));
+ fullPath_str = Form("%s/%s", tmp, fullPath);
+ }
if (fDebug > 1)
- Info("GetFileFromWrapper","Copying file %s from PROOF scratch space", fullPath_str.Data());
+ Info("GetFileFromWrapper","Copying file %s from PROOF scratch space to %s", fullPath_str.Data(),filename);
Bool_t gotit = TFile::Cp(fullPath_str.Data(), filename);
if (!gotit)
Error("GetFileFromWrapper", "Could not get file %s from proof scratch space", filename);
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;
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;
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();
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) {
void AliAnalysisManager::DoLoadBranch(const char *name)
{
// Get tree and load branch if needed.
+ static Long64_t crtEntry = -100;
- if (!fTree)
+ if (fAutoBranchHandling || !fTree)
return;
TBranch *br = dynamic_cast<TBranch*>(fTable.FindObject(name));
}
fTable.Add(br);
}
- if (br->GetReadEntry()==GetCurrentEntry())
- return;
- br->GetEntry(GetCurrentEntry());
+ if (br->GetReadEntry()==fCurrentEntry) return;
+ Int_t ret = br->GetEntry(GetCurrentEntry());
+ if (ret<0) {
+ Error("DoLoadBranch", "Could not load entry %lld from branch %s",GetCurrentEntry(), name);
+ if (crtEntry != fCurrentEntry) {
+ CountEvent(1,0,1,0);
+ crtEntry = fCurrentEntry;
+ }
+ } else {
+ if (crtEntry != fCurrentEntry) {
+ CountEvent(1,1,0,0);
+ crtEntry = fCurrentEntry;
+ }
+ }
+}
+
+//______________________________________________________________________________
+void AliAnalysisManager::AddStatisticsTask(UInt_t offlineMask)
+{
+// Add the statistics task to the manager.
+ if (fStatistics) {
+ Info("AddStatisticsTask", "Already added");
+ return;
+ }
+ TString line = Form("AliAnalysisTaskStat::AddToManager(%u);", offlineMask);
+ gROOT->ProcessLine(line);
+}
+
+//______________________________________________________________________________
+void AliAnalysisManager::CountEvent(Int_t ninput, Int_t nprocessed, Int_t nfailed, Int_t naccepted)
+{
+// Bookkeep current event;
+ if (!fStatistics) return;
+ fStatistics->AddInput(ninput);
+ fStatistics->AddProcessed(nprocessed);
+ fStatistics->AddFailed(nfailed);
+ fStatistics->AddAccepted(naccepted);
+}
+
+//______________________________________________________________________________
+void AliAnalysisManager::AddStatisticsMsg(const char *line)
+{
+// Add a line in the statistics message. If available, the statistics message is written
+// at the end of the SlaveTerminate phase on workers AND at the end of Terminate
+// on the client.
+ if (!strlen(line)) return;
+ if (!fStatisticsMsg.IsNull()) fStatisticsMsg += "\n";
+ fStatisticsMsg += line;
+}
+
+//______________________________________________________________________________
+void AliAnalysisManager::WriteStatisticsMsg(Int_t)
+{
+// If fStatistics is present, write the file in the format ninput_nprocessed_nfailed_naccepted.stat
+ static Bool_t done = kFALSE;
+ if (done) return;
+ done = kTRUE;
+ if (!fStatistics) return;
+ ofstream out;
+ AddStatisticsMsg(Form("Number of input events: %lld",fStatistics->GetNinput()));
+ AddStatisticsMsg(Form("Number of processed events: %lld",fStatistics->GetNprocessed()));
+ AddStatisticsMsg(Form("Number of failed events (I/O): %lld",fStatistics->GetNfailed()));
+ AddStatisticsMsg(Form("Number of accepted events for mask %s: %lld", AliAnalysisStatistics::GetMaskAsString(fStatistics->GetOfflineMask()), fStatistics->GetNaccepted()));
+ out.open(Form("%lld_%lld_%lld_%lld.stat",fStatistics->GetNinput(),
+ fStatistics->GetNprocessed(),fStatistics->GetNfailed(),
+ fStatistics->GetNaccepted()), ios::out);
+ out << fStatisticsMsg << endl;
+ out.close();
+}
+
+//______________________________________________________________________________
+const char* AliAnalysisManager::GetOADBPath()
+{
+// returns the path of the OADB
+// this static function just depends on environment variables
+
+ static TString oadbPath;
+
+ if (gSystem->Getenv("OADB_PATH"))
+ oadbPath = gSystem->Getenv("OADB_PATH");
+ else if (gSystem->Getenv("ALICE_ROOT"))
+ oadbPath.Form("%s/OADB", gSystem->Getenv("ALICE_ROOT"));
+ else
+ ::Fatal("AliAnalysisManager::GetOADBPath", "Cannot figure out AODB path. Define ALICE_ROOT or OADB_PATH!");
+
+ return oadbPath;
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff