QOptions.cc

Go to the documentation of this file.

#include "QOptions.hh"
#include "QMessage.hh"
 
#include <stdexcept>
#include <iostream>
#include <fstream>
#include <sstream>
#include <unistd.h>
#include <time.h>
#include <string.h>
#include "QStringHandler.hh"
#include "QError.hh"
#include "QRealComplexFFT.hh"
#include "QDianaVersion.hh"
#include <limits>
 
using namespace QStringHandler;
extern char *optarg;
extern int optind, opterr, optopt;
 
Q_BEGIN_NAMESPACE
 
QOptions& QOptions::GetInstance() 
{
 
    static QOptions me;
        return me;
}
 
QOptions::QOptions() 
{ 
    fUserParams.clear();
    fParams.clear();
    fFirstSequenceName = "";
    fLastSequenceName = "";
    SetParameter("General.MainConfigFile",std::string(""));
    SetParameter("General.LogFile",std::string(""));
    // see QMessageHandler::Init for defaults
    SetParameter("General.PrintVerbosity",QVdt(1)); // debug
    SetParameter("General.LogVerbosity",QVdt(1)); // debug
    SetParameter("General.EventsToBeSkipped",0);
    SetParameter("General.EventsToBeProcessed",0);
    SetParameter("General.Driver",QVdt(""));
    SetParameter("General.OverWrite",QVdt(false));
    SetParameter("General.TimeProfilingOn",QVdt(false));
    SetParameter("General.SkipRequiredNotValid",QVdt(false));
    Diana::DianaDebug = false;
 
    QVdt::QVdt_vector versions;
    versions.push_back(QVdt(Diana::QSWInfo::GetROOTVersion(),"DIANA_VERSION_ROOT"));
    versions.push_back(QVdt(Diana::QSWInfo::GetPSQLVersion(),"DIANA_VERSION_PSQL"));
    versions.push_back(QVdt(Diana::QSWInfo::GetGSLVersion(),"DIANA_VERSION_GSL"));
    versions.push_back(QVdt(QRealComplexFFT::GetFFTLibrary(),"DIANA_FFT_LIB"));
    if(!strcmp(QRealComplexFFT::GetFFTLibrary(),"FFTW3"))
      versions.push_back(QVdt(Diana::QSWInfo::GetFFTWVersion(),"DIANA_VERSION_FFTW"));
    versions.push_back(QVdt(Diana::QSWInfo::GetQtVersion(),"DIANA_VERSION_QT"));
    versions.push_back(QVdt(Diana::QSWInfo::GetBoostVersion(),"DIANA_VERSION_BOOST"));
    SetParameter("General.DIANA_EXTSWREVISION",versions);
    SetParameter("General.DIANA_SWREVISION",QVdt(Diana::QSWInfo::GetDianaSWRevision()));
    SetParameter("General.DIANA_VERSIONTAG",QVdt(Diana::QSWInfo::GetDianaVersionTag()));
    SetParameter("General.GlobalDataInputVersion",QVdt(Diana::QSWInfo::GetDianaVersionTag()));
 
}
 
QOptions::~QOptions()
{
 
}
void QOptions::CheckNotGet(const std::string& seq, std::ostream& o) 
{
    std::map< std::string, ParamInfo >::const_iterator iter = fParams.begin();
    std::vector<std::string> floatingOptions;
    while(iter != fParams.end()) {
        std::string name = iter->first;
        std::string myseq = name.substr(0,name.find_first_of("."));
        std::string rest = name.substr(0,name.find_last_of("."));
        bool enabled = false; 
        try {
            enabled = GetParameter(rest + ".enable").GetBool();
        } 
        catch (...) {};
        if(myseq == seq && enabled && iter->second.get == 0) {
            floatingOptions.push_back(iter->first);
        }
        iter++;
    }
    if(!floatingOptions.empty()) {
        o << "The following configuration file parameters were not read by modules (useless directives?): "<<std::endl;
        for(size_t i = 0; i < floatingOptions.size();  i++ ) {
            o << "Parameter: "<<floatingOptions[i]<<std::endl;
        }
    }
}
 
void QOptions::CheckAtDefault(const std::string& seq, std::ostream& o) 
{
    std::map< std::string, ParamInfo >::const_iterator iter = fParams.begin();
    std::vector<std::string> floatingOptions;
    while(iter != fParams.end()) {
        std::string name = iter->first;
        std::string myseq = name.substr(0,name.find_first_of("."));
        std::string rest = name.substr(0,name.find_last_of("."));
        bool enabled = false; 
        try {
            enabled = GetParameter(rest + ".enable").GetBool();
        } 
        catch (...) {};
        if(myseq == seq && enabled && iter->second.get == 2) {
            floatingOptions.push_back(iter->first);
        }
        iter++;
    }
    if(!floatingOptions.empty()) {
        o << "The following configuration parameters were set at default values: "<<std::endl;
        for(size_t i = 0; i < floatingOptions.size();  i++ ) {
            o << "Parameter: "<<floatingOptions[i]<<" = "<<fParams[floatingOptions[i]].param<<std::endl;
        }
    }
}
 
void QOptions::Dump(std::ostream& o) 
{
    o << "(CC) Dump of configuration parameters\n";
    std::map< std::string, ParamInfo>::iterator it;
    for(it=fParams.begin(); it!=fParams.end(); it++) {
        o <<"(CC) "<< it->first<< "\t=\t";
        if(it->second.param.GetType() == QVdt::Vector_QVdt) {
           const QVdt::QVdt_vector& vec = it->second.param.GetVector();
           o<<"{";
           for(size_t i = 0; i < vec.size(); i++) {
               o<<vec[i].GetName()<<"="<<vec[i].GetString()<<","; 
           }
           o<<"}"<<std::endl;
        } else {
            o <<it->second.param.GetString()<<std::endl;
        }
    }
    o << "(CC) End of dump of configuration parameters\n";
}
 
void QOptions::Help(const char* exe) 
{
    std::cout << "Usage: "<<exe<<" -C file [options]" << std::endl;
    std::cout << "Options:" << std::endl;
    std::cout << "  -c file        file overriding config file parameters\n";
    std::cout << "  -C file        config file name (mandatory)\n";
    std::cout << "  -e n           number of events to be processed\n";
    std::cout << "  -D driver      automatically load a driver module\n";
    std::cout << "  -f file        input filename or filelist (must have .list extension) \n";
    std::cout << "  -g             abort instead of throwing an exception (useful to trace back errors)\n";
    std::cout << "  -h             this command \n";
    std::cout << "  -i version     version of input gloabl data quantities (e.g. 2.10) \n";
    std::cout << "  -l logfile     logfile name\n";
    std::cout << "  -o filep       output file prefix \n";
    std::cout << "  -O             overwrite objects already present in input files \n";
    std::cout << "  -p param val   override config file parameter sequence.module.occurrence.parameter with value val\n";
    std::cout << "  -q             decrease screen verbosity by 1 level\n";
    std::cout << "  -s n           number of events to be skipped\n";
    std::cout << "  -S             switch to true the SkipRequiredNotValid option when present\n";
    std::cout << "  -T             enable time profiling of Do() methods in modules\n";
    std::cout << "  -v             increase screen verbosity by 1 level\n";
    std::cout << "  -V var val     define config file variable var with value val\n";
}
 
 
void QOptions::Init(int argc, char * const argv[]) 
{
 
    // set default values
    int GeneralVerbosity = 2; // Info
    std::string UserConfigFile = "";
    std::string MainConfigFile = "";
    std::string LogFileName;
    std::string Driver = "";
    time_t t = time (0);
    char time_string[31];
    ::strftime(time_string, 31, "diana_%Y_%m_%d_%H%M%S.log", ::localtime(&t));
    const char *p = ::getenv("DIANA_INSTALL");
    if(p) SetParameter("CFGVar.DIANA_INSTALL",QVdt(p));
    const char *pext = ::getenv("DIANA_EXT_INSTALL");
    if(pext) SetParameter("CFGVar.DIANA_EXT_INSTALL",QVdt(pext));
 
 
    if(pext) p = pext;
    if (p) {
        LogFileName = p;
        LogFileName += "/log/";
        LogFileName += time_string;
    } else {
        LogFileName = "log/";
        LogFileName += time_string;
    }
 
    const char* dbv;
    dbv = ::getenv("DIANA_DB_NAME");
    if(dbv) SetParameter("General.DIANA_DB_NAME",QVdt(dbv));
    dbv = ::getenv("DIANA_DB_HOST");
    if(dbv) SetParameter("General.DIANA_DB_HOST",QVdt(dbv));
    dbv = ::getenv("DIANA_DB_PORT");
    if(dbv) SetParameter("General.DIANA_DB_PORT",QVdt(dbv));
    dbv = ::getenv("DIANA_DB_USER");
    if(dbv) SetParameter("General.DIANA_DB_USER",QVdt(dbv));
    dbv = ::getenv("DIANA_DB_PWD");
    if(dbv) SetParameter("General.DIANA_DB_PWD",QVdt(dbv));
 
 
    int EventsToBeSkipped = 0;
    int EventsToBeProcessed = std::numeric_limits<int>::max();
 
    std::string InputFileName="";
    std::string InputFilesList="";
    std::string OutputFilePrefix="";
 
    // handle inline options using standard C libraries
    opterr = 0;
    SetParameter("General.GSLErrorHandler",std::string("diana"));
    while (1) {
        const char valid_options[] = ":vqhgc:i:C:G:f:F:Ss:e:n:OTp:lo:D:V:";
 
        int c = ::getopt (argc, argv, valid_options);
 
        if (c == -1) break;
 
 
        switch (c) {
            case 'c':                       // change USER configuration file name
                UserConfigFile = optarg;
                SetParameter("General.UserConfigFile",QVdt(UserConfigFile));
                break;
 
            case 'C':                       // change MAIN configuration file name
                MainConfigFile = optarg;
                break;
 
            case 'h':
                Help(argv[0]);
                exit(0);
                break;
 
            case 'i': {
                std::string inputVersion = optarg;
                SetParameter("General.GlobalDataInputVersion",QVdt(inputVersion));
                break;
            }
            case 'f': // input file name 
                InputFileName = optarg;
                SetParameter("General.InputFile",QVdt(InputFileName));
                SetParameter("General.ReadFilesList",QVdt(false));
                break;
 
                        case 'F': // input file list
                                InputFilesList = optarg;
                                SetParameter("General.InputFilesList",QVdt(InputFilesList));
                                SetParameter("General.ReadFilesList",QVdt(true));
                                break;
             case 'g':
                SetParameter("General.GSLErrorHandler",std::string("default"));
                Diana::DianaDebug = true;
                break;
                  case 's':                       // number of triggers to be processed
                          EventsToBeSkipped = atoi( optarg );
                          if (EventsToBeSkipped < 0)
                                EventsToBeSkipped=0;
                          break;
 
          case 'S':
              SetParameter("General.SkipRequiredNotValid",QVdt(true));
              break;
          case 'T':
              SetParameter("General.TimeProfilingOn",QVdt(true));
              break;
 
          case 'e':
              EventsToBeProcessed = atoi( optarg );
              if (EventsToBeProcessed < 0)
                  EventsToBeProcessed=999999999;
              break;
          case 'O':
              SetParameter("General.OverWrite",QVdt(true));
              break;
 
                  case 'p': // change the value of any parameter with inline command
              // optind is the index to the next option (so argv[optind] is the second opt parameter)
              if(!argv[optind])
                  throw std::runtime_error ("option -p requires 2 parameters with the \"sequence.module.occurrence.parameter value\" syntax"); 
              if ( !argv[optind] || argv[optind][0] == '-' ) {
                  for (size_t k = 0; k < ::strlen (valid_options); k++) {
                      if (valid_options[k] != ':' && valid_options[k] == argv[optind][1]) 
                          throw std::runtime_error ("option -p requires 2 parameters with the \"sequence.module.occurrence.parameter value\" syntax"); 
                  }
              }
              fUserParams[optarg] = QVdt(std::string(argv[optind++]));
              break;
 
          case 'V': 
              {
              // change the value of any parameter with inline command
              // optind is the index to the next option (so argv[optind] is the second opt parameter)
              if(!argv[optind])
                  throw std::runtime_error ("option -V requires 2 parameters with the \"variable_name variable_value\" syntax"); 
              if ( !argv[optind] || argv[optind][0] == '-' ) {
                  for (size_t k = 0; k < ::strlen (valid_options); k++) {
                      if (valid_options[k] != ':' && valid_options[k] == argv[optind][1]) 
                          throw std::runtime_error ("option -V requires 2 parameters with the \"variable_name variable_value\" syntax"); 
                  }
              }
              std::string cfgvar = "CFGVar.";
              cfgvar += std::string(optarg);
              QOptions::GetInstance().SetParameter(cfgvar,std::string(argv[optind++]));
              }
              break;
 
 
          case 'l':
              if (optind < argc && argv[optind] && argv[optind][0] != '-') 
                  LogFileName = argv[optind++];
              else 
                  LogFileName = "";
              break;
 
          case 'v':                      // each "v" decrease GeneralVerbositythreshold by one level
              GeneralVerbosity --;
              if(GeneralVerbosity<0) GeneralVerbosity = 0;
              break;
 
          case 'q':                      // each "q" invrease GeneralVerbositythreshold by one level
              GeneralVerbosity ++;
              break;
 
          case 'o':                      
              OutputFilePrefix = optarg;
              SetParameter("General.OutputFilePrefix",QVdt(OutputFilePrefix));
              break;
          case 'D':
              Driver = optarg;
              break;
 
          case ':':
              throw std::runtime_error (std::string("Missing value on command line option -") + char (optopt));
              break;
 
          default:
              throw std::runtime_error (std::string("Unknown command line option: -") + char (optopt));
              break;
      }
  }
 
  
  if(MainConfigFile.empty()) {
        Help(argv[0]);
        exit(1);
  }
 
  SetParameter("General.MainConfigFile",QVdt(MainConfigFile));
  SetParameter("General.LogFile",QVdt(LogFileName));
  SetParameter("General.PrintVerbosity",QVdt(GeneralVerbosity));
  SetParameter("General.LogVerbosity",QVdt(1));
  SetParameter("General.EventsToBeSkipped",QVdt(EventsToBeSkipped));
  SetParameter("General.EventsToBeProcessed",QVdt(EventsToBeProcessed));
  SetParameter("General.Driver",QVdt(Driver));
  QMessageHandler::Get()->Init((MsgLevel)GetInt("General.PrintVerbosity"),
          (MsgLevel)GetInt("General.LogVerbosity"),
          GetString("General.LogFile")
          );
}
 
// replace parameters defined with command line
void QOptions::ReplaceUserParams() 
{
    std::map<std::string,QVdt>::const_iterator itb;
    for(itb=fUserParams.begin(); itb!=fUserParams.end(); itb++) {
        const std::string& n = itb->first;
        SetParameter(n,itb->second);
    }
 
    std::map<std::string,ParamInfo>::const_iterator itp = fParams.begin();
    while(itp != fParams.end()) {
        std::string key = itp->first;
        // override input file list
        if ((key.substr(key.find_last_of(".0"),std::string::npos) == ".InputFilesList") &&
                (key.substr(0,key.find_first_of(".")) == fFirstSequenceName)) {
            try {
                QVdt s = GetParameter("General.InputFilesList");
                if (s.GetString() != "") {
                    SetParameter(itp->first,s);
                }
            }
            catch(QError &err) {
                QMessageHandler::Panic(GetName(),"Command line option error for parameter InputFilesList: " + err.GetDescription());
            }
            catch(...) {
            }
        }
        // override output file prefix
        if ((key.substr(key.find_last_of(".0"),std::string::npos) == ".OutputFilePrefix") &&
                (key.substr(0,key.find_first_of(".")) == fLastSequenceName)) {
            try {
                QVdt s = GetParameter("General.OutputFilePrefix");
                if (s.GetString() != "") {
                    SetParameter(itp->first,s);
                }
            }
            catch(QError &err) {
                QMessageHandler::Panic(GetName(),"Command line option error for parameter OutputFilePrefix: " + err.GetDescription());
            }
            catch(...) {
            }
        }
        // override input file name
        if ((key.substr(key.find_last_of(".0"),std::string::npos) == ".InputFile") &&
                (key.substr(0,key.find_first_of(".")) == fFirstSequenceName)) {
 
            try {
                QVdt s = GetParameter("General.InputFile");
                if (s.GetString() != "") {
                    SetParameter(itp->first,s);
                }
            }
            catch(QError &err) {
                QMessageHandler::Panic(GetName(),"Command line option error for parameter InputFile: " + err.GetDescription());
            }
            catch(...) {
            }
        }
        // override read fileslist
        if ((key.substr(key.find_last_of(".0"),std::string::npos) == ".ReadFilesList") &&
                (key.substr(0,key.find_first_of(".")) == fFirstSequenceName)) {
            try {
                QVdt b = GetParameter("General.ReadFilesList");
                SetParameter(itp->first,b);
            }
            catch(QError &err) {
                QMessageHandler::Panic(GetName(),"Command line option error for parameter ReadFilesList: " + err.GetDescription());
            }
            catch(...) {
            }
        }
 
        // override SkipRequiredNotValid
        if ((key.substr(key.find_last_of("."),std::string::npos) == ".SkipRequiredNotValid") ) {
 
            try {
                QVdt s = GetParameter("General.SkipRequiredNotValid");
                if (s.GetBool() == true) {
                    SetParameter(itp->first,s);
                }
            }
            catch(QError &err) {
                QMessageHandler::Panic(GetName(),"Command line option error for parameter SkipRequiredNotValid: " + err.GetDescription());
            }
            catch(...) {
            }
        }
 
        itp++;
 
 
    }
 
}
 
const QVdt& QOptions::GetParameter(const std::string& n)
{
    if ( fParams.find(n) ==fParams.end() ){
        throw std::runtime_error("Parameter: \""+n+"\" does not exist");
    }
    if(fParams[n].get != 2)
        fParams[n].get=1;
    return fParams[n].param;
}
 
const QVdt& QOptions::GetParameter(const std::string& seq, const std::string& mod, size_t occ, const std::string& par) 
{
    char o[128];
    snprintf(o,128,"%u",(unsigned int)occ);
    std::string n = seq+"."+mod+"."+o+"."+par;
    return GetParameter(n);
}
 
void QOptions::SetParameter(const std::string& seq, const std::string& mod, size_t occ, const std::string& par, const QVdt& p, const bool isDefault) 
{
    char o[128];
    snprintf(o,128,"%u",(unsigned int)occ);
    std::string n = seq+"."+mod+"."+o+"."+par;
    SetParameter(n,p, isDefault);
}
 
// double
double QOptions::GetDouble(const std::string& seq, const std::string& mod,size_t occ, const std::string& par) 
{
    return GetParameter(seq,mod,occ,par).GetDouble();
}
 
double QOptions::GetDouble(const std::string& n) 
{
    return GetParameter(n).GetDouble();
}
std::vector<double> QOptions::GetVectorDouble(const std::string& seq, const std::string& mod,size_t occ, const std::string& par) 
{
    return GetParameter(seq,mod,occ,par).GetVectorDouble();
}
std::vector<double> QOptions::GetVectorDouble(const std::string& n) 
{
    return GetParameter(n).GetVectorDouble();
}
 
// int
int QOptions::GetInt(const std::string& seq, const std::string& mod,size_t occ, const std::string& par) 
{
    return GetParameter(seq,mod,occ,par).GetInt();
}
int QOptions::GetInt(const std::string& n) 
{
    return GetParameter(n).GetInt();
}
std::vector<int> QOptions::GetVectorInt(const std::string& seq, const std::string& mod,size_t occ, const std::string& par) 
{
    return GetParameter(seq,mod,occ,par).GetVectorInt();
}
std::vector<int> QOptions::GetVectorInt(const std::string& n) 
{
    return GetParameter(n).GetVectorInt();
}
 
// bool
bool QOptions::GetBool(const std::string& seq, const std::string& mod,size_t occ, const std::string& par) 
{
    return GetParameter(seq,mod,occ,par).GetBool();
}
bool QOptions::GetBool(const std::string& n) 
{
    return GetParameter(n).GetBool();
}
std::vector<bool> QOptions::GetVectorBool(const std::string& seq, const std::string& mod,size_t occ, const std::string& par) 
{
    return GetParameter(seq,mod,occ,par).GetVectorBool();
}
std::vector<bool> QOptions::GetVectorBool(const std::string& n) 
{
    return GetParameter(n).GetVectorBool();
}
 
// string
std::vector<std::string> QOptions::GetVectorString(const std::string& seq, const std::string& mod,size_t occ, const std::string& par) 
{
    return GetParameter(seq,mod,occ,par).GetVectorString();
}
std::vector<std::string> QOptions::GetVectorString(const std::string& n) 
{
    return GetParameter(n).GetVectorString();
}
 
 
 
 
const std::string& QOptions::GetString(const std::string& seq, const std::string& mod,size_t occ, const std::string& par) 
{
    return GetParameter(seq,mod,occ,par).GetString();
}
 
const std::string& QOptions::GetString(const std::string& n) 
{
    return GetParameter(n).GetString();
}
 
// replace a parameter
void QOptions::SetParameter(const std::string& n, const QVdt& val, const bool isDefault) 
{
    if(fParams.find(n) != fParams.end()) {
        fParams[n].param.SetName(n);
    }
    fParams[n].param = val;
    if(isDefault) {
        fParams[n].get = 2;
    }else 
        fParams[n].get = 0;
}
 
 
std::map<std::string, QVdt*> QOptions::GetModuleParameters(const std::string& seq, const std::string& mod, size_t occ)
{
    std::map<std::string,QVdt*> theMap;
    theMap.clear();
    std::map<std::string, ParamInfo>::iterator p = fParams.begin();
 
    while(p != fParams.end()) {
        char o[128];
        snprintf(o,128,"%u",(unsigned int)occ);
        std::string os=o;
        std::string::size_type loc = p->first.find(seq + "." + mod+"." + os, 0 );
        if( loc != std::string::npos ) {
            size_t len = seq.size() + 1 + mod.size() + 1 + os.size();
            std::string paramName = p->first.substr(len+1,std::string::npos);
            theMap[paramName] = &(p->second.param);
 
        }
        p++;
    }
    return theMap;
}
 
Q_END_NAMESPACE