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),
fExtraFiles(),
fFileInfoLog(),
fAutoBranchHandling(kTRUE),
- fAsyncReading(kTRUE), // default prefetching on
+ fAsyncReading(kFALSE), // default prefetching on
fTable(),
fRunFromPath(0),
fNcalls(0),
fMustClean(other.fMustClean),
fIsRemote(other.fIsRemote),
fLocked(other.fLocked),
+ fMCLoop(other.fMCLoop),
fDebug(other.fDebug),
fSpecialOutputLocation(""),
fTasks(NULL),
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);
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()));
+ 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
}
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();
if (!fInitOK) InitAnalysis();
if (!fInitOK) return kFALSE;
fTree = tree;
- CreateReadCache();
- 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());
}
// Init timer should be already started
// Apply debug options
ApplyDebugOptions();
- if (fCacheSize && fMCtruthEventHandler) fMCtruthEventHandler->SetCacheSize(fCacheSize);
+ 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;
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 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();
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)
Error("CheckBranches", "Could not find branch %s",obj->GetName());
continue;
}
+ fTable.Add(br);
}
- fTable.Add(br);
if (load && br->GetReadEntry()!=GetCurrentEntry()) {
br->GetEntry(GetCurrentEntry());
}
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;
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);
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();
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()
{
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff