if (strlen(filename) && !isManagedByHandler) {
// Backup current folder
TDirectory *opwd = gDirectory;
- // File resident outputs
- TFile *file = AliAnalysisManager::OpenFile(output, "RECREATE", kTRUE);
+ // File resident outputs.
+ // Check first if the file exists.
+ TString open_option = "RECREATE";
+ if (!gSystem->AccessPathName(output->GetFileName())) open_option = "UPDATE";
+ TFile *file = AliAnalysisManager::OpenFile(output, open_option, kTRUE);
// Clear file list to release object ownership to user.
file->Clear();
// Save data to file, then close.
if (fDebug > 1) printf("PackOutput %s: special output\n", output->GetName());
if (isManagedByHandler) {
// Terminate IO for files managed by the output handler
- if (file) file->Write();
+ // file->Write() moved to AOD handler (A.G. 11.01.10)
+// if (file) file->Write();
if (file && fDebug > 2) {
printf(" handled file %s listing content:\n", file->GetName());
file->ls();
}
}
//
+ if (fInputEventHandler) fInputEventHandler ->TerminateIO();
+ if (fOutputEventHandler) fOutputEventHandler ->TerminateIO();
+ if (fMCtruthEventHandler) fMCtruthEventHandler->TerminateIO();
TIter next1(fOutputs);
+ TString handlerFile = "";
+ if (fOutputEventHandler) {
+ handlerFile = fOutputEventHandler->GetOutputFileName();
+ }
while ((output=(AliAnalysisDataContainer*)next1())) {
// Special outputs or grid files have the files already closed and written.
if (fMode == kGridAnalysis) continue;
if (output->IsSpecialOutput() || output->IsRegisterDataset()) 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;
- }
- }
+ TString open_option = "RECREATE";
+ if (!(strcmp(filename, "default"))) continue;
if (!strlen(filename)) continue;
if (!output->GetData()) continue;
TDirectory *opwd = gDirectory;
TFile *file = output->GetFile();
if (!file) file = (TFile*)gROOT->GetListOfFiles()->FindObject(filename);
- if (!file) file = new TFile(filename, "RECREATE");
+ if (!file) {
+ printf("Terminate : handlerFile = %s, filename = %s\n",handlerFile.Data(),filename);
+ //if (handlerFile == filename && !gSystem->AccessPathName(filename)) open_option = "UPDATE";
+ if (!gSystem->AccessPathName(filename)) open_option = "UPDATE";
+ file = new TFile(filename, open_option);
+ }
if (file->IsZombie()) {
Error("Terminate", "Cannot open output file %s", filename);
continue;
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)
+Long64_t AliAnalysisManager::StartAnalysis(const char *type, TTree *tree, Long64_t nentries, Long64_t 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;
+ return -1;
}
if (fDebug > 0) printf("StartAnalysis %s\n",GetName());
TString anaType = type;
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;
+ return -1;
}
// Write analysis manager in the analysis file
cout << "===== RUNNING GRID ANALYSIS: " << GetName() << endl;
}
if (!fGridHandler->StartAnalysis(nentries, firstentry)) {
Info("StartAnalysis", "Grid analysis was stopped and cannot be terminated");
- return;
+ return -1;
}
// Terminate grid analysis
- if (fSelector && fSelector->GetStatus() == -1) return;
- if (fGridHandler->GetRunMode() == AliAnalysisGrid::kOffline) return;
+ if (fSelector && fSelector->GetStatus() == -1) return -1;
+ if (fGridHandler->GetRunMode() == AliAnalysisGrid::kOffline) return 0;
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;
+ return 0;
}
ImportWrappers(NULL);
Terminate();
- return;
+ return 0;
}
char line[256];
SetEventLoop(kFALSE);
chain = (TChain*)tree;
if (!chain || !chain->GetListOfFiles()->First()) {
Error("StartAnalysis", "Cannot process null or empty chain...");
- return;
+ return -1;
}
ttype = "TChain";
}
if (IsExternalLoop()) {
Info("StartAnalysis", "Initialization done. Event loop is controlled externally.\
\nSetData for top container, call ExecAnalysis in a loop and then Terminate manually");
- return;
+ return 0;
}
ExecAnalysis();
Terminate();
- return;
+ return 0;
}
// Run tree-based analysis via AliAnalysisSelector
cout << "===== RUNNING LOCAL ANALYSIS " << GetName() << " ON TREE " << tree->GetName() << endl;
case kProofAnalysis:
if (!gROOT->GetListOfProofs() || !gROOT->GetListOfProofs()->GetEntries()) {
Error("StartAnalysis", "No PROOF!!! Aborting.");
- return;
+ return -1;
}
sprintf(line, "gProof->AddInput((TObject*)0x%lx);", (ULong_t)this);
gROOT->ProcessLine(line);
chain->Process("AliAnalysisSelector", "", nentries, firstentry);
} else {
Error("StartAnalysis", "No chain!!! Aborting.");
- return;
+ return -1;
}
break;
case kGridAnalysis:
// Run event mixing analysis
if (!fEventPool) {
Error("StartAnalysis", "Cannot run event mixing without event pool");
- return;
+ return -1;
}
cout << "===== RUNNING EVENT MIXING ANALYSIS " << GetName() << endl;
fSelector = new AliAnalysisSelector(this);
}
PackOutput(fSelector->GetOutputList());
Terminate();
- }
+ }
+ if (fSelector) return fSelector->GetStatus();
+ return 0;
}
//______________________________________________________________________________
-void AliAnalysisManager::StartAnalysis(const char *type, const char *dataset, Long64_t nentries, Long64_t firstentry)
+Long64_t AliAnalysisManager::StartAnalysis(const char *type, const char *dataset, Long64_t nentries, Long64_t firstentry)
{
// Start analysis for this manager on a given dataset. Analysis task can be:
// LOCAL, PROOF or GRID. Process nentries starting from firstentry.
if (!fInitOK) {
Error("StartAnalysis","Analysis manager was not initialized !");
- return;
+ return -1;
}
if (fDebug > 0) printf("StartAnalysis %s\n",GetName());
TString anaType = type;
anaType.ToLower();
if (!anaType.Contains("proof")) {
Error("StartAnalysis", "Cannot process datasets in %s mode. Try PROOF.", type);
- return;
+ return -1;
}
fMode = kProofAnalysis;
char line[256];
if (!gROOT->GetListOfProofs() || !gROOT->GetListOfProofs()->GetEntries()) {
Error("StartAnalysis", "No PROOF!!! Aborting.");
- return;
+ return -1;
}
sprintf(line, "gProof->AddInput((TObject*)0x%lx);", (ULong_t)this);
gROOT->ProcessLine(line);
sprintf(line, "gProof->GetDataSet(\"%s\");", dataset);
if (!gROOT->ProcessLine(line)) {
Error("StartAnalysis", "Dataset %s not found", dataset);
- return;
+ return -1;
}
sprintf(line, "gProof->Process(\"%s\", \"AliAnalysisSelector\", \"\", %lld, %lld);",
dataset, nentries, firstentry);
cout << "===== RUNNING PROOF ANALYSIS " << GetName() << " ON DATASET " << dataset << endl;
gROOT->ProcessLine(line);
+ if (fSelector) return fSelector->GetStatus();
+ return 0;
}
//______________________________________________________________________________
TString opt(option);
opt.ToUpper();
if ((opt=="UPDATE") && (opt!=f->GetOption()))
- ::Fatal("AliAnalysisManager::OpenFile", "File %s already opened, but not in UPDATE mode!", cont->GetFileName());
+ ::Info("AliAnalysisManager::OpenFile", "File %s already opened in %s mode!", cont->GetFileName(), f->GetOption());
} else {
f = TFile::Open(filename, option);
}
TString opt(option);
opt.ToUpper();
if ((opt=="UPDATE") && (opt!=f->GetOption()))
- Fatal("OpenProofFile", "File %s already opened, but not in UPDATE mode!", cont->GetFileName());
+ ::Info("OpenProofFile", "File %s already opened in %s mode!", cont->GetFileName(), f->GetOption());
} else {
f = new TFile(filename, option);
}
// Set the input event handler and create a container for it.
fInputEventHandler = handler;
fCommonInput = CreateContainer("cAUTO_INPUT", TChain::Class(), AliAnalysisManager::kInputContainer);
- Warning("SetInputEventHandler", " An automatic input container for the input chain was created.\nPlease use: mgr->GetCommonInputContainer() to access it.");
+// Warning("SetInputEventHandler", " An automatic input container for the input chain was created.\nPlease use: mgr->GetCommonInputContainer() to access it.");
}
//______________________________________________________________________________
fOutputEventHandler = handler;
fCommonOutput = CreateContainer("cAUTO_OUTPUT", TTree::Class(), AliAnalysisManager::kOutputContainer, "default");
fCommonOutput->SetSpecialOutput();
- Warning("SetOutputEventHandler", " An automatic output container for the output tree was created.\nPlease use: mgr->GetCommonOutputContainer() to access it.");
+// Warning("SetOutputEventHandler", " An automatic output container for the output tree was created.\nPlease use: mgr->GetCommonOutputContainer() to access it.");
}
//______________________________________________________________________________
if (filename == "default") {
if (!fOutputEventHandler) continue;
filename = fOutputEventHandler->GetOutputFileName();
+ // Main AOD may not be there
+ if (gSystem->AccessPathName(filename)) continue;
}
// Check if the file is closed
if (openedFiles.Contains(filename)) continue;;
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff