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) return kFALSE;
fTree = tree;
if (fMode != kProofAnalysis) CreateReadCache();
- fTable.Rehash(100);
+ 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());
}
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;
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)
+Bool_t AliAnalysisManager::IsMacroLoaded(const char * filename)
{
// Check if a macro was loaded.
return fgMacroNames.Contains(filename);
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff