Various hacks to fix up DAs:
authorcholm <Christian.Holm.Christensen@cern.ch>
Fri, 20 Feb 2015 12:49:27 +0000 (13:49 +0100)
committercholm <Christian.Holm.Christensen@cern.ch>
Fri, 20 Feb 2015 12:49:27 +0000 (13:49 +0100)
- Do not upload from program - rely on wrapper script to do it
- Use own implementation of daqDA_FES_storeFile to circumvent call
  to "fork" that goes out of memory (solution uses vfork).

Other improvements to the code - minor stuff.

FMD/DA/FMDBaseda.cxx
FMD/DA/FMDGainda.cxx
FMD/DA/FMDPedestalda.cxx
FMD/DA/FMDUtilda.h
FMD/FMDutil/AliFMDBaseDA.cxx
FMD/FMDutil/AliFMDBaseDA.h
FMD/FMDutil/AliFMDGainDA.cxx
FMD/FMDutil/AliFMDGainDA.h
FMD/FMDutil/AliFMDPedestalDA.cxx
FMD/FMDutil/AliFMDPedestalDA.h

index 2047c6b..46dcdc7 100644 (file)
@@ -49,61 +49,27 @@ int main(int argc, char **argv)
                                        "RIO",
                                        "TStreamerInfo()");
 #endif
+  AliFMDBaseDA::Runner r;
+
+  Int_t ret = r.Init(argc, argv, false);
+  if (ret < 0) return -ret;
+  if (ret > 0) return 0;
+
   
   
   const Char_t* tableSOD[]  = {"ALL", "no", "SOD", "all", NULL, NULL};
 
-  Bool_t old = kTRUE;
   monitorDeclareTable(const_cast<char**>(tableSOD));
 
-  AliFMDParameters::Instance()->Init(kFALSE,0);
-  AliFMDParameters::Instance()->UseCompleteHeader(old);
-
-  Int_t  debugLevel = 0;
-  Bool_t badOption  = false;
-  char*  source     = 0;
-  for (int i = 1; i < argc; i++) { 
-    if (argv[i][0] == '-') { // Options 
-      if (argv[i][1] == '-') { // Long option 
-       TString arg(&(argv[i][2])); 
-       if      (arg.EqualTo("help")) { usage(std::cout, argv[0]); return 0; }
-       if      (arg.EqualTo("diagnostics")) { }
-       else if (arg.EqualTo("debug")) debugLevel = atoi(argv[++i]); 
-       else                             badOption = true;
-      }
-      else { // Short option 
-       switch (argv[i][1]) { 
-       case 'h': usage(std::cout, argv[0]); return 0; 
-       case 'd': break; 
-       case 'D': debugLevel = atoi(argv[++i]); break;
-       default:  badOption = true;
-       }
-      }
-      if (badOption) { 
-       std::cerr << argv[0] << ": Unknown option " << argv[i] 
-                 << std::endl;
-       return 1;
-      }
-    }
-    else { 
-      if (!source) source     = argv[i];
-      else         debugLevel = atoi(argv[i]);
-    }
-  }
-  if (!source) { 
-    printf("%s: No data source specified\n", argv[0]);
-    return -1;
-  }
-  int status=monitorSetDataSource(source);
+  int status = monitorSetDataSource(r.fSource.Data());
   if (status!=0) {
     printf("monitorSetDataSource() failed for %s: %s\n",
-          source, monitorDecodeError(status));
+          r.fSource.Data(), monitorDecodeError(status));
     return -1;
   }
   
-  AliLog::SetModuleDebugLevel("FMD", debugLevel);
   /* declare monitoring program */
-  status=monitorDeclareMp( __FILE__ );
+  status = monitorDeclareMp( __FILE__ );
   if (status!=0) {
     printf("monitorDeclareMp() failed : %s\n",monitorDecodeError(status));
     return -1;
@@ -112,11 +78,10 @@ int main(int argc, char **argv)
   monitorSetNowait();
   monitorSetNoWaitNetworkTimeout(1000);
 
-  AliRawReader* reader  = 0;
   AliFMDBaseDA  baseDA;
-  Int_t         retval  = 0;
   Int_t         iev     = 0;
-  Bool_t        sodSeen = kFALSE;
+  Bool_t        sodSeen = false;
+  Bool_t        success = false;
   while(!sodSeen && iev<1000) {
     
     /* check shutdown condition */
@@ -142,25 +107,29 @@ int main(int argc, char **argv)
     iev++; 
     
     switch (event->eventType) {
-    case START_OF_DATA:
+    case START_OF_DATA: {
       std::cout << "Got START OF DATA event" << std::endl;
-      reader = new AliRawReaderDate((void*)event);
-      baseDA.Run(reader, true);
+      AliRawReader* reader = new AliRawReaderDate((void*)event);
+      if (!(success = baseDA.Run(reader, r.fAppendRun, true)))     
+       std::cout << "Base DA failed" << std::endl;
       sodSeen = kTRUE;
-      std::cout << "Pushing to FXS" << std::endl;
-      retval = 
-       daqDA_FES_storeFile("conditions.csv", 
-                           AliFMDParameters::Instance()
-                           ->GetConditionsShuttleID());
-      if (retval != 0) std::cerr << "Base DA failed" << std::endl;
-      
+    }
       break;
-    
     default:
       break;
     
     }
   }
+  int retval = success ? 0 : 1;
+  if (r.fUpload && success) {
+    std::cout << "Pushing to FXS" << std::endl;
+    retval = 
+      daqDA_FES_storeFile("conditions.csv", 
+                         AliFMDParameters::Instance()
+                         ->GetConditionsShuttleID());
+    if (retval != 0) std::cerr << "Base DA failed" << std::endl;
+      
+  }
   std::cout << "End of FMD-Base - return " << retval << std::endl;
    
   return retval;
index 8fae0eb..0709d4b 100644 (file)
@@ -31,27 +31,37 @@ int main(int argc, char **argv)
   gainDA.SetMakeSummaries(kTRUE);
 #endif
   std::cout << "Running Gain DA" << std::endl;
-  r.Exec(gainDA);
-
-  const char* files[] = { "conditions.csv", 
-                         "gains.csv", 
-                         0 }; 
-  const char* ids[] = { AliFMDParameters::Instance()->GetConditionsShuttleID(), 
-                       AliFMDParameters::Instance()->GetGainShuttleID(),
-                       0 };
-  ret = UploadFiles(files, ids);
-
-  if(ret > 0) std::cerr << "Gain DA failed" << std::endl;
+  Bool_t success = r.Exec(gainDA);
+  if (!success) { 
+    std::cout << "Failed to execute Gain DA" 
+             << std::endl;
+    ret = 1;
+  }
+  
+  if (success && r.fUpload) {
+    const char* files[] = { "conditions.csv", 
+                           "gains.csv", 
+                           0 }; 
+    const char* ids[] = { AliFMDParameters::Instance()->GetConditionsShuttleID(), 
+                         AliFMDParameters::Instance()->GetGainShuttleID(),
+                         0 };
+    ret = UploadFiles(files, ids, r.fOwnUpload);
+    if (ret > 0) std::cerr << "Upload of gains failed" << std::endl;
+  }
 
-  PostSummaries(gainDA, "gain", r.RunNumber());
+  if (success) 
+    PostSummaries(gainDA, "gain", r.RunNumber());
 
-  std::cout << "End of FMD-Gain, return " << ret << std::endl;
 
   gROOT->SetMustClean(false);
+  if (r.fFast) {
+    std::cout << "Sleep 1 second before getting out" << std::endl;
+    gSystem->Sleep(1000);
+    std::cout << "Now calling _exit(" << ret << ") to finish NOW!" << std::endl;
+    _exit(ret);
+  }
 
-  std::cout << "Now calling _Exit(" << ret << ") to finish NOW!" << std::endl;
-  _exit(ret);
-
+  std::cout << "End of FMD-Gain, return " << ret << std::endl;
   return ret;
 }
 //
index 96e0411..73275bb 100644 (file)
@@ -30,27 +30,38 @@ int main(int argc, char **argv)
 #ifdef ALI_AMORE
   pedDA.SetMakeSummaries(kTRUE);
 #endif
-  std::cout << "Eecuting pedestal DA" << std::endl;
-  r.Exec(pedDA);
-
-  const char* files[] = { "conditions.csv", 
-                         "peds.csv", 
+  std::cout << "Executing pedestal DA" << std::endl;
+  Bool_t success = r.Exec(pedDA);
+  if (!success) {
+    std::cout << "Failed to execute Pedestal DA" 
+             << std::endl;
+    ret = 1;
+  }
+  
+  if (success && r.fUpload) {
+    const char* files[] = { "conditions.csv", 
+                           "peds.csv", 
+                           0 };
+    const char* ids[] = { AliFMDParameters::Instance()->GetConditionsShuttleID(),
+                         AliFMDParameters::Instance()->GetPedestalShuttleID(), 
                          0 };
-  const char* ids[] = { AliFMDParameters::Instance()->GetConditionsShuttleID(),
-                       AliFMDParameters::Instance()->GetPedestalShuttleID(), 
-                       0 };
-  ret = UploadFiles(files, ids);
-
-  if(ret > 0) std::cerr << "Pedestal DA failed" << std::endl;
+    ret = UploadFiles(files, ids, r.fOwnUpload);
+    if (ret > 0) std::cerr << "Upload of pedestals failed" << std::endl;
+  }
 
-  PostSummaries(pedDA, "ped", r.RunNumber());
+  if (success) 
+    PostSummaries(pedDA, "ped", r.RunNumber());
 
-  std::cout << "End of FMD-Gain, return " << ret << std::endl;
   gROOT->SetMustClean(false);
 
-  std::cout << "Now calling _Exit(" << ret << ") to finish NOW!" << std::endl;
-  _exit(ret);
+  if (r.fFast) {
+    std::cout << "Sleep 1 second before getting out" << std::endl;
+    gSystem->Sleep(1000);
+    std::cout << "Now calling _exit(" << ret << ") to finish NOW!" << std::endl;
+    _exit(ret);
+  }
 
+  std::cout << "End of FMD-Pedestal, return " << ret << std::endl;
   return ret;
 }
 //
index 07ff8ac..8e320d4 100644 (file)
@@ -4,18 +4,19 @@
 #include "daqDA.h"
 #include <stdexcept>
 #include <iostream>
+#include <fstream>
 #ifdef ALI_AMORE
 # include <AmoreDA.h>
 # include <TH2.h>
 # include <TSystem.h>
 #endif
 
-void
+Bool_t
 PostSummaries(AliFMDBaseDA& da, const char* prefix, Int_t runNumber, bool verb=true)
 {
 #ifndef ALI_AMORE
   std::cerr << "AMORE not found - nothing posted" << std::endl;
-  return;
+  return true;
 #else
   if (verb) 
     std::cout << "Posting " << prefix << " data to AMORE" << std::endl;
@@ -58,14 +59,123 @@ PostSummaries(AliFMDBaseDA& da, const char* prefix, Int_t runNumber, bool verb=t
   }
   catch (std::exception& e) {
     std::cerr << "Failed to make AMORE instance: " << e.what() << std::endl;
+    return false;
   }
   if (verb) 
     std::cout << "All objects posted to AMORE" << std::endl;
+  return true;
 #endif
 }
 
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <cstring>
+#include <cerrno>
+
+int system_alternative(const char* pgm, char* const argv[])
+{
+  // See http://stackoverflow.com/questions/3055924/problems-with-system-calls-in-linux 
+  pid_t pid = vfork();
+  if (pid > 0) {
+    // We're the parent, so wait for child to finish
+    int status;
+    waitpid(pid, &status, 0);
+    return status;
+  }
+  else if (pid == 0) {
+    // We're the child, so run the specified program.  Our exit status will
+    // be that of the child program unless the execv() syscall fails.
+    std::cout << "Execute \"" << pgm << "\"";
+    for (int i = 0; argv[i]; i++) 
+      std::cout << " \"" << argv[i] << "\"";  
+    std::cout << std::endl;
+    int status = execv(pgm, argv);
+    if (status == -1) { 
+      std::cout << "Failed to exec " << errno 
+               << " (" << strerror(errno) << ")" << std::endl;
+    }
+    return status;
+  }
+  else {
+    // Something horrible happened, like system out of memory
+    std::cout << "Failed to for fork " << errno 
+             << " (" << strerror(errno) << ")" << std::endl;
+    return -1;
+  }
+}
+
+Int_t myFesStore2(const char* file, const char* id, bool verb=true)
+{
+  TString path(gSystem->Getenv("DAQDALIB_PATH"));
+  if (path.IsNull()) {
+    std::cout << "DAQDALIB_PATH undefined" << std::endl;
+    return -1;
+  }
+  TString cmd(path); 
+  cmd.Append("/daqFES_store");
+  std::cout << "Will Execute \"" << cmd 
+           << "\",\"" << file << "\",\"" << id
+           << "\"" << std::endl;
+  char* const args[] = { 
+    const_cast<char*>(cmd.Data()),
+    const_cast<char*>(file), 
+    const_cast<char*>(id), 
+    0 };
+  int ret = system_alternative(cmd.Data(),args);
+  if (WIFEXITED(ret)) {
+    ret = WEXITSTATUS(ret);
+    if (ret != 0) 
+      std::cout << "Failed to execute \"" << cmd << "\" -> " 
+               << ret << std::endl;
+  }
+  else if (WIFSIGNALED(ret)) {
+    int sig = WTERMSIG(ret);
+    std::cout << "Process \"" << cmd << "\" received signal "
+             << sig << " (" << strsignal(sig) << ")" << std::endl;
+    ret = -1;
+  }
+  return ret;
+}
+  
+Int_t myFesStore(const char* file, const char* id, bool verb=true)
+{
+  TString path(gSystem->Getenv("DAQDALIB_PATH"));
+  if (path.IsNull()) {
+    std::cout << "DAQDALIB_PATH undefined" << std::endl;
+    return -1;
+  }
+  // Check if we can get a shell 
+  Int_t ret = system(NULL);
+  if (ret == 0) { 
+    std::cout << "Cannot spawn a shell" << std::endl;
+    return -2;
+  }
+  // Biuld command 
+  TString cmd(path); 
+  cmd.Append("/daqDetDB_store ");
+  cmd.Append(file);
+  cmd.Append(" ");
+  cmd.Append(id);
+  // Execute the command 
+  std::cout << "Will now execute \"" << cmd << "\"" << std::endl;
+  ret = system(cmd.Data());
+  if (WIFEXITED(ret)) {
+    ret = WEXITSTATUS(ret);
+    if (ret != 0) 
+      std::cout << "Failed to execute \"" << cmd << "\" -> " 
+               << ret << std::endl;
+  }
+  else if (WIFSIGNALED(ret)) {
+    int sig = WTERMSIG(ret);
+    std::cout << "Process \"" << cmd << "\" received signal "
+             << sig << " (" << strsignal(sig) << ")" << std::endl;
+    ret = -1;
+  }
+  return ret;
+}
+
 Int_t
-UploadFiles(const char** files, const char** ids, bool verb=true)
+UploadFiles(const char** files, const char** ids, bool useOwn, bool verb=true)
 {
   const char** pFile = files; 
   const char** pId   = ids; 
@@ -76,16 +186,23 @@ UploadFiles(const char** files, const char** ids, bool verb=true)
   while (*pFile && *pId) {
     if (verb) 
       std::cout << " Upload " << *pFile << " (" << *pId << ") ... " << std::flush;
-    Int_t lret = daqDA_FES_storeFile(*pFile, *pId);
+    Int_t lret = -1;
+    if (useOwn) lret = myFesStore2(*pFile, *pId);
+    else        lret = daqDA_FES_storeFile(*pFile, *pId);
+
     if (lret != 0) {
       if (verb) 
-       std::cout << "failed" << std::endl;
+       std::cout << "failed (" << lret << ")" << std::endl;
       std::cerr << "Failed to upload " << *pFile << " to FES id " 
-               << *pId << std::endl;
+               << *pId << " - exit " << lret << std::endl;
       ret++;
     }
-    if (verb)
-      std::cout << "done" << std::endl;
+    else {
+     if (verb) std::cout << "done" << std::endl;
+     std::ofstream touch(Form("%s.upload", *pFile));
+     touch << "Done" << std::endl;
+     touch.close();
+    }
     pFile++;
     pId++;
   }
index fcf132d..1f33139 100644 (file)
@@ -128,7 +128,7 @@ AliFMDBaseDA::GetDetectorPath(UShort_t det,
   // 
   // Parameters 
   //     det      Detector number
-  //     ring     Ring identifier 
+  //     ring     Rg identifier 
   //     sec      Sector number 
   //     str      Strip number
   //     full     If true, return full path 
@@ -162,10 +162,9 @@ AliFMDBaseDA::AliFMDBaseDA() :
     fSeenDetectors[i] = false;
     fNEventsPerDetector[i] = 0;
   }
-  fDetectorArray.SetOwner();
-  Rotate("conditions.csv", 3);
-  fConditionsFile.open("conditions.csv");
 }
+
+
 //_____________________________________________________________________
 AliFMDBaseDA::AliFMDBaseDA(const AliFMDBaseDA & baseDA) : 
   TNamed(baseDA),
@@ -209,6 +208,26 @@ AliFMDBaseDA::~AliFMDBaseDA()
 }
 
 //_____________________________________________________________________
+Bool_t
+AliFMDBaseDA::OpenFiles(Bool_t appendRun)
+{
+  fDetectorArray.SetOwner();
+  if (!appendRun || fRunno == 0) {
+    Rotate("conditions.csv", 3);
+    fConditionsFile.open("conditions.csv");
+  }
+  else {
+    fConditionsFile.open(Form("conditions_%09d.csv", 
+                             fRunno));
+  }
+  if (!fConditionsFile) { 
+    Error("OpenFiles", "Failed to open conditions file");
+    return false;
+  }
+  return true;
+}
+
+//_____________________________________________________________________
 Bool_t AliFMDBaseDA::HaveEnough(Int_t nEvents) const
 {
   // if (!fAll) return nEvents > GetRequiredEvents();
@@ -240,21 +259,30 @@ UShort_t AliFMDBaseDA::GetProgress(Int_t nEvents) const
 }
 
 //_____________________________________________________________________
-void AliFMDBaseDA::Run(AliRawReader* reader, Bool_t isBase) 
+Bool_t
+AliFMDBaseDA::Run(AliRawReader* reader, Bool_t appendRun, Bool_t isBase) 
 {
   //Run the FMD DA
   TFile* diagFile = 0;
   // if (fSaveHistograms)
   //  diagFile = TFile::Open(fDiagnosticsFilename.Data(),"RECREATE");
-  
+
   reader->Reset();
   fRunno = reader->GetRunNumber();
+  if (fRunno <= 0) { 
+    TString dateRunNumber(gSystem->Getenv("DATE_RUN_NUMBER"));
+    if (!dateRunNumber.IsNull()) fRunno = dateRunNumber.Atoll();
+  }
 
+  // Open our output files
+  if (!OpenFiles(appendRun)) return false;
+  // Create our reader 
   AliFMDRawReader* fmdReader  = new AliFMDRawReader(reader,0);
   TClonesArray*    digitArray = new TClonesArray("AliFMDDigit",0);
   
+  // Look for SOD  
   Bool_t sodread = kFALSE;
-  
   for(Int_t i=0;i<3;i++) {
     if (!reader->NextEvent()) { 
       // Read Start-of-Run / Start-of-Files event
@@ -272,9 +300,13 @@ void AliFMDBaseDA::Run(AliRawReader* reader, Bool_t isBase)
       break;
     }
   }
-  if (isBase) return;
+  if (isBase) 
+    // IF this is the base DA, do thing more 
+    return true;
 
+  // Initialize everything 
   Init();
+  // Initialize our containers 
   InitContainer(diagFile);
   if (AliLog::GetDebugLevel("FMD","") >= 3) { 
     fDetectorArray.ls();
@@ -285,8 +317,10 @@ void AliFMDBaseDA::Run(AliRawReader* reader, Bool_t isBase)
   
   int lastProgress = 0;
 
+  // Reset event counters 
   for(Int_t i = 0; i< 3;i++) fNEventsPerDetector[i] = 0;
 
+  // Loop until we have enough 
   for(Int_t n = 1; !HaveEnough(n); n++) {
     AliDebugF(1,"Get the next event %d", n);
     if(!reader->NextEvent()) { n--; continue; }
@@ -324,18 +358,16 @@ void AliFMDBaseDA::Run(AliRawReader* reader, Bool_t isBase)
     if (progress <= lastProgress) continue;
     lastProgress = progress;
     std::cout << "Progress: " << lastProgress << " / 100 " << std::endl;
-
-    if (AliLog::GetDebugLevel("FMD","") >= 0) { 
-    }
-    
   }
-  
+
+  // Now at end of processing 
   AliInfoF("Looped over %d events (%d,%d,%d)",GetCurrentEvent(),
           fNEventsPerDetector[0], 
           fNEventsPerDetector[1], 
           fNEventsPerDetector[2]);
   WriteHeaderToFile();
   
+  // Analyse the data and make summaries 
   for(UShort_t det=1;det<=3;det++) {
     if (!fSeenDetectors[det-1]) continue;
     std::cout << "FMD" << det << std::endl;
@@ -360,13 +392,16 @@ void AliFMDBaseDA::Run(AliRawReader* reader, Bool_t isBase)
     }
   }
   
+  // If we have an output file, close it  
   if(fOutputFile.is_open()) {
     fOutputFile.write("# EOF\n",6);
     fOutputFile.close();
   }
   
+  // Do final stuff on the diagnostics file 
   Terminate(diagFile);
     
+  // Possibly write histograms to diagnostics file 
   if(fSaveHistograms ) {
     diagFile = TFile::Open(fDiagnosticsFilename.Data(),"RECREATE");
     fDetectorArray.Write("FMD", TObject::kSingleKey);
@@ -375,8 +410,10 @@ void AliFMDBaseDA::Run(AliRawReader* reader, Bool_t isBase)
     // diagFile->Write();
     diagFile->Close();
     AliInfo("done");
-    
   }
+
+  // All is good 
+  return true;
 }
 //_____________________________________________________________________
 
@@ -662,9 +699,14 @@ AliFMDBaseDA::GetStripArray(UShort_t det, Char_t ring,
 //=====================================================================
 AliFMDBaseDA::Runner::Runner()
   : fReader(0),
+    fSource(""),
     fDiagFile(""), 
     fDiag(false),
-    fAll(false)
+    fAll(false),
+    fFast(true),
+    fUpload(true),
+    fAppendRun(false),
+    fOwnUpload(false)
 {}
 
 //_____________________________________________________________________ 
@@ -714,7 +756,12 @@ AliFMDBaseDA::Runner::ShowUsage(std::ostream& o, const char* progname)
     << "   -h,--help                Show this help\n"
     << "   -d,--diagnostics[=FILE]  Write diagnostics to file\n"
     << "   -D,--debug=LEVEL         Set the debug level\n"
-    << "   -A,--all                 Try to get data from all detectors\n\n"
+    << "   -A,--all                 Try to get data from all detectors (" << fAll << ")\n"
+    << "   -F,--fast                Fast exit (" <<fFast <<")\n"
+    << "   -U,--upload              Upload to FXS (" <<fUpload <<")\n"
+    << "   -R,--append              Append run # to filename (" <<fAppendRun <<")\n"
+    << "   -Z,--own                 Use custom upload (" << fOwnUpload << ")\n"
+    << "\n"
     << "SOURCE is one of\n"
     << " * FILE.raw                Raw data file\n"
     << " * FILE.root               ROOT'ified raw data file\n"
@@ -740,7 +787,7 @@ namespace {
       
 //_____________________________________________________________________ 
 Int_t
-AliFMDBaseDA::Runner::Init(int argc, char** argv)
+AliFMDBaseDA::Runner::Init(int argc, char** argv, Bool_t reader)
 {
   AddHandlers();
 
@@ -762,18 +809,22 @@ AliFMDBaseDA::Runner::Init(int argc, char** argv)
            debugLevel = val.Atoi();
        }
        else if (arg.BeginsWith("--diagnostics")) { 
-         fDiag = true;
+         fDiag = !fDiag;
          if (ExtractValue(arg, val)) 
            fDiagFile = val;
        }
-       else if (arg.EqualTo("--all"))  fAll = true;
+       else if (arg.EqualTo("--all"))    fAll  = !fAll;
+       else if (arg.EqualTo("--fast"))   fFast = !fFast;
+       else if (arg.EqualTo("--upload")) fUpload = !fUpload;
+       else if (arg.EqualTo("--append")) fAppendRun = !fAppendRun;
+       else if (arg.EqualTo("--own"))    fOwnUpload = !fOwnUpload;
        else badOption = true;
       }
       else { // Short option 
        TString next(i < argc-1 ? argv[i+1] : "");
        switch (arg[1]) { 
        case 'h': help = true; break;
-       case 'd': fDiag = true; 
+       case 'd': fDiag = !fDiag; 
          if (!next.IsNull() && next[0] != '-') {
            fDiagFile = next;
            i++;
@@ -785,7 +836,11 @@ AliFMDBaseDA::Runner::Init(int argc, char** argv)
            i++;
          }
          break;
-       case 'A': fAll = true ; break ;
+       case 'A': fAll       = !fAll ; break ;
+       case 'F': fFast      = !fFast ; break ;
+       case 'U': fUpload    = !fUpload ; break ;
+       case 'R': fAppendRun = !fAppendRun ; break ;
+       case 'Z': fOwnUpload = !fOwnUpload ; break ;
        default: badOption = true;
        }
       } // End of options
@@ -796,8 +851,7 @@ AliFMDBaseDA::Runner::Init(int argc, char** argv)
       }
     }
     else { // source or compatibility debug level 
-      if (source.IsNull()) source = arg;
-      else                 debugLevel = arg.Atoi();
+      source = arg;
     }
   }
   
@@ -812,6 +866,7 @@ AliFMDBaseDA::Runner::Init(int argc, char** argv)
     std::cerr << "No source given" << std::endl;
     return -2;
   }
+  fSource = source;
 
   // --- Initialize various things -----------------------------------
   AliFMDParameters::Instance()->Init(kFALSE,0);
@@ -825,6 +880,7 @@ AliFMDBaseDA::Runner::Init(int argc, char** argv)
   AliLog::SetModuleDebugLevel("FMD", debugLevel);
 
   // --- Make our reader ---------------------------------------------
+  if (!reader) return 0;
   fReader = AliRawReader::Create(source);
   if (!fReader) { 
     std::cerr << "Failed to make raw reader for source \"" << source 
@@ -838,12 +894,21 @@ AliFMDBaseDA::Runner::Init(int argc, char** argv)
 Int_t
 AliFMDBaseDA::Runner::RunNumber() const
 { 
-  if (!fReader) return -1;
-  return fReader->GetRunNumber(); 
+  Int_t run = -1;
+  if (fReader) 
+    run = fReader->GetRunNumber(); 
+  if (run <= 0) {
+    TString dateRunNumber(gSystem->Getenv("DATE_RUN_NUMBER"));
+    if (!dateRunNumber.IsNull()) 
+      run = dateRunNumber.Atoll();
+    else 
+      run = -1;
+  }
+  return run;
 }
 
 //_____________________________________________________________________ 
-void
+Bool_t
 AliFMDBaseDA::Runner::Exec(AliFMDBaseDA& da)
 {
   TStopwatch timer;
@@ -853,10 +918,12 @@ AliFMDBaseDA::Runner::Exec(AliFMDBaseDA& da)
   da.SetTryAll(fAll);
   if (!fDiagFile.IsNull()) da.SetDiagnosticsFilename(fDiagFile);
 
-  da.Run(fReader);
+  Bool_t ret = da.Run(fReader, fAppendRun);
 
   timer.Stop();
   timer.Print();
+
+  return ret;
 }
 
 #if 0
index e226ab9..dfb82c1 100644 (file)
@@ -84,9 +84,10 @@ public:
    * Run this DA
    * 
    * @param fmdReader Raw input reader
+   * @param appendRun Append run number to files
    * @param isBase Terminate after reading SOD   
    */  
-  void Run(AliRawReader* fmdReader, Bool_t isBase=false);
+  Bool_t Run(AliRawReader* fmdReader, Bool_t appendRun, Bool_t isBase=false);
   /** 
    * Set whether to save diagnostics 
    * 
@@ -144,20 +145,53 @@ public:
   struct Runner {
     Runner();
     Runner(const Runner&) 
-      : fReader(0), fDiagFile(""), fDiag(false), fAll(false) {}
+      : fReader(0),
+       fSource(""),
+       fDiagFile(""), 
+       fDiag(false), 
+       fAll(false),
+       fFast(true),
+       fUpload(true),
+       fAppendRun(false),
+       fOwnUpload(false)
+    {}
     ~Runner() {} 
     Runner& operator=(const Runner&) { return *this; }
     void   AddHandlers();
     void   ShowUsage(std::ostream& o, const char* progname);
-    Int_t  Init(int argc, char** argv);
-    void   Exec(AliFMDBaseDA& da);
+    Int_t  Init(int argc, char** argv, Bool_t reader=true);
+    Bool_t Exec(AliFMDBaseDA& da);
     Int_t  RunNumber() const;
     AliRawReader* fReader;
+    TString       fSource;
     TString       fDiagFile;
     Bool_t        fDiag;
     Bool_t        fAll;
+    Bool_t        fFast;
+    Bool_t        fUpload;
+    Bool_t        fAppendRun;
+    Bool_t        fOwnUpload;
   };
 protected:
+  /**
+   * Open our output file 
+   *
+   * The output file is named 
+   *
+   *   conditions.csv 
+   *
+   * and existing files are rotated, or 
+   * 
+   *   conditions_XXXXXXXXX.csv 
+   *
+   * in case the run number is to be appended. 
+   * 
+   * @param appendRun if true, append run number (9 digits, zero
+   * padded) to the output file name(s).
+   *
+   * @return true on success 
+   */
+  virtual Bool_t OpenFiles(Bool_t appendRun=false);
   /** 
    * Initialize 
    */  
index da07042..0d38255 100644 (file)
@@ -75,7 +75,6 @@ AliFMDGainDA::AliFMDGainDA()
   //   None
   fCurrentPulse.Reset(0);
   fCurrentChannel.Reset(0);
-  fOutputFile.open("gains.csv");
   fDiagnosticsFilename = "diagnosticsGain.root";
 }
 
@@ -117,6 +116,25 @@ AliFMDGainDA::~AliFMDGainDA()
   //   None
 }
 
+
+//_____________________________________________________________________
+Bool_t
+AliFMDGainDA::OpenFiles(Bool_t appendRun) 
+{
+  if (!AliFMDBaseDA::OpenFiles(appendRun)) return false;
+  if (!appendRun || fRunno == 0) { 
+    Rotate("gains.csv", 3);
+    fOutputFile.open("gains.csv");
+  }
+  else 
+    fOutputFile.open(Form("gains_%09d.csv", fRunno));
+  if (!fOutputFile) { 
+    Error("OpenFiles", "Failed to open gains file");
+    return false;
+  }
+  return true;
+}
+
 //_____________________________________________________________________
 void AliFMDGainDA::Init() 
 {
index 521fb7d..0d41077 100644 (file)
@@ -43,6 +43,27 @@ public:
    * 
    */
   virtual ~AliFMDGainDA();
+  /**
+   * Open our output files 
+   *
+   * The output files are named 
+   *
+   *   gains.csv
+   *   conditions.csv 
+   *
+   * or 
+   * 
+   *   gains_XXXXXXXXX.csv 
+   *   conditions_XXXXXXXXX.csv 
+   *
+   * in case the run number is to be appended
+   * 
+   * @param appendRun if true, append run number (9 digits, zero
+   * padded) to the output file name(s).
+   *
+   * @return true on success 
+   */
+  Bool_t OpenFiles(Bool_t appendRun=false);
   /** 
    * Initialize 
    * 
index 4e1afc3..bf78a8e 100644 (file)
@@ -66,14 +66,6 @@ AliFMDPedestalDA::AliFMDPedestalDA()
     fSummaryFMD3o(0)
 {
   // Default constructor 
-  Rotate("peds.csv", 3);
-  fOutputFile.open("peds.csv");
-  Rotate("ddl3072.csv", 10);
-  fZSfileFMD1.open("ddl3072.csv");
-  Rotate("ddl3073.csv", 10);
-  fZSfileFMD2.open("ddl3073.csv");
-  Rotate("ddl3074.csv", 10);
-  fZSfileFMD3.open("ddl3074.csv");  
   fDiagnosticsFilename = "diagnosticsPedestal.root";
 }
 
@@ -104,6 +96,31 @@ AliFMDPedestalDA::~AliFMDPedestalDA()
 }
 
 //_____________________________________________________________________
+Bool_t 
+AliFMDPedestalDA::OpenFiles(Bool_t appendRun)
+{
+  if (!AliFMDBaseDA::OpenFiles(appendRun)) return false;
+  if (!appendRun || fRunno == 0) {
+    Rotate("peds.csv", 3);
+    fOutputFile.open("peds.csv");
+  }
+  else 
+    fOutputFile.open(Form("peds_%09d.csv",fRunno));
+  
+  if (!fOutputFile) { 
+    Error("OpenFiles", "Failed to open pedestal file");
+    return false;
+  }
+  Rotate("ddl3072.csv", 10);
+  fZSfileFMD1.open("ddl3072.csv");
+  Rotate("ddl3073.csv", 10);
+  fZSfileFMD2.open("ddl3073.csv");
+  Rotate("ddl3074.csv", 10);
+  fZSfileFMD3.open("ddl3074.csv");  
+  return true;
+}
+
+//_____________________________________________________________________
 void AliFMDPedestalDA::Init() 
 { 
   // Initialise 
index dd11fb9..9ecf5b9 100644 (file)
@@ -44,6 +44,33 @@ public:
    * 
    */
   virtual ~AliFMDPedestalDA();
+  /**
+   * Open our output files 
+   *
+   * The output files are named 
+   *
+   *   peds.csv
+   *   conditions.csv 
+   *   ddl3072.csv
+   *   ddl3073.csv
+   *   ddl3074.csv
+   *
+   * and existing files are rotated, or 
+   * 
+   *   peds_XXXXXXXXX.csv 
+   *   conditions_XXXXXXXXX.csv 
+   *   ddl3072.csv
+   *   ddl3073.csv
+   *   ddl3074.csv
+   *
+   * in case the run number is to be appended. 
+   * 
+   * @param appendRun if true, append run number (9 digits, zero
+   * padded) to the output file name(s).
+   *
+   * @return true on success 
+   */
+  Bool_t OpenFiles(Bool_t appendRun=false);
   /** 
    * Initialiser
    *