CLogSocketSink::CLogSocketSink(const LogSettings& oSettings)
{
m_URL = oSettings.getLogURL();
CThreadQueue::setLogCategory(LogCategory("NO_LOGGING"));
setPollInterval(QUEUE_POLL_INTERVAL_INFINITE);
start(epLow);
}
static void initLogsCache(LogCacheExt& logsCache, const QStringList& ) {
#ifdef _DEBUG
logsCache.setConsoleOutputEnabled(true);
#else
QString consoleOutVal = qgetenv("UGENE_PRINT_TO_CONSOLE");
logsCache.setConsoleOutputEnabled(consoleOutVal == "true" || consoleOutVal == "1");
#endif
QString file = qgetenv(U2_PRINT_TO_FILE);
if (!file.isEmpty()) {
logsCache.setFileOutputEnabled(file);
return;
}
LogSettings ls;
ls.reinitAll();
if(ls.toFile){
logsCache.setFileOutputEnabled(ls.outputFile);
}
}
static LogSettings initializeLogger(const po::variables_map& vm)
{
map<string, LogCategory> logCatMap = MAP_LIST_OF
"init", LC_INIT MAP_LIST_SEP "nls", LC_NLS MAP_LIST_SEP
"ls", LC_LS MAP_LIST_SEP "solver", LC_SOLVER MAP_LIST_SEP
"output", LC_OUTPUT MAP_LIST_SEP "events", LC_EVENTS MAP_LIST_SEP
"model", LC_MODEL MAP_LIST_SEP "other", LC_OTHER MAP_LIST_END;
map<string, LogLevel> logLvlMap = MAP_LIST_OF
"error", LL_ERROR MAP_LIST_SEP "warning", LL_WARNING MAP_LIST_SEP
"info", LL_INFO MAP_LIST_SEP "debug", LL_DEBUG MAP_LIST_END;
map<string, LogFormat> logFormatMap = MAP_LIST_OF
"txt", LF_TXT MAP_LIST_SEP "xml", LF_XML MAP_LIST_SEP
"xmltcp", LF_XMLTCP MAP_LIST_END;
map<string, LogOMEdit> logOMEditMap = MAP_LIST_OF
"LOG_EVENTS", LOG_EVENTS MAP_LIST_SEP "LOG_INIT", LOG_INIT MAP_LIST_SEP
"LOG_LS", LOG_LS MAP_LIST_SEP "LOG_NLS", LOG_NLS MAP_LIST_SEP
"LOG_SOLVER", LOG_SOLVER MAP_LIST_SEP "LOG_STATS", LOG_STATS MAP_LIST_END;
LogSettings logSettings;
std::string logOMEditWarning;
if (vm.count("log-settings"))
{
vector<string> log_vec = vm["log-settings"].as<vector<string> >();
vector<string> tmpvec;
for (int i = 0; i < log_vec.size(); i++) {
// translate XML stream options to native options
if (log_vec[i].compare(0, 4, "LOG_") == 0) {
LogOMEdit logOMEdit;
boost::split(tmpvec, log_vec[i], boost::is_any_of(","));
for (int j = 0; j < tmpvec.size(); j++) {
if (logOMEditMap.find(tmpvec[j]) != logOMEditMap.end())
logOMEdit = logOMEditMap[tmpvec[j]];
else {
if (logOMEditWarning.size() > 0)
logOMEditWarning += ",";
logOMEditWarning += tmpvec[j];
continue;
}
switch (logOMEdit) {
case LOG_EVENTS:
logSettings.modes[LC_EVENTS] = LL_DEBUG;
break;
case LOG_INIT:
logSettings.modes[LC_INIT] = LL_DEBUG;
break;
case LOG_LS:
logSettings.modes[LC_LS] = LL_DEBUG;
break;
case LOG_NLS:
logSettings.modes[LC_NLS] = LL_DEBUG;
break;
case LOG_SOLVER:
logSettings.modes[LC_SOLVER] = LL_DEBUG;
//case LOG_STATS:
default:
if (logSettings.modes[LC_SOLVER] < LL_INFO)
logSettings.modes[LC_SOLVER] = LL_INFO;
}
}
}
// treat native option
else {
boost::split(tmpvec, log_vec[i], boost::is_any_of("="));
if (tmpvec.size() > 1 && logLvlMap.find(tmpvec[1]) != logLvlMap.end()
&& (tmpvec[0] == "all" || logCatMap.find(tmpvec[0]) != logCatMap.end()))
{
if (tmpvec[0] == "all") {
logSettings.setAll(logLvlMap[tmpvec[1]]);
break;
}
else
logSettings.modes[logCatMap[tmpvec[0]]] = logLvlMap[tmpvec[1]];
}
else
throw ModelicaSimulationError(MODEL_FACTORY,
"log-settings flags not supported: " + log_vec[i] + "\n");
}
}
}
if (vm.count("warn-all") && vm["warn-all"].as<bool>()) {
for (int i = 0; i < logSettings.modes.size(); i++)
if (logSettings.modes[i] < LL_WARNING)
logSettings.modes[i] = LL_WARNING;
}
if (vm.count("log-format")) {
string logFormat_str = vm["log-format"].as<string>();
if (logFormatMap.find(logFormat_str) != logFormatMap.end())
logSettings.format = logFormatMap[logFormat_str];
else
throw ModelicaSimulationError(MODEL_FACTORY,
"Unknown log-format " + logFormat_str);
}
// make sure other infos get issued and initialize logger
if (logSettings.modes[LC_OTHER] < LL_INFO)
logSettings.modes[LC_OTHER] = LL_INFO;
// initialize logger if it has been enabled
if (Logger::isEnabled()) {
int port = vm["log-port"].as<int>();
if (port > 0) {
try {
LoggerXMLTCP::initialize("127.0.0.1", port, logSettings);
}
catch (std::exception &ex) {
throw ModelicaSimulationError(MODEL_FACTORY,
"Failed to start logger with port " + to_string(port) + ": "
+ ex.what() + '\n');
}
}
else
Logger::initialize(logSettings);
}
if (logOMEditWarning.size() > 0) {
LOGGER_WRITE("Warning: unrecognized logging " + logOMEditWarning,
LC_OTHER, LL_WARNING);
ostringstream os;
os << "Supported are: ";
map<std::string, LogOMEdit>::const_iterator it;
for (it = logOMEditMap.begin(); it != logOMEditMap.end(); ++it) {
if (it != logOMEditMap.begin())
os << ",";
os << it->first;
}
LOGGER_WRITE(os.str(), LC_OTHER, LL_INFO);
}
return logSettings;
}
SimSettings OMCFactory::readSimulationParameter(int argc, const char* argv[])
{
int opt;
int portnum;
map<string, LogCategory> logCatMap = MAP_LIST_OF
"init", LC_INIT MAP_LIST_SEP "nls", LC_NLS MAP_LIST_SEP
"ls", LC_LS MAP_LIST_SEP "solv", LC_SOLV MAP_LIST_SEP
"output", LC_OUT MAP_LIST_SEP "event", LC_EVT MAP_LIST_SEP
"model", LC_MOD MAP_LIST_SEP "other", LC_OTHER MAP_LIST_END;
map<string, LogLevel> logLvlMap = MAP_LIST_OF
"error", LL_ERROR MAP_LIST_SEP "warning", LL_WARNING MAP_LIST_SEP
"info", LL_INFO MAP_LIST_SEP "debug", LL_DEBUG MAP_LIST_END;
map<string, OutputPointType> outputPointTypeMap = MAP_LIST_OF
"all", OPT_ALL MAP_LIST_SEP "step", OPT_STEP MAP_LIST_SEP
"none", OPT_NONE MAP_LIST_END;
map<string, OutputFormat> outputFormatTypeMap = MAP_LIST_OF
"csv", CSV MAP_LIST_SEP "mat", MAT MAP_LIST_SEP
"buffer", BUFFER MAP_LIST_SEP "empty", EMPTY MAP_LIST_END;
po::options_description desc("Allowed options");
//program options that can be overwritten by OMEdit must be declared as vector
//so that the same value can be set multiple times
//(e.g. 'executable -F arg1 -r=arg2' -> 'executable -F arg1 -F=arg2')
//the variables of OMEdit are always the first elements of the result vectors, if they are set
desc.add_options()
("help", "produce help message")
("nls-continue", po::bool_switch()->default_value(false),"non linear solver will continue if it can not reach the given precision")
("runtime-library,R", po::value<string>(),"path to cpp runtime libraries")
("modelica-system-library,M", po::value<string>(), "path to Modelica library")
("results-file,F", po::value<vector<string> >(),"name of results file")
("start-time,S", po::value< double >()->default_value(0.0), "simulation start time")
("stop-time,E", po::value< double >()->default_value(1.0), "simulation stop time")
("step-size,H", po::value< double >()->default_value(0.0), "simulation step size")
("solver,I", po::value< string >()->default_value("euler"), "solver method")
("lin-solver,L", po::value< string >()->default_value(_defaultLinSolver), "linear solver method")
("non-lin-solver,N", po::value< string >()->default_value(_defaultNonLinSolver), "non linear solver method")
("number-of-intervals,G", po::value< int >()->default_value(500), "number of intervals in equidistant grid")
("tolerance,T", po::value< double >()->default_value(1e-6), "solver tolerance")
("log-settings,V", po::value< vector<string> >(), "log information: init, nls, ls, solv, output, event, model, other")
("alarm,A", po::value<unsigned int >()->default_value(360), "sets timeout in seconds for simulation")
("output-type,O", po::value< string >()->default_value("all"), "the points in time written to result file: all (output steps + events), step (just output points), none")
("output-format,P", po::value< string >()->default_value("mat"), "The simulation results output format")
;
// a group for all options that should not be visible if '--help' is set
po::options_description descHidden("Hidden options");
descHidden.add_options()
("ignored", po::value<vector<string> >(), "ignored options")
("unrecognized", po::value<vector<string> >(), "unsupported options")
("solverThreads", po::value<int>()->default_value(1), "number of threads that can be used by the solver")
;
po::options_description descAll("All options");
descAll.add(desc);
descAll.add(descHidden);
po::variables_map vm;
boost::function<pair<string, string> (const string&)> parserFunction(boost::bind(&OMCFactory::parseIngoredAndWrongFormatOption, this, _1));
po::parsed_options parsed = po::command_line_parser(argc, argv)
.options(descAll)
.style((po::command_line_style::default_style | po::command_line_style::allow_long_disguise) & ~po::command_line_style::allow_guessing)
.extra_parser(parserFunction)
.allow_unregistered()
.run();
po::store(parsed, vm);
po::notify(vm);
if (vm.count("help")) {
cout << desc << "\n";
throw ModelicaSimulationError(MODEL_FACTORY, "Cannot parse command line arguments correctly, because the help message was requested.", "",true);
}
// warn about unrecognized command line options, including OMEdit for now
vector<string> unrecognized = po::collect_unrecognized(parsed.options, po::include_positional);
if (vm.count("unrecognized")) {
vector<string> opts = vm["unrecognized"].as<vector<string> >();
unrecognized.insert(unrecognized.begin(), opts.begin(), opts.end());
}
if (unrecognized.size() > 0) {
cerr << "Warning: unrecognized command line options ";
copy(unrecognized.begin(), unrecognized.end(), ostream_iterator<string>(cerr, " "));
cerr << endl;
}
string runtime_lib_path;
string modelica_lib_path;
double starttime = vm["start-time"].as<double>();
double stoptime = vm["stop-time"].as<double>();
double stepsize =vm["step-size"].as<double>();
bool nlsContinueOnError = vm["nls-continue"].as<bool>();
int solverThreads = vm["solverThreads"].as<int>();
if (!(stepsize > 0.0))
stepsize = (stoptime - starttime) / vm["number-of-intervals"].as<int>();
double tolerance =vm["tolerance"].as<double>();
string solver = vm["solver"].as<string>();
string nonLinSolver = vm["non-lin-solver"].as<string>();
string linSolver = vm["lin-solver"].as<string>();
unsigned int timeOut = vm["alarm"].as<unsigned int>();
if (vm.count("runtime-library"))
{
//cout << "runtime library path set to " << vm["runtime-library"].as<string>() << endl;
runtime_lib_path = vm["runtime-library"].as<string>();
}
else
throw ModelicaSimulationError(MODEL_FACTORY,"runtime libraries path is not set");
if (vm.count("modelica-system-library"))
{
//cout << "Modelica library path set to " << vm["Modelica-system-library"].as<string>() << endl;
modelica_lib_path =vm["modelica-system-library"].as<string>();
}
else
throw ModelicaSimulationError(MODEL_FACTORY,"Modelica library path is not set");
string resultsfilename;
if (vm.count("results-file"))
{
//cout << "results file: " << vm["results-file"].as<string>() << endl;
resultsfilename = vm["results-file"].as<vector<string> >().front();
}
else
throw ModelicaSimulationError(MODEL_FACTORY,"results-filename is not set");
string outputPointType_str;
OutputPointType outputPointType;
if (vm.count("output-type"))
{
//cout << "results file: " << vm["results-file"].as<string>() << endl;
outputPointType_str = vm["output-type"].as<string>();
outputPointType = outputPointTypeMap[outputPointType_str];
}
else
throw ModelicaSimulationError(MODEL_FACTORY, "output-type is not set");
LogSettings logSet;
if (vm.count("log-settings"))
{
vector<string> log_vec = vm["log-settings"].as<vector<string> >(),tmpvec;
for(unsigned i=0;i<log_vec.size();++i)
{
//cout << i << ". " << log_vec[i] << endl;
tmpvec.clear();
boost::split(tmpvec,log_vec[i],boost::is_any_of("="));
if(tmpvec.size()>1 && logLvlMap.find(tmpvec[1]) != logLvlMap.end() && ( tmpvec[0] == "all" || logCatMap.find(tmpvec[0]) != logCatMap.end()))
{
if(tmpvec[0] == "all")
{
logSet.setAll(logLvlMap[tmpvec[1]]);
break;
}
else
logSet.modes[logCatMap[tmpvec[0]]] = logLvlMap[tmpvec[1]];
}
else
throw ModelicaSimulationError(MODEL_FACTORY,"log-settings flags not supported: " + log_vec[i] + "\n");
}
}
OutputFormat outputFormat;
if (vm.count("output-format"))
{
string outputFormatType_str = vm["output-format"].as<string>();
outputFormat = outputFormatTypeMap[outputFormatType_str];
}
else
throw ModelicaSimulationError(MODEL_FACTORY, "output-format is not set");
fs::path libraries_path = fs::path( runtime_lib_path) ;
fs::path modelica_path = fs::path( modelica_lib_path) ;
libraries_path.make_preferred();
modelica_path.make_preferred();
SimSettings settings = {solver,linSolver,nonLinSolver,starttime,stoptime,stepsize,1e-24,0.01,tolerance,resultsfilename,timeOut,outputPointType,logSet,nlsContinueOnError,solverThreads,outputFormat};
_library_path = libraries_path.string();
_modelicasystem_path = modelica_path.string();
return settings;
}