#include "TGridResult.h"
#include "TGridCollection.h"
#include "TGridJDL.h"
+#include "TGridJobStatusList.h"
+#include "TGridJobStatus.h"
#include "TFileMerger.h"
#include "AliAnalysisManager.h"
#include "AliVEventHandler.h"
fNtestFiles(0),
fNrunsPerMaster(0),
fMaxMergeFiles(0),
+ fNsubmitted(0),
+ fProductionMode(0),
fRunNumbers(),
fExecutable(),
+ fExecutableCommand(),
fArguments(),
fAnalysisMacro(),
fAnalysisSource(),
fIncludePath(),
fCloseSE(),
fFriendChainName(),
+ fJobTag(),
fInputFiles(0),
fPackages(0)
{
fNtestFiles(0),
fNrunsPerMaster(0),
fMaxMergeFiles(0),
+ fNsubmitted(0),
+ fProductionMode(0),
fRunNumbers(),
fExecutable(),
+ fExecutableCommand(),
fArguments(),
fAnalysisMacro(),
fAnalysisSource(),
fIncludePath(),
fCloseSE(),
fFriendChainName(),
+ fJobTag(),
fInputFiles(0),
fPackages(0)
{
fNtestFiles(other.fNtestFiles),
fNrunsPerMaster(other.fNrunsPerMaster),
fMaxMergeFiles(other.fMaxMergeFiles),
+ fNsubmitted(other.fNsubmitted),
+ fProductionMode(other.fProductionMode),
fRunNumbers(other.fRunNumbers),
fExecutable(other.fExecutable),
+ fExecutableCommand(other.fExecutableCommand),
fArguments(other.fArguments),
fAnalysisMacro(other.fAnalysisMacro),
fAnalysisSource(other.fAnalysisSource),
fIncludePath(other.fIncludePath),
fCloseSE(other.fCloseSE),
fFriendChainName(other.fFriendChainName),
+ fJobTag(other.fJobTag),
fInputFiles(0),
fPackages(0)
{
fMaxInitFailed = other.fMaxInitFailed;
fMasterResubmitThreshold = other.fMasterResubmitThreshold;
fNtestFiles = other.fNtestFiles;
+ fNrunsPerMaster = other.fNrunsPerMaster;
+ fMaxMergeFiles = other.fMaxMergeFiles;
+ fNsubmitted = other.fNsubmitted;
+ fProductionMode = other.fProductionMode;
fRunNumbers = other.fRunNumbers;
fExecutable = other.fExecutable;
+ fExecutableCommand = other.fExecutableCommand;
fArguments = other.fArguments;
fAnalysisMacro = other.fAnalysisMacro;
fAnalysisSource = other.fAnalysisSource;
fIncludePath = other.fIncludePath;
fCloseSE = other.fCloseSE;
fFriendChainName = other.fFriendChainName;
+ fJobTag = other.fJobTag;
if (other.fInputFiles) {
fInputFiles = new TObjArray();
TIter next(other.fInputFiles);
fRunNumbers += Form("%d", run);
}
+//______________________________________________________________________________
+void AliAnalysisAlien::AddRunNumber(const char* run)
+{
+// Add a run number to the list of runs to be processed.
+ if (fRunNumbers.Length()) fRunNumbers += " ";
+ fRunNumbers += run;
+}
+
//______________________________________________________________________________
void AliAnalysisAlien::AddDataFile(const char *lfn)
{
}
TString homedir = gGrid->GetHomeDirectory();
TString workdir = homedir + fGridWorkingDir;
- if (!gGrid->Cd(workdir)) {
- gGrid->Cd(homedir);
- if (gGrid->Mkdir(workdir)) {
- gGrid->Cd(fGridWorkingDir);
- Info("CreateJDL", "\n##### Created alien working directory %s", fGridWorkingDir.Data());
- } else {
- Warning("CreateJDL", "Working directory %s cannot be created.\n Using %s instead.",
- workdir.Data(), homedir.Data());
- fGridWorkingDir = "";
- }
- }
+ if (DirectoryExists(workdir)) {
+ gGrid->Cd(workdir);
+ return;
+ }
+ // Work directory not existing - create it
+ gGrid->Cd(homedir);
+ if (gGrid->Mkdir(workdir)) {
+ gGrid->Cd(fGridWorkingDir);
+ Info("CreateJDL", "\n##### Created alien working directory %s", fGridWorkingDir.Data());
+ } else {
+ Warning("CreateJDL", "Working directory %s cannot be created.\n Using %s instead.",
+ workdir.Data(), homedir.Data());
+ fGridWorkingDir = "";
+ }
}
//______________________________________________________________________________
{
// Check validity of input data. If necessary, create xml files.
if (!fInputFiles && !fRunNumbers.Length() && !fRunRange[0]) {
- Error("CheckInputData", "You have to specify either a set of run numbers or some existing grid files. Use AddRunNumber()/AddDataFile()/SetRunRange().");
- return kFALSE;
+ if (!fGridDataDir.Length()) {
+ Error("CkeckInputData", "AliEn path to base data directory must be set.\n = Use: SetGridDataDir()");
+ return kFALSE;
+ }
+ Info("CheckInputData", "Analysis will make a single xml for base data directory %s",fGridDataDir.Data());
+ return kTRUE;
}
// Process declared files
Bool_t is_collection = kFALSE;
Error("CkeckInputData", "AliEn path to base data directory must be set.\n = Use: SetGridDataDir()");
return kFALSE;
}
- if (!gGrid->Cd(fGridDataDir)) {
+ if (!DirectoryExists(fGridDataDir)) {
Error("CheckInputData", "Data directory %s not existing.", fGridDataDir.Data());
return kFALSE;
}
TIter next(arr);
while ((os=(TObjString*)next())) {
path = Form("%s/%s ", fGridDataDir.Data(), os->GetString().Data());
- if (!gGrid->Cd(path)) {
- Warning("CheckInputData", "Run number %s not found in path: %s", os->GetString().Data(), path.Data());
+ if (!DirectoryExists(path)) {
+ Warning("CheckInputData", "Run number %s not found in path: <%s>", os->GetString().Data(), path.Data());
continue;
}
path = Form("%s/%s.xml", workdir.Data(),os->GetString().Data());
else msg += " using_tags: No";
Info("CheckDataType", msg.Data());
if (fNrunsPerMaster<2) {
- AddDataFile(path);
+ AddDataFile(Form("%s.xml", os->GetString().Data()));
} else {
nruns++;
if (((nruns-1)%fNrunsPerMaster) == 0) {
}
if ((nruns%fNrunsPerMaster)!=0 && os!=arr->Last()) continue;
schunk += Form("_%s.xml", os->GetString().Data());
- path = Form("%s/%s", workdir.Data(), schunk.Data());
- AddDataFile(path);
+ AddDataFile(schunk);
}
}
delete arr;
Info("CheckDataType", "Using run range [%d, %d]", fRunRange[0], fRunRange[1]);
for (Int_t irun=fRunRange[0]; irun<=fRunRange[1]; irun++) {
path = Form("%s/%d ", fGridDataDir.Data(), irun);
- if (!gGrid->Cd(path)) {
- Warning("CheckInputData", "Run number %d not found in path: %s", irun, path.Data());
+ if (!DirectoryExists(path)) {
+// Warning("CheckInputData", "Run number %d not found in path: <%s>", irun, path.Data());
continue;
}
path = Form("%s/%d.xml", workdir.Data(),irun);
else msg += " using_tags: No";
Info("CheckDataType", msg.Data());
if (fNrunsPerMaster<2) {
- AddDataFile(path);
+ AddDataFile(Form("%d.xml",irun));
} else {
nruns++;
if (((nruns-1)%fNrunsPerMaster) == 0) {
}
if ((nruns%fNrunsPerMaster)!=0 && irun != fRunRange[1]) continue;
schunk += Form("_%d.xml", irun);
- path = Form("%s/%s", workdir.Data(), schunk.Data());
- AddDataFile(path);
+ AddDataFile(schunk);
}
}
}
Int_t nruns = 0;
TString schunk;
TGridCollection *cbase=0, *cadd=0;
- if (!fRunNumbers.Length() && !fRunRange[0]) return kTRUE;
+ if (!fRunNumbers.Length() && !fRunRange[0]) {
+ if (fInputFiles && fInputFiles->GetEntries()) return kTRUE;
+ // Make a single data collection from data directory.
+ path = fGridDataDir;
+ if (!DirectoryExists(path)) {
+ Error("CreateDataset", "Path to data directory %s not valid",fGridDataDir.Data());
+ return kFALSE;
+ }
+// CdWork();
+ if (TestBit(AliAnalysisGrid::kTest)) file = "wn.xml";
+ else file = Form("%s.xml", gSystem->BaseName(path));
+ if (gSystem->AccessPathName(file) || TestBit(AliAnalysisGrid::kTest)) {
+ command = "find ";
+ command += options;
+ command += path;
+ command += " ";
+ command += pattern;
+ command += conditions;
+ printf("command: %s\n", command.Data());
+ TGridResult *res = gGrid->Command(command);
+ if (res) delete res;
+ // Write standard output to file
+ gROOT->ProcessLine(Form("gGrid->Stdout(); > %s", file.Data()));
+ }
+ if (!TestBit(AliAnalysisGrid::kTest) && !FileExists(file)) {
+ // Copy xml file to alien space
+ TFile::Cp(Form("file:%s",file.Data()), Form("alien://%s/%s",workdir.Data(), file.Data()));
+ if (!FileExists(file)) {
+ Error("CreateDataset", "Command %s did NOT succeed", command.Data());
+ return kFALSE;
+ }
+ // Update list of files to be processed.
+ }
+ AddDataFile(Form("%s/%s", workdir.Data(), file.Data()));
+ return kTRUE;
+ }
// Several runs
if (fRunNumbers.Length()) {
TObjArray *arr = fRunNumbers.Tokenize(" ");
TIter next(arr);
while ((os=(TObjString*)next())) {
path = Form("%s/%s ", fGridDataDir.Data(), os->GetString().Data());
+ if (!DirectoryExists(path)) continue;
+// CdWork();
if (TestBit(AliAnalysisGrid::kTest)) file = "wn.xml";
else file = Form("%s.xml", os->GetString().Data());
// If local collection file does not exist, create it via 'find' command.
Info("CreateDataset", "\n##### Dataset %s exist. Skipping creation...", schunk.Data());
continue;
}
- printf("Exporting merged collection <%s> and copying to AliEn.\n", schunk.Data());
+ printf("Exporting merged collection <%s> and copying to AliEn\n", schunk.Data());
cbase->ExportXML(Form("file://%s", schunk.Data()),kFALSE,kFALSE, schunk, "Merged runs");
- TFile::Cp(Form("file:%s",file.Data()), Form("alien://%s/%s",workdir.Data(), file.Data()));
+ TFile::Cp(Form("file:%s",schunk.Data()), Form("alien://%s/%s",workdir.Data(), schunk.Data()));
if (!FileExists(schunk)) {
Error("CreateDataset", "Copy command did NOT succeed for %s", schunk.Data());
delete arr;
// Process a full run range.
for (Int_t irun=fRunRange[0]; irun<=fRunRange[1]; irun++) {
path = Form("%s/%d ", fGridDataDir.Data(), irun);
+ if (!DirectoryExists(path)) continue;
+// CdWork();
if (TestBit(AliAnalysisGrid::kTest)) file = "wn.xml";
else file = Form("%d.xml", irun);
if (FileExists(file) && fNrunsPerMaster<2 && !TestBit(AliAnalysisGrid::kTest)) {
}
} else {
nruns++;
+ // Check if the collection for the chunk exist locally.
+ Int_t nchunk = (nruns-1)/fNrunsPerMaster;
+ if (FileExists(fInputFiles->At(nchunk)->GetName())) continue;
printf(" Merging collection <%s> into %d runs chunk...\n",file.Data(),fNrunsPerMaster);
if (((nruns-1)%fNrunsPerMaster) == 0) {
schunk = Form("%d", irun);
}
printf("Exporting merged collection <%s> and copying to AliEn.\n", schunk.Data());
cbase->ExportXML(Form("file://%s", schunk.Data()),kFALSE,kFALSE, schunk, "Merged runs");
+ if (FileExists(schunk)) {
+ Info("CreateDataset", "\n##### Dataset %s exist. Skipping copy...", schunk.Data());
+ continue;
+ }
TFile::Cp(Form("file:%s",schunk.Data()), Form("alien://%s/%s",workdir.Data(), schunk.Data()));
if (!FileExists(schunk)) {
Error("CreateDataset", "Copy command did NOT succeed for %s", schunk.Data());
Error("CreateJDL", "You must define AliEn output directory");
error = kTRUE;
} else {
- if (!gGrid->Cd(fGridOutputDir)) {
+ if (!fGridOutputDir.Contains("/")) fGridOutputDir = Form("%s/%s", workdir.Data(), fGridOutputDir.Data());
+ if (!DirectoryExists(fGridOutputDir)) {
if (gGrid->Mkdir(fGridOutputDir)) {
Info("CreateJDL", "\n##### Created alien output directory %s", fGridOutputDir.Data());
} else {
Error("CreateJDL", "Could not create alien output directory %s", fGridOutputDir.Data());
- error = kTRUE;
+ // error = kTRUE;
}
}
gGrid->Cd(workdir);
fGridJDL->SetInputDataListFormat(fInputFormat);
fGridJDL->SetInputDataList("wn.xml");
fGridJDL->AddToInputSandbox(Form("LF:%s/%s", workdir.Data(), fAnalysisMacro.Data()));
- fGridJDL->AddToInputSandbox(Form("LF:%s/analysis.root", workdir.Data()));
+ TString analysisFile = fExecutable;
+ analysisFile.ReplaceAll(".sh", ".root");
+ fGridJDL->AddToInputSandbox(Form("LF:%s/%s", workdir.Data(),analysisFile.Data()));
if (IsUsingTags() && !gSystem->AccessPathName("ConfigureCuts.C"))
fGridJDL->AddToInputSandbox(Form("LF:%s/ConfigureCuts.C", workdir.Data()));
if (fAdditionalLibs.Length()) {
arr = fOutputFiles.Tokenize(" ");
TIter next(arr);
while ((os=(TObjString*)next())) {
+ // Ignore ouputs in jdl that are also in outputarchive
+ TString sout = os->GetString();
+ if (sout.Index("@")>0) sout.Remove(sout.Index("@"));
+ if (fOutputArchive.Contains(sout)) continue;
if (!os->GetString().Contains("@") && fCloseSE.Length())
fGridJDL->AddToOutputSandbox(Form("%s@%s",os->GetString().Data(), fCloseSE.Data()));
else
delete arr;
// fGridJDL->SetPrice((UInt_t)fPrice);
fGridJDL->SetValue("Price", Form("\"%d\"", fPrice));
- fGridJDL->SetValidationCommand(Form("%s/validate.sh", workdir.Data()));
+ TString validationScript = fExecutable;
+ validationScript.ReplaceAll(".sh", "_validation.sh");
+ fGridJDL->SetValidationCommand(Form("%s/%s", workdir.Data(),validationScript.Data()));
if (fMasterResubmitThreshold) fGridJDL->SetValue("MasterResubmitThreshold", Form("\"%d%%\"", fMasterResubmitThreshold));
- // Depending if going through a run range or not, generate one or mode jdl's
- if (!fRunRange[0]) WriteJDL(-1,copy);
- else {
- for (Int_t irun=fRunRange[0]; irun<=fRunRange[1]; irun++)
- if (!WriteJDL(irun-fRunRange[0],copy)) break;
- }
+ // Write a jdl with 2 input parameters: collection name and output dir name.
+ WriteJDL(copy);
}
// Copy jdl to grid workspace
if (copy) {
}
//______________________________________________________________________________
-Bool_t AliAnalysisAlien::WriteJDL(Int_t findex, Bool_t copy)
+Bool_t AliAnalysisAlien::WriteJDL(Bool_t copy)
{
// Writes one or more JDL's corresponding to findex. If findex is negative,
// 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 line;
TString workdir = gGrid->GetHomeDirectory();
workdir += fGridWorkingDir;
- if (findex < 0) {
+
+ if (!fRunNumbers.Length() && !fRunRange[0]) {
+ // One jdl with no parameters in case input data is specified by name.
TIter next(fInputFiles);
while ((os=(TObjString*)next()))
fGridJDL->AddToInputDataCollection(Form("LF:%s,nodownload", os->GetString().Data()));
- fGridJDL->SetOutputDirectory(Form("%s/%s/#alien_counter_03i#", workdir.Data(), fGridOutputDir.Data()));
+ fGridJDL->SetOutputDirectory(Form("%s/#alien_counter_03i#", fGridOutputDir.Data()));
} else {
- os = (TObjString*)fInputFiles->At(findex);
- if (!os) return kFALSE;
- line = "#Input xml collection\n";
- line += "InputDataCollection = {";
- line += Form(" \"LF:%s,nodownload\"", os->GetString().Data());
- line += "\n};\n";
- fGridJDL->SetOutputDirectory(Form("%s/%s/%03d#alien_counter_03i#", workdir.Data(), fGridOutputDir.Data(),findex));
+ // 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()));
+ fGridJDL->SetOutputDirectory(Form("%s/$2/#alien_counter_03i#", fGridOutputDir.Data()));
}
if (index >= 0) sjdl.Insert(index, "\n# We want each subjob to get maximum this number of input files\n");
index = sjdl.Index("InputDataCollection");
if (index >= 0) sjdl.Insert(index, "# Input xml collections\n");
- else {
- index = sjdl.Index("OutputDir");
- sjdl.Insert(index, line.Data());
- }
index = sjdl.Index("InputFile");
if (index >= 0) sjdl.Insert(index, "\n# List of input files to be uploaded to wn's\n");
index = sjdl.Index("InputDataList ");
sjdl.ReplaceAll("\n\n", "\n");
sjdl.ReplaceAll("OutputDirectory", "OutputDir");
sjdl += "JDLVariables = \n{\n \"Packages\",\n \"OutputDir\"\n};\n";
- sjdl.Prepend("JobTag = \"Automatically generated analysis JDL\";\n");
+ sjdl.Prepend(Form("Jobtag = {\n \"comment:%s\"\n};\n", fJobTag.Data()));
index = sjdl.Index("JDLVariables");
if (index >= 0) sjdl.Insert(index, "\n# JDL variables\n");
// Write jdl to file
- TString snjdl = fJDLName;
- if (findex >=0) snjdl.ReplaceAll(".jdl", Form("_%03d.jdl", findex));
ofstream out;
- out.open(snjdl.Data(), ios::out);
+ out.open(fJDLName.Data(), ios::out);
if (out.bad()) {
- Error("CreateJDL", "Bad file name: %s", snjdl.Data());
+ Error("CreateJDL", "Bad file name: %s", fJDLName.Data());
return kFALSE;
}
out << sjdl << endl;
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());
} else {
- Info("CreateJDL", "\n##### Copying JDL file <%s> to your AliEn working space", snjdl.Data());
- if (FileExists(snjdl)) gGrid->Rm(snjdl);
- TFile::Cp(Form("file:%s",snjdl.Data()), Form("alien://%s/%s", workdir.Data(), snjdl.Data()));
+ Info("CreateJDL", "\n##### Copying JDL file <%s> to your AliEn output directory", fJDLName.Data());
+ TString locjdl = Form("%s/%s", fGridOutputDir.Data(),fJDLName.Data());
+ if (fProductionMode)
+ locjdl = Form("%s/%s", workdir.Data(),fJDLName.Data());
+ if (FileExists(locjdl)) gGrid->Rm(locjdl);
+ TFile::Cp(Form("file:%s",fJDLName.Data()), Form("alien://%s", locjdl.Data()));
}
return kTRUE;
}
//______________________________________________________________________________
-Bool_t AliAnalysisAlien::FileExists(const char *lfn) const
+Bool_t AliAnalysisAlien::FileExists(const char *lfn)
{
// Returns true if file exists.
- if (!gGrid) {
- Error("FileExists", "No connection to grid");
- return kFALSE;
- }
+ if (!gGrid) return kFALSE;
TGridResult *res = gGrid->Ls(lfn);
if (!res) return kFALSE;
TMap *map = dynamic_cast<TMap*>(res->At(0));
return kTRUE;
}
+//______________________________________________________________________________
+Bool_t AliAnalysisAlien::DirectoryExists(const char *dirname)
+{
+// Returns true if directory exists. Can be also a path.
+ if (!gGrid) return kFALSE;
+ // Check if dirname is a path
+ TString dirstripped = dirname;
+ dirstripped = dirstripped.Strip();
+ dirstripped = dirstripped.Strip(TString::kTrailing, '/');
+ TString dir = gSystem->BaseName(dirstripped);
+ dir += "/";
+ TString path = gSystem->DirName(dirstripped);
+ TGridResult *res = gGrid->Ls(path, "-F");
+ if (!res) return kFALSE;
+ TIter next(res);
+ TMap *map;
+ TObject *obj;
+ while ((map=dynamic_cast<TMap*>(next()))) {
+ obj = map->GetValue("name");
+ if (!obj) break;
+ if (dir == obj->GetName()) {
+ delete res;
+ return kTRUE;
+ }
+ }
+ delete res;
+ return kFALSE;
+}
+
//______________________________________________________________________________
void AliAnalysisAlien::CheckDataType(const char *lfn, Bool_t &is_collection, Bool_t &is_xml, Bool_t &use_tags)
{
fPackages->Add(new TObjString(pkg));
}
+//______________________________________________________________________________
+const char *AliAnalysisAlien::GetJobStatus(Int_t jobidstart, Int_t lastid, Int_t &nrunning, Int_t &nwaiting, Int_t &nerror, Int_t &ndone)
+{
+// Get job status for all jobs with jobid>jobidstart.
+ static char mstatus[20];
+ mstatus[0] = '\0';
+ nrunning = 0;
+ nwaiting = 0;
+ nerror = 0;
+ ndone = 0;
+ TGridJobStatusList *list = gGrid->Ps("");
+ if (!list) return mstatus;
+ Int_t nentries = list->GetSize();
+ TGridJobStatus *status;
+ Int_t pid;
+ for (Int_t ijob=0; ijob<nentries; ijob++) {
+ status = (TGridJobStatus *)list->At(ijob);
+ pid = gROOT->ProcessLine(Form("atoi(((TAlienJobStatus*)0x%lx)->GetKey(\"queueId\"));", (ULong_t)status));
+ if (pid<jobidstart) continue;
+ if (pid == lastid) {
+ gROOT->ProcessLine(Form("sprintf((char*)0x%lx,((TAlienJobStatus*)0x%lx)->GetKey(\"status\"));",(ULong_t)mstatus, (ULong_t)status));
+ }
+ switch (status->GetStatus()) {
+ case TGridJobStatus::kWAITING:
+ nwaiting++; break;
+ case TGridJobStatus::kRUNNING:
+ nrunning++; break;
+ case TGridJobStatus::kABORTED:
+ case TGridJobStatus::kFAIL:
+ case TGridJobStatus::kUNKNOWN:
+ nerror++; break;
+ case TGridJobStatus::kDONE:
+ ndone++;
+ }
+ }
+ list->Delete();
+ delete list;
+ return mstatus;
+}
+
//______________________________________________________________________________
Bool_t AliAnalysisAlien::IsCollection(const char *lfn) const
{
{
// Print current plugin settings.
printf("### AliEn analysis plugin current settings ###\n");
+ printf("= Production mode:______________________________ %d\n", fProductionMode);
printf("= Version of API requested: ____________________ %s\n", fAPIVersion.Data());
printf("= Version of ROOT requested: ___________________ %s\n", fROOTVersion.Data());
printf("= Version of AliRoot requested: ________________ %s\n", fAliROOTVersion.Data());
fMaxMergeFiles = 100;
fRunNumbers = "";
fExecutable = "analysis.sh";
+ fExecutableCommand = "root -b -q";
fArguments = "";
fAnalysisMacro = "myAnalysis.C";
fAnalysisSource = "";
fOutputFiles = ""; // Like "AliAODs.root histos.root"
fInputFormat = "xml-single";
fJDLName = "analysis.jdl";
+ fJobTag = "Automatically generated analysis JDL";
fMergeExcludes = "";
}
return kFALSE;
}
// Get the output path
- TString output = Form("/%s/%s/%s", gGrid->GetHomeDirectory(), fGridWorkingDir.Data(), fGridOutputDir.Data());
- if (!gGrid->Cd(output)) output = Form("/%s/%s", gGrid->GetHomeDirectory(), fGridOutputDir.Data());
- if (!gGrid->Cd(output)) {
+ if (!fGridOutputDir.Contains("/")) fGridOutputDir = Form("/%s/%s/%s", gGrid->GetHomeDirectory(), fGridWorkingDir.Data(), fGridOutputDir.Data());
+ if (!DirectoryExists(fGridOutputDir)) {
Error("MergeOutputs", "Grid output directory %s not found. Terminate() will NOT be executed", fGridOutputDir.Data());
return kFALSE;
}
if (fMergeExcludes.Length() &&
fMergeExcludes.Contains(output_file.Data())) continue;
// Perform a 'find' command in the output directory, looking for registered outputs
- command = Form("find %s/ *%s", output.Data(), output_file.Data());
+ command = Form("find %s/ *%s", fGridOutputDir.Data(), output_file.Data());
printf("command: %s\n", command.Data());
TGridResult *res = gGrid->Command(command);
if (!res) continue;
}
//______________________________________________________________________________
-void AliAnalysisAlien::StartAnalysis(Long64_t /*nentries*/, Long64_t /*firstEntry*/)
+Bool_t AliAnalysisAlien::StartAnalysis(Long64_t /*nentries*/, Long64_t /*firstEntry*/)
{
// Start remote grid analysis.
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
if (!mgr || !mgr->IsInitialized()) {
Error("StartAnalysis", "You need an initialized analysis manager for this");
- return;
+ return kFALSE;
}
fOutputFiles = "";
TIter next(mgr->GetOutputs());
if (!mgr->GetOutputEventHandler()) continue;
filename = mgr->GetOutputEventHandler()->GetOutputFileName();
}
+ if (fOutputFiles.Contains(filename)) continue;
if (fOutputFiles.Length()) fOutputFiles += " ";
fOutputFiles += filename;
}
if (mgr->GetExtraFiles().Length()) {
if (fOutputFiles.Length()) fOutputFiles += " ";
fOutputFiles += mgr->GetExtraFiles();
- }
+ }
}
// if (!fCloseSE.Length()) fCloseSE = gSystem->Getenv("alien_CLOSE_SE");
if (TestBit(AliAnalysisGrid::kOffline)) {
\n space and job submitted.");
} else if (TestBit(AliAnalysisGrid::kMerge)) {
Info("StartAnalysis","\n##### MERGE MODE ##### The registered outputs of the analysis will be merged");
- return;
+ return kTRUE;
} else {
Info("StartAnalysis","\n##### FULL ANALYSIS MODE ##### Producing needed files and submitting your analysis job...");
}
if (!Connect()) {
Error("StartAnalysis", "Cannot start grid analysis without grid connection");
- return;
+ return kFALSE;
}
Print();
if (!CheckInputData()) {
Error("StartAnalysis", "There was an error in preprocessing your requested input data");
- return;
+ return kFALSE;
}
CreateDataset(fDataPattern);
WriteAnalysisFile();
WriteAnalysisMacro();
WriteExecutable();
WriteValidationScript();
- if (!CreateJDL()) return;
- if (TestBit(AliAnalysisGrid::kOffline)) return;
+ if (!CreateJDL()) return kFALSE;
+ if (TestBit(AliAnalysisGrid::kOffline)) return kFALSE;
if (TestBit(AliAnalysisGrid::kTest)) {
// Locally testing the analysis
Info("StartAnalysis", "\n_______________________________________________________________________ \
}
delete list;
gSystem->Exec(Form("bash %s 2>stderr", fExecutable.Data()));
- gSystem->Exec("bash validate.sh");
+ TString validationScript = fExecutable;
+ validationScript.ReplaceAll(".sh", "_validation.sh");
+ gSystem->Exec(Form("bash %s",validationScript.Data()));
// gSystem->Exec("cat stdout");
- return;
+ return kFALSE;
}
+ // Check if submitting is managed by LPM manager
+ if (fProductionMode) {
+ TString prodfile = fJDLName;
+ prodfile.ReplaceAll(".jdl", ".prod");
+ WriteProductionFile(prodfile);
+ Info("StartAnalysis", "Job submitting is managed by LPM. Rerun in terminate mode after jobs finished.");
+ return kFALSE;
+ }
// Submit AliEn job(s)
- CdWork();
+ gGrid->Cd(fGridOutputDir);
TGridResult *res;
TString jobID = "";
- if (!fRunRange[0]) {
+ if (!fRunNumbers.Length() && !fRunRange[0]) {
// Submit a given xml or a set of runs
res = gGrid->Command(Form("submit %s", fJDLName.Data()));
printf("*************************** %s\n",Form("submit %s", fJDLName.Data()));
const char *cjobId = res->GetKey(0,"jobId");
if (!cjobId) {
Error("StartAnalysis", "Your JDL %s could not be submitted", fJDLName.Data());
- return;
+ return kFALSE;
} else {
Info("StartAnalysis", "\n_______________________________________________________________________ \
\n##### Your JDL %s was successfully submitted. \nTHE JOB ID IS: %s \
delete res;
}
} else {
- // Submit for a range of runs.
- TString sjdl;
- for (Int_t irun=fRunRange[0]; irun<=fRunRange[1]; irun++) {
- if (!fInputFiles->At(irun-fRunRange[0])) break;
- sjdl = fJDLName;
- sjdl.ReplaceAll(".jdl", Form("_%03d.jdl", irun-fRunRange[0]));
- res = gGrid->Command(Form("submit %s", sjdl.Data()));
- printf("*************************** %s\n",Form("submit %s", sjdl.Data()));
- if (res) {
- const char *cjobId1 = res->GetKey(0,"jobId");
- if (!cjobId1) {
- Error("StartAnalysis", "Your JDL %s could not be submitted", sjdl.Data());
- return;
- } else {
- Info("StartAnalysis", "\n_______________________________________________________________________ \
- \n##### Your JDL %s was successfully submitted. \nTHE JOB ID IS: %s \
- \n_______________________________________________________________________",
- sjdl.Data(), cjobId1);
- jobID += cjobId1;
- jobID += " ";
- }
- delete res;
- }
- }
+ // Submit for a range of enumeration of runs.
+ Submit();
}
Info("StartAnalysis", "\n#### STARTING AN ALIEN SHELL FOR YOU. EXIT WHEN YOUR JOB %s HAS FINISHED. #### \
\n You may exit at any time and terminate the job later using the option <terminate> \
\n ##################################################################################", jobID.Data());
gSystem->Exec("aliensh");
+ return kTRUE;
+}
+
+//______________________________________________________________________________
+void AliAnalysisAlien::Submit()
+{
+// Submit all master jobs.
+ Int_t nmasterjobs = fInputFiles->GetEntries();
+ Long_t tshoot = gSystem->Now();
+ if (!fNsubmitted) SubmitNext();
+ while (fNsubmitted < nmasterjobs) {
+ Long_t now = gSystem->Now();
+ if ((now-tshoot)>30000) {
+ tshoot = now;
+ SubmitNext();
+ }
+ }
+}
+
+//______________________________________________________________________________
+void AliAnalysisAlien::SubmitNext()
+{
+// Submit next bunch of master jobs if the queue is free.
+ static Bool_t iscalled = kFALSE;
+ static Int_t firstmaster = 0;
+ static Int_t lastmaster = 0;
+ static Int_t npermaster = 0;
+ if (iscalled) return;
+ iscalled = kTRUE;
+ Int_t nrunning=0, nwaiting=0, nerror=0, ndone=0;
+ Int_t ntosubmit = 0;
+ TGridResult *res;
+ TString jobID = "";
+ if (!fNsubmitted) ntosubmit = 1;
+ 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
+ if (status != "SPLIT") {iscalled = kFALSE; return;}
+ // No more than 100 waiting jobs
+ if (nwaiting>100) {iscalled = kFALSE; return;}
+ npermaster = (nrunning+nwaiting+nerror+ndone)/fNsubmitted;
+ if (npermaster) ntosubmit = (100-nwaiting)/npermaster;
+ 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;}
+ TString query;
+ query = Form("submit %s %s %03d", fJDLName.Data(), fInputFiles->At(fNsubmitted)->GetName(), fNsubmitted);
+ printf("********* %s\n",query.Data());
+ res = gGrid->Command(query);
+ if (res) {
+ TString cjobId1 = res->GetKey(0,"jobId");
+ if (!cjobId1.Length()) {
+ Error("StartAnalysis", "Your JDL %s could not be submitted", fJDLName.Data());
+ iscalled = kFALSE;
+ return;
+ } else {
+ Info("StartAnalysis", "\n_______________________________________________________________________ \
+ \n##### Your JDL %s submitted (%d to go). \nTHE JOB ID IS: %s \
+ \n_______________________________________________________________________",
+ fJDLName.Data(), nmasterjobs-fNsubmitted-1, cjobId1.Data());
+ jobID += cjobId1;
+ jobID += " ";
+ lastmaster = cjobId1.Atoi();
+ if (!firstmaster) firstmaster = lastmaster;
+ fNsubmitted++;
+ }
+ delete res;
+ }
+ }
+ iscalled = kFALSE;
}
//______________________________________________________________________________
void AliAnalysisAlien::WriteAnalysisFile()
{
-// Write current analysis manager into the file analysis.root
+// Write current analysis manager into the file <analysisFile>
+ TString analysisFile = fExecutable;
+ analysisFile.ReplaceAll(".sh", ".root");
if (!TestBit(AliAnalysisGrid::kSubmit)) {
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
if (!mgr || !mgr->IsInitialized()) {
if (handler->InheritsFrom("AliAODInputHandler")) TObject::SetBit(AliAnalysisGrid::kUseAOD);
}
TDirectory *cdir = gDirectory;
- TFile *file = TFile::Open("analysis.root", "RECREATE");
+ TFile *file = TFile::Open(analysisFile, "RECREATE");
if (file) {
mgr->Write();
delete file;
}
if (cdir) cdir->cd();
- Info("WriteAnalysisFile", "\n##### Analysis manager: %s wrote to file <analysis.root>\n", mgr->GetName());
+ 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;
CdWork();
TString workdir = gGrid->GetHomeDirectory();
workdir += fGridWorkingDir;
- Info("CreateJDL", "\n##### Copying file <analysis.root> containing your initialized analysis manager to your alien workspace");
- if (FileExists("analysis.root")) gGrid->Rm("analysis.root");
- TFile::Cp("file:analysis.root", Form("alien://%s/analysis.root", workdir.Data()));
+ Info("CreateJDL", "\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()));
}
}
if (IsUsingTags()) {
out << " TChain *chain = CreateChainFromTags(\"wn.xml\", anatype);" << endl << endl;
} else {
- out << " TChain *chain = CreateChain(\"wn.xml\", anatype);" << endl << endl;
+ if(fFriendChainName!="AliAOD.VertexingHF.root") {
+ out << " TChain *chain = CreateChain(\"wn.xml\", anatype);" << endl << endl;
+ } else {
+ out << " // Check if the macro to create the chain was provided" << endl;
+ out << " if (gSystem->AccessPathName(\"MakeAODInputChain.C\")) {" << endl;
+ out << " ::Error(\"" << func.Data() << "\", \"File MakeAODInputChain.C not provided. Aborting.\");" << endl;
+ out << " return;" << endl;
+ out << " }" << endl;
+ out << " gROOT->LoadMacro(\"MakeAODInputChain.C\");" << endl;
+ out << " TChain *chain = MakeAODInputChain(\"wn.xml\",\"none\");" << endl << endl;
+ }
}
out << "// read the analysis manager from file" << endl;
- out << " TFile *file = TFile::Open(\"analysis.root\");" << endl;
+ TString analysisFile = fExecutable;
+ analysisFile.ReplaceAll(".sh", ".root");
+ out << " TFile *file = TFile::Open(\"" << analysisFile << "\");" << endl;
out << " if (!file) return;" << endl;
out << " TIter nextkey(file->GetListOfKeys());" << endl;
out << " AliAnalysisManager *mgr = 0;" << endl;
out << " mgr = (AliAnalysisManager*)file->Get(key->GetName());" << endl;
out << " };" << endl;
out << " if (!mgr) {" << endl;
- out << " ::Error(\"" << func.Data() << "\", \"No analysis manager found in file analysis.root\");" << endl;
+ out << " ::Error(\"" << func.Data() << "\", \"No analysis manager found in file" << analysisFile <<"\");" << endl;
out << " return;" << endl;
out << " }" << endl << endl;
out << " mgr->PrintStatus();" << endl;
ofstream out;
out.open(fExecutable.Data(), ios::out);
if (out.bad()) {
- Error("CreateJDL", "Bad file name for executable: %s", fExecutable.Data());
+ Error("WriteExecutable", "Bad file name for executable: %s", fExecutable.Data());
return;
}
out << "#!/bin/bash" << endl;
- out << "export GCLIENT_SERVER_LIST=\"pcapiserv04.cern.ch:10000|pcapiserv05.cern.ch:10000|pcapiserv06.cern.ch:10000|pcapiserv07.cern.ch:10000\"" << endl;
out << "echo \"=========================================\"" << endl;
out << "echo \"############## PATH : ##############\"" << endl;
out << "echo $PATH" << endl;
out << "which aliroot" << endl;
out << "echo \"=========================================\"" << endl << endl;
// if (TestBit(AliAnalysisGrid::kTest)) out << "root ";
- out << "root -b -q ";
+ out << fExecutableCommand << " ";
out << fAnalysisMacro.Data() << endl << endl;
out << "echo \"======== " << fAnalysisMacro.Data() << " finished ========\"" << endl;
}
if (copy) {
CdWork();
TString workdir = gGrid->GetHomeDirectory();
+ TString bindir = Form("%s/bin", workdir.Data());
+ if (!DirectoryExists(bindir)) gGrid->Mkdir(bindir);
workdir += fGridWorkingDir;
TString executable = Form("%s/bin/%s", gGrid->GetHomeDirectory(), fExecutable.Data());
if (FileExists(executable)) gGrid->Rm(executable);
}
}
+//______________________________________________________________________________
+void AliAnalysisAlien::WriteProductionFile(const char *filename) const
+{
+// Write the production file to be submitted by LPM manager. The format is:
+// First line: full_path_to_jdl estimated_no_subjobs_per_master
+// Next lines: full_path_to_dataset XXX (XXX is a string)
+// To submit, one has to: submit jdl XXX for all lines
+ ofstream out;
+ out.open(filename, ios::out);
+ if (out.bad()) {
+ Error("WriteProductionFile", "Bad file name: %s", filename);
+ return;
+ }
+ TString workdir = gGrid->GetHomeDirectory();
+ workdir += fGridWorkingDir;
+ Int_t njobspermaster = 1000*fNrunsPerMaster/fSplitMaxInputFileNumber;
+ TString locjdl = Form("%s/%s", workdir.Data(),fJDLName.Data());
+ out << locjdl << " " << njobspermaster << endl;
+ Int_t nmasterjobs = fInputFiles->GetEntries();
+ for (Int_t i=0; i<nmasterjobs; i++) {
+ out << Form("%s", fInputFiles->At(i)->GetName()) << " " << Form("%03d", i) << endl;
+ }
+ Info("WriteProductionFile", "\n##### Copying production file <%s> to your work directory", filename);
+ TFile::Cp(Form("file:%s",filename), Form("alien://%s/%s", workdir.Data(),filename));
+}
+
//______________________________________________________________________________
void AliAnalysisAlien::WriteValidationScript()
{
// Generate the alien validation script.
// Generate the validation script
TObjString *os;
+ TString validationScript = fExecutable;
+ validationScript.ReplaceAll(".sh", "_validation.sh");
if (!Connect()) {
Error("WriteValidationScript", "Alien connection required");
return;
if (!TestBit(AliAnalysisGrid::kTest)) out_stream = " >> stdout";
if (!TestBit(AliAnalysisGrid::kSubmit)) {
ofstream out;
- out.open("validate.sh", ios::out);
+ out.open(validationScript, ios::out);
out << "#!/bin/bash" << endl;
out << "##################################################" << endl;
out << "validateout=`dirname $0`" << endl;
out << "fi" << endl;
}
delete arr;
+ out << "if ! [ -f outputs_valid ] ; then" << endl;
+ out << " error=1" << endl;
+ out << " echo \"Output files were not validated by the analysis manager\" >> stdout" << endl;
+ out << " echo \"Output files were not validated by the analysis manager\" >> stderr" << endl;
+ out << "fi" << endl;
+
out << "if [ $error = 0 ] ; then" << endl;
out << " echo \"* ---------------- Job Validated ------------------*\"" << out_stream << endl;
out << "fi" << endl;
CdWork();
TString workdir = gGrid->GetHomeDirectory();
workdir += fGridWorkingDir;
- Info("CreateJDL", "\n##### Copying validation script <validate.sh> to your AliEn working space");
- if (FileExists("validate.sh")) gGrid->Rm("validate.sh");
- TFile::Cp("file:validate.sh", Form("alien://%s/validate.sh", workdir.Data()));
+ Info("CreateJDL", "\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