#include <TClass.h>
#include <TFile.h>
+#include <TKey.h>
#include <TMethodCall.h>
#include <TChain.h>
#include <TSystem.h>
#include <TCanvas.h>
#include "AliAnalysisSelector.h"
+#include "AliAnalysisGrid.h"
#include "AliAnalysisTask.h"
#include "AliAnalysisDataContainer.h"
#include "AliAnalysisDataSlot.h"
fInputEventHandler(NULL),
fOutputEventHandler(NULL),
fMCtruthEventHandler(NULL),
- fEventPool(NULL),
+ fEventPool(NULL),
fCurrentEntry(-1),
fNSysInfo(0),
fMode(kLocalAnalysis),
fContainers(NULL),
fInputs(NULL),
fOutputs(NULL),
- fSelector(NULL)
+ fSelector(NULL),
+ fGridHandler(NULL)
{
// Default constructor.
fgAnalysisManager = this;
fContainers(NULL),
fInputs(NULL),
fOutputs(NULL),
- fSelector(NULL)
+ fSelector(NULL),
+ fGridHandler(NULL)
{
// Copy constructor.
fTasks = new TObjArray(*other.fTasks);
fInputs = new TObjArray(*other.fInputs);
fOutputs = new TObjArray(*other.fOutputs);
fSelector = NULL;
+ fGridHandler = NULL;
fgAnalysisManager = this;
}
return *this;
if (fContainers) {fContainers->Delete(); delete fContainers;}
if (fInputs) delete fInputs;
if (fOutputs) delete fOutputs;
+ if (fGridHandler) delete fGridHandler;
if (fgAnalysisManager==this) fgAnalysisManager = NULL;
}
// When running with PROOF SlaveBegin() is called on each slave server.
// The tree argument is deprecated (on PROOF 0 is passed).
if (fDebug > 0) printf("->AliAnalysisManager::SlaveBegin()\n");
-
+ static Bool_t isCalled = kFALSE;
+ TDirectory *curdir = gDirectory;
+ // Call SlaveBegin only once in case of mixing
+ if (isCalled && fMode==kMixingAnalysis) return;
// Call Init of EventHandler
if (fOutputEventHandler) {
if (fMode == kProofAnalysis) {
- fOutputEventHandler->Init("proof");
+ TIter nextout(fOutputs);
+ AliAnalysisDataContainer *c_aod;
+ while ((c_aod=(AliAnalysisDataContainer*)nextout())) if (!strcmp(c_aod->GetFileName(),"default")) break;
+ if (c_aod && c_aod->IsSpecialOutput()) {
+ // Merging via files
+ if (fDebug > 1) printf(" Initializing special output file %s...\n", fOutputEventHandler->GetOutputFileName());
+ OpenProofFile(fOutputEventHandler->GetOutputFileName(), "RECREATE");
+ c_aod->SetFile(gFile);
+ fOutputEventHandler->Init("proofspecial");
+ } else {
+ // Merging in memory
+ fOutputEventHandler->Init("proof");
+ }
} else {
fOutputEventHandler->Init("local");
}
fMCtruthEventHandler->Init("local");
}
}
-
+ if (curdir) curdir->cd();
+
TIter next(fTasks);
AliAnalysisTask *task;
// Call CreateOutputObjects for all tasks
while ((task=(AliAnalysisTask*)next())) {
- TDirectory *curdir = gDirectory;
+ curdir = gDirectory;
task->CreateOutputObjects();
if (curdir) curdir->cd();
}
+ isCalled = kTRUE;
if (fDebug > 0) printf("<-AliAnalysisManager::SlaveBegin()\n");
}
if (fMode == kProofAnalysis) {
TIter next(fOutputs);
AliAnalysisDataContainer *output;
+ Bool_t isManagedByHandler = kFALSE;
while ((output=(AliAnalysisDataContainer*)next())) {
// Do not consider outputs of post event loop tasks
+ isManagedByHandler = kFALSE;
if (output->GetProducer()->IsPostEventLoop()) continue;
+ const char *filename = output->GetFileName();
+ if (!(strcmp(filename, "default")) && fOutputEventHandler) {
+ isManagedByHandler = kTRUE;
+ filename = fOutputEventHandler->GetOutputFileName();
+ }
// Check if data was posted to this container. If not, issue an error.
- if (!output->GetData() ) {
+ if (!output->GetData() && !isManagedByHandler) {
Error("PackOutput", "No data for output container %s. Forgot to PostData ?\n", output->GetName());
continue;
}
if (!output->IsSpecialOutput()) {
// Normal outputs
- const char *filename = output->GetFileName();
- if (!(strcmp(filename, "default"))) {
- if (fOutputEventHandler) filename = fOutputEventHandler->GetOutputFileName();
- }
- if (strlen(filename)) {
- // File resident outputs
+ if (strlen(filename) && !isManagedByHandler) {
+ // File resident outputs
TFile *file = output->GetFile();
// Backup current folder
TDirectory *opwd = gDirectory;
// Clear file list to release object ownership to user.
file->Clear();
// Save data to file, then close.
- output->GetData()->Write();
+ if (output->GetData()->InheritsFrom(TCollection::Class())) {
+ // If data is a collection, we set the name of the collection
+ // as the one of the container and we save as a single key.
+ TCollection *coll = (TCollection*)output->GetData();
+ coll->SetName(output->GetName());
+ coll->Write(output->GetName(), TObject::kSingleKey);
+ } else {
+ if (output->GetData()->InheritsFrom(TTree::Class())) {
+ TTree *tree = (TTree*)output->GetData();
+ tree->SetDirectory(file);
+ tree->AutoSave();
+ } else {
+ output->GetData()->Write();
+ }
+ }
if (fDebug > 1) printf("PackOutput %s: memory merge, file resident output\n", output->GetName());
if (fDebug > 2) {
printf(" file %s listing content:\n", filename);
if (opwd) opwd->cd();
} else {
// Memory-resident outputs
- if (fDebug > 1) printf("PackOutput %s: memory merge memory resident output\n", output->GetName());
+ if (fDebug > 1) printf("PackOutput %s: memory merge memory resident output\n", filename);
}
- AliAnalysisDataWrapper *wrap = output->ExportData();
- // Output wrappers must delete data after merging (AG 13/11/07)
- wrap->SetDeleteData(kTRUE);
+ AliAnalysisDataWrapper *wrap = 0;
+ if (isManagedByHandler) {
+ wrap = new AliAnalysisDataWrapper(fOutputEventHandler->GetTree());
+ wrap->SetName(output->GetName());
+ }
+ else wrap =output->ExportData();
+ // Output wrappers must NOT delete data after merging - the user owns them
+ wrap->SetDeleteData(kFALSE);
target->Add(wrap);
- }
+ } else {
// Special outputs
- if (output->IsSpecialOutput()) {
TDirectory *opwd = gDirectory;
TFile *file = output->GetFile();
+ if (fDebug > 1 && file) printf("PackOutput %s: file merge, special output\n", output->GetName());
+ if (isManagedByHandler) {
+ // Terminate IO for files managed by the output handler
+ if (file) file->Write();
+ if (file && fDebug > 2) {
+ printf(" handled file %s listing content:\n", file->GetName());
+ file->ls();
+ }
+ fOutputEventHandler->TerminateIO();
+ continue;
+ }
+
if (!file) {
AliAnalysisTask *producer = output->GetProducer();
Error("PackOutput",
}
file->cd();
// Release object ownership to users after writing data to file
- if (output->GetData()) output->GetData()->Write();
+ if (output->GetData()->InheritsFrom(TCollection::Class())) {
+ // If data is a collection, we set the name of the collection
+ // as the one of the container and we save as a single key.
+ TCollection *coll = (TCollection*)output->GetData();
+ coll->SetName(output->GetName());
+ coll->Write(output->GetName(), TObject::kSingleKey);
+ } else {
+ if (output->GetData()->InheritsFrom(TTree::Class())) {
+ TTree *tree = (TTree*)output->GetData();
+ tree->SetDirectory(file);
+ tree->AutoSave();
+ } else {
+ output->GetData()->Write();
+ }
+ }
file->Clear();
if (fDebug > 2) {
printf(" file %s listing content:\n", output->GetFileName());
file->ls();
- }
+ }
+ TString outFilename = file->GetName();
file->Close();
// Restore current directory
if (opwd) opwd->cd();
Int_t gid = gROOT->ProcessLine("gProofServ->GetGroupId();");
remote += Form("%s_%d_", gSystem->HostName(), gid);
remote += output->GetFileName();
- TFile::Cp(output->GetFileName(), remote.Data());
+ TFile::Cp ( outFilename.Data(), remote.Data() );
} else {
// No special location specified-> use TProofOutputFile as merging utility
// The file at this output slot must be opened in CreateOutputObjects
AliAnalysisDataContainer *cont;
AliAnalysisDataWrapper *wrap;
Int_t icont = 0;
+ Bool_t inGrid = (fMode == kGridAnalysis)?kTRUE:kFALSE;
while ((cont=(AliAnalysisDataContainer*)next())) {
- if (cont->GetProducer()->IsPostEventLoop()) continue;
- if (cont->IsSpecialOutput()) {
- if (strlen(fSpecialOutputLocation.Data())) continue;
- // Copy merged file from PROOF scratch space
- if (fDebug > 1)
- printf(" Copying file %s from PROOF scratch space\n", cont->GetFileName());
- Bool_t gotit = TFile::Cp(Form("root://lxb6045.cern.ch:11094//pool/scratch/%s",cont->GetFileName()),
- cont->GetFileName());
- if (!gotit) {
- Error("ImportWrappers", "Could not get file %s from proof scratch space", cont->GetFileName());
- }
+ wrap = 0;
+ if (cont->GetProducer()->IsPostEventLoop() && !inGrid) continue;
+ const char *filename = cont->GetFileName();
+ Bool_t isManagedByHandler = kFALSE;
+ if (!(strcmp(filename, "default")) && fOutputEventHandler) {
+ isManagedByHandler = kTRUE;
+ filename = fOutputEventHandler->GetOutputFileName();
+ }
+ if (cont->IsSpecialOutput() || inGrid) {
+ if (strlen(fSpecialOutputLocation.Data()) && !isManagedByHandler) continue;
+ // Copy merged file from PROOF scratch space.
+ // In case of grid the files are already in the current directory.
+ if (!inGrid) {
+ char full_path[512];
+ char ch_url[512];
+ TObject *pof = source->FindObject(filename);
+ if (!pof || !pof->InheritsFrom("TProofOutputFile")) {
+ Error("ImportWrappers", "TProofOutputFile object not found in output list for container %s", cont->GetName());
+ continue;
+ }
+ gROOT->ProcessLine(Form("sprintf((char*)0x%lx, \"%%s\", ((TProofOutputFile*)0x%lx)->GetOutputFileName();)", full_path, pof));
+ gROOT->ProcessLine(Form("sprintf((char*)0x%lx, \"%%s\", gProof->GetUrl();)", ch_url));
+ TString clientUrl(ch_url);
+ TString full_path_str(full_path);
+ if (clientUrl.Contains("localhost")){
+ TObjArray* array = full_path_str.Tokenize ( "//" );
+ TObjString *strobj = ( TObjString *)array->At(1);
+ TObjArray* arrayPort = strobj->GetString().Tokenize ( ":" );
+ TObjString *strobjPort = ( TObjString *) arrayPort->At(1);
+ full_path_str.ReplaceAll(strobj->GetString().Data(),"localhost:PORT");
+ full_path_str.ReplaceAll(":PORT",Form(":%s",strobjPort->GetString().Data()));
+ if (fDebug > 1) Info("ImportWrappers","Using tunnel from %s to %s",full_path_str.Data(),filename);
+ }
+ if (fDebug > 1)
+ printf(" Copying file %s from PROOF scratch space\n", full_path_str.Data());
+ Bool_t gotit = TFile::Cp(full_path_str.Data(), filename);
+ if (!gotit) {
+ Error("ImportWrappers", "Could not get file %s from proof scratch space", cont->GetFileName());
+ continue;
+ }
+ }
// Normally we should connect data from the copied file to the
// corresponding output container, but it is not obvious how to do this
// automatically if several objects in file...
- continue;
+ TFile *f = TFile::Open(filename, "READ");
+ if (!f) {
+ Error("ImportWrappers", "Cannot open file %s in read-only mode", filename);
+ continue;
+ }
+ TObject *obj = 0;
+ // Try to fetch first a list object having the container name.
+ obj = f->Get(cont->GetName());
+ if (!obj) {
+ // Fetch first object from file having the container type.
+ TIter nextkey(f->GetListOfKeys());
+ TKey *key;
+ while ((key=(TKey*)nextkey())) {
+ obj = f->Get(key->GetName());
+ if (obj && obj->IsA()->InheritsFrom(cont->GetType())) break;
+ }
+ }
+ if (!obj) {
+ Error("ImportWrappers", "Could not find object for container %s in file %s", cont->GetName(), filename);
+ continue;
+ }
+ wrap = new AliAnalysisDataWrapper(obj);
+ wrap->SetDeleteData(kFALSE);
}
- wrap = (AliAnalysisDataWrapper*)source->FindObject(cont->GetName());
+ if (!wrap) wrap = (AliAnalysisDataWrapper*)source->FindObject(cont->GetName());
if (!wrap) {
Error("ImportWrappers","Container %s not found in analysis output !", cont->GetName());
continue;
icont++;
if (fDebug > 1) {
printf(" Importing data for container %s", cont->GetName());
- if (strlen(cont->GetFileName())) printf(" -> file %s\n", cont->GetFileName());
+ if (strlen(filename)) printf(" -> file %s\n", filename);
else printf("\n");
}
cont->ImportData(wrap);
// Call Terminate() for tasks
while ((task=(AliAnalysisTask*)next())) task->Terminate();
//
- if (fInputEventHandler) fInputEventHandler ->TerminateIO();
- if (fOutputEventHandler) fOutputEventHandler ->TerminateIO();
- if (fMCtruthEventHandler) fMCtruthEventHandler->TerminateIO();
TIter next1(fOutputs);
AliAnalysisDataContainer *output;
while ((output=(AliAnalysisDataContainer*)next1())) {
- if (!output->GetData()) continue;
- // Close all files at output
+ // Special outputs or grid files have the files already closed and written.
+ if (fMode == kGridAnalysis) continue;
+ if (output->IsSpecialOutput()&&(fMode == kProofAnalysis)) continue;
const char *filename = output->GetFileName();
if (!(strcmp(filename, "default"))) {
if (fOutputEventHandler) filename = fOutputEventHandler->GetOutputFileName();
+ TFile *aodfile = (TFile*)gROOT->GetListOfFiles()->FindObject(filename);
+ if (aodfile) {
+ if (fDebug > 1) printf("Writing output handler file: %s\n", filename);
+ aodfile->Write();
+ continue;
+ }
}
if (!strlen(filename)) continue;
+ if (!output->GetData()) continue;
TFile *file = output->GetFile();
TDirectory *opwd = gDirectory;
- if (file) {
- file->cd();
- } else {
- file = new TFile(filename, "RECREATE");
- if (file->IsZombie()) continue;
- output->SetFile(file);
- }
+ file = (TFile*)gROOT->GetListOfFiles()->FindObject(filename);
+ if (!file) file = new TFile(filename, "RECREATE");
+ if (file->IsZombie()) continue;
+ output->SetFile(file);
+ file->cd();
if (fDebug > 1) printf(" writing output data %s to file %s\n", output->GetData()->GetName(), file->GetName());
- output->GetData()->Write();
- file->Close();
+ if (output->GetData()->InheritsFrom(TCollection::Class())) {
+ // If data is a collection, we set the name of the collection
+ // as the one of the container and we save as a single key.
+ TCollection *coll = (TCollection*)output->GetData();
+ coll->SetName(output->GetName());
+ coll->Write(output->GetName(), TObject::kSingleKey);
+ } else {
+ if (output->GetData()->InheritsFrom(TTree::Class())) {
+ TTree *tree = (TTree*)output->GetData();
+ tree->SetDirectory(file);
+ tree->AutoSave();
+ } else {
+ output->GetData()->Write();
+ }
+ }
+ if (opwd) opwd->cd();
+ }
+ next1.Reset();
+ while ((output=(AliAnalysisDataContainer*)next1())) {
+ // Close all files at output
+ TDirectory *opwd = gDirectory;
+ if (output->GetFile()) output->GetFile()->Close();
if (opwd) opwd->cd();
}
+ if (fInputEventHandler) fInputEventHandler ->TerminateIO();
+ if (fOutputEventHandler) fOutputEventHandler ->TerminateIO();
+ if (fMCtruthEventHandler) fMCtruthEventHandler->TerminateIO();
+
Bool_t getsysInfo = ((fNSysInfo>0) && (fMode==kLocalAnalysis))?kTRUE:kFALSE;
if (getsysInfo) {
TDirectory *cdir = gDirectory;
//______________________________________________________________________________
void AliAnalysisManager::StartAnalysis(const char *type, TTree *tree, Long64_t nentries, Long64_t firstentry)
{
-// Start analysis for this manager. Analysis task can be: LOCAL, PROOF or GRID.
-// Process nentries starting from firstentry
+// Start analysis for this manager. Analysis task can be: LOCAL, PROOF, GRID or
+// MIX. Process nentries starting from firstentry
if (!fInitOK) {
Error("StartAnalysis","Analysis manager was not initialized !");
return;
TString anaType = type;
anaType.ToLower();
fMode = kLocalAnalysis;
- if (tree) {
- if (anaType.Contains("proof")) fMode = kProofAnalysis;
- else if (anaType.Contains("grid")) fMode = kGridAnalysis;
- }
+ Bool_t runlocalinit = kTRUE;
+ if (anaType.Contains("file")) runlocalinit = kFALSE;
+ if (anaType.Contains("proof")) fMode = kProofAnalysis;
+ else if (anaType.Contains("grid")) fMode = kGridAnalysis;
+ else if (anaType.Contains("mix")) fMode = kMixingAnalysis;
+
if (fMode == kGridAnalysis) {
- Warning("StartAnalysis", "GRID analysis mode not implemented. Running local.");
- fMode = kLocalAnalysis;
+ if (!fGridHandler) {
+ Error("StartAnalysis", "Cannot start grid analysis without a grid handler.");
+ Info("===", "Add an AliAnalysisAlien object as plugin for this manager and configure it.");
+ return;
+ }
+ // 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();
+ }
+ fGridHandler->StartAnalysis(nentries, firstentry);
+
+ // Terminate grid analysis
+ if (fGridHandler->GetRunMode() == AliAnalysisGrid::kOffline) return;
+ cout << "===== MERGING OUTPUTS REGISTERED BY YOUR ANALYSIS JOB: " << GetName() << endl;
+ if (!fGridHandler->MergeOutputs()) {
+ // Return if outputs could not be merged or if it alien handler
+ // was configured for offline mode or local testing.
+ return;
+ }
+ ImportWrappers(NULL);
+ Terminate();
+ return;
}
char line[256];
SetEventLoop(kFALSE);
// Enable event loop mode if a tree was provided
- if (tree) SetEventLoop(kTRUE);
+ if (tree || fMode==kMixingAnalysis) SetEventLoop(kTRUE);
TChain *chain = 0;
TString ttype = "TTree";
- if (tree->IsA() == TChain::Class()) {
+ if (tree && tree->IsA() == TChain::Class()) {
chain = (TChain*)tree;
if (!chain || !chain->GetListOfFiles()->First()) {
Error("StartAnalysis", "Cannot process null or empty chain...");
ttype = "TChain";
}
- // Initialize locally all tasks
+ // Initialize locally all tasks (happens for all modes)
TIter next(fTasks);
AliAnalysisTask *task;
- while ((task=(AliAnalysisTask*)next())) {
- task->LocalInit();
- }
+ if (runlocalinit) {
+ while ((task=(AliAnalysisTask*)next())) {
+ task->LocalInit();
+ }
+ }
switch (fMode) {
case kLocalAnalysis:
}
// Run tree-based analysis via AliAnalysisSelector
cout << "===== RUNNING LOCAL ANALYSIS " << GetName() << " ON TREE " << tree->GetName() << endl;
- sprintf(line, "AliAnalysisSelector *selector = new AliAnalysisSelector((AliAnalysisManager*)0x%lx);",(ULong_t)this);
- gROOT->ProcessLine(line);
- sprintf(line, "((%s*)0x%lx)->Process(selector, \"\",%lld, %lld);",ttype.Data(),(ULong_t)tree, nentries, firstentry);
- gROOT->ProcessLine(line);
+ fSelector = new AliAnalysisSelector(this);
+ tree->Process(fSelector, "", nentries, firstentry);
break;
case kProofAnalysis:
if (!gROOT->GetListOfProofs() || !gROOT->GetListOfProofs()->GetEntries()) {
break;
case kGridAnalysis:
Warning("StartAnalysis", "GRID analysis mode not implemented. Running local.");
+ break;
+ case kMixingAnalysis:
+ // Run event mixing analysis
+ if (!fEventPool) {
+ Error("StartAnalysis", "Cannot run event mixing without event pool");
+ return;
+ }
+ cout << "===== RUNNING EVENT MIXING ANALYSIS " << GetName() << endl;
+ fSelector = new AliAnalysisSelector(this);
+ while ((chain=fEventPool->GetNextChain())) {
+ next.Reset();
+ // Call NotifyBinChange for all tasks
+ while ((task=(AliAnalysisTask*)next()))
+ if (!task->IsPostEventLoop()) task->NotifyBinChange();
+ chain->Process(fSelector);
+ }
+ PackOutput(fSelector->GetOutputList());
+ Terminate();
}
}
TString anaType = type;
anaType.ToLower();
if (!anaType.Contains("proof")) {
- Error("Cannot process datasets in %s mode. Try PROOF.", type);
+ Error("StartAnalysis", "Cannot process datasets in %s mode. Try PROOF.", type);
return;
}
fMode = kProofAnalysis;
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff