#include "TROOT.h"
#include "TSystem.h"
#include "TFile.h"
+#include "TFileCollection.h"
+#include "TChain.h"
#include "TObjString.h"
#include "TObjArray.h"
#include "TGrid.h"
fFastReadOption(0),
fOverwriteMode(1),
fNreplicas(2),
+ fNproofWorkers(0),
+ fNproofWorkersPerSlave(0),
+ fProofReset(0),
fRunNumbers(),
fExecutable(),
fExecutableCommand(),
fExecutableArgs(),
fAnalysisMacro(),
fAnalysisSource(),
+ fValidationScript(),
fAdditionalRootLibs(),
fAdditionalLibs(),
fSplitMode(),
fInputFormat(),
fDatasetName(),
fJDLName(),
+ fTerminateFiles(),
fMergeExcludes(),
fIncludePath(),
fCloseSE(),
fJobTag(),
fOutputSingle(),
fRunPrefix(),
+ fProofCluster(),
+ fProofDataSet(),
+ fFileForTestMode(),
+ fRootVersionForProof(),
+ fAliRootMode(),
fInputFiles(0),
fPackages(0)
{
fFastReadOption(0),
fOverwriteMode(1),
fNreplicas(2),
+ fNproofWorkers(0),
+ fNproofWorkersPerSlave(0),
+ fProofReset(0),
fRunNumbers(),
fExecutable(),
fExecutableCommand(),
fExecutableArgs(),
fAnalysisMacro(),
fAnalysisSource(),
+ fValidationScript(),
fAdditionalRootLibs(),
fAdditionalLibs(),
fSplitMode(),
fInputFormat(),
fDatasetName(),
fJDLName(),
+ fTerminateFiles(),
fMergeExcludes(),
fIncludePath(),
fCloseSE(),
fJobTag(),
fOutputSingle(),
fRunPrefix(),
+ fProofCluster(),
+ fProofDataSet(),
+ fFileForTestMode(),
+ fRootVersionForProof(),
+ fAliRootMode(),
fInputFiles(0),
fPackages(0)
{
fFastReadOption(other.fFastReadOption),
fOverwriteMode(other.fOverwriteMode),
fNreplicas(other.fNreplicas),
+ fNproofWorkers(other.fNproofWorkers),
+ fNproofWorkersPerSlave(other.fNproofWorkersPerSlave),
+ fProofReset(other.fProofReset),
fRunNumbers(other.fRunNumbers),
fExecutable(other.fExecutable),
fExecutableCommand(other.fExecutableCommand),
fExecutableArgs(other.fExecutableArgs),
fAnalysisMacro(other.fAnalysisMacro),
fAnalysisSource(other.fAnalysisSource),
+ fValidationScript(other.fValidationScript),
fAdditionalRootLibs(other.fAdditionalRootLibs),
fAdditionalLibs(other.fAdditionalLibs),
fSplitMode(other.fSplitMode),
fInputFormat(other.fInputFormat),
fDatasetName(other.fDatasetName),
fJDLName(other.fJDLName),
+ fTerminateFiles(other.fTerminateFiles),
fMergeExcludes(other.fMergeExcludes),
fIncludePath(other.fIncludePath),
fCloseSE(other.fCloseSE),
fJobTag(other.fJobTag),
fOutputSingle(other.fOutputSingle),
fRunPrefix(other.fRunPrefix),
+ fProofCluster(other.fProofCluster),
+ fProofDataSet(other.fProofDataSet),
+ fFileForTestMode(other.fFileForTestMode),
+ fRootVersionForProof(other.fRootVersionForProof),
+ fAliRootMode(other.fAliRootMode),
fInputFiles(0),
fPackages(0)
{
fFastReadOption = other.fFastReadOption;
fOverwriteMode = other.fOverwriteMode;
fNreplicas = other.fNreplicas;
+ fNproofWorkers = other.fNproofWorkers;
+ fNproofWorkersPerSlave = other.fNproofWorkersPerSlave;
+ fProofReset = other.fProofReset;
fRunNumbers = other.fRunNumbers;
fExecutable = other.fExecutable;
fExecutableCommand = other.fExecutableCommand;
fExecutableArgs = other.fExecutableArgs;
fAnalysisMacro = other.fAnalysisMacro;
fAnalysisSource = other.fAnalysisSource;
+ fValidationScript = other.fValidationScript;
fAdditionalRootLibs = other.fAdditionalRootLibs;
fAdditionalLibs = other.fAdditionalLibs;
fSplitMode = other.fSplitMode;
fInputFormat = other.fInputFormat;
fDatasetName = other.fDatasetName;
fJDLName = other.fJDLName;
+ fTerminateFiles = other.fTerminateFiles;
fMergeExcludes = other.fMergeExcludes;
fIncludePath = other.fIncludePath;
fCloseSE = other.fCloseSE;
fJobTag = other.fJobTag;
fOutputSingle = other.fOutputSingle;
fRunPrefix = other.fRunPrefix;
+ fProofCluster = other.fProofCluster;
+ fProofDataSet = other.fProofDataSet;
+ fFileForTestMode = other.fFileForTestMode;
+ fRootVersionForProof = other.fRootVersionForProof;
+ fAliRootMode = other.fAliRootMode;
if (other.fInputFiles) {
fInputFiles = new TObjArray();
TIter next(other.fInputFiles);
{
// Try to connect to AliEn. User needs a valid token and /tmp/gclient_env_$UID sourced.
if (gGrid && gGrid->IsConnected()) return kTRUE;
+ if (fProductionMode) return kTRUE;
if (!gGrid) {
Info("Connect", "Trying to connect to AliEn ...");
TGrid::Connect("alien://");
gGrid->Cd(homedir);
if (gGrid->Mkdir(workdir, "-p")) {
gGrid->Cd(fGridWorkingDir);
- Info("CreateJDL", "\n##### Created alien working directory %s", fGridWorkingDir.Data());
+ Info("CdWork", "\n##### Created alien working directory %s", fGridWorkingDir.Data());
} else {
- Warning("CreateJDL", "Working directory %s cannot be created.\n Using %s instead.",
+ Warning("CdWork", "Working directory %s cannot be created.\n Using %s instead.",
workdir.Data(), homedir.Data());
fGridWorkingDir = "";
}
Bool_t AliAnalysisAlien::CheckFileCopy(const char *alienpath)
{
// Check if file copying is possible.
+ if (fProductionMode) return kTRUE;
if (!Connect()) {
Error("CheckFileCopy", "Not connected to AliEn. File copying cannot be tested.");
return kFALSE;
Bool_t AliAnalysisAlien::CheckInputData()
{
// Check validity of input data. If necessary, create xml files.
+ if (fProductionMode) return kTRUE;
if (!fInputFiles && !fRunNumbers.Length() && !fRunRange[0]) {
if (!fGridDataDir.Length()) {
Error("CkeckInputData", "AliEn path to base data directory must be set.\n = Use: SetGridDataDir()");
Bool_t isXml = kFALSE;
Bool_t useTags = kFALSE;
Bool_t checked = kFALSE;
- CdWork();
+ if (!TestBit(AliAnalysisGrid::kTest)) CdWork();
TString file;
TString workdir = gGrid->GetHomeDirectory();
workdir += fGridWorkingDir;
Bool_t AliAnalysisAlien::CreateDataset(const char *pattern)
{
// Create dataset for the grid data directory + run number.
- if (TestBit(AliAnalysisGrid::kOffline)) return kTRUE;
+ if (fProductionMode || TestBit(AliAnalysisGrid::kOffline)) return kTRUE;
if (!Connect()) {
Error("CreateDataset", "Cannot create dataset with no grid connection");
return kFALSE;
}
// Cd workspace
- CdWork();
+ if (!TestBit(AliAnalysisGrid::kTest)) CdWork();
TString workdir = gGrid->GetHomeDirectory();
workdir += fGridWorkingDir;
Bool_t error = kFALSE;
TObjArray *arr = 0;
Bool_t copy = kTRUE;
- if (TestBit(AliAnalysisGrid::kOffline) || TestBit(AliAnalysisGrid::kTest)) copy = kFALSE;
+ if (fProductionMode || TestBit(AliAnalysisGrid::kOffline) || TestBit(AliAnalysisGrid::kTest)) copy = kFALSE;
Bool_t generate = kTRUE;
if (TestBit(AliAnalysisGrid::kTest) || TestBit(AliAnalysisGrid::kSubmit)) generate = kFALSE;
if (!Connect()) {
return kFALSE;
}
// Check validity of alien workspace
- CdWork();
- TString workdir = gGrid->GetHomeDirectory();
+ TString workdir;
+ if (!fProductionMode && !fGridWorkingDir.BeginsWith("/alice")) workdir = gGrid->GetHomeDirectory();
+ if (!fProductionMode && !TestBit(AliAnalysisGrid::kTest)) CdWork();
workdir += fGridWorkingDir;
if (generate) {
TObjString *os;
Error("CreateJDL", "You must define AliEn output directory");
error = kTRUE;
} else {
- if (!fGridOutputDir.Contains("/")) fGridOutputDir = Form("%s/%s", workdir.Data(), fGridOutputDir.Data());
- if (!DirectoryExists(fGridOutputDir)) {
- if (gGrid->Mkdir(fGridOutputDir,"-p")) {
- Info("CreateJDL", "\n##### Created alien output directory %s", fGridOutputDir.Data());
- } else {
- Error("CreateJDL", "Could not create alien output directory %s", fGridOutputDir.Data());
- // error = kTRUE;
- }
- }
- gGrid->Cd(workdir);
+ if (!fProductionMode) {
+ if (!fGridOutputDir.Contains("/")) fGridOutputDir = Form("%s/%s", workdir.Data(), fGridOutputDir.Data());
+ if (!DirectoryExists(fGridOutputDir)) {
+ if (gGrid->Mkdir(fGridOutputDir,"-p")) {
+ Info("CreateJDL", "\n##### Created alien output directory %s", fGridOutputDir.Data());
+ } else {
+ Error("CreateJDL", "Could not create alien output directory %s", fGridOutputDir.Data());
+ // error = kTRUE;
+ }
+ }
+ gGrid->Cd(workdir);
+ }
}
// Exit if any error up to now
if (error) return kFALSE;
fMergingJDL->AddToInputSandbox(Form("LF:%s/%s", workdir.Data(),mergeExec.Data()), "List of input files to be uploaded to workers");
if (!fArguments.IsNull())
fGridJDL->SetArguments(fArguments, "Arguments for the executable command");
- fMergingJDL->SetArguments("$1 $2 $3");
+ if (IsOneStageMerging()) fMergingJDL->SetArguments(fGridOutputDir);
+ else fMergingJDL->SetArguments("$1 $2 $3");
fGridJDL->SetValue("TTL", Form("\"%d\"",fTTL));
fGridJDL->SetDescription("TTL", Form("Time after which the job is killed (%d min.)", fTTL/60));
fMergingJDL->SetValue("TTL", Form("\"%d\"",fTTL));
}
delete arr;
}
+ if (!fTerminateFiles.IsNull()) {
+ fTerminateFiles.Strip();
+ fTerminateFiles.ReplaceAll(" ", ",");
+ outputArchive.ReplaceAll("root_archive.zip:", Form("root_archive.zip:%s,", fTerminateFiles.Data()));
+ }
arr = outputArchive.Tokenize(" ");
TIter next2(arr);
comment = comment1;
if (!first) comment = NULL;
TString currentfile = os->GetString();
currentfile.ReplaceAll(".root", "*.root");
- currentfile.ReplaceAll(".zip", "-Stage$2_$3.zip");
+ if (!IsOneStageMerging()) currentfile.ReplaceAll(".zip", "-Stage$2_$3.zip");
if (!currentfile.Contains("@") && fCloseSE.Length())
- fMergingJDL->AddToOutputArchive(Form("%s@%s",currentfile.Data(), fCloseSE.Data()), comment);
+ fMergingJDL->AddToOutputArchive(Form("%s@%s",currentfile.Data(), fCloseSE.Data()), comment);
else
fMergingJDL->AddToOutputArchive(currentfile, comment);
first = kFALSE;
fMergingJDL->AddToOutputSandbox(Form("%s@%s",os->GetString().Data(), fCloseSE.Data()), comment);
else
fMergingJDL->AddToOutputSandbox(os->GetString(), comment);
+ first = kFALSE;
}
delete arr;
}
fGridJDL->SetPrice((UInt_t)fPrice, "AliEn price for this job");
fMergingJDL->SetPrice((UInt_t)fPrice, "AliEn price for this job");
- TString validationScript = fExecutable;
- validationScript.ReplaceAll(".sh", "_validation.sh");
+ TString validationScript = fValidationScript;
fGridJDL->SetValidationCommand(Form("%s/%s", workdir.Data(),validationScript.Data()), "Validation script to be run for each subjob");
- validationScript = fExecutable;
- validationScript.ReplaceAll(".sh", "_mergevalidation.sh");
+ validationScript.ReplaceAll(".sh", "_merge.sh");
fMergingJDL->SetValidationCommand(Form("%s/%s", workdir.Data(),validationScript.Data()), "Validation script to be run for each subjob");
if (fMasterResubmitThreshold) {
fGridJDL->SetValue("MasterResubmitThreshold", Form("\"%d%%\"", fMasterResubmitThreshold));
// all run numbers are considered in one go (jdl). For non-negative indices
// they correspond to the indices in the array fInputFiles.
if (!fInputFiles) return kFALSE;
- TObjString *os;
- TString workdir = gGrid->GetHomeDirectory();
+ TObject *os;
+ TString workdir;
+ if (!fProductionMode && !fGridWorkingDir.BeginsWith("/alice")) workdir = gGrid->GetHomeDirectory();
workdir += fGridWorkingDir;
- if (!fRunNumbers.Length() && !fRunRange[0]) {
- // One jdl with no parameters in case input data is specified by name.
+ if (fProductionMode) {
TIter next(fInputFiles);
- while ((os=(TObjString*)next()))
- fGridJDL->AddToInputDataCollection(Form("LF:%s,nodownload", os->GetString().Data()), "Input xml collections");
- if (!fOutputSingle.IsNull())
- fGridJDL->SetOutputDirectory(Form("#alienfulldir#/../%s",fOutputSingle.Data()), "Output directory");
- else {
- fGridJDL->SetOutputDirectory(Form("%s/#alien_counter_03i#", fGridOutputDir.Data()), "Output directory");
- fMergingJDL->SetOutputDirectory(fGridOutputDir);
- }
- } else {
- // One jdl to be submitted with 2 input parameters: data collection name and output dir prefix
- fGridJDL->AddToInputDataCollection(Form("LF:%s/$1,nodownload", workdir.Data()), "Input xml collections");
- if (!fOutputSingle.IsNull()) {
- if (!fOutputToRunNo) fGridJDL->SetOutputDirectory(Form("#alienfulldir#/%s",fOutputSingle.Data()), "Output directory");
- else fGridJDL->SetOutputDirectory(Form("%s/$2",fGridOutputDir.Data()), "Output directory");
- } else {
- fGridJDL->SetOutputDirectory(Form("%s/$2/#alien_counter_03i#", fGridOutputDir.Data()), "Output directory");
- fMergingJDL->SetOutputDirectory("$1", "Output directory");
- }
+ while ((os=next()))
+ fGridJDL->AddToInputDataCollection(Form("LF:%s,nodownload", os->GetName()), "Input xml collections");
+ fGridJDL->SetOutputDirectory(Form("%s/#alien_counter_04i#", fGridOutputDir.Data()));
+ fMergingJDL->SetOutputDirectory(fGridOutputDir);
+ } else {
+ if (!fRunNumbers.Length() && !fRunRange[0]) {
+ // One jdl with no parameters in case input data is specified by name.
+ TIter next(fInputFiles);
+ while ((os=next()))
+ fGridJDL->AddToInputDataCollection(Form("LF:%s,nodownload", os->GetName()), "Input xml collections");
+ if (!fOutputSingle.IsNull())
+ fGridJDL->SetOutputDirectory(Form("#alienfulldir#/../%s",fOutputSingle.Data()), "Output directory");
+ else {
+ fGridJDL->SetOutputDirectory(Form("%s/#alien_counter_03i#", fGridOutputDir.Data()), "Output directory");
+ fMergingJDL->SetOutputDirectory(fGridOutputDir);
+ }
+ } else {
+ // One jdl to be submitted with 2 input parameters: data collection name and output dir prefix
+ fGridJDL->AddToInputDataCollection(Form("LF:%s/$1,nodownload", workdir.Data()), "Input xml collections");
+ if (!fOutputSingle.IsNull()) {
+ if (!fOutputToRunNo) fGridJDL->SetOutputDirectory(Form("#alienfulldir#/%s",fOutputSingle.Data()), "Output directory");
+ else fGridJDL->SetOutputDirectory(Form("%s/$2",fGridOutputDir.Data()), "Output directory");
+ } else {
+ fGridJDL->SetOutputDirectory(Form("%s/$2/#alien_counter_03i#", fGridOutputDir.Data()), "Output directory");
+ fMergingJDL->SetOutputDirectory("$1", "Output directory");
+ }
+ }
}
-
// Generate the JDL as a string
TString sjdl = fGridJDL->Generate();
TString sjdl1 = fMergingJDL->Generate();
if (index >= 0) sjdl.Insert(index, "\n# JDL variables\n");
sjdl += "Workdirectorysize = {\"5000MB\"};";
sjdl1 += "JDLVariables = \n{\n \"Packages\",\n \"OutputDir\"\n};\n";
- sjdl1.Prepend(Form("Jobtag = {\n \"comment:%s_Merging\"\n};\n", fJobTag.Data()));
+ index = fJobTag.Index(":");
+ if (index < 0) index = fJobTag.Length();
+ TString jobTag = fJobTag;
+ jobTag.Insert(index, "_Merging");
+ sjdl1.Prepend(Form("Jobtag = {\n \"comment:%s_Merging\"\n};\n", jobTag.Data()));
sjdl1.Prepend("# Generated merging jdl\n# $1 = full alien path to output directory to be merged\n# $2 = merging stage\n# $3 = merged chunk\n");
index = sjdl1.Index("JDLVariables");
if (index >= 0) sjdl1.Insert(index, "\n# JDL variables\n");
ofstream out;
out.open(fJDLName.Data(), ios::out);
if (out.bad()) {
- Error("CreateJDL", "Bad file name: %s", fJDLName.Data());
+ Error("WriteJDL", "Bad file name: %s", fJDLName.Data());
return kFALSE;
}
out << sjdl << endl;
ofstream out1;
out1.open(mergeJDLName.Data(), ios::out);
if (out.bad()) {
- Error("CreateJDL", "Bad file name: %s", mergeJDLName.Data());
+ Error("WriteJDL", "Bad file name: %s", mergeJDLName.Data());
return kFALSE;
}
out1 << sjdl1 << endl;
// Copy jdl to grid workspace
if (!copy) {
- Info("CreateJDL", "\n##### You may want to review jdl:%s and analysis macro:%s before running in <submit> mode", fJDLName.Data(), fAnalysisMacro.Data());
+ Info("WriteJDL", "\n##### You may want to review jdl:%s and analysis macro:%s before running in <submit> mode", fJDLName.Data(), fAnalysisMacro.Data());
} else {
TString locjdl = Form("%s/%s", fGridOutputDir.Data(),fJDLName.Data());
TString locjdl1 = Form("%s/%s", fGridOutputDir.Data(),mergeJDLName.Data());
}
if (FileExists(locjdl)) gGrid->Rm(locjdl);
if (FileExists(locjdl1)) gGrid->Rm(locjdl1);
- Info("CreateJDL", "\n##### Copying JDL file <%s> to your AliEn output directory", fJDLName.Data());
+ Info("WriteJDL", "\n##### Copying JDL file <%s> to your AliEn output directory", fJDLName.Data());
TFile::Cp(Form("file:%s",fJDLName.Data()), Form("alien://%s", locjdl.Data()));
if (fMergeViaJDL) {
- Info("CreateJDL", "\n##### Copying merging JDL file <%s> to your AliEn output directory", mergeJDLName.Data());
+ Info("WriteJDL", "\n##### Copying merging JDL file <%s> to your AliEn output directory", mergeJDLName.Data());
TFile::Cp(Form("file:%s",mergeJDLName.Data()), Form("alien://%s", locjdl1.Data()));
}
}
fPackages->Add(new TObjString(pkg));
}
+//______________________________________________________________________________
+TChain *AliAnalysisAlien::GetChainForTestMode(const char *treeName) const
+{
+// Make a tree from files having the location specified in fFileForTestMode.
+// Inspired from JF's CreateESDChain.
+ if (fFileForTestMode.IsNull()) {
+ Error("GetChainForTestMode", "For proof test mode please use SetFileForTestMode() pointing to a file that contains data file locations.");
+ return NULL;
+ }
+ if (gSystem->AccessPathName(fFileForTestMode)) {
+ Error("GetChainForTestMode", "File not found: %s", fFileForTestMode.Data());
+ return NULL;
+ }
+ // Open the file
+ ifstream in;
+ in.open(fFileForTestMode);
+ Int_t count = 0;
+ // Read the input list of files and add them to the chain
+ TString line;
+ TChain *chain = new TChain(treeName);
+ while (in.good())
+ {
+ in >> line;
+ if (line.IsNull()) continue;
+ if (count++ == fNtestFiles) break;
+ TString esdFile(line);
+ TFile *file = TFile::Open(esdFile);
+ if (file) {
+ if (!file->IsZombie()) chain->Add(esdFile);
+ file->Close();
+ } else {
+ Error("GetChainforTestMode", "Skipping un-openable file: %s", esdFile.Data());
+ }
+ }
+ in.close();
+ if (!chain->GetListOfFiles()->GetEntries()) {
+ Error("GetChainForTestMode", "No file from %s could be opened", fFileForTestMode.Data());
+ delete chain;
+ return NULL;
+ }
+// chain->ls();
+ return chain;
+}
+
//______________________________________________________________________________
const char *AliAnalysisAlien::GetJobStatus(Int_t jobidstart, Int_t lastid, Int_t &nrunning, Int_t &nwaiting, Int_t &nerror, Int_t &ndone)
{
{
// Print current plugin settings.
printf("### AliEn analysis plugin current settings ###\n");
+ AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
+ if (mgr && mgr->IsProofMode()) {
+ TString proofType = "= PLUGIN IN PROOF MODE ON CLUSTER:_________________";
+ if (TestBit(AliAnalysisGrid::kTest))
+ proofType = "= PLUGIN IN PROOF LITE MODE ON CLUSTER:____________";
+ printf("%s %s\n", proofType.Data(), fProofCluster.Data());
+ if (!fProofDataSet.IsNull())
+ printf("= Requested data set:___________________________ %s\n", fProofDataSet.Data());
+ if (fProofReset==1)
+ printf("= Soft reset signal will be send to master______ CHANGE BEHAVIOR AFTER COMPLETION\n");
+ if (fProofReset>1)
+ printf("= Hard reset signal will be send to master______ CHANGE BEHAVIOR AFTER COMPLETION\n");
+ if (!fRootVersionForProof.IsNull())
+ printf("= ROOT version requested________________________ %s\n", fRootVersionForProof.Data());
+ else
+ printf("= ROOT version requested________________________ default\n");
+ printf("= AliRoot version requested_____________________ %s\n", fAliROOTVersion.Data());
+ if (!fAliRootMode.IsNull())
+ printf("= Requested AliRoot mode________________________ %s\n", fAliRootMode.Data());
+ if (fNproofWorkers)
+ printf("= Number of PROOF workers limited to____________ %d\n", fNproofWorkers);
+ if (fNproofWorkersPerSlave)
+ printf("= Maximum number of workers per slave___________ %d\n", fNproofWorkersPerSlave);
+ if (TestSpecialBit(kClearPackages))
+ printf("= ClearPackages requested...\n");
+ if (fIncludePath.Data())
+ printf("= Include path for runtime task compilation: ___ %s\n", fIncludePath.Data());
+ printf("= Additional libs to be loaded or souces to be compiled runtime: <%s>\n",fAdditionalLibs.Data());
+ if (fPackages && fPackages->GetEntries()) {
+ TIter next(fPackages);
+ TObject *obj;
+ TString list;
+ while ((obj=next())) list += obj->GetName();
+ printf("= Par files to be used: ________________________ %s\n", list.Data());
+ }
+ if (TestSpecialBit(kProofConnectGrid))
+ printf("= Requested PROOF connection to grid\n");
+ return;
+ }
printf("= OverwriteMode:________________________________ %d\n", fOverwriteMode);
if (fOverwriteMode) {
printf("***** NOTE: Overwrite mode will overwrite the input generated datasets and partial results from previous analysis. \
printf("= List of output files to be registered: _______ %s\n", fOutputFiles.Data());
printf("= List of outputs going to be archived: ________ %s\n", fOutputArchive.Data());
printf("= List of outputs that should not be merged: ___ %s\n", fMergeExcludes.Data());
+ printf("= List of outputs produced during Terminate: ___ %s\n", fTerminateFiles.Data());
printf("=====================================================================\n");
printf("= Job price: ___________________________________ %d\n", fPrice);
printf("= Time to live (TTL): __________________________ %d\n", fTTL);
printf("= Force job outputs to storage element: ________ %s\n", fCloseSE.Data());
if (fFriendChainName.Length())
printf("= Open friend chain file on worker: ____________ %s\n", fFriendChainName.Data());
- if (fPackages) {
+ if (fPackages && fPackages->GetEntries()) {
TIter next(fPackages);
TObject *obj;
TString list;
delete res;
printf("=> Removing files from previous stages...\n");
gGrid->Rm(Form("%s/*Stage*.root", aliendir));
- gGrid->Rm(Form("%s/*Stage*.zip", aliendir));
+ for (i=1; i<stage; i++)
+ gGrid->Rm(Form("%s/*Stage%d*.zip", aliendir, i));
return kTRUE;
}
}
Bool_t AliAnalysisAlien::StartAnalysis(Long64_t /*nentries*/, Long64_t /*firstEntry*/)
{
// Start remote grid analysis.
+ AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
+ Bool_t testMode = TestBit(AliAnalysisGrid::kTest);
+ if (!mgr || !mgr->IsInitialized()) {
+ Error("StartAnalysis", "You need an initialized analysis manager for this");
+ return kFALSE;
+ }
+ // Are we in PROOF mode ?
+ if (mgr->IsProofMode()) {
+ Info("StartAnalysis", "##### Starting PROOF analysis on cluster <%s> via the plugin #####", fProofCluster.Data());
+ if (fProofCluster.IsNull()) {
+ Error("StartAnalysis", "You need to specify the proof cluster name via SetProofCluster");
+ return kFALSE;
+ }
+ if (fProofDataSet.IsNull() && !testMode) {
+ Error("StartAnalysis", "You need to specify a dataset using SetProofDataSet()");
+ return kFALSE;
+ }
+ // Set the needed environment
+ gEnv->SetValue("XSec.GSI.DelegProxy","2");
+ // Do we need to reset PROOF ? The success of the Reset operation cannot be checked
+ if (fProofReset && !testMode) {
+ if (fProofReset==1) {
+ Info("StartAnalysis", "Sending soft reset signal to proof cluster %s", fProofCluster.Data());
+ gROOT->ProcessLine(Form("TProof::Reset(\"%s\", kFALSE);", fProofCluster.Data()));
+ } else {
+ Info("StartAnalysis", "Sending hard reset signal to proof cluster %s", fProofCluster.Data());
+ gROOT->ProcessLine(Form("TProof::Reset(\"%s\", kTRUE);", fProofCluster.Data()));
+ }
+ Info("StartAnalysis", "Stopping the analysis. Please use SetProofReset(0) to resume.");
+ return kFALSE;
+ }
+ // Do we need to change the ROOT version ? The success of this cannot be checked.
+ if (!fRootVersionForProof.IsNull() && !testMode) {
+ gROOT->ProcessLine(Form("TProof::Mgr(\"%s\")->SetROOTVersion(\"%s\");",
+ fProofCluster.Data(), fRootVersionForProof.Data()));
+ }
+ // Connect to PROOF and check the status
+ Long_t proof = 0;
+ TString sworkers;
+ if (fNproofWorkersPerSlave) sworkers = Form("workers=%dx", fNproofWorkersPerSlave);
+ else if (fNproofWorkers) sworkers = Form("workers=%d", fNproofWorkers);
+ if (!testMode) {
+ if (!sworkers.IsNull())
+ proof = gROOT->ProcessLine(Form("TProof::Open(\"%s\", \"%s\");", fProofCluster.Data(), sworkers.Data()));
+ else
+ proof = gROOT->ProcessLine(Form("TProof::Open(\"%s\");", fProofCluster.Data()));
+ } else {
+ proof = gROOT->ProcessLine("TProof::Open(\"\");");
+ if (!proof) {
+ Error("StartAnalysis", "Could not start PROOF in test mode");
+ return kFALSE;
+ }
+ }
+ if (!proof) {
+ Error("StartAnalysis", "Could not connect to PROOF cluster <%s>", fProofCluster.Data());
+ return kFALSE;
+ }
+ if (fNproofWorkersPerSlave*fNproofWorkers > 0)
+ gROOT->ProcessLine(Form("gProof->SetParallel(%d);", fNproofWorkers));
+ // Is dataset existing ?
+ if (!testMode) {
+ TString dataset = fProofDataSet;
+ Int_t index = dataset.Index("#");
+ if (index>=0) dataset.Remove(index);
+// if (!gROOT->ProcessLine(Form("gProof->ExistsDataSet(\"%s\");",fProofDataSet.Data()))) {
+// Error("StartAnalysis", "Dataset %s not existing", fProofDataSet.Data());
+// return kFALSE;
+// }
+// Info("StartAnalysis", "Dataset %s found", dataset.Data());
+ }
+ // Is ClearPackages() needed ?
+ if (TestSpecialBit(kClearPackages)) {
+ Info("StartAnalysis", "ClearPackages signal sent to PROOF. Use SetClearPackages(kFALSE) to reset this.");
+ gROOT->ProcessLine("gProof->ClearPackages();");
+ }
+ // Is a given aliroot mode requested ?
+ TList optionsList;
+ if (!fAliRootMode.IsNull()) {
+ TString alirootMode = fAliRootMode;
+ if (alirootMode == "default") alirootMode = "";
+ Info("StartAnalysis", "You are requesting AliRoot mode: %s", fAliRootMode.Data());
+ optionsList.SetOwner();
+ optionsList.Add(new TNamed("ALIROOT_MODE", alirootMode.Data()));
+ // Check the additional libs to be loaded
+ TString extraLibs;
+ if (!alirootMode.IsNull()) extraLibs = "ANALYSIS:ANALYSISalice";
+ // Parse the extra libs for .so
+ if (fAdditionalLibs.Length()) {
+ TObjArray *list = fAdditionalLibs.Tokenize(" ");
+ TIter next(list);
+ TObjString *str;
+ while((str=(TObjString*)next()) && str->GetString().Contains(".so")) {
+ TString stmp = str->GetName();
+ if (stmp.BeginsWith("lib")) stmp.Remove(0,3);
+ stmp.ReplaceAll(".so","");
+ if (!extraLibs.IsNull()) extraLibs += ":";
+ extraLibs += stmp;
+ }
+ if (list) delete list;
+ }
+ if (!extraLibs.IsNull()) optionsList.Add(new TNamed("ALIROOT_EXTRA_LIBS",extraLibs.Data()));
+ // Check extra includes
+ if (!fIncludePath.IsNull()) {
+ TString includePath = fIncludePath;
+ includePath.ReplaceAll(" ",":");
+ includePath.Strip(TString::kTrailing, ':');
+ Info("StartAnalysis", "Adding extra includes: %s",includePath.Data());
+ optionsList.Add(new TNamed("ALIROOT_EXTRA_INCLUDES",includePath.Data()));
+ }
+ // Check if connection to grid is requested
+ if (TestSpecialBit(kProofConnectGrid))
+ optionsList.Add(new TNamed("ALIROOT_ENABLE_ALIEN", "1"));
+ // Enable AliRoot par
+ if (testMode) {
+ // Enable proof lite package
+ TString alirootLite = gSystem->ExpandPathName("$ALICE_ROOT/ANALYSIS/macros/AliRootProofLite.par");
+ for (Int_t i=0; i<optionsList.GetSize(); i++) {
+ TNamed *obj = (TNamed*)optionsList.At(i);
+ printf("%s %s\n", obj->GetName(), obj->GetTitle());
+ }
+ if (!gROOT->ProcessLine(Form("gProof->UploadPackage(\"%s\");",alirootLite.Data()))
+ && !gROOT->ProcessLine(Form("gProof->EnablePackage(\"%s\", (TList*)0x%lx);",alirootLite.Data(),(ULong_t)&optionsList))) {
+ Info("StartAnalysis", "AliRootProofLite enabled");
+ } else {
+ Error("StartAnalysis", "There was an error trying to enable package AliRootProofLite.par");
+ return kFALSE;
+ }
+ } else {
+ if (gROOT->ProcessLine(Form("gProof->EnablePackage(\"VO_ALICE@AliRoot::%s\", (TList*)0x%lx);",
+ fAliROOTVersion.Data(), (ULong_t)&optionsList))) {
+ Error("StartAnalysis", "There was an error trying to enable package VO_ALICE@AliRoot::%s", fAliROOTVersion.Data());
+ return kFALSE;
+ }
+ }
+ } else {
+ if (fAdditionalLibs.Contains(".so") && !testMode) {
+ Error("StartAnalysis", "You request additional libs to be loaded but did not enabled any AliRoot mode. Please refer to: \
+ \n http://aaf.cern.ch/node/83 and use a parameter for SetAliRootMode()");
+ return kFALSE;
+ }
+ }
+ // Enable par files if requested
+ if (fPackages && fPackages->GetEntries()) {
+ TIter next(fPackages);
+ TObject *package;
+ while ((package=next())) {
+ if (gROOT->ProcessLine(Form("gProof->UploadPackage(\"%s\");", package->GetName()))) {
+ if (gROOT->ProcessLine(Form("gProof->EnablePackage(\"%s\",kTRUE);", package->GetName()))) {
+ Error("StartAnalysis", "There was an error trying to enable package %s", package->GetName());
+ return kFALSE;
+ }
+ } else {
+ Error("StartAnalysis", "There was an error trying to upload package %s", package->GetName());
+ return kFALSE;
+ }
+ }
+ }
+ // Do we need to load analysis source files ?
+ // NOTE: don't load on client since this is anyway done by the user to attach his task.
+ if (fAnalysisSource.Length()) {
+ TObjArray *list = fAnalysisSource.Tokenize(" ");
+ TIter next(list);
+ TObjString *str;
+ while((str=(TObjString*)next())) {
+ gROOT->ProcessLine(Form("gProof->Load(\"%s+g\", kTRUE);", str->GetName()));
+ }
+ if (list) delete list;
+ }
+ if (testMode) {
+ // Register dataset to proof lite.
+ if (fFileForTestMode.IsNull()) {
+ Error("GetChainForTestMode", "For proof test mode please use SetFileForTestMode() pointing to a file that contains data file locations.");
+ return kFALSE;
+ }
+ if (gSystem->AccessPathName(fFileForTestMode)) {
+ Error("GetChainForTestMode", "File not found: %s", fFileForTestMode.Data());
+ return kFALSE;
+ }
+ TFileCollection *coll = new TFileCollection();
+ coll->AddFromFile(fFileForTestMode);
+ gROOT->ProcessLine(Form("gProof->RegisterDataSet(\"test_collection\", (TFileCollection*)0x%lx, \"OV\");", (ULong_t)coll));
+ gROOT->ProcessLine("gProof->ShowDataSets()");
+ }
+ return kTRUE;
+ }
// Check if output files have to be taken from the analysis manager
if (TestBit(AliAnalysisGrid::kDefaultOutputs)) {
- AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
- if (!mgr || !mgr->IsInitialized()) {
- Error("StartAnalysis", "You need an initialized analysis manager for this");
- return kFALSE;
- }
fOutputFiles = "";
TIter next(mgr->GetOutputs());
AliAnalysisDataContainer *output;
Error("StartAnalysis", "Cannot start grid analysis without grid connection");
return kFALSE;
}
- if (IsCheckCopy()) CheckFileCopy(gGrid->GetHomeDirectory());
+ if (IsCheckCopy() && gGrid) CheckFileCopy(gGrid->GetHomeDirectory());
if (!CheckInputData()) {
Error("StartAnalysis", "There was an error in preprocessing your requested input data");
return kFALSE;
}
if (!CreateJDL()) return kFALSE;
if (TestBit(AliAnalysisGrid::kOffline)) return kFALSE;
- if (TestBit(AliAnalysisGrid::kTest)) {
+ if (testMode) {
// Locally testing the analysis
Info("StartAnalysis", "\n_______________________________________________________________________ \
\n Running analysis script in a daughter shell as on a worker node \
Int_t ntosubmit = 0;
TGridResult *res;
TString jobID = "";
- if (!fNsubmitted) ntosubmit = 1;
- else {
+ Int_t nmasterjobs = fInputFiles->GetEntries();
+ if (!fNsubmitted) {
+ ntosubmit = 1;
+ if (!IsUseSubmitPolicy()) {
+ if (nmasterjobs>5)
+ Info("SubmitNext","### Warning submit policy not used ! Submitting too many jobs at a time may be prohibitted. \
+ \n### You can use SetUseSubmitPolicy() to enable if you have problems.");
+ ntosubmit = nmasterjobs;
+ }
+ } else {
TString status = GetJobStatus(firstmaster, lastmaster, nrunning, nwaiting, nerror, ndone);
printf("=== master %d: %s\n", lastmaster, status.Data());
// If last master not split, just return
printf("=== WAITING(%d) RUNNING(%d) DONE(%d) OTHER(%d) NperMaster=%d => to submit %d jobs\n",
nwaiting, nrunning, ndone, nerror, npermaster, ntosubmit);
}
- Int_t nmasterjobs = fInputFiles->GetEntries();
for (Int_t i=0; i<ntosubmit; i++) {
// Submit for a range of enumeration of runs.
if (fNsubmitted>=nmasterjobs) {iscalled = kFALSE; return kTRUE;}
Info("WriteAnalysisFile", "\n##### Analysis manager: %s wrote to file <%s>\n", mgr->GetName(),analysisFile.Data());
}
Bool_t copy = kTRUE;
- if (TestBit(AliAnalysisGrid::kOffline) || TestBit(AliAnalysisGrid::kTest)) copy = kFALSE;
+ if (fProductionMode || TestBit(AliAnalysisGrid::kOffline) || TestBit(AliAnalysisGrid::kTest)) copy = kFALSE;
if (copy) {
CdWork();
TString workdir = gGrid->GetHomeDirectory();
workdir += fGridWorkingDir;
- Info("CreateJDL", "\n##### Copying file <%s> containing your initialized analysis manager to your alien workspace", analysisFile.Data());
+ Info("WriteAnalysisFile", "\n##### Copying file <%s> containing your initialized analysis manager to your alien workspace", analysisFile.Data());
if (FileExists(analysisFile)) gGrid->Rm(analysisFile);
TFile::Cp(Form("file:%s",analysisFile.Data()), Form("alien://%s/%s", workdir.Data(),analysisFile.Data()));
}
out << "// Automatically generated analysis steering macro executed in grid subjobs" << endl << endl;
out << " TStopwatch timer;" << endl;
out << " timer.Start();" << endl << endl;
+ // Change temp directory to current one
+ out << "// Set temporary merging directory to current one" << endl;
+ out << " gSystem->Setenv(\"TMPDIR\", gSystem->pwd());" << endl << endl;
out << "// load base root libraries" << endl;
out << " gSystem->Load(\"libTree\");" << endl;
out << " gSystem->Load(\"libGeom\");" << endl;
out << "// fast xrootd reading enabled" << endl;
out << " printf(\"!!! You requested FastRead option. Using xrootd flags to reduce timeouts. Note that this may skip some files that could be accessed !!!\");" << endl;
out << " gEnv->SetValue(\"XNet.ConnectTimeout\",10);" << endl;
- out << " gEnv->SetValue(\"XNet.RequestTimeout\",10);" << endl;
+ out << " gEnv->SetValue(\"XNet.RequestTimeout\",20);" << endl;
out << " gEnv->SetValue(\"XNet.MaxRedirectCount\",2);" << endl;
- out << " gEnv->SetValue(\"XNet.ReconnectTimeout\",10);" << endl;
+ out << " gEnv->SetValue(\"XNet.ReconnectTimeout\",50);" << endl;
out << " gEnv->SetValue(\"XNet.FirstConnectMaxCnt\",1);" << endl << endl;
}
- // Change temp directory to current one
- out << "// Set temporary merging directory to current one" << endl;
- out << " gSystem->Setenv(\"TMPDIR\", gSystem->pwd());" << endl << endl;
out << "// connect to AliEn and make the chain" << endl;
out << " if (!TGrid::Connect(\"alien://\")) return;" << endl;
- if (IsUsingTags()) {
- out << " TChain *chain = CreateChainFromTags(\"wn.xml\", anatype);" << endl << endl;
- } else {
- out << " TChain *chain = CreateChain(\"wn.xml\", anatype);" << endl << endl;
- }
out << "// read the analysis manager from file" << endl;
TString analysisFile = fExecutable;
analysisFile.ReplaceAll(".sh", ".root");
if (AliAnalysisManager::GetAnalysisManager()->GetDebugLevel()>3) {
out << " gEnv->SetValue(\"XNet.Debug\", \"1\");" << endl;
} else {
- out << " AliLog::SetGlobalLogLevel(AliLog::kError);" << endl;
+ if (TestBit(AliAnalysisGrid::kTest))
+ out << " AliLog::SetGlobalLogLevel(AliLog::kWarning);" << endl;
+ else
+ out << " AliLog::SetGlobalLogLevel(AliLog::kError);" << endl;
}
}
+ if (IsUsingTags()) {
+ out << " TChain *chain = CreateChainFromTags(\"wn.xml\", anatype);" << endl << endl;
+ } else {
+ out << " TChain *chain = CreateChain(\"wn.xml\", anatype);" << endl << endl;
+ }
out << " mgr->StartAnalysis(\"localfile\", chain);" << endl;
out << " timer.Stop();" << endl;
out << " timer.Print();" << endl;
out << "TChain* CreateChain(const char *xmlfile, const char *type=\"ESD\")" << endl;
out << "{" << endl;
out << "// Create a chain using url's from xml file" << endl;
+ out << " TString filename;" << endl;
+ out << " Int_t run = 0;" << endl;
out << " TString treename = type;" << endl;
out << " treename.ToLower();" << endl;
out << " treename += \"Tree\";" << endl;
out << " ::Error(\"CreateChain\", \"Cannot create an AliEn collection from %s\", xmlfile);" << endl;
out << " return NULL;" << endl;
out << " }" << endl;
+ out << " AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();" << endl;
out << " TChain *chain = new TChain(treename);" << endl;
if(fFriendChainName!="") {
out << " TChain *chainFriend = new TChain(treename);" << endl;
}
out << " coll->Reset();" << endl;
out << " while (coll->Next()) {" << endl;
- out << " chain->Add(coll->GetTURL(\"\"));" << endl;
+ out << " filename = coll->GetTURL("");" << endl;
+ out << " if (mgr) {" << endl;
+ out << " Int_t nrun = AliAnalysisManager::GetRunFromAlienPath(filename);" << endl;
+ out << " if (nrun && nrun != run) {" << endl;
+ out << " printf(\"### Run number detected from chain: %d\\n\", nrun);" << endl;
+ out << " mgr->SetRunFromPath(nrun);" << endl;
+ out << " run = nrun;" << endl;
+ out << " }" << endl;
+ out << " }" << endl;
+ out << " chain->Add(filename);" << endl;
if(fFriendChainName!="") {
out << " TString fileFriend=coll->GetTURL(\"\");" << endl;
out << " fileFriend.ReplaceAll(\"AliAOD.root\",\""<<fFriendChainName.Data()<<"\");" << endl;
Info("WriteAnalysisMacro", "\n##### Analysis macro to run on worker nodes <%s> written",fAnalysisMacro.Data());
}
Bool_t copy = kTRUE;
- if (TestBit(AliAnalysisGrid::kOffline) || TestBit(AliAnalysisGrid::kTest)) copy = kFALSE;
+ if (fProductionMode || TestBit(AliAnalysisGrid::kOffline) || TestBit(AliAnalysisGrid::kTest)) copy = kFALSE;
if (copy) {
CdWork();
TString workdir = gGrid->GetHomeDirectory();
out << "// fast xrootd reading enabled" << endl;
out << " printf(\"!!! You requested FastRead option. Using xrootd flags to reduce timeouts. Note that this may skip some files that could be accessed !!!\");" << endl;
out << " gEnv->SetValue(\"XNet.ConnectTimeout\",10);" << endl;
- out << " gEnv->SetValue(\"XNet.RequestTimeout\",10);" << endl;
+ out << " gEnv->SetValue(\"XNet.RequestTimeout\",20);" << endl;
out << " gEnv->SetValue(\"XNet.MaxRedirectCount\",2);" << endl;
- out << " gEnv->SetValue(\"XNet.ReconnectTimeout\",10);" << endl;
+ out << " gEnv->SetValue(\"XNet.ReconnectTimeout\",50);" << endl;
out << " gEnv->SetValue(\"XNet.FirstConnectMaxCnt\",1);" << endl << endl;
}
// Change temp directory to current one
if (AliAnalysisManager::GetAnalysisManager()->GetDebugLevel()>3) {
out << " gEnv->SetValue(\"XNet.Debug\", \"1\");" << endl;
} else {
- out << " AliLog::SetGlobalLogLevel(AliLog::kError);" << endl;
+ if (TestBit(AliAnalysisGrid::kTest))
+ out << " AliLog::SetGlobalLogLevel(AliLog::kWarning);" << endl;
+ else
+ out << " AliLog::SetGlobalLogLevel(AliLog::kError);" << endl;
}
}
- out << " mgr->StartAnalysis(\"gridterminate\");" << endl;
+ out << " TTree *tree = NULL;" << endl;
+ out << " mgr->StartAnalysis(\"gridterminate\", tree);" << endl;
out << "}" << endl << endl;
if (hasANALYSISalice) {
out <<"//________________________________________________________________________________" << endl;
}
}
Bool_t copy = kTRUE;
- if (TestBit(AliAnalysisGrid::kOffline) || TestBit(AliAnalysisGrid::kTest)) copy = kFALSE;
+ if (fProductionMode || TestBit(AliAnalysisGrid::kOffline) || TestBit(AliAnalysisGrid::kTest)) copy = kFALSE;
if (copy) {
CdWork();
TString workdir = gGrid->GetHomeDirectory();
out << "free -m" << endl;
}
Bool_t copy = kTRUE;
- if (TestBit(AliAnalysisGrid::kOffline) || TestBit(AliAnalysisGrid::kTest)) copy = kFALSE;
+ if (fProductionMode || TestBit(AliAnalysisGrid::kOffline) || TestBit(AliAnalysisGrid::kTest)) copy = kFALSE;
if (copy) {
CdWork();
TString workdir = gGrid->GetHomeDirectory();
workdir += fGridWorkingDir;
TString executable = Form("%s/bin/%s", gGrid->GetHomeDirectory(), fExecutable.Data());
if (FileExists(executable)) gGrid->Rm(executable);
- Info("CreateJDL", "\n##### Copying executable file <%s> to your AliEn bin directory", fExecutable.Data());
+ Info("WriteExecutable", "\n##### Copying executable file <%s> to your AliEn bin directory", fExecutable.Data());
TFile::Cp(Form("file:%s",fExecutable.Data()), Form("alien://%s", executable.Data()));
}
}
out << "free -m" << endl;
}
Bool_t copy = kTRUE;
- if (TestBit(AliAnalysisGrid::kOffline) || TestBit(AliAnalysisGrid::kTest)) copy = kFALSE;
+ if (fProductionMode || TestBit(AliAnalysisGrid::kOffline) || TestBit(AliAnalysisGrid::kTest)) copy = kFALSE;
if (copy) {
CdWork();
TString workdir = gGrid->GetHomeDirectory();
workdir += fGridWorkingDir;
TString executable = Form("%s/bin/%s", gGrid->GetHomeDirectory(), mergeExec.Data());
if (FileExists(executable)) gGrid->Rm(executable);
- Info("CreateJDL", "\n##### Copying executable file <%s> to your AliEn bin directory", mergeExec.Data());
+ Info("WriteMergeExecutable", "\n##### Copying executable file <%s> to your AliEn bin directory", mergeExec.Data());
TFile::Cp(Form("file:%s",mergeExec.Data()), Form("alien://%s", executable.Data()));
}
}
Error("WriteProductionFile", "Bad file name: %s", filename);
return;
}
- TString workdir = gGrid->GetHomeDirectory();
+ TString workdir;
+ if (!fProductionMode && !fGridWorkingDir.BeginsWith("/alice"))
+ workdir = gGrid->GetHomeDirectory();
workdir += fGridWorkingDir;
Int_t njobspermaster = 1000*fNrunsPerMaster/fSplitMaxInputFileNumber;
TString locjdl = Form("%s/%s", workdir.Data(),fJDLName.Data());
else
out << Form("%s", fInputFiles->At(i)->GetName()) << " " << Form("%03d", i) << endl;
}
- Info("WriteProductionFile", "\n##### Copying production file <%s> to your work directory", filename);
- if (FileExists(filename)) gGrid->Rm(filename);
- TFile::Cp(Form("file:%s",filename), Form("alien://%s/%s", workdir.Data(),filename));
+ if (gGrid) {
+ Info("WriteProductionFile", "\n##### Copying production file <%s> to your work directory", filename);
+ if (FileExists(filename)) gGrid->Rm(filename);
+ TFile::Cp(Form("file:%s",filename), Form("alien://%s/%s", workdir.Data(),filename));
+ }
}
//______________________________________________________________________________
// Generate the alien validation script.
// Generate the validation script
TObjString *os;
- TString validationScript = fExecutable;
- if (merge) validationScript.ReplaceAll(".sh", "_mergevalidation.sh");
- else validationScript.ReplaceAll(".sh", "_validation.sh");
+ if (fValidationScript.IsNull()) {
+ fValidationScript = fExecutable;
+ fValidationScript.ReplaceAll(".sh", "_validation.sh");
+ }
+ TString validationScript = fValidationScript;
+ if (merge) validationScript.ReplaceAll(".sh", "_merge.sh");
if (!Connect()) {
Error("WriteValidationScript", "Alien connection required");
return;
}
+ if (!fTerminateFiles.IsNull()) {
+ fTerminateFiles.Strip();
+ fTerminateFiles.ReplaceAll(" ",",");
+ }
TString outStream = "";
if (!TestBit(AliAnalysisGrid::kTest)) outStream = " >> stdout";
if (!TestBit(AliAnalysisGrid::kSubmit)) {
// Part dedicated to the specific analyses running into the train
- TObjArray *arr = fOutputFiles.Tokenize(",");
+ TString outputFiles = fOutputFiles;
+ if (merge && !fTerminateFiles.IsNull()) {
+ outputFiles += ",";
+ outputFiles += fTerminateFiles;
+ }
+ TObjArray *arr = outputFiles.Tokenize(",");
TIter next1(arr);
TString outputFile;
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
TString extra = mgr->GetExtraFiles();
while ((os=(TObjString*)next1())) {
- if (merge) break;
outputFile = os->GetString();
Int_t index = outputFile.Index("@");
if (index > 0) outputFile.Remove(index);
+ if (!merge && fTerminateFiles.Contains(outputFile)) continue;
if (merge && fMergeExcludes.Contains(outputFile)) continue;
if (extra.Contains(outputFile)) continue;
if (outputFile.Contains("*")) continue;
out << "exit $error" << endl;
}
Bool_t copy = kTRUE;
- if (TestBit(AliAnalysisGrid::kOffline) || TestBit(AliAnalysisGrid::kTest)) copy = kFALSE;
+ if (fProductionMode || TestBit(AliAnalysisGrid::kOffline) || TestBit(AliAnalysisGrid::kTest)) copy = kFALSE;
if (copy) {
CdWork();
TString workdir = gGrid->GetHomeDirectory();
workdir += fGridWorkingDir;
- Info("CreateJDL", "\n##### Copying validation script <%s> to your AliEn working space", validationScript.Data());
+ Info("WriteValidationScript", "\n##### Copying validation script <%s> to your AliEn working space", validationScript.Data());
if (FileExists(validationScript)) gGrid->Rm(validationScript);
TFile::Cp(Form("file:%s",validationScript.Data()), Form("alien://%s/%s", workdir.Data(),validationScript.Data()));
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff