#include <cerrno>
#include <Riostream.h>
#include <TError.h>
+#include <TMap.h>
#include <TClass.h>
#include <TFile.h>
#include <TMath.h>
#include <TCanvas.h>
#include <TStopwatch.h>
+#include "AliLog.h"
#include "AliAnalysisSelector.h"
#include "AliAnalysisGrid.h"
#include "AliAnalysisTask.h"
fNSysInfo(0),
fMode(kLocalAnalysis),
fInitOK(kFALSE),
+ fMustClean(kFALSE),
fIsRemote(kFALSE),
fDebug(0),
fSpecialOutputLocation(""),
fMaxEntries(0),
fStatisticsMsg(),
fRequestedBranches(),
- fStatistics(0)
+ fStatistics(0),
+ fGlobals(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();
+ }
SetEventLoop(kTRUE);
- TObject::SetObjectStat(kFALSE);
}
//______________________________________________________________________________
fNSysInfo(0),
fMode(other.fMode),
fInitOK(other.fInitOK),
+ fMustClean(other.fMustClean),
fIsRemote(other.fIsRemote),
fDebug(other.fDebug),
fSpecialOutputLocation(""),
fMaxEntries(other.fMaxEntries),
fStatisticsMsg(other.fStatisticsMsg),
fRequestedBranches(other.fRequestedBranches),
- fStatistics(other.fStatistics)
+ fStatistics(other.fStatistics),
+ fGlobals(other.fGlobals)
{
// Copy constructor.
fTasks = new TObjArray(*other.fTasks);
fParamCont = new TObjArray(*other.fParamCont);
fgCommonFileName = "AnalysisResults.root";
fgAnalysisManager = this;
- TObject::SetObjectStat(kFALSE);
}
//______________________________________________________________________________
fStatisticsMsg = other.fStatisticsMsg;
fRequestedBranches = other.fRequestedBranches;
fStatistics = other.fStatistics;
+ fGlobals = new TMap();
}
return *this;
}
if (fMCtruthEventHandler) delete fMCtruthEventHandler;
if (fEventPool) delete fEventPool;
if (fgAnalysisManager==this) fgAnalysisManager = NULL;
- TObject::SetObjectStat(kTRUE);
+ if (fGlobals) {fGlobals->DeleteAll(); delete fGlobals;}
}
//______________________________________________________________________________
// 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;
}
// 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;
}
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();
}
gROOT->cd();
next1.Reset();
+ TString copiedFiles;
while ((output=(AliAnalysisDataContainer*)next1())) {
// Close all files at output
TDirectory *opwd = gDirectory;
// 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();
}
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)
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();
+ }
+ cdir->cd();
+ TObject::SetBit(kTasksInitialized, kTRUE);
+}
+
//______________________________________________________________________________
Long64_t AliAnalysisManager::StartAnalysis(const char *type, Long64_t nentries, Long64_t firstentry)
{
return -1;
}
if (!CheckTasks()) Fatal("StartAnalysis", "Not all needed libraries were loaded");
- if (fDebug > 1) printf("StartAnalysis %s\n",GetName());
+ 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;
// 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();
// 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:
}
// 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;
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)) {
{
// 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();
}
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();
+}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff