#include "AliAnalysisManager.h"
+#include <cerrno>
#include <Riostream.h>
#include <TError.h>
#include <TClass.h>
#include <TCanvas.h>
#include <TStopwatch.h>
+#include "AliLog.h"
#include "AliAnalysisSelector.h"
#include "AliAnalysisGrid.h"
#include "AliAnalysisTask.h"
fOutputs = new TObjArray();
fParamCont = new TObjArray();
SetEventLoop(kTRUE);
- TObject::SetObjectStat(kFALSE);
}
//______________________________________________________________________________
fParamCont = new TObjArray(*other.fParamCont);
fgCommonFileName = "AnalysisResults.root";
fgAnalysisManager = this;
- TObject::SetObjectStat(kFALSE);
}
//______________________________________________________________________________
if (fMCtruthEventHandler) delete fMCtruthEventHandler;
if (fEventPool) delete fEventPool;
if (fgAnalysisManager==this) fgAnalysisManager = NULL;
- TObject::SetObjectStat(kTRUE);
}
//______________________________________________________________________________
// alice data in alien.
// sim: /alice/sim/<production>/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;
}
// 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++;
}
// to the generated code, but the routine can be extended by the
// user if needed. The return value is currently not used.
if (!fTree) return kFALSE;
+ if (!TObject::TestBit(AliAnalysisManager::kTrueNotify)) return kFALSE;
fTable.Clear("nodelete"); // clearing the hash table may not be needed -> C.L.
if (fMode == kProofAnalysis) fIsRemote = kTRUE;
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;
}
//______________________________________________________________________________
-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
// 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;
}
}
}
// Write statistics message on the workers.
- WriteStatisticsMsg(fNcalls);
+ if (fStatistics) WriteStatisticsMsg(fNcalls);
if (fMode == kProofAnalysis) {
TIter next(fOutputs);
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();
}
delete allOutputs;
//Write statistics information on the client
- WriteStatisticsMsg(fNcalls);
+ if (fStatistics) WriteStatisticsMsg(fNcalls);
if (getsysInfo) {
TDirectory *crtdir = gDirectory;
TFile f("syswatch.root", "RECREATE");
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]");
}
}
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();
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
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;
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;
// 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)
fRequestedBranches += obj->GetName();
}
}
- if (arr) delete arr;
+ delete arr;
}
//______________________________________________________________________________
fTable.Add(br);
if (load && br->GetReadEntry()!=GetCurrentEntry()) br->GetEntry(GetCurrentEntry());
}
+ delete arr;
}
+//______________________________________________________________________________
+Bool_t AliAnalysisManager::CheckTasks() const
+{
+// Check consistency of tasks.
+ Int_t ntasks = fTasks->GetEntries();
+ if (!ntasks) {
+ Error("CheckTasks", "No tasks connected to the manager. This may be due to forgetting to compile the task or to load their library.");
+ return kFALSE;
+ }
+ // Get the pointer to AliAnalysisTaskSE::Class()
+ TClass *badptr = (TClass*)gROOT->ProcessLine("AliAnalysisTaskSE::Class()");
+ // Loop all tasks to check if their corresponding library was loaded
+ TIter next(fTasks);
+ TObject *obj;
+ while ((obj=next())) {
+ if (obj->IsA() == badptr) {
+ Error("CheckTasks", "##################\n \
+ Class for task %s NOT loaded. You probably forgot to load the library for this task (or compile it dynamically).\n###########################\n",obj->GetName());
+ return kFALSE;
+ }
+ }
+ return kTRUE;
+}
+
//______________________________________________________________________________
void AliAnalysisManager::PrintStatus(Option_t *option) const
{
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 (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;
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;
}
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)) {
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);
+ if (!fCommonInput) fCommonInput = CreateContainer("cAUTO_INPUT", TChain::Class(), AliAnalysisManager::kInputContainer);
}
//______________________________________________________________________________
{
// Set the input event handler and create a container for it.
fOutputEventHandler = handler;
- fCommonOutput = CreateContainer("cAUTO_OUTPUT", TTree::Class(), AliAnalysisManager::kOutputContainer, "default");
+ if (!fCommonOutput) fCommonOutput = CreateContainer("cAUTO_OUTPUT", TTree::Class(), AliAnalysisManager::kOutputContainer, "default");
fCommonOutput->SetSpecialOutput();
}
static Bool_t oneoftwo = kFALSE;
static Int_t nrefresh = 0;
static Int_t nchecks = 0;
+ static char lastChar = 0;
const char symbol[4] = {'-','\\','|','/'};
+ if (!lastChar) lastChar = (IsPipe(std::cerr))?'\r':'\n';
if (!refresh) {
nrefresh = 0;
if (!size) return;
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);
- fprintf(stderr, "[%6.2f %%] TIME %.2d:%.2d:%.2d ETA %.2d:%.2d:%.2d\r",
- percent, hours, minutes, seconds, rhour, rmin, rsec);
+ 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 %%]\r", percent);
+ else fprintf(stderr, "[%6.2f %%]%c", percent, lastChar);
if (refresh && oneoftwo) oname = nname;
if (owatch) owatch->Continue();
if (last) {
}
//______________________________________________________________________________
-void AliAnalysisManager::WriteStatisticsMsg(Int_t nevents)
+void AliAnalysisManager::WriteStatisticsMsg(Int_t)
{
-// Write the statistics message in a file named <nevents.stat>.
// If fStatistics is present, write the file in the format ninput_nprocessed_nfailed_naccepted.stat
static Bool_t done = kFALSE;
if (done) return;
done = kTRUE;
+ if (!fStatistics) return;
ofstream out;
- if (fStatistics) {
- AddStatisticsMsg(Form("Number of input events: %lld",fStatistics->GetNinput()));
- AddStatisticsMsg(Form("Number of processed events: %lld",fStatistics->GetNprocessed()));
- AddStatisticsMsg(Form("Number of failed events (I/O): %lld",fStatistics->GetNfailed()));
- AddStatisticsMsg(Form("Number of accepted events for mask %s: %lld", AliAnalysisStatistics::GetMaskAsString(fStatistics->GetOfflineMask()), fStatistics->GetNaccepted()));
- out.open(Form("%lld_%lld_%lld_%lld.stat",fStatistics->GetNinput(),
- fStatistics->GetNprocessed(),fStatistics->GetNfailed(),
- fStatistics->GetNaccepted()), ios::out);
- out << fStatisticsMsg << endl;
- } else {
- if (!nevents) return;
- out.open(Form("%09d.stat", nevents), ios::out);
- if (!fStatisticsMsg.IsNull()) out << fStatisticsMsg << endl;
- }
+ AddStatisticsMsg(Form("Number of input events: %lld",fStatistics->GetNinput()));
+ AddStatisticsMsg(Form("Number of processed events: %lld",fStatistics->GetNprocessed()));
+ AddStatisticsMsg(Form("Number of failed events (I/O): %lld",fStatistics->GetNfailed()));
+ AddStatisticsMsg(Form("Number of accepted events for mask %s: %lld", AliAnalysisStatistics::GetMaskAsString(fStatistics->GetOfflineMask()), fStatistics->GetNaccepted()));
+ out.open(Form("%lld_%lld_%lld_%lld.stat",fStatistics->GetNinput(),
+ fStatistics->GetNprocessed(),fStatistics->GetNfailed(),
+ fStatistics->GetNaccepted()), ios::out);
+ out << fStatisticsMsg << endl;
out.close();
}
+
+//______________________________________________________________________________
+const char* AliAnalysisManager::GetOADBPath()
+{
+// returns the path of the OADB
+// this static function just depends on environment variables
+
+ static TString oadbPath;
+
+ if (gSystem->Getenv("OADB_PATH"))
+ oadbPath = gSystem->Getenv("OADB_PATH");
+ else if (gSystem->Getenv("ALICE_ROOT"))
+ oadbPath.Form("%s/OADB", gSystem->Getenv("ALICE_ROOT"));
+ else
+ ::Fatal("AliAnalysisManager::GetOADBPath", "Cannot figure out AODB path. Define ALICE_ROOT or OADB_PATH!");
+
+ return oadbPath;
+}